From 87dbe82474cf12467f3b0557143b4a27714c6ea6 Mon Sep 17 00:00:00 2001 From: Jamie Mansfield Date: Tue, 13 Apr 2021 18:30:37 +0100 Subject: [PATCH 01/57] NOISSUE Support custom,latest,recommended loader versions for ATL This provides support for modpacks using the new loader mechanism in ATLauncher and using a non-specific version target. --- .../atlauncher/ATLPackInstallTask.cpp | 47 +++++++++++++++---- .../atlauncher/ATLPackInstallTask.h | 18 +++++-- .../atlauncher/ATLPackManifest.cpp | 26 ++++++---- .../pages/modplatform/atlauncher/AtlPage.cpp | 39 ++++++++++++++- .../pages/modplatform/atlauncher/AtlPage.h | 5 +- 5 files changed, 109 insertions(+), 26 deletions(-) diff --git a/api/logic/modplatform/atlauncher/ATLPackInstallTask.cpp b/api/logic/modplatform/atlauncher/ATLPackInstallTask.cpp index 12ceaccd..32420415 100644 --- a/api/logic/modplatform/atlauncher/ATLPackInstallTask.cpp +++ b/api/logic/modplatform/atlauncher/ATLPackInstallTask.cpp @@ -18,8 +18,9 @@ namespace ATLauncher { -PackInstallTask::PackInstallTask(QString pack, QString version) +PackInstallTask::PackInstallTask(UserInteractionSupport *support, QString pack, QString version) { + m_support = support; m_pack = pack; m_version_name = version; } @@ -154,20 +155,47 @@ QString PackInstallTask::getVersionForLoader(QString uid) auto vlist = ENV.metadataIndex()->get(uid); if(!vlist) { - emitFailed(tr("Failed to get local metadata index for ") + uid); + emitFailed(tr("Failed to get local metadata index for %1").arg(uid)); return Q_NULLPTR; } - // todo: filter by Minecraft version - - if(m_version.loader.recommended) { - return vlist.get()->getRecommended().get()->descriptor(); + if(!vlist->isLoaded()) { + vlist->load(Net::Mode::Online); } - else if(m_version.loader.latest) { - return vlist.get()->at(0)->descriptor(); + + if(m_version.loader.recommended || m_version.loader.latest) { + for (int i = 0; i < vlist->versions().size(); i++) { + auto version = vlist->versions().at(i); + auto reqs = version->requires(); + + // filter by minecraft version, if the loader depends on a certain version. + // not all mod loaders depend on a given Minecraft version, so we won't do this + // filtering for those loaders. + if (m_version.loader.type != "fabric") { + auto iter = std::find_if(reqs.begin(), reqs.end(), [](const Meta::Require &req) { + return req.uid == "net.minecraft"; + }); + if (iter == reqs.end()) continue; + if (iter->equalsVersion != m_version.minecraft) continue; + } + + if (m_version.loader.recommended) { + // first recommended build we find, we use. + if (!version->isRecommended()) continue; + } + + return version->descriptor(); + } + + emitFailed(tr("Failed to find version for %1 loader").arg(m_version.loader.type)); } else if(m_version.loader.choose) { - // todo: implement + // Fabric Loader doesn't depend on a given Minecraft version. + if (m_version.loader.type == "fabric") { + return m_support->chooseVersion(vlist, Q_NULLPTR); + } + + return m_support->chooseVersion(vlist, m_version.minecraft); } } @@ -451,7 +479,6 @@ void PackInstallTask::downloadMods() auto cacheName = fileName.completeBaseName() + "-" + mod.md5 + "." + fileName.suffix(); if (mod.type == ModType::Extract || mod.type == ModType::TexturePackExtract || mod.type == ModType::ResourcePackExtract) { - auto entry = ENV.metacache()->resolveEntry("ATLauncherPacks", cacheName); entry->setStale(true); modsToExtract.insert(entry->getFullPath(), mod); diff --git a/api/logic/modplatform/atlauncher/ATLPackInstallTask.h b/api/logic/modplatform/atlauncher/ATLPackInstallTask.h index 78544bab..3647e471 100644 --- a/api/logic/modplatform/atlauncher/ATLPackInstallTask.h +++ b/api/logic/modplatform/atlauncher/ATLPackInstallTask.h @@ -15,12 +15,23 @@ namespace ATLauncher { +class MULTIMC_LOGIC_EXPORT UserInteractionSupport { + +public: + /** + * Requests a user interaction to select a component version from a given version list + * and constrained to a given Minecraft version. + */ + virtual QString chooseVersion(Meta::VersionListPtr vlist, QString minecraftVersion) = 0; + +}; + class MULTIMC_LOGIC_EXPORT PackInstallTask : public InstanceTask { Q_OBJECT public: - explicit PackInstallTask(QString pack, QString version); + explicit PackInstallTask(UserInteractionSupport *support, QString pack, QString version); virtual ~PackInstallTask(){} bool abort() override; @@ -54,6 +65,8 @@ private: void install(); private: + UserInteractionSupport *m_support; + NetJobPtr jobPtr; QByteArray response; @@ -76,9 +89,6 @@ private: QFuture m_modExtractFuture; QFutureWatcher m_modExtractFutureWatcher; - QFuture m_decompFuture; - QFutureWatcher m_decompFutureWatcher; - }; } diff --git a/api/logic/modplatform/atlauncher/ATLPackManifest.cpp b/api/logic/modplatform/atlauncher/ATLPackManifest.cpp index 84389330..50682391 100644 --- a/api/logic/modplatform/atlauncher/ATLPackManifest.cpp +++ b/api/logic/modplatform/atlauncher/ATLPackManifest.cpp @@ -81,12 +81,15 @@ static ATLauncher::ModType parseModType(QString rawType) { static void loadVersionLoader(ATLauncher::VersionLoader & p, QJsonObject & obj) { p.type = Json::requireString(obj, "type"); - p.latest = Json::ensureBoolean(obj, QString("latest"), false); p.choose = Json::ensureBoolean(obj, QString("choose"), false); - p.recommended = Json::ensureBoolean(obj, QString("recommended"), false); auto metadata = Json::requireObject(obj, "metadata"); - p.version = Json::requireString(metadata, "version"); + + if (metadata.contains("version")) { + p.version = Json::requireString(metadata, "version"); + } + p.latest = Json::ensureBoolean(metadata, QString("latest"), false); + p.recommended = Json::ensureBoolean(metadata, QString("recommended"), false); } static void loadVersionLibrary(ATLauncher::VersionLibrary & p, QJsonObject & obj) { @@ -169,12 +172,15 @@ void ATLauncher::loadVersion(PackVersion & v, QJsonObject & obj) } } - auto mods = Json::requireArray(obj, "mods"); - for (const auto modRaw : mods) - { - auto modObj = Json::requireObject(modRaw); - ATLauncher::VersionMod mod; - loadVersionMod(mod, modObj); - v.mods.append(mod); + + if(obj.contains("mods")) { + auto mods = Json::requireArray(obj, "mods"); + for (const auto modRaw : mods) + { + auto modObj = Json::requireObject(modRaw); + ATLauncher::VersionMod mod; + loadVersionMod(mod, modObj); + v.mods.append(mod); + } } } diff --git a/application/pages/modplatform/atlauncher/AtlPage.cpp b/application/pages/modplatform/atlauncher/AtlPage.cpp index f90d734c..748f467c 100644 --- a/application/pages/modplatform/atlauncher/AtlPage.cpp +++ b/application/pages/modplatform/atlauncher/AtlPage.cpp @@ -4,6 +4,7 @@ #include "dialogs/NewInstanceDialog.h" #include #include +#include AtlPage::AtlPage(NewInstanceDialog* dialog, QWidget *parent) : QWidget(parent), ui(new Ui::AtlPage), dialog(dialog) @@ -50,7 +51,7 @@ void AtlPage::openedImpl() void AtlPage::suggestCurrent() { if(isOpened) { - dialog->setSuggestedPack(selected.name, new ATLauncher::PackInstallTask(selected.safeName, selectedVersion)); + dialog->setSuggestedPack(selected.name, new ATLauncher::PackInstallTask(this, selected.safeName, selectedVersion)); } auto editedLogoName = selected.safeName; @@ -112,3 +113,39 @@ void AtlPage::onVersionSelectionChanged(QString data) selectedVersion = data; suggestCurrent(); } + +QString AtlPage::chooseVersion(Meta::VersionListPtr vlist, QString minecraftVersion) { + VersionSelectDialog vselect(vlist.get(), "Choose Version", MMC->activeWindow(), false); + if (minecraftVersion != Q_NULLPTR) { + vselect.setExactFilter(BaseVersionList::ParentVersionRole, minecraftVersion); + vselect.setEmptyString(tr("No versions are currently available for Minecraft %1").arg(minecraftVersion)); + } + else { + vselect.setEmptyString(tr("No versions are currently available")); + } + vselect.setEmptyErrorString(tr("Couldn't load or download the version lists!")); + + // select recommended build + for (int i = 0; i < vlist->versions().size(); i++) { + auto version = vlist->versions().at(i); + auto reqs = version->requires(); + + // filter by minecraft version, if the loader depends on a certain version. + if (minecraftVersion != Q_NULLPTR) { + auto iter = std::find_if(reqs.begin(), reqs.end(), [](const Meta::Require &req) { + return req.uid == "net.minecraft"; + }); + if (iter == reqs.end()) continue; + if (iter->equalsVersion != minecraftVersion) continue; + } + + // first recommended build we find, we use. + if (version->isRecommended()) { + vselect.setCurrentVersion(version->descriptor()); + break; + } + } + + vselect.exec(); + return vselect.selectedVersion()->descriptor(); +} diff --git a/application/pages/modplatform/atlauncher/AtlPage.h b/application/pages/modplatform/atlauncher/AtlPage.h index 715cf5f4..6a89b609 100644 --- a/application/pages/modplatform/atlauncher/AtlPage.h +++ b/application/pages/modplatform/atlauncher/AtlPage.h @@ -19,6 +19,7 @@ #include "AtlListModel.h" #include +#include #include "MultiMC.h" #include "pages/BasePage.h" @@ -31,7 +32,7 @@ namespace Ui class NewInstanceDialog; -class AtlPage : public QWidget, public BasePage +class AtlPage : public QWidget, public BasePage, public ATLauncher::UserInteractionSupport { Q_OBJECT @@ -61,6 +62,8 @@ public: private: void suggestCurrent(); + QString chooseVersion(Meta::VersionListPtr vlist, QString minecraftVersion) override; + private slots: void triggerSearch(); void resetSearch(); From 73788f5d2fd46c0e1b24216962f93c777e1253ae Mon Sep 17 00:00:00 2001 From: Jamie Mansfield Date: Wed, 14 Apr 2021 13:43:37 +0100 Subject: [PATCH 02/57] NOISSUE Emit failure on failure conditions The 'Installing modpack' dialog will no longer stay open forever, even though the installation has failed. --- .../modplatform/atlauncher/ATLPackInstallTask.cpp | 10 +++++++++- 1 file changed, 9 insertions(+), 1 deletion(-) diff --git a/api/logic/modplatform/atlauncher/ATLPackInstallTask.cpp b/api/logic/modplatform/atlauncher/ATLPackInstallTask.cpp index 32420415..192dd0b1 100644 --- a/api/logic/modplatform/atlauncher/ATLPackInstallTask.cpp +++ b/api/logic/modplatform/atlauncher/ATLPackInstallTask.cpp @@ -188,6 +188,7 @@ QString PackInstallTask::getVersionForLoader(QString uid) } emitFailed(tr("Failed to find version for %1 loader").arg(m_version.loader.type)); + return Q_NULLPTR; } else if(m_version.loader.choose) { // Fabric Loader doesn't depend on a given Minecraft version. @@ -199,6 +200,11 @@ QString PackInstallTask::getVersionForLoader(QString uid) } } + if (m_version.loader.version == Q_NULLPTR || m_version.loader.version.isEmpty()) { + emitFailed(tr("No loader version set for modpack!")); + return Q_NULLPTR; + } + return m_version.loader.version; } @@ -549,7 +555,7 @@ void PackInstallTask::onModsDownloaded() { qDebug() << "PackInstallTask::onModsDownloaded: " << QThread::currentThreadId(); jobPtr.reset(); - if(modsToExtract.size() || modsToDecomp.size() || modsToCopy.size()) { + if(!modsToExtract.empty() || !modsToDecomp.empty() || !modsToCopy.empty()) { m_modExtractFuture = QtConcurrent::run(QThreadPool::globalInstance(), this, &PackInstallTask::extractMods, modsToExtract, modsToDecomp, modsToCopy); connect(&m_modExtractFutureWatcher, &QFutureWatcher::finished, this, &PackInstallTask::onModsExtracted); connect(&m_modExtractFutureWatcher, &QFutureWatcher::canceled, this, [&]() @@ -656,6 +662,7 @@ void PackInstallTask::install() // Use a component to add libraries BEFORE Minecraft if(!createLibrariesComponent(instance.instanceRoot(), components)) { + emitFailed(tr("Failed to create libraries component")); return; } @@ -693,6 +700,7 @@ void PackInstallTask::install() // Use a component to fill in the rest of the data // todo: use more detection if(!createPackComponent(instance.instanceRoot(), components)) { + emitFailed(tr("Failed to create pack component")); return; } From 438ddfb88dc4fede0c197107a1464990d7ec5a8d Mon Sep 17 00:00:00 2001 From: Jamie Mansfield Date: Wed, 14 Apr 2021 18:20:50 +0100 Subject: [PATCH 03/57] NOISSUE Support Fabric modpacks on ATLauncher Annoyingly the metadata structure is loader dependent :( --- .../modplatform/atlauncher/ATLPackManifest.cpp | 14 ++++++++++---- 1 file changed, 10 insertions(+), 4 deletions(-) diff --git a/api/logic/modplatform/atlauncher/ATLPackManifest.cpp b/api/logic/modplatform/atlauncher/ATLPackManifest.cpp index 50682391..df42c5bb 100644 --- a/api/logic/modplatform/atlauncher/ATLPackManifest.cpp +++ b/api/logic/modplatform/atlauncher/ATLPackManifest.cpp @@ -84,12 +84,18 @@ static void loadVersionLoader(ATLauncher::VersionLoader & p, QJsonObject & obj) p.choose = Json::ensureBoolean(obj, QString("choose"), false); auto metadata = Json::requireObject(obj, "metadata"); - - if (metadata.contains("version")) { - p.version = Json::requireString(metadata, "version"); - } p.latest = Json::ensureBoolean(metadata, QString("latest"), false); p.recommended = Json::ensureBoolean(metadata, QString("recommended"), false); + + // Minecraft Forge + if (p.type == "forge") { + p.version = Json::ensureString(metadata, "version", ""); + } + + // Fabric Loader + if (p.type == "fabric") { + p.version = Json::ensureString(metadata, "loader", ""); + } } static void loadVersionLibrary(ATLauncher::VersionLibrary & p, QJsonObject & obj) { From 42253150e43fa4289130d4b53729e618908a251e Mon Sep 17 00:00:00 2001 From: kumquat-ir <66188216+kumquat-ir@users.noreply.github.com> Date: Thu, 15 Apr 2021 23:19:01 -0700 Subject: [PATCH 04/57] add toml11 as dependency --- CMakeLists.txt | 1 + COPYING.md | 24 + libraries/README.md | 7 + libraries/toml11/CMakeLists.txt | 5 + libraries/toml11/LICENSE | 21 + libraries/toml11/README.md | 1918 +++++++++++++++ libraries/toml11/include/toml.hpp | 46 + libraries/toml11/include/toml/color.hpp | 64 + libraries/toml11/include/toml/combinator.hpp | 306 +++ libraries/toml11/include/toml/comments.hpp | 466 ++++ libraries/toml11/include/toml/datetime.hpp | 631 +++++ libraries/toml11/include/toml/exception.hpp | 65 + libraries/toml11/include/toml/from.hpp | 20 + libraries/toml11/include/toml/get.hpp | 1068 ++++++++ libraries/toml11/include/toml/into.hpp | 20 + libraries/toml11/include/toml/lexer.hpp | 270 ++ libraries/toml11/include/toml/literal.hpp | 112 + libraries/toml11/include/toml/macros.hpp | 121 + libraries/toml11/include/toml/parser.hpp | 2177 +++++++++++++++++ libraries/toml11/include/toml/region.hpp | 417 ++++ libraries/toml11/include/toml/result.hpp | 717 ++++++ libraries/toml11/include/toml/serializer.hpp | 853 +++++++ .../toml11/include/toml/source_location.hpp | 233 ++ libraries/toml11/include/toml/storage.hpp | 43 + libraries/toml11/include/toml/string.hpp | 224 ++ libraries/toml11/include/toml/traits.hpp | 300 +++ libraries/toml11/include/toml/types.hpp | 150 ++ libraries/toml11/include/toml/utility.hpp | 93 + libraries/toml11/include/toml/value.hpp | 2023 +++++++++++++++ 29 files changed, 12395 insertions(+) create mode 100644 libraries/toml11/CMakeLists.txt create mode 100644 libraries/toml11/LICENSE create mode 100644 libraries/toml11/README.md create mode 100644 libraries/toml11/include/toml.hpp create mode 100644 libraries/toml11/include/toml/color.hpp create mode 100644 libraries/toml11/include/toml/combinator.hpp create mode 100644 libraries/toml11/include/toml/comments.hpp create mode 100644 libraries/toml11/include/toml/datetime.hpp create mode 100644 libraries/toml11/include/toml/exception.hpp create mode 100644 libraries/toml11/include/toml/from.hpp create mode 100644 libraries/toml11/include/toml/get.hpp create mode 100644 libraries/toml11/include/toml/into.hpp create mode 100644 libraries/toml11/include/toml/lexer.hpp create mode 100644 libraries/toml11/include/toml/literal.hpp create mode 100644 libraries/toml11/include/toml/macros.hpp create mode 100644 libraries/toml11/include/toml/parser.hpp create mode 100644 libraries/toml11/include/toml/region.hpp create mode 100644 libraries/toml11/include/toml/result.hpp create mode 100644 libraries/toml11/include/toml/serializer.hpp create mode 100644 libraries/toml11/include/toml/source_location.hpp create mode 100644 libraries/toml11/include/toml/storage.hpp create mode 100644 libraries/toml11/include/toml/string.hpp create mode 100644 libraries/toml11/include/toml/traits.hpp create mode 100644 libraries/toml11/include/toml/types.hpp create mode 100644 libraries/toml11/include/toml/utility.hpp create mode 100644 libraries/toml11/include/toml/value.hpp diff --git a/CMakeLists.txt b/CMakeLists.txt index 1c93e7a9..cfba3430 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -265,6 +265,7 @@ add_subdirectory(libraries/iconfix) # fork of Qt's QIcon loader add_subdirectory(libraries/LocalPeer) # fork of a library from Qt solutions add_subdirectory(libraries/classparser) # google analytics library add_subdirectory(libraries/optional-bare) +add_subdirectory(libraries/toml11) # toml parser ############################### Built Artifacts ############################### diff --git a/COPYING.md b/COPYING.md index c0c98606..ea8fe479 100644 --- a/COPYING.md +++ b/COPYING.md @@ -251,3 +251,27 @@ FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +# toml11 + + The MIT License (MIT) + + Copyright (c) 2017 Toru Niina + + Permission is hereby granted, free of charge, to any person obtaining a copy + of this software and associated documentation files (the "Software"), to deal + in the Software without restriction, including without limitation the rights + to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + copies of the Software, and to permit persons to whom the Software is + furnished to do so, subject to the following conditions: + + The above copyright notice and this permission notice shall be included in + all copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + THE SOFTWARE. diff --git a/libraries/README.md b/libraries/README.md index cdc72004..76ee8c46 100644 --- a/libraries/README.md +++ b/libraries/README.md @@ -158,3 +158,10 @@ A Google Analytics library for Qt. BSD licensed, derived from [qt-google-analytics](https://github.com/HSAnet/qt-google-analytics). Modifications include better handling of IP anonymization (can be enabled) and general improvements of the API (application handles persistence and ID generation instead of the library). + +## toml11 +A C++11 TOML language parser. Used by Forge 1.14+ to store mod metadata. + +See [github repo](https://github.com/ToruNiina/toml11). + +Licenced under the MIT licence. diff --git a/libraries/toml11/CMakeLists.txt b/libraries/toml11/CMakeLists.txt new file mode 100644 index 00000000..556ec150 --- /dev/null +++ b/libraries/toml11/CMakeLists.txt @@ -0,0 +1,5 @@ +cmake_minimum_required(VERSION 3.1) +project(toml11) + +add_library(toml11 INTERFACE) +target_include_directories(toml11 INTERFACE "${CMAKE_CURRENT_SOURCE_DIR}/include") diff --git a/libraries/toml11/LICENSE b/libraries/toml11/LICENSE new file mode 100644 index 00000000..f55c511d --- /dev/null +++ b/libraries/toml11/LICENSE @@ -0,0 +1,21 @@ +The MIT License (MIT) + +Copyright (c) 2017 Toru Niina + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. diff --git a/libraries/toml11/README.md b/libraries/toml11/README.md new file mode 100644 index 00000000..d5bc1c81 --- /dev/null +++ b/libraries/toml11/README.md @@ -0,0 +1,1918 @@ +toml11 +====== + +[![Build Status on GitHub Actions](https://github.com/ToruNiina/toml11/workflows/build/badge.svg)](https://github.com/ToruNiina/toml11/actions) +[![Build Status on TravisCI](https://travis-ci.org/ToruNiina/toml11.svg?branch=master)](https://travis-ci.org/ToruNiina/toml11) +[![Build status on Appveyor](https://ci.appveyor.com/api/projects/status/m2n08a926asvg5mg/branch/master?svg=true)](https://ci.appveyor.com/project/ToruNiina/toml11/branch/master) +[![Build status on CircleCI](https://circleci.com/gh/ToruNiina/toml11/tree/master.svg?style=svg)](https://circleci.com/gh/ToruNiina/toml11/tree/master) +[![Version](https://img.shields.io/github/release/ToruNiina/toml11.svg?style=flat)](https://github.com/ToruNiina/toml11/releases) +[![License](https://img.shields.io/github/license/ToruNiina/toml11.svg?style=flat)](LICENSE) +[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.1209136.svg)](https://doi.org/10.5281/zenodo.1209136) + +toml11 is a C++11 (or later) header-only toml parser/encoder depending only on C++ standard library. + +- It is compatible to the latest version of [TOML v1.0.0](https://toml.io/en/v1.0.0). +- It is one of the most TOML standard compliant libraries, tested with [the language agnostic test suite for TOML parsers by BurntSushi](https://github.com/BurntSushi/toml-test). +- It shows highly informative error messages. You can see the error messages about invalid files at [CircleCI](https://circleci.com/gh/ToruNiina/toml11). +- It has configurable container. You can use any random-access containers and key-value maps as backend containers. +- It optionally preserves comments without any overhead. +- It has configurable serializer that supports comments, inline tables, literal strings and multiline strings. +- It supports user-defined type conversion from/into toml values. +- It correctly handles UTF-8 sequences, with or without BOM, both on posix and Windows. + +## Example + +```cpp +#include +#include + +int main() +{ + // ```toml + // title = "an example toml file" + // nums = [3, 1, 4, 1, 5] + // ``` + auto data = toml::parse("example.toml"); + + // find a value with the specified type from a table + std::string title = toml::find(data, "title"); + + // convert the whole array into any container automatically + std::vector nums = toml::find>(data, "nums"); + + // access with STL-like manner + if(not data.contains("foo")) + { + data["foo"] = "bar"; + } + + // pass a fallback + std::string name = toml::find_or(data, "name", "not found"); + + // width-dependent formatting + std::cout << std::setw(80) << data << std::endl; + + return 0; +} +``` + +## Table of Contents + +- [Integration](#integration) +- [Decoding a toml file](#decoding-a-toml-file) + - [In the case of syntax error](#in-the-case-of-syntax-error) + - [Invalid UTF-8 Codepoints](#invalid-utf-8-codepoints) +- [Finding a toml value](#finding-a-toml-value) + - [Finding a value in a table](#finding-a-value-in-a-table) + - [In case of error](#in-case-of-error) + - [Dotted keys](#dotted-keys) +- [Casting a toml value](#casting-a-toml-value) +- [Checking value type](#checking-value-type) +- [More about conversion](#more-about-conversion) + - [Converting an array](#converting-an-array) + - [Converting a table](#converting-a-table) + - [Getting an array of tables](#getting-an-array-of-tables) + - [Cost of conversion](#cost-of-conversion) + - [Converting datetime and its variants](#converting-datetime-and-its-variants) +- [Getting with a fallback](#getting-with-a-fallback) +- [Expecting conversion](#expecting-conversion) +- [Visiting a toml::value](#visiting-a-tomlvalue) +- [Constructing a toml::value](#constructing-a-tomlvalue) +- [Preserving Comments](#preserving-comments) +- [Customizing containers](#customizing-containers) +- [TOML literal](#toml-literal) +- [Conversion between toml value and arbitrary types](#conversion-between-toml-value-and-arbitrary-types) +- [Formatting user-defined error messages](#formatting-user-defined-error-messages) +- [Obtaining location information](#obtaining-location-information) +- [Exceptions](#exceptions) +- [Colorize Error Messages](#colorize-error-messages) +- [Serializing TOML data](#serializing-toml-data) +- [Underlying types](#underlying-types) +- [Unreleased TOML features](#unreleased-toml-features) +- [Breaking Changes from v2](#breaking-changes-from-v2) +- [Running Tests](#running-tests) +- [Contributors](#contributors) +- [Licensing Terms](#licensing-terms) + +## Integration + +Just include the file after adding it to the include path. + +```cpp +#include // that's all! now you can use it. +#include + +int main() +{ + const auto data = toml::parse("example.toml"); + const auto title = toml::find(data, "title"); + std::cout << "the title is " << title << std::endl; + return 0; +} +``` + +The convenient way is to add this repository as a git-submodule or to install +it in your system by CMake. + +Note for MSVC: We recommend to set `/Zc:__cplusplus` to detect C++ version correctly. + +## Decoding a toml file + +To parse a toml file, the only thing you have to do is +to pass a filename to the `toml::parse` function. + +```cpp +const std::string fname("sample.toml"); +const toml::value data = toml::parse(fname); +``` + +As required by the TOML specification, the top-level value is always a table. +You can find a value inside it, cast it into a table explicitly, and insert it as a value into other `toml::value`. + +If it encounters an error while opening a file, it will throw `std::runtime_error`. + +You can also pass a `std::istream` to the `toml::parse` function. +To show a filename in an error message, however, it is recommended to pass the +filename with the stream. + +```cpp +std::ifstream ifs("sample.toml", std::ios_base::binary); +assert(ifs.good()); +const auto data = toml::parse(ifs, /*optional -> */ "sample.toml"); +``` + +**Note**: When you are **on Windows, open a file in binary mode**. +If a file is opened in text-mode, CRLF ("\r\n") will automatically be +converted to LF ("\n") and this causes inconsistency between file size +and the contents that would be read. This causes weird error. + +### In the case of syntax error + +If there is a syntax error in a toml file, `toml::parse` will throw +`toml::syntax_error` that inherits `std::exception`. + +toml11 has clean and informative error messages inspired by Rust and +it looks like the following. + +```console +terminate called after throwing an instance of 'toml::syntax_error' + what(): [error] toml::parse_table: invalid line format # error description + --> example.toml # file name + 3 | a = 42 = true # line num and content + | ^------ expected newline, but got '='. # error reason +``` + +If you (mistakenly) duplicate tables and got an error, it is helpful to see +where they are. toml11 shows both at the same time like the following. + +```console +terminate called after throwing an instance of 'toml::syntax_error' + what(): [error] toml::insert_value: table ("table") already exists. + --> duplicate-table.toml + 1 | [table] + | ~~~~~~~ table already exists here + ... + 3 | [table] + | ~~~~~~~ table defined twice +``` + +When toml11 encounters a malformed value, it tries to detect what type it is. +Then it shows hints to fix the format. An error message while reading one of +the malformed files in [the language agnostic test suite](https://github.com/BurntSushi/toml-test). +is shown below. + +```console +what(): [error] bad time: should be HH:MM:SS.subsec + --> ./datetime-malformed-no-secs.toml + 1 | no-secs = 1987-07-05T17:45Z + | ^------- HH:MM:SS.subsec + | +Hint: pass: 1979-05-27T07:32:00, 1979-05-27 07:32:00.999999 +Hint: fail: 1979-05-27T7:32:00, 1979-05-27 17:32 +``` + +You can find other examples in a job named `output_result` on +[CircleCI](https://circleci.com/gh/ToruNiina/toml11). + +Since the error message generation is generally a difficult task, the current +status is not ideal. If you encounter a weird error message, please let us know +and contribute to improve the quality! + +### Invalid UTF-8 codepoints + +It throws `syntax_error` if a value of an escape sequence +representing unicode character is not a valid UTF-8 codepoint. + +```console + what(): [error] toml::read_utf8_codepoint: input codepoint is too large. + --> utf8.toml + 1 | exceeds_unicode = "\U0011FFFF example" + | ^--------- should be in [0x00..0x10FFFF] +``` + +## Finding a toml value + +After parsing successfully, you can obtain the values from the result of +`toml::parse` using `toml::find` function. + +```toml +# sample.toml +answer = 42 +pi = 3.14 +numbers = [1,2,3] +time = 1979-05-27T07:32:00Z +``` + +``` cpp +const auto data = toml::parse("sample.toml"); +const auto answer = toml::find(data, "answer"); +const auto pi = toml::find(data, "pi"); +const auto numbers = toml::find>(data, "numbers"); +const auto timepoint = toml::find(data, "time"); +``` + +By default, `toml::find` returns a `toml::value`. + +```cpp +const toml::value& answer = toml::find(data, "answer"); +``` + +When you pass an exact TOML type that does not require type conversion, +`toml::find` returns a reference without copying the value. + +```cpp +const auto data = toml::parse("sample.toml"); +const auto& answer = toml::find(data, "answer"); +``` + +If the specified type requires conversion, you can't take a reference to the value. +See also [underlying types](#underlying-types). + +**NOTE**: For some technical reason, automatic conversion between `integer` and +`floating` is not supported. If you want to get a floating value even if a value +has integer value, you need to convert it manually after obtaining a value, +like the followings. + +```cpp +const auto vx = toml::find(data, "x"); +double x = vx.is_floating() ? vx.as_floating(std::nothrow) : + static_cast(vx.as_integer()); // it throws if vx is neither + // floating nor integer. +``` + +### Finding a value in a table + +There are several way to get a value defined in a table. +First, you can get a table as a normal value and find a value from the table. + +```toml +[fruit] +name = "apple" +[fruit.physical] +color = "red" +shape = "round" +``` + +``` cpp +const auto data = toml::parse("fruit.toml"); +const auto& fruit = toml::find(data, "fruit"); +const auto name = toml::find(fruit, "name"); + +const auto& physical = toml::find(fruit, "physical"); +const auto color = toml::find(physical, "color"); +const auto shape = toml::find(physical, "shape"); +``` + +Here, variable `fruit` is a `toml::value` and can be used as the first argument +of `toml::find`. + +Second, you can pass as many arguments as the number of subtables to `toml::find`. + +```cpp +const auto data = toml::parse("fruit.toml"); +const auto color = toml::find(data, "fruit", "physical", "color"); +const auto shape = toml::find(data, "fruit", "physical", "shape"); +``` + +### Finding a value in an array + +You can find n-th value in an array by `toml::find`. + +```toml +values = ["foo", "bar", "baz"] +``` + +``` cpp +const auto data = toml::parse("sample.toml"); +const auto values = toml::find(data, "values"); +const auto bar = toml::find(values, 1); +``` + +`toml::find` can also search array recursively. + +```cpp +const auto data = toml::parse("fruit.toml"); +const auto bar = toml::find(data, "values", 1); +``` + +Before calling `toml::find`, you can check if a value corresponding to a key +exists. You can use both `bool toml::value::contains(const key&) const` and +`std::size_t toml::value::count(const key&) const`. Those behaves like the +`std::map::contains` and `std::map::count`. + +```cpp +const auto data = toml::parse("fruit.toml"); +if(data.contains("fruit") && data.at("fruit").count("physical") != 0) +{ + // ... +} +``` + +### In case of error + +If the value does not exist, `toml::find` throws `std::out_of_range` with the +location of the table. + +```console +terminate called after throwing an instance of 'std::out_of_range' + what(): [error] key "answer" not found + --> example.toml + 6 | [tab] + | ~~~~~ in this table +``` + +---- + +If the specified type differs from the actual value contained, it throws +`toml::type_error` that inherits `std::exception`. + +Similar to the case of syntax error, toml11 also displays clean error messages. +The error message when you choose `int` to get `string` value would be like this. + +```console +terminate called after throwing an instance of 'toml::type_error' + what(): [error] toml::value bad_cast to integer + --> example.toml + 3 | title = "TOML Example" + | ~~~~~~~~~~~~~~ the actual type is string +``` + +**NOTE**: In order to show this kind of error message, all the toml values have +a pointer to represent its range in a file. The entire contents of a file is +shared by `toml::value`s and remains on the heap memory. It is recommended to +destruct all the `toml::value` classes after configuring your application +if you have a large TOML file compared to the memory resource. + +### Dotted keys + +TOML v0.5.0 has a new feature named "dotted keys". +You can chain keys to represent the structure of the data. + +```toml +physical.color = "orange" +physical.shape = "round" +``` + +This is equivalent to the following. + +```toml +[physical] +color = "orange" +shape = "round" +``` + +You can get both of the above tables with the same c++ code. + +```cpp +const auto physical = toml::find(data, "physical"); +const auto color = toml::find(physical, "color"); +``` + +The following code does not work for the above toml file. + +```cpp +// XXX this does not work! +const auto color = toml::find(data, "physical.color"); +``` + +The above code works with the following toml file. + +```toml +"physical.color" = "orange" +# equivalent to {"physical.color": "orange"}, +# NOT {"physical": {"color": "orange"}}. +``` + + +## Casting a toml value + +### `toml::get` + +`toml::parse` returns `toml::value`. `toml::value` is a union type that can +contain one of the following types. + +- `toml::boolean` (`bool`) +- `toml::integer` (`std::int64_t`) +- `toml::floating` (`double`) +- `toml::string` (a type convertible to std::string) +- `toml::local_date` +- `toml::local_time` +- `toml::local_datetime` +- `toml::offset_datetime` +- `toml::array` (by default, `std::vector`) + - It depends. See [customizing containers](#customizing-containers) for detail. +- `toml::table` (by default, `std::unordered_map`) + - It depends. See [customizing containers](#customizing-containers) for detail. + +To get a value inside, you can use `toml::get()`. The usage is the same as +`toml::find` (actually, `toml::find` internally uses `toml::get` after casting +a value to `toml::table`). + +``` cpp +const toml::value data = toml::parse("sample.toml"); +const toml::value answer_ = toml::get(data).at("answer"); +const std::int64_t answer = toml::get(answer_); +``` + +When you pass an exact TOML type that does not require type conversion, +`toml::get` returns a reference through which you can modify the content +(if the `toml::value` is `const`, it returns `const` reference). + +```cpp +toml::value data = toml::parse("sample.toml"); +toml::value answer_ = toml::get(data).at("answer"); +toml::integer& answer = toml::get(answer_); +answer = 6 * 9; // write to data.answer. now `answer_` contains 54. +``` + +If the specified type requires conversion, you can't take a reference to the value. +See also [underlying types](#underlying-types). + +It also throws a `toml::type_error` if the type differs. + +### `as_xxx` + +You can also use a member function to cast a value. + +```cpp +const std::int64_t answer = data.as_table().at("answer").as_integer(); +``` + +It also throws a `toml::type_error` if the type differs. If you are sure that +the value `v` contains a value of the specified type, you can suppress checking +by passing `std::nothrow`. + +```cpp +const auto& answer = data.as_table().at("answer"); +if(answer.is_integer() && answer.as_integer(std::nothrow) == 42) +{ + std::cout << "value is 42" << std::endl; +} +``` + +If `std::nothrow` is passed, the functions are marked as noexcept. + +By casting a `toml::value` into an array or a table, you can iterate over the +elements. + +```cpp +const auto data = toml::parse("example.toml"); +std::cout << "keys in the top-level table are the following: \n"; +for(const auto& [k, v] : data.as_table()) +{ + std::cout << k << '\n'; +} + +const auto& fruits = toml::find(data, "fruits"); +for(const auto& v : fruits.as_array()) +{ + std::cout << toml::find(v, "name") << '\n'; +} +``` + +The full list of the functions is below. + +```cpp +namespace toml { +class value { + // ... + const boolean& as_boolean() const&; + const integer& as_integer() const&; + const floating& as_floating() const&; + const string& as_string() const&; + const offset_datetime& as_offset_datetime() const&; + const local_datetime& as_local_datetime() const&; + const local_date& as_local_date() const&; + const local_time& as_local_time() const&; + const array& as_array() const&; + const table& as_table() const&; + // -------------------------------------------------------- + // non-const version + boolean& as_boolean() &; + // ditto... + // -------------------------------------------------------- + // rvalue version + boolean&& as_boolean() &&; + // ditto... + + // -------------------------------------------------------- + // noexcept versions ... + const boolean& as_boolean(const std::nothrow_t&) const& noexcept; + boolean& as_boolean(const std::nothrow_t&) & noexcept; + boolean&& as_boolean(const std::nothrow_t&) && noexcept; + // ditto... +}; +} // toml +``` + +### `at()` + +You can access to the element of a table and an array by `toml::basic_value::at`. + +```cpp +const toml::value v{1,2,3,4,5}; +std::cout << v.at(2).as_integer() << std::endl; // 3 + +const toml::value v{{"foo", 42}, {"bar", 3.14}}; +std::cout << v.at("foo").as_integer() << std::endl; // 42 +``` + +If an invalid key (integer for a table, string for an array), it throws +`toml::type_error` for the conversion. If the provided key is out-of-range, +it throws `std::out_of_range`. + +Note that, although `std::string` has `at()` member function, `toml::value::at` +throws if the contained type is a string. Because `std::string` does not +contain `toml::value`. + +### `operator[]` + +You can also access to the element of a table and an array by +`toml::basic_value::operator[]`. + +```cpp +const toml::value v{1,2,3,4,5}; +std::cout << v[2].as_integer() << std::endl; // 3 + +const toml::value v{{"foo", 42}, {"bar", 3.14}}; +std::cout << v["foo"].as_integer() << std::endl; // 42 +``` + +When you access to a `toml::value` that is not initialized yet via +`operator[](const std::string&)`, the `toml::value` will be a table, +just like the `std::map`. + +```cpp +toml::value v; // not initialized as a table. +v["foo"] = 42; // OK. `v` will be a table. +``` + +Contrary, if you access to a `toml::value` that contains an array via `operator[]`, +it does not check anything. It converts `toml::value` without type check and then +access to the n-th element without boundary check, just like the `std::vector::operator[]`. + +```cpp +toml::value v; // not initialized as an array +v[2] = 42; // error! UB +``` + +Please make sure that the `toml::value` has an array inside when you access to +its element via `operator[]`. + +## Checking value type + +You can check the type of a value by `is_xxx` function. + +```cpp +const toml::value v = /* ... */; +if(v.is_integer()) +{ + std::cout << "value is an integer" << std::endl; +} +``` + +The complete list of the functions is below. + +```cpp +namespace toml { +class value { + // ... + bool is_boolean() const noexcept; + bool is_integer() const noexcept; + bool is_floating() const noexcept; + bool is_string() const noexcept; + bool is_offset_datetime() const noexcept; + bool is_local_datetime() const noexcept; + bool is_local_date() const noexcept; + bool is_local_time() const noexcept; + bool is_array() const noexcept; + bool is_table() const noexcept; + bool is_uninitialized() const noexcept; + // ... +}; +} // toml +``` + +Also, you can get `enum class value_t` from `toml::value::type()`. + +```cpp +switch(data.at("something").type()) +{ + case toml::value_t::integer: /*do some stuff*/ ; break; + case toml::value_t::floating: /*do some stuff*/ ; break; + case toml::value_t::string : /*do some stuff*/ ; break; + default : throw std::runtime_error( + "unexpected type : " + toml::stringize(data.at("something").type())); +} +``` + +The complete list of the `enum`s can be found in the section +[underlying types](#underlying-types). + +The `enum`s can be used as a parameter of `toml::value::is` function like the following. + +```cpp +toml::value v = /* ... */; +if(v.is(toml::value_t::boolean)) // ... +``` + +## More about conversion + +Since `toml::find` internally uses `toml::get`, all the following examples work +with both `toml::get` and `toml::find`. + +### Converting an array + +You can get any kind of `container` class from a `toml::array` +except for `map`-like classes. + +``` cpp +// # sample.toml +// numbers = [1,2,3] + +const auto numbers = toml::find(data, "numbers"); + +const auto vc = toml::get >(numbers); +const auto ls = toml::get >(numbers); +const auto dq = toml::get >(numbers); +const auto ar = toml::get>(numbers); +// if the size of data.at("numbers") is larger than that of std::array, +// it will throw toml::type_error because std::array is not resizable. +``` + +Surprisingly, you can convert `toml::array` into `std::pair` and `std::tuple`. + +```cpp +// numbers = [1,2,3] +const auto tp = toml::get>(numbers); +``` + +This functionality is helpful when you have a toml file like the following. + +```toml +array_of_arrays = [[1, 2, 3], ["foo", "bar", "baz"]] # toml allows this +``` + +What is the corresponding C++ type? +Obviously, it is a `std::pair` of `std::vector`s. + +```cpp +const auto array_of_arrays = toml::find(data, "array_of_arrays"); +const auto aofa = toml::get< + std::pair, std::vector> + >(array_of_arrays); +``` + +If you don't know the type of the elements, you can use `toml::array`, +which is a `std::vector` of `toml::value`, instead. + +```cpp +const auto a_of_a = toml::get(array_of_arrays); +const auto first = toml::get>(a_of_a.at(0)); +``` + +You can change the implementation of `toml::array` with `std::deque` or some +other array-like container. See [Customizing containers](#customizing-containers) +for detail. + +### Converting a table + +When all the values of the table have the same type, toml11 allows you to +convert a `toml::table` to a `map` that contains the convertible type. + +```toml +[tab] +key1 = "foo" # all the values are +key2 = "bar" # toml String +``` + +```cpp +const auto data = toml::parse("sample.toml"); +const auto tab = toml::find>(data, "tab"); +std::cout << tab["key1"] << std::endl; // foo +std::cout << tab["key2"] << std::endl; // bar +``` + +But since `toml::table` is just an alias of `std::unordered_map`, +normally you don't need to convert it because it has all the functionalities that +`std::unordered_map` has (e.g. `operator[]`, `count`, and `find`). In most cases +`toml::table` is sufficient. + +```cpp +toml::table tab = toml::get(data); +if(data.count("title") != 0) +{ + data["title"] = std::string("TOML example"); +} +``` + +You can change the implementation of `toml::table` with `std::map` or some +other map-like container. See [Customizing containers](#customizing-containers) +for detail. + +### Getting an array of tables + +An array of tables is just an array of tables. +You can get it in completely the same way as the other arrays and tables. + +```toml +# sample.toml +array_of_inline_tables = [{key = "value1"}, {key = "value2"}, {key = "value3"}] + +[[array_of_tables]] +key = "value4" +[[array_of_tables]] +key = "value5" +[[array_of_tables]] +key = "value6" +``` + +```cpp +const auto data = toml::parse("sample.toml"); +const auto aot1 = toml::find>(data, "array_of_inline_tables"); +const auto aot2 = toml::find>(data, "array_of_tables"); +``` + +### Cost of conversion + +Although conversion through `toml::(get|find)` is convenient, it has additional +copy-cost because it copies data contained in `toml::value` to the +user-specified type. Of course in some cases this overhead is not ignorable. + +```cpp +// the following code constructs a std::vector. +// it requires heap allocation for vector and element conversion. +const auto array = toml::find>(data, "foo"); +``` + +By passing the exact types, `toml::get` returns reference that has no overhead. + +``` cpp +const auto& tab = toml::find(data, "tab"); +const auto& numbers = toml::find(data, "numbers"); +``` + +Also, `as_xxx` are zero-overhead because they always return a reference. + +``` cpp +const auto& tab = toml::find(data, "tab" ).as_table(); +const auto& numbers = toml::find(data, "numbers").as_array(); +``` + +In this case you need to call `toml::get` each time you access to +the element of `toml::array` because `toml::array` is an array of `toml::value`. + +```cpp +const auto& num0 = toml::get(numbers.at(0)); +const auto& num1 = toml::get(numbers.at(1)); +const auto& num2 = toml::get(numbers.at(2)); +``` + +### Converting datetime and its variants + +TOML v0.5.0 has 4 different datetime objects, `local_date`, `local_time`, +`local_datetime`, and `offset_datetime`. + +Since `local_date`, `local_datetime`, and `offset_datetime` represent a time +point, you can convert them to `std::chrono::system_clock::time_point`. + +Contrary, `local_time` does not represents a time point because they lack a +date information, but it can be converted to `std::chrono::duration` that +represents a duration from the beginning of the day, `00:00:00.000`. + +```toml +# sample.toml +date = 2018-12-23 +time = 12:30:00 +l_dt = 2018-12-23T12:30:00 +o_dt = 2018-12-23T12:30:00+09:30 +``` + +```cpp +const auto data = toml::parse("sample.toml"); + +const auto date = toml::get(data.at("date")); +const auto l_dt = toml::get(data.at("l_dt")); +const auto o_dt = toml::get(data.at("o_dt")); + +const auto time = toml::get(data.at("time")); // 12 * 60 + 30 min +``` + +`local_date` and `local_datetime` are assumed to be in the local timezone when +they are converted into `time_point`. On the other hand, `offset_datetime` only +uses the offset part of the data and it does not take local timezone into account. + +To contain datetime data, toml11 defines its own datetime types. +For more detail, you can see the definitions in [toml/datetime.hpp](toml/datetime.hpp). + +## Getting with a fallback + +`toml::find_or` returns a default value if the value is not found or has a +different type. + +```cpp +const auto data = toml::parse("example.toml"); +const auto num = toml::find_or(data, "num", 42); +``` + +Also, `toml::get_or` returns a default value if `toml::get` failed. + +```cpp +toml::value v("foo"); // v contains String +const int value = toml::get_or(v, 42); // conversion fails. it returns 42. +``` + +These functions automatically deduce what type you want to get +from the default value you passed. + +To get a reference through this function, take care about the default value. + +```cpp +toml::value v("foo"); // v contains String +toml::integer& i = toml::get_or(v, 42); // does not work because binding `42` + // to `integer&` is invalid +toml::integer opt = 42; +toml::integer& i = toml::get_or(v, opt); // this works. +``` + +## Expecting conversion + +By using `toml::expect`, you will get your expected value or an error message +without throwing `toml::type_error`. + +```cpp +const auto value = toml::expect(data.at("title")); +if(value.is_ok()) { + std::cout << value.unwrap() << std::endl; +} else { + std::cout << value.unwrap_err() << std::endl; +} +``` + +Also, you can pass a function object to modify the expected value. + +```cpp +const auto value = toml::expect(data.at("number")) + .map(// function that receives expected type (here, int) + [](const int number) -> double { + return number * 1.5 + 1.0; + }).unwrap_or(/*default value =*/ 3.14); +``` + +## Visiting a toml::value + +toml11 provides `toml::visit` to apply a function to `toml::value` in the +same way as `std::variant`. + +```cpp +const toml::value v(3.14); +toml::visit([](const auto& val) -> void { + std::cout << val << std::endl; + }, v); +``` + +The function object that would be passed to `toml::visit` must be able to +recieve all the possible TOML types. Also, the result types should be the same +each other. + +## Constructing a toml::value + +`toml::value` can be constructed in various ways. + +```cpp +toml::value v(true); // boolean +toml::value v(42); // integer +toml::value v(3.14); // floating +toml::value v("foobar"); // string +toml::value v(toml::local_date(2019, toml::month_t::Apr, 1)); // date +toml::value v{1, 2, 3, 4, 5}; // array +toml::value v{{"foo", 42}, {"bar", 3.14}, {"baz", "qux"}}; // table +``` + +When constructing a string, you can choose to use either literal or basic string. +By default, it will be a basic string. + +```cpp +toml::value v("foobar", toml::string_t::basic ); +toml::value v("foobar", toml::string_t::literal); +``` + +Datetime objects can be constructed from `std::tm` and +`std::chrono::system_clock::time_point`. But you need to specify what type +you use to avoid ambiguity. + +```cpp +const auto now = std::chrono::system_clock::now(); +toml::value v(toml::local_date(now)); +toml::value v(toml::local_datetime(now)); +toml::value v(toml::offset_datetime(now)); +``` + +Since local time is not equivalent to a time point, because it lacks date +information, it will be constructed from `std::chrono::duration`. + +```cpp +toml::value v(toml::local_time(std::chrono::hours(10))); +``` + +You can construct an array object not only from `initializer_list`, but also +from STL containers. In that case, the element type must be convertible to +`toml::value`. + +```cpp +std::vector vec{1,2,3,4,5}; +toml::value v(vec); +``` + +When you construct an array value, all the elements of `initializer_list` +must be convertible into `toml::value`. + +If a `toml::value` has an array, you can `push_back` an element in it. + +```cpp +toml::value v{1,2,3,4,5}; +v.push_back(6); +``` + +`emplace_back` also works. + +## Preserving comments + +After toml11 v3, you can choose whether comments are preserved or not. + +```cpp +const auto data1 = toml::parse("example.toml"); +const auto data2 = toml::parse("example.toml"); +``` + +Comments related to a value can be obtained by `toml::value::comments()`. +The return value has the same interface as `std::vector`. + +```cpp +const auto& com = v.comments(); +for(const auto& c : com) +{ + std::cout << c << std::endl; +} +``` + +Comments just before and just after (within the same line) a value are kept in a value. + +```toml +# this is a comment for v1. +v1 = "foo" + +v2 = "bar" # this is a comment for v2. +# Note that this comment is NOT a comment for v2. + +# this comment is not related to any value +# because there are empty lines between v3. +# this comment will be ignored even if you set `preserve_comments`. + +# this is a comment for v3 +# this is also a comment for v3. +v3 = "baz" # ditto. +``` + +Each comment line becomes one element of a `std::vector`. + +Hash signs will be removed, but spaces after hash sign will not be removed. + +```cpp +v1.comments().at(0) == " this is a comment for v1."s; + +v2.comments().at(1) == " this is a comment for v1."s; + +v3.comments().at(0) == " this is a comment for v3."s; +v3.comments().at(1) == " this is also a comment for v3."s; +v3.comments().at(2) == " ditto."s; +``` + +Note that a comment just after an opening brace of an array will not be a +comment for the array. + +```toml +# this is a comment for a. +a = [ # this is not a comment for a. this will be ignored. + 1, 2, 3, + # this is a comment for `42`. + 42, # this is also a comment for `42`. + 5 +] # this is a comment for a. +``` + +You can also append and modify comments. +The interfaces are the same as `std::vector`. + +```cpp +toml::basic_value v(42); +v.comments().push_back(" add this comment."); +// # add this comment. +// i = 42 +``` + +Also, you can pass a `std::vector` when constructing a +`toml::basic_value`. + +```cpp +std::vector comments{"comment 1", "comment 2"}; +const toml::basic_value v1(42, std::move(comments)); +const toml::basic_value v2(42, {"comment 1", "comment 2"}); +``` + +When `toml::discard_comments` is chosen, comments will not be contained in a value. +`value::comments()` will always be kept empty. +All the modification on comments would be ignored. +All the element access in a `discard_comments` causes the same error as accessing +an element of an empty `std::vector`. + +The comments will also be serialized. If comments exist, those comments will be +added just before the values. + +__NOTE__: Result types from `toml::parse(...)` and +`toml::parse(...)` are different. + +## Customizing containers + +Actually, `toml::basic_value` has 3 template arguments. + +```cpp +template class Table = std::unordered_map, + template class Array = std::vector> +class basic_value; +``` + +This enables you to change the containers used inside. E.g. you can use +`std::map` to contain a table object instead of `std::unordered_map`. +And also can use `std::deque` as a array object instead of `std::vector`. + +You can set these parameters while calling `toml::parse` function. + +```cpp +const auto data = toml::parse< + toml::preserve_comments, std::map, std::deque + >("example.toml"); +``` + +Needless to say, the result types from `toml::parse(...)` and +`toml::parse(...)` are different (unless you specify the same +types as default). + +Note that, since `toml::table` and `toml::array` is an alias for a table and an +array of a default `toml::value`, so it is different from the types actually +contained in a `toml::basic_value` when you customize containers. +To get the actual type in a generic way, use +`typename toml::basic_type::table_type` and +`typename toml::basic_type::array_type`. + +## TOML literal + +toml11 supports `"..."_toml` literal. +It accept both a bare value and a file content. + +```cpp +using namespace toml::literals::toml_literals; + +// `_toml` can convert a bare value without key +const toml::value v = u8"0xDEADBEEF"_toml; +// v is an Integer value containing 0xDEADBEEF. + +// raw string literal (`R"(...)"` is useful for this purpose) +const toml::value t = u8R"( + title = "this is TOML literal" + [table] + key = "value" +)"_toml; +// the literal will be parsed and the result will be contained in t +``` + +The literal function is defined in the same way as the standard library literals +such as `std::literals::string_literals::operator""s`. + +```cpp +namespace toml +{ +inline namespace literals +{ +inline namespace toml_literals +{ +toml::value operator"" _toml(const char* str, std::size_t len); +} // toml_literals +} // literals +} // toml +``` + +Access to the operator can be gained with `using namespace toml::literals;`, +`using namespace toml::toml_literals`, and `using namespace toml::literals::toml_literals`. + +Note that a key that is composed only of digits is allowed in TOML. +And, unlike the file parser, toml-literal allows a bare value without a key. +Thus it is difficult to distinguish arrays having integers and definitions of +tables that are named as digits. +Currently, literal `[1]` becomes a table named "1". +To ensure a literal to be considered as an array with one element, you need to +add a comma after the first element (like `[1,]`). + +```cpp +"[1,2,3]"_toml; // This is an array +"[table]"_toml; // This is a table that has an empty table named "table" inside. +"[[1,2,3]]"_toml; // This is an array of arrays +"[[table]]"_toml; // This is a table that has an array of tables inside. + +"[[1]]"_toml; // This literal is ambiguous. + // Currently, it becomes a table that has array of table "1". +"1 = [{}]"_toml; // This is a table that has an array of table named 1. +"[[1,]]"_toml; // This is an array of arrays. +"[[1],]"_toml; // ditto. +``` + +NOTE: `_toml` literal returns a `toml::value` that does not have comments. + +## Conversion between toml value and arbitrary types + +You can also use `toml::get` and other related functions with the types +you defined after you implement a way to convert it. + +```cpp +namespace ext +{ +struct foo +{ + int a; + double b; + std::string c; +}; +} // ext + +const auto data = toml::parse("example.toml"); + +// to do this +const foo f = toml::find(data, "foo"); +``` + +There are 3 ways to use `toml::get` with the types that you defined. + +The first one is to implement `from_toml(const toml::value&)` member function. + +```cpp +namespace ext +{ +struct foo +{ + int a; + double b; + std::string c; + + void from_toml(const toml::value& v) + { + this->a = toml::find(v, "a"); + this->b = toml::find(v, "b"); + this->c = toml::find(v, "c"); + return; + } +}; +} // ext +``` + +In this way, because `toml::get` first constructs `foo` without arguments, +the type should be default-constructible. + +The second is to implement `constructor(const toml::value&)`. + +```cpp +namespace ext +{ +struct foo +{ + explicit foo(const toml::value& v) + : a(toml::find(v, "a")), b(toml::find(v, "b")), + c(toml::find(v, "c")) + {} + + int a; + double b; + std::string c; +}; +} // ext +``` + +Note that implicit default constructor declaration will be suppressed +when a constructor is defined. If you want to use the struct (here, `foo`) +in a container (e.g. `std::vector`), you may need to define default +constructor explicitly. + +The third is to implement specialization of `toml::from` for your type. + +```cpp +namespace ext +{ +struct foo +{ + int a; + double b; + std::string c; +}; +} // ext + +namespace toml +{ +template<> +struct from +{ + static ext::foo from_toml(const value& v) + { + ext::foo f; + f.a = find(v, "a"); + f.b = find(v, "b"); + f.c = find(v, "c"); + return f; + } +}; +} // toml +``` + +In this way, since the conversion function is defined outside of the class, +you can add conversion between `toml::value` and classes defined in another library. + +Note that you cannot implement both of the functions because the overload +resolution of `toml::get` will be ambiguous. + +If you want to convert any versions of `toml::basic_value`, +you need to templatize the conversion function as follows. + +```cpp +struct foo +{ + template class M, template class A> + void from_toml(const toml::basic_value& v) + { + this->a = toml::find(v, "a"); + this->b = toml::find(v, "b"); + this->c = toml::find(v, "c"); + return; + } +}; +// or +namespace toml +{ +template<> +struct from +{ + template class M, template class A> + static ext::foo from_toml(const basic_value& v) + { + ext::foo f; + f.a = find(v, "a"); + f.b = find(v, "b"); + f.c = find(v, "c"); + return f; + } +}; +} // toml +``` + +---- + +The opposite direction is also supported in a similar way. You can directly +pass your type to `toml::value`'s constructor by introducing `into_toml` or +`toml::into`. + +```cpp +namespace ext +{ +struct foo +{ + int a; + double b; + std::string c; + + toml::value into_toml() const // you need to mark it const. + { + return toml::value{{"a", this->a}, {"b", this->b}, {"c", this->c}}; + } +}; +} // ext + +ext::foo f{42, 3.14, "foobar"}; +toml::value v(f); +``` + +The definition of `toml::into` is similar to `toml::from`. + +```cpp +namespace ext +{ +struct foo +{ + int a; + double b; + std::string c; +}; +} // ext + +namespace toml +{ +template<> +struct into +{ + static toml::value into_toml(const ext::foo& f) + { + return toml::value{{"a", f.a}, {"b", f.b}, {"c", f.c}}; + } +}; +} // toml + +ext::foo f{42, 3.14, "foobar"}; +toml::value v(f); +``` + +Any type that can be converted to `toml::value`, e.g. `int`, `toml::table` and +`toml::array` are okay to return from `into_toml`. + +You can also return a custom `toml::basic_value` from `toml::into`. + +```cpp +namespace toml +{ +template<> +struct into +{ + static toml::basic_value into_toml(const ext::foo& f) + { + toml::basic_value v{{"a", f.a}, {"b", f.b}, {"c", f.c}}; + v.comments().push_back(" comment"); + return v; + } +}; +} // toml +``` + +But note that, if this `basic_value` would be assigned into other `toml::value` +that discards `comments`, the comments would be dropped. + +### Macro to automatically define conversion functions + +There is a helper macro that automatically generates conversion functions `from` and `into` for a simple struct. + +```cpp +namespace foo +{ +struct Foo +{ + std::string s; + double d; + int i; +}; +} // foo + +TOML11_DEFINE_CONVERSION_NON_INTRUSIVE(foo::Foo, s, d, i) + +int main() +{ + const auto file = toml::parse("example.toml"); + auto f = toml::find(file, "foo"); +} +``` + +And then you can use `toml::find(file, "foo");` + +**Note** that, because of a slight difference in implementation of preprocessor between gcc/clang and MSVC, [you need to define `/Zc:preprocessor`](https://github.com/ToruNiina/toml11/issues/139#issuecomment-803683682) to use it in MSVC (Thank you @glebm !). + +## Formatting user-defined error messages + +When you encounter an error after you read the toml value, you may want to +show the error with the value. + +toml11 provides you a function that formats user-defined error message with +related values. With a code like the following, + +```cpp +const auto value = toml::find(data, "num"); +if(value < 0) +{ + std::cerr << toml::format_error("[error] value should be positive", + data.at("num"), "positive number required") + << std::endl; +} +``` + +you will get an error message like this. + +```console +[error] value should be positive + --> example.toml + 3 | num = -42 + | ~~~ positive number required +``` + +When you pass two values to `toml::format_error`, + +```cpp +const auto min = toml::find(range, "min"); +const auto max = toml::find(range, "max"); +if(max < min) +{ + std::cerr << toml::format_error("[error] max should be larger than min", + data.at("min"), "minimum number here", + data.at("max"), "maximum number here"); + << std::endl; +} +``` + +you will get an error message like this. + +```console +[error] max should be larger than min + --> example.toml + 3 | min = 54 + | ~~ minimum number here + ... + 4 | max = 42 + | ~~ maximum number here +``` + +You can print hints at the end of the message. + +```cpp +std::vector hints; +hints.push_back("positive number means n >= 0."); +hints.push_back("negative number is not positive."); +std::cerr << toml::format_error("[error] value should be positive", + data.at("num"), "positive number required", hints) + << std::endl; +``` + +```console +[error] value should be positive + --> example.toml + 2 | num = 42 + | ~~ positive number required + | +Hint: positive number means n >= 0. +Hint: negative number is not positive. +``` + +## Obtaining location information + +You can also format error messages in your own way by using `source_location`. + +```cpp +struct source_location +{ + std::uint_least32_t line() const noexcept; + std::uint_least32_t column() const noexcept; + std::uint_least32_t region() const noexcept; + std::string const& file_name() const noexcept; + std::string const& line_str() const noexcept; +}; +// +-- line() +--- length of the region (here, region() == 9) +// v .---+---. +// 12 | value = "foo bar" <- line_str() returns the line itself. +// ^-------- column() points here +``` + +You can get this by +```cpp +const toml::value v = /*...*/; +const toml::source_location loc = v.location(); +``` + +## Exceptions + +The following `exception` classes inherits `toml::exception` that inherits +`std::exception`. + +```cpp +namespace toml { +struct exception : public std::exception {/**/}; +struct syntax_error : public toml::exception {/**/}; +struct type_error : public toml::exception {/**/}; +struct internal_error : public toml::exception {/**/}; +} // toml +``` + +`toml::exception` has `toml::exception::location()` member function that returns +`toml::source_location`, in addition to `what()`. + +```cpp +namespace toml { +struct exception : public std::exception +{ + // ... + source_location const& location() const noexcept; +}; +} // toml +``` + +It represents where the error occurs. + +`syntax_error` will be thrown from `toml::parse` and `_toml` literal. +`type_error` will be thrown from `toml::get/find`, `toml::value::as_xxx()`, and +other functions that takes a content inside of `toml::value`. + +Note that, currently, from `toml::value::at()` and `toml::find(value, key)` +may throw an `std::out_of_range` that does not inherits `toml::exception`. + +Also, in some cases, most likely in the file open error, it will throw an +`std::runtime_error`. + +## Colorize Error Messages + +By defining `TOML11_COLORIZE_ERROR_MESSAGE`, the error messages from +`toml::parse` and `toml::find|get` will be colorized. By default, this feature +is turned off. + +With the following toml file taken from `toml-lang/toml/tests/hard_example.toml`, + +```toml +[error] +array = [ + "This might most likely happen in multiline arrays", + Like here, + "or here, + and here" + ] End of array comment, forgot the # +``` + +the error message would be like this. + +![error-message-1](https://github.com/ToruNiina/toml11/blob/misc/misc/toml11-err-msg-1.png) + +With the following, + +```toml +[error] +# array = [ +# "This might most likely happen in multiline arrays", +# Like here, +# "or here, +# and here" +# ] End of array comment, forgot the # +number = 3.14 pi <--again forgot the # +``` + +the error message would be like this. + +![error-message-2](https://github.com/ToruNiina/toml11/blob/misc/misc/toml11-err-msg-2.png) + +The message would be messy when it is written to a file, not a terminal because +it uses [ANSI escape code](https://en.wikipedia.org/wiki/ANSI_escape_code). + +Without `TOML11_COLORIZE_ERROR_MESSAGE`, you can still colorize user-defined +error message by passing `true` to the `toml::format_error` function. +If you define `TOML11_COLORIZE_ERROR_MESSAGE`, the value is `true` by default. +If not, the defalut value would be `false`. + +```cpp +std::cerr << toml::format_error("[error] value should be positive", + data.at("num"), "positive number required", + hints, /*colorize = */ true) << std::endl; +``` + +Note: It colorize `[error]` in red. That means that it detects `[error]` prefix +at the front of the error message. If there is no `[error]` prefix, +`format_error` adds it to the error message. + +## Serializing TOML data + +toml11 enables you to serialize data into toml format. + +```cpp +const toml::value data{{"foo", 42}, {"bar", "baz"}}; +std::cout << data << std::endl; +// bar = "baz" +// foo = 42 +``` + +toml11 automatically makes a small table and small array inline. +You can specify the width to make them inline by `std::setw` for streams. + +```cpp +const toml::value data{ + {"qux", {{"foo", 42}, {"bar", "baz"}}}, + {"quux", {"small", "array", "of", "strings"}}, + {"foobar", {"this", "array", "of", "strings", "is", "too", "long", + "to", "print", "into", "single", "line", "isn't", "it?"}}, +}; + +// the threshold becomes 80. +std::cout << std::setw(80) << data << std::endl; +// foobar = [ +// "this","array","of","strings","is","too","long","to","print","into", +// "single","line","isn't","it?", +// ] +// quux = ["small","array","of","strings"] +// qux = {bar="baz",foo=42} + + +// the width is 0. nothing become inline. +std::cout << std::setw(0) << data << std::endl; +// foobar = [ +// "this", +// ... (snip) +// "it?", +// ] +// quux = [ +// "small", +// "array", +// "of", +// "strings", +// ] +// [qux] +// bar = "baz" +// foo = 42 +``` + +It is recommended to set width before printing data. Some I/O functions changes +width to 0, and it makes all the stuff (including `toml::array`) multiline. +The resulting files becomes too long. + +To control the precision of floating point numbers, you need to pass +`std::setprecision` to stream. + +```cpp +const toml::value data{ + {"pi", 3.141592653589793}, + {"e", 2.718281828459045} +}; +std::cout << std::setprecision(17) << data << std::endl; +// e = 2.7182818284590451 +// pi = 3.1415926535897931 +std::cout << std::setprecision( 7) << data << std::endl; +// e = 2.718282 +// pi = 3.141593 +``` + +There is another way to format toml values, `toml::format()`. +It returns `std::string` that represents a value. + +```cpp +const toml::value v{{"a", 42}}; +const std::string fmt = toml::format(v); +// a = 42 +``` + +Note that since `toml::format` formats a value, the resulting string may lack +the key value. + +```cpp +const toml::value v{3.14}; +const std::string fmt = toml::format(v); +// 3.14 +``` + +To control the width and precision, `toml::format` receives optional second and +third arguments to set them. By default, the witdh is 80 and the precision is +`std::numeric_limits::max_digit10`. + +```cpp +const auto serial = toml::format(data, /*width = */ 0, /*prec = */ 17); +``` + +When you pass a comment-preserving-value, the comment will also be serialized. +An array or a table containing a value that has a comment would not be inlined. + +## Underlying types + +The toml types (can be used as `toml::*` in this library) and corresponding `enum` names are listed in the table below. + +| TOML type | underlying c++ type | enum class | +| -------------- | ---------------------------------- | -------------------------------- | +| Boolean | `bool` | `toml::value_t::boolean` | +| Integer | `std::int64_t` | `toml::value_t::integer` | +| Float | `double` | `toml::value_t::floating` | +| String | `toml::string` | `toml::value_t::string` | +| LocalDate | `toml::local_date` | `toml::value_t::local_date` | +| LocalTime | `toml::local_time` | `toml::value_t::local_time` | +| LocalDatetime | `toml::local_datetime` | `toml::value_t::local_datetime` | +| OffsetDatetime | `toml::offset_datetime` | `toml::value_t::offset_datetime` | +| Array | `array-like` | `toml::value_t::array` | +| Table | `map-like` | `toml::value_t::table` | + +`array-like` and `map-like` are the STL containers that works like a `std::vector` and +`std::unordered_map`, respectively. By default, `std::vector` and `std::unordered_map` +are used. See [Customizing containers](#customizing-containers) for detail. + +`toml::string` is effectively the same as `std::string` but has an additional +flag that represents a kind of a string, `string_t::basic` and `string_t::literal`. +Although `std::string` is not an exact toml type, still you can get a reference +that points to internal `std::string` by using `toml::get()` for convenience. +The most important difference between `std::string` and `toml::string` is that +`toml::string` will be formatted as a TOML string when outputed with `ostream`. +This feature is introduced to make it easy to write a custom serializer. + +`Datetime` variants are `struct` that are defined in this library. +Because `std::chrono::system_clock::time_point` is a __time point__, +not capable of representing a Local Time independent from a specific day. + +## Unreleased TOML features + +Since TOML v1.0.0-rc.1 has been released, those features are now activated by +default. We no longer need to define `TOML11_USE_UNRELEASED_FEATURES`. + +- Leading zeroes in exponent parts of floats are permitted. + - e.g. `1.0e+01`, `5e+05` + - [toml-lang/toml/PR/656](https://github.com/toml-lang/toml/pull/656) +- Allow raw tab characters in basic strings and multi-line basic strings. + - [toml-lang/toml/PR/627](https://github.com/toml-lang/toml/pull/627) +- Allow heterogeneous arrays + - [toml-lang/toml/PR/676](https://github.com/toml-lang/toml/pull/676) + +## Note about heterogeneous arrays + +Although `toml::parse` allows heterogeneous arrays, constructor of `toml::value` +does not. Here the reason is explained. + +```cpp +// this won't be compiled +toml::value v{ + "foo", 3.14, 42, {1,2,3,4,5}, {{"key", "value"}} +} +``` + +There is a workaround for this. By explicitly converting values into +`toml::value`, you can initialize `toml::value` with a heterogeneous array. +Also, you can first initialize a `toml::value` with an array and then +`push_back` into it. + +```cpp +// OK! +toml::value v{ + toml::value("foo"), toml::value(3.14), toml::value(42), + toml::value{1,2,3,4,5}, toml::value{{"key", "value"}} +} + +// OK! +toml::value v(toml::array{}); +v.push_back("foo"); +v.push_back(3.14); + +// OK! +toml::array a; +a.push_back("foo"); +a.push_back(3.14); +toml::value v(std::move(a)); +``` + +The reason why the first example is not allowed is the following. +Let's assume that you are initializing a `toml::value` with a table. + +```cpp + // # expecting TOML table. +toml::value v{ // [v] + {"answer", 42}, // answer = 42 + {"pi", 3.14}, // pi = 3.14 + {"foo", "bar"} // foo = "bar" +}; +``` + +This is indistinguishable from a (heterogeneous) TOML array definition. + +```toml +v = [ + ["answer", 42], + ["pi", 3.14], + ["foo", "bar"], +] +``` + +This means that the above C++ code makes constructor's overload resolution +ambiguous. So a constructor that allows both "table as an initializer-list" and +"heterogeneous array as an initializer-list" cannot be implemented. + +Thus, although it is painful, we need to explicitly cast values into +`toml::value` when you initialize heterogeneous array in a C++ code. + +```cpp +toml::value v{ + toml::value("foo"), toml::value(3.14), toml::value(42), + toml::value{1,2,3,4,5}, toml::value{{"key", "value"}} +}; +``` + +## Breaking Changes from v2 + +Although toml11 is relatively new library (it's three years old now), it had +some confusing and inconvenient user-interfaces because of historical reasons. + +Between v2 and v3, those interfaces are rearranged. + +- `toml::parse` now returns a `toml::value`, not `toml::table`. +- `toml::value` is now an alias of `toml::basic_value`. + - See [Customizing containers](#customizing-containers) for detail. +- The elements of `toml::value_t` are renamed as `snake_case`. + - See [Underlying types](#underlying-types) for detail. +- Supports for the CamelCaseNames are dropped. + - See [Underlying types](#underlying-types) for detail. +- `(is|as)_float` has been removed to make the function names consistent with others. + - Since `float` is a keyword, toml11 named a float type as `toml::floating`. + - Also a `value_t` corresponds to `toml::floating` is named `value_t::floating`. + - So `(is|as)_floating` is introduced and `is_float` has been removed. + - See [Casting a toml::value](#casting-a-tomlvalue) and [Checking value type](#checking-value-type) for detail. +- An overload of `toml::find` for `toml::table` has been dropped. Use `toml::value` version instead. + - Because type conversion between a table and a value causes ambiguity while overload resolution + - Since `toml::parse` now returns a `toml::value`, this feature becomes less important. + - Also because `toml::table` is a normal STL container, implementing utility function is easy. + - See [Finding a toml::value](#finding-a-toml-value) for detail. +- An overload of `operator<<` and `toml::format` for `toml::table`s are dropped. + - Use `toml::value` instead. + - See [Serializing TOML data](#serializing-toml-data) for detail. +- Interface around comments. + - See [Preserving Comments](#preserving-comments) for detail. +- An ancient `from_toml/into_toml` has been removed. Use arbitrary type conversion support. + - See [Conversion between toml value and arbitrary types](#conversion-between-toml-value-and-arbitrary-types) for detail. + +Such a big change will not happen in the coming years. + +## Running Tests + +After cloning this repository, run the following command (thank you @jwillikers +for automating test set fetching!). + +```sh +$ mkdir build +$ cd build +$ cmake .. -Dtoml11_BUILD_TEST=ON +$ make +$ make test +``` + +To run the language agnostic test suite, you need to compile +`tests/check_toml_test.cpp` and pass it to the tester. + +## Contributors + +I appreciate the help of the contributors who introduced the great feature to this library. + +- Guillaume Fraux (@Luthaf) + - Windows support and CI on Appvayor + - Intel Compiler support +- Quentin Khan (@xaxousis) + - Found & Fixed a bug around ODR + - Improved error messages for invaild keys to show the location where the parser fails +- Petr BeneÅ¡ (@wbenny) + - Fixed warnings on MSVC +- Ivan Shynkarenka (@chronoxor) + - Fixed Visual Studio 2019 warnings +- @khoitd1997 + - Fixed warnings while type conversion +- @KerstinKeller + - Added installation script to CMake +- J.C. Moyer (@jcmoyer) + - Fixed an example code in the documentation +- Jt Freeman (@blockparty-sh) + - Fixed feature test macro around `localtime_s` + - Suppress warnings in Debug mode +- OGAWA Kenichi (@kenichiice) + - Suppress warnings on intel compiler +- Jordan Williams (@jwillikers) + - Fixed clang range-loop-analysis warnings + - Fixed feature test macro to suppress -Wundef + - Use cache variables in CMakeLists.txt + - Automate test set fetching, update and refactor CMakeLists.txt +- Scott McCaskill + - Parse 9 digits (nanoseconds) of fractional seconds in a `local_time` +- Shu Wang (@halfelf) + - fix "Finding a value in an array" example in README +- @maass-tv and @SeverinLeonhardt + - Fix MSVC warning C4866 +- OGAWA KenIchi (@kenichiice) + - Fix include path in README +- Mohammed Alyousef (@MoAlyousef) + - Made testing optional in CMake +- Ivan Shynkarenka (@chronoxor) + - Fix compilation error in `` with MinGW +- Alex Merry (@amerry) + - Add missing include files +- sneakypete81 (@sneakypete81) + - Fix typo in error message + + +## Licensing terms + +This product is licensed under the terms of the [MIT License](LICENSE). + +- Copyright (c) 2017-2020 Toru Niina + +All rights reserved. diff --git a/libraries/toml11/include/toml.hpp b/libraries/toml11/include/toml.hpp new file mode 100644 index 00000000..9ed1216e --- /dev/null +++ b/libraries/toml11/include/toml.hpp @@ -0,0 +1,46 @@ +/* + * The MIT License (MIT) + * + * Copyright (c) 2017 Toru Niina + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ + +#ifndef TOML_FOR_MODERN_CPP +#define TOML_FOR_MODERN_CPP + +#ifndef __cplusplus +# error "__cplusplus is not defined" +#endif + +#if __cplusplus < 201103L && _MSC_VER < 1900 +# error "toml11 requires C++11 or later." +#endif + +#define TOML11_VERSION_MAJOR 3 +#define TOML11_VERSION_MINOR 6 +#define TOML11_VERSION_PATCH 1 + +#include "toml/parser.hpp" +#include "toml/literal.hpp" +#include "toml/serializer.hpp" +#include "toml/get.hpp" +#include "toml/macros.hpp" + +#endif// TOML_FOR_MODERN_CPP diff --git a/libraries/toml11/include/toml/color.hpp b/libraries/toml11/include/toml/color.hpp new file mode 100644 index 00000000..4cb572cb --- /dev/null +++ b/libraries/toml11/include/toml/color.hpp @@ -0,0 +1,64 @@ +#ifndef TOML11_COLOR_HPP +#define TOML11_COLOR_HPP +#include +#include + +#ifdef TOML11_COLORIZE_ERROR_MESSAGE +#define TOML11_ERROR_MESSAGE_COLORIZED true +#else +#define TOML11_ERROR_MESSAGE_COLORIZED false +#endif + +namespace toml +{ + +// put ANSI escape sequence to ostream +namespace color_ansi +{ +namespace detail +{ +inline int colorize_index() +{ + static const int index = std::ios_base::xalloc(); + return index; +} +} // detail + +inline std::ostream& colorize(std::ostream& os) +{ + // by default, it is zero. + os.iword(detail::colorize_index()) = 1; + return os; +} +inline std::ostream& nocolorize(std::ostream& os) +{ + os.iword(detail::colorize_index()) = 0; + return os; +} +inline std::ostream& reset (std::ostream& os) +{if(os.iword(detail::colorize_index()) == 1) {os << "\033[00m";} return os;} +inline std::ostream& bold (std::ostream& os) +{if(os.iword(detail::colorize_index()) == 1) {os << "\033[01m";} return os;} +inline std::ostream& grey (std::ostream& os) +{if(os.iword(detail::colorize_index()) == 1) {os << "\033[30m";} return os;} +inline std::ostream& red (std::ostream& os) +{if(os.iword(detail::colorize_index()) == 1) {os << "\033[31m";} return os;} +inline std::ostream& green (std::ostream& os) +{if(os.iword(detail::colorize_index()) == 1) {os << "\033[32m";} return os;} +inline std::ostream& yellow (std::ostream& os) +{if(os.iword(detail::colorize_index()) == 1) {os << "\033[33m";} return os;} +inline std::ostream& blue (std::ostream& os) +{if(os.iword(detail::colorize_index()) == 1) {os << "\033[34m";} return os;} +inline std::ostream& magenta(std::ostream& os) +{if(os.iword(detail::colorize_index()) == 1) {os << "\033[35m";} return os;} +inline std::ostream& cyan (std::ostream& os) +{if(os.iword(detail::colorize_index()) == 1) {os << "\033[36m";} return os;} +inline std::ostream& white (std::ostream& os) +{if(os.iword(detail::colorize_index()) == 1) {os << "\033[37m";} return os;} +} // color_ansi + +// ANSI escape sequence is the only and default colorization method currently +namespace color = color_ansi; + +} // toml +#endif// TOML11_COLOR_HPP diff --git a/libraries/toml11/include/toml/combinator.hpp b/libraries/toml11/include/toml/combinator.hpp new file mode 100644 index 00000000..e250188f --- /dev/null +++ b/libraries/toml11/include/toml/combinator.hpp @@ -0,0 +1,306 @@ +// Copyright Toru Niina 2017. +// Distributed under the MIT License. +#ifndef TOML11_COMBINATOR_HPP +#define TOML11_COMBINATOR_HPP +#include +#include +#include + +#include +#include +#include +#include +#include + +#include "region.hpp" +#include "result.hpp" +#include "traits.hpp" +#include "utility.hpp" + +// they scans characters and returns region if it matches to the condition. +// when they fail, it does not change the location. +// in lexer.hpp, these are used. + +namespace toml +{ +namespace detail +{ + +// to output character as an error message. +inline std::string show_char(const char c) +{ + // It supress an error that occurs only in Debug mode of MSVC++ on Windows. + // I'm not completely sure but they check the value of char to be in the + // range [0, 256) and some of the COMPLETELY VALID utf-8 character sometimes + // has negative value (if char has sign). So here it re-interprets c as + // unsigned char through pointer. In general, converting pointer to a + // pointer that has different type cause UB, but `(signed|unsigned)?char` + // are one of the exceptions. Converting pointer only to char and std::byte + // (c++17) are valid. + if(std::isgraph(*reinterpret_cast(std::addressof(c)))) + { + return std::string(1, c); + } + else + { + std::array buf; + buf.fill('\0'); + const auto r = std::snprintf( + buf.data(), buf.size(), "0x%02x", static_cast(c) & 0xFF); + (void) r; // Unused variable warning + assert(r == static_cast(buf.size()) - 1); + return std::string(buf.data()); + } +} + +template +struct character +{ + static constexpr char target = C; + + static result + invoke(location& loc) + { + if(loc.iter() == loc.end()) {return none();} + const auto first = loc.iter(); + + const char c = *(loc.iter()); + if(c != target) + { + return none(); + } + loc.advance(); // update location + + return ok(region(loc, first, loc.iter())); + } +}; +template +constexpr char character::target; + +// closed interval [Low, Up]. both Low and Up are included. +template +struct in_range +{ + // assuming ascii part of UTF-8... + static_assert(Low <= Up, "lower bound should be less than upper bound."); + + static constexpr char upper = Up; + static constexpr char lower = Low; + + static result + invoke(location& loc) + { + if(loc.iter() == loc.end()) {return none();} + const auto first = loc.iter(); + + const char c = *(loc.iter()); + if(c < lower || upper < c) + { + return none(); + } + + loc.advance(); + return ok(region(loc, first, loc.iter())); + } +}; +template constexpr char in_range::upper; +template constexpr char in_range::lower; + +// keep iterator if `Combinator` matches. otherwise, increment `iter` by 1 char. +// for detecting invalid characters, like control sequences in toml string. +template +struct exclude +{ + static result + invoke(location& loc) + { + if(loc.iter() == loc.end()) {return none();} + auto first = loc.iter(); + + auto rslt = Combinator::invoke(loc); + if(rslt.is_ok()) + { + loc.reset(first); + return none(); + } + loc.reset(std::next(first)); // XXX maybe loc.advance() is okay but... + return ok(region(loc, first, loc.iter())); + } +}; + +// increment `iter`, if matches. otherwise, just return empty string. +template +struct maybe +{ + static result + invoke(location& loc) + { + const auto rslt = Combinator::invoke(loc); + if(rslt.is_ok()) + { + return rslt; + } + return ok(region(loc)); + } +}; + +template +struct sequence; + +template +struct sequence +{ + static result + invoke(location& loc) + { + const auto first = loc.iter(); + const auto rslt = Head::invoke(loc); + if(rslt.is_err()) + { + loc.reset(first); + return none(); + } + return sequence::invoke(loc, std::move(rslt.unwrap()), first); + } + + // called from the above function only, recursively. + template + static result + invoke(location& loc, region reg, Iterator first) + { + const auto rslt = Head::invoke(loc); + if(rslt.is_err()) + { + loc.reset(first); + return none(); + } + reg += rslt.unwrap(); // concat regions + return sequence::invoke(loc, std::move(reg), first); + } +}; + +template +struct sequence +{ + // would be called from sequence::invoke only. + template + static result + invoke(location& loc, region reg, Iterator first) + { + const auto rslt = Head::invoke(loc); + if(rslt.is_err()) + { + loc.reset(first); + return none(); + } + reg += rslt.unwrap(); // concat regions + return ok(reg); + } +}; + +template +struct either; + +template +struct either +{ + static result + invoke(location& loc) + { + const auto rslt = Head::invoke(loc); + if(rslt.is_ok()) {return rslt;} + return either::invoke(loc); + } +}; +template +struct either +{ + static result + invoke(location& loc) + { + return Head::invoke(loc); + } +}; + +template +struct repeat; + +template struct exactly{}; +template struct at_least{}; +struct unlimited{}; + +template +struct repeat> +{ + static result + invoke(location& loc) + { + region retval(loc); + const auto first = loc.iter(); + for(std::size_t i=0; i +struct repeat> +{ + static result + invoke(location& loc) + { + region retval(loc); + + const auto first = loc.iter(); + for(std::size_t i=0; i +struct repeat +{ + static result + invoke(location& loc) + { + region retval(loc); + while(true) + { + auto rslt = T::invoke(loc); + if(rslt.is_err()) + { + return ok(std::move(retval)); + } + retval += rslt.unwrap(); + } + } +}; + +} // detail +} // toml +#endif// TOML11_COMBINATOR_HPP diff --git a/libraries/toml11/include/toml/comments.hpp b/libraries/toml11/include/toml/comments.hpp new file mode 100644 index 00000000..92fc8e13 --- /dev/null +++ b/libraries/toml11/include/toml/comments.hpp @@ -0,0 +1,466 @@ +// Copyright Toru Niina 2019. +// Distributed under the MIT License. +#ifndef TOML11_COMMENTS_HPP +#define TOML11_COMMENTS_HPP +#include +#include +#include +#include +#include +#include +#include + +// This file provides mainly two classes, `preserve_comments` and `discard_comments`. +// Those two are a container that have the same interface as `std::vector` +// but bahaves in the opposite way. `preserve_comments` is just the same as +// `std::vector` and each `std::string` corresponds to a comment line. +// Conversely, `discard_comments` discards all the strings and ignores everything +// assigned in it. `discard_comments` is always empty and you will encounter an +// error whenever you access to the element. +namespace toml +{ +struct discard_comments; // forward decl + +// use it in the following way +// +// const toml::basic_value data = +// toml::parse("example.toml"); +// +// the interface is almost the same as std::vector. +struct preserve_comments +{ + // `container_type` is not provided in discard_comments. + // do not use this inner-type in a generic code. + using container_type = std::vector; + + using size_type = container_type::size_type; + using difference_type = container_type::difference_type; + using value_type = container_type::value_type; + using reference = container_type::reference; + using const_reference = container_type::const_reference; + using pointer = container_type::pointer; + using const_pointer = container_type::const_pointer; + using iterator = container_type::iterator; + using const_iterator = container_type::const_iterator; + using reverse_iterator = container_type::reverse_iterator; + using const_reverse_iterator = container_type::const_reverse_iterator; + + preserve_comments() = default; + ~preserve_comments() = default; + preserve_comments(preserve_comments const&) = default; + preserve_comments(preserve_comments &&) = default; + preserve_comments& operator=(preserve_comments const&) = default; + preserve_comments& operator=(preserve_comments &&) = default; + + explicit preserve_comments(const std::vector& c): comments(c){} + explicit preserve_comments(std::vector&& c) + : comments(std::move(c)) + {} + preserve_comments& operator=(const std::vector& c) + { + comments = c; + return *this; + } + preserve_comments& operator=(std::vector&& c) + { + comments = std::move(c); + return *this; + } + + explicit preserve_comments(const discard_comments&) {} + + explicit preserve_comments(size_type n): comments(n) {} + preserve_comments(size_type n, const std::string& x): comments(n, x) {} + preserve_comments(std::initializer_list x): comments(x) {} + template + preserve_comments(InputIterator first, InputIterator last) + : comments(first, last) + {} + + template + void assign(InputIterator first, InputIterator last) {comments.assign(first, last);} + void assign(std::initializer_list ini) {comments.assign(ini);} + void assign(size_type n, const std::string& val) {comments.assign(n, val);} + + // Related to the issue #97. + // + // It is known that `std::vector::insert` and `std::vector::erase` in + // the standard library implementation included in GCC 4.8.5 takes + // `std::vector::iterator` instead of `std::vector::const_iterator`. + // Because of the const-correctness, we cannot convert a `const_iterator` to + // an `iterator`. It causes compilation error in GCC 4.8.5. +#if defined(__GNUC__) && defined(__GNUC_MINOR__) && defined(__GNUC_PATCHLEVEL__) && !defined(__clang__) +# if (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__) <= 40805 +# define TOML11_WORKAROUND_GCC_4_8_X_STANDARD_LIBRARY_IMPLEMENTATION +# endif +#endif + +#ifdef TOML11_WORKAROUND_GCC_4_8_X_STANDARD_LIBRARY_IMPLEMENTATION + iterator insert(iterator p, const std::string& x) + { + return comments.insert(p, x); + } + iterator insert(iterator p, std::string&& x) + { + return comments.insert(p, std::move(x)); + } + void insert(iterator p, size_type n, const std::string& x) + { + return comments.insert(p, n, x); + } + template + void insert(iterator p, InputIterator first, InputIterator last) + { + return comments.insert(p, first, last); + } + void insert(iterator p, std::initializer_list ini) + { + return comments.insert(p, ini); + } + + template + iterator emplace(iterator p, Ts&& ... args) + { + return comments.emplace(p, std::forward(args)...); + } + + iterator erase(iterator pos) {return comments.erase(pos);} + iterator erase(iterator first, iterator last) + { + return comments.erase(first, last); + } +#else + iterator insert(const_iterator p, const std::string& x) + { + return comments.insert(p, x); + } + iterator insert(const_iterator p, std::string&& x) + { + return comments.insert(p, std::move(x)); + } + iterator insert(const_iterator p, size_type n, const std::string& x) + { + return comments.insert(p, n, x); + } + template + iterator insert(const_iterator p, InputIterator first, InputIterator last) + { + return comments.insert(p, first, last); + } + iterator insert(const_iterator p, std::initializer_list ini) + { + return comments.insert(p, ini); + } + + template + iterator emplace(const_iterator p, Ts&& ... args) + { + return comments.emplace(p, std::forward(args)...); + } + + iterator erase(const_iterator pos) {return comments.erase(pos);} + iterator erase(const_iterator first, const_iterator last) + { + return comments.erase(first, last); + } +#endif + + void swap(preserve_comments& other) {comments.swap(other.comments);} + + void push_back(const std::string& v) {comments.push_back(v);} + void push_back(std::string&& v) {comments.push_back(std::move(v));} + void pop_back() {comments.pop_back();} + + template + void emplace_back(Ts&& ... args) {comments.emplace_back(std::forward(args)...);} + + void clear() {comments.clear();} + + size_type size() const noexcept {return comments.size();} + size_type max_size() const noexcept {return comments.max_size();} + size_type capacity() const noexcept {return comments.capacity();} + bool empty() const noexcept {return comments.empty();} + + void reserve(size_type n) {comments.reserve(n);} + void resize(size_type n) {comments.resize(n);} + void resize(size_type n, const std::string& c) {comments.resize(n, c);} + void shrink_to_fit() {comments.shrink_to_fit();} + + reference operator[](const size_type n) noexcept {return comments[n];} + const_reference operator[](const size_type n) const noexcept {return comments[n];} + reference at(const size_type n) {return comments.at(n);} + const_reference at(const size_type n) const {return comments.at(n);} + reference front() noexcept {return comments.front();} + const_reference front() const noexcept {return comments.front();} + reference back() noexcept {return comments.back();} + const_reference back() const noexcept {return comments.back();} + + pointer data() noexcept {return comments.data();} + const_pointer data() const noexcept {return comments.data();} + + iterator begin() noexcept {return comments.begin();} + iterator end() noexcept {return comments.end();} + const_iterator begin() const noexcept {return comments.begin();} + const_iterator end() const noexcept {return comments.end();} + const_iterator cbegin() const noexcept {return comments.cbegin();} + const_iterator cend() const noexcept {return comments.cend();} + + reverse_iterator rbegin() noexcept {return comments.rbegin();} + reverse_iterator rend() noexcept {return comments.rend();} + const_reverse_iterator rbegin() const noexcept {return comments.rbegin();} + const_reverse_iterator rend() const noexcept {return comments.rend();} + const_reverse_iterator crbegin() const noexcept {return comments.crbegin();} + const_reverse_iterator crend() const noexcept {return comments.crend();} + + friend bool operator==(const preserve_comments&, const preserve_comments&); + friend bool operator!=(const preserve_comments&, const preserve_comments&); + friend bool operator< (const preserve_comments&, const preserve_comments&); + friend bool operator<=(const preserve_comments&, const preserve_comments&); + friend bool operator> (const preserve_comments&, const preserve_comments&); + friend bool operator>=(const preserve_comments&, const preserve_comments&); + + friend void swap(preserve_comments&, std::vector&); + friend void swap(std::vector&, preserve_comments&); + + private: + + container_type comments; +}; + +inline bool operator==(const preserve_comments& lhs, const preserve_comments& rhs) {return lhs.comments == rhs.comments;} +inline bool operator!=(const preserve_comments& lhs, const preserve_comments& rhs) {return lhs.comments != rhs.comments;} +inline bool operator< (const preserve_comments& lhs, const preserve_comments& rhs) {return lhs.comments < rhs.comments;} +inline bool operator<=(const preserve_comments& lhs, const preserve_comments& rhs) {return lhs.comments <= rhs.comments;} +inline bool operator> (const preserve_comments& lhs, const preserve_comments& rhs) {return lhs.comments > rhs.comments;} +inline bool operator>=(const preserve_comments& lhs, const preserve_comments& rhs) {return lhs.comments >= rhs.comments;} + +inline void swap(preserve_comments& lhs, preserve_comments& rhs) +{ + lhs.swap(rhs); + return; +} +inline void swap(preserve_comments& lhs, std::vector& rhs) +{ + lhs.comments.swap(rhs); + return; +} +inline void swap(std::vector& lhs, preserve_comments& rhs) +{ + lhs.swap(rhs.comments); + return; +} + +template +std::basic_ostream& +operator<<(std::basic_ostream& os, const preserve_comments& com) +{ + for(const auto& c : com) + { + os << '#' << c << '\n'; + } + return os; +} + +namespace detail +{ + +// To provide the same interface with `preserve_comments`, `discard_comments` +// should have an iterator. But it does not contain anything, so we need to +// add an iterator that points nothing. +// +// It always points null, so DO NOT unwrap this iterator. It always crashes +// your program. +template +struct empty_iterator +{ + using value_type = T; + using reference_type = typename std::conditional::type; + using pointer_type = typename std::conditional::type; + using difference_type = std::ptrdiff_t; + using iterator_category = std::random_access_iterator_tag; + + empty_iterator() = default; + ~empty_iterator() = default; + empty_iterator(empty_iterator const&) = default; + empty_iterator(empty_iterator &&) = default; + empty_iterator& operator=(empty_iterator const&) = default; + empty_iterator& operator=(empty_iterator &&) = default; + + // DO NOT call these operators. + reference_type operator*() const noexcept {std::terminate();} + pointer_type operator->() const noexcept {return nullptr;} + reference_type operator[](difference_type) const noexcept {return this->operator*();} + + // These operators do nothing. + empty_iterator& operator++() noexcept {return *this;} + empty_iterator operator++(int) noexcept {return *this;} + empty_iterator& operator--() noexcept {return *this;} + empty_iterator operator--(int) noexcept {return *this;} + + empty_iterator& operator+=(difference_type) noexcept {return *this;} + empty_iterator& operator-=(difference_type) noexcept {return *this;} + + empty_iterator operator+(difference_type) const noexcept {return *this;} + empty_iterator operator-(difference_type) const noexcept {return *this;} +}; + +template +bool operator==(const empty_iterator&, const empty_iterator&) noexcept {return true;} +template +bool operator!=(const empty_iterator&, const empty_iterator&) noexcept {return false;} +template +bool operator< (const empty_iterator&, const empty_iterator&) noexcept {return false;} +template +bool operator<=(const empty_iterator&, const empty_iterator&) noexcept {return true;} +template +bool operator> (const empty_iterator&, const empty_iterator&) noexcept {return false;} +template +bool operator>=(const empty_iterator&, const empty_iterator&) noexcept {return true;} + +template +typename empty_iterator::difference_type +operator-(const empty_iterator&, const empty_iterator&) noexcept {return 0;} + +template +empty_iterator +operator+(typename empty_iterator::difference_type, const empty_iterator& rhs) noexcept {return rhs;} +template +empty_iterator +operator+(const empty_iterator& lhs, typename empty_iterator::difference_type) noexcept {return lhs;} + +} // detail + +// The default comment type. It discards all the comments. It requires only one +// byte to contain, so the memory footprint is smaller than preserve_comments. +// +// It just ignores `push_back`, `insert`, `erase`, and any other modifications. +// IT always returns size() == 0, the iterator taken by `begin()` is always the +// same as that of `end()`, and accessing through `operator[]` or iterators +// always causes a segmentation fault. DO NOT access to the element of this. +// +// Why this is chose as the default type is because the last version (2.x.y) +// does not contain any comments in a value. To minimize the impact on the +// efficiency, this is choosed as a default. +// +// To reduce the memory footprint, later we can try empty base optimization (EBO). +struct discard_comments +{ + using size_type = std::size_t; + using difference_type = std::ptrdiff_t; + using value_type = std::string; + using reference = std::string&; + using const_reference = std::string const&; + using pointer = std::string*; + using const_pointer = std::string const*; + using iterator = detail::empty_iterator; + using const_iterator = detail::empty_iterator; + using reverse_iterator = detail::empty_iterator; + using const_reverse_iterator = detail::empty_iterator; + + discard_comments() = default; + ~discard_comments() = default; + discard_comments(discard_comments const&) = default; + discard_comments(discard_comments &&) = default; + discard_comments& operator=(discard_comments const&) = default; + discard_comments& operator=(discard_comments &&) = default; + + explicit discard_comments(const std::vector&) noexcept {} + explicit discard_comments(std::vector&&) noexcept {} + discard_comments& operator=(const std::vector&) noexcept {return *this;} + discard_comments& operator=(std::vector&&) noexcept {return *this;} + + explicit discard_comments(const preserve_comments&) noexcept {} + + explicit discard_comments(size_type) noexcept {} + discard_comments(size_type, const std::string&) noexcept {} + discard_comments(std::initializer_list) noexcept {} + template + discard_comments(InputIterator, InputIterator) noexcept {} + + template + void assign(InputIterator, InputIterator) noexcept {} + void assign(std::initializer_list) noexcept {} + void assign(size_type, const std::string&) noexcept {} + + iterator insert(const_iterator, const std::string&) {return iterator{};} + iterator insert(const_iterator, std::string&&) {return iterator{};} + iterator insert(const_iterator, size_type, const std::string&) {return iterator{};} + template + iterator insert(const_iterator, InputIterator, InputIterator) {return iterator{};} + iterator insert(const_iterator, std::initializer_list) {return iterator{};} + + template + iterator emplace(const_iterator, Ts&& ...) {return iterator{};} + iterator erase(const_iterator) {return iterator{};} + iterator erase(const_iterator, const_iterator) {return iterator{};} + + void swap(discard_comments&) {return;} + + void push_back(const std::string&) {return;} + void push_back(std::string&& ) {return;} + void pop_back() {return;} + + template + void emplace_back(Ts&& ...) {return;} + + void clear() {return;} + + size_type size() const noexcept {return 0;} + size_type max_size() const noexcept {return 0;} + size_type capacity() const noexcept {return 0;} + bool empty() const noexcept {return true;} + + void reserve(size_type) {return;} + void resize(size_type) {return;} + void resize(size_type, const std::string&) {return;} + void shrink_to_fit() {return;} + + // DO NOT access to the element of this container. This container is always + // empty, so accessing through operator[], front/back, data causes address + // error. + + reference operator[](const size_type) noexcept {return *data();} + const_reference operator[](const size_type) const noexcept {return *data();} + reference at(const size_type) {throw std::out_of_range("toml::discard_comment is always empty.");} + const_reference at(const size_type) const {throw std::out_of_range("toml::discard_comment is always empty.");} + reference front() noexcept {return *data();} + const_reference front() const noexcept {return *data();} + reference back() noexcept {return *data();} + const_reference back() const noexcept {return *data();} + + pointer data() noexcept {return nullptr;} + const_pointer data() const noexcept {return nullptr;} + + iterator begin() noexcept {return iterator{};} + iterator end() noexcept {return iterator{};} + const_iterator begin() const noexcept {return const_iterator{};} + const_iterator end() const noexcept {return const_iterator{};} + const_iterator cbegin() const noexcept {return const_iterator{};} + const_iterator cend() const noexcept {return const_iterator{};} + + reverse_iterator rbegin() noexcept {return iterator{};} + reverse_iterator rend() noexcept {return iterator{};} + const_reverse_iterator rbegin() const noexcept {return const_iterator{};} + const_reverse_iterator rend() const noexcept {return const_iterator{};} + const_reverse_iterator crbegin() const noexcept {return const_iterator{};} + const_reverse_iterator crend() const noexcept {return const_iterator{};} +}; + +inline bool operator==(const discard_comments&, const discard_comments&) noexcept {return true;} +inline bool operator!=(const discard_comments&, const discard_comments&) noexcept {return false;} +inline bool operator< (const discard_comments&, const discard_comments&) noexcept {return false;} +inline bool operator<=(const discard_comments&, const discard_comments&) noexcept {return true;} +inline bool operator> (const discard_comments&, const discard_comments&) noexcept {return false;} +inline bool operator>=(const discard_comments&, const discard_comments&) noexcept {return true;} + +inline void swap(const discard_comments&, const discard_comments&) noexcept {return;} + +template +std::basic_ostream& +operator<<(std::basic_ostream& os, const discard_comments&) +{ + return os; +} + +} // toml11 +#endif// TOML11_COMMENTS_HPP diff --git a/libraries/toml11/include/toml/datetime.hpp b/libraries/toml11/include/toml/datetime.hpp new file mode 100644 index 00000000..d8127c15 --- /dev/null +++ b/libraries/toml11/include/toml/datetime.hpp @@ -0,0 +1,631 @@ +// Copyright Toru Niina 2017. +// Distributed under the MIT License. +#ifndef TOML11_DATETIME_HPP +#define TOML11_DATETIME_HPP +#include +#include +#include + +#include +#include +#include +#include +#include + +namespace toml +{ + +// To avoid non-threadsafe std::localtime. In C11 (not C++11!), localtime_s is +// provided in the absolutely same purpose, but C++11 is actually not compatible +// with C11. We need to dispatch the function depending on the OS. +namespace detail +{ +// TODO: find more sophisticated way to handle this +#if (defined(_POSIX_C_SOURCE) && _POSIX_C_SOURCE >= 1) || defined(_XOPEN_SOURCE) || defined(_BSD_SOURCE) || defined(_SVID_SOURCE) || defined(_POSIX_SOURCE) +inline std::tm localtime_s(const std::time_t* src) +{ + std::tm dst; + const auto result = ::localtime_r(src, &dst); + if (!result) { throw std::runtime_error("localtime_r failed."); } + return dst; +} +inline std::tm gmtime_s(const std::time_t* src) +{ + std::tm dst; + const auto result = ::gmtime_r(src, &dst); + if (!result) { throw std::runtime_error("gmtime_r failed."); } + return dst; +} +#elif defined(_MSC_VER) +inline std::tm localtime_s(const std::time_t* src) +{ + std::tm dst; + const auto result = ::localtime_s(&dst, src); + if (result) { throw std::runtime_error("localtime_s failed."); } + return dst; +} +inline std::tm gmtime_s(const std::time_t* src) +{ + std::tm dst; + const auto result = ::gmtime_s(&dst, src); + if (result) { throw std::runtime_error("gmtime_s failed."); } + return dst; +} +#else // fallback. not threadsafe +inline std::tm localtime_s(const std::time_t* src) +{ + const auto result = std::localtime(src); + if (!result) { throw std::runtime_error("localtime failed."); } + return *result; +} +inline std::tm gmtime_s(const std::time_t* src) +{ + const auto result = std::gmtime(src); + if (!result) { throw std::runtime_error("gmtime failed."); } + return *result; +} +#endif +} // detail + +enum class month_t : std::uint8_t +{ + Jan = 0, + Feb = 1, + Mar = 2, + Apr = 3, + May = 4, + Jun = 5, + Jul = 6, + Aug = 7, + Sep = 8, + Oct = 9, + Nov = 10, + Dec = 11 +}; + +struct local_date +{ + std::int16_t year; // A.D. (like, 2018) + std::uint8_t month; // [0, 11] + std::uint8_t day; // [1, 31] + + local_date(int y, month_t m, int d) + : year (static_cast(y)), + month(static_cast(m)), + day (static_cast(d)) + {} + + explicit local_date(const std::tm& t) + : year (static_cast(t.tm_year + 1900)), + month(static_cast(t.tm_mon)), + day (static_cast(t.tm_mday)) + {} + + explicit local_date(const std::chrono::system_clock::time_point& tp) + { + const auto t = std::chrono::system_clock::to_time_t(tp); + const auto time = detail::localtime_s(&t); + *this = local_date(time); + } + + explicit local_date(const std::time_t t) + : local_date(std::chrono::system_clock::from_time_t(t)) + {} + + operator std::chrono::system_clock::time_point() const + { + // std::mktime returns date as local time zone. no conversion needed + std::tm t; + t.tm_sec = 0; + t.tm_min = 0; + t.tm_hour = 0; + t.tm_mday = static_cast(this->day); + t.tm_mon = static_cast(this->month); + t.tm_year = static_cast(this->year) - 1900; + t.tm_wday = 0; // the value will be ignored + t.tm_yday = 0; // the value will be ignored + t.tm_isdst = -1; + return std::chrono::system_clock::from_time_t(std::mktime(&t)); + } + + operator std::time_t() const + { + return std::chrono::system_clock::to_time_t( + std::chrono::system_clock::time_point(*this)); + } + + local_date() = default; + ~local_date() = default; + local_date(local_date const&) = default; + local_date(local_date&&) = default; + local_date& operator=(local_date const&) = default; + local_date& operator=(local_date&&) = default; +}; + +inline bool operator==(const local_date& lhs, const local_date& rhs) +{ + return std::make_tuple(lhs.year, lhs.month, lhs.day) == + std::make_tuple(rhs.year, rhs.month, rhs.day); +} +inline bool operator!=(const local_date& lhs, const local_date& rhs) +{ + return !(lhs == rhs); +} +inline bool operator< (const local_date& lhs, const local_date& rhs) +{ + return std::make_tuple(lhs.year, lhs.month, lhs.day) < + std::make_tuple(rhs.year, rhs.month, rhs.day); +} +inline bool operator<=(const local_date& lhs, const local_date& rhs) +{ + return (lhs < rhs) || (lhs == rhs); +} +inline bool operator> (const local_date& lhs, const local_date& rhs) +{ + return !(lhs <= rhs); +} +inline bool operator>=(const local_date& lhs, const local_date& rhs) +{ + return !(lhs < rhs); +} + +template +std::basic_ostream& +operator<<(std::basic_ostream& os, const local_date& date) +{ + os << std::setfill('0') << std::setw(4) << static_cast(date.year ) << '-'; + os << std::setfill('0') << std::setw(2) << static_cast(date.month) + 1 << '-'; + os << std::setfill('0') << std::setw(2) << static_cast(date.day ) ; + return os; +} + +struct local_time +{ + std::uint8_t hour; // [0, 23] + std::uint8_t minute; // [0, 59] + std::uint8_t second; // [0, 60] + std::uint16_t millisecond; // [0, 999] + std::uint16_t microsecond; // [0, 999] + std::uint16_t nanosecond; // [0, 999] + + local_time(int h, int m, int s, + int ms = 0, int us = 0, int ns = 0) + : hour (static_cast(h)), + minute(static_cast(m)), + second(static_cast(s)), + millisecond(static_cast(ms)), + microsecond(static_cast(us)), + nanosecond (static_cast(ns)) + {} + + explicit local_time(const std::tm& t) + : hour (static_cast(t.tm_hour)), + minute(static_cast(t.tm_min)), + second(static_cast(t.tm_sec)), + millisecond(0), microsecond(0), nanosecond(0) + {} + + template + explicit local_time(const std::chrono::duration& t) + { + const auto h = std::chrono::duration_cast(t); + this->hour = static_cast(h.count()); + const auto t2 = t - h; + const auto m = std::chrono::duration_cast(t2); + this->minute = static_cast(m.count()); + const auto t3 = t2 - m; + const auto s = std::chrono::duration_cast(t3); + this->second = static_cast(s.count()); + const auto t4 = t3 - s; + const auto ms = std::chrono::duration_cast(t4); + this->millisecond = static_cast(ms.count()); + const auto t5 = t4 - ms; + const auto us = std::chrono::duration_cast(t5); + this->microsecond = static_cast(us.count()); + const auto t6 = t5 - us; + const auto ns = std::chrono::duration_cast(t6); + this->nanosecond = static_cast(ns.count()); + } + + operator std::chrono::nanoseconds() const + { + return std::chrono::nanoseconds (this->nanosecond) + + std::chrono::microseconds(this->microsecond) + + std::chrono::milliseconds(this->millisecond) + + std::chrono::seconds(this->second) + + std::chrono::minutes(this->minute) + + std::chrono::hours(this->hour); + } + + local_time() = default; + ~local_time() = default; + local_time(local_time const&) = default; + local_time(local_time&&) = default; + local_time& operator=(local_time const&) = default; + local_time& operator=(local_time&&) = default; +}; + +inline bool operator==(const local_time& lhs, const local_time& rhs) +{ + return std::make_tuple(lhs.hour, lhs.minute, lhs.second, lhs.millisecond, lhs.microsecond, lhs.nanosecond) == + std::make_tuple(rhs.hour, rhs.minute, rhs.second, rhs.millisecond, rhs.microsecond, rhs.nanosecond); +} +inline bool operator!=(const local_time& lhs, const local_time& rhs) +{ + return !(lhs == rhs); +} +inline bool operator< (const local_time& lhs, const local_time& rhs) +{ + return std::make_tuple(lhs.hour, lhs.minute, lhs.second, lhs.millisecond, lhs.microsecond, lhs.nanosecond) < + std::make_tuple(rhs.hour, rhs.minute, rhs.second, rhs.millisecond, rhs.microsecond, rhs.nanosecond); +} +inline bool operator<=(const local_time& lhs, const local_time& rhs) +{ + return (lhs < rhs) || (lhs == rhs); +} +inline bool operator> (const local_time& lhs, const local_time& rhs) +{ + return !(lhs <= rhs); +} +inline bool operator>=(const local_time& lhs, const local_time& rhs) +{ + return !(lhs < rhs); +} + +template +std::basic_ostream& +operator<<(std::basic_ostream& os, const local_time& time) +{ + os << std::setfill('0') << std::setw(2) << static_cast(time.hour ) << ':'; + os << std::setfill('0') << std::setw(2) << static_cast(time.minute) << ':'; + os << std::setfill('0') << std::setw(2) << static_cast(time.second); + if(time.millisecond != 0 || time.microsecond != 0 || time.nanosecond != 0) + { + os << '.'; + os << std::setfill('0') << std::setw(3) << static_cast(time.millisecond); + if(time.microsecond != 0 || time.nanosecond != 0) + { + os << std::setfill('0') << std::setw(3) << static_cast(time.microsecond); + if(time.nanosecond != 0) + { + os << std::setfill('0') << std::setw(3) << static_cast(time.nanosecond); + } + } + } + return os; +} + +struct time_offset +{ + std::int8_t hour; // [-12, 12] + std::int8_t minute; // [-59, 59] + + time_offset(int h, int m) + : hour (static_cast(h)), + minute(static_cast(m)) + {} + + operator std::chrono::minutes() const + { + return std::chrono::minutes(this->minute) + + std::chrono::hours(this->hour); + } + + time_offset() = default; + ~time_offset() = default; + time_offset(time_offset const&) = default; + time_offset(time_offset&&) = default; + time_offset& operator=(time_offset const&) = default; + time_offset& operator=(time_offset&&) = default; +}; + +inline bool operator==(const time_offset& lhs, const time_offset& rhs) +{ + return std::make_tuple(lhs.hour, lhs.minute) == + std::make_tuple(rhs.hour, rhs.minute); +} +inline bool operator!=(const time_offset& lhs, const time_offset& rhs) +{ + return !(lhs == rhs); +} +inline bool operator< (const time_offset& lhs, const time_offset& rhs) +{ + return std::make_tuple(lhs.hour, lhs.minute) < + std::make_tuple(rhs.hour, rhs.minute); +} +inline bool operator<=(const time_offset& lhs, const time_offset& rhs) +{ + return (lhs < rhs) || (lhs == rhs); +} +inline bool operator> (const time_offset& lhs, const time_offset& rhs) +{ + return !(lhs <= rhs); +} +inline bool operator>=(const time_offset& lhs, const time_offset& rhs) +{ + return !(lhs < rhs); +} + +template +std::basic_ostream& +operator<<(std::basic_ostream& os, const time_offset& offset) +{ + if(offset.hour == 0 && offset.minute == 0) + { + os << 'Z'; + return os; + } + int minute = static_cast(offset.hour) * 60 + offset.minute; + if(minute < 0){os << '-'; minute = std::abs(minute);} else {os << '+';} + os << std::setfill('0') << std::setw(2) << minute / 60 << ':'; + os << std::setfill('0') << std::setw(2) << minute % 60; + return os; +} + +struct local_datetime +{ + local_date date; + local_time time; + + local_datetime(local_date d, local_time t): date(d), time(t) {} + + explicit local_datetime(const std::tm& t): date(t), time(t){} + + explicit local_datetime(const std::chrono::system_clock::time_point& tp) + { + const auto t = std::chrono::system_clock::to_time_t(tp); + std::tm ltime = detail::localtime_s(&t); + + this->date = local_date(ltime); + this->time = local_time(ltime); + + // std::tm lacks subsecond information, so diff between tp and tm + // can be used to get millisecond & microsecond information. + const auto t_diff = tp - + std::chrono::system_clock::from_time_t(std::mktime(<ime)); + this->time.millisecond = static_cast( + std::chrono::duration_cast(t_diff).count()); + this->time.microsecond = static_cast( + std::chrono::duration_cast(t_diff).count()); + this->time.nanosecond = static_cast( + std::chrono::duration_cast(t_diff).count()); + } + + explicit local_datetime(const std::time_t t) + : local_datetime(std::chrono::system_clock::from_time_t(t)) + {} + + operator std::chrono::system_clock::time_point() const + { + using internal_duration = + typename std::chrono::system_clock::time_point::duration; + + // Normally DST begins at A.M. 3 or 4. If we re-use conversion operator + // of local_date and local_time independently, the conversion fails if + // it is the day when DST begins or ends. Since local_date considers the + // time is 00:00 A.M. and local_time does not consider DST because it + // does not have any date information. We need to consider both date and + // time information at the same time to convert it correctly. + + std::tm t; + t.tm_sec = static_cast(this->time.second); + t.tm_min = static_cast(this->time.minute); + t.tm_hour = static_cast(this->time.hour); + t.tm_mday = static_cast(this->date.day); + t.tm_mon = static_cast(this->date.month); + t.tm_year = static_cast(this->date.year) - 1900; + t.tm_wday = 0; // the value will be ignored + t.tm_yday = 0; // the value will be ignored + t.tm_isdst = -1; + + // std::mktime returns date as local time zone. no conversion needed + auto dt = std::chrono::system_clock::from_time_t(std::mktime(&t)); + dt += std::chrono::duration_cast( + std::chrono::milliseconds(this->time.millisecond) + + std::chrono::microseconds(this->time.microsecond) + + std::chrono::nanoseconds (this->time.nanosecond)); + return dt; + } + + operator std::time_t() const + { + return std::chrono::system_clock::to_time_t( + std::chrono::system_clock::time_point(*this)); + } + + local_datetime() = default; + ~local_datetime() = default; + local_datetime(local_datetime const&) = default; + local_datetime(local_datetime&&) = default; + local_datetime& operator=(local_datetime const&) = default; + local_datetime& operator=(local_datetime&&) = default; +}; + +inline bool operator==(const local_datetime& lhs, const local_datetime& rhs) +{ + return std::make_tuple(lhs.date, lhs.time) == + std::make_tuple(rhs.date, rhs.time); +} +inline bool operator!=(const local_datetime& lhs, const local_datetime& rhs) +{ + return !(lhs == rhs); +} +inline bool operator< (const local_datetime& lhs, const local_datetime& rhs) +{ + return std::make_tuple(lhs.date, lhs.time) < + std::make_tuple(rhs.date, rhs.time); +} +inline bool operator<=(const local_datetime& lhs, const local_datetime& rhs) +{ + return (lhs < rhs) || (lhs == rhs); +} +inline bool operator> (const local_datetime& lhs, const local_datetime& rhs) +{ + return !(lhs <= rhs); +} +inline bool operator>=(const local_datetime& lhs, const local_datetime& rhs) +{ + return !(lhs < rhs); +} + +template +std::basic_ostream& +operator<<(std::basic_ostream& os, const local_datetime& dt) +{ + os << dt.date << 'T' << dt.time; + return os; +} + +struct offset_datetime +{ + local_date date; + local_time time; + time_offset offset; + + offset_datetime(local_date d, local_time t, time_offset o) + : date(d), time(t), offset(o) + {} + offset_datetime(const local_datetime& dt, time_offset o) + : date(dt.date), time(dt.time), offset(o) + {} + explicit offset_datetime(const local_datetime& ld) + : date(ld.date), time(ld.time), offset(get_local_offset(nullptr)) + // use the current local timezone offset + {} + explicit offset_datetime(const std::chrono::system_clock::time_point& tp) + : offset(0, 0) // use gmtime + { + const auto timet = std::chrono::system_clock::to_time_t(tp); + const auto tm = detail::gmtime_s(&timet); + this->date = local_date(tm); + this->time = local_time(tm); + } + explicit offset_datetime(const std::time_t& t) + : offset(0, 0) // use gmtime + { + const auto tm = detail::gmtime_s(&t); + this->date = local_date(tm); + this->time = local_time(tm); + } + explicit offset_datetime(const std::tm& t) + : offset(0, 0) // assume gmtime + { + this->date = local_date(t); + this->time = local_time(t); + } + + operator std::chrono::system_clock::time_point() const + { + // get date-time + using internal_duration = + typename std::chrono::system_clock::time_point::duration; + + // first, convert it to local date-time information in the same way as + // local_datetime does. later we will use time_t to adjust time offset. + std::tm t; + t.tm_sec = static_cast(this->time.second); + t.tm_min = static_cast(this->time.minute); + t.tm_hour = static_cast(this->time.hour); + t.tm_mday = static_cast(this->date.day); + t.tm_mon = static_cast(this->date.month); + t.tm_year = static_cast(this->date.year) - 1900; + t.tm_wday = 0; // the value will be ignored + t.tm_yday = 0; // the value will be ignored + t.tm_isdst = -1; + const std::time_t tp_loc = std::mktime(std::addressof(t)); + + auto tp = std::chrono::system_clock::from_time_t(tp_loc); + tp += std::chrono::duration_cast( + std::chrono::milliseconds(this->time.millisecond) + + std::chrono::microseconds(this->time.microsecond) + + std::chrono::nanoseconds (this->time.nanosecond)); + + // Since mktime uses local time zone, it should be corrected. + // `12:00:00+09:00` means `03:00:00Z`. So mktime returns `03:00:00Z` if + // we are in `+09:00` timezone. To represent `12:00:00Z` there, we need + // to add `+09:00` to `03:00:00Z`. + // Here, it uses the time_t converted from date-time info to handle + // daylight saving time. + const auto ofs = get_local_offset(std::addressof(tp_loc)); + tp += std::chrono::hours (ofs.hour); + tp += std::chrono::minutes(ofs.minute); + + // We got `12:00:00Z` by correcting local timezone applied by mktime. + // Then we will apply the offset. Let's say `12:00:00-08:00` is given. + // And now, we have `12:00:00Z`. `12:00:00-08:00` means `20:00:00Z`. + // So we need to subtract the offset. + tp -= std::chrono::minutes(this->offset); + return tp; + } + + operator std::time_t() const + { + return std::chrono::system_clock::to_time_t( + std::chrono::system_clock::time_point(*this)); + } + + offset_datetime() = default; + ~offset_datetime() = default; + offset_datetime(offset_datetime const&) = default; + offset_datetime(offset_datetime&&) = default; + offset_datetime& operator=(offset_datetime const&) = default; + offset_datetime& operator=(offset_datetime&&) = default; + + private: + + static time_offset get_local_offset(const std::time_t* tp) + { + // get local timezone with the same date-time information as mktime + const auto t = detail::localtime_s(tp); + + std::array buf; + const auto result = std::strftime(buf.data(), 6, "%z", &t); // +hhmm\0 + if(result != 5) + { + throw std::runtime_error("toml::offset_datetime: cannot obtain " + "timezone information of current env"); + } + const int ofs = std::atoi(buf.data()); + const int ofs_h = ofs / 100; + const int ofs_m = ofs - (ofs_h * 100); + return time_offset(ofs_h, ofs_m); + } +}; + +inline bool operator==(const offset_datetime& lhs, const offset_datetime& rhs) +{ + return std::make_tuple(lhs.date, lhs.time, lhs.offset) == + std::make_tuple(rhs.date, rhs.time, rhs.offset); +} +inline bool operator!=(const offset_datetime& lhs, const offset_datetime& rhs) +{ + return !(lhs == rhs); +} +inline bool operator< (const offset_datetime& lhs, const offset_datetime& rhs) +{ + return std::make_tuple(lhs.date, lhs.time, lhs.offset) < + std::make_tuple(rhs.date, rhs.time, rhs.offset); +} +inline bool operator<=(const offset_datetime& lhs, const offset_datetime& rhs) +{ + return (lhs < rhs) || (lhs == rhs); +} +inline bool operator> (const offset_datetime& lhs, const offset_datetime& rhs) +{ + return !(lhs <= rhs); +} +inline bool operator>=(const offset_datetime& lhs, const offset_datetime& rhs) +{ + return !(lhs < rhs); +} + +template +std::basic_ostream& +operator<<(std::basic_ostream& os, const offset_datetime& dt) +{ + os << dt.date << 'T' << dt.time << dt.offset; + return os; +} + +}//toml +#endif// TOML11_DATETIME diff --git a/libraries/toml11/include/toml/exception.hpp b/libraries/toml11/include/toml/exception.hpp new file mode 100644 index 00000000..c64651d0 --- /dev/null +++ b/libraries/toml11/include/toml/exception.hpp @@ -0,0 +1,65 @@ +// Copyright Toru Niina 2017. +// Distributed under the MIT License. +#ifndef TOML11_EXCEPTION_HPP +#define TOML11_EXCEPTION_HPP +#include +#include + +#include "source_location.hpp" + +namespace toml +{ + +struct exception : public std::exception +{ + public: + explicit exception(const source_location& loc): loc_(loc) {} + virtual ~exception() noexcept override = default; + virtual const char* what() const noexcept override {return "";} + virtual source_location const& location() const noexcept {return loc_;} + + protected: + source_location loc_; +}; + +struct syntax_error : public toml::exception +{ + public: + explicit syntax_error(const std::string& what_arg, const source_location& loc) + : exception(loc), what_(what_arg) + {} + virtual ~syntax_error() noexcept override = default; + virtual const char* what() const noexcept override {return what_.c_str();} + + protected: + std::string what_; +}; + +struct type_error : public toml::exception +{ + public: + explicit type_error(const std::string& what_arg, const source_location& loc) + : exception(loc), what_(what_arg) + {} + virtual ~type_error() noexcept override = default; + virtual const char* what() const noexcept override {return what_.c_str();} + + protected: + std::string what_; +}; + +struct internal_error : public toml::exception +{ + public: + explicit internal_error(const std::string& what_arg, const source_location& loc) + : exception(loc), what_(what_arg) + {} + virtual ~internal_error() noexcept override = default; + virtual const char* what() const noexcept override {return what_.c_str();} + + protected: + std::string what_; +}; + +} // toml +#endif // TOML_EXCEPTION diff --git a/libraries/toml11/include/toml/from.hpp b/libraries/toml11/include/toml/from.hpp new file mode 100644 index 00000000..8251973a --- /dev/null +++ b/libraries/toml11/include/toml/from.hpp @@ -0,0 +1,20 @@ +// Copyright Toru Niina 2019. +// Distributed under the MIT License. +#ifndef TOML11_FROM_HPP +#define TOML11_FROM_HPP +#include "traits.hpp" + +namespace toml +{ + +template +struct from; +// { +// static T from_toml(const toml::value& v) +// { +// // User-defined conversions ... +// } +// }; + +} // toml +#endif // TOML11_FROM_HPP diff --git a/libraries/toml11/include/toml/get.hpp b/libraries/toml11/include/toml/get.hpp new file mode 100644 index 00000000..5095caf2 --- /dev/null +++ b/libraries/toml11/include/toml/get.hpp @@ -0,0 +1,1068 @@ +// Copyright Toru Niina 2017. +// Distributed under the MIT License. +#ifndef TOML11_GET_HPP +#define TOML11_GET_HPP +#include + +#include "from.hpp" +#include "result.hpp" +#include "value.hpp" + +namespace toml +{ + +// ============================================================================ +// exact toml::* type + +template class M, template class V> +detail::enable_if_t>::value, T> & +get(basic_value& v) +{ + return v.template cast>::value>(); +} + +template class M, template class V> +detail::enable_if_t>::value, T> const& +get(const basic_value& v) +{ + return v.template cast>::value>(); +} + +template class M, template class V> +detail::enable_if_t>::value, T> +get(basic_value&& v) +{ + return T(std::move(v).template cast>::value>()); +} + +// ============================================================================ +// T == toml::value; identity transformation. + +template class M, template class V> +inline detail::enable_if_t>::value, T>& +get(basic_value& v) +{ + return v; +} + +template class M, template class V> +inline detail::enable_if_t>::value, T> const& +get(const basic_value& v) +{ + return v; +} + +template class M, template class V> +inline detail::enable_if_t>::value, T> +get(basic_value&& v) +{ + return basic_value(std::move(v)); +} + +// ============================================================================ +// T == toml::basic_value; basic_value -> basic_value + +template class M, template class V> +inline detail::enable_if_t, + detail::negation>> + >::value, T> +get(const basic_value& v) +{ + return T(v); +} + +// ============================================================================ +// integer convertible from toml::Integer + +template class M, template class V> +inline detail::enable_if_t, // T is integral + detail::negation>, // but not bool + detail::negation< // but not toml::integer + detail::is_exact_toml_type>> + >::value, T> +get(const basic_value& v) +{ + return static_cast(v.as_integer()); +} + +// ============================================================================ +// floating point convertible from toml::Float + +template class M, template class V> +inline detail::enable_if_t, // T is floating_point + detail::negation< // but not toml::floating + detail::is_exact_toml_type>> + >::value, T> +get(const basic_value& v) +{ + return static_cast(v.as_floating()); +} + +// ============================================================================ +// std::string; toml uses its own toml::string, but it should be convertible to +// std::string seamlessly + +template class M, template class V> +inline detail::enable_if_t::value, std::string>& +get(basic_value& v) +{ + return v.as_string().str; +} + +template class M, template class V> +inline detail::enable_if_t::value, std::string> const& +get(const basic_value& v) +{ + return v.as_string().str; +} + +template class M, template class V> +inline detail::enable_if_t::value, std::string> +get(basic_value&& v) +{ + return std::string(std::move(v.as_string().str)); +} + +// ============================================================================ +// std::string_view + +#if __cplusplus >= 201703L +template class M, template class V> +inline detail::enable_if_t::value, std::string_view> +get(const basic_value& v) +{ + return std::string_view(v.as_string().str); +} +#endif + +// ============================================================================ +// std::chrono::duration from toml::local_time. + +template class M, template class V> +inline detail::enable_if_t::value, T> +get(const basic_value& v) +{ + return std::chrono::duration_cast( + std::chrono::nanoseconds(v.as_local_time())); +} + +// ============================================================================ +// std::chrono::system_clock::time_point from toml::datetime variants + +template class M, template class V> +inline detail::enable_if_t< + std::is_same::value, T> +get(const basic_value& v) +{ + switch(v.type()) + { + case value_t::local_date: + { + return std::chrono::system_clock::time_point(v.as_local_date()); + } + case value_t::local_datetime: + { + return std::chrono::system_clock::time_point(v.as_local_datetime()); + } + case value_t::offset_datetime: + { + return std::chrono::system_clock::time_point(v.as_offset_datetime()); + } + default: + { + throw type_error(detail::format_underline("toml::value: " + "bad_cast to std::chrono::system_clock::time_point", { + {v.location(), concat_to_string("the actual type is ", v.type())} + }), v.location()); + } + } +} + +// ============================================================================ +// forward declaration to use this recursively. ignore this and go ahead. + +// array-like type with push_back(value) method +template class M, template class V> +detail::enable_if_t, // T is a container + detail::has_push_back_method, // T::push_back(value) works + detail::negation< // but not toml::array + detail::is_exact_toml_type>> + >::value, T> +get(const basic_value&); + +// array-like type without push_back(value) method +template class M, template class V> +detail::enable_if_t, // T is a container + detail::negation>, // w/o push_back(...) + detail::negation< // not toml::array + detail::is_exact_toml_type>> + >::value, T> +get(const basic_value&); + +// std::pair +template class M, template class V> +detail::enable_if_t::value, T> +get(const basic_value&); + +// std::tuple +template class M, template class V> +detail::enable_if_t::value, T> +get(const basic_value&); + +// map-like classes +template class M, template class V> +detail::enable_if_t, // T is map + detail::negation< // but not toml::table + detail::is_exact_toml_type>> + >::value, T> +get(const basic_value&); + +// T.from_toml(v) +template class M, template class V> +detail::enable_if_t>>, + detail::has_from_toml_method, // but has from_toml(toml::value) + std::is_default_constructible // and default constructible + >::value, T> +get(const basic_value&); + +// toml::from::from_toml(v) +template class M, template class V, + std::size_t S = sizeof(::toml::from)> +T get(const basic_value&); + +// T(const toml::value&) and T is not toml::basic_value +template class M, template class V> +detail::enable_if_t>, + std::is_constructible&> + >::value, T> +get(const basic_value&); + +// ============================================================================ +// array-like types; most likely STL container, like std::vector, etc. + +template class M, template class V> +detail::enable_if_t, // T is a container + detail::has_push_back_method, // container.push_back(elem) works + detail::negation< // but not toml::array + detail::is_exact_toml_type>> + >::value, T> +get(const basic_value& v) +{ + using value_type = typename T::value_type; + const auto& ary = v.as_array(); + + T container; + try_reserve(container, ary.size()); + + for(const auto& elem : ary) + { + container.push_back(get(elem)); + } + return container; +} + +// ============================================================================ +// std::forward_list does not have push_back, insert, or emplace. +// It has insert_after, emplace_after, push_front. + +template class M, template class V> +detail::enable_if_t::value, T> +get(const basic_value& v) +{ + using value_type = typename T::value_type; + T container; + for(const auto& elem : v.as_array()) + { + container.push_front(get(elem)); + } + container.reverse(); + return container; +} + +// ============================================================================ +// array-like types, without push_back(). most likely [std|boost]::array. + +template class M, template class V> +detail::enable_if_t, // T is a container + detail::negation>, // w/o push_back + detail::negation< // T is not toml::array + detail::is_exact_toml_type>> + >::value, T> +get(const basic_value& v) +{ + using value_type = typename T::value_type; + const auto& ar = v.as_array(); + + T container; + if(ar.size() != container.size()) + { + throw std::out_of_range(detail::format_underline(concat_to_string( + "toml::get: specified container size is ", container.size(), + " but there are ", ar.size(), " elements in toml array."), { + {v.location(), "here"} + })); + } + for(std::size_t i=0; i(ar[i]); + } + return container; +} + +// ============================================================================ +// std::pair. + +template class M, template class V> +detail::enable_if_t::value, T> +get(const basic_value& v) +{ + using first_type = typename T::first_type; + using second_type = typename T::second_type; + + const auto& ar = v.as_array(); + if(ar.size() != 2) + { + throw std::out_of_range(detail::format_underline(concat_to_string( + "toml::get: specified std::pair but there are ", ar.size(), + " elements in toml array."), {{v.location(), "here"}})); + } + return std::make_pair(::toml::get(ar.at(0)), + ::toml::get(ar.at(1))); +} + +// ============================================================================ +// std::tuple. + +namespace detail +{ +template +T get_tuple_impl(const Array& a, index_sequence) +{ + return std::make_tuple( + ::toml::get::type>(a.at(I))...); +} +} // detail + +template class M, template class V> +detail::enable_if_t::value, T> +get(const basic_value& v) +{ + const auto& ar = v.as_array(); + if(ar.size() != std::tuple_size::value) + { + throw std::out_of_range(detail::format_underline(concat_to_string( + "toml::get: specified std::tuple with ", + std::tuple_size::value, " elements, but there are ", ar.size(), + " elements in toml array."), {{v.location(), "here"}})); + } + return detail::get_tuple_impl(ar, + detail::make_index_sequence::value>{}); +} + +// ============================================================================ +// map-like types; most likely STL map, like std::map or std::unordered_map. + +template class M, template class V> +detail::enable_if_t, // T is map + detail::negation< // but not toml::array + detail::is_exact_toml_type>> + >::value, T> +get(const basic_value& v) +{ + using key_type = typename T::key_type; + using mapped_type = typename T::mapped_type; + static_assert(std::is_convertible::value, + "toml::get only supports map type of which key_type is " + "convertible from std::string."); + T map; + for(const auto& kv : v.as_table()) + { + map.emplace(key_type(kv.first), get(kv.second)); + } + return map; +} + +// ============================================================================ +// user-defined, but compatible types. + +template class M, template class V> +detail::enable_if_t>>, + detail::has_from_toml_method, // but has from_toml(toml::value) memfn + std::is_default_constructible // and default constructible + >::value, T> +get(const basic_value& v) +{ + T ud; + ud.from_toml(v); + return ud; +} +template class M, template class V, + std::size_t> +T get(const basic_value& v) +{ + return ::toml::from::from_toml(v); +} + +template class M, template class V> +detail::enable_if_t>, + std::is_constructible&> + >::value, T> +get(const basic_value& v) +{ + return T(v); +} + +// ============================================================================ +// find + +// ---------------------------------------------------------------------------- +// these overloads do not require to set T. and returns value itself. +template class M, template class V> +basic_value const& find(const basic_value& v, const key& ky) +{ + const auto& tab = v.as_table(); + if(tab.count(ky) == 0) + { + detail::throw_key_not_found_error(v, ky); + } + return tab.at(ky); +} +template class M, template class V> +basic_value& find(basic_value& v, const key& ky) +{ + auto& tab = v.as_table(); + if(tab.count(ky) == 0) + { + detail::throw_key_not_found_error(v, ky); + } + return tab.at(ky); +} +template class M, template class V> +basic_value find(basic_value&& v, const key& ky) +{ + typename basic_value::table_type tab = std::move(v).as_table(); + if(tab.count(ky) == 0) + { + detail::throw_key_not_found_error(v, ky); + } + return basic_value(std::move(tab.at(ky))); +} + +// ---------------------------------------------------------------------------- +// find(value, idx) +template class M, template class V> +basic_value const& +find(const basic_value& v, const std::size_t idx) +{ + const auto& ary = v.as_array(); + if(ary.size() <= idx) + { + throw std::out_of_range(detail::format_underline(concat_to_string( + "index ", idx, " is out of range"), {{v.location(), "in this array"}})); + } + return ary.at(idx); +} +template class M, template class V> +basic_value& find(basic_value& v, const std::size_t idx) +{ + auto& ary = v.as_array(); + if(ary.size() <= idx) + { + throw std::out_of_range(detail::format_underline(concat_to_string( + "index ", idx, " is out of range"), {{v.location(), "in this array"}})); + } + return ary.at(idx); +} +template class M, template class V> +basic_value find(basic_value&& v, const std::size_t idx) +{ + auto& ary = v.as_array(); + if(ary.size() <= idx) + { + throw std::out_of_range(detail::format_underline(concat_to_string( + "index ", idx, " is out of range"), {{v.location(), "in this array"}})); + } + return basic_value(std::move(ary.at(idx))); +} + +// ---------------------------------------------------------------------------- +// find(value, key); + +template class M, template class V> +decltype(::toml::get(std::declval const&>())) +find(const basic_value& v, const key& ky) +{ + const auto& tab = v.as_table(); + if(tab.count(ky) == 0) + { + detail::throw_key_not_found_error(v, ky); + } + return ::toml::get(tab.at(ky)); +} + +template class M, template class V> +decltype(::toml::get(std::declval&>())) +find(basic_value& v, const key& ky) +{ + auto& tab = v.as_table(); + if(tab.count(ky) == 0) + { + detail::throw_key_not_found_error(v, ky); + } + return ::toml::get(tab.at(ky)); +} + +template class M, template class V> +decltype(::toml::get(std::declval&&>())) +find(basic_value&& v, const key& ky) +{ + typename basic_value::table_type tab = std::move(v).as_table(); + if(tab.count(ky) == 0) + { + detail::throw_key_not_found_error(v, ky); + } + return ::toml::get(std::move(tab.at(ky))); +} + +// ---------------------------------------------------------------------------- +// find(value, idx) +template class M, template class V> +decltype(::toml::get(std::declval const&>())) +find(const basic_value& v, const std::size_t idx) +{ + const auto& ary = v.as_array(); + if(ary.size() <= idx) + { + throw std::out_of_range(detail::format_underline(concat_to_string( + "index ", idx, " is out of range"), {{v.location(), "in this array"}})); + } + return ::toml::get(ary.at(idx)); +} +template class M, template class V> +decltype(::toml::get(std::declval&>())) +find(basic_value& v, const std::size_t idx) +{ + auto& ary = v.as_array(); + if(ary.size() <= idx) + { + throw std::out_of_range(detail::format_underline(concat_to_string( + "index ", idx, " is out of range"), {{v.location(), "in this array"}})); + } + return ::toml::get(ary.at(idx)); +} +template class M, template class V> +decltype(::toml::get(std::declval&&>())) +find(basic_value&& v, const std::size_t idx) +{ + typename basic_value::array_type ary = std::move(v).as_array(); + if(ary.size() <= idx) + { + throw std::out_of_range(detail::format_underline(concat_to_string( + "index ", idx, " is out of range"), {{v.location(), "in this array"}})); + } + return ::toml::get(std::move(ary.at(idx))); +} + +// -------------------------------------------------------------------------- +// toml::find(toml::value, toml::key, Ts&& ... keys) + +namespace detail +{ +// It suppresses warnings by -Wsign-conversion. Let's say we have the following +// code. +// ```cpp +// const auto x = toml::find(data, "array", 0); +// ``` +// Here, the type of literal number `0` is `int`. `int` is a signed integer. +// `toml::find` takes `std::size_t` as an index. So it causes implicit sign +// conversion and `-Wsign-conversion` warns about it. Using `0u` instead of `0` +// suppresses the warning, but it makes user code messy. +// To suppress this warning, we need to be aware of type conversion caused +// by `toml::find(v, key1, key2, ... keys)`. But the thing is that the types of +// keys can be any combination of {string-like, size_t-like}. Of course we can't +// write down all the combinations. Thus we need to use some function that +// recognize the type of argument and cast it into `std::string` or +// `std::size_t` depending on the context. +// `key_cast` does the job. It has 2 overloads. One is invoked when the +// argument type is an integer and cast the argument into `std::size_t`. The +// other is invoked when the argument type is not an integer, possibly one of +// std::string, const char[N] or const char*, and construct std::string from +// the argument. +// `toml::find(v, k1, k2, ... ks)` uses `key_cast` before passing `ks` to +// `toml::find(v, k)` to suppress -Wsign-conversion. + +template +enable_if_t>, + negation, bool>>>::value, std::size_t> +key_cast(T&& v) noexcept +{ + return std::size_t(v); +} +template +enable_if_t>, + negation, bool>>>>::value, std::string> +key_cast(T&& v) noexcept +{ + return std::string(std::forward(v)); +} +} // detail + +template class M, template class V, + typename Key1, typename Key2, typename ... Keys> +const basic_value& +find(const basic_value& v, Key1&& k1, Key2&& k2, Keys&& ... keys) +{ + return ::toml::find(::toml::find(v, detail::key_cast(k1)), + detail::key_cast(k2), std::forward(keys)...); +} +template class M, template class V, + typename Key1, typename Key2, typename ... Keys> +basic_value& +find(basic_value& v, Key1&& k1, Key2&& k2, Keys&& ... keys) +{ + return ::toml::find(::toml::find(v, detail::key_cast(k1)), + detail::key_cast(k2), std::forward(keys)...); +} +template class M, template class V, + typename Key1, typename Key2, typename ... Keys> +basic_value +find(basic_value&& v, Key1&& k1, Key2&& k2, Keys&& ... keys) +{ + return ::toml::find(::toml::find(std::move(v), std::forward(k1)), + detail::key_cast(k2), std::forward(keys)...); +} + +template class M, template class V, + typename Key1, typename Key2, typename ... Keys> +decltype(::toml::get(std::declval&>())) +find(const basic_value& v, Key1&& k1, Key2&& k2, Keys&& ... keys) +{ + return ::toml::find(::toml::find(v, detail::key_cast(k1)), + detail::key_cast(k2), std::forward(keys)...); +} +template class M, template class V, + typename Key1, typename Key2, typename ... Keys> +decltype(::toml::get(std::declval&>())) +find(basic_value& v, Key1&& k1, Key2&& k2, Keys&& ... keys) +{ + return ::toml::find(::toml::find(v, detail::key_cast(k1)), + detail::key_cast(k2), std::forward(keys)...); +} +template class M, template class V, + typename Key1, typename Key2, typename ... Keys> +decltype(::toml::get(std::declval&&>())) +find(basic_value&& v, Key1&& k1, Key2&& k2, Keys&& ... keys) +{ + return ::toml::find(::toml::find(std::move(v), detail::key_cast(k1)), + detail::key_cast(k2), std::forward(keys)...); +} + +// ============================================================================ +// get_or(value, fallback) + +template class M, template class V> +basic_value const& +get_or(const basic_value& v, const basic_value&) +{ + return v; +} +template class M, template class V> +basic_value& +get_or(basic_value& v, basic_value&) +{ + return v; +} +template class M, template class V> +basic_value +get_or(basic_value&& v, basic_value&&) +{ + return v; +} + +// ---------------------------------------------------------------------------- +// specialization for the exact toml types (return type becomes lvalue ref) + +template class M, template class V> +detail::enable_if_t< + detail::is_exact_toml_type>::value, T> const& +get_or(const basic_value& v, const T& opt) +{ + try + { + return get>(v); + } + catch(...) + { + return opt; + } +} +template class M, template class V> +detail::enable_if_t< + detail::is_exact_toml_type>::value, T>& +get_or(basic_value& v, T& opt) +{ + try + { + return get>(v); + } + catch(...) + { + return opt; + } +} +template class M, template class V> +detail::enable_if_t, + basic_value>::value, detail::remove_cvref_t> +get_or(basic_value&& v, T&& opt) +{ + try + { + return get>(std::move(v)); + } + catch(...) + { + return detail::remove_cvref_t(std::forward(opt)); + } +} + +// ---------------------------------------------------------------------------- +// specialization for std::string (return type becomes lvalue ref) + +template class M, template class V> +detail::enable_if_t, std::string>::value, + std::string> const& +get_or(const basic_value& v, const T& opt) +{ + try + { + return v.as_string().str; + } + catch(...) + { + return opt; + } +} +template class M, template class V> +detail::enable_if_t::value, std::string>& +get_or(basic_value& v, T& opt) +{ + try + { + return v.as_string().str; + } + catch(...) + { + return opt; + } +} +template class M, template class V> +detail::enable_if_t< + std::is_same, std::string>::value, std::string> +get_or(basic_value&& v, T&& opt) +{ + try + { + return std::move(v.as_string().str); + } + catch(...) + { + return std::string(std::forward(opt)); + } +} + +// ---------------------------------------------------------------------------- +// specialization for string literal + +template class M, template class V> +detail::enable_if_t::type>::value, std::string> +get_or(const basic_value& v, T&& opt) +{ + try + { + return std::move(v.as_string().str); + } + catch(...) + { + return std::string(std::forward(opt)); + } +} + +// ---------------------------------------------------------------------------- +// others (require type conversion and return type cannot be lvalue reference) + +template class M, template class V> +detail::enable_if_t, + basic_value>>, + detail::negation>>, + detail::negation::type>> + >::value, detail::remove_cvref_t> +get_or(const basic_value& v, T&& opt) +{ + try + { + return get>(v); + } + catch(...) + { + return detail::remove_cvref_t(std::forward(opt)); + } +} + +// =========================================================================== +// find_or(value, key, fallback) + +template class M, template class V> +basic_value const& +find_or(const basic_value& v, const key& ky, + const basic_value& opt) +{ + if(!v.is_table()) {return opt;} + const auto& tab = v.as_table(); + if(tab.count(ky) == 0) {return opt;} + return tab.at(ky); +} + +template class M, template class V> +basic_value& +find_or(basic_value& v, const toml::key& ky, basic_value& opt) +{ + if(!v.is_table()) {return opt;} + auto& tab = v.as_table(); + if(tab.count(ky) == 0) {return opt;} + return tab.at(ky); +} + +template class M, template class V> +basic_value +find_or(basic_value&& v, const toml::key& ky, basic_value&& opt) +{ + if(!v.is_table()) {return opt;} + auto tab = std::move(v).as_table(); + if(tab.count(ky) == 0) {return opt;} + return basic_value(std::move(tab.at(ky))); +} + +// --------------------------------------------------------------------------- +// exact types (return type can be a reference) +template class M, template class V> +detail::enable_if_t< + detail::is_exact_toml_type>::value, T> const& +find_or(const basic_value& v, const key& ky, const T& opt) +{ + if(!v.is_table()) {return opt;} + const auto& tab = v.as_table(); + if(tab.count(ky) == 0) {return opt;} + return get_or(tab.at(ky), opt); +} + +template class M, template class V> +detail::enable_if_t< + detail::is_exact_toml_type>::value, T>& +find_or(basic_value& v, const toml::key& ky, T& opt) +{ + if(!v.is_table()) {return opt;} + auto& tab = v.as_table(); + if(tab.count(ky) == 0) {return opt;} + return get_or(tab.at(ky), opt); +} + +template class M, template class V> +detail::enable_if_t< + detail::is_exact_toml_type>::value, + detail::remove_cvref_t> +find_or(basic_value&& v, const toml::key& ky, T&& opt) +{ + if(!v.is_table()) {return std::forward(opt);} + auto tab = std::move(v).as_table(); + if(tab.count(ky) == 0) {return std::forward(opt);} + return get_or(std::move(tab.at(ky)), std::forward(opt)); +} + +// --------------------------------------------------------------------------- +// std::string (return type can be a reference) + +template class M, template class V> +detail::enable_if_t::value, std::string> const& +find_or(const basic_value& v, const key& ky, const T& opt) +{ + if(!v.is_table()) {return opt;} + const auto& tab = v.as_table(); + if(tab.count(ky) == 0) {return opt;} + return get_or(tab.at(ky), opt); +} +template class M, template class V> +detail::enable_if_t::value, std::string>& +find_or(basic_value& v, const toml::key& ky, T& opt) +{ + if(!v.is_table()) {return opt;} + auto& tab = v.as_table(); + if(tab.count(ky) == 0) {return opt;} + return get_or(tab.at(ky), opt); +} +template class M, template class V> +detail::enable_if_t::value, std::string> +find_or(basic_value&& v, const toml::key& ky, T&& opt) +{ + if(!v.is_table()) {return std::forward(opt);} + auto tab = std::move(v).as_table(); + if(tab.count(ky) == 0) {return std::forward(opt);} + return get_or(std::move(tab.at(ky)), std::forward(opt)); +} + +// --------------------------------------------------------------------------- +// string literal (deduced as std::string) +template class M, template class V> +detail::enable_if_t< + detail::is_string_literal::type>::value, + std::string> +find_or(const basic_value& v, const toml::key& ky, T&& opt) +{ + if(!v.is_table()) {return std::string(opt);} + const auto& tab = v.as_table(); + if(tab.count(ky) == 0) {return std::string(opt);} + return get_or(tab.at(ky), std::forward(opt)); +} + +// --------------------------------------------------------------------------- +// others (require type conversion and return type cannot be lvalue reference) +template class M, template class V> +detail::enable_if_t, basic_value>>, + // T is not std::string + detail::negation>>, + // T is not a string literal + detail::negation::type>> + >::value, detail::remove_cvref_t> +find_or(const basic_value& v, const toml::key& ky, T&& opt) +{ + if(!v.is_table()) {return std::forward(opt);} + const auto& tab = v.as_table(); + if(tab.count(ky) == 0) {return std::forward(opt);} + return get_or(tab.at(ky), std::forward(opt)); +} + +// ============================================================================ +// expect + +template class M, template class V> +result expect(const basic_value& v) noexcept +{ + try + { + return ok(get(v)); + } + catch(const std::exception& e) + { + return err(e.what()); + } +} +template class M, template class V> +result +expect(const basic_value& v, const toml::key& k) noexcept +{ + try + { + return ok(find(v, k)); + } + catch(const std::exception& e) + { + return err(e.what()); + } +} + +} // toml +#endif// TOML11_GET diff --git a/libraries/toml11/include/toml/into.hpp b/libraries/toml11/include/toml/into.hpp new file mode 100644 index 00000000..17f22488 --- /dev/null +++ b/libraries/toml11/include/toml/into.hpp @@ -0,0 +1,20 @@ +// Copyright Toru Niina 2019. +// Distributed under the MIT License. +#ifndef TOML11_INTO_HPP +#define TOML11_INTO_HPP +#include "traits.hpp" + +namespace toml +{ + +template +struct into; +// { +// static toml::value into_toml(const T& user_defined_type) +// { +// // User-defined conversions ... +// } +// }; + +} // toml +#endif // TOML11_INTO_HPP diff --git a/libraries/toml11/include/toml/lexer.hpp b/libraries/toml11/include/toml/lexer.hpp new file mode 100644 index 00000000..2eea996e --- /dev/null +++ b/libraries/toml11/include/toml/lexer.hpp @@ -0,0 +1,270 @@ +// Copyright Toru Niina 2017. +// Distributed under the MIT License. +#ifndef TOML11_LEXER_HPP +#define TOML11_LEXER_HPP +#include +#include +#include +#include + +#include "combinator.hpp" + +namespace toml +{ +namespace detail +{ + +// these scans contents from current location in a container of char +// and extract a region that matches their own pattern. +// to see the implementation of each component, see combinator.hpp. + +using lex_wschar = either, character<'\t'>>; +using lex_ws = repeat>; +using lex_newline = either, + sequence, character<'\n'>>>; +using lex_lower = in_range<'a', 'z'>; +using lex_upper = in_range<'A', 'Z'>; +using lex_alpha = either; +using lex_digit = in_range<'0', '9'>; +using lex_nonzero = in_range<'1', '9'>; +using lex_oct_dig = in_range<'0', '7'>; +using lex_bin_dig = in_range<'0', '1'>; +using lex_hex_dig = either, in_range<'a', 'f'>>; + +using lex_hex_prefix = sequence, character<'x'>>; +using lex_oct_prefix = sequence, character<'o'>>; +using lex_bin_prefix = sequence, character<'b'>>; +using lex_underscore = character<'_'>; +using lex_plus = character<'+'>; +using lex_minus = character<'-'>; +using lex_sign = either; + +// digit | nonzero 1*(digit | _ digit) +using lex_unsigned_dec_int = either>, at_least<1>>>, + lex_digit>; +// (+|-)? unsigned_dec_int +using lex_dec_int = sequence, lex_unsigned_dec_int>; + +// hex_prefix hex_dig *(hex_dig | _ hex_dig) +using lex_hex_int = sequence>, unlimited>>>; +// oct_prefix oct_dig *(oct_dig | _ oct_dig) +using lex_oct_int = sequence>, unlimited>>>; +// bin_prefix bin_dig *(bin_dig | _ bin_dig) +using lex_bin_int = sequence>, unlimited>>>; + +// (dec_int | hex_int | oct_int | bin_int) +using lex_integer = either; + +// =========================================================================== + +using lex_inf = sequence, character<'n'>, character<'f'>>; +using lex_nan = sequence, character<'a'>, character<'n'>>; +using lex_special_float = sequence, either>; + +using lex_zero_prefixable_int = sequence>, unlimited>>; + +using lex_fractional_part = sequence, lex_zero_prefixable_int>; + +using lex_exponent_part = sequence, character<'E'>>, + maybe, lex_zero_prefixable_int>; + +using lex_float = either>>>>; + +// =========================================================================== + +using lex_true = sequence, character<'r'>, + character<'u'>, character<'e'>>; +using lex_false = sequence, character<'a'>, character<'l'>, + character<'s'>, character<'e'>>; +using lex_boolean = either; + +// =========================================================================== + +using lex_date_fullyear = repeat>; +using lex_date_month = repeat>; +using lex_date_mday = repeat>; +using lex_time_delim = either, character<'t'>, character<' '>>; +using lex_time_hour = repeat>; +using lex_time_minute = repeat>; +using lex_time_second = repeat>; +using lex_time_secfrac = sequence, + repeat>>; + +using lex_time_numoffset = sequence, character<'-'>>, + sequence, + lex_time_minute>>; +using lex_time_offset = either, character<'z'>, + lex_time_numoffset>; + +using lex_partial_time = sequence, + lex_time_minute, character<':'>, + lex_time_second, maybe>; +using lex_full_date = sequence, + lex_date_month, character<'-'>, + lex_date_mday>; +using lex_full_time = sequence; + +using lex_offset_date_time = sequence; +using lex_local_date_time = sequence; +using lex_local_date = lex_full_date; +using lex_local_time = lex_partial_time; + +// =========================================================================== + +using lex_quotation_mark = character<'"'>; +using lex_basic_unescaped = exclude, // 0x09 (tab) + in_range<0x0a, 0x1F>, // is allowed + character<0x22>, character<0x5C>, + character<0x7F>>>; + +using lex_escape = character<'\\'>; +using lex_escape_unicode_short = sequence, + repeat>>; +using lex_escape_unicode_long = sequence, + repeat>>; +using lex_escape_seq_char = either, character<'\\'>, + character<'b'>, character<'f'>, + character<'n'>, character<'r'>, + character<'t'>, + lex_escape_unicode_short, + lex_escape_unicode_long + >; +using lex_escaped = sequence; +using lex_basic_char = either; +using lex_basic_string = sequence, + lex_quotation_mark>; + +// After toml post-v0.5.0, it is explicitly clarified how quotes in ml-strings +// are allowed to be used. +// After this, the following strings are *explicitly* allowed. +// - One or two `"`s in a multi-line basic string is allowed wherever it is. +// - Three consecutive `"`s in a multi-line basic string is considered as a delimiter. +// - One or two `"`s can appear just before or after the delimiter. +// ```toml +// str4 = """Here are two quotation marks: "". Simple enough.""" +// str5 = """Here are three quotation marks: ""\".""" +// str6 = """Here are fifteen quotation marks: ""\"""\"""\"""\"""\".""" +// str7 = """"This," she said, "is just a pointless statement."""" +// ``` +// In the current implementation (v3.3.0), it is difficult to parse `str7` in +// the above example. It is difficult to recognize `"` at the end of string body +// collectly. It will be misunderstood as a `"""` delimiter and an additional, +// invalid `"`. Like this: +// ```console +// what(): [error] toml::parse_table: invalid line format +// --> hoge.toml +// | +// 13 | str7 = """"This," she said, "is just a pointless statement."""" +// | ^- expected newline, but got '"'. +// ``` +// As a quick workaround for this problem, `lex_ml_basic_string_delim` was +// splitted into two, `lex_ml_basic_string_open` and `lex_ml_basic_string_close`. +// `lex_ml_basic_string_open` allows only `"""`. `_close` allows 3-5 `"`s. +// In parse_ml_basic_string() function, the trailing `"`s will be attached to +// the string body. +// +using lex_ml_basic_string_delim = repeat>; +using lex_ml_basic_string_open = lex_ml_basic_string_delim; +using lex_ml_basic_string_close = sequence< + repeat>, + maybe, maybe + >; + +using lex_ml_basic_unescaped = exclude, // 0x09 + in_range<0x0a, 0x1F>, // is tab + character<0x5C>, // backslash + character<0x7F>, // DEL + lex_ml_basic_string_delim>>; + +using lex_ml_basic_escaped_newline = sequence< + lex_escape, maybe, lex_newline, + repeat, unlimited>>; + +using lex_ml_basic_char = either; +using lex_ml_basic_body = repeat, + unlimited>; +using lex_ml_basic_string = sequence; + +using lex_literal_char = exclude, + in_range<0x10, 0x19>, character<0x27>>>; +using lex_apostrophe = character<'\''>; +using lex_literal_string = sequence, + lex_apostrophe>; + +// the same reason as above. +using lex_ml_literal_string_delim = repeat>; +using lex_ml_literal_string_open = lex_ml_literal_string_delim; +using lex_ml_literal_string_close = sequence< + repeat>, + maybe, maybe + >; + +using lex_ml_literal_char = exclude, + in_range<0x10, 0x1F>, + character<0x7F>, + lex_ml_literal_string_delim>>; +using lex_ml_literal_body = repeat, + unlimited>; +using lex_ml_literal_string = sequence; + +using lex_string = either; + +// =========================================================================== + +using lex_comment_start_symbol = character<'#'>; +using lex_non_eol = either, exclude>>; +using lex_comment = sequence>; + +using lex_dot_sep = sequence, character<'.'>, maybe>; + +using lex_unquoted_key = repeat, character<'_'>>, + at_least<1>>; +using lex_quoted_key = either; +using lex_simple_key = either; +using lex_dotted_key = sequence, + at_least<1> + > + >; +using lex_key = either; + +using lex_keyval_sep = sequence, + character<'='>, + maybe>; + +using lex_std_table_open = character<'['>; +using lex_std_table_close = character<']'>; +using lex_std_table = sequence, + lex_key, + maybe, + lex_std_table_close>; + +using lex_array_table_open = sequence; +using lex_array_table_close = sequence; +using lex_array_table = sequence, + lex_key, + maybe, + lex_array_table_close>; + +} // detail +} // toml +#endif // TOML_LEXER_HPP diff --git a/libraries/toml11/include/toml/literal.hpp b/libraries/toml11/include/toml/literal.hpp new file mode 100644 index 00000000..0824f838 --- /dev/null +++ b/libraries/toml11/include/toml/literal.hpp @@ -0,0 +1,112 @@ +// Copyright Toru Niina 2019. +// Distributed under the MIT License. +#ifndef TOML11_LITERAL_HPP +#define TOML11_LITERAL_HPP +#include "parser.hpp" + +namespace toml +{ +inline namespace literals +{ +inline namespace toml_literals +{ + +// implementation +inline ::toml::basic_value<::toml::discard_comments, std::unordered_map, std::vector> +literal_internal_impl(::toml::detail::location loc) +{ + using value_type = ::toml::basic_value< + ::toml::discard_comments, std::unordered_map, std::vector>; + // if there are some comments or empty lines, skip them. + using skip_line = ::toml::detail::repeat, + ::toml::detail::maybe<::toml::detail::lex_comment>, + ::toml::detail::lex_newline + >, ::toml::detail::at_least<1>>; + skip_line::invoke(loc); + + // if there are some whitespaces before a value, skip them. + using skip_ws = ::toml::detail::repeat< + ::toml::detail::lex_ws, ::toml::detail::at_least<1>>; + skip_ws::invoke(loc); + + // to distinguish arrays and tables, first check it is a table or not. + // + // "[1,2,3]"_toml; // this is an array + // "[table]"_toml; // a table that has an empty table named "table" inside. + // "[[1,2,3]]"_toml; // this is an array of arrays + // "[[table]]"_toml; // this is a table that has an array of tables inside. + // + // "[[1]]"_toml; // this can be both... (currently it becomes a table) + // "1 = [{}]"_toml; // this is a table that has an array of table named 1. + // "[[1,]]"_toml; // this is an array of arrays. + // "[[1],]"_toml; // this also. + + const auto the_front = loc.iter(); + + const bool is_table_key = ::toml::detail::lex_std_table::invoke(loc); + loc.reset(the_front); + + const bool is_aots_key = ::toml::detail::lex_array_table::invoke(loc); + loc.reset(the_front); + + // If it is neither a table-key or a array-of-table-key, it may be a value. + if(!is_table_key && !is_aots_key) + { + if(auto data = ::toml::detail::parse_value(loc)) + { + return data.unwrap(); + } + } + + // Note that still it can be a table, because the literal might be something + // like the following. + // ```cpp + // R"( // c++11 raw string literals + // key = "value" + // int = 42 + // )"_toml; + // ``` + // It is a valid toml file. + // It should be parsed as if we parse a file with this content. + + if(auto data = ::toml::detail::parse_toml_file(loc)) + { + return data.unwrap(); + } + else // none of them. + { + throw ::toml::syntax_error(data.unwrap_err(), source_location(loc)); + } + +} + +inline ::toml::basic_value<::toml::discard_comments, std::unordered_map, std::vector> +operator"" _toml(const char* str, std::size_t len) +{ + ::toml::detail::location loc( + std::string("TOML literal encoded in a C++ code"), + std::vector(str, str + len)); + return literal_internal_impl(std::move(loc)); +} + +// value of __cplusplus in C++2a/20 mode is not fixed yet along compilers. +// So here we use the feature test macro for `char8_t` itself. +#if defined(__cpp_char8_t) && __cpp_char8_t >= 201811L +// value of u8"" literal has been changed from char to char8_t and char8_t is +// NOT compatible to char +inline ::toml::basic_value<::toml::discard_comments, std::unordered_map, std::vector> +operator"" _toml(const char8_t* str, std::size_t len) +{ + ::toml::detail::location loc( + std::string("TOML literal encoded in a C++ code"), + std::vector(reinterpret_cast(str), + reinterpret_cast(str) + len)); + return literal_internal_impl(std::move(loc)); +} +#endif + +} // toml_literals +} // literals +} // toml +#endif//TOML11_LITERAL_HPP diff --git a/libraries/toml11/include/toml/macros.hpp b/libraries/toml11/include/toml/macros.hpp new file mode 100644 index 00000000..e8f91aec --- /dev/null +++ b/libraries/toml11/include/toml/macros.hpp @@ -0,0 +1,121 @@ +#ifndef TOML11_MACROS_HPP +#define TOML11_MACROS_HPP + +#define TOML11_STRINGIZE_AUX(x) #x +#define TOML11_STRINGIZE(x) TOML11_STRINGIZE_AUX(x) + +#define TOML11_CONCATENATE_AUX(x, y) x##y +#define TOML11_CONCATENATE(x, y) TOML11_CONCATENATE_AUX(x, y) + +// ============================================================================ +// TOML11_DEFINE_CONVERSION_NON_INTRUSIVE + +#ifndef TOML11_WITHOUT_DEFINE_NON_INTRUSIVE + +// ---------------------------------------------------------------------------- +// TOML11_ARGS_SIZE + +#define TOML11_INDEX_RSEQ() \ + 32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, \ + 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 +#define TOML11_ARGS_SIZE_IMPL(\ + ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7, ARG8, ARG9, ARG10, \ + ARG11, ARG12, ARG13, ARG14, ARG15, ARG16, ARG17, ARG18, ARG19, ARG20, \ + ARG21, ARG22, ARG23, ARG24, ARG25, ARG26, ARG27, ARG28, ARG29, ARG30, \ + ARG31, ARG32, N, ...) N +#define TOML11_ARGS_SIZE_AUX(...) TOML11_ARGS_SIZE_IMPL(__VA_ARGS__) +#define TOML11_ARGS_SIZE(...) TOML11_ARGS_SIZE_AUX(__VA_ARGS__, TOML11_INDEX_RSEQ()) + +// ---------------------------------------------------------------------------- +// TOML11_FOR_EACH_VA_ARGS + +#define TOML11_FOR_EACH_VA_ARGS_AUX_1( FUNCTOR, ARG1 ) FUNCTOR(ARG1) +#define TOML11_FOR_EACH_VA_ARGS_AUX_2( FUNCTOR, ARG1, ...) FUNCTOR(ARG1) TOML11_FOR_EACH_VA_ARGS_AUX_1( FUNCTOR, __VA_ARGS__) +#define TOML11_FOR_EACH_VA_ARGS_AUX_3( FUNCTOR, ARG1, ...) FUNCTOR(ARG1) TOML11_FOR_EACH_VA_ARGS_AUX_2( FUNCTOR, __VA_ARGS__) +#define TOML11_FOR_EACH_VA_ARGS_AUX_4( FUNCTOR, ARG1, ...) FUNCTOR(ARG1) TOML11_FOR_EACH_VA_ARGS_AUX_3( FUNCTOR, __VA_ARGS__) +#define TOML11_FOR_EACH_VA_ARGS_AUX_5( FUNCTOR, ARG1, ...) FUNCTOR(ARG1) TOML11_FOR_EACH_VA_ARGS_AUX_4( FUNCTOR, __VA_ARGS__) +#define TOML11_FOR_EACH_VA_ARGS_AUX_6( FUNCTOR, ARG1, ...) FUNCTOR(ARG1) TOML11_FOR_EACH_VA_ARGS_AUX_5( FUNCTOR, __VA_ARGS__) +#define TOML11_FOR_EACH_VA_ARGS_AUX_7( FUNCTOR, ARG1, ...) FUNCTOR(ARG1) TOML11_FOR_EACH_VA_ARGS_AUX_6( FUNCTOR, __VA_ARGS__) +#define TOML11_FOR_EACH_VA_ARGS_AUX_8( FUNCTOR, ARG1, ...) FUNCTOR(ARG1) TOML11_FOR_EACH_VA_ARGS_AUX_7( FUNCTOR, __VA_ARGS__) +#define TOML11_FOR_EACH_VA_ARGS_AUX_9( FUNCTOR, ARG1, ...) FUNCTOR(ARG1) TOML11_FOR_EACH_VA_ARGS_AUX_8( FUNCTOR, __VA_ARGS__) +#define TOML11_FOR_EACH_VA_ARGS_AUX_10(FUNCTOR, ARG1, ...) FUNCTOR(ARG1) TOML11_FOR_EACH_VA_ARGS_AUX_9( FUNCTOR, __VA_ARGS__) +#define TOML11_FOR_EACH_VA_ARGS_AUX_11(FUNCTOR, ARG1, ...) FUNCTOR(ARG1) TOML11_FOR_EACH_VA_ARGS_AUX_10(FUNCTOR, __VA_ARGS__) +#define TOML11_FOR_EACH_VA_ARGS_AUX_12(FUNCTOR, ARG1, ...) FUNCTOR(ARG1) TOML11_FOR_EACH_VA_ARGS_AUX_11(FUNCTOR, __VA_ARGS__) +#define TOML11_FOR_EACH_VA_ARGS_AUX_13(FUNCTOR, ARG1, ...) FUNCTOR(ARG1) TOML11_FOR_EACH_VA_ARGS_AUX_12(FUNCTOR, __VA_ARGS__) +#define TOML11_FOR_EACH_VA_ARGS_AUX_14(FUNCTOR, ARG1, ...) FUNCTOR(ARG1) TOML11_FOR_EACH_VA_ARGS_AUX_13(FUNCTOR, __VA_ARGS__) +#define TOML11_FOR_EACH_VA_ARGS_AUX_15(FUNCTOR, ARG1, ...) FUNCTOR(ARG1) TOML11_FOR_EACH_VA_ARGS_AUX_14(FUNCTOR, __VA_ARGS__) +#define TOML11_FOR_EACH_VA_ARGS_AUX_16(FUNCTOR, ARG1, ...) FUNCTOR(ARG1) TOML11_FOR_EACH_VA_ARGS_AUX_15(FUNCTOR, __VA_ARGS__) +#define TOML11_FOR_EACH_VA_ARGS_AUX_17(FUNCTOR, ARG1, ...) FUNCTOR(ARG1) TOML11_FOR_EACH_VA_ARGS_AUX_16(FUNCTOR, __VA_ARGS__) +#define TOML11_FOR_EACH_VA_ARGS_AUX_18(FUNCTOR, ARG1, ...) FUNCTOR(ARG1) TOML11_FOR_EACH_VA_ARGS_AUX_17(FUNCTOR, __VA_ARGS__) +#define TOML11_FOR_EACH_VA_ARGS_AUX_19(FUNCTOR, ARG1, ...) FUNCTOR(ARG1) TOML11_FOR_EACH_VA_ARGS_AUX_18(FUNCTOR, __VA_ARGS__) +#define TOML11_FOR_EACH_VA_ARGS_AUX_20(FUNCTOR, ARG1, ...) FUNCTOR(ARG1) TOML11_FOR_EACH_VA_ARGS_AUX_19(FUNCTOR, __VA_ARGS__) +#define TOML11_FOR_EACH_VA_ARGS_AUX_21(FUNCTOR, ARG1, ...) FUNCTOR(ARG1) TOML11_FOR_EACH_VA_ARGS_AUX_20(FUNCTOR, __VA_ARGS__) +#define TOML11_FOR_EACH_VA_ARGS_AUX_22(FUNCTOR, ARG1, ...) FUNCTOR(ARG1) TOML11_FOR_EACH_VA_ARGS_AUX_21(FUNCTOR, __VA_ARGS__) +#define TOML11_FOR_EACH_VA_ARGS_AUX_23(FUNCTOR, ARG1, ...) FUNCTOR(ARG1) TOML11_FOR_EACH_VA_ARGS_AUX_22(FUNCTOR, __VA_ARGS__) +#define TOML11_FOR_EACH_VA_ARGS_AUX_24(FUNCTOR, ARG1, ...) FUNCTOR(ARG1) TOML11_FOR_EACH_VA_ARGS_AUX_23(FUNCTOR, __VA_ARGS__) +#define TOML11_FOR_EACH_VA_ARGS_AUX_25(FUNCTOR, ARG1, ...) FUNCTOR(ARG1) TOML11_FOR_EACH_VA_ARGS_AUX_24(FUNCTOR, __VA_ARGS__) +#define TOML11_FOR_EACH_VA_ARGS_AUX_26(FUNCTOR, ARG1, ...) FUNCTOR(ARG1) TOML11_FOR_EACH_VA_ARGS_AUX_25(FUNCTOR, __VA_ARGS__) +#define TOML11_FOR_EACH_VA_ARGS_AUX_27(FUNCTOR, ARG1, ...) FUNCTOR(ARG1) TOML11_FOR_EACH_VA_ARGS_AUX_26(FUNCTOR, __VA_ARGS__) +#define TOML11_FOR_EACH_VA_ARGS_AUX_28(FUNCTOR, ARG1, ...) FUNCTOR(ARG1) TOML11_FOR_EACH_VA_ARGS_AUX_27(FUNCTOR, __VA_ARGS__) +#define TOML11_FOR_EACH_VA_ARGS_AUX_29(FUNCTOR, ARG1, ...) FUNCTOR(ARG1) TOML11_FOR_EACH_VA_ARGS_AUX_28(FUNCTOR, __VA_ARGS__) +#define TOML11_FOR_EACH_VA_ARGS_AUX_30(FUNCTOR, ARG1, ...) FUNCTOR(ARG1) TOML11_FOR_EACH_VA_ARGS_AUX_29(FUNCTOR, __VA_ARGS__) +#define TOML11_FOR_EACH_VA_ARGS_AUX_31(FUNCTOR, ARG1, ...) FUNCTOR(ARG1) TOML11_FOR_EACH_VA_ARGS_AUX_30(FUNCTOR, __VA_ARGS__) +#define TOML11_FOR_EACH_VA_ARGS_AUX_32(FUNCTOR, ARG1, ...) FUNCTOR(ARG1) TOML11_FOR_EACH_VA_ARGS_AUX_31(FUNCTOR, __VA_ARGS__) + +#define TOML11_FOR_EACH_VA_ARGS(FUNCTOR, ...)\ + TOML11_CONCATENATE(TOML11_FOR_EACH_VA_ARGS_AUX_, TOML11_ARGS_SIZE(__VA_ARGS__))(FUNCTOR, __VA_ARGS__) + +// ---------------------------------------------------------------------------- +// TOML11_DEFINE_CONVERSION_NON_INTRUSIVE + +// use it in the following way. +// ```cpp +// namespace foo +// { +// struct Foo +// { +// std::string s; +// double d; +// int i; +// }; +// } // foo +// +// TOML11_DEFINE_CONVERSION_NON_INTRUSIVE(foo::Foo, s, d, i) +// ``` +// And then you can use `toml::find(file, "foo");` +// +#define TOML11_FIND_MEMBER_VARIABLE_FROM_VALUE(VAR_NAME)\ + obj.VAR_NAME = toml::find(v, TOML11_STRINGIZE(VAR_NAME)); + +#define TOML11_ASSIGN_MEMBER_VARIABLE_TO_VALUE(VAR_NAME)\ + v[TOML11_STRINGIZE(VAR_NAME)] = obj.VAR_NAME; + +#define TOML11_DEFINE_CONVERSION_NON_INTRUSIVE(NAME, ...)\ + namespace toml { \ + template<> \ + struct from \ + { \ + template class T, \ + template class A> \ + static NAME from_toml(const basic_value& v) \ + { \ + NAME obj; \ + TOML11_FOR_EACH_VA_ARGS(TOML11_FIND_MEMBER_VARIABLE_FROM_VALUE, __VA_ARGS__) \ + return obj; \ + } \ + }; \ + template<> \ + struct into \ + { \ + static value into_toml(const NAME& obj) \ + { \ + ::toml::value v = ::toml::table{}; \ + TOML11_FOR_EACH_VA_ARGS(TOML11_ASSIGN_MEMBER_VARIABLE_TO_VALUE, __VA_ARGS__) \ + return v; \ + } \ + }; \ + } /* toml */ + +#endif// TOML11_WITHOUT_DEFINE_NON_INTRUSIVE + +#endif// TOML11_MACROS_HPP diff --git a/libraries/toml11/include/toml/parser.hpp b/libraries/toml11/include/toml/parser.hpp new file mode 100644 index 00000000..c3df644e --- /dev/null +++ b/libraries/toml11/include/toml/parser.hpp @@ -0,0 +1,2177 @@ +// Copyright Toru Niina 2017. +// Distributed under the MIT License. +#ifndef TOML11_PARSER_HPP +#define TOML11_PARSER_HPP +#include +#include +#include + +#include "combinator.hpp" +#include "lexer.hpp" +#include "region.hpp" +#include "result.hpp" +#include "types.hpp" +#include "value.hpp" + +#ifndef TOML11_DISABLE_STD_FILESYSTEM +#ifdef __cpp_lib_filesystem +#if __has_include() +#define TOML11_HAS_STD_FILESYSTEM +#include +#endif // has_include() +#endif // __cpp_lib_filesystem +#endif // TOML11_DISABLE_STD_FILESYSTEM + +namespace toml +{ +namespace detail +{ + +inline result, std::string> +parse_boolean(location& loc) +{ + const auto first = loc.iter(); + if(const auto token = lex_boolean::invoke(loc)) + { + const auto reg = token.unwrap(); + if (reg.str() == "true") {return ok(std::make_pair(true, reg));} + else if(reg.str() == "false") {return ok(std::make_pair(false, reg));} + else // internal error. + { + throw internal_error(format_underline( + "toml::parse_boolean: internal error", + {{source_location(reg), "invalid token"}}), + source_location(reg)); + } + } + loc.reset(first); //rollback + return err(format_underline("toml::parse_boolean: ", + {{source_location(loc), "the next token is not a boolean"}})); +} + +inline result, std::string> +parse_binary_integer(location& loc) +{ + const auto first = loc.iter(); + if(const auto token = lex_bin_int::invoke(loc)) + { + auto str = token.unwrap().str(); + assert(str.size() > 2); // minimum -> 0b1 + integer retval(0), base(1); + for(auto i(str.rbegin()), e(str.rend() - 2); i!=e; ++i) + { + if (*i == '1'){retval += base; base *= 2;} + else if(*i == '0'){base *= 2;} + else if(*i == '_'){/* do nothing. */} + else // internal error. + { + throw internal_error(format_underline( + "toml::parse_integer: internal error", + {{source_location(token.unwrap()), "invalid token"}}), + source_location(loc)); + } + } + return ok(std::make_pair(retval, token.unwrap())); + } + loc.reset(first); + return err(format_underline("toml::parse_binary_integer:", + {{source_location(loc), "the next token is not an integer"}})); +} + +inline result, std::string> +parse_octal_integer(location& loc) +{ + const auto first = loc.iter(); + if(const auto token = lex_oct_int::invoke(loc)) + { + auto str = token.unwrap().str(); + str.erase(std::remove(str.begin(), str.end(), '_'), str.end()); + str.erase(str.begin()); str.erase(str.begin()); // remove `0o` prefix + + std::istringstream iss(str); + integer retval(0); + iss >> std::oct >> retval; + return ok(std::make_pair(retval, token.unwrap())); + } + loc.reset(first); + return err(format_underline("toml::parse_octal_integer:", + {{source_location(loc), "the next token is not an integer"}})); +} + +inline result, std::string> +parse_hexadecimal_integer(location& loc) +{ + const auto first = loc.iter(); + if(const auto token = lex_hex_int::invoke(loc)) + { + auto str = token.unwrap().str(); + str.erase(std::remove(str.begin(), str.end(), '_'), str.end()); + str.erase(str.begin()); str.erase(str.begin()); // remove `0x` prefix + + std::istringstream iss(str); + integer retval(0); + iss >> std::hex >> retval; + return ok(std::make_pair(retval, token.unwrap())); + } + loc.reset(first); + return err(format_underline("toml::parse_hexadecimal_integer", + {{source_location(loc), "the next token is not an integer"}})); +} + +inline result, std::string> +parse_integer(location& loc) +{ + const auto first = loc.iter(); + if(first != loc.end() && *first == '0') + { + const auto second = std::next(first); + if(second == loc.end()) // the token is just zero. + { + loc.advance(); + return ok(std::make_pair(0, region(loc, first, second))); + } + + if(*second == 'b') {return parse_binary_integer (loc);} // 0b1100 + if(*second == 'o') {return parse_octal_integer (loc);} // 0o775 + if(*second == 'x') {return parse_hexadecimal_integer(loc);} // 0xC0FFEE + + if(std::isdigit(*second)) + { + return err(format_underline("toml::parse_integer: " + "leading zero in an Integer is not allowed.", + {{source_location(loc), "leading zero"}})); + } + else if(std::isalpha(*second)) + { + return err(format_underline("toml::parse_integer: " + "unknown integer prefix appeared.", + {{source_location(loc), "none of 0x, 0o, 0b"}})); + } + } + + if(const auto token = lex_dec_int::invoke(loc)) + { + auto str = token.unwrap().str(); + str.erase(std::remove(str.begin(), str.end(), '_'), str.end()); + + std::istringstream iss(str); + integer retval(0); + iss >> retval; + return ok(std::make_pair(retval, token.unwrap())); + } + loc.reset(first); + return err(format_underline("toml::parse_integer: ", + {{source_location(loc), "the next token is not an integer"}})); +} + +inline result, std::string> +parse_floating(location& loc) +{ + const auto first = loc.iter(); + if(const auto token = lex_float::invoke(loc)) + { + auto str = token.unwrap().str(); + if(str == "inf" || str == "+inf") + { + if(std::numeric_limits::has_infinity) + { + return ok(std::make_pair( + std::numeric_limits::infinity(), token.unwrap())); + } + else + { + throw std::domain_error("toml::parse_floating: inf value found" + " but the current environment does not support inf. Please" + " make sure that the floating-point implementation conforms" + " IEEE 754/ISO 60559 international standard."); + } + } + else if(str == "-inf") + { + if(std::numeric_limits::has_infinity) + { + return ok(std::make_pair( + -std::numeric_limits::infinity(), token.unwrap())); + } + else + { + throw std::domain_error("toml::parse_floating: inf value found" + " but the current environment does not support inf. Please" + " make sure that the floating-point implementation conforms" + " IEEE 754/ISO 60559 international standard."); + } + } + else if(str == "nan" || str == "+nan") + { + if(std::numeric_limits::has_quiet_NaN) + { + return ok(std::make_pair( + std::numeric_limits::quiet_NaN(), token.unwrap())); + } + else if(std::numeric_limits::has_signaling_NaN) + { + return ok(std::make_pair( + std::numeric_limits::signaling_NaN(), token.unwrap())); + } + else + { + throw std::domain_error("toml::parse_floating: NaN value found" + " but the current environment does not support NaN. Please" + " make sure that the floating-point implementation conforms" + " IEEE 754/ISO 60559 international standard."); + } + } + else if(str == "-nan") + { + if(std::numeric_limits::has_quiet_NaN) + { + return ok(std::make_pair( + -std::numeric_limits::quiet_NaN(), token.unwrap())); + } + else if(std::numeric_limits::has_signaling_NaN) + { + return ok(std::make_pair( + -std::numeric_limits::signaling_NaN(), token.unwrap())); + } + else + { + throw std::domain_error("toml::parse_floating: NaN value found" + " but the current environment does not support NaN. Please" + " make sure that the floating-point implementation conforms" + " IEEE 754/ISO 60559 international standard."); + } + } + str.erase(std::remove(str.begin(), str.end(), '_'), str.end()); + std::istringstream iss(str); + floating v(0.0); + iss >> v; + return ok(std::make_pair(v, token.unwrap())); + } + loc.reset(first); + return err(format_underline("toml::parse_floating: ", + {{source_location(loc), "the next token is not a float"}})); +} + +inline std::string read_utf8_codepoint(const region& reg, const location& loc) +{ + const auto str = reg.str().substr(1); + std::uint_least32_t codepoint; + std::istringstream iss(str); + iss >> std::hex >> codepoint; + + const auto to_char = [](const std::uint_least32_t i) noexcept -> char { + const auto uc = static_cast(i); + return *reinterpret_cast(std::addressof(uc)); + }; + + std::string character; + if(codepoint < 0x80) // U+0000 ... U+0079 ; just an ASCII. + { + character += static_cast(codepoint); + } + else if(codepoint < 0x800) //U+0080 ... U+07FF + { + // 110yyyyx 10xxxxxx; 0x3f == 0b0011'1111 + character += to_char(0xC0| codepoint >> 6); + character += to_char(0x80|(codepoint & 0x3F)); + } + else if(codepoint < 0x10000) // U+0800...U+FFFF + { + if(0xD800 <= codepoint && codepoint <= 0xDFFF) + { + throw syntax_error(format_underline( + "toml::read_utf8_codepoint: codepoints in the range " + "[0xD800, 0xDFFF] are not valid UTF-8.", {{ + source_location(loc), "not a valid UTF-8 codepoint" + }}), source_location(loc)); + } + assert(codepoint < 0xD800 || 0xDFFF < codepoint); + // 1110yyyy 10yxxxxx 10xxxxxx + character += to_char(0xE0| codepoint >> 12); + character += to_char(0x80|(codepoint >> 6 & 0x3F)); + character += to_char(0x80|(codepoint & 0x3F)); + } + else if(codepoint < 0x110000) // U+010000 ... U+10FFFF + { + // 11110yyy 10yyxxxx 10xxxxxx 10xxxxxx + character += to_char(0xF0| codepoint >> 18); + character += to_char(0x80|(codepoint >> 12 & 0x3F)); + character += to_char(0x80|(codepoint >> 6 & 0x3F)); + character += to_char(0x80|(codepoint & 0x3F)); + } + else // out of UTF-8 region + { + throw syntax_error(format_underline("toml::read_utf8_codepoint:" + " input codepoint is too large.", + {{source_location(loc), "should be in [0x00..0x10FFFF]"}}), + source_location(loc)); + } + return character; +} + +inline result parse_escape_sequence(location& loc) +{ + const auto first = loc.iter(); + if(first == loc.end() || *first != '\\') + { + return err(format_underline("toml::parse_escape_sequence: ", {{ + source_location(loc), "the next token is not a backslash \"\\\""}})); + } + loc.advance(); + switch(*loc.iter()) + { + case '\\':{loc.advance(); return ok(std::string("\\"));} + case '"' :{loc.advance(); return ok(std::string("\""));} + case 'b' :{loc.advance(); return ok(std::string("\b"));} + case 't' :{loc.advance(); return ok(std::string("\t"));} + case 'n' :{loc.advance(); return ok(std::string("\n"));} + case 'f' :{loc.advance(); return ok(std::string("\f"));} + case 'r' :{loc.advance(); return ok(std::string("\r"));} + case 'u' : + { + if(const auto token = lex_escape_unicode_short::invoke(loc)) + { + return ok(read_utf8_codepoint(token.unwrap(), loc)); + } + else + { + return err(format_underline("parse_escape_sequence: " + "invalid token found in UTF-8 codepoint uXXXX.", + {{source_location(loc), "here"}})); + } + } + case 'U': + { + if(const auto token = lex_escape_unicode_long::invoke(loc)) + { + return ok(read_utf8_codepoint(token.unwrap(), loc)); + } + else + { + return err(format_underline("parse_escape_sequence: " + "invalid token found in UTF-8 codepoint Uxxxxxxxx", + {{source_location(loc), "here"}})); + } + } + } + + const auto msg = format_underline("parse_escape_sequence: " + "unknown escape sequence appeared.", {{source_location(loc), + "escape sequence is one of \\, \", b, t, n, f, r, uxxxx, Uxxxxxxxx"}}, + /* Hints = */{"if you want to write backslash as just one backslash, " + "use literal string like: regex = '<\\i\\c*\\s*>'"}); + loc.reset(first); + return err(msg); +} + +inline result, std::string> +parse_ml_basic_string(location& loc) +{ + const auto first = loc.iter(); + if(const auto token = lex_ml_basic_string::invoke(loc)) + { + auto inner_loc = loc; + inner_loc.reset(first); + + std::string retval; + retval.reserve(token.unwrap().size()); + + auto delim = lex_ml_basic_string_open::invoke(inner_loc); + if(!delim) + { + throw internal_error(format_underline( + "parse_ml_basic_string: invalid token", + {{source_location(inner_loc), "should be \"\"\""}}), + source_location(inner_loc)); + } + // immediate newline is ignored (if exists) + /* discard return value */ lex_newline::invoke(inner_loc); + + delim = none(); + while(!delim) + { + using lex_unescaped_seq = repeat< + either, unlimited>; + if(auto unescaped = lex_unescaped_seq::invoke(inner_loc)) + { + retval += unescaped.unwrap().str(); + } + if(auto escaped = parse_escape_sequence(inner_loc)) + { + retval += escaped.unwrap(); + } + if(auto esc_nl = lex_ml_basic_escaped_newline::invoke(inner_loc)) + { + // ignore newline after escape until next non-ws char + } + if(inner_loc.iter() == inner_loc.end()) + { + throw internal_error(format_underline( + "parse_ml_basic_string: unexpected end of region", + {{source_location(inner_loc), "not sufficient token"}}), + source_location(inner_loc)); + } + delim = lex_ml_basic_string_close::invoke(inner_loc); + } + // `lex_ml_basic_string_close` allows 3 to 5 `"`s to allow 1 or 2 `"`s + // at just before the delimiter. Here, we need to attach `"`s at the + // end of the string body, if it exists. + // For detail, see the definition of `lex_ml_basic_string_close`. + assert(std::all_of(delim.unwrap().first(), delim.unwrap().last(), + [](const char c) noexcept {return c == '\"';})); + switch(delim.unwrap().size()) + { + case 3: {break;} + case 4: {retval += "\""; break;} + case 5: {retval += "\"\""; break;} + default: + { + throw internal_error(format_underline( + "parse_ml_basic_string: closing delimiter has invalid length", + {{source_location(inner_loc), "end of this"}}), + source_location(inner_loc)); + } + } + return ok(std::make_pair(toml::string(retval), token.unwrap())); + } + else + { + loc.reset(first); + return err(format_underline("toml::parse_ml_basic_string: " + "the next token is not a valid multiline string", + {{source_location(loc), "here"}})); + } +} + +inline result, std::string> +parse_basic_string(location& loc) +{ + const auto first = loc.iter(); + if(const auto token = lex_basic_string::invoke(loc)) + { + auto inner_loc = loc; + inner_loc.reset(first); + + auto quot = lex_quotation_mark::invoke(inner_loc); + if(!quot) + { + throw internal_error(format_underline("parse_basic_string: " + "invalid token", {{source_location(inner_loc), "should be \""}}), + source_location(inner_loc)); + } + + std::string retval; + retval.reserve(token.unwrap().size()); + + quot = none(); + while(!quot) + { + using lex_unescaped_seq = repeat; + if(auto unescaped = lex_unescaped_seq::invoke(inner_loc)) + { + retval += unescaped.unwrap().str(); + } + if(auto escaped = parse_escape_sequence(inner_loc)) + { + retval += escaped.unwrap(); + } + if(inner_loc.iter() == inner_loc.end()) + { + throw internal_error(format_underline( + "parse_basic_string: unexpected end of region", + {{source_location(inner_loc), "not sufficient token"}}), + source_location(inner_loc)); + } + quot = lex_quotation_mark::invoke(inner_loc); + } + return ok(std::make_pair(toml::string(retval), token.unwrap())); + } + else + { + loc.reset(first); // rollback + return err(format_underline("toml::parse_basic_string: " + "the next token is not a valid string", + {{source_location(loc), "here"}})); + } +} + +inline result, std::string> +parse_ml_literal_string(location& loc) +{ + const auto first = loc.iter(); + if(const auto token = lex_ml_literal_string::invoke(loc)) + { + location inner_loc(loc.name(), token.unwrap().str()); + + const auto open = lex_ml_literal_string_open::invoke(inner_loc); + if(!open) + { + throw internal_error(format_underline( + "parse_ml_literal_string: invalid token", + {{source_location(inner_loc), "should be '''"}}), + source_location(inner_loc)); + } + // immediate newline is ignored (if exists) + /* discard return value */ lex_newline::invoke(inner_loc); + + const auto body = lex_ml_literal_body::invoke(inner_loc); + + const auto close = lex_ml_literal_string_close::invoke(inner_loc); + if(!close) + { + throw internal_error(format_underline( + "parse_ml_literal_string: invalid token", + {{source_location(inner_loc), "should be '''"}}), + source_location(inner_loc)); + } + // `lex_ml_literal_string_close` allows 3 to 5 `'`s to allow 1 or 2 `'`s + // at just before the delimiter. Here, we need to attach `'`s at the + // end of the string body, if it exists. + // For detail, see the definition of `lex_ml_basic_string_close`. + + std::string retval = body.unwrap().str(); + assert(std::all_of(close.unwrap().first(), close.unwrap().last(), + [](const char c) noexcept {return c == '\'';})); + switch(close.unwrap().size()) + { + case 3: {break;} + case 4: {retval += "'"; break;} + case 5: {retval += "''"; break;} + default: + { + throw internal_error(format_underline( + "parse_ml_literal_string: closing delimiter has invalid length", + {{source_location(inner_loc), "end of this"}}), + source_location(inner_loc)); + } + } + return ok(std::make_pair(toml::string(retval, toml::string_t::literal), + token.unwrap())); + } + else + { + loc.reset(first); // rollback + return err(format_underline("toml::parse_ml_literal_string: " + "the next token is not a valid multiline literal string", + {{source_location(loc), "here"}})); + } +} + +inline result, std::string> +parse_literal_string(location& loc) +{ + const auto first = loc.iter(); + if(const auto token = lex_literal_string::invoke(loc)) + { + location inner_loc(loc.name(), token.unwrap().str()); + + const auto open = lex_apostrophe::invoke(inner_loc); + if(!open) + { + throw internal_error(format_underline( + "parse_literal_string: invalid token", + {{source_location(inner_loc), "should be '"}}), + source_location(inner_loc)); + } + + const auto body = repeat::invoke(inner_loc); + + const auto close = lex_apostrophe::invoke(inner_loc); + if(!close) + { + throw internal_error(format_underline( + "parse_literal_string: invalid token", + {{source_location(inner_loc), "should be '"}}), + source_location(inner_loc)); + } + return ok(std::make_pair( + toml::string(body.unwrap().str(), toml::string_t::literal), + token.unwrap())); + } + else + { + loc.reset(first); // rollback + return err(format_underline("toml::parse_literal_string: " + "the next token is not a valid literal string", + {{source_location(loc), "here"}})); + } +} + +inline result, std::string> +parse_string(location& loc) +{ + if(loc.iter() != loc.end() && *(loc.iter()) == '"') + { + if(loc.iter() + 1 != loc.end() && *(loc.iter() + 1) == '"' && + loc.iter() + 2 != loc.end() && *(loc.iter() + 2) == '"') + { + return parse_ml_basic_string(loc); + } + else + { + return parse_basic_string(loc); + } + } + else if(loc.iter() != loc.end() && *(loc.iter()) == '\'') + { + if(loc.iter() + 1 != loc.end() && *(loc.iter() + 1) == '\'' && + loc.iter() + 2 != loc.end() && *(loc.iter() + 2) == '\'') + { + return parse_ml_literal_string(loc); + } + else + { + return parse_literal_string(loc); + } + } + return err(format_underline("toml::parse_string: ", + {{source_location(loc), "the next token is not a string"}})); +} + +inline result, std::string> +parse_local_date(location& loc) +{ + const auto first = loc.iter(); + if(const auto token = lex_local_date::invoke(loc)) + { + location inner_loc(loc.name(), token.unwrap().str()); + + const auto y = lex_date_fullyear::invoke(inner_loc); + if(!y || inner_loc.iter() == inner_loc.end() || *inner_loc.iter() != '-') + { + throw internal_error(format_underline( + "toml::parse_inner_local_date: invalid year format", + {{source_location(inner_loc), "should be `-`"}}), + source_location(inner_loc)); + } + inner_loc.advance(); + const auto m = lex_date_month::invoke(inner_loc); + if(!m || inner_loc.iter() == inner_loc.end() || *inner_loc.iter() != '-') + { + throw internal_error(format_underline( + "toml::parse_local_date: invalid month format", + {{source_location(inner_loc), "should be `-`"}}), + source_location(inner_loc)); + } + inner_loc.advance(); + const auto d = lex_date_mday::invoke(inner_loc); + if(!d) + { + throw internal_error(format_underline( + "toml::parse_local_date: invalid day format", + {{source_location(inner_loc), "here"}}), + source_location(inner_loc)); + } + return ok(std::make_pair(local_date( + static_cast(from_string(y.unwrap().str(), 0)), + static_cast( + static_cast(from_string(m.unwrap().str(), 0)-1)), + static_cast(from_string(d.unwrap().str(), 0))), + token.unwrap())); + } + else + { + loc.reset(first); + return err(format_underline("toml::parse_local_date: ", + {{source_location(loc), "the next token is not a local_date"}})); + } +} + +inline result, std::string> +parse_local_time(location& loc) +{ + const auto first = loc.iter(); + if(const auto token = lex_local_time::invoke(loc)) + { + location inner_loc(loc.name(), token.unwrap().str()); + + const auto h = lex_time_hour::invoke(inner_loc); + if(!h || inner_loc.iter() == inner_loc.end() || *inner_loc.iter() != ':') + { + throw internal_error(format_underline( + "toml::parse_local_time: invalid year format", + {{source_location(inner_loc), "should be `:`"}}), + source_location(inner_loc)); + } + inner_loc.advance(); + const auto m = lex_time_minute::invoke(inner_loc); + if(!m || inner_loc.iter() == inner_loc.end() || *inner_loc.iter() != ':') + { + throw internal_error(format_underline( + "toml::parse_local_time: invalid month format", + {{source_location(inner_loc), "should be `:`"}}), + source_location(inner_loc)); + } + inner_loc.advance(); + const auto s = lex_time_second::invoke(inner_loc); + if(!s) + { + throw internal_error(format_underline( + "toml::parse_local_time: invalid second format", + {{source_location(inner_loc), "here"}}), + source_location(inner_loc)); + } + local_time time( + from_string(h.unwrap().str(), 0), + from_string(m.unwrap().str(), 0), + from_string(s.unwrap().str(), 0), 0, 0); + + const auto before_secfrac = inner_loc.iter(); + if(const auto secfrac = lex_time_secfrac::invoke(inner_loc)) + { + auto sf = secfrac.unwrap().str(); + sf.erase(sf.begin()); // sf.front() == '.' + switch(sf.size() % 3) + { + case 2: sf += '0'; break; + case 1: sf += "00"; break; + case 0: break; + default: break; + } + if(sf.size() >= 9) + { + time.millisecond = from_string(sf.substr(0, 3), 0u); + time.microsecond = from_string(sf.substr(3, 3), 0u); + time.nanosecond = from_string(sf.substr(6, 3), 0u); + } + else if(sf.size() >= 6) + { + time.millisecond = from_string(sf.substr(0, 3), 0u); + time.microsecond = from_string(sf.substr(3, 3), 0u); + } + else if(sf.size() >= 3) + { + time.millisecond = from_string(sf, 0u); + time.microsecond = 0u; + } + } + else + { + if(before_secfrac != inner_loc.iter()) + { + throw internal_error(format_underline( + "toml::parse_local_time: invalid subsecond format", + {{source_location(inner_loc), "here"}}), + source_location(inner_loc)); + } + } + return ok(std::make_pair(time, token.unwrap())); + } + else + { + loc.reset(first); + return err(format_underline("toml::parse_local_time: ", + {{source_location(loc), "the next token is not a local_time"}})); + } +} + +inline result, std::string> +parse_local_datetime(location& loc) +{ + const auto first = loc.iter(); + if(const auto token = lex_local_date_time::invoke(loc)) + { + location inner_loc(loc.name(), token.unwrap().str()); + const auto date = parse_local_date(inner_loc); + if(!date || inner_loc.iter() == inner_loc.end()) + { + throw internal_error(format_underline( + "toml::parse_local_datetime: invalid datetime format", + {{source_location(inner_loc), "date, not datetime"}}), + source_location(inner_loc)); + } + const char delim = *(inner_loc.iter()); + if(delim != 'T' && delim != 't' && delim != ' ') + { + throw internal_error(format_underline( + "toml::parse_local_datetime: invalid datetime format", + {{source_location(inner_loc), "should be `T` or ` ` (space)"}}), + source_location(inner_loc)); + } + inner_loc.advance(); + const auto time = parse_local_time(inner_loc); + if(!time) + { + throw internal_error(format_underline( + "toml::parse_local_datetime: invalid datetime format", + {{source_location(inner_loc), "invalid time fomrat"}}), + source_location(inner_loc)); + } + return ok(std::make_pair( + local_datetime(date.unwrap().first, time.unwrap().first), + token.unwrap())); + } + else + { + loc.reset(first); + return err(format_underline("toml::parse_local_datetime: ", + {{source_location(loc), "the next token is not a local_datetime"}})); + } +} + +inline result, std::string> +parse_offset_datetime(location& loc) +{ + const auto first = loc.iter(); + if(const auto token = lex_offset_date_time::invoke(loc)) + { + location inner_loc(loc.name(), token.unwrap().str()); + const auto datetime = parse_local_datetime(inner_loc); + if(!datetime || inner_loc.iter() == inner_loc.end()) + { + throw internal_error(format_underline( + "toml::parse_offset_datetime: invalid datetime format", + {{source_location(inner_loc), "date, not datetime"}}), + source_location(inner_loc)); + } + time_offset offset(0, 0); + if(const auto ofs = lex_time_numoffset::invoke(inner_loc)) + { + const auto str = ofs.unwrap().str(); + if(str.front() == '+') + { + offset = time_offset(from_string(str.substr(1,2), 0), + from_string(str.substr(4,2), 0)); + } + else + { + offset = time_offset(-from_string(str.substr(1,2), 0), + -from_string(str.substr(4,2), 0)); + } + } + else if(*inner_loc.iter() != 'Z' && *inner_loc.iter() != 'z') + { + throw internal_error(format_underline( + "toml::parse_offset_datetime: invalid datetime format", + {{source_location(inner_loc), "should be `Z` or `+HH:MM`"}}), + source_location(inner_loc)); + } + return ok(std::make_pair(offset_datetime(datetime.unwrap().first, offset), + token.unwrap())); + } + else + { + loc.reset(first); + return err(format_underline("toml::parse_offset_datetime: ", + {{source_location(loc), "the next token is not a offset_datetime"}})); + } +} + +inline result, std::string> +parse_simple_key(location& loc) +{ + if(const auto bstr = parse_basic_string(loc)) + { + return ok(std::make_pair(bstr.unwrap().first.str, bstr.unwrap().second)); + } + if(const auto lstr = parse_literal_string(loc)) + { + return ok(std::make_pair(lstr.unwrap().first.str, lstr.unwrap().second)); + } + if(const auto bare = lex_unquoted_key::invoke(loc)) + { + const auto reg = bare.unwrap(); + return ok(std::make_pair(reg.str(), reg)); + } + return err(format_underline("toml::parse_simple_key: ", + {{source_location(loc), "the next token is not a simple key"}})); +} + +// dotted key become vector of keys +inline result, region>, std::string> +parse_key(location& loc) +{ + const auto first = loc.iter(); + // dotted key -> `foo.bar.baz` where several single keys are chained by + // dots. Whitespaces between keys and dots are allowed. + if(const auto token = lex_dotted_key::invoke(loc)) + { + const auto reg = token.unwrap(); + location inner_loc(loc.name(), reg.str()); + std::vector keys; + + while(inner_loc.iter() != inner_loc.end()) + { + lex_ws::invoke(inner_loc); + if(const auto k = parse_simple_key(inner_loc)) + { + keys.push_back(k.unwrap().first); + } + else + { + throw internal_error(format_underline( + "toml::detail::parse_key: dotted key contains invalid key", + {{source_location(inner_loc), k.unwrap_err()}}), + source_location(inner_loc)); + } + + lex_ws::invoke(inner_loc); + if(inner_loc.iter() == inner_loc.end()) + { + break; + } + else if(*inner_loc.iter() == '.') + { + inner_loc.advance(); // to skip `.` + } + else + { + throw internal_error(format_underline("toml::parse_key: " + "dotted key contains invalid key ", + {{source_location(inner_loc), "should be `.`"}}), + source_location(inner_loc)); + } + } + return ok(std::make_pair(keys, reg)); + } + loc.reset(first); + + // simple_key: a single (basic_string|literal_string|bare key) + if(const auto smpl = parse_simple_key(loc)) + { + return ok(std::make_pair(std::vector(1, smpl.unwrap().first), + smpl.unwrap().second)); + } + return err(format_underline("toml::parse_key: an invalid key appeared.", + {{source_location(loc), "is not a valid key"}}, { + "bare keys : non-empty strings composed only of [A-Za-z0-9_-].", + "quoted keys: same as \"basic strings\" or 'literal strings'.", + "dotted keys: sequence of bare or quoted keys joined with a dot." + })); +} + +// forward-decl to implement parse_array and parse_table +template +result parse_value(location&); + +template +result, std::string> +parse_array(location& loc) +{ + using value_type = Value; + using array_type = typename value_type::array_type; + + const auto first = loc.iter(); + if(loc.iter() == loc.end()) + { + return err("toml::parse_array: input is empty"); + } + if(*loc.iter() != '[') + { + return err("toml::parse_array: token is not an array"); + } + loc.advance(); + + using lex_ws_comment_newline = repeat< + either, unlimited>; + + array_type retval; + while(loc.iter() != loc.end()) + { + lex_ws_comment_newline::invoke(loc); // skip + + if(loc.iter() != loc.end() && *loc.iter() == ']') + { + loc.advance(); // skip ']' + return ok(std::make_pair(retval, + region(loc, first, loc.iter()))); + } + + if(auto val = parse_value(loc)) + { + // After TOML v1.0.0-rc.1, array becomes to be able to have values + // with different types. So here we will omit this by default. + // + // But some of the test-suite checks if the parser accepts a hetero- + // geneous arrays, so we keep this for a while. +#ifdef TOML11_DISALLOW_HETEROGENEOUS_ARRAYS + if(!retval.empty() && retval.front().type() != val.as_ok().type()) + { + auto array_start_loc = loc; + array_start_loc.reset(first); + + throw syntax_error(format_underline("toml::parse_array: " + "type of elements should be the same each other.", { + {source_location(array_start_loc), "array starts here"}, + { + retval.front().location(), + "value has type " + stringize(retval.front().type()) + }, + { + val.unwrap().location(), + "value has different type, " + stringize(val.unwrap().type()) + } + }), source_location(loc)); + } +#endif + retval.push_back(std::move(val.unwrap())); + } + else + { + auto array_start_loc = loc; + array_start_loc.reset(first); + + throw syntax_error(format_underline("toml::parse_array: " + "value having invalid format appeared in an array", { + {source_location(array_start_loc), "array starts here"}, + {source_location(loc), "it is not a valid value."} + }), source_location(loc)); + } + + using lex_array_separator = sequence, character<','>>; + const auto sp = lex_array_separator::invoke(loc); + if(!sp) + { + lex_ws_comment_newline::invoke(loc); + if(loc.iter() != loc.end() && *loc.iter() == ']') + { + loc.advance(); // skip ']' + return ok(std::make_pair(retval, + region(loc, first, loc.iter()))); + } + else + { + auto array_start_loc = loc; + array_start_loc.reset(first); + + throw syntax_error(format_underline("toml::parse_array:" + " missing array separator `,` after a value", { + {source_location(array_start_loc), "array starts here"}, + {source_location(loc), "should be `,`"} + }), source_location(loc)); + } + } + } + loc.reset(first); + throw syntax_error(format_underline("toml::parse_array: " + "array did not closed by `]`", + {{source_location(loc), "should be closed"}}), + source_location(loc)); +} + +template +result, region>, Value>, std::string> +parse_key_value_pair(location& loc) +{ + using value_type = Value; + + const auto first = loc.iter(); + auto key_reg = parse_key(loc); + if(!key_reg) + { + std::string msg = std::move(key_reg.unwrap_err()); + // if the next token is keyvalue-separator, it means that there are no + // key. then we need to show error as "empty key is not allowed". + if(const auto keyval_sep = lex_keyval_sep::invoke(loc)) + { + loc.reset(first); + msg = format_underline("toml::parse_key_value_pair: " + "empty key is not allowed.", + {{source_location(loc), "key expected before '='"}}); + } + return err(std::move(msg)); + } + + const auto kvsp = lex_keyval_sep::invoke(loc); + if(!kvsp) + { + std::string msg; + // if the line contains '=' after the invalid sequence, possibly the + // error is in the key (like, invalid character in bare key). + const auto line_end = std::find(loc.iter(), loc.end(), '\n'); + if(std::find(loc.iter(), line_end, '=') != line_end) + { + msg = format_underline("toml::parse_key_value_pair: " + "invalid format for key", + {{source_location(loc), "invalid character in key"}}, + {"Did you forget '.' to separate dotted-key?", + "Allowed characters for bare key are [0-9a-zA-Z_-]."}); + } + else // if not, the error is lack of key-value separator. + { + msg = format_underline("toml::parse_key_value_pair: " + "missing key-value separator `=`", + {{source_location(loc), "should be `=`"}}); + } + loc.reset(first); + return err(std::move(msg)); + } + + const auto after_kvsp = loc.iter(); // err msg + auto val = parse_value(loc); + if(!val) + { + std::string msg; + loc.reset(after_kvsp); + // check there is something not a comment/whitespace after `=` + if(sequence, maybe, lex_newline>::invoke(loc)) + { + loc.reset(after_kvsp); + msg = format_underline("toml::parse_key_value_pair: " + "missing value after key-value separator '='", + {{source_location(loc), "expected value, but got nothing"}}); + } + else // there is something not a comment/whitespace, so invalid format. + { + msg = std::move(val.unwrap_err()); + } + loc.reset(first); + return err(msg); + } + return ok(std::make_pair(std::move(key_reg.unwrap()), + std::move(val.unwrap()))); +} + +// for error messages. +template +std::string format_dotted_keys(InputIterator first, const InputIterator last) +{ + static_assert(std::is_same::value_type>::value,""); + + std::string retval(*first++); + for(; first != last; ++first) + { + retval += '.'; + retval += *first; + } + return retval; +} + +// forward decl for is_valid_forward_table_definition +result, region>, std::string> +parse_table_key(location& loc); + +// The following toml file is allowed. +// ```toml +// [a.b.c] # here, table `a` has element `b`. +// foo = "bar" +// [a] # merge a = {baz = "qux"} to a = {b = {...}} +// baz = "qux" +// ``` +// But the following is not allowed. +// ```toml +// [a] +// b.c.foo = "bar" +// [a] # error! the same table [a] defined! +// baz = "qux" +// ``` +// The following is neither allowed. +// ```toml +// a = { b.c.foo = "bar"} +// [a] # error! the same table [a] defined! +// baz = "qux" +// ``` +// Here, it parses region of `tab->at(k)` as a table key and check the depth +// of the key. If the key region points deeper node, it would be allowed. +// Otherwise, the key points the same node. It would be rejected. +template +bool is_valid_forward_table_definition(const Value& fwd, + Iterator key_first, Iterator key_curr, Iterator key_last) +{ + std::string internal = ""; + if(const auto ptr = detail::get_region(fwd)) + { + internal = ptr->str(); + } + location def("internal", std::move(internal)); + if(const auto tabkeys = parse_table_key(def)) + { + // table keys always contains all the nodes from the root. + const auto& tks = tabkeys.unwrap().first; + if(std::size_t(std::distance(key_first, key_last)) == tks.size() && + std::equal(tks.begin(), tks.end(), key_first)) + { + // the keys are equivalent. it is not allowed. + return false; + } + // the keys are not equivalent. it is allowed. + return true; + } + if(const auto dotkeys = parse_key(def)) + { + // consider the following case. + // [a] + // b.c = {d = 42} + // [a.b.c] + // e = 2.71 + // this defines the table [a.b.c] twice. no? + + // a dotted key starts from the node representing a table in which the + // dotted key belongs to. + const auto& dks = dotkeys.unwrap().first; + if(std::size_t(std::distance(key_curr, key_last)) == dks.size() && + std::equal(dks.begin(), dks.end(), key_curr)) + { + // the keys are equivalent. it is not allowed. + return false; + } + // the keys are not equivalent. it is allowed. + return true; + } + return false; +} + +template +result +insert_nested_key(typename Value::table_type& root, const Value& v, + InputIterator iter, const InputIterator last, + region key_reg, + const bool is_array_of_table = false) +{ + static_assert(std::is_same::value_type>::value,""); + + using value_type = Value; + using table_type = typename value_type::table_type; + using array_type = typename value_type::array_type; + + const auto first = iter; + assert(iter != last); + + table_type* tab = std::addressof(root); + for(; iter != last; ++iter) // search recursively + { + const key& k = *iter; + if(std::next(iter) == last) // k is the last key + { + // XXX if the value is array-of-tables, there can be several + // tables that are in the same array. in that case, we need to + // find the last element and insert it to there. + if(is_array_of_table) + { + if(tab->count(k) == 1) // there is already an array of table + { + if(tab->at(k).is_table()) + { + // show special err msg for conflicting table + throw syntax_error(format_underline(concat_to_string( + "toml::insert_value: array of table (\"", + format_dotted_keys(first, last), + "\") cannot be defined"), { + {tab->at(k).location(), "table already defined"}, + {v.location(), "this conflicts with the previous table"} + }), v.location()); + } + else if(!(tab->at(k).is_array())) + { + throw syntax_error(format_underline(concat_to_string( + "toml::insert_value: array of table (\"", + format_dotted_keys(first, last), "\") collides with" + " existing value"), { + {tab->at(k).location(), + concat_to_string("this ", tab->at(k).type(), + " value already exists")}, + {v.location(), + "while inserting this array-of-tables"} + }), v.location()); + } + // the above if-else-if checks tab->at(k) is an array + auto& a = tab->at(k).as_array(); + if(!(a.front().is_table())) + { + throw syntax_error(format_underline(concat_to_string( + "toml::insert_value: array of table (\"", + format_dotted_keys(first, last), "\") collides with" + " existing value"), { + {tab->at(k).location(), + concat_to_string("this ", tab->at(k).type(), + " value already exists")}, + {v.location(), + "while inserting this array-of-tables"} + }), v.location()); + } + // avoid conflicting array of table like the following. + // ```toml + // a = [{b = 42}] # define a as an array of *inline* tables + // [[a]] # a is an array of *multi-line* tables + // b = 54 + // ``` + // Here, from the type information, these cannot be detected + // bacause inline table is also a table. + // But toml v0.5.0 explicitly says it is invalid. The above + // array-of-tables has a static size and appending to the + // array is invalid. + // In this library, multi-line table value has a region + // that points to the key of the table (e.g. [[a]]). By + // comparing the first two letters in key, we can detect + // the array-of-table is inline or multiline. + if(const auto ptr = detail::get_region(a.front())) + { + if(ptr->str().substr(0,2) != "[[") + { + throw syntax_error(format_underline(concat_to_string( + "toml::insert_value: array of table (\"", + format_dotted_keys(first, last), "\") collides " + "with existing array-of-tables"), { + {tab->at(k).location(), + concat_to_string("this ", tab->at(k).type(), + " value has static size")}, + {v.location(), + "appending it to the statically sized array"} + }), v.location()); + } + } + a.push_back(v); + return ok(true); + } + else // if not, we need to create the array of table + { + // XXX: Consider the following array of tables. + // ```toml + // # This is a comment. + // [[aot]] + // foo = "bar" + // ``` + // Here, the comment is for `aot`. But here, actually two + // values are defined. An array that contains tables, named + // `aot`, and the 0th element of the `aot`, `{foo = "bar"}`. + // Those two are different from each other. But both of them + // points to the same portion of the TOML file, `[[aot]]`, + // so `key_reg.comments()` returns `# This is a comment`. + // If it is assigned as a comment of `aot` defined here, the + // comment will be duplicated. Both the `aot` itself and + // the 0-th element will have the same comment. This causes + // "duplication of the same comments" bug when the data is + // serialized. + // Next, consider the following. + // ```toml + // # comment 1 + // aot = [ + // # coment 2 + // {foo = "bar"}, + // ] + // ``` + // In this case, we can distinguish those two comments. So + // here we need to add "comment 1" to the `aot` and + // "comment 2" to the 0th element of that. + // To distinguish those two, we check the key region. + std::vector comments{/* empty by default */}; + if(key_reg.str().substr(0, 2) != "[[") + { + comments = key_reg.comments(); + } + value_type aot(array_type(1, v), key_reg, std::move(comments)); + tab->insert(std::make_pair(k, aot)); + return ok(true); + } + } // end if(array of table) + + if(tab->count(k) == 1) + { + if(tab->at(k).is_table() && v.is_table()) + { + if(!is_valid_forward_table_definition( + tab->at(k), first, iter, last)) + { + throw syntax_error(format_underline(concat_to_string( + "toml::insert_value: table (\"", + format_dotted_keys(first, last), + "\") already exists."), { + {tab->at(k).location(), "table already exists here"}, + {v.location(), "table defined twice"} + }), v.location()); + } + // to allow the following toml file. + // [a.b.c] + // d = 42 + // [a] + // e = 2.71 + auto& t = tab->at(k).as_table(); + for(const auto& kv : v.as_table()) + { + t[kv.first] = kv.second; + } + detail::change_region(tab->at(k), key_reg); + return ok(true); + } + else if(v.is_table() && + tab->at(k).is_array() && + tab->at(k).as_array().size() > 0 && + tab->at(k).as_array().front().is_table()) + { + throw syntax_error(format_underline(concat_to_string( + "toml::insert_value: array of tables (\"", + format_dotted_keys(first, last), "\") already exists."), { + {tab->at(k).location(), "array of tables defined here"}, + {v.location(), "table conflicts with the previous array of table"} + }), v.location()); + } + else + { + throw syntax_error(format_underline(concat_to_string( + "toml::insert_value: value (\"", + format_dotted_keys(first, last), "\") already exists."), { + {tab->at(k).location(), "value already exists here"}, + {v.location(), "value defined twice"} + }), v.location()); + } + } + tab->insert(std::make_pair(k, v)); + return ok(true); + } + else // k is not the last one, we should insert recursively + { + // if there is no corresponding value, insert it first. + // related: you don't need to write + // # [x] + // # [x.y] + // to write + // [x.y.z] + if(tab->count(k) == 0) + { + // a table that is defined implicitly doesn't have any comments. + (*tab)[k] = value_type(table_type{}, key_reg, {/*no comment*/}); + } + + // type checking... + if(tab->at(k).is_table()) + { + // According to toml-lang/toml:36d3091b3 "Clarify that inline + // tables are immutable", check if it adds key-value pair to an + // inline table. + if(const auto* ptr = get_region(tab->at(k))) + { + // here, if the value is a (multi-line) table, the region + // should be something like `[table-name]`. + if(ptr->front() == '{') + { + throw syntax_error(format_underline(concat_to_string( + "toml::insert_value: inserting to an inline table (", + format_dotted_keys(first, std::next(iter)), + ") but inline tables are immutable"), { + {tab->at(k).location(), "inline tables are immutable"}, + {v.location(), "inserting this"} + }), v.location()); + } + } + tab = std::addressof((*tab)[k].as_table()); + } + else if(tab->at(k).is_array()) // inserting to array-of-tables? + { + auto& a = (*tab)[k].as_array(); + if(!a.back().is_table()) + { + throw syntax_error(format_underline(concat_to_string( + "toml::insert_value: target (", + format_dotted_keys(first, std::next(iter)), + ") is neither table nor an array of tables"), { + {a.back().location(), concat_to_string( + "actual type is ", a.back().type())}, + {v.location(), "inserting this"} + }), v.location()); + } + tab = std::addressof(a.back().as_table()); + } + else + { + throw syntax_error(format_underline(concat_to_string( + "toml::insert_value: target (", + format_dotted_keys(first, std::next(iter)), + ") is neither table nor an array of tables"), { + {tab->at(k).location(), concat_to_string( + "actual type is ", tab->at(k).type())}, + {v.location(), "inserting this"} + }), v.location()); + } + } + } + return err(std::string("toml::detail::insert_nested_key: never reach here")); +} + +template +result, std::string> +parse_inline_table(location& loc) +{ + using value_type = Value; + using table_type = typename value_type::table_type; + + const auto first = loc.iter(); + table_type retval; + if(!(loc.iter() != loc.end() && *loc.iter() == '{')) + { + return err(format_underline("toml::parse_inline_table: ", + {{source_location(loc), "the next token is not an inline table"}})); + } + loc.advance(); + // it starts from "{". it should be formatted as inline-table + while(loc.iter() != loc.end()) + { + maybe::invoke(loc); + if(loc.iter() != loc.end() && *loc.iter() == '}') + { + loc.advance(); // skip `}` + return ok(std::make_pair(retval, + region(loc, first, loc.iter()))); + } + + const auto kv_r = parse_key_value_pair(loc); + if(!kv_r) + { + return err(kv_r.unwrap_err()); + } + const auto& kvpair = kv_r.unwrap(); + const std::vector& keys = kvpair.first.first; + const auto& key_reg = kvpair.first.second; + const value_type& val = kvpair.second; + + const auto inserted = + insert_nested_key(retval, val, keys.begin(), keys.end(), key_reg); + if(!inserted) + { + throw internal_error("toml::parse_inline_table: " + "failed to insert value into table: " + inserted.unwrap_err(), + source_location(loc)); + } + + using lex_table_separator = sequence, character<','>>; + const auto sp = lex_table_separator::invoke(loc); + if(!sp) + { + maybe::invoke(loc); + if(loc.iter() != loc.end() && *loc.iter() == '}') + { + loc.advance(); // skip `}` + return ok(std::make_pair( + retval, region(loc, first, loc.iter()))); + } + else if(*loc.iter() == '#' || *loc.iter() == '\r' || *loc.iter() == '\n') + { + throw syntax_error(format_underline( + "toml::parse_inline_table: missing curly brace `}`", + {{source_location(loc), "should be `}`"}}), + source_location(loc)); + } + else + { + throw syntax_error(format_underline( + "toml::parse_inline_table: missing table separator `,` ", + {{source_location(loc), "should be `,`"}}), + source_location(loc)); + } + } + } + loc.reset(first); + throw syntax_error(format_underline("toml::parse_inline_table: " + "inline table did not closed by `}`", + {{source_location(loc), "should be closed"}}), + source_location(loc)); +} + +inline result guess_number_type(const location& l) +{ + // This function tries to find some (common) mistakes by checking characters + // that follows the last character of a value. But it is often difficult + // because some non-newline characters can appear after a value. E.g. + // spaces, tabs, commas (in an array or inline table), closing brackets + // (of an array or inline table), comment-sign (#). Since this function + // does not parse further, those characters are always allowed to be there. + location loc = l; + + if(lex_offset_date_time::invoke(loc)) {return ok(value_t::offset_datetime);} + loc.reset(l.iter()); + + if(lex_local_date_time::invoke(loc)) + { + // bad offset may appear after this. + if(loc.iter() != loc.end() && (*loc.iter() == '+' || *loc.iter() == '-' + || *loc.iter() == 'Z' || *loc.iter() == 'z')) + { + return err(format_underline("bad offset: should be [+-]HH:MM or Z", + {{source_location(loc), "[+-]HH:MM or Z"}}, + {"pass: +09:00, -05:30", "fail: +9:00, -5:30"})); + } + return ok(value_t::local_datetime); + } + loc.reset(l.iter()); + + if(lex_local_date::invoke(loc)) + { + // bad time may appear after this. + // A space is allowed as a delimiter between local time. But there are + // both cases in which a space becomes valid or invalid. + // - invalid: 2019-06-16 7:00:00 + // - valid : 2019-06-16 07:00:00 + if(loc.iter() != loc.end()) + { + const auto c = *loc.iter(); + if(c == 'T' || c == 't') + { + return err(format_underline("bad time: should be HH:MM:SS.subsec", + {{source_location(loc), "HH:MM:SS.subsec"}}, + {"pass: 1979-05-27T07:32:00, 1979-05-27 07:32:00.999999", + "fail: 1979-05-27T7:32:00, 1979-05-27 17:32"})); + } + if('0' <= c && c <= '9') + { + return err(format_underline("bad time: missing T", + {{source_location(loc), "T or space required here"}}, + {"pass: 1979-05-27T07:32:00, 1979-05-27 07:32:00.999999", + "fail: 1979-05-27T7:32:00, 1979-05-27 7:32"})); + } + if(c == ' ' && std::next(loc.iter()) != loc.end() && + ('0' <= *std::next(loc.iter()) && *std::next(loc.iter())<= '9')) + { + loc.advance(); + return err(format_underline("bad time: should be HH:MM:SS.subsec", + {{source_location(loc), "HH:MM:SS.subsec"}}, + {"pass: 1979-05-27T07:32:00, 1979-05-27 07:32:00.999999", + "fail: 1979-05-27T7:32:00, 1979-05-27 7:32"})); + } + } + return ok(value_t::local_date); + } + loc.reset(l.iter()); + + if(lex_local_time::invoke(loc)) {return ok(value_t::local_time);} + loc.reset(l.iter()); + + if(lex_float::invoke(loc)) + { + if(loc.iter() != loc.end() && *loc.iter() == '_') + { + return err(format_underline("bad float: `_` should be surrounded by digits", + {{source_location(loc), "here"}}, + {"pass: +1.0, -2e-2, 3.141_592_653_589, inf, nan", + "fail: .0, 1., _1.0, 1.0_, 1_.0, 1.0__0"})); + } + return ok(value_t::floating); + } + loc.reset(l.iter()); + + if(lex_integer::invoke(loc)) + { + if(loc.iter() != loc.end()) + { + const auto c = *loc.iter(); + if(c == '_') + { + return err(format_underline("bad integer: `_` should be surrounded by digits", + {{source_location(loc), "here"}}, + {"pass: -42, 1_000, 1_2_3_4_5, 0xC0FFEE, 0b0010, 0o755", + "fail: 1__000, 0123"})); + } + if('0' <= c && c <= '9') + { + // leading zero. point '0' + loc.retrace(); + return err(format_underline("bad integer: leading zero", + {{source_location(loc), "here"}}, + {"pass: -42, 1_000, 1_2_3_4_5, 0xC0FFEE, 0b0010, 0o755", + "fail: 1__000, 0123"})); + } + if(c == ':' || c == '-') + { + return err(format_underline("bad datetime: invalid format", + {{source_location(loc), "here"}}, + {"pass: 1979-05-27T07:32:00-07:00, 1979-05-27 07:32:00.999999Z", + "fail: 1979-05-27T7:32:00-7:00, 1979-05-27 7:32-00:30"})); + } + if(c == '.' || c == 'e' || c == 'E') + { + return err(format_underline("bad float: invalid format", + {{source_location(loc), "here"}}, + {"pass: +1.0, -2e-2, 3.141_592_653_589, inf, nan", + "fail: .0, 1., _1.0, 1.0_, 1_.0, 1.0__0"})); + } + } + return ok(value_t::integer); + } + if(loc.iter() != loc.end() && *loc.iter() == '.') + { + return err(format_underline("bad float: invalid format", + {{source_location(loc), "integer part required before this"}}, + {"pass: +1.0, -2e-2, 3.141_592_653_589, inf, nan", + "fail: .0, 1., _1.0, 1.0_, 1_.0, 1.0__0"})); + } + if(loc.iter() != loc.end() && *loc.iter() == '_') + { + return err(format_underline("bad number: `_` should be surrounded by digits", + {{source_location(loc), "`_` is not surrounded by digits"}}, + {"pass: -42, 1_000, 1_2_3_4_5, 0xC0FFEE, 0b0010, 0o755", + "fail: 1__000, 0123"})); + } + return err(format_underline("bad format: unknown value appeared", + {{source_location(loc), "here"}})); +} + +inline result guess_value_type(const location& loc) +{ + switch(*loc.iter()) + { + case '"' : {return ok(value_t::string); } + case '\'': {return ok(value_t::string); } + case 't' : {return ok(value_t::boolean); } + case 'f' : {return ok(value_t::boolean); } + case '[' : {return ok(value_t::array); } + case '{' : {return ok(value_t::table); } + case 'i' : {return ok(value_t::floating);} // inf. + case 'n' : {return ok(value_t::floating);} // nan. + default : {return guess_number_type(loc);} + } +} + +template +result +parse_value_helper(result, std::string> rslt) +{ + if(rslt.is_ok()) + { + auto comments = rslt.as_ok().second.comments(); + return ok(Value(std::move(rslt.as_ok()), std::move(comments))); + } + else + { + return err(std::move(rslt.as_err())); + } +} + +template +result parse_value(location& loc) +{ + const auto first = loc.iter(); + if(first == loc.end()) + { + return err(format_underline("toml::parse_value: input is empty", + {{source_location(loc), ""}})); + } + + const auto type = guess_value_type(loc); + if(!type) + { + return err(type.unwrap_err()); + } + + switch(type.unwrap()) + { + case value_t::boolean : {return parse_value_helper(parse_boolean(loc) );} + case value_t::integer : {return parse_value_helper(parse_integer(loc) );} + case value_t::floating : {return parse_value_helper(parse_floating(loc) );} + case value_t::string : {return parse_value_helper(parse_string(loc) );} + case value_t::offset_datetime: {return parse_value_helper(parse_offset_datetime(loc) );} + case value_t::local_datetime : {return parse_value_helper(parse_local_datetime(loc) );} + case value_t::local_date : {return parse_value_helper(parse_local_date(loc) );} + case value_t::local_time : {return parse_value_helper(parse_local_time(loc) );} + case value_t::array : {return parse_value_helper(parse_array(loc) );} + case value_t::table : {return parse_value_helper(parse_inline_table(loc));} + default: + { + const auto msg = format_underline("toml::parse_value: " + "unknown token appeared", {{source_location(loc), "unknown"}}); + loc.reset(first); + return err(msg); + } + } +} + +inline result, region>, std::string> +parse_table_key(location& loc) +{ + if(auto token = lex_std_table::invoke(loc)) + { + location inner_loc(loc.name(), token.unwrap().str()); + + const auto open = lex_std_table_open::invoke(inner_loc); + if(!open || inner_loc.iter() == inner_loc.end()) + { + throw internal_error(format_underline( + "toml::parse_table_key: no `[`", + {{source_location(inner_loc), "should be `[`"}}), + source_location(inner_loc)); + } + // to skip [ a . b . c ] + // ^----------- this whitespace + lex_ws::invoke(inner_loc); + const auto keys = parse_key(inner_loc); + if(!keys) + { + throw internal_error(format_underline( + "toml::parse_table_key: invalid key", + {{source_location(inner_loc), "not key"}}), + source_location(inner_loc)); + } + // to skip [ a . b . c ] + // ^-- this whitespace + lex_ws::invoke(inner_loc); + const auto close = lex_std_table_close::invoke(inner_loc); + if(!close) + { + throw internal_error(format_underline( + "toml::parse_table_key: no `]`", + {{source_location(inner_loc), "should be `]`"}}), + source_location(inner_loc)); + } + + // after [table.key], newline or EOF(empty table) requried. + if(loc.iter() != loc.end()) + { + using lex_newline_after_table_key = + sequence, maybe, lex_newline>; + const auto nl = lex_newline_after_table_key::invoke(loc); + if(!nl) + { + throw syntax_error(format_underline( + "toml::parse_table_key: newline required after [table.key]", + {{source_location(loc), "expected newline"}}), + source_location(loc)); + } + } + return ok(std::make_pair(keys.unwrap().first, token.unwrap())); + } + else + { + return err(format_underline("toml::parse_table_key: " + "not a valid table key", {{source_location(loc), "here"}})); + } +} + +inline result, region>, std::string> +parse_array_table_key(location& loc) +{ + if(auto token = lex_array_table::invoke(loc)) + { + location inner_loc(loc.name(), token.unwrap().str()); + + const auto open = lex_array_table_open::invoke(inner_loc); + if(!open || inner_loc.iter() == inner_loc.end()) + { + throw internal_error(format_underline( + "toml::parse_array_table_key: no `[[`", + {{source_location(inner_loc), "should be `[[`"}}), + source_location(inner_loc)); + } + lex_ws::invoke(inner_loc); + const auto keys = parse_key(inner_loc); + if(!keys) + { + throw internal_error(format_underline( + "toml::parse_array_table_key: invalid key", + {{source_location(inner_loc), "not a key"}}), + source_location(inner_loc)); + } + lex_ws::invoke(inner_loc); + const auto close = lex_array_table_close::invoke(inner_loc); + if(!close) + { + throw internal_error(format_underline( + "toml::parse_table_key: no `]]`", + {{source_location(inner_loc), "should be `]]`"}}), + source_location(inner_loc)); + } + + // after [[table.key]], newline or EOF(empty table) requried. + if(loc.iter() != loc.end()) + { + using lex_newline_after_table_key = + sequence, maybe, lex_newline>; + const auto nl = lex_newline_after_table_key::invoke(loc); + if(!nl) + { + throw syntax_error(format_underline("toml::" + "parse_array_table_key: newline required after [[table.key]]", + {{source_location(loc), "expected newline"}}), + source_location(loc)); + } + } + return ok(std::make_pair(keys.unwrap().first, token.unwrap())); + } + else + { + return err(format_underline("toml::parse_array_table_key: " + "not a valid table key", {{source_location(loc), "here"}})); + } +} + +// parse table body (key-value pairs until the iter hits the next [tablekey]) +template +result +parse_ml_table(location& loc) +{ + using value_type = Value; + using table_type = typename value_type::table_type; + + const auto first = loc.iter(); + if(first == loc.end()) + { + return ok(table_type{}); + } + + // XXX at lest one newline is needed. + using skip_line = repeat< + sequence, maybe, lex_newline>, at_least<1>>; + skip_line::invoke(loc); + lex_ws::invoke(loc); + + table_type tab; + while(loc.iter() != loc.end()) + { + lex_ws::invoke(loc); + const auto before = loc.iter(); + if(const auto tmp = parse_array_table_key(loc)) // next table found + { + loc.reset(before); + return ok(tab); + } + if(const auto tmp = parse_table_key(loc)) // next table found + { + loc.reset(before); + return ok(tab); + } + + if(const auto kv = parse_key_value_pair(loc)) + { + const auto& kvpair = kv.unwrap(); + const std::vector& keys = kvpair.first.first; + const auto& key_reg = kvpair.first.second; + const value_type& val = kvpair.second; + const auto inserted = + insert_nested_key(tab, val, keys.begin(), keys.end(), key_reg); + if(!inserted) + { + return err(inserted.unwrap_err()); + } + } + else + { + return err(kv.unwrap_err()); + } + + // comment lines are skipped by the above function call. + // However, since the `skip_line` requires at least 1 newline, it fails + // if the file ends with ws and/or comment without newline. + // `skip_line` matches `ws? + comment? + newline`, not `ws` or `comment` + // itself. To skip the last ws and/or comment, call lexers. + // It does not matter if these fails, so the return value is discarded. + lex_ws::invoke(loc); + lex_comment::invoke(loc); + + // skip_line is (whitespace? comment? newline)_{1,}. multiple empty lines + // and comments after the last key-value pairs are allowed. + const auto newline = skip_line::invoke(loc); + if(!newline && loc.iter() != loc.end()) + { + const auto before2 = loc.iter(); + lex_ws::invoke(loc); // skip whitespace + const auto msg = format_underline("toml::parse_table: " + "invalid line format", {{source_location(loc), concat_to_string( + "expected newline, but got '", show_char(*loc.iter()), "'.")}}); + loc.reset(before2); + return err(msg); + } + + // the skip_lines only matches with lines that includes newline. + // to skip the last line that includes comment and/or whitespace + // but no newline, call them one more time. + lex_ws::invoke(loc); + lex_comment::invoke(loc); + } + return ok(tab); +} + +template +result parse_toml_file(location& loc) +{ + using value_type = Value; + using table_type = typename value_type::table_type; + + const auto first = loc.iter(); + if(first == loc.end()) + { + return ok(value_type(table_type{} /*, empty file has no region ...*/)); + } + + // put the first line as a region of a file + // Here first != loc.end(), so taking std::next is okay + const region file(loc, first, std::next(loc.iter())); + + // The first successive comments that are separated from the first value + // by an empty line are for a file itself. + // ```toml + // # this is a comment for a file. + // + // key = "the first value" + // ``` + // ```toml + // # this is a comment for "the first value". + // key = "the first value" + // ``` + std::vector comments; + using lex_first_comments = sequence< + repeat, lex_comment, lex_newline>, at_least<1>>, + sequence, lex_newline> + >; + if(const auto token = lex_first_comments::invoke(loc)) + { + location inner_loc(loc.name(), token.unwrap().str()); + while(inner_loc.iter() != inner_loc.end()) + { + maybe::invoke(inner_loc); // remove ws if exists + if(lex_newline::invoke(inner_loc)) + { + assert(inner_loc.iter() == inner_loc.end()); + break; // empty line found. + } + auto com = lex_comment::invoke(inner_loc).unwrap().str(); + com.erase(com.begin()); // remove # sign + comments.push_back(std::move(com)); + lex_newline::invoke(inner_loc); + } + } + + table_type data; + // root object is also a table, but without [tablename] + if(auto tab = parse_ml_table(loc)) + { + data = std::move(tab.unwrap()); + } + else // failed (empty table is regarded as success in parse_ml_table) + { + return err(tab.unwrap_err()); + } + while(loc.iter() != loc.end()) + { + // here, the region of [table] is regarded as the table-key because + // the table body is normally too big and it is not so informative + // if the first key-value pair of the table is shown in the error + // message. + if(const auto tabkey = parse_array_table_key(loc)) + { + const auto tab = parse_ml_table(loc); + if(!tab){return err(tab.unwrap_err());} + + const auto& tk = tabkey.unwrap(); + const auto& keys = tk.first; + const auto& reg = tk.second; + + const auto inserted = insert_nested_key(data, + value_type(tab.unwrap(), reg, reg.comments()), + keys.begin(), keys.end(), reg, + /*is_array_of_table=*/ true); + if(!inserted) {return err(inserted.unwrap_err());} + + continue; + } + if(const auto tabkey = parse_table_key(loc)) + { + const auto tab = parse_ml_table(loc); + if(!tab){return err(tab.unwrap_err());} + + const auto& tk = tabkey.unwrap(); + const auto& keys = tk.first; + const auto& reg = tk.second; + + const auto inserted = insert_nested_key(data, + value_type(tab.unwrap(), reg, reg.comments()), + keys.begin(), keys.end(), reg); + if(!inserted) {return err(inserted.unwrap_err());} + + continue; + } + return err(format_underline("toml::parse_toml_file: " + "unknown line appeared", {{source_location(loc), "unknown format"}})); + } + + return ok(Value(std::move(data), file, comments)); +} + +} // detail + +template class Table = std::unordered_map, + template class Array = std::vector> +basic_value +parse(std::istream& is, const std::string& fname = "unknown file") +{ + using value_type = basic_value; + + const auto beg = is.tellg(); + is.seekg(0, std::ios::end); + const auto end = is.tellg(); + const auto fsize = end - beg; + is.seekg(beg); + + // read whole file as a sequence of char + assert(fsize >= 0); + std::vector letters(static_cast(fsize)); + is.read(letters.data(), fsize); + + while(!letters.empty() && letters.back() == '\0') + { + letters.pop_back(); + } + assert(letters.empty() || letters.back() != '\0'); + + detail::location loc(std::move(fname), std::move(letters)); + + // skip BOM if exists. + // XXX component of BOM (like 0xEF) exceeds the representable range of + // signed char, so on some (actually, most) of the environment, these cannot + // be compared to char. However, since we are always out of luck, we need to + // check our chars are equivalent to BOM. To do this, first we need to + // convert char to unsigned char to guarantee the comparability. + if(loc.source()->size() >= 3) + { + std::array BOM; + std::memcpy(BOM.data(), loc.source()->data(), 3); + if(BOM[0] == 0xEF && BOM[1] == 0xBB && BOM[2] == 0xBF) + { + loc.advance(3); // BOM found. skip. + } + } + + const auto data = detail::parse_toml_file(loc); + if(!data) + { + throw syntax_error(data.unwrap_err(), source_location(loc)); + } + return data.unwrap(); +} + +template class Table = std::unordered_map, + template class Array = std::vector> +basic_value parse(const std::string& fname) +{ + std::ifstream ifs(fname.c_str(), std::ios_base::binary); + if(!ifs.good()) + { + throw std::runtime_error("toml::parse: file open error -> " + fname); + } + return parse(ifs, fname); +} + +#ifdef TOML11_HAS_STD_FILESYSTEM +// This function just forwards `parse("filename.toml")` to std::string version +// to avoid the ambiguity in overload resolution. +// +// Both std::string and std::filesystem::path are convertible from const char*. +// Without this, both parse(std::string) and parse(std::filesystem::path) +// matches to parse("filename.toml"). This breaks the existing code. +// +// This function exactly matches to the invokation with c-string. +// So this function is preferred than others and the ambiguity disappears. +template class Table = std::unordered_map, + template class Array = std::vector> +basic_value parse(const char* fname) +{ + return parse(std::string(fname)); +} + +template class Table = std::unordered_map, + template class Array = std::vector> +basic_value parse(const std::filesystem::path& fpath) +{ + std::ifstream ifs(fpath, std::ios_base::binary); + if(!ifs.good()) + { + throw std::runtime_error("toml::parse: file open error -> " + + fpath.string()); + } + return parse(ifs, fpath.string()); +} +#endif // TOML11_HAS_STD_FILESYSTEM + +} // toml +#endif// TOML11_PARSER_HPP diff --git a/libraries/toml11/include/toml/region.hpp b/libraries/toml11/include/toml/region.hpp new file mode 100644 index 00000000..37ba3a30 --- /dev/null +++ b/libraries/toml11/include/toml/region.hpp @@ -0,0 +1,417 @@ +// Copyright Toru Niina 2017. +// Distributed under the MIT License. +#ifndef TOML11_REGION_HPP +#define TOML11_REGION_HPP +#include +#include +#include +#include +#include +#include +#include +#include "color.hpp" + +namespace toml +{ +namespace detail +{ + +// helper function to avoid std::string(0, 'c') or std::string(iter, iter) +template +std::string make_string(Iterator first, Iterator last) +{ + if(first == last) {return "";} + return std::string(first, last); +} +inline std::string make_string(std::size_t len, char c) +{ + if(len == 0) {return "";} + return std::string(len, c); +} + +// region_base is a base class of location and region that are defined below. +// it will be used to generate better error messages. +struct region_base +{ + region_base() = default; + virtual ~region_base() = default; + region_base(const region_base&) = default; + region_base(region_base&& ) = default; + region_base& operator=(const region_base&) = default; + region_base& operator=(region_base&& ) = default; + + virtual bool is_ok() const noexcept {return false;} + virtual char front() const noexcept {return '\0';} + + virtual std::string str() const {return std::string("unknown region");} + virtual std::string name() const {return std::string("unknown file");} + virtual std::string line() const {return std::string("unknown line");} + virtual std::string line_num() const {return std::string("?");} + + // length of the region + virtual std::size_t size() const noexcept {return 0;} + // number of characters in the line before the region + virtual std::size_t before() const noexcept {return 0;} + // number of characters in the line after the region + virtual std::size_t after() const noexcept {return 0;} + + virtual std::vector comments() const {return {};} + // ```toml + // # comment_before + // key = "value" # comment_inline + // ``` +}; + +// location represents a position in a container, which contains a file content. +// it can be considered as a region that contains only one character. +// +// it contains pointer to the file content and iterator that points the current +// location. +struct location final : public region_base +{ + using const_iterator = typename std::vector::const_iterator; + using difference_type = typename const_iterator::difference_type; + using source_ptr = std::shared_ptr>; + + location(std::string name, std::vector cont) + : source_(std::make_shared>(std::move(cont))), + line_number_(1), source_name_(std::move(name)), iter_(source_->cbegin()) + {} + location(std::string name, const std::string& cont) + : source_(std::make_shared>(cont.begin(), cont.end())), + line_number_(1), source_name_(std::move(name)), iter_(source_->cbegin()) + {} + + location(const location&) = default; + location(location&&) = default; + location& operator=(const location&) = default; + location& operator=(location&&) = default; + ~location() = default; + + bool is_ok() const noexcept override {return static_cast(source_);} + char front() const noexcept override {return *iter_;} + + // this const prohibits codes like `++(loc.iter())`. + const const_iterator iter() const noexcept {return iter_;} + + const_iterator begin() const noexcept {return source_->cbegin();} + const_iterator end() const noexcept {return source_->cend();} + + // XXX `location::line_num()` used to be implemented using `std::count` to + // count a number of '\n'. But with a long toml file (typically, 10k lines), + // it becomes intolerably slow because each time it generates error messages, + // it counts '\n' from thousands of characters. To workaround it, I decided + // to introduce `location::line_number_` member variable and synchronize it + // to the location changes the point to look. So an overload of `iter()` + // which returns mutable reference is removed and `advance()`, `retrace()` + // and `reset()` is added. + void advance(difference_type n = 1) noexcept + { + this->line_number_ += static_cast( + std::count(this->iter_, std::next(this->iter_, n), '\n')); + this->iter_ += n; + return; + } + void retrace(difference_type n = 1) noexcept + { + this->line_number_ -= static_cast( + std::count(std::prev(this->iter_, n), this->iter_, '\n')); + this->iter_ -= n; + return; + } + void reset(const_iterator rollback) noexcept + { + // since c++11, std::distance works in both ways for random-access + // iterators and returns a negative value if `first > last`. + if(0 <= std::distance(rollback, this->iter_)) // rollback < iter + { + this->line_number_ -= static_cast( + std::count(rollback, this->iter_, '\n')); + } + else // iter < rollback [[unlikely]] + { + this->line_number_ += static_cast( + std::count(this->iter_, rollback, '\n')); + } + this->iter_ = rollback; + return; + } + + std::string str() const override {return make_string(1, *this->iter());} + std::string name() const override {return source_name_;} + + std::string line_num() const override + { + return std::to_string(this->line_number_); + } + + std::string line() const override + { + return make_string(this->line_begin(), this->line_end()); + } + + const_iterator line_begin() const noexcept + { + using reverse_iterator = std::reverse_iterator; + return std::find(reverse_iterator(this->iter()), + reverse_iterator(this->begin()), '\n').base(); + } + const_iterator line_end() const noexcept + { + return std::find(this->iter(), this->end(), '\n'); + } + + // location is always points a character. so the size is 1. + std::size_t size() const noexcept override + { + return 1u; + } + std::size_t before() const noexcept override + { + const auto sz = std::distance(this->line_begin(), this->iter()); + assert(sz >= 0); + return static_cast(sz); + } + std::size_t after() const noexcept override + { + const auto sz = std::distance(this->iter(), this->line_end()); + assert(sz >= 0); + return static_cast(sz); + } + + source_ptr const& source() const& noexcept {return source_;} + source_ptr&& source() && noexcept {return std::move(source_);} + + private: + + source_ptr source_; + std::size_t line_number_; + std::string source_name_; + const_iterator iter_; +}; + +// region represents a range in a container, which contains a file content. +// +// it contains pointer to the file content and iterator that points the first +// and last location. +struct region final : public region_base +{ + using const_iterator = typename std::vector::const_iterator; + using source_ptr = std::shared_ptr>; + + // delete default constructor. source_ never be null. + region() = delete; + + explicit region(const location& loc) + : source_(loc.source()), source_name_(loc.name()), + first_(loc.iter()), last_(loc.iter()) + {} + explicit region(location&& loc) + : source_(loc.source()), source_name_(loc.name()), + first_(loc.iter()), last_(loc.iter()) + {} + + region(const location& loc, const_iterator f, const_iterator l) + : source_(loc.source()), source_name_(loc.name()), first_(f), last_(l) + {} + region(location&& loc, const_iterator f, const_iterator l) + : source_(loc.source()), source_name_(loc.name()), first_(f), last_(l) + {} + + region(const region&) = default; + region(region&&) = default; + region& operator=(const region&) = default; + region& operator=(region&&) = default; + ~region() = default; + + region& operator+=(const region& other) + { + // different regions cannot be concatenated + assert(this->begin() == other.begin() && this->end() == other.end() && + this->last_ == other.first_); + + this->last_ = other.last_; + return *this; + } + + bool is_ok() const noexcept override {return static_cast(source_);} + char front() const noexcept override {return *first_;} + + std::string str() const override {return make_string(first_, last_);} + std::string line() const override + { + if(this->contain_newline()) + { + return make_string(this->line_begin(), + std::find(this->line_begin(), this->last(), '\n')); + } + return make_string(this->line_begin(), this->line_end()); + } + std::string line_num() const override + { + return std::to_string(1 + std::count(this->begin(), this->first(), '\n')); + } + + std::size_t size() const noexcept override + { + const auto sz = std::distance(first_, last_); + assert(sz >= 0); + return static_cast(sz); + } + std::size_t before() const noexcept override + { + const auto sz = std::distance(this->line_begin(), this->first()); + assert(sz >= 0); + return static_cast(sz); + } + std::size_t after() const noexcept override + { + const auto sz = std::distance(this->last(), this->line_end()); + assert(sz >= 0); + return static_cast(sz); + } + + bool contain_newline() const noexcept + { + return std::find(this->first(), this->last(), '\n') != this->last(); + } + + const_iterator line_begin() const noexcept + { + using reverse_iterator = std::reverse_iterator; + return std::find(reverse_iterator(this->first()), + reverse_iterator(this->begin()), '\n').base(); + } + const_iterator line_end() const noexcept + { + return std::find(this->last(), this->end(), '\n'); + } + + const_iterator begin() const noexcept {return source_->cbegin();} + const_iterator end() const noexcept {return source_->cend();} + const_iterator first() const noexcept {return first_;} + const_iterator last() const noexcept {return last_;} + + source_ptr const& source() const& noexcept {return source_;} + source_ptr&& source() && noexcept {return std::move(source_);} + + std::string name() const override {return source_name_;} + + std::vector comments() const override + { + // assuming the current region (`*this`) points a value. + // ```toml + // a = "value" + // ^^^^^^^- this region + // ``` + using rev_iter = std::reverse_iterator; + + std::vector com{}; + { + // find comments just before the current region. + // ```toml + // # this should be collected. + // # this also. + // a = value # not this. + // ``` + + // # this is a comment for `a`, not array elements. + // a = [1, 2, 3, 4, 5] + if(this->first() == std::find_if(this->line_begin(), this->first(), + [](const char c) noexcept -> bool {return c == '[' || c == '{';})) + { + auto iter = this->line_begin(); // points the first character + while(iter != this->begin()) + { + iter = std::prev(iter); + + // range [line_start, iter) represents the previous line + const auto line_start = std::find( + rev_iter(iter), rev_iter(this->begin()), '\n').base(); + const auto comment_found = std::find(line_start, iter, '#'); + if(comment_found == iter) + { + break; // comment not found. + } + + // exclude the following case. + // > a = "foo" # comment // <-- this is not a comment for b but a. + // > b = "current value" + if(std::all_of(line_start, comment_found, + [](const char c) noexcept -> bool { + return c == ' ' || c == '\t'; + })) + { + // unwrap the first '#' by std::next. + auto str = make_string(std::next(comment_found), iter); + if(!str.empty() && str.back() == '\r') {str.pop_back();} + com.push_back(std::move(str)); + } + else + { + break; + } + iter = line_start; + } + } + } + + if(com.size() > 1) + { + std::reverse(com.begin(), com.end()); + } + + { + // find comments just after the current region. + // ```toml + // # not this. + // a = value # this one. + // a = [ # not this (technically difficult) + // + // ] # and this. + // ``` + // The reason why it's difficult is that it requires parsing in the + // following case. + // ```toml + // a = [ 10 # this comment is for `10`. not for `a` but `a[0]`. + // # ... + // ] # this is apparently a comment for a. + // + // b = [ + // 3.14 ] # there is no way to add a comment to `3.14` currently. + // + // c = [ + // 3.14 # do this if you need a comment here. + // ] + // ``` + const auto comment_found = + std::find(this->last(), this->line_end(), '#'); + if(comment_found != this->line_end()) // '#' found + { + // table = {key = "value"} # what is this for? + // the above comment is not for "value", but {key="value"}. + if(comment_found == std::find_if(this->last(), comment_found, + [](const char c) noexcept -> bool { + return !(c == ' ' || c == '\t' || c == ','); + })) + { + // unwrap the first '#' by std::next. + auto str = make_string(std::next(comment_found), this->line_end()); + if(!str.empty() && str.back() == '\r') {str.pop_back();} + com.push_back(std::move(str)); + } + } + } + return com; + } + + private: + + source_ptr source_; + std::string source_name_; + const_iterator first_, last_; +}; + +} // detail +} // toml +#endif// TOML11_REGION_H diff --git a/libraries/toml11/include/toml/result.hpp b/libraries/toml11/include/toml/result.hpp new file mode 100644 index 00000000..77cd46c6 --- /dev/null +++ b/libraries/toml11/include/toml/result.hpp @@ -0,0 +1,717 @@ +// Copyright Toru Niina 2017. +// Distributed under the MIT License. +#ifndef TOML11_RESULT_HPP +#define TOML11_RESULT_HPP +#include "traits.hpp" +#include +#include +#include +#include +#include +#include +#include + +namespace toml +{ + +template +struct success +{ + using value_type = T; + value_type value; + + explicit success(const value_type& v) + noexcept(std::is_nothrow_copy_constructible::value) + : value(v) + {} + explicit success(value_type&& v) + noexcept(std::is_nothrow_move_constructible::value) + : value(std::move(v)) + {} + + template + explicit success(U&& v): value(std::forward(v)) {} + + template + explicit success(const success& v): value(v.value) {} + template + explicit success(success&& v): value(std::move(v.value)) {} + + ~success() = default; + success(const success&) = default; + success(success&&) = default; + success& operator=(const success&) = default; + success& operator=(success&&) = default; +}; + +template +struct failure +{ + using value_type = T; + value_type value; + + explicit failure(const value_type& v) + noexcept(std::is_nothrow_copy_constructible::value) + : value(v) + {} + explicit failure(value_type&& v) + noexcept(std::is_nothrow_move_constructible::value) + : value(std::move(v)) + {} + + template + explicit failure(U&& v): value(std::forward(v)) {} + + template + explicit failure(const failure& v): value(v.value) {} + template + explicit failure(failure&& v): value(std::move(v.value)) {} + + ~failure() = default; + failure(const failure&) = default; + failure(failure&&) = default; + failure& operator=(const failure&) = default; + failure& operator=(failure&&) = default; +}; + +template +success::type>::type> +ok(T&& v) +{ + return success< + typename std::remove_cv::type>::type + >(std::forward(v)); +} +template +failure::type>::type> +err(T&& v) +{ + return failure< + typename std::remove_cv::type>::type + >(std::forward(v)); +} + +inline success ok(const char* literal) +{ + return success(std::string(literal)); +} +inline failure err(const char* literal) +{ + return failure(std::string(literal)); +} + + +template +struct result +{ + using value_type = T; + using error_type = E; + using success_type = success; + using failure_type = failure; + + result(const success_type& s): is_ok_(true) + { + auto tmp = ::new(std::addressof(this->succ)) success_type(s); + assert(tmp == std::addressof(this->succ)); + (void)tmp; + } + result(const failure_type& f): is_ok_(false) + { + auto tmp = ::new(std::addressof(this->fail)) failure_type(f); + assert(tmp == std::addressof(this->fail)); + (void)tmp; + } + result(success_type&& s): is_ok_(true) + { + auto tmp = ::new(std::addressof(this->succ)) success_type(std::move(s)); + assert(tmp == std::addressof(this->succ)); + (void)tmp; + } + result(failure_type&& f): is_ok_(false) + { + auto tmp = ::new(std::addressof(this->fail)) failure_type(std::move(f)); + assert(tmp == std::addressof(this->fail)); + (void)tmp; + } + + template + result(const success& s): is_ok_(true) + { + auto tmp = ::new(std::addressof(this->succ)) success_type(s.value); + assert(tmp == std::addressof(this->succ)); + (void)tmp; + } + template + result(const failure& f): is_ok_(false) + { + auto tmp = ::new(std::addressof(this->fail)) failure_type(f.value); + assert(tmp == std::addressof(this->fail)); + (void)tmp; + } + template + result(success&& s): is_ok_(true) + { + auto tmp = ::new(std::addressof(this->succ)) success_type(std::move(s.value)); + assert(tmp == std::addressof(this->succ)); + (void)tmp; + } + template + result(failure&& f): is_ok_(false) + { + auto tmp = ::new(std::addressof(this->fail)) failure_type(std::move(f.value)); + assert(tmp == std::addressof(this->fail)); + (void)tmp; + } + + result& operator=(const success_type& s) + { + this->cleanup(); + this->is_ok_ = true; + auto tmp = ::new(std::addressof(this->succ)) success_type(s); + assert(tmp == std::addressof(this->succ)); + (void)tmp; + return *this; + } + result& operator=(const failure_type& f) + { + this->cleanup(); + this->is_ok_ = false; + auto tmp = ::new(std::addressof(this->fail)) failure_type(f); + assert(tmp == std::addressof(this->fail)); + (void)tmp; + return *this; + } + result& operator=(success_type&& s) + { + this->cleanup(); + this->is_ok_ = true; + auto tmp = ::new(std::addressof(this->succ)) success_type(std::move(s)); + assert(tmp == std::addressof(this->succ)); + (void)tmp; + return *this; + } + result& operator=(failure_type&& f) + { + this->cleanup(); + this->is_ok_ = false; + auto tmp = ::new(std::addressof(this->fail)) failure_type(std::move(f)); + assert(tmp == std::addressof(this->fail)); + (void)tmp; + return *this; + } + + template + result& operator=(const success& s) + { + this->cleanup(); + this->is_ok_ = true; + auto tmp = ::new(std::addressof(this->succ)) success_type(s.value); + assert(tmp == std::addressof(this->succ)); + (void)tmp; + return *this; + } + template + result& operator=(const failure& f) + { + this->cleanup(); + this->is_ok_ = false; + auto tmp = ::new(std::addressof(this->fail)) failure_type(f.value); + assert(tmp == std::addressof(this->fail)); + (void)tmp; + return *this; + } + template + result& operator=(success&& s) + { + this->cleanup(); + this->is_ok_ = true; + auto tmp = ::new(std::addressof(this->succ)) success_type(std::move(s.value)); + assert(tmp == std::addressof(this->succ)); + (void)tmp; + return *this; + } + template + result& operator=(failure&& f) + { + this->cleanup(); + this->is_ok_ = false; + auto tmp = ::new(std::addressof(this->fail)) failure_type(std::move(f.value)); + assert(tmp == std::addressof(this->fail)); + (void)tmp; + return *this; + } + + ~result() noexcept {this->cleanup();} + + result(const result& other): is_ok_(other.is_ok()) + { + if(other.is_ok()) + { + auto tmp = ::new(std::addressof(this->succ)) success_type(other.as_ok()); + assert(tmp == std::addressof(this->succ)); + (void)tmp; + } + else + { + auto tmp = ::new(std::addressof(this->fail)) failure_type(other.as_err()); + assert(tmp == std::addressof(this->fail)); + (void)tmp; + } + } + result(result&& other): is_ok_(other.is_ok()) + { + if(other.is_ok()) + { + auto tmp = ::new(std::addressof(this->succ)) success_type(std::move(other.as_ok())); + assert(tmp == std::addressof(this->succ)); + (void)tmp; + } + else + { + auto tmp = ::new(std::addressof(this->fail)) failure_type(std::move(other.as_err())); + assert(tmp == std::addressof(this->fail)); + (void)tmp; + } + } + + template + result(const result& other): is_ok_(other.is_ok()) + { + if(other.is_ok()) + { + auto tmp = ::new(std::addressof(this->succ)) success_type(other.as_ok()); + assert(tmp == std::addressof(this->succ)); + (void)tmp; + } + else + { + auto tmp = ::new(std::addressof(this->fail)) failure_type(other.as_err()); + assert(tmp == std::addressof(this->fail)); + (void)tmp; + } + } + template + result(result&& other): is_ok_(other.is_ok()) + { + if(other.is_ok()) + { + auto tmp = ::new(std::addressof(this->succ)) success_type(std::move(other.as_ok())); + assert(tmp == std::addressof(this->succ)); + (void)tmp; + } + else + { + auto tmp = ::new(std::addressof(this->fail)) failure_type(std::move(other.as_err())); + assert(tmp == std::addressof(this->fail)); + (void)tmp; + } + } + + result& operator=(const result& other) + { + this->cleanup(); + if(other.is_ok()) + { + auto tmp = ::new(std::addressof(this->succ)) success_type(other.as_ok()); + assert(tmp == std::addressof(this->succ)); + (void)tmp; + } + else + { + auto tmp = ::new(std::addressof(this->fail)) failure_type(other.as_err()); + assert(tmp == std::addressof(this->fail)); + (void)tmp; + } + is_ok_ = other.is_ok(); + return *this; + } + result& operator=(result&& other) + { + this->cleanup(); + if(other.is_ok()) + { + auto tmp = ::new(std::addressof(this->succ)) success_type(std::move(other.as_ok())); + assert(tmp == std::addressof(this->succ)); + (void)tmp; + } + else + { + auto tmp = ::new(std::addressof(this->fail)) failure_type(std::move(other.as_err())); + assert(tmp == std::addressof(this->fail)); + (void)tmp; + } + is_ok_ = other.is_ok(); + return *this; + } + + template + result& operator=(const result& other) + { + this->cleanup(); + if(other.is_ok()) + { + auto tmp = ::new(std::addressof(this->succ)) success_type(other.as_ok()); + assert(tmp == std::addressof(this->succ)); + (void)tmp; + } + else + { + auto tmp = ::new(std::addressof(this->fail)) failure_type(other.as_err()); + assert(tmp == std::addressof(this->fail)); + (void)tmp; + } + is_ok_ = other.is_ok(); + return *this; + } + template + result& operator=(result&& other) + { + this->cleanup(); + if(other.is_ok()) + { + auto tmp = ::new(std::addressof(this->succ)) success_type(std::move(other.as_ok())); + assert(tmp == std::addressof(this->succ)); + (void)tmp; + } + else + { + auto tmp = ::new(std::addressof(this->fail)) failure_type(std::move(other.as_err())); + assert(tmp == std::addressof(this->fail)); + (void)tmp; + } + is_ok_ = other.is_ok(); + return *this; + } + + bool is_ok() const noexcept {return is_ok_;} + bool is_err() const noexcept {return !is_ok_;} + + operator bool() const noexcept {return is_ok_;} + + value_type& unwrap() & + { + if(is_err()) + { + throw std::runtime_error("toml::result: bad unwrap: " + + format_error(this->as_err())); + } + return this->succ.value; + } + value_type const& unwrap() const& + { + if(is_err()) + { + throw std::runtime_error("toml::result: bad unwrap: " + + format_error(this->as_err())); + } + return this->succ.value; + } + value_type&& unwrap() && + { + if(is_err()) + { + throw std::runtime_error("toml::result: bad unwrap: " + + format_error(this->as_err())); + } + return std::move(this->succ.value); + } + + value_type& unwrap_or(value_type& opt) & + { + if(is_err()) {return opt;} + return this->succ.value; + } + value_type const& unwrap_or(value_type const& opt) const& + { + if(is_err()) {return opt;} + return this->succ.value; + } + value_type unwrap_or(value_type opt) && + { + if(is_err()) {return opt;} + return this->succ.value; + } + + error_type& unwrap_err() & + { + if(is_ok()) {throw std::runtime_error("toml::result: bad unwrap_err");} + return this->fail.value; + } + error_type const& unwrap_err() const& + { + if(is_ok()) {throw std::runtime_error("toml::result: bad unwrap_err");} + return this->fail.value; + } + error_type&& unwrap_err() && + { + if(is_ok()) {throw std::runtime_error("toml::result: bad unwrap_err");} + return std::move(this->fail.value); + } + + value_type& as_ok() & noexcept {return this->succ.value;} + value_type const& as_ok() const& noexcept {return this->succ.value;} + value_type&& as_ok() && noexcept {return std::move(this->succ.value);} + + error_type& as_err() & noexcept {return this->fail.value;} + error_type const& as_err() const& noexcept {return this->fail.value;} + error_type&& as_err() && noexcept {return std::move(this->fail.value);} + + + // prerequisities + // F: T -> U + // retval: result + template + result, error_type> + map(F&& f) & + { + if(this->is_ok()){return ok(f(this->as_ok()));} + return err(this->as_err()); + } + template + result, error_type> + map(F&& f) const& + { + if(this->is_ok()){return ok(f(this->as_ok()));} + return err(this->as_err()); + } + template + result, error_type> + map(F&& f) && + { + if(this->is_ok()){return ok(f(std::move(this->as_ok())));} + return err(std::move(this->as_err())); + } + + // prerequisities + // F: E -> F + // retval: result + template + result> + map_err(F&& f) & + { + if(this->is_err()){return err(f(this->as_err()));} + return ok(this->as_ok()); + } + template + result> + map_err(F&& f) const& + { + if(this->is_err()){return err(f(this->as_err()));} + return ok(this->as_ok()); + } + template + result> + map_err(F&& f) && + { + if(this->is_err()){return err(f(std::move(this->as_err())));} + return ok(std::move(this->as_ok())); + } + + // prerequisities + // F: T -> U + // retval: U + template + detail::return_type_of_t + map_or_else(F&& f, U&& opt) & + { + if(this->is_err()){return std::forward(opt);} + return f(this->as_ok()); + } + template + detail::return_type_of_t + map_or_else(F&& f, U&& opt) const& + { + if(this->is_err()){return std::forward(opt);} + return f(this->as_ok()); + } + template + detail::return_type_of_t + map_or_else(F&& f, U&& opt) && + { + if(this->is_err()){return std::forward(opt);} + return f(std::move(this->as_ok())); + } + + // prerequisities + // F: E -> U + // retval: U + template + detail::return_type_of_t + map_err_or_else(F&& f, U&& opt) & + { + if(this->is_ok()){return std::forward(opt);} + return f(this->as_err()); + } + template + detail::return_type_of_t + map_err_or_else(F&& f, U&& opt) const& + { + if(this->is_ok()){return std::forward(opt);} + return f(this->as_err()); + } + template + detail::return_type_of_t + map_err_or_else(F&& f, U&& opt) && + { + if(this->is_ok()){return std::forward(opt);} + return f(std::move(this->as_err())); + } + + // prerequisities: + // F: func T -> U + // toml::err(error_type) should be convertible to U. + // normally, type U is another result and E is convertible to F + template + detail::return_type_of_t + and_then(F&& f) & + { + if(this->is_ok()){return f(this->as_ok());} + return err(this->as_err()); + } + template + detail::return_type_of_t + and_then(F&& f) const& + { + if(this->is_ok()){return f(this->as_ok());} + return err(this->as_err()); + } + template + detail::return_type_of_t + and_then(F&& f) && + { + if(this->is_ok()){return f(std::move(this->as_ok()));} + return err(std::move(this->as_err())); + } + + // prerequisities: + // F: func E -> U + // toml::ok(value_type) should be convertible to U. + // normally, type U is another result and T is convertible to S + template + detail::return_type_of_t + or_else(F&& f) & + { + if(this->is_err()){return f(this->as_err());} + return ok(this->as_ok()); + } + template + detail::return_type_of_t + or_else(F&& f) const& + { + if(this->is_err()){return f(this->as_err());} + return ok(this->as_ok()); + } + template + detail::return_type_of_t + or_else(F&& f) && + { + if(this->is_err()){return f(std::move(this->as_err()));} + return ok(std::move(this->as_ok())); + } + + // if *this is error, returns *this. otherwise, returns other. + result and_other(const result& other) const& + { + return this->is_err() ? *this : other; + } + result and_other(result&& other) && + { + return this->is_err() ? std::move(*this) : std::move(other); + } + + // if *this is okay, returns *this. otherwise, returns other. + result or_other(const result& other) const& + { + return this->is_ok() ? *this : other; + } + result or_other(result&& other) && + { + return this->is_ok() ? std::move(*this) : std::move(other); + } + + void swap(result& other) + { + result tmp(std::move(*this)); + *this = std::move(other); + other = std::move(tmp); + return ; + } + + private: + + static std::string format_error(std::exception const& excpt) + { + return std::string(excpt.what()); + } + template::value, std::nullptr_t>::type = nullptr> + static std::string format_error(U const& others) + { + std::ostringstream oss; oss << others; + return oss.str(); + } + + void cleanup() noexcept + { + if(this->is_ok_) {this->succ.~success_type();} + else {this->fail.~failure_type();} + return; + } + + private: + + bool is_ok_; + union + { + success_type succ; + failure_type fail; + }; +}; + +template +void swap(result& lhs, result& rhs) +{ + lhs.swap(rhs); + return; +} + +// this might be confusing because it eagerly evaluated, while in the other +// cases operator && and || are short-circuited. +// +// template +// inline result +// operator&&(const result& lhs, const result& rhs) noexcept +// { +// return lhs.is_ok() ? rhs : lhs; +// } +// +// template +// inline result +// operator||(const result& lhs, const result& rhs) noexcept +// { +// return lhs.is_ok() ? lhs : rhs; +// } + +// ---------------------------------------------------------------------------- +// re-use result as a optional with none_t + +namespace detail +{ +struct none_t {}; +inline bool operator==(const none_t&, const none_t&) noexcept {return true;} +inline bool operator!=(const none_t&, const none_t&) noexcept {return false;} +inline bool operator< (const none_t&, const none_t&) noexcept {return false;} +inline bool operator<=(const none_t&, const none_t&) noexcept {return true;} +inline bool operator> (const none_t&, const none_t&) noexcept {return false;} +inline bool operator>=(const none_t&, const none_t&) noexcept {return true;} +template +std::basic_ostream& +operator<<(std::basic_ostream& os, const none_t&) +{ + os << "none"; + return os; +} +inline failure none() noexcept {return failure{none_t{}};} +} // detail +} // toml11 +#endif// TOML11_RESULT_H diff --git a/libraries/toml11/include/toml/serializer.hpp b/libraries/toml11/include/toml/serializer.hpp new file mode 100644 index 00000000..77aef589 --- /dev/null +++ b/libraries/toml11/include/toml/serializer.hpp @@ -0,0 +1,853 @@ +// Copyright Toru Niina 2019. +// Distributed under the MIT License. +#ifndef TOML11_SERIALIZER_HPP +#define TOML11_SERIALIZER_HPP +#include + +#include + +#include "lexer.hpp" +#include "value.hpp" + +namespace toml +{ + +// This function serialize a key. It checks a string is a bare key and +// escapes special characters if the string is not compatible to a bare key. +// ```cpp +// std::string k("non.bare.key"); // the key itself includes `.`s. +// std::string formatted = toml::format_key(k); +// assert(formatted == "\"non.bare.key\""); +// ``` +// +// This function is exposed to make it easy to write a user-defined serializer. +// Since toml restricts characters available in a bare key, generally a string +// should be escaped. But checking whether a string needs to be surrounded by +// a `"` and escaping some special character is boring. +template +std::basic_string +format_key(const std::basic_string& key) +{ + // check the key can be a bare (unquoted) key + detail::location loc(key, std::vector(key.begin(), key.end())); + detail::lex_unquoted_key::invoke(loc); + if(loc.iter() == loc.end()) + { + return key; // all the tokens are consumed. the key is unquoted-key. + } + + //if it includes special characters, then format it in a "quoted" key. + std::basic_string serialized("\""); + for(const char c : key) + { + switch(c) + { + case '\\': {serialized += "\\\\"; break;} + case '\"': {serialized += "\\\""; break;} + case '\b': {serialized += "\\b"; break;} + case '\t': {serialized += "\\t"; break;} + case '\f': {serialized += "\\f"; break;} + case '\n': {serialized += "\\n"; break;} + case '\r': {serialized += "\\r"; break;} + default : {serialized += c; break;} + } + } + serialized += "\""; + return serialized; +} + +template +std::basic_string +format_keys(const std::vector>& keys) +{ + std::basic_string serialized; + if(keys.empty()) {return serialized;} + + for(const auto& ky : keys) + { + serialized += format_key(ky); + serialized += charT('.'); + } + serialized.pop_back(); // remove the last dot '.' + return serialized; +} + +template +struct serializer +{ + static_assert(detail::is_basic_value::value, + "toml::serializer is for toml::value and its variants, " + "toml::basic_value<...>."); + + using value_type = Value; + using key_type = typename value_type::key_type ; + using comment_type = typename value_type::comment_type ; + using boolean_type = typename value_type::boolean_type ; + using integer_type = typename value_type::integer_type ; + using floating_type = typename value_type::floating_type ; + using string_type = typename value_type::string_type ; + using local_time_type = typename value_type::local_time_type ; + using local_date_type = typename value_type::local_date_type ; + using local_datetime_type = typename value_type::local_datetime_type ; + using offset_datetime_type = typename value_type::offset_datetime_type; + using array_type = typename value_type::array_type ; + using table_type = typename value_type::table_type ; + + serializer(const std::size_t w = 80u, + const int float_prec = std::numeric_limits::max_digits10, + const bool can_be_inlined = false, + const bool no_comment = false, + std::vector ks = {}, + const bool value_has_comment = false) + : can_be_inlined_(can_be_inlined), no_comment_(no_comment), + value_has_comment_(value_has_comment && !no_comment), + float_prec_(float_prec), width_(w), keys_(std::move(ks)) + {} + ~serializer() = default; + + std::string operator()(const boolean_type& b) const + { + return b ? "true" : "false"; + } + std::string operator()(const integer_type i) const + { + return std::to_string(i); + } + std::string operator()(const floating_type f) const + { + const auto fmt = "%.*g"; + const auto bsz = std::snprintf(nullptr, 0, fmt, this->float_prec_, f); + // +1 for null character(\0) + std::vector buf(static_cast(bsz + 1), '\0'); + std::snprintf(buf.data(), buf.size(), fmt, this->float_prec_, f); + + std::string token(buf.begin(), std::prev(buf.end())); + if(!token.empty() && token.back() == '.') // 1. => 1.0 + { + token += '0'; + } + + const auto e = std::find_if( + token.cbegin(), token.cend(), [](const char c) noexcept -> bool { + return c == 'e' || c == 'E'; + }); + const auto has_exponent = (token.cend() != e); + const auto has_fraction = (token.cend() != std::find( + token.cbegin(), token.cend(), '.')); + + if(!has_exponent && !has_fraction) + { + // the resulting value does not have any float specific part! + token += ".0"; + } + return token; + } + std::string operator()(const string_type& s) const + { + if(s.kind == string_t::basic) + { + if(std::find(s.str.cbegin(), s.str.cend(), '\n') != s.str.cend() || + std::find(s.str.cbegin(), s.str.cend(), '\"') != s.str.cend()) + { + // if linefeed or double-quote is contained, + // make it multiline basic string. + const auto escaped = this->escape_ml_basic_string(s.str); + std::string open("\"\"\""); + std::string close("\"\"\""); + if(escaped.find('\n') != std::string::npos || + this->width_ < escaped.size() + 6) + { + // if the string body contains newline or is enough long, + // add newlines after and before delimiters. + open += "\n"; + close = std::string("\\\n") + close; + } + return open + escaped + close; + } + + // no linefeed. try to make it oneline-string. + std::string oneline = this->escape_basic_string(s.str); + if(oneline.size() + 2 < width_ || width_ < 2) + { + const std::string quote("\""); + return quote + oneline + quote; + } + + // the line is too long compared to the specified width. + // split it into multiple lines. + std::string token("\"\"\"\n"); + while(!oneline.empty()) + { + if(oneline.size() < width_) + { + token += oneline; + oneline.clear(); + } + else if(oneline.at(width_-2) == '\\') + { + token += oneline.substr(0, width_-2); + token += "\\\n"; + oneline.erase(0, width_-2); + } + else + { + token += oneline.substr(0, width_-1); + token += "\\\n"; + oneline.erase(0, width_-1); + } + } + return token + std::string("\\\n\"\"\""); + } + else // the string `s` is literal-string. + { + if(std::find(s.str.cbegin(), s.str.cend(), '\n') != s.str.cend() || + std::find(s.str.cbegin(), s.str.cend(), '\'') != s.str.cend() ) + { + std::string open("'''"); + if(this->width_ + 6 < s.str.size()) + { + open += '\n'; // the first newline is ignored by TOML spec + } + const std::string close("'''"); + return open + s.str + close; + } + else + { + const std::string quote("'"); + return quote + s.str + quote; + } + } + } + + std::string operator()(const local_date_type& d) const + { + std::ostringstream oss; + oss << d; + return oss.str(); + } + std::string operator()(const local_time_type& t) const + { + std::ostringstream oss; + oss << t; + return oss.str(); + } + std::string operator()(const local_datetime_type& dt) const + { + std::ostringstream oss; + oss << dt; + return oss.str(); + } + std::string operator()(const offset_datetime_type& odt) const + { + std::ostringstream oss; + oss << odt; + return oss.str(); + } + + std::string operator()(const array_type& v) const + { + if(v.empty()) + { + return std::string("[]"); + } + if(this->is_array_of_tables(v)) + { + return make_array_of_tables(v); + } + + // not an array of tables. normal array. + // first, try to make it inline if none of the elements have a comment. + if( ! this->has_comment_inside(v)) + { + const auto inl = this->make_inline_array(v); + if(inl.size() < this->width_ && + std::find(inl.cbegin(), inl.cend(), '\n') == inl.cend()) + { + return inl; + } + } + + // if the length exceeds this->width_, print multiline array. + // key = [ + // # ... + // 42, + // ... + // ] + std::string token; + std::string current_line; + token += "[\n"; + for(const auto& item : v) + { + if( ! item.comments().empty() && !no_comment_) + { + // if comment exists, the element must be the only element in the line. + // e.g. the following is not allowed. + // ```toml + // array = [ + // # comment for what? + // 1, 2, 3, 4, 5 + // ] + // ``` + if(!current_line.empty()) + { + if(current_line.back() != '\n') + { + current_line += '\n'; + } + token += current_line; + current_line.clear(); + } + for(const auto& c : item.comments()) + { + token += '#'; + token += c; + token += '\n'; + } + token += toml::visit(*this, item); + if(!token.empty() && token.back() == '\n') {token.pop_back();} + token += ",\n"; + continue; + } + std::string next_elem; + next_elem += toml::visit(*this, item); + + // comma before newline. + if(!next_elem.empty() && next_elem.back() == '\n') {next_elem.pop_back();} + + // if current line does not exceeds the width limit, continue. + if(current_line.size() + next_elem.size() + 1 < this->width_) + { + current_line += next_elem; + current_line += ','; + } + else if(current_line.empty()) + { + // if current line was empty, force put the next_elem because + // next_elem is not splittable + token += next_elem; + token += ",\n"; + // current_line is kept empty + } + else // reset current_line + { + assert(current_line.back() == ','); + token += current_line; + token += '\n'; + current_line = next_elem; + current_line += ','; + } + } + if(!current_line.empty()) + { + if(!current_line.empty() && current_line.back() != '\n') + { + current_line += '\n'; + } + token += current_line; + } + token += "]\n"; + return token; + } + + // templatize for any table-like container + std::string operator()(const table_type& v) const + { + // if an element has a comment, then it can't be inlined. + // table = {# how can we write a comment for this? key = "value"} + if(this->can_be_inlined_ && !(this->has_comment_inside(v))) + { + std::string token; + if(!this->keys_.empty()) + { + token += format_key(this->keys_.back()); + token += " = "; + } + token += this->make_inline_table(v); + if(token.size() < this->width_ && + token.end() == std::find(token.begin(), token.end(), '\n')) + { + return token; + } + } + + std::string token; + if(!keys_.empty()) + { + token += '['; + token += format_keys(keys_); + token += "]\n"; + } + token += this->make_multiline_table(v); + return token; + } + + private: + + std::string escape_basic_string(const std::string& s) const + { + //XXX assuming `s` is a valid utf-8 sequence. + std::string retval; + for(const char c : s) + { + switch(c) + { + case '\\': {retval += "\\\\"; break;} + case '\"': {retval += "\\\""; break;} + case '\b': {retval += "\\b"; break;} + case '\t': {retval += "\\t"; break;} + case '\f': {retval += "\\f"; break;} + case '\n': {retval += "\\n"; break;} + case '\r': {retval += "\\r"; break;} + default : {retval += c; break;} + } + } + return retval; + } + + std::string escape_ml_basic_string(const std::string& s) const + { + std::string retval; + for(auto i=s.cbegin(), e=s.cend(); i!=e; ++i) + { + switch(*i) + { + case '\\': {retval += "\\\\"; break;} + // One or two consecutive "s are allowed. + // Later we will check there are no three consecutive "s. + // case '\"': {retval += "\\\""; break;} + case '\b': {retval += "\\b"; break;} + case '\t': {retval += "\\t"; break;} + case '\f': {retval += "\\f"; break;} + case '\n': {retval += "\n"; break;} + case '\r': + { + if(std::next(i) != e && *std::next(i) == '\n') + { + retval += "\r\n"; + ++i; + } + else + { + retval += "\\r"; + } + break; + } + default: {retval += *i; break;} + } + } + // Only 1 or 2 consecutive `"`s are allowed in multiline basic string. + // 3 consecutive `"`s are considered as a closing delimiter. + // We need to check if there are 3 or more consecutive `"`s and insert + // backslash to break them down into several short `"`s like the `str6` + // in the following example. + // ```toml + // str4 = """Here are two quotation marks: "". Simple enough.""" + // # str5 = """Here are three quotation marks: """.""" # INVALID + // str5 = """Here are three quotation marks: ""\".""" + // str6 = """Here are fifteen quotation marks: ""\"""\"""\"""\"""\".""" + // ``` + auto found_3_quotes = retval.find("\"\"\""); + while(found_3_quotes != std::string::npos) + { + retval.replace(found_3_quotes, 3, "\"\"\\\""); + found_3_quotes = retval.find("\"\"\""); + } + return retval; + } + + // if an element of a table or an array has a comment, it cannot be inlined. + bool has_comment_inside(const array_type& a) const noexcept + { + // if no_comment is set, comments would not be written. + if(this->no_comment_) {return false;} + + for(const auto& v : a) + { + if(!v.comments().empty()) {return true;} + } + return false; + } + bool has_comment_inside(const table_type& t) const noexcept + { + // if no_comment is set, comments would not be written. + if(this->no_comment_) {return false;} + + for(const auto& kv : t) + { + if(!kv.second.comments().empty()) {return true;} + } + return false; + } + + std::string make_inline_array(const array_type& v) const + { + assert(!has_comment_inside(v)); + std::string token; + token += '['; + bool is_first = true; + for(const auto& item : v) + { + if(is_first) {is_first = false;} else {token += ',';} + token += visit(serializer( + (std::numeric_limits::max)(), this->float_prec_, + /* inlined */ true, /*no comment*/ false, /*keys*/ {}, + /*has_comment*/ !item.comments().empty()), item); + } + token += ']'; + return token; + } + + std::string make_inline_table(const table_type& v) const + { + assert(!has_comment_inside(v)); + assert(this->can_be_inlined_); + std::string token; + token += '{'; + bool is_first = true; + for(const auto& kv : v) + { + // in inline tables, trailing comma is not allowed (toml-lang #569). + if(is_first) {is_first = false;} else {token += ',';} + token += format_key(kv.first); + token += '='; + token += visit(serializer( + (std::numeric_limits::max)(), this->float_prec_, + /* inlined */ true, /*no comment*/ false, /*keys*/ {}, + /*has_comment*/ !kv.second.comments().empty()), kv.second); + } + token += '}'; + return token; + } + + std::string make_multiline_table(const table_type& v) const + { + std::string token; + + // print non-table elements first. + // ```toml + // [foo] # a table we're writing now here + // key = "value" # <- non-table element, "key" + // # ... + // [foo.bar] # <- table element, "bar" + // ``` + // because after printing [foo.bar], the remaining non-table values will + // be assigned into [foo.bar], not [foo]. Those values should be printed + // earlier. + for(const auto& kv : v) + { + if(kv.second.is_table() || is_array_of_tables(kv.second)) + { + continue; + } + + token += write_comments(kv.second); + + const auto key_and_sep = format_key(kv.first) + " = "; + const auto residual_width = (this->width_ > key_and_sep.size()) ? + this->width_ - key_and_sep.size() : 0; + token += key_and_sep; + token += visit(serializer(residual_width, this->float_prec_, + /*can be inlined*/ true, /*no comment*/ false, /*keys*/ {}, + /*has_comment*/ !kv.second.comments().empty()), kv.second); + + if(token.back() != '\n') + { + token += '\n'; + } + } + + // normal tables / array of tables + + // after multiline table appeared, the other tables cannot be inline + // because the table would be assigned into the table. + // [foo] + // ... + // bar = {...} # <- bar will be a member of [foo]. + bool multiline_table_printed = false; + for(const auto& kv : v) + { + if(!kv.second.is_table() && !is_array_of_tables(kv.second)) + { + continue; // other stuff are already serialized. skip them. + } + + std::vector ks(this->keys_); + ks.push_back(kv.first); + + auto tmp = visit(serializer(this->width_, this->float_prec_, + !multiline_table_printed, this->no_comment_, ks, + /*has_comment*/ !kv.second.comments().empty()), kv.second); + + // If it is the first time to print a multi-line table, it would be + // helpful to separate normal key-value pair and subtables by a + // newline. + // (this checks if the current key-value pair contains newlines. + // but it is not perfect because multi-line string can also contain + // a newline. in such a case, an empty line will be written) TODO + if((!multiline_table_printed) && + std::find(tmp.cbegin(), tmp.cend(), '\n') != tmp.cend()) + { + multiline_table_printed = true; + token += '\n'; // separate key-value pairs and subtables + + token += write_comments(kv.second); + token += tmp; + + // care about recursive tables (all tables in each level prints + // newline and there will be a full of newlines) + if(tmp.substr(tmp.size() - 2, 2) != "\n\n" && + tmp.substr(tmp.size() - 4, 4) != "\r\n\r\n" ) + { + token += '\n'; + } + } + else + { + token += write_comments(kv.second); + token += tmp; + token += '\n'; + } + } + return token; + } + + std::string make_array_of_tables(const array_type& v) const + { + // if it's not inlined, we need to add `[[table.key]]`. + // but if it can be inlined, we can format it as the following. + // ``` + // table.key = [ + // {...}, + // # comment + // {...}, + // ] + // ``` + // This function checks if inlinization is possible or not, and then + // format the array-of-tables in a proper way. + // + // Note about comments: + // + // If the array itself has a comment (value_has_comment_ == true), we + // should try to make it inline. + // ```toml + // # comment about array + // array = [ + // # comment about table element + // {of = "table"} + // ] + // ``` + // If it is formatted as a multiline table, the two comments becomes + // indistinguishable. + // ```toml + // # comment about array + // # comment about table element + // [[array]] + // of = "table" + // ``` + // So we need to try to make it inline, and it force-inlines regardless + // of the line width limit. + // It may fail if the element of a table has comment. In that case, + // the array-of-tables will be formatted as a multiline table. + if(this->can_be_inlined_ || this->value_has_comment_) + { + std::string token; + if(!keys_.empty()) + { + token += format_key(keys_.back()); + token += " = "; + } + + bool failed = false; + token += "[\n"; + for(const auto& item : v) + { + // if an element of the table has a comment, the table + // cannot be inlined. + if(this->has_comment_inside(item.as_table())) + { + failed = true; + break; + } + // write comments for the table itself + token += write_comments(item); + + const auto t = this->make_inline_table(item.as_table()); + + if(t.size() + 1 > width_ || // +1 for the last comma {...}, + std::find(t.cbegin(), t.cend(), '\n') != t.cend()) + { + // if the value itself has a comment, ignore the line width limit + if( ! this->value_has_comment_) + { + failed = true; + break; + } + } + token += t; + token += ",\n"; + } + + if( ! failed) + { + token += "]\n"; + return token; + } + // if failed, serialize them as [[array.of.tables]]. + } + + std::string token; + for(const auto& item : v) + { + token += write_comments(item); + token += "[["; + token += format_keys(keys_); + token += "]]\n"; + token += this->make_multiline_table(item.as_table()); + } + return token; + } + + std::string write_comments(const value_type& v) const + { + std::string retval; + if(this->no_comment_) {return retval;} + + for(const auto& c : v.comments()) + { + retval += '#'; + retval += c; + retval += '\n'; + } + return retval; + } + + bool is_array_of_tables(const value_type& v) const + { + if(!v.is_array() || v.as_array().empty()) {return false;} + return is_array_of_tables(v.as_array()); + } + bool is_array_of_tables(const array_type& v) const + { + // Since TOML v0.5.0, heterogeneous arrays are allowed. So we need to + // check all the element in an array to check if the array is an array + // of tables. + return std::all_of(v.begin(), v.end(), [](const value_type& elem) { + return elem.is_table(); + }); + } + + private: + + bool can_be_inlined_; + bool no_comment_; + bool value_has_comment_; + int float_prec_; + std::size_t width_; + std::vector keys_; +}; + +template class M, template class V> +std::string +format(const basic_value& v, std::size_t w = 80u, + int fprec = std::numeric_limits::max_digits10, + bool no_comment = false, bool force_inline = false) +{ + using value_type = basic_value; + // if value is a table, it is considered to be a root object. + // the root object can't be an inline table. + if(v.is_table()) + { + std::ostringstream oss; + if(!v.comments().empty()) + { + oss << v.comments(); + oss << '\n'; // to split the file comment from the first element + } + const auto serialized = visit(serializer(w, fprec, no_comment, false), v); + oss << serialized; + return oss.str(); + } + return visit(serializer(w, fprec, force_inline), v); +} + +namespace detail +{ +template +int comment_index(std::basic_ostream&) +{ + static const int index = std::ios_base::xalloc(); + return index; +} +} // detail + +template +std::basic_ostream& +nocomment(std::basic_ostream& os) +{ + // by default, it is zero. and by defalut, it shows comments. + os.iword(detail::comment_index(os)) = 1; + return os; +} + +template +std::basic_ostream& +showcomment(std::basic_ostream& os) +{ + // by default, it is zero. and by defalut, it shows comments. + os.iword(detail::comment_index(os)) = 0; + return os; +} + +template class M, template class V> +std::basic_ostream& +operator<<(std::basic_ostream& os, const basic_value& v) +{ + using value_type = basic_value; + + // get status of std::setw(). + const auto w = static_cast(os.width()); + const int fprec = static_cast(os.precision()); + os.width(0); + + // by defualt, iword is initialized byl 0. And by default, toml11 outputs + // comments. So `0` means showcomment. 1 means nocommnet. + const bool no_comment = (1 == os.iword(detail::comment_index(os))); + + if(!no_comment && v.is_table() && !v.comments().empty()) + { + os << v.comments(); + os << '\n'; // to split the file comment from the first element + } + // the root object can't be an inline table. so pass `false`. + const auto serialized = visit(serializer(w, fprec, no_comment, false), v); + os << serialized; + + // if v is a non-table value, and has only one comment, then + // put a comment just after a value. in the following way. + // + // ```toml + // key = "value" # comment. + // ``` + // + // Since the top-level toml object is a table, one who want to put a + // non-table toml value must use this in a following way. + // + // ```cpp + // toml::value v; + // std::cout << "user-defined-key = " << v << std::endl; + // ``` + // + // In this case, it is impossible to put comments before key-value pair. + // The only way to preserve comments is to put all of them after a value. + if(!no_comment && !v.is_table() && !v.comments().empty()) + { + os << " #"; + for(const auto& c : v.comments()) {os << c;} + } + return os; +} + +} // toml +#endif// TOML11_SERIALIZER_HPP diff --git a/libraries/toml11/include/toml/source_location.hpp b/libraries/toml11/include/toml/source_location.hpp new file mode 100644 index 00000000..fa175b5b --- /dev/null +++ b/libraries/toml11/include/toml/source_location.hpp @@ -0,0 +1,233 @@ +// Copyright Toru Niina 2019. +// Distributed under the MIT License. +#ifndef TOML11_SOURCE_LOCATION_HPP +#define TOML11_SOURCE_LOCATION_HPP +#include +#include + +#include "region.hpp" + +namespace toml +{ + +// A struct to contain location in a toml file. +// The interface imitates std::experimental::source_location, +// but not completely the same. +// +// It would be constructed by toml::value. It can be used to generate +// user-defined error messages. +// +// - std::uint_least32_t line() const noexcept +// - returns the line number where the region is on. +// - std::uint_least32_t column() const noexcept +// - returns the column number where the region starts. +// - std::uint_least32_t region() const noexcept +// - returns the size of the region. +// +// +-- line() +-- region of interest (region() == 9) +// v .---+---. +// 12 | value = "foo bar" +// ^ +// +-- column() +// +// - std::string const& file_name() const noexcept; +// - name of the file. +// - std::string const& line_str() const noexcept; +// - the whole line that contains the region of interest. +// +struct source_location +{ + public: + + source_location() + : line_num_(1), column_num_(1), region_size_(1), + file_name_("unknown file"), line_str_("") + {} + + explicit source_location(const detail::region_base* reg) + : line_num_(1), column_num_(1), region_size_(1), + file_name_("unknown file"), line_str_("") + { + if(reg) + { + if(reg->line_num() != detail::region_base().line_num()) + { + line_num_ = static_cast( + std::stoul(reg->line_num())); + } + column_num_ = static_cast(reg->before() + 1); + region_size_ = static_cast(reg->size()); + file_name_ = reg->name(); + line_str_ = reg->line(); + } + } + + explicit source_location(const detail::region& reg) + : line_num_(static_cast(std::stoul(reg.line_num()))), + column_num_(static_cast(reg.before() + 1)), + region_size_(static_cast(reg.size())), + file_name_(reg.name()), + line_str_ (reg.line()) + {} + explicit source_location(const detail::location& loc) + : line_num_(static_cast(std::stoul(loc.line_num()))), + column_num_(static_cast(loc.before() + 1)), + region_size_(static_cast(loc.size())), + file_name_(loc.name()), + line_str_ (loc.line()) + {} + + ~source_location() = default; + source_location(source_location const&) = default; + source_location(source_location &&) = default; + source_location& operator=(source_location const&) = default; + source_location& operator=(source_location &&) = default; + + std::uint_least32_t line() const noexcept {return line_num_;} + std::uint_least32_t column() const noexcept {return column_num_;} + std::uint_least32_t region() const noexcept {return region_size_;} + + std::string const& file_name() const noexcept {return file_name_;} + std::string const& line_str() const noexcept {return line_str_;} + + private: + + std::uint_least32_t line_num_; + std::uint_least32_t column_num_; + std::uint_least32_t region_size_; + std::string file_name_; + std::string line_str_; +}; + +namespace detail +{ + +// internal error message generation. +inline std::string format_underline(const std::string& message, + const std::vector>& loc_com, + const std::vector& helps = {}, + const bool colorize = TOML11_ERROR_MESSAGE_COLORIZED) +{ + std::size_t line_num_width = 0; + for(const auto& lc : loc_com) + { + std::uint_least32_t line = lc.first.line(); + std::size_t digit = 0; + while(line != 0) + { + line /= 10; + digit += 1; + } + line_num_width = (std::max)(line_num_width, digit); + } + // 1 is the minimum width + line_num_width = std::max(line_num_width, 1); + + std::ostringstream retval; + + if(colorize) + { + retval << color::colorize; // turn on ANSI color + } + + // XXX + // Here, before `colorize` support, it does not output `[error]` prefix + // automatically. So some user may output it manually and this change may + // duplicate the prefix. To avoid it, check the first 7 characters and + // if it is "[error]", it removes that part from the message shown. + if(message.size() > 7 && message.substr(0, 7) == "[error]") + { + retval << color::bold << color::red << "[error]" << color::reset + << color::bold << message.substr(7) << color::reset << '\n'; + } + else + { + retval << color::bold << color::red << "[error] " << color::reset + << color::bold << message << color::reset << '\n'; + } + + const auto format_one_location = [line_num_width] + (std::ostringstream& oss, + const source_location& loc, const std::string& comment) -> void + { + oss << ' ' << color::bold << color::blue + << std::setw(static_cast(line_num_width)) + << std::right << loc.line() << " | " << color::reset + << loc.line_str() << '\n'; + + oss << make_string(line_num_width + 1, ' ') + << color::bold << color::blue << " | " << color::reset + << make_string(loc.column()-1 /*1-origin*/, ' '); + + if(loc.region() == 1) + { + // invalid + // ^------ + oss << color::bold << color::red << "^---" << color::reset; + } + else + { + // invalid + // ~~~~~~~ + const auto underline_len = (std::min)( + static_cast(loc.region()), loc.line_str().size()); + oss << color::bold << color::red + << make_string(underline_len, '~') << color::reset; + } + oss << ' '; + oss << comment; + return; + }; + + assert(!loc_com.empty()); + + // --> example.toml + // | + retval << color::bold << color::blue << " --> " << color::reset + << loc_com.front().first.file_name() << '\n'; + retval << make_string(line_num_width + 1, ' ') + << color::bold << color::blue << " |\n" << color::reset; + // 1 | key value + // | ^--- missing = + format_one_location(retval, loc_com.front().first, loc_com.front().second); + + // process the rest of the locations + for(std::size_t i=1; i filename.toml" again + { + retval << color::bold << color::blue << " --> " << color::reset + << curr.first.file_name() << '\n'; + retval << make_string(line_num_width + 1, ' ') + << color::bold << color::blue << " |\n" << color::reset; + } + + format_one_location(retval, curr.first, curr.second); + } + + if(!helps.empty()) + { + retval << '\n'; + retval << make_string(line_num_width + 1, ' '); + retval << color::bold << color::blue << " |" << color::reset; + for(const auto& help : helps) + { + retval << color::bold << "\nHint: " << color::reset; + retval << help; + } + } + return retval.str(); +} + +} // detail +} // toml +#endif// TOML11_SOURCE_LOCATION_HPP diff --git a/libraries/toml11/include/toml/storage.hpp b/libraries/toml11/include/toml/storage.hpp new file mode 100644 index 00000000..202f9035 --- /dev/null +++ b/libraries/toml11/include/toml/storage.hpp @@ -0,0 +1,43 @@ +// Copyright Toru Niina 2017. +// Distributed under the MIT License. +#ifndef TOML11_STORAGE_HPP +#define TOML11_STORAGE_HPP +#include "utility.hpp" + +namespace toml +{ +namespace detail +{ + +// this contains pointer and deep-copy the content if copied. +// to avoid recursive pointer. +template +struct storage +{ + using value_type = T; + + explicit storage(value_type const& v): ptr(toml::make_unique(v)) {} + explicit storage(value_type&& v): ptr(toml::make_unique(std::move(v))) {} + ~storage() = default; + storage(const storage& rhs): ptr(toml::make_unique(*rhs.ptr)) {} + storage& operator=(const storage& rhs) + { + this->ptr = toml::make_unique(*rhs.ptr); + return *this; + } + storage(storage&&) = default; + storage& operator=(storage&&) = default; + + bool is_ok() const noexcept {return static_cast(ptr);} + + value_type& value() & noexcept {return *ptr;} + value_type const& value() const& noexcept {return *ptr;} + value_type&& value() && noexcept {return std::move(*ptr);} + + private: + std::unique_ptr ptr; +}; + +} // detail +} // toml +#endif// TOML11_STORAGE_HPP diff --git a/libraries/toml11/include/toml/string.hpp b/libraries/toml11/include/toml/string.hpp new file mode 100644 index 00000000..a6ed0801 --- /dev/null +++ b/libraries/toml11/include/toml/string.hpp @@ -0,0 +1,224 @@ +// Copyright Toru Niina 2017. +// Distributed under the MIT License. +#ifndef TOML11_STRING_HPP +#define TOML11_STRING_HPP +#include + +#include +#include + +#if __cplusplus >= 201703L +#if __has_include() +#include +#endif +#endif + +namespace toml +{ + +enum class string_t : std::uint8_t +{ + basic = 0, + literal = 1, +}; + +struct string +{ + string() = default; + ~string() = default; + string(const string& s) = default; + string(string&& s) = default; + string& operator=(const string& s) = default; + string& operator=(string&& s) = default; + + string(const std::string& s): kind(string_t::basic), str(s){} + string(const std::string& s, string_t k): kind(k), str(s){} + string(const char* s): kind(string_t::basic), str(s){} + string(const char* s, string_t k): kind(k), str(s){} + + string(std::string&& s): kind(string_t::basic), str(std::move(s)){} + string(std::string&& s, string_t k): kind(k), str(std::move(s)){} + + string& operator=(const std::string& s) + {kind = string_t::basic; str = s; return *this;} + string& operator=(std::string&& s) + {kind = string_t::basic; str = std::move(s); return *this;} + + operator std::string& () & noexcept {return str;} + operator std::string const& () const& noexcept {return str;} + operator std::string&& () && noexcept {return std::move(str);} + + string& operator+=(const char* rhs) {str += rhs; return *this;} + string& operator+=(const char rhs) {str += rhs; return *this;} + string& operator+=(const std::string& rhs) {str += rhs; return *this;} + string& operator+=(const string& rhs) {str += rhs.str; return *this;} + +#if __cplusplus >= 201703L + explicit string(std::string_view s): kind(string_t::basic), str(s){} + string(std::string_view s, string_t k): kind(k), str(s){} + + string& operator=(std::string_view s) + {kind = string_t::basic; str = s; return *this;} + + explicit operator std::string_view() const noexcept + {return std::string_view(str);} + + string& operator+=(const std::string_view& rhs) {str += rhs; return *this;} +#endif + + string_t kind; + std::string str; +}; + +inline bool operator==(const string& lhs, const string& rhs) +{ + return lhs.kind == rhs.kind && lhs.str == rhs.str; +} +inline bool operator!=(const string& lhs, const string& rhs) +{ + return !(lhs == rhs); +} +inline bool operator<(const string& lhs, const string& rhs) +{ + return (lhs.kind == rhs.kind) ? (lhs.str < rhs.str) : (lhs.kind < rhs.kind); +} +inline bool operator>(const string& lhs, const string& rhs) +{ + return rhs < lhs; +} +inline bool operator<=(const string& lhs, const string& rhs) +{ + return !(rhs < lhs); +} +inline bool operator>=(const string& lhs, const string& rhs) +{ + return !(lhs < rhs); +} + +inline bool +operator==(const string& lhs, const std::string& rhs) {return lhs.str == rhs;} +inline bool +operator!=(const string& lhs, const std::string& rhs) {return lhs.str != rhs;} +inline bool +operator< (const string& lhs, const std::string& rhs) {return lhs.str < rhs;} +inline bool +operator> (const string& lhs, const std::string& rhs) {return lhs.str > rhs;} +inline bool +operator<=(const string& lhs, const std::string& rhs) {return lhs.str <= rhs;} +inline bool +operator>=(const string& lhs, const std::string& rhs) {return lhs.str >= rhs;} + +inline bool +operator==(const std::string& lhs, const string& rhs) {return lhs == rhs.str;} +inline bool +operator!=(const std::string& lhs, const string& rhs) {return lhs != rhs.str;} +inline bool +operator< (const std::string& lhs, const string& rhs) {return lhs < rhs.str;} +inline bool +operator> (const std::string& lhs, const string& rhs) {return lhs > rhs.str;} +inline bool +operator<=(const std::string& lhs, const string& rhs) {return lhs <= rhs.str;} +inline bool +operator>=(const std::string& lhs, const string& rhs) {return lhs >= rhs.str;} + +inline bool +operator==(const string& lhs, const char* rhs) {return lhs.str == std::string(rhs);} +inline bool +operator!=(const string& lhs, const char* rhs) {return lhs.str != std::string(rhs);} +inline bool +operator< (const string& lhs, const char* rhs) {return lhs.str < std::string(rhs);} +inline bool +operator> (const string& lhs, const char* rhs) {return lhs.str > std::string(rhs);} +inline bool +operator<=(const string& lhs, const char* rhs) {return lhs.str <= std::string(rhs);} +inline bool +operator>=(const string& lhs, const char* rhs) {return lhs.str >= std::string(rhs);} + +inline bool +operator==(const char* lhs, const string& rhs) {return std::string(lhs) == rhs.str;} +inline bool +operator!=(const char* lhs, const string& rhs) {return std::string(lhs) != rhs.str;} +inline bool +operator< (const char* lhs, const string& rhs) {return std::string(lhs) < rhs.str;} +inline bool +operator> (const char* lhs, const string& rhs) {return std::string(lhs) > rhs.str;} +inline bool +operator<=(const char* lhs, const string& rhs) {return std::string(lhs) <= rhs.str;} +inline bool +operator>=(const char* lhs, const string& rhs) {return std::string(lhs) >= rhs.str;} + +template +std::basic_ostream& +operator<<(std::basic_ostream& os, const string& s) +{ + if(s.kind == string_t::basic) + { + if(std::find(s.str.cbegin(), s.str.cend(), '\n') != s.str.cend()) + { + // it contains newline. make it multiline string. + os << "\"\"\"\n"; + for(auto i=s.str.cbegin(), e=s.str.cend(); i!=e; ++i) + { + switch(*i) + { + case '\\': {os << "\\\\"; break;} + case '\"': {os << "\\\""; break;} + case '\b': {os << "\\b"; break;} + case '\t': {os << "\\t"; break;} + case '\f': {os << "\\f"; break;} + case '\n': {os << '\n'; break;} + case '\r': + { + // since it is a multiline string, + // CRLF is not needed to be escaped. + if(std::next(i) != e && *std::next(i) == '\n') + { + os << "\r\n"; + ++i; + } + else + { + os << "\\r"; + } + break; + } + default: {os << *i; break;} + } + } + os << "\\\n\"\"\""; + return os; + } + // no newline. make it inline. + os << "\""; + for(const auto c : s.str) + { + switch(c) + { + case '\\': {os << "\\\\"; break;} + case '\"': {os << "\\\""; break;} + case '\b': {os << "\\b"; break;} + case '\t': {os << "\\t"; break;} + case '\f': {os << "\\f"; break;} + case '\n': {os << "\\n"; break;} + case '\r': {os << "\\r"; break;} + default : {os << c; break;} + } + } + os << "\""; + return os; + } + // the string `s` is literal-string. + if(std::find(s.str.cbegin(), s.str.cend(), '\n') != s.str.cend() || + std::find(s.str.cbegin(), s.str.cend(), '\'') != s.str.cend() ) + { + // contains newline or single quote. make it multiline. + os << "'''\n" << s.str << "'''"; + return os; + } + // normal literal string + os << '\'' << s.str << '\''; + return os; +} + +} // toml +#endif// TOML11_STRING_H diff --git a/libraries/toml11/include/toml/traits.hpp b/libraries/toml11/include/toml/traits.hpp new file mode 100644 index 00000000..eafa6afe --- /dev/null +++ b/libraries/toml11/include/toml/traits.hpp @@ -0,0 +1,300 @@ +// Copyright Toru Niina 2017. +// Distributed under the MIT License. +#ifndef TOML11_TRAITS_HPP +#define TOML11_TRAITS_HPP +#include +#include +#include +#include +#include +#include + +#if __cplusplus >= 201703L +#if __has_include() +#include +#endif // has_include() +#endif // cplusplus >= C++17 + +namespace toml +{ +template class T, template class A> +class basic_value; + +namespace detail +{ +// --------------------------------------------------------------------------- +// check whether type T is a kind of container/map class + +struct has_iterator_impl +{ + template static std::true_type check(typename T::iterator*); + template static std::false_type check(...); +}; +struct has_value_type_impl +{ + template static std::true_type check(typename T::value_type*); + template static std::false_type check(...); +}; +struct has_key_type_impl +{ + template static std::true_type check(typename T::key_type*); + template static std::false_type check(...); +}; +struct has_mapped_type_impl +{ + template static std::true_type check(typename T::mapped_type*); + template static std::false_type check(...); +}; +struct has_reserve_method_impl +{ + template static std::false_type check(...); + template static std::true_type check( + decltype(std::declval().reserve(std::declval()))*); +}; +struct has_push_back_method_impl +{ + template static std::false_type check(...); + template static std::true_type check( + decltype(std::declval().push_back(std::declval()))*); +}; +struct is_comparable_impl +{ + template static std::false_type check(...); + template static std::true_type check( + decltype(std::declval() < std::declval())*); +}; + +struct has_from_toml_method_impl +{ + template class Tb, template class A> + static std::true_type check( + decltype(std::declval().from_toml( + std::declval<::toml::basic_value>()))*); + + template class Tb, template class A> + static std::false_type check(...); +}; +struct has_into_toml_method_impl +{ + template + static std::true_type check(decltype(std::declval().into_toml())*); + template + static std::false_type check(...); +}; + +/// Intel C++ compiler can not use decltype in parent class declaration, here +/// is a hack to work around it. https://stackoverflow.com/a/23953090/4692076 +#ifdef __INTEL_COMPILER +#define decltype(...) std::enable_if::type +#endif + +template +struct has_iterator : decltype(has_iterator_impl::check(nullptr)){}; +template +struct has_value_type : decltype(has_value_type_impl::check(nullptr)){}; +template +struct has_key_type : decltype(has_key_type_impl::check(nullptr)){}; +template +struct has_mapped_type : decltype(has_mapped_type_impl::check(nullptr)){}; +template +struct has_reserve_method : decltype(has_reserve_method_impl::check(nullptr)){}; +template +struct has_push_back_method : decltype(has_push_back_method_impl::check(nullptr)){}; +template +struct is_comparable : decltype(is_comparable_impl::check(nullptr)){}; + +template class Tb, template class A> +struct has_from_toml_method +: decltype(has_from_toml_method_impl::check(nullptr)){}; + +template +struct has_into_toml_method +: decltype(has_into_toml_method_impl::check(nullptr)){}; + +#ifdef __INTEL_COMPILER +#undef decltype +#endif + +// --------------------------------------------------------------------------- +// C++17 and/or/not + +#if __cplusplus >= 201703L + +using std::conjunction; +using std::disjunction; +using std::negation; + +#else + +template struct conjunction : std::true_type{}; +template struct conjunction : T{}; +template +struct conjunction : + std::conditional(T::value), conjunction, T>::type +{}; + +template struct disjunction : std::false_type{}; +template struct disjunction : T {}; +template +struct disjunction : + std::conditional(T::value), T, disjunction>::type +{}; + +template +struct negation : std::integral_constant(T::value)>{}; + +#endif + +// --------------------------------------------------------------------------- +// type checkers + +template struct is_std_pair : std::false_type{}; +template +struct is_std_pair> : std::true_type{}; + +template struct is_std_tuple : std::false_type{}; +template +struct is_std_tuple> : std::true_type{}; + +template struct is_std_forward_list : std::false_type{}; +template +struct is_std_forward_list> : std::true_type{}; + +template struct is_chrono_duration: std::false_type{}; +template +struct is_chrono_duration>: std::true_type{}; + +template +struct is_map : conjunction< // map satisfies all the following conditions + has_iterator, // has T::iterator + has_value_type, // has T::value_type + has_key_type, // has T::key_type + has_mapped_type // has T::mapped_type + >{}; +template struct is_map : is_map{}; +template struct is_map : is_map{}; +template struct is_map : is_map{}; +template struct is_map : is_map{}; + +template +struct is_container : conjunction< + negation>, // not a map + negation>, // not a std::string +#if __cplusplus >= 201703L + negation>, // not a std::string_view +#endif + has_iterator, // has T::iterator + has_value_type // has T::value_type + >{}; +template struct is_container : is_container{}; +template struct is_container : is_container{}; +template struct is_container : is_container{}; +template struct is_container : is_container{}; + +template +struct is_basic_value: std::false_type{}; +template struct is_basic_value : is_basic_value{}; +template struct is_basic_value : is_basic_value{}; +template struct is_basic_value : is_basic_value{}; +template struct is_basic_value : is_basic_value{}; +template class M, template class V> +struct is_basic_value<::toml::basic_value>: std::true_type{}; + +// --------------------------------------------------------------------------- +// C++14 index_sequence + +#if __cplusplus >= 201402L + +using std::index_sequence; +using std::make_index_sequence; + +#else + +template struct index_sequence{}; + +template struct push_back_index_sequence{}; +template +struct push_back_index_sequence, N> +{ + typedef index_sequence type; +}; + +template +struct index_sequence_maker +{ + typedef typename push_back_index_sequence< + typename index_sequence_maker::type, N>::type type; +}; +template<> +struct index_sequence_maker<0> +{ + typedef index_sequence<0> type; +}; +template +using make_index_sequence = typename index_sequence_maker::type; + +#endif // __cplusplus >= 2014 + +// --------------------------------------------------------------------------- +// C++14 enable_if_t + +#if __cplusplus >= 201402L + +using std::enable_if_t; + +#else + +template +using enable_if_t = typename std::enable_if::type; + +#endif // __cplusplus >= 2014 + +// --------------------------------------------------------------------------- +// return_type_of_t + +#if __cplusplus >= 201703L + +template +using return_type_of_t = std::invoke_result_t; + +#else +// result_of is deprecated after C++17 +template +using return_type_of_t = typename std::result_of::type; + +#endif + +// --------------------------------------------------------------------------- +// is_string_literal +// +// to use this, pass `typename remove_reference::type` to T. + +template +struct is_string_literal: +disjunction< + std::is_same, + conjunction< + std::is_array, + std::is_same::type> + > + >{}; + +// --------------------------------------------------------------------------- +// C++20 remove_cvref_t + +template +struct remove_cvref +{ + using type = typename std::remove_cv< + typename std::remove_reference::type>::type; +}; + +template +using remove_cvref_t = typename remove_cvref::type; + +}// detail +}//toml +#endif // TOML_TRAITS diff --git a/libraries/toml11/include/toml/types.hpp b/libraries/toml11/include/toml/types.hpp new file mode 100644 index 00000000..0818ebd1 --- /dev/null +++ b/libraries/toml11/include/toml/types.hpp @@ -0,0 +1,150 @@ +// Copyright Toru Niina 2017. +// Distributed under the MIT License. +#ifndef TOML11_TYPES_HPP +#define TOML11_TYPES_HPP +#include +#include + +#include "comments.hpp" +#include "datetime.hpp" +#include "string.hpp" +#include "traits.hpp" + +namespace toml +{ + +template class Table, // map-like class + template class Array> // vector-like class +class basic_value; + +using character = char; +using key = std::string; + +using boolean = bool; +using integer = std::int64_t; +using floating = double; // "float" is a keyward, cannot use it here. +// the following stuffs are structs defined here, so aliases are not needed. +// - string +// - offset_datetime +// - offset_datetime +// - local_datetime +// - local_date +// - local_time + +// default toml::value and default array/table. these are defined after defining +// basic_value itself. +// using value = basic_value; +// using array = typename value::array_type; +// using table = typename value::table_type; + +enum class value_t : std::uint8_t +{ + empty = 0, + boolean = 1, + integer = 2, + floating = 3, + string = 4, + offset_datetime = 5, + local_datetime = 6, + local_date = 7, + local_time = 8, + array = 9, + table = 10, +}; + +template +inline std::basic_ostream& +operator<<(std::basic_ostream& os, value_t t) +{ + switch(t) + { + case value_t::boolean : os << "boolean"; return os; + case value_t::integer : os << "integer"; return os; + case value_t::floating : os << "floating"; return os; + case value_t::string : os << "string"; return os; + case value_t::offset_datetime : os << "offset_datetime"; return os; + case value_t::local_datetime : os << "local_datetime"; return os; + case value_t::local_date : os << "local_date"; return os; + case value_t::local_time : os << "local_time"; return os; + case value_t::array : os << "array"; return os; + case value_t::table : os << "table"; return os; + case value_t::empty : os << "empty"; return os; + default : os << "unknown"; return os; + } +} + +template, + typename alloc = std::allocator> +inline std::basic_string stringize(value_t t) +{ + std::basic_ostringstream oss; + oss << t; + return oss.str(); +} + +namespace detail +{ + +// helper to define a type that represents a value_t value. +template +using value_t_constant = std::integral_constant; + +// meta-function that convertes from value_t to the exact toml type that corresponds to. +// It takes toml::basic_value type because array and table types depend on it. +template struct enum_to_type {using type = void ;}; +template struct enum_to_type{using type = void ;}; +template struct enum_to_type{using type = boolean ;}; +template struct enum_to_type{using type = integer ;}; +template struct enum_to_type{using type = floating ;}; +template struct enum_to_type{using type = string ;}; +template struct enum_to_type{using type = offset_datetime ;}; +template struct enum_to_type{using type = local_datetime ;}; +template struct enum_to_type{using type = local_date ;}; +template struct enum_to_type{using type = local_time ;}; +template struct enum_to_type{using type = typename Value::array_type;}; +template struct enum_to_type{using type = typename Value::table_type;}; + +// meta-function that converts from an exact toml type to the enum that corresponds to. +template +struct type_to_enum : std::conditional< + std::is_same::value, // if T == array_type, + value_t_constant, // then value_t::array + typename std::conditional< // else... + std::is_same::value, // if T == table_type + value_t_constant, // then value_t::table + value_t_constant // else value_t::empty + >::type + >::type {}; +template struct type_to_enum: value_t_constant {}; +template struct type_to_enum: value_t_constant {}; +template struct type_to_enum: value_t_constant {}; +template struct type_to_enum: value_t_constant {}; +template struct type_to_enum: value_t_constant {}; +template struct type_to_enum: value_t_constant {}; +template struct type_to_enum: value_t_constant {}; +template struct type_to_enum: value_t_constant {}; + +// meta-function that checks the type T is the same as one of the toml::* types. +template +struct is_exact_toml_type : disjunction< + std::is_same, + std::is_same, + std::is_same, + std::is_same, + std::is_same, + std::is_same, + std::is_same, + std::is_same, + std::is_same, + std::is_same + >{}; +template struct is_exact_toml_type : is_exact_toml_type{}; +template struct is_exact_toml_type : is_exact_toml_type{}; +template struct is_exact_toml_type : is_exact_toml_type{}; +template struct is_exact_toml_type: is_exact_toml_type{}; + +} // detail +} // toml +#endif// TOML11_TYPES_H diff --git a/libraries/toml11/include/toml/utility.hpp b/libraries/toml11/include/toml/utility.hpp new file mode 100644 index 00000000..113bec61 --- /dev/null +++ b/libraries/toml11/include/toml/utility.hpp @@ -0,0 +1,93 @@ +// Copyright Toru Niina 2017. +// Distributed under the MIT License. +#ifndef TOML11_UTILITY_HPP +#define TOML11_UTILITY_HPP +#include +#include +#include + +#include "traits.hpp" + +#if __cplusplus >= 201402L +# define TOML11_MARK_AS_DEPRECATED(msg) [[deprecated(msg)]] +#elif defined(__GNUC__) +# define TOML11_MARK_AS_DEPRECATED(msg) __attribute__((deprecated(msg))) +#elif defined(_MSC_VER) +# define TOML11_MARK_AS_DEPRECATED(msg) __declspec(deprecated(msg)) +#else +# define TOML11_MARK_AS_DEPRECATED +#endif + +namespace toml +{ + +#if __cplusplus >= 201402L + +using std::make_unique; + +#else + +template +inline std::unique_ptr make_unique(Ts&& ... args) +{ + return std::unique_ptr(new T(std::forward(args)...)); +} + +#endif // __cplusplus >= 2014 + +namespace detail +{ +template +void try_reserve_impl(Container& container, std::size_t N, std::true_type) +{ + container.reserve(N); + return; +} +template +void try_reserve_impl(Container&, std::size_t, std::false_type) noexcept +{ + return; +} +} // detail + +template +void try_reserve(Container& container, std::size_t N) +{ + if(N <= container.size()) {return;} + detail::try_reserve_impl(container, N, detail::has_reserve_method{}); + return; +} + +namespace detail +{ +inline std::string concat_to_string_impl(std::ostringstream& oss) +{ + return oss.str(); +} +template +std::string concat_to_string_impl(std::ostringstream& oss, T&& head, Ts&& ... tail) +{ + oss << std::forward(head); + return concat_to_string_impl(oss, std::forward(tail) ... ); +} +} // detail + +template +std::string concat_to_string(Ts&& ... args) +{ + std::ostringstream oss; + oss << std::boolalpha << std::fixed; + return detail::concat_to_string_impl(oss, std::forward(args) ...); +} + +template +T from_string(const std::string& str, T opt) +{ + T v(opt); + std::istringstream iss(str); + iss >> v; + return v; +} + +}// toml +#endif // TOML11_UTILITY diff --git a/libraries/toml11/include/toml/value.hpp b/libraries/toml11/include/toml/value.hpp new file mode 100644 index 00000000..e374c3b5 --- /dev/null +++ b/libraries/toml11/include/toml/value.hpp @@ -0,0 +1,2023 @@ +// Copyright Toru Niina 2017. +// Distributed under the MIT License. +#ifndef TOML11_VALUE_HPP +#define TOML11_VALUE_HPP +#include + +#include "comments.hpp" +#include "exception.hpp" +#include "into.hpp" +#include "region.hpp" +#include "source_location.hpp" +#include "storage.hpp" +#include "traits.hpp" +#include "types.hpp" +#include "utility.hpp" + +namespace toml +{ + +namespace detail +{ + +// to show error messages. not recommended for users. +template +inline region_base const* get_region(const Value& v) +{ + return v.region_info_.get(); +} + +template +void change_region(Value& v, region reg) +{ + v.region_info_ = std::make_shared(std::move(reg)); + return; +} + +template +[[noreturn]] inline void +throw_bad_cast(const std::string& funcname, value_t actual, const Value& v) +{ + throw type_error(detail::format_underline( + concat_to_string(funcname, "bad_cast to ", Expected), { + {v.location(), concat_to_string("the actual type is ", actual)} + }), v.location()); +} + +// Throw `out_of_range` from `toml::value::at()` and `toml::find()` +// after generating an error message. +// +// The implementation is a bit complicated and there are many edge-cases. +// If you are not interested in the error message generation, just skip this. +template +[[noreturn]] void +throw_key_not_found_error(const Value& v, const key& ky) +{ + // The top-level table has its region at the first character of the file. + // That means that, in the case when a key is not found in the top-level + // table, the error message points to the first character. If the file has + // its first table at the first line, the error message would be like this. + // ```console + // [error] key "a" not found + // --> example.toml + // | + // 1 | [table] + // | ^------ in this table + // ``` + // It actually points to the top-level table at the first character, + // not `[table]`. But it is too confusing. To avoid the confusion, the error + // message should explicitly say "key not found in the top-level table". + const auto loc = v.location(); + if(loc.line() == 1 && loc.region() == 1) + { + // Here it assumes that top-level table starts at the first character. + // The region corresponds to the top-level table will be generated at + // `parse_toml_file` function. + // It also assumes that the top-level table size is just one and + // the line number is `1`. It is always satisfied. And those conditions + // are satisfied only if the table is the top-level table. + // + // 1. one-character dot-key at the first line + // ```toml + // a.b = "c" + // ``` + // toml11 counts whole key as the table key. Here, `a.b` is the region + // of the table "a". It could be counter intuitive, but it works. + // The size of the region is 3, not 1. The above example is the shortest + // dot-key example. The size cannot be 1. + // + // 2. one-character inline-table at the first line + // ```toml + // a = {b = "c"} + // ``` + // toml11 consideres the inline table body as the table region. Here, + // `{b = "c"}` is the region of the table "a". The size of the region + // is 9, not 1. The shotest inline table still has two characters, `{` + // and `}`. The size cannot be 1. + // + // 3. one-character table declaration at the first line + // ```toml + // [a] + // ``` + // toml11 consideres the whole table key as the table region. Here, + // `[a]` is the table region. The size is 3, not 1. + // + throw std::out_of_range(format_underline(concat_to_string( + "key \"", ky, "\" not found in the top-level table"), { + {loc, "the top-level table starts here"} + })); + } + else + { + // normal table. + throw std::out_of_range(format_underline(concat_to_string( + "key \"", ky, "\" not found"), { {loc, "in this table"} })); + } +} + +// switch by `value_t` at the compile time. +template +struct switch_cast {}; +#define TOML11_GENERATE_SWITCH_CASTER(TYPE) \ + template<> \ + struct switch_cast \ + { \ + template \ + static typename Value::TYPE##_type& invoke(Value& v) \ + { \ + return v.as_##TYPE(); \ + } \ + template \ + static typename Value::TYPE##_type const& invoke(const Value& v) \ + { \ + return v.as_##TYPE(); \ + } \ + template \ + static typename Value::TYPE##_type&& invoke(Value&& v) \ + { \ + return std::move(v).as_##TYPE(); \ + } \ + }; \ + /**/ +TOML11_GENERATE_SWITCH_CASTER(boolean) +TOML11_GENERATE_SWITCH_CASTER(integer) +TOML11_GENERATE_SWITCH_CASTER(floating) +TOML11_GENERATE_SWITCH_CASTER(string) +TOML11_GENERATE_SWITCH_CASTER(offset_datetime) +TOML11_GENERATE_SWITCH_CASTER(local_datetime) +TOML11_GENERATE_SWITCH_CASTER(local_date) +TOML11_GENERATE_SWITCH_CASTER(local_time) +TOML11_GENERATE_SWITCH_CASTER(array) +TOML11_GENERATE_SWITCH_CASTER(table) + +#undef TOML11_GENERATE_SWITCH_CASTER + +}// detail + +template class Table = std::unordered_map, + template class Array = std::vector> +class basic_value +{ + template + static void assigner(T& dst, U&& v) + { + const auto tmp = ::new(std::addressof(dst)) T(std::forward(v)); + assert(tmp == std::addressof(dst)); + (void)tmp; + } + + using region_base = detail::region_base; + + template class T, + template class A> + friend class basic_value; + + public: + + using comment_type = Comment; + using key_type = ::toml::key; + using value_type = basic_value; + using boolean_type = ::toml::boolean; + using integer_type = ::toml::integer; + using floating_type = ::toml::floating; + using string_type = ::toml::string; + using local_time_type = ::toml::local_time; + using local_date_type = ::toml::local_date; + using local_datetime_type = ::toml::local_datetime; + using offset_datetime_type = ::toml::offset_datetime; + using array_type = Array; + using table_type = Table; + + public: + + basic_value() noexcept + : type_(value_t::empty), + region_info_(std::make_shared(region_base{})) + {} + ~basic_value() noexcept {this->cleanup();} + + basic_value(const basic_value& v) + : type_(v.type()), region_info_(v.region_info_), comments_(v.comments_) + { + switch(v.type()) + { + case value_t::boolean : assigner(boolean_ , v.boolean_ ); break; + case value_t::integer : assigner(integer_ , v.integer_ ); break; + case value_t::floating : assigner(floating_ , v.floating_ ); break; + case value_t::string : assigner(string_ , v.string_ ); break; + case value_t::offset_datetime: assigner(offset_datetime_, v.offset_datetime_); break; + case value_t::local_datetime : assigner(local_datetime_ , v.local_datetime_ ); break; + case value_t::local_date : assigner(local_date_ , v.local_date_ ); break; + case value_t::local_time : assigner(local_time_ , v.local_time_ ); break; + case value_t::array : assigner(array_ , v.array_ ); break; + case value_t::table : assigner(table_ , v.table_ ); break; + default: break; + } + } + basic_value(basic_value&& v) + : type_(v.type()), region_info_(std::move(v.region_info_)), + comments_(std::move(v.comments_)) + { + switch(this->type_) // here this->type_ is already initialized + { + case value_t::boolean : assigner(boolean_ , std::move(v.boolean_ )); break; + case value_t::integer : assigner(integer_ , std::move(v.integer_ )); break; + case value_t::floating : assigner(floating_ , std::move(v.floating_ )); break; + case value_t::string : assigner(string_ , std::move(v.string_ )); break; + case value_t::offset_datetime: assigner(offset_datetime_, std::move(v.offset_datetime_)); break; + case value_t::local_datetime : assigner(local_datetime_ , std::move(v.local_datetime_ )); break; + case value_t::local_date : assigner(local_date_ , std::move(v.local_date_ )); break; + case value_t::local_time : assigner(local_time_ , std::move(v.local_time_ )); break; + case value_t::array : assigner(array_ , std::move(v.array_ )); break; + case value_t::table : assigner(table_ , std::move(v.table_ )); break; + default: break; + } + } + basic_value& operator=(const basic_value& v) + { + this->cleanup(); + this->region_info_ = v.region_info_; + this->comments_ = v.comments_; + this->type_ = v.type(); + switch(this->type_) + { + case value_t::boolean : assigner(boolean_ , v.boolean_ ); break; + case value_t::integer : assigner(integer_ , v.integer_ ); break; + case value_t::floating : assigner(floating_ , v.floating_ ); break; + case value_t::string : assigner(string_ , v.string_ ); break; + case value_t::offset_datetime: assigner(offset_datetime_, v.offset_datetime_); break; + case value_t::local_datetime : assigner(local_datetime_ , v.local_datetime_ ); break; + case value_t::local_date : assigner(local_date_ , v.local_date_ ); break; + case value_t::local_time : assigner(local_time_ , v.local_time_ ); break; + case value_t::array : assigner(array_ , v.array_ ); break; + case value_t::table : assigner(table_ , v.table_ ); break; + default: break; + } + return *this; + } + basic_value& operator=(basic_value&& v) + { + this->cleanup(); + this->region_info_ = std::move(v.region_info_); + this->comments_ = std::move(v.comments_); + this->type_ = v.type(); + switch(this->type_) + { + case value_t::boolean : assigner(boolean_ , std::move(v.boolean_ )); break; + case value_t::integer : assigner(integer_ , std::move(v.integer_ )); break; + case value_t::floating : assigner(floating_ , std::move(v.floating_ )); break; + case value_t::string : assigner(string_ , std::move(v.string_ )); break; + case value_t::offset_datetime: assigner(offset_datetime_, std::move(v.offset_datetime_)); break; + case value_t::local_datetime : assigner(local_datetime_ , std::move(v.local_datetime_ )); break; + case value_t::local_date : assigner(local_date_ , std::move(v.local_date_ )); break; + case value_t::local_time : assigner(local_time_ , std::move(v.local_time_ )); break; + case value_t::array : assigner(array_ , std::move(v.array_ )); break; + case value_t::table : assigner(table_ , std::move(v.table_ )); break; + default: break; + } + return *this; + } + + // overwrite comments ---------------------------------------------------- + + basic_value(const basic_value& v, std::vector comments) + : type_(v.type()), region_info_(v.region_info_), + comments_(std::move(comments)) + { + switch(v.type()) + { + case value_t::boolean : assigner(boolean_ , v.boolean_ ); break; + case value_t::integer : assigner(integer_ , v.integer_ ); break; + case value_t::floating : assigner(floating_ , v.floating_ ); break; + case value_t::string : assigner(string_ , v.string_ ); break; + case value_t::offset_datetime: assigner(offset_datetime_, v.offset_datetime_); break; + case value_t::local_datetime : assigner(local_datetime_ , v.local_datetime_ ); break; + case value_t::local_date : assigner(local_date_ , v.local_date_ ); break; + case value_t::local_time : assigner(local_time_ , v.local_time_ ); break; + case value_t::array : assigner(array_ , v.array_ ); break; + case value_t::table : assigner(table_ , v.table_ ); break; + default: break; + } + } + + basic_value(basic_value&& v, std::vector comments) + : type_(v.type()), region_info_(std::move(v.region_info_)), + comments_(std::move(comments)) + { + switch(this->type_) // here this->type_ is already initialized + { + case value_t::boolean : assigner(boolean_ , std::move(v.boolean_ )); break; + case value_t::integer : assigner(integer_ , std::move(v.integer_ )); break; + case value_t::floating : assigner(floating_ , std::move(v.floating_ )); break; + case value_t::string : assigner(string_ , std::move(v.string_ )); break; + case value_t::offset_datetime: assigner(offset_datetime_, std::move(v.offset_datetime_)); break; + case value_t::local_datetime : assigner(local_datetime_ , std::move(v.local_datetime_ )); break; + case value_t::local_date : assigner(local_date_ , std::move(v.local_date_ )); break; + case value_t::local_time : assigner(local_time_ , std::move(v.local_time_ )); break; + case value_t::array : assigner(array_ , std::move(v.array_ )); break; + case value_t::table : assigner(table_ , std::move(v.table_ )); break; + default: break; + } + } + + // ----------------------------------------------------------------------- + // conversion between different basic_values. + template class T, + template class A> + basic_value(const basic_value& v) + : type_(v.type()), region_info_(v.region_info_), comments_(v.comments()) + { + switch(v.type()) + { + case value_t::boolean : assigner(boolean_ , v.boolean_ ); break; + case value_t::integer : assigner(integer_ , v.integer_ ); break; + case value_t::floating : assigner(floating_ , v.floating_ ); break; + case value_t::string : assigner(string_ , v.string_ ); break; + case value_t::offset_datetime: assigner(offset_datetime_, v.offset_datetime_); break; + case value_t::local_datetime : assigner(local_datetime_ , v.local_datetime_ ); break; + case value_t::local_date : assigner(local_date_ , v.local_date_ ); break; + case value_t::local_time : assigner(local_time_ , v.local_time_ ); break; + case value_t::array : + { + array_type tmp(v.as_array(std::nothrow).begin(), + v.as_array(std::nothrow).end()); + assigner(array_, std::move(tmp)); + break; + } + case value_t::table : + { + table_type tmp(v.as_table(std::nothrow).begin(), + v.as_table(std::nothrow).end()); + assigner(table_, std::move(tmp)); + break; + } + default: break; + } + } + template class T, + template class A> + basic_value(const basic_value& v, std::vector comments) + : type_(v.type()), region_info_(v.region_info_), + comments_(std::move(comments)) + { + switch(v.type()) + { + case value_t::boolean : assigner(boolean_ , v.boolean_ ); break; + case value_t::integer : assigner(integer_ , v.integer_ ); break; + case value_t::floating : assigner(floating_ , v.floating_ ); break; + case value_t::string : assigner(string_ , v.string_ ); break; + case value_t::offset_datetime: assigner(offset_datetime_, v.offset_datetime_); break; + case value_t::local_datetime : assigner(local_datetime_ , v.local_datetime_ ); break; + case value_t::local_date : assigner(local_date_ , v.local_date_ ); break; + case value_t::local_time : assigner(local_time_ , v.local_time_ ); break; + case value_t::array : + { + array_type tmp(v.as_array(std::nothrow).begin(), + v.as_array(std::nothrow).end()); + assigner(array_, std::move(tmp)); + break; + } + case value_t::table : + { + table_type tmp(v.as_table(std::nothrow).begin(), + v.as_table(std::nothrow).end()); + assigner(table_, std::move(tmp)); + break; + } + default: break; + } + } + template class T, + template class A> + basic_value& operator=(const basic_value& v) + { + this->region_info_ = v.region_info_; + this->comments_ = comment_type(v.comments()); + this->type_ = v.type(); + switch(v.type()) + { + case value_t::boolean : assigner(boolean_ , v.boolean_ ); break; + case value_t::integer : assigner(integer_ , v.integer_ ); break; + case value_t::floating : assigner(floating_ , v.floating_ ); break; + case value_t::string : assigner(string_ , v.string_ ); break; + case value_t::offset_datetime: assigner(offset_datetime_, v.offset_datetime_); break; + case value_t::local_datetime : assigner(local_datetime_ , v.local_datetime_ ); break; + case value_t::local_date : assigner(local_date_ , v.local_date_ ); break; + case value_t::local_time : assigner(local_time_ , v.local_time_ ); break; + case value_t::array : + { + array_type tmp(v.as_array(std::nothrow).begin(), + v.as_array(std::nothrow).end()); + assigner(array_, std::move(tmp)); + break; + } + case value_t::table : + { + table_type tmp(v.as_table(std::nothrow).begin(), + v.as_table(std::nothrow).end()); + assigner(table_, std::move(tmp)); + break; + } + default: break; + } + return *this; + } + + // boolean ============================================================== + + basic_value(boolean b) + : type_(value_t::boolean), + region_info_(std::make_shared(region_base{})) + { + assigner(this->boolean_, b); + } + basic_value& operator=(boolean b) + { + this->cleanup(); + this->type_ = value_t::boolean; + this->region_info_ = std::make_shared(region_base{}); + assigner(this->boolean_, b); + return *this; + } + basic_value(boolean b, std::vector comments) + : type_(value_t::boolean), + region_info_(std::make_shared(region_base{})), + comments_(std::move(comments)) + { + assigner(this->boolean_, b); + } + + // integer ============================================================== + + template, detail::negation>>::value, + std::nullptr_t>::type = nullptr> + basic_value(T i) + : type_(value_t::integer), + region_info_(std::make_shared(region_base{})) + { + assigner(this->integer_, static_cast(i)); + } + + template, detail::negation>>::value, + std::nullptr_t>::type = nullptr> + basic_value& operator=(T i) + { + this->cleanup(); + this->type_ = value_t::integer; + this->region_info_ = std::make_shared(region_base{}); + assigner(this->integer_, static_cast(i)); + return *this; + } + + template, detail::negation>>::value, + std::nullptr_t>::type = nullptr> + basic_value(T i, std::vector comments) + : type_(value_t::integer), + region_info_(std::make_shared(region_base{})), + comments_(std::move(comments)) + { + assigner(this->integer_, static_cast(i)); + } + + // floating ============================================================= + + template::value, std::nullptr_t>::type = nullptr> + basic_value(T f) + : type_(value_t::floating), + region_info_(std::make_shared(region_base{})) + { + assigner(this->floating_, static_cast(f)); + } + + + template::value, std::nullptr_t>::type = nullptr> + basic_value& operator=(T f) + { + this->cleanup(); + this->type_ = value_t::floating; + this->region_info_ = std::make_shared(region_base{}); + assigner(this->floating_, static_cast(f)); + return *this; + } + + template::value, std::nullptr_t>::type = nullptr> + basic_value(T f, std::vector comments) + : type_(value_t::floating), + region_info_(std::make_shared(region_base{})), + comments_(std::move(comments)) + { + assigner(this->floating_, f); + } + + // string =============================================================== + + basic_value(toml::string s) + : type_(value_t::string), + region_info_(std::make_shared(region_base{})) + { + assigner(this->string_, std::move(s)); + } + basic_value& operator=(toml::string s) + { + this->cleanup(); + this->type_ = value_t::string ; + this->region_info_ = std::make_shared(region_base{}); + assigner(this->string_, s); + return *this; + } + basic_value(toml::string s, std::vector comments) + : type_(value_t::string), + region_info_(std::make_shared(region_base{})), + comments_(std::move(comments)) + { + assigner(this->string_, std::move(s)); + } + + basic_value(std::string s) + : type_(value_t::string), + region_info_(std::make_shared(region_base{})) + { + assigner(this->string_, toml::string(std::move(s))); + } + basic_value& operator=(std::string s) + { + this->cleanup(); + this->type_ = value_t::string ; + this->region_info_ = std::make_shared(region_base{}); + assigner(this->string_, toml::string(std::move(s))); + return *this; + } + basic_value(std::string s, string_t kind) + : type_(value_t::string), + region_info_(std::make_shared(region_base{})) + { + assigner(this->string_, toml::string(std::move(s), kind)); + } + basic_value(std::string s, std::vector comments) + : type_(value_t::string), + region_info_(std::make_shared(region_base{})), + comments_(std::move(comments)) + { + assigner(this->string_, toml::string(std::move(s))); + } + basic_value(std::string s, string_t kind, std::vector comments) + : type_(value_t::string), + region_info_(std::make_shared(region_base{})), + comments_(std::move(comments)) + { + assigner(this->string_, toml::string(std::move(s), kind)); + } + + basic_value(const char* s) + : type_(value_t::string), + region_info_(std::make_shared(region_base{})) + { + assigner(this->string_, toml::string(std::string(s))); + } + basic_value& operator=(const char* s) + { + this->cleanup(); + this->type_ = value_t::string ; + this->region_info_ = std::make_shared(region_base{}); + assigner(this->string_, toml::string(std::string(s))); + return *this; + } + basic_value(const char* s, string_t kind) + : type_(value_t::string), + region_info_(std::make_shared(region_base{})) + { + assigner(this->string_, toml::string(std::string(s), kind)); + } + basic_value(const char* s, std::vector comments) + : type_(value_t::string), + region_info_(std::make_shared(region_base{})), + comments_(std::move(comments)) + { + assigner(this->string_, toml::string(std::string(s))); + } + basic_value(const char* s, string_t kind, std::vector comments) + : type_(value_t::string), + region_info_(std::make_shared(region_base{})), + comments_(std::move(comments)) + { + assigner(this->string_, toml::string(std::string(s), kind)); + } + +#if __cplusplus >= 201703L + basic_value(std::string_view s) + : type_(value_t::string), + region_info_(std::make_shared(region_base{})) + { + assigner(this->string_, toml::string(s)); + } + basic_value& operator=(std::string_view s) + { + this->cleanup(); + this->type_ = value_t::string ; + this->region_info_ = std::make_shared(region_base{}); + assigner(this->string_, toml::string(s)); + return *this; + } + basic_value(std::string_view s, std::vector comments) + : type_(value_t::string), + region_info_(std::make_shared(region_base{})), + comments_(std::move(comments)) + { + assigner(this->string_, toml::string(s)); + } + basic_value(std::string_view s, string_t kind) + : type_(value_t::string), + region_info_(std::make_shared(region_base{})) + { + assigner(this->string_, toml::string(s, kind)); + } + basic_value(std::string_view s, string_t kind, std::vector comments) + : type_(value_t::string), + region_info_(std::make_shared(region_base{})), + comments_(std::move(comments)) + { + assigner(this->string_, toml::string(s, kind)); + } +#endif + + // local date =========================================================== + + basic_value(const local_date& ld) + : type_(value_t::local_date), + region_info_(std::make_shared(region_base{})) + { + assigner(this->local_date_, ld); + } + basic_value& operator=(const local_date& ld) + { + this->cleanup(); + this->type_ = value_t::local_date; + this->region_info_ = std::make_shared(region_base{}); + assigner(this->local_date_, ld); + return *this; + } + basic_value(const local_date& ld, std::vector comments) + : type_(value_t::local_date), + region_info_(std::make_shared(region_base{})), + comments_(std::move(comments)) + { + assigner(this->local_date_, ld); + } + + // local time =========================================================== + + basic_value(const local_time& lt) + : type_(value_t::local_time), + region_info_(std::make_shared(region_base{})) + { + assigner(this->local_time_, lt); + } + basic_value(const local_time& lt, std::vector comments) + : type_(value_t::local_time), + region_info_(std::make_shared(region_base{})), + comments_(std::move(comments)) + { + assigner(this->local_time_, lt); + } + basic_value& operator=(const local_time& lt) + { + this->cleanup(); + this->type_ = value_t::local_time; + this->region_info_ = std::make_shared(region_base{}); + assigner(this->local_time_, lt); + return *this; + } + + template + basic_value(const std::chrono::duration& dur) + : type_(value_t::local_time), + region_info_(std::make_shared(region_base{})) + { + assigner(this->local_time_, local_time(dur)); + } + template + basic_value(const std::chrono::duration& dur, + std::vector comments) + : type_(value_t::local_time), + region_info_(std::make_shared(region_base{})), + comments_(std::move(comments)) + { + assigner(this->local_time_, local_time(dur)); + } + template + basic_value& operator=(const std::chrono::duration& dur) + { + this->cleanup(); + this->type_ = value_t::local_time; + this->region_info_ = std::make_shared(region_base{}); + assigner(this->local_time_, local_time(dur)); + return *this; + } + + // local datetime ======================================================= + + basic_value(const local_datetime& ldt) + : type_(value_t::local_datetime), + region_info_(std::make_shared(region_base{})) + { + assigner(this->local_datetime_, ldt); + } + basic_value(const local_datetime& ldt, std::vector comments) + : type_(value_t::local_datetime), + region_info_(std::make_shared(region_base{})), + comments_(std::move(comments)) + { + assigner(this->local_datetime_, ldt); + } + basic_value& operator=(const local_datetime& ldt) + { + this->cleanup(); + this->type_ = value_t::local_datetime; + this->region_info_ = std::make_shared(region_base{}); + assigner(this->local_datetime_, ldt); + return *this; + } + + // offset datetime ====================================================== + + basic_value(const offset_datetime& odt) + : type_(value_t::offset_datetime), + region_info_(std::make_shared(region_base{})) + { + assigner(this->offset_datetime_, odt); + } + basic_value(const offset_datetime& odt, std::vector comments) + : type_(value_t::offset_datetime), + region_info_(std::make_shared(region_base{})), + comments_(std::move(comments)) + { + assigner(this->offset_datetime_, odt); + } + basic_value& operator=(const offset_datetime& odt) + { + this->cleanup(); + this->type_ = value_t::offset_datetime; + this->region_info_ = std::make_shared(region_base{}); + assigner(this->offset_datetime_, odt); + return *this; + } + basic_value(const std::chrono::system_clock::time_point& tp) + : type_(value_t::offset_datetime), + region_info_(std::make_shared(region_base{})) + { + assigner(this->offset_datetime_, offset_datetime(tp)); + } + basic_value(const std::chrono::system_clock::time_point& tp, + std::vector comments) + : type_(value_t::offset_datetime), + region_info_(std::make_shared(region_base{})), + comments_(std::move(comments)) + { + assigner(this->offset_datetime_, offset_datetime(tp)); + } + basic_value& operator=(const std::chrono::system_clock::time_point& tp) + { + this->cleanup(); + this->type_ = value_t::offset_datetime; + this->region_info_ = std::make_shared(region_base{}); + assigner(this->offset_datetime_, offset_datetime(tp)); + return *this; + } + + // array ================================================================ + + basic_value(const array_type& ary) + : type_(value_t::array), + region_info_(std::make_shared(region_base{})) + { + assigner(this->array_, ary); + } + basic_value(const array_type& ary, std::vector comments) + : type_(value_t::array), + region_info_(std::make_shared(region_base{})), + comments_(std::move(comments)) + { + assigner(this->array_, ary); + } + basic_value& operator=(const array_type& ary) + { + this->cleanup(); + this->type_ = value_t::array ; + this->region_info_ = std::make_shared(region_base{}); + assigner(this->array_, ary); + return *this; + } + + // array (initializer_list) ---------------------------------------------- + + template::value, + std::nullptr_t>::type = nullptr> + basic_value(std::initializer_list list) + : type_(value_t::array), + region_info_(std::make_shared(region_base{})) + { + array_type ary(list.begin(), list.end()); + assigner(this->array_, std::move(ary)); + } + template::value, + std::nullptr_t>::type = nullptr> + basic_value(std::initializer_list list, std::vector comments) + : type_(value_t::array), + region_info_(std::make_shared(region_base{})), + comments_(std::move(comments)) + { + array_type ary(list.begin(), list.end()); + assigner(this->array_, std::move(ary)); + } + template::value, + std::nullptr_t>::type = nullptr> + basic_value& operator=(std::initializer_list list) + { + this->cleanup(); + this->type_ = value_t::array; + this->region_info_ = std::make_shared(region_base{}); + + array_type ary(list.begin(), list.end()); + assigner(this->array_, std::move(ary)); + return *this; + } + + // array (STL Containers) ------------------------------------------------ + + template>, + detail::is_container + >::value, std::nullptr_t>::type = nullptr> + basic_value(const T& list) + : type_(value_t::array), + region_info_(std::make_shared(region_base{})) + { + static_assert(std::is_convertible::value, + "elements of a container should be convertible to toml::value"); + + array_type ary(list.size()); + std::copy(list.begin(), list.end(), ary.begin()); + assigner(this->array_, std::move(ary)); + } + template>, + detail::is_container + >::value, std::nullptr_t>::type = nullptr> + basic_value(const T& list, std::vector comments) + : type_(value_t::array), + region_info_(std::make_shared(region_base{})), + comments_(std::move(comments)) + { + static_assert(std::is_convertible::value, + "elements of a container should be convertible to toml::value"); + + array_type ary(list.size()); + std::copy(list.begin(), list.end(), ary.begin()); + assigner(this->array_, std::move(ary)); + } + template>, + detail::is_container + >::value, std::nullptr_t>::type = nullptr> + basic_value& operator=(const T& list) + { + static_assert(std::is_convertible::value, + "elements of a container should be convertible to toml::value"); + + this->cleanup(); + this->type_ = value_t::array; + this->region_info_ = std::make_shared(region_base{}); + + array_type ary(list.size()); + std::copy(list.begin(), list.end(), ary.begin()); + assigner(this->array_, std::move(ary)); + return *this; + } + + // table ================================================================ + + basic_value(const table_type& tab) + : type_(value_t::table), + region_info_(std::make_shared(region_base{})) + { + assigner(this->table_, tab); + } + basic_value(const table_type& tab, std::vector comments) + : type_(value_t::table), + region_info_(std::make_shared(region_base{})), + comments_(std::move(comments)) + { + assigner(this->table_, tab); + } + basic_value& operator=(const table_type& tab) + { + this->cleanup(); + this->type_ = value_t::table; + this->region_info_ = std::make_shared(region_base{}); + assigner(this->table_, tab); + return *this; + } + + // initializer-list ------------------------------------------------------ + + basic_value(std::initializer_list> list) + : type_(value_t::table), + region_info_(std::make_shared(region_base{})) + { + table_type tab; + for(const auto& elem : list) {tab[elem.first] = elem.second;} + assigner(this->table_, std::move(tab)); + } + + basic_value(std::initializer_list> list, + std::vector comments) + : type_(value_t::table), + region_info_(std::make_shared(region_base{})), + comments_(std::move(comments)) + { + table_type tab; + for(const auto& elem : list) {tab[elem.first] = elem.second;} + assigner(this->table_, std::move(tab)); + } + basic_value& operator=(std::initializer_list> list) + { + this->cleanup(); + this->type_ = value_t::table; + this->region_info_ = std::make_shared(region_base{}); + + table_type tab; + for(const auto& elem : list) {tab[elem.first] = elem.second;} + assigner(this->table_, std::move(tab)); + return *this; + } + + // other table-like ----------------------------------------------------- + + template>, + detail::is_map + >::value, std::nullptr_t>::type = nullptr> + basic_value(const Map& mp) + : type_(value_t::table), + region_info_(std::make_shared(region_base{})) + { + table_type tab; + for(const auto& elem : mp) {tab[elem.first] = elem.second;} + assigner(this->table_, std::move(tab)); + } + template>, + detail::is_map + >::value, std::nullptr_t>::type = nullptr> + basic_value(const Map& mp, std::vector comments) + : type_(value_t::table), + region_info_(std::make_shared(region_base{})), + comments_(std::move(comments)) + { + table_type tab; + for(const auto& elem : mp) {tab[elem.first] = elem.second;} + assigner(this->table_, std::move(tab)); + } + template>, + detail::is_map + >::value, std::nullptr_t>::type = nullptr> + basic_value& operator=(const Map& mp) + { + this->cleanup(); + this->type_ = value_t::table; + this->region_info_ = std::make_shared(region_base{}); + + table_type tab; + for(const auto& elem : mp) {tab[elem.first] = elem.second;} + assigner(this->table_, std::move(tab)); + return *this; + } + + // user-defined ========================================================= + + // convert using into_toml() method ------------------------------------- + + template::value, std::nullptr_t>::type = nullptr> + basic_value(const T& ud): basic_value(ud.into_toml()) {} + + template::value, std::nullptr_t>::type = nullptr> + basic_value(const T& ud, std::vector comments) + : basic_value(ud.into_toml(), std::move(comments)) + {} + template::value, std::nullptr_t>::type = nullptr> + basic_value& operator=(const T& ud) + { + *this = ud.into_toml(); + return *this; + } + + // convert using into struct ----------------------------------------- + + template)> + basic_value(const T& ud): basic_value(::toml::into::into_toml(ud)) {} + template)> + basic_value(const T& ud, std::vector comments) + : basic_value(::toml::into::into_toml(ud), std::move(comments)) + {} + template)> + basic_value& operator=(const T& ud) + { + *this = ::toml::into::into_toml(ud); + return *this; + } + + // for internal use ------------------------------------------------------ + // + // Those constructors take detail::region that contains parse result. + + basic_value(boolean b, detail::region reg, std::vector cm) + : type_(value_t::boolean), + region_info_(std::make_shared(std::move(reg))), + comments_(std::move(cm)) + { + assigner(this->boolean_, b); + } + template, detail::negation> + >::value, std::nullptr_t>::type = nullptr> + basic_value(T i, detail::region reg, std::vector cm) + : type_(value_t::integer), + region_info_(std::make_shared(std::move(reg))), + comments_(std::move(cm)) + { + assigner(this->integer_, static_cast(i)); + } + template::value, std::nullptr_t>::type = nullptr> + basic_value(T f, detail::region reg, std::vector cm) + : type_(value_t::floating), + region_info_(std::make_shared(std::move(reg))), + comments_(std::move(cm)) + { + assigner(this->floating_, static_cast(f)); + } + basic_value(toml::string s, detail::region reg, + std::vector cm) + : type_(value_t::string), + region_info_(std::make_shared(std::move(reg))), + comments_(std::move(cm)) + { + assigner(this->string_, std::move(s)); + } + basic_value(const local_date& ld, detail::region reg, + std::vector cm) + : type_(value_t::local_date), + region_info_(std::make_shared(std::move(reg))), + comments_(std::move(cm)) + { + assigner(this->local_date_, ld); + } + basic_value(const local_time& lt, detail::region reg, + std::vector cm) + : type_(value_t::local_time), + region_info_(std::make_shared(std::move(reg))), + comments_(std::move(cm)) + { + assigner(this->local_time_, lt); + } + basic_value(const local_datetime& ldt, detail::region reg, + std::vector cm) + : type_(value_t::local_datetime), + region_info_(std::make_shared(std::move(reg))), + comments_(std::move(cm)) + { + assigner(this->local_datetime_, ldt); + } + basic_value(const offset_datetime& odt, detail::region reg, + std::vector cm) + : type_(value_t::offset_datetime), + region_info_(std::make_shared(std::move(reg))), + comments_(std::move(cm)) + { + assigner(this->offset_datetime_, odt); + } + basic_value(const array_type& ary, detail::region reg, + std::vector cm) + : type_(value_t::array), + region_info_(std::make_shared(std::move(reg))), + comments_(std::move(cm)) + { + assigner(this->array_, ary); + } + basic_value(const table_type& tab, detail::region reg, + std::vector cm) + : type_(value_t::table), + region_info_(std::make_shared(std::move(reg))), + comments_(std::move(cm)) + { + assigner(this->table_, tab); + } + + template::value, + std::nullptr_t>::type = nullptr> + basic_value(std::pair parse_result, std::vector comments) + : basic_value(std::move(parse_result.first), + std::move(parse_result.second), + std::move(comments)) + {} + + // type checking and casting ============================================ + + template::value, + std::nullptr_t>::type = nullptr> + bool is() const noexcept + { + return detail::type_to_enum::value == this->type_; + } + bool is(value_t t) const noexcept {return t == this->type_;} + + bool is_uninitialized() const noexcept {return this->is(value_t::empty );} + bool is_boolean() const noexcept {return this->is(value_t::boolean );} + bool is_integer() const noexcept {return this->is(value_t::integer );} + bool is_floating() const noexcept {return this->is(value_t::floating );} + bool is_string() const noexcept {return this->is(value_t::string );} + bool is_offset_datetime() const noexcept {return this->is(value_t::offset_datetime);} + bool is_local_datetime() const noexcept {return this->is(value_t::local_datetime );} + bool is_local_date() const noexcept {return this->is(value_t::local_date );} + bool is_local_time() const noexcept {return this->is(value_t::local_time );} + bool is_array() const noexcept {return this->is(value_t::array );} + bool is_table() const noexcept {return this->is(value_t::table );} + + value_t type() const noexcept {return type_;} + + template + typename detail::enum_to_type::type& cast() & + { + if(this->type_ != T) + { + detail::throw_bad_cast("toml::value::cast: ", this->type_, *this); + } + return detail::switch_cast::invoke(*this); + } + template + typename detail::enum_to_type::type const& cast() const& + { + if(this->type_ != T) + { + detail::throw_bad_cast("toml::value::cast: ", this->type_, *this); + } + return detail::switch_cast::invoke(*this); + } + template + typename detail::enum_to_type::type&& cast() && + { + if(this->type_ != T) + { + detail::throw_bad_cast("toml::value::cast: ", this->type_, *this); + } + return detail::switch_cast::invoke(std::move(*this)); + } + + // ------------------------------------------------------------------------ + // nothrow version + + boolean const& as_boolean (const std::nothrow_t&) const& noexcept {return this->boolean_;} + integer const& as_integer (const std::nothrow_t&) const& noexcept {return this->integer_;} + floating const& as_floating (const std::nothrow_t&) const& noexcept {return this->floating_;} + string const& as_string (const std::nothrow_t&) const& noexcept {return this->string_;} + offset_datetime const& as_offset_datetime(const std::nothrow_t&) const& noexcept {return this->offset_datetime_;} + local_datetime const& as_local_datetime (const std::nothrow_t&) const& noexcept {return this->local_datetime_;} + local_date const& as_local_date (const std::nothrow_t&) const& noexcept {return this->local_date_;} + local_time const& as_local_time (const std::nothrow_t&) const& noexcept {return this->local_time_;} + array_type const& as_array (const std::nothrow_t&) const& noexcept {return this->array_.value();} + table_type const& as_table (const std::nothrow_t&) const& noexcept {return this->table_.value();} + + boolean & as_boolean (const std::nothrow_t&) & noexcept {return this->boolean_;} + integer & as_integer (const std::nothrow_t&) & noexcept {return this->integer_;} + floating & as_floating (const std::nothrow_t&) & noexcept {return this->floating_;} + string & as_string (const std::nothrow_t&) & noexcept {return this->string_;} + offset_datetime& as_offset_datetime(const std::nothrow_t&) & noexcept {return this->offset_datetime_;} + local_datetime & as_local_datetime (const std::nothrow_t&) & noexcept {return this->local_datetime_;} + local_date & as_local_date (const std::nothrow_t&) & noexcept {return this->local_date_;} + local_time & as_local_time (const std::nothrow_t&) & noexcept {return this->local_time_;} + array_type & as_array (const std::nothrow_t&) & noexcept {return this->array_.value();} + table_type & as_table (const std::nothrow_t&) & noexcept {return this->table_.value();} + + boolean && as_boolean (const std::nothrow_t&) && noexcept {return std::move(this->boolean_);} + integer && as_integer (const std::nothrow_t&) && noexcept {return std::move(this->integer_);} + floating && as_floating (const std::nothrow_t&) && noexcept {return std::move(this->floating_);} + string && as_string (const std::nothrow_t&) && noexcept {return std::move(this->string_);} + offset_datetime&& as_offset_datetime(const std::nothrow_t&) && noexcept {return std::move(this->offset_datetime_);} + local_datetime && as_local_datetime (const std::nothrow_t&) && noexcept {return std::move(this->local_datetime_);} + local_date && as_local_date (const std::nothrow_t&) && noexcept {return std::move(this->local_date_);} + local_time && as_local_time (const std::nothrow_t&) && noexcept {return std::move(this->local_time_);} + array_type && as_array (const std::nothrow_t&) && noexcept {return std::move(this->array_.value());} + table_type && as_table (const std::nothrow_t&) && noexcept {return std::move(this->table_.value());} + + // ======================================================================== + // throw version + // ------------------------------------------------------------------------ + // const reference {{{ + + boolean const& as_boolean() const& + { + if(this->type_ != value_t::boolean) + { + detail::throw_bad_cast( + "toml::value::as_boolean(): ", this->type_, *this); + } + return this->boolean_; + } + integer const& as_integer() const& + { + if(this->type_ != value_t::integer) + { + detail::throw_bad_cast( + "toml::value::as_integer(): ", this->type_, *this); + } + return this->integer_; + } + floating const& as_floating() const& + { + if(this->type_ != value_t::floating) + { + detail::throw_bad_cast( + "toml::value::as_floating(): ", this->type_, *this); + } + return this->floating_; + } + string const& as_string() const& + { + if(this->type_ != value_t::string) + { + detail::throw_bad_cast( + "toml::value::as_string(): ", this->type_, *this); + } + return this->string_; + } + offset_datetime const& as_offset_datetime() const& + { + if(this->type_ != value_t::offset_datetime) + { + detail::throw_bad_cast( + "toml::value::as_offset_datetime(): ", this->type_, *this); + } + return this->offset_datetime_; + } + local_datetime const& as_local_datetime() const& + { + if(this->type_ != value_t::local_datetime) + { + detail::throw_bad_cast( + "toml::value::as_local_datetime(): ", this->type_, *this); + } + return this->local_datetime_; + } + local_date const& as_local_date() const& + { + if(this->type_ != value_t::local_date) + { + detail::throw_bad_cast( + "toml::value::as_local_date(): ", this->type_, *this); + } + return this->local_date_; + } + local_time const& as_local_time() const& + { + if(this->type_ != value_t::local_time) + { + detail::throw_bad_cast( + "toml::value::as_local_time(): ", this->type_, *this); + } + return this->local_time_; + } + array_type const& as_array() const& + { + if(this->type_ != value_t::array) + { + detail::throw_bad_cast( + "toml::value::as_array(): ", this->type_, *this); + } + return this->array_.value(); + } + table_type const& as_table() const& + { + if(this->type_ != value_t::table) + { + detail::throw_bad_cast( + "toml::value::as_table(): ", this->type_, *this); + } + return this->table_.value(); + } + // }}} + // ------------------------------------------------------------------------ + // nonconst reference {{{ + + boolean & as_boolean() & + { + if(this->type_ != value_t::boolean) + { + detail::throw_bad_cast( + "toml::value::as_boolean(): ", this->type_, *this); + } + return this->boolean_; + } + integer & as_integer() & + { + if(this->type_ != value_t::integer) + { + detail::throw_bad_cast( + "toml::value::as_integer(): ", this->type_, *this); + } + return this->integer_; + } + floating & as_floating() & + { + if(this->type_ != value_t::floating) + { + detail::throw_bad_cast( + "toml::value::as_floating(): ", this->type_, *this); + } + return this->floating_; + } + string & as_string() & + { + if(this->type_ != value_t::string) + { + detail::throw_bad_cast( + "toml::value::as_string(): ", this->type_, *this); + } + return this->string_; + } + offset_datetime & as_offset_datetime() & + { + if(this->type_ != value_t::offset_datetime) + { + detail::throw_bad_cast( + "toml::value::as_offset_datetime(): ", this->type_, *this); + } + return this->offset_datetime_; + } + local_datetime & as_local_datetime() & + { + if(this->type_ != value_t::local_datetime) + { + detail::throw_bad_cast( + "toml::value::as_local_datetime(): ", this->type_, *this); + } + return this->local_datetime_; + } + local_date & as_local_date() & + { + if(this->type_ != value_t::local_date) + { + detail::throw_bad_cast( + "toml::value::as_local_date(): ", this->type_, *this); + } + return this->local_date_; + } + local_time & as_local_time() & + { + if(this->type_ != value_t::local_time) + { + detail::throw_bad_cast( + "toml::value::as_local_time(): ", this->type_, *this); + } + return this->local_time_; + } + array_type & as_array() & + { + if(this->type_ != value_t::array) + { + detail::throw_bad_cast( + "toml::value::as_array(): ", this->type_, *this); + } + return this->array_.value(); + } + table_type & as_table() & + { + if(this->type_ != value_t::table) + { + detail::throw_bad_cast( + "toml::value::as_table(): ", this->type_, *this); + } + return this->table_.value(); + } + + // }}} + // ------------------------------------------------------------------------ + // rvalue reference {{{ + + boolean && as_boolean() && + { + if(this->type_ != value_t::boolean) + { + detail::throw_bad_cast( + "toml::value::as_boolean(): ", this->type_, *this); + } + return std::move(this->boolean_); + } + integer && as_integer() && + { + if(this->type_ != value_t::integer) + { + detail::throw_bad_cast( + "toml::value::as_integer(): ", this->type_, *this); + } + return std::move(this->integer_); + } + floating && as_floating() && + { + if(this->type_ != value_t::floating) + { + detail::throw_bad_cast( + "toml::value::as_floating(): ", this->type_, *this); + } + return std::move(this->floating_); + } + string && as_string() && + { + if(this->type_ != value_t::string) + { + detail::throw_bad_cast( + "toml::value::as_string(): ", this->type_, *this); + } + return std::move(this->string_); + } + offset_datetime && as_offset_datetime() && + { + if(this->type_ != value_t::offset_datetime) + { + detail::throw_bad_cast( + "toml::value::as_offset_datetime(): ", this->type_, *this); + } + return std::move(this->offset_datetime_); + } + local_datetime && as_local_datetime() && + { + if(this->type_ != value_t::local_datetime) + { + detail::throw_bad_cast( + "toml::value::as_local_datetime(): ", this->type_, *this); + } + return std::move(this->local_datetime_); + } + local_date && as_local_date() && + { + if(this->type_ != value_t::local_date) + { + detail::throw_bad_cast( + "toml::value::as_local_date(): ", this->type_, *this); + } + return std::move(this->local_date_); + } + local_time && as_local_time() && + { + if(this->type_ != value_t::local_time) + { + detail::throw_bad_cast( + "toml::value::as_local_time(): ", this->type_, *this); + } + return std::move(this->local_time_); + } + array_type && as_array() && + { + if(this->type_ != value_t::array) + { + detail::throw_bad_cast( + "toml::value::as_array(): ", this->type_, *this); + } + return std::move(this->array_.value()); + } + table_type && as_table() && + { + if(this->type_ != value_t::table) + { + detail::throw_bad_cast( + "toml::value::as_table(): ", this->type_, *this); + } + return std::move(this->table_.value()); + } + // }}} + + // accessors ============================================================= + // + // may throw type_error or out_of_range + // + value_type& at(const key& k) + { + if(!this->is_table()) + { + detail::throw_bad_cast( + "toml::value::at(key): ", this->type_, *this); + } + if(this->as_table(std::nothrow).count(k) == 0) + { + detail::throw_key_not_found_error(*this, k); + } + return this->as_table(std::nothrow).at(k); + } + value_type const& at(const key& k) const + { + if(!this->is_table()) + { + detail::throw_bad_cast( + "toml::value::at(key): ", this->type_, *this); + } + if(this->as_table(std::nothrow).count(k) == 0) + { + detail::throw_key_not_found_error(*this, k); + } + return this->as_table(std::nothrow).at(k); + } + value_type& operator[](const key& k) + { + if(this->is_uninitialized()) + { + *this = table_type{}; + } + else if(!this->is_table()) // initialized, but not a table + { + detail::throw_bad_cast( + "toml::value::operator[](key): ", this->type_, *this); + } + return this->as_table(std::nothrow)[k]; + } + + value_type& at(const std::size_t idx) + { + if(!this->is_array()) + { + detail::throw_bad_cast( + "toml::value::at(idx): ", this->type_, *this); + } + if(this->as_array(std::nothrow).size() <= idx) + { + throw std::out_of_range(detail::format_underline( + "toml::value::at(idx): no element corresponding to the index", { + {this->location(), concat_to_string("the length is ", + this->as_array(std::nothrow).size(), + ", and the specified index is ", idx)} + })); + } + return this->as_array().at(idx); + } + value_type const& at(const std::size_t idx) const + { + if(!this->is_array()) + { + detail::throw_bad_cast( + "toml::value::at(idx): ", this->type_, *this); + } + if(this->as_array(std::nothrow).size() <= idx) + { + throw std::out_of_range(detail::format_underline( + "toml::value::at(idx): no element corresponding to the index", { + {this->location(), concat_to_string("the length is ", + this->as_array(std::nothrow).size(), + ", and the specified index is ", idx)} + })); + } + return this->as_array(std::nothrow).at(idx); + } + + value_type& operator[](const std::size_t idx) noexcept + { + // no check... + return this->as_array(std::nothrow)[idx]; + } + value_type const& operator[](const std::size_t idx) const noexcept + { + // no check... + return this->as_array(std::nothrow)[idx]; + } + + void push_back(const value_type& x) + { + if(!this->is_array()) + { + detail::throw_bad_cast( + "toml::value::push_back(value): ", this->type_, *this); + } + this->as_array(std::nothrow).push_back(x); + return; + } + void push_back(value_type&& x) + { + if(!this->is_array()) + { + detail::throw_bad_cast( + "toml::value::push_back(value): ", this->type_, *this); + } + this->as_array(std::nothrow).push_back(std::move(x)); + return; + } + + template + value_type& emplace_back(Ts&& ... args) + { + if(!this->is_array()) + { + detail::throw_bad_cast( + "toml::value::emplace_back(...): ", this->type_, *this); + } + this->as_array(std::nothrow).emplace_back(std::forward(args) ...); + return this->as_array(std::nothrow).back(); + } + + std::size_t size() const + { + switch(this->type_) + { + case value_t::array: + { + return this->as_array(std::nothrow).size(); + } + case value_t::table: + { + return this->as_table(std::nothrow).size(); + } + case value_t::string: + { + return this->as_string(std::nothrow).str.size(); + } + default: + { + throw type_error(detail::format_underline( + "toml::value::size(): bad_cast to container types", { + {this->location(), + concat_to_string("the actual type is ", this->type_)} + }), this->location()); + } + } + } + + std::size_t count(const key_type& k) const + { + if(!this->is_table()) + { + detail::throw_bad_cast( + "toml::value::count(key): ", this->type_, *this); + } + return this->as_table(std::nothrow).count(k); + } + + bool contains(const key_type& k) const + { + if(!this->is_table()) + { + detail::throw_bad_cast( + "toml::value::contains(key): ", this->type_, *this); + } + return (this->as_table(std::nothrow).count(k) != 0); + } + + source_location location() const + { + return source_location(this->region_info_.get()); + } + + comment_type const& comments() const noexcept {return this->comments_;} + comment_type& comments() noexcept {return this->comments_;} + + private: + + void cleanup() noexcept + { + switch(this->type_) + { + case value_t::string : {string_.~string(); return;} + case value_t::array : {array_.~array_storage(); return;} + case value_t::table : {table_.~table_storage(); return;} + default : return; + } + } + + // for error messages + template + friend region_base const* detail::get_region(const Value& v); + + template + friend void detail::change_region(Value& v, detail::region reg); + + private: + + using array_storage = detail::storage; + using table_storage = detail::storage; + + value_t type_; + union + { + boolean boolean_; + integer integer_; + floating floating_; + string string_; + offset_datetime offset_datetime_; + local_datetime local_datetime_; + local_date local_date_; + local_time local_time_; + array_storage array_; + table_storage table_; + }; + std::shared_ptr region_info_; + comment_type comments_; +}; + +// default toml::value and default array/table. +using value = basic_value; +using array = typename value::array_type; +using table = typename value::table_type; + +template class T, template class A> +inline bool +operator==(const basic_value& lhs, const basic_value& rhs) +{ + if(lhs.type() != rhs.type()) {return false;} + if(lhs.comments() != rhs.comments()) {return false;} + + switch(lhs.type()) + { + case value_t::boolean : + { + return lhs.as_boolean() == rhs.as_boolean(); + } + case value_t::integer : + { + return lhs.as_integer() == rhs.as_integer(); + } + case value_t::floating : + { + return lhs.as_floating() == rhs.as_floating(); + } + case value_t::string : + { + return lhs.as_string() == rhs.as_string(); + } + case value_t::offset_datetime: + { + return lhs.as_offset_datetime() == rhs.as_offset_datetime(); + } + case value_t::local_datetime: + { + return lhs.as_local_datetime() == rhs.as_local_datetime(); + } + case value_t::local_date: + { + return lhs.as_local_date() == rhs.as_local_date(); + } + case value_t::local_time: + { + return lhs.as_local_time() == rhs.as_local_time(); + } + case value_t::array : + { + return lhs.as_array() == rhs.as_array(); + } + case value_t::table : + { + return lhs.as_table() == rhs.as_table(); + } + case value_t::empty : {return true; } + default: {return false;} + } +} + +template class T, template class A> +inline bool operator!=(const basic_value& lhs, const basic_value& rhs) +{ + return !(lhs == rhs); +} + +template class T, template class A> +typename std::enable_if::array_type>, + detail::is_comparable::table_type> + >::value, bool>::type +operator<(const basic_value& lhs, const basic_value& rhs) +{ + if(lhs.type() != rhs.type()){return (lhs.type() < rhs.type());} + switch(lhs.type()) + { + case value_t::boolean : + { + return lhs.as_boolean() < rhs.as_boolean() || + (lhs.as_boolean() == rhs.as_boolean() && + lhs.comments() < rhs.comments()); + } + case value_t::integer : + { + return lhs.as_integer() < rhs.as_integer() || + (lhs.as_integer() == rhs.as_integer() && + lhs.comments() < rhs.comments()); + } + case value_t::floating : + { + return lhs.as_floating() < rhs.as_floating() || + (lhs.as_floating() == rhs.as_floating() && + lhs.comments() < rhs.comments()); + } + case value_t::string : + { + return lhs.as_string() < rhs.as_string() || + (lhs.as_string() == rhs.as_string() && + lhs.comments() < rhs.comments()); + } + case value_t::offset_datetime: + { + return lhs.as_offset_datetime() < rhs.as_offset_datetime() || + (lhs.as_offset_datetime() == rhs.as_offset_datetime() && + lhs.comments() < rhs.comments()); + } + case value_t::local_datetime: + { + return lhs.as_local_datetime() < rhs.as_local_datetime() || + (lhs.as_local_datetime() == rhs.as_local_datetime() && + lhs.comments() < rhs.comments()); + } + case value_t::local_date: + { + return lhs.as_local_date() < rhs.as_local_date() || + (lhs.as_local_date() == rhs.as_local_date() && + lhs.comments() < rhs.comments()); + } + case value_t::local_time: + { + return lhs.as_local_time() < rhs.as_local_time() || + (lhs.as_local_time() == rhs.as_local_time() && + lhs.comments() < rhs.comments()); + } + case value_t::array : + { + return lhs.as_array() < rhs.as_array() || + (lhs.as_array() == rhs.as_array() && + lhs.comments() < rhs.comments()); + } + case value_t::table : + { + return lhs.as_table() < rhs.as_table() || + (lhs.as_table() == rhs.as_table() && + lhs.comments() < rhs.comments()); + } + case value_t::empty : + { + return lhs.comments() < rhs.comments(); + } + default: + { + return lhs.comments() < rhs.comments(); + } + } +} + +template class T, template class A> +typename std::enable_if::array_type>, + detail::is_comparable::table_type> + >::value, bool>::type +operator<=(const basic_value& lhs, const basic_value& rhs) +{ + return (lhs < rhs) || (lhs == rhs); +} +template class T, template class A> +typename std::enable_if::array_type>, + detail::is_comparable::table_type> + >::value, bool>::type +operator>(const basic_value& lhs, const basic_value& rhs) +{ + return !(lhs <= rhs); +} +template class T, template class A> +typename std::enable_if::array_type>, + detail::is_comparable::table_type> + >::value, bool>::type +operator>=(const basic_value& lhs, const basic_value& rhs) +{ + return !(lhs < rhs); +} + +template class T, template class A> +inline std::string format_error(const std::string& err_msg, + const basic_value& v, const std::string& comment, + std::vector hints = {}, + const bool colorize = TOML11_ERROR_MESSAGE_COLORIZED) +{ + return detail::format_underline(err_msg, {{v.location(), comment}}, + std::move(hints), colorize); +} + +template class T, template class A> +inline std::string format_error(const std::string& err_msg, + const toml::basic_value& v1, const std::string& comment1, + const toml::basic_value& v2, const std::string& comment2, + std::vector hints = {}, + const bool colorize = TOML11_ERROR_MESSAGE_COLORIZED) +{ + return detail::format_underline(err_msg, { + {v1.location(), comment1}, {v2.location(), comment2} + }, std::move(hints), colorize); +} + +template class T, template class A> +inline std::string format_error(const std::string& err_msg, + const toml::basic_value& v1, const std::string& comment1, + const toml::basic_value& v2, const std::string& comment2, + const toml::basic_value& v3, const std::string& comment3, + std::vector hints = {}, + const bool colorize = TOML11_ERROR_MESSAGE_COLORIZED) +{ + return detail::format_underline(err_msg, {{v1.location(), comment1}, + {v2.location(), comment2}, {v3.location(), comment3} + }, std::move(hints), colorize); +} + +template class T, template class A> +detail::return_type_of_t +visit(Visitor&& visitor, const toml::basic_value& v) +{ + switch(v.type()) + { + case value_t::boolean : {return visitor(v.as_boolean ());} + case value_t::integer : {return visitor(v.as_integer ());} + case value_t::floating : {return visitor(v.as_floating ());} + case value_t::string : {return visitor(v.as_string ());} + case value_t::offset_datetime: {return visitor(v.as_offset_datetime());} + case value_t::local_datetime : {return visitor(v.as_local_datetime ());} + case value_t::local_date : {return visitor(v.as_local_date ());} + case value_t::local_time : {return visitor(v.as_local_time ());} + case value_t::array : {return visitor(v.as_array ());} + case value_t::table : {return visitor(v.as_table ());} + case value_t::empty : break; + default: break; + } + throw std::runtime_error(format_error("[error] toml::visit: toml::basic_value " + "does not have any valid basic_value.", v, "here")); +} + +template class T, template class A> +detail::return_type_of_t +visit(Visitor&& visitor, toml::basic_value& v) +{ + switch(v.type()) + { + case value_t::boolean : {return visitor(v.as_boolean ());} + case value_t::integer : {return visitor(v.as_integer ());} + case value_t::floating : {return visitor(v.as_floating ());} + case value_t::string : {return visitor(v.as_string ());} + case value_t::offset_datetime: {return visitor(v.as_offset_datetime());} + case value_t::local_datetime : {return visitor(v.as_local_datetime ());} + case value_t::local_date : {return visitor(v.as_local_date ());} + case value_t::local_time : {return visitor(v.as_local_time ());} + case value_t::array : {return visitor(v.as_array ());} + case value_t::table : {return visitor(v.as_table ());} + case value_t::empty : break; + default: break; + } + throw std::runtime_error(format_error("[error] toml::visit: toml::basic_value " + "does not have any valid basic_value.", v, "here")); +} + +template class T, template class A> +detail::return_type_of_t +visit(Visitor&& visitor, toml::basic_value&& v) +{ + switch(v.type()) + { + case value_t::boolean : {return visitor(std::move(v.as_boolean ()));} + case value_t::integer : {return visitor(std::move(v.as_integer ()));} + case value_t::floating : {return visitor(std::move(v.as_floating ()));} + case value_t::string : {return visitor(std::move(v.as_string ()));} + case value_t::offset_datetime: {return visitor(std::move(v.as_offset_datetime()));} + case value_t::local_datetime : {return visitor(std::move(v.as_local_datetime ()));} + case value_t::local_date : {return visitor(std::move(v.as_local_date ()));} + case value_t::local_time : {return visitor(std::move(v.as_local_time ()));} + case value_t::array : {return visitor(std::move(v.as_array ()));} + case value_t::table : {return visitor(std::move(v.as_table ()));} + case value_t::empty : break; + default: break; + } + throw std::runtime_error(format_error("[error] toml::visit: toml::basic_value " + "does not have any valid basic_value.", v, "here")); +} + +}// toml +#endif// TOML11_VALUE From 860706caec6cf2ab26089d6c1f1fc12166767cd9 Mon Sep 17 00:00:00 2001 From: kumquat-ir <66188216+kumquat-ir@users.noreply.github.com> Date: Fri, 16 Apr 2021 11:02:02 -0700 Subject: [PATCH 05/57] allow parsing toml from a QByteArray --- libraries/toml11/include/toml/parser.hpp | 44 ++++++++++++++++++++++++ 1 file changed, 44 insertions(+) diff --git a/libraries/toml11/include/toml/parser.hpp b/libraries/toml11/include/toml/parser.hpp index c3df644e..3ab74209 100644 --- a/libraries/toml11/include/toml/parser.hpp +++ b/libraries/toml11/include/toml/parser.hpp @@ -5,6 +5,7 @@ #include #include #include +#include #include "combinator.hpp" #include "lexer.hpp" @@ -2127,6 +2128,49 @@ parse(std::istream& is, const std::string& fname = "unknown file") return data.unwrap(); } +template class Table = std::unordered_map, + template class Array = std::vector> +basic_value +parse(QByteArray qba, const std::string& fname = "unknown file") +{ + using value_type = basic_value; + + // convert QByteArray to vector + std::vector letters(qba.begin(), qba.end()); + + while(!letters.empty() && letters.back() == '\0') + { + letters.pop_back(); + } + assert(letters.empty() || letters.back() != '\0'); + + detail::location loc(std::move(fname), std::move(letters)); + + // skip BOM if exists. + // XXX component of BOM (like 0xEF) exceeds the representable range of + // signed char, so on some (actually, most) of the environment, these cannot + // be compared to char. However, since we are always out of luck, we need to + // check our chars are equivalent to BOM. To do this, first we need to + // convert char to unsigned char to guarantee the comparability. + if(loc.source()->size() >= 3) + { + std::array BOM; + std::memcpy(BOM.data(), loc.source()->data(), 3); + if(BOM[0] == 0xEF && BOM[1] == 0xBB && BOM[2] == 0xBF) + { + loc.advance(3); // BOM found. skip. + } + } + + const auto data = detail::parse_toml_file(loc); + if(!data) + { + throw syntax_error(data.unwrap_err(), source_location(loc)); + } + return data.unwrap(); +} + template class Table = std::unordered_map, template class Array = std::vector> From 7156e086f6ba6993db87396e133b8158bed882c8 Mon Sep 17 00:00:00 2001 From: kumquat-ir <66188216+kumquat-ir@users.noreply.github.com> Date: Fri, 16 Apr 2021 13:33:56 -0700 Subject: [PATCH 06/57] parse META-INF/mods.toml for metadata --- api/logic/CMakeLists.txt | 2 +- api/logic/minecraft/mod/LocalModParseTask.cpp | 74 ++++++++++++++++++- 2 files changed, 74 insertions(+), 2 deletions(-) diff --git a/api/logic/CMakeLists.txt b/api/logic/CMakeLists.txt index beaa0c00..23bf848d 100644 --- a/api/logic/CMakeLists.txt +++ b/api/logic/CMakeLists.txt @@ -540,7 +540,7 @@ set_target_properties(MultiMC_logic PROPERTIES CXX_VISIBILITY_PRESET hidden VISI generate_export_header(MultiMC_logic) # Link -target_link_libraries(MultiMC_logic systeminfo MultiMC_quazip MultiMC_classparser ${NBT_NAME} ${ZLIB_LIBRARIES} optional-bare BuildConfig) +target_link_libraries(MultiMC_logic systeminfo MultiMC_quazip MultiMC_classparser ${NBT_NAME} ${ZLIB_LIBRARIES} optional-bare toml11 BuildConfig) target_link_libraries(MultiMC_logic Qt5::Core Qt5::Xml Qt5::Network Qt5::Concurrent) # Mark and export headers diff --git a/api/logic/minecraft/mod/LocalModParseTask.cpp b/api/logic/minecraft/mod/LocalModParseTask.cpp index 22ebd7d4..cb35dca6 100644 --- a/api/logic/minecraft/mod/LocalModParseTask.cpp +++ b/api/logic/minecraft/mod/LocalModParseTask.cpp @@ -6,6 +6,7 @@ #include #include #include +#include #include "settings/INIFile.h" #include "FileSystem.h" @@ -90,6 +91,64 @@ std::shared_ptr ReadMCModInfo(QByteArray contents) return nullptr; } + +std::shared_ptr ReadMCModTOML(QByteArray contents) +{ + std::shared_ptr details = std::make_shared(); + + // toml11 throws an error when something goes wrong in parsing, so we need to catch that + try { + // data under the root table + auto tomlData = toml::parse(contents); + // data under [[mods]] + auto tomlModsArr = toml::find>(tomlData, "mods"); + + // these properties are required in this location by forge, and thus can be assumed to exist + // forge supports multiple mods in one file, details of which are accessable here from tomlModsArr[n] + details->mod_id = QString::fromStdString(toml::find(tomlModsArr[0], "modId")); + details->version = QString::fromStdString(toml::find(tomlModsArr[0], "version")); + details->name = QString::fromStdString(toml::find(tomlModsArr[0], "displayName")); + // known issue: sometimes overflows the description box for some reason + details->description = QString::fromStdString(toml::find(tomlModsArr[0], "description")); + + // optional properties - can be stored either in the root table or in [[mods]] + auto authors = QString::fromStdString(toml::find_or(tomlData, "authors", "")); + if(authors.isEmpty()) + { + authors = QString::fromStdString(toml::find_or(tomlModsArr[0], "authors", "")); + } + if(!authors.isEmpty()) + { + // author information is stored as a string now, not a list + details->authors.append(authors); + } + // is credits even used anywhere? including this for completion/parity with old data version + auto credits = QString::fromStdString(toml::find_or(tomlData, "credits", "")); + if(credits.isEmpty()) + { + credits = QString::fromStdString(toml::find_or(tomlModsArr[0], "credits", "")); + } + details->credits = credits; + auto homeurl = QString::fromStdString(toml::find_or(tomlData, "displayURL", "")); + if(homeurl.isEmpty()) + { + homeurl = QString::fromStdString(toml::find_or(tomlModsArr[0], "displayURL", "")); + } + if(!homeurl.isEmpty()) + { + // fix up url. + if (!homeurl.startsWith("http://") && !homeurl.startsWith("https://") && !homeurl.startsWith("ftp://")) + { + homeurl.prepend("http://"); + } + } + details->homeurl = homeurl; + } catch (toml::syntax_error&) { + return nullptr; + } + return details; +} + // https://fabricmc.net/wiki/documentation:fabric_mod_json std::shared_ptr ReadFabricModInfo(QByteArray contents) { @@ -198,7 +257,20 @@ void LocalModParseTask::processAsZip() QuaZipFile file(&zip); - if (zip.setCurrentFile("mcmod.info")) + if (zip.setCurrentFile("META-INF/mods.toml")) + { + if (!file.open(QIODevice::ReadOnly)) + { + zip.close(); + return; + } + + m_result->details = ReadMCModTOML(file.readAll()); + file.close(); + zip.close(); + return; + } + else if (zip.setCurrentFile("mcmod.info")) { if (!file.open(QIODevice::ReadOnly)) { From 13afad80fb9b17503621dc63509113203af8887c Mon Sep 17 00:00:00 2001 From: kumquat-ir <66188216+kumquat-ir@users.noreply.github.com> Date: Fri, 16 Apr 2021 17:45:55 -0700 Subject: [PATCH 07/57] replace ${file.jarVersion} with something useful --- api/logic/minecraft/mod/LocalModParseTask.cpp | 37 +++++++++++++++++++ 1 file changed, 37 insertions(+) diff --git a/api/logic/minecraft/mod/LocalModParseTask.cpp b/api/logic/minecraft/mod/LocalModParseTask.cpp index cb35dca6..9f3da5a7 100644 --- a/api/logic/minecraft/mod/LocalModParseTask.cpp +++ b/api/logic/minecraft/mod/LocalModParseTask.cpp @@ -267,6 +267,43 @@ void LocalModParseTask::processAsZip() m_result->details = ReadMCModTOML(file.readAll()); file.close(); + + // to replace ${file.jarVersion} with the actual version, as needed + if (m_result->details && m_result->details->version == "${file.jarVersion}") + { + if (zip.setCurrentFile("META-INF/MANIFEST.MF")) + { + if (!file.open(QIODevice::ReadOnly)) + { + zip.close(); + return; + } + + // quick and dirty line-by-line parser + auto manifestLines = file.readAll().split('\n'); + QString manifestVersion = ""; + for (auto &line : manifestLines) + { + if (QString(line).startsWith("Implementation-Version: ")) + { + manifestVersion = QString(line).remove("Implementation-Version: "); + break; + } + } + + // some mods use ${projectversion} in their build.gradle, causing this mess to show up in MANIFEST.MF + // also keep with forge's behavior of setting the version to "NONE" if none is found + if (manifestVersion.contains("task ':jar' property 'archiveVersion'") || manifestVersion == "") + { + manifestVersion = "NONE"; + } + + m_result->details->version = manifestVersion; + + file.close(); + } + } + zip.close(); return; } From e668aa0f95f4f56a1ac4320f014662d279c22708 Mon Sep 17 00:00:00 2001 From: kumquat-ir <66188216+kumquat-ir@users.noreply.github.com> Date: Sat, 17 Apr 2021 09:46:11 -0700 Subject: [PATCH 08/57] switch to new toml library --- CMakeLists.txt | 2 +- COPYING.md | 15 +- api/logic/CMakeLists.txt | 2 +- api/logic/minecraft/mod/LocalModParseTask.cpp | 10 +- libraries/README.md | 6 +- libraries/toml11/CMakeLists.txt | 5 - libraries/toml11/README.md | 1918 -------------- libraries/toml11/include/toml.hpp | 46 - libraries/toml11/include/toml/color.hpp | 64 - libraries/toml11/include/toml/combinator.hpp | 306 --- libraries/toml11/include/toml/comments.hpp | 466 ---- libraries/toml11/include/toml/datetime.hpp | 631 ----- libraries/toml11/include/toml/exception.hpp | 65 - libraries/toml11/include/toml/from.hpp | 20 - libraries/toml11/include/toml/get.hpp | 1068 -------- libraries/toml11/include/toml/into.hpp | 20 - libraries/toml11/include/toml/lexer.hpp | 270 -- libraries/toml11/include/toml/literal.hpp | 112 - libraries/toml11/include/toml/macros.hpp | 121 - libraries/toml11/include/toml/parser.hpp | 2221 ---------------- libraries/toml11/include/toml/region.hpp | 417 --- libraries/toml11/include/toml/result.hpp | 717 ----- libraries/toml11/include/toml/serializer.hpp | 853 ------ .../toml11/include/toml/source_location.hpp | 233 -- libraries/toml11/include/toml/storage.hpp | 43 - libraries/toml11/include/toml/string.hpp | 224 -- libraries/toml11/include/toml/traits.hpp | 300 --- libraries/toml11/include/toml/types.hpp | 150 -- libraries/toml11/include/toml/utility.hpp | 93 - libraries/toml11/include/toml/value.hpp | 2023 --------------- libraries/tomlc99/CMakeLists.txt | 10 + libraries/{toml11 => tomlc99}/LICENSE | 13 +- libraries/tomlc99/README.md | 194 ++ libraries/tomlc99/include/toml.h | 175 ++ libraries/tomlc99/src/toml.c | 2300 +++++++++++++++++ 35 files changed, 2704 insertions(+), 12409 deletions(-) delete mode 100644 libraries/toml11/CMakeLists.txt delete mode 100644 libraries/toml11/README.md delete mode 100644 libraries/toml11/include/toml.hpp delete mode 100644 libraries/toml11/include/toml/color.hpp delete mode 100644 libraries/toml11/include/toml/combinator.hpp delete mode 100644 libraries/toml11/include/toml/comments.hpp delete mode 100644 libraries/toml11/include/toml/datetime.hpp delete mode 100644 libraries/toml11/include/toml/exception.hpp delete mode 100644 libraries/toml11/include/toml/from.hpp delete mode 100644 libraries/toml11/include/toml/get.hpp delete mode 100644 libraries/toml11/include/toml/into.hpp delete mode 100644 libraries/toml11/include/toml/lexer.hpp delete mode 100644 libraries/toml11/include/toml/literal.hpp delete mode 100644 libraries/toml11/include/toml/macros.hpp delete mode 100644 libraries/toml11/include/toml/parser.hpp delete mode 100644 libraries/toml11/include/toml/region.hpp delete mode 100644 libraries/toml11/include/toml/result.hpp delete mode 100644 libraries/toml11/include/toml/serializer.hpp delete mode 100644 libraries/toml11/include/toml/source_location.hpp delete mode 100644 libraries/toml11/include/toml/storage.hpp delete mode 100644 libraries/toml11/include/toml/string.hpp delete mode 100644 libraries/toml11/include/toml/traits.hpp delete mode 100644 libraries/toml11/include/toml/types.hpp delete mode 100644 libraries/toml11/include/toml/utility.hpp delete mode 100644 libraries/toml11/include/toml/value.hpp create mode 100644 libraries/tomlc99/CMakeLists.txt rename libraries/{toml11 => tomlc99}/LICENSE (85%) create mode 100644 libraries/tomlc99/README.md create mode 100644 libraries/tomlc99/include/toml.h create mode 100644 libraries/tomlc99/src/toml.c diff --git a/CMakeLists.txt b/CMakeLists.txt index cfba3430..4ea92f68 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -265,7 +265,7 @@ add_subdirectory(libraries/iconfix) # fork of Qt's QIcon loader add_subdirectory(libraries/LocalPeer) # fork of a library from Qt solutions add_subdirectory(libraries/classparser) # google analytics library add_subdirectory(libraries/optional-bare) -add_subdirectory(libraries/toml11) # toml parser +add_subdirectory(libraries/tomlc99) # toml parser ############################### Built Artifacts ############################### diff --git a/COPYING.md b/COPYING.md index ea8fe479..caa4bed5 100644 --- a/COPYING.md +++ b/COPYING.md @@ -252,11 +252,12 @@ ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. -# toml11 +# tomlc99 - The MIT License (MIT) + MIT License - Copyright (c) 2017 Toru Niina + Copyright (c) 2017 CK Tan + https://github.com/cktan/tomlc99 Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal @@ -265,13 +266,13 @@ 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 above copyright notice and this permission notice shall be included in all + copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, - OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN - THE SOFTWARE. + OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + SOFTWARE. diff --git a/api/logic/CMakeLists.txt b/api/logic/CMakeLists.txt index 23bf848d..91155ea7 100644 --- a/api/logic/CMakeLists.txt +++ b/api/logic/CMakeLists.txt @@ -540,7 +540,7 @@ set_target_properties(MultiMC_logic PROPERTIES CXX_VISIBILITY_PRESET hidden VISI generate_export_header(MultiMC_logic) # Link -target_link_libraries(MultiMC_logic systeminfo MultiMC_quazip MultiMC_classparser ${NBT_NAME} ${ZLIB_LIBRARIES} optional-bare toml11 BuildConfig) +target_link_libraries(MultiMC_logic systeminfo MultiMC_quazip MultiMC_classparser ${NBT_NAME} ${ZLIB_LIBRARIES} optional-bare tomlc99 BuildConfig) target_link_libraries(MultiMC_logic Qt5::Core Qt5::Xml Qt5::Network Qt5::Concurrent) # Mark and export headers diff --git a/api/logic/minecraft/mod/LocalModParseTask.cpp b/api/logic/minecraft/mod/LocalModParseTask.cpp index 9f3da5a7..d8475fe2 100644 --- a/api/logic/minecraft/mod/LocalModParseTask.cpp +++ b/api/logic/minecraft/mod/LocalModParseTask.cpp @@ -6,7 +6,7 @@ #include #include #include -#include +#include #include "settings/INIFile.h" #include "FileSystem.h" @@ -91,7 +91,7 @@ std::shared_ptr ReadMCModInfo(QByteArray contents) return nullptr; } - +/* std::shared_ptr ReadMCModTOML(QByteArray contents) { std::shared_ptr details = std::make_shared(); @@ -148,7 +148,7 @@ std::shared_ptr ReadMCModTOML(QByteArray contents) } return details; } - +*/ // https://fabricmc.net/wiki/documentation:fabric_mod_json std::shared_ptr ReadFabricModInfo(QByteArray contents) { @@ -257,7 +257,7 @@ void LocalModParseTask::processAsZip() QuaZipFile file(&zip); - if (zip.setCurrentFile("META-INF/mods.toml")) + /*if (zip.setCurrentFile("META-INF/mods.toml")) { if (!file.open(QIODevice::ReadOnly)) { @@ -307,7 +307,7 @@ void LocalModParseTask::processAsZip() zip.close(); return; } - else if (zip.setCurrentFile("mcmod.info")) + else*/ if (zip.setCurrentFile("mcmod.info")) { if (!file.open(QIODevice::ReadOnly)) { diff --git a/libraries/README.md b/libraries/README.md index 76ee8c46..ac861148 100644 --- a/libraries/README.md +++ b/libraries/README.md @@ -159,9 +159,9 @@ BSD licensed, derived from [qt-google-analytics](https://github.com/HSAnet/qt-go Modifications include better handling of IP anonymization (can be enabled) and general improvements of the API (application handles persistence and ID generation instead of the library). -## toml11 -A C++11 TOML language parser. Used by Forge 1.14+ to store mod metadata. +## tomlc99 +A TOML language parser. Used by Forge 1.14+ to store mod metadata. -See [github repo](https://github.com/ToruNiina/toml11). +See [github repo](https://github.com/cktan/tomlc99). Licenced under the MIT licence. diff --git a/libraries/toml11/CMakeLists.txt b/libraries/toml11/CMakeLists.txt deleted file mode 100644 index 556ec150..00000000 --- a/libraries/toml11/CMakeLists.txt +++ /dev/null @@ -1,5 +0,0 @@ -cmake_minimum_required(VERSION 3.1) -project(toml11) - -add_library(toml11 INTERFACE) -target_include_directories(toml11 INTERFACE "${CMAKE_CURRENT_SOURCE_DIR}/include") diff --git a/libraries/toml11/README.md b/libraries/toml11/README.md deleted file mode 100644 index d5bc1c81..00000000 --- a/libraries/toml11/README.md +++ /dev/null @@ -1,1918 +0,0 @@ -toml11 -====== - -[![Build Status on GitHub Actions](https://github.com/ToruNiina/toml11/workflows/build/badge.svg)](https://github.com/ToruNiina/toml11/actions) -[![Build Status on TravisCI](https://travis-ci.org/ToruNiina/toml11.svg?branch=master)](https://travis-ci.org/ToruNiina/toml11) -[![Build status on Appveyor](https://ci.appveyor.com/api/projects/status/m2n08a926asvg5mg/branch/master?svg=true)](https://ci.appveyor.com/project/ToruNiina/toml11/branch/master) -[![Build status on CircleCI](https://circleci.com/gh/ToruNiina/toml11/tree/master.svg?style=svg)](https://circleci.com/gh/ToruNiina/toml11/tree/master) -[![Version](https://img.shields.io/github/release/ToruNiina/toml11.svg?style=flat)](https://github.com/ToruNiina/toml11/releases) -[![License](https://img.shields.io/github/license/ToruNiina/toml11.svg?style=flat)](LICENSE) -[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.1209136.svg)](https://doi.org/10.5281/zenodo.1209136) - -toml11 is a C++11 (or later) header-only toml parser/encoder depending only on C++ standard library. - -- It is compatible to the latest version of [TOML v1.0.0](https://toml.io/en/v1.0.0). -- It is one of the most TOML standard compliant libraries, tested with [the language agnostic test suite for TOML parsers by BurntSushi](https://github.com/BurntSushi/toml-test). -- It shows highly informative error messages. You can see the error messages about invalid files at [CircleCI](https://circleci.com/gh/ToruNiina/toml11). -- It has configurable container. You can use any random-access containers and key-value maps as backend containers. -- It optionally preserves comments without any overhead. -- It has configurable serializer that supports comments, inline tables, literal strings and multiline strings. -- It supports user-defined type conversion from/into toml values. -- It correctly handles UTF-8 sequences, with or without BOM, both on posix and Windows. - -## Example - -```cpp -#include -#include - -int main() -{ - // ```toml - // title = "an example toml file" - // nums = [3, 1, 4, 1, 5] - // ``` - auto data = toml::parse("example.toml"); - - // find a value with the specified type from a table - std::string title = toml::find(data, "title"); - - // convert the whole array into any container automatically - std::vector nums = toml::find>(data, "nums"); - - // access with STL-like manner - if(not data.contains("foo")) - { - data["foo"] = "bar"; - } - - // pass a fallback - std::string name = toml::find_or(data, "name", "not found"); - - // width-dependent formatting - std::cout << std::setw(80) << data << std::endl; - - return 0; -} -``` - -## Table of Contents - -- [Integration](#integration) -- [Decoding a toml file](#decoding-a-toml-file) - - [In the case of syntax error](#in-the-case-of-syntax-error) - - [Invalid UTF-8 Codepoints](#invalid-utf-8-codepoints) -- [Finding a toml value](#finding-a-toml-value) - - [Finding a value in a table](#finding-a-value-in-a-table) - - [In case of error](#in-case-of-error) - - [Dotted keys](#dotted-keys) -- [Casting a toml value](#casting-a-toml-value) -- [Checking value type](#checking-value-type) -- [More about conversion](#more-about-conversion) - - [Converting an array](#converting-an-array) - - [Converting a table](#converting-a-table) - - [Getting an array of tables](#getting-an-array-of-tables) - - [Cost of conversion](#cost-of-conversion) - - [Converting datetime and its variants](#converting-datetime-and-its-variants) -- [Getting with a fallback](#getting-with-a-fallback) -- [Expecting conversion](#expecting-conversion) -- [Visiting a toml::value](#visiting-a-tomlvalue) -- [Constructing a toml::value](#constructing-a-tomlvalue) -- [Preserving Comments](#preserving-comments) -- [Customizing containers](#customizing-containers) -- [TOML literal](#toml-literal) -- [Conversion between toml value and arbitrary types](#conversion-between-toml-value-and-arbitrary-types) -- [Formatting user-defined error messages](#formatting-user-defined-error-messages) -- [Obtaining location information](#obtaining-location-information) -- [Exceptions](#exceptions) -- [Colorize Error Messages](#colorize-error-messages) -- [Serializing TOML data](#serializing-toml-data) -- [Underlying types](#underlying-types) -- [Unreleased TOML features](#unreleased-toml-features) -- [Breaking Changes from v2](#breaking-changes-from-v2) -- [Running Tests](#running-tests) -- [Contributors](#contributors) -- [Licensing Terms](#licensing-terms) - -## Integration - -Just include the file after adding it to the include path. - -```cpp -#include // that's all! now you can use it. -#include - -int main() -{ - const auto data = toml::parse("example.toml"); - const auto title = toml::find(data, "title"); - std::cout << "the title is " << title << std::endl; - return 0; -} -``` - -The convenient way is to add this repository as a git-submodule or to install -it in your system by CMake. - -Note for MSVC: We recommend to set `/Zc:__cplusplus` to detect C++ version correctly. - -## Decoding a toml file - -To parse a toml file, the only thing you have to do is -to pass a filename to the `toml::parse` function. - -```cpp -const std::string fname("sample.toml"); -const toml::value data = toml::parse(fname); -``` - -As required by the TOML specification, the top-level value is always a table. -You can find a value inside it, cast it into a table explicitly, and insert it as a value into other `toml::value`. - -If it encounters an error while opening a file, it will throw `std::runtime_error`. - -You can also pass a `std::istream` to the `toml::parse` function. -To show a filename in an error message, however, it is recommended to pass the -filename with the stream. - -```cpp -std::ifstream ifs("sample.toml", std::ios_base::binary); -assert(ifs.good()); -const auto data = toml::parse(ifs, /*optional -> */ "sample.toml"); -``` - -**Note**: When you are **on Windows, open a file in binary mode**. -If a file is opened in text-mode, CRLF ("\r\n") will automatically be -converted to LF ("\n") and this causes inconsistency between file size -and the contents that would be read. This causes weird error. - -### In the case of syntax error - -If there is a syntax error in a toml file, `toml::parse` will throw -`toml::syntax_error` that inherits `std::exception`. - -toml11 has clean and informative error messages inspired by Rust and -it looks like the following. - -```console -terminate called after throwing an instance of 'toml::syntax_error' - what(): [error] toml::parse_table: invalid line format # error description - --> example.toml # file name - 3 | a = 42 = true # line num and content - | ^------ expected newline, but got '='. # error reason -``` - -If you (mistakenly) duplicate tables and got an error, it is helpful to see -where they are. toml11 shows both at the same time like the following. - -```console -terminate called after throwing an instance of 'toml::syntax_error' - what(): [error] toml::insert_value: table ("table") already exists. - --> duplicate-table.toml - 1 | [table] - | ~~~~~~~ table already exists here - ... - 3 | [table] - | ~~~~~~~ table defined twice -``` - -When toml11 encounters a malformed value, it tries to detect what type it is. -Then it shows hints to fix the format. An error message while reading one of -the malformed files in [the language agnostic test suite](https://github.com/BurntSushi/toml-test). -is shown below. - -```console -what(): [error] bad time: should be HH:MM:SS.subsec - --> ./datetime-malformed-no-secs.toml - 1 | no-secs = 1987-07-05T17:45Z - | ^------- HH:MM:SS.subsec - | -Hint: pass: 1979-05-27T07:32:00, 1979-05-27 07:32:00.999999 -Hint: fail: 1979-05-27T7:32:00, 1979-05-27 17:32 -``` - -You can find other examples in a job named `output_result` on -[CircleCI](https://circleci.com/gh/ToruNiina/toml11). - -Since the error message generation is generally a difficult task, the current -status is not ideal. If you encounter a weird error message, please let us know -and contribute to improve the quality! - -### Invalid UTF-8 codepoints - -It throws `syntax_error` if a value of an escape sequence -representing unicode character is not a valid UTF-8 codepoint. - -```console - what(): [error] toml::read_utf8_codepoint: input codepoint is too large. - --> utf8.toml - 1 | exceeds_unicode = "\U0011FFFF example" - | ^--------- should be in [0x00..0x10FFFF] -``` - -## Finding a toml value - -After parsing successfully, you can obtain the values from the result of -`toml::parse` using `toml::find` function. - -```toml -# sample.toml -answer = 42 -pi = 3.14 -numbers = [1,2,3] -time = 1979-05-27T07:32:00Z -``` - -``` cpp -const auto data = toml::parse("sample.toml"); -const auto answer = toml::find(data, "answer"); -const auto pi = toml::find(data, "pi"); -const auto numbers = toml::find>(data, "numbers"); -const auto timepoint = toml::find(data, "time"); -``` - -By default, `toml::find` returns a `toml::value`. - -```cpp -const toml::value& answer = toml::find(data, "answer"); -``` - -When you pass an exact TOML type that does not require type conversion, -`toml::find` returns a reference without copying the value. - -```cpp -const auto data = toml::parse("sample.toml"); -const auto& answer = toml::find(data, "answer"); -``` - -If the specified type requires conversion, you can't take a reference to the value. -See also [underlying types](#underlying-types). - -**NOTE**: For some technical reason, automatic conversion between `integer` and -`floating` is not supported. If you want to get a floating value even if a value -has integer value, you need to convert it manually after obtaining a value, -like the followings. - -```cpp -const auto vx = toml::find(data, "x"); -double x = vx.is_floating() ? vx.as_floating(std::nothrow) : - static_cast(vx.as_integer()); // it throws if vx is neither - // floating nor integer. -``` - -### Finding a value in a table - -There are several way to get a value defined in a table. -First, you can get a table as a normal value and find a value from the table. - -```toml -[fruit] -name = "apple" -[fruit.physical] -color = "red" -shape = "round" -``` - -``` cpp -const auto data = toml::parse("fruit.toml"); -const auto& fruit = toml::find(data, "fruit"); -const auto name = toml::find(fruit, "name"); - -const auto& physical = toml::find(fruit, "physical"); -const auto color = toml::find(physical, "color"); -const auto shape = toml::find(physical, "shape"); -``` - -Here, variable `fruit` is a `toml::value` and can be used as the first argument -of `toml::find`. - -Second, you can pass as many arguments as the number of subtables to `toml::find`. - -```cpp -const auto data = toml::parse("fruit.toml"); -const auto color = toml::find(data, "fruit", "physical", "color"); -const auto shape = toml::find(data, "fruit", "physical", "shape"); -``` - -### Finding a value in an array - -You can find n-th value in an array by `toml::find`. - -```toml -values = ["foo", "bar", "baz"] -``` - -``` cpp -const auto data = toml::parse("sample.toml"); -const auto values = toml::find(data, "values"); -const auto bar = toml::find(values, 1); -``` - -`toml::find` can also search array recursively. - -```cpp -const auto data = toml::parse("fruit.toml"); -const auto bar = toml::find(data, "values", 1); -``` - -Before calling `toml::find`, you can check if a value corresponding to a key -exists. You can use both `bool toml::value::contains(const key&) const` and -`std::size_t toml::value::count(const key&) const`. Those behaves like the -`std::map::contains` and `std::map::count`. - -```cpp -const auto data = toml::parse("fruit.toml"); -if(data.contains("fruit") && data.at("fruit").count("physical") != 0) -{ - // ... -} -``` - -### In case of error - -If the value does not exist, `toml::find` throws `std::out_of_range` with the -location of the table. - -```console -terminate called after throwing an instance of 'std::out_of_range' - what(): [error] key "answer" not found - --> example.toml - 6 | [tab] - | ~~~~~ in this table -``` - ----- - -If the specified type differs from the actual value contained, it throws -`toml::type_error` that inherits `std::exception`. - -Similar to the case of syntax error, toml11 also displays clean error messages. -The error message when you choose `int` to get `string` value would be like this. - -```console -terminate called after throwing an instance of 'toml::type_error' - what(): [error] toml::value bad_cast to integer - --> example.toml - 3 | title = "TOML Example" - | ~~~~~~~~~~~~~~ the actual type is string -``` - -**NOTE**: In order to show this kind of error message, all the toml values have -a pointer to represent its range in a file. The entire contents of a file is -shared by `toml::value`s and remains on the heap memory. It is recommended to -destruct all the `toml::value` classes after configuring your application -if you have a large TOML file compared to the memory resource. - -### Dotted keys - -TOML v0.5.0 has a new feature named "dotted keys". -You can chain keys to represent the structure of the data. - -```toml -physical.color = "orange" -physical.shape = "round" -``` - -This is equivalent to the following. - -```toml -[physical] -color = "orange" -shape = "round" -``` - -You can get both of the above tables with the same c++ code. - -```cpp -const auto physical = toml::find(data, "physical"); -const auto color = toml::find(physical, "color"); -``` - -The following code does not work for the above toml file. - -```cpp -// XXX this does not work! -const auto color = toml::find(data, "physical.color"); -``` - -The above code works with the following toml file. - -```toml -"physical.color" = "orange" -# equivalent to {"physical.color": "orange"}, -# NOT {"physical": {"color": "orange"}}. -``` - - -## Casting a toml value - -### `toml::get` - -`toml::parse` returns `toml::value`. `toml::value` is a union type that can -contain one of the following types. - -- `toml::boolean` (`bool`) -- `toml::integer` (`std::int64_t`) -- `toml::floating` (`double`) -- `toml::string` (a type convertible to std::string) -- `toml::local_date` -- `toml::local_time` -- `toml::local_datetime` -- `toml::offset_datetime` -- `toml::array` (by default, `std::vector`) - - It depends. See [customizing containers](#customizing-containers) for detail. -- `toml::table` (by default, `std::unordered_map`) - - It depends. See [customizing containers](#customizing-containers) for detail. - -To get a value inside, you can use `toml::get()`. The usage is the same as -`toml::find` (actually, `toml::find` internally uses `toml::get` after casting -a value to `toml::table`). - -``` cpp -const toml::value data = toml::parse("sample.toml"); -const toml::value answer_ = toml::get(data).at("answer"); -const std::int64_t answer = toml::get(answer_); -``` - -When you pass an exact TOML type that does not require type conversion, -`toml::get` returns a reference through which you can modify the content -(if the `toml::value` is `const`, it returns `const` reference). - -```cpp -toml::value data = toml::parse("sample.toml"); -toml::value answer_ = toml::get(data).at("answer"); -toml::integer& answer = toml::get(answer_); -answer = 6 * 9; // write to data.answer. now `answer_` contains 54. -``` - -If the specified type requires conversion, you can't take a reference to the value. -See also [underlying types](#underlying-types). - -It also throws a `toml::type_error` if the type differs. - -### `as_xxx` - -You can also use a member function to cast a value. - -```cpp -const std::int64_t answer = data.as_table().at("answer").as_integer(); -``` - -It also throws a `toml::type_error` if the type differs. If you are sure that -the value `v` contains a value of the specified type, you can suppress checking -by passing `std::nothrow`. - -```cpp -const auto& answer = data.as_table().at("answer"); -if(answer.is_integer() && answer.as_integer(std::nothrow) == 42) -{ - std::cout << "value is 42" << std::endl; -} -``` - -If `std::nothrow` is passed, the functions are marked as noexcept. - -By casting a `toml::value` into an array or a table, you can iterate over the -elements. - -```cpp -const auto data = toml::parse("example.toml"); -std::cout << "keys in the top-level table are the following: \n"; -for(const auto& [k, v] : data.as_table()) -{ - std::cout << k << '\n'; -} - -const auto& fruits = toml::find(data, "fruits"); -for(const auto& v : fruits.as_array()) -{ - std::cout << toml::find(v, "name") << '\n'; -} -``` - -The full list of the functions is below. - -```cpp -namespace toml { -class value { - // ... - const boolean& as_boolean() const&; - const integer& as_integer() const&; - const floating& as_floating() const&; - const string& as_string() const&; - const offset_datetime& as_offset_datetime() const&; - const local_datetime& as_local_datetime() const&; - const local_date& as_local_date() const&; - const local_time& as_local_time() const&; - const array& as_array() const&; - const table& as_table() const&; - // -------------------------------------------------------- - // non-const version - boolean& as_boolean() &; - // ditto... - // -------------------------------------------------------- - // rvalue version - boolean&& as_boolean() &&; - // ditto... - - // -------------------------------------------------------- - // noexcept versions ... - const boolean& as_boolean(const std::nothrow_t&) const& noexcept; - boolean& as_boolean(const std::nothrow_t&) & noexcept; - boolean&& as_boolean(const std::nothrow_t&) && noexcept; - // ditto... -}; -} // toml -``` - -### `at()` - -You can access to the element of a table and an array by `toml::basic_value::at`. - -```cpp -const toml::value v{1,2,3,4,5}; -std::cout << v.at(2).as_integer() << std::endl; // 3 - -const toml::value v{{"foo", 42}, {"bar", 3.14}}; -std::cout << v.at("foo").as_integer() << std::endl; // 42 -``` - -If an invalid key (integer for a table, string for an array), it throws -`toml::type_error` for the conversion. If the provided key is out-of-range, -it throws `std::out_of_range`. - -Note that, although `std::string` has `at()` member function, `toml::value::at` -throws if the contained type is a string. Because `std::string` does not -contain `toml::value`. - -### `operator[]` - -You can also access to the element of a table and an array by -`toml::basic_value::operator[]`. - -```cpp -const toml::value v{1,2,3,4,5}; -std::cout << v[2].as_integer() << std::endl; // 3 - -const toml::value v{{"foo", 42}, {"bar", 3.14}}; -std::cout << v["foo"].as_integer() << std::endl; // 42 -``` - -When you access to a `toml::value` that is not initialized yet via -`operator[](const std::string&)`, the `toml::value` will be a table, -just like the `std::map`. - -```cpp -toml::value v; // not initialized as a table. -v["foo"] = 42; // OK. `v` will be a table. -``` - -Contrary, if you access to a `toml::value` that contains an array via `operator[]`, -it does not check anything. It converts `toml::value` without type check and then -access to the n-th element without boundary check, just like the `std::vector::operator[]`. - -```cpp -toml::value v; // not initialized as an array -v[2] = 42; // error! UB -``` - -Please make sure that the `toml::value` has an array inside when you access to -its element via `operator[]`. - -## Checking value type - -You can check the type of a value by `is_xxx` function. - -```cpp -const toml::value v = /* ... */; -if(v.is_integer()) -{ - std::cout << "value is an integer" << std::endl; -} -``` - -The complete list of the functions is below. - -```cpp -namespace toml { -class value { - // ... - bool is_boolean() const noexcept; - bool is_integer() const noexcept; - bool is_floating() const noexcept; - bool is_string() const noexcept; - bool is_offset_datetime() const noexcept; - bool is_local_datetime() const noexcept; - bool is_local_date() const noexcept; - bool is_local_time() const noexcept; - bool is_array() const noexcept; - bool is_table() const noexcept; - bool is_uninitialized() const noexcept; - // ... -}; -} // toml -``` - -Also, you can get `enum class value_t` from `toml::value::type()`. - -```cpp -switch(data.at("something").type()) -{ - case toml::value_t::integer: /*do some stuff*/ ; break; - case toml::value_t::floating: /*do some stuff*/ ; break; - case toml::value_t::string : /*do some stuff*/ ; break; - default : throw std::runtime_error( - "unexpected type : " + toml::stringize(data.at("something").type())); -} -``` - -The complete list of the `enum`s can be found in the section -[underlying types](#underlying-types). - -The `enum`s can be used as a parameter of `toml::value::is` function like the following. - -```cpp -toml::value v = /* ... */; -if(v.is(toml::value_t::boolean)) // ... -``` - -## More about conversion - -Since `toml::find` internally uses `toml::get`, all the following examples work -with both `toml::get` and `toml::find`. - -### Converting an array - -You can get any kind of `container` class from a `toml::array` -except for `map`-like classes. - -``` cpp -// # sample.toml -// numbers = [1,2,3] - -const auto numbers = toml::find(data, "numbers"); - -const auto vc = toml::get >(numbers); -const auto ls = toml::get >(numbers); -const auto dq = toml::get >(numbers); -const auto ar = toml::get>(numbers); -// if the size of data.at("numbers") is larger than that of std::array, -// it will throw toml::type_error because std::array is not resizable. -``` - -Surprisingly, you can convert `toml::array` into `std::pair` and `std::tuple`. - -```cpp -// numbers = [1,2,3] -const auto tp = toml::get>(numbers); -``` - -This functionality is helpful when you have a toml file like the following. - -```toml -array_of_arrays = [[1, 2, 3], ["foo", "bar", "baz"]] # toml allows this -``` - -What is the corresponding C++ type? -Obviously, it is a `std::pair` of `std::vector`s. - -```cpp -const auto array_of_arrays = toml::find(data, "array_of_arrays"); -const auto aofa = toml::get< - std::pair, std::vector> - >(array_of_arrays); -``` - -If you don't know the type of the elements, you can use `toml::array`, -which is a `std::vector` of `toml::value`, instead. - -```cpp -const auto a_of_a = toml::get(array_of_arrays); -const auto first = toml::get>(a_of_a.at(0)); -``` - -You can change the implementation of `toml::array` with `std::deque` or some -other array-like container. See [Customizing containers](#customizing-containers) -for detail. - -### Converting a table - -When all the values of the table have the same type, toml11 allows you to -convert a `toml::table` to a `map` that contains the convertible type. - -```toml -[tab] -key1 = "foo" # all the values are -key2 = "bar" # toml String -``` - -```cpp -const auto data = toml::parse("sample.toml"); -const auto tab = toml::find>(data, "tab"); -std::cout << tab["key1"] << std::endl; // foo -std::cout << tab["key2"] << std::endl; // bar -``` - -But since `toml::table` is just an alias of `std::unordered_map`, -normally you don't need to convert it because it has all the functionalities that -`std::unordered_map` has (e.g. `operator[]`, `count`, and `find`). In most cases -`toml::table` is sufficient. - -```cpp -toml::table tab = toml::get(data); -if(data.count("title") != 0) -{ - data["title"] = std::string("TOML example"); -} -``` - -You can change the implementation of `toml::table` with `std::map` or some -other map-like container. See [Customizing containers](#customizing-containers) -for detail. - -### Getting an array of tables - -An array of tables is just an array of tables. -You can get it in completely the same way as the other arrays and tables. - -```toml -# sample.toml -array_of_inline_tables = [{key = "value1"}, {key = "value2"}, {key = "value3"}] - -[[array_of_tables]] -key = "value4" -[[array_of_tables]] -key = "value5" -[[array_of_tables]] -key = "value6" -``` - -```cpp -const auto data = toml::parse("sample.toml"); -const auto aot1 = toml::find>(data, "array_of_inline_tables"); -const auto aot2 = toml::find>(data, "array_of_tables"); -``` - -### Cost of conversion - -Although conversion through `toml::(get|find)` is convenient, it has additional -copy-cost because it copies data contained in `toml::value` to the -user-specified type. Of course in some cases this overhead is not ignorable. - -```cpp -// the following code constructs a std::vector. -// it requires heap allocation for vector and element conversion. -const auto array = toml::find>(data, "foo"); -``` - -By passing the exact types, `toml::get` returns reference that has no overhead. - -``` cpp -const auto& tab = toml::find(data, "tab"); -const auto& numbers = toml::find(data, "numbers"); -``` - -Also, `as_xxx` are zero-overhead because they always return a reference. - -``` cpp -const auto& tab = toml::find(data, "tab" ).as_table(); -const auto& numbers = toml::find(data, "numbers").as_array(); -``` - -In this case you need to call `toml::get` each time you access to -the element of `toml::array` because `toml::array` is an array of `toml::value`. - -```cpp -const auto& num0 = toml::get(numbers.at(0)); -const auto& num1 = toml::get(numbers.at(1)); -const auto& num2 = toml::get(numbers.at(2)); -``` - -### Converting datetime and its variants - -TOML v0.5.0 has 4 different datetime objects, `local_date`, `local_time`, -`local_datetime`, and `offset_datetime`. - -Since `local_date`, `local_datetime`, and `offset_datetime` represent a time -point, you can convert them to `std::chrono::system_clock::time_point`. - -Contrary, `local_time` does not represents a time point because they lack a -date information, but it can be converted to `std::chrono::duration` that -represents a duration from the beginning of the day, `00:00:00.000`. - -```toml -# sample.toml -date = 2018-12-23 -time = 12:30:00 -l_dt = 2018-12-23T12:30:00 -o_dt = 2018-12-23T12:30:00+09:30 -``` - -```cpp -const auto data = toml::parse("sample.toml"); - -const auto date = toml::get(data.at("date")); -const auto l_dt = toml::get(data.at("l_dt")); -const auto o_dt = toml::get(data.at("o_dt")); - -const auto time = toml::get(data.at("time")); // 12 * 60 + 30 min -``` - -`local_date` and `local_datetime` are assumed to be in the local timezone when -they are converted into `time_point`. On the other hand, `offset_datetime` only -uses the offset part of the data and it does not take local timezone into account. - -To contain datetime data, toml11 defines its own datetime types. -For more detail, you can see the definitions in [toml/datetime.hpp](toml/datetime.hpp). - -## Getting with a fallback - -`toml::find_or` returns a default value if the value is not found or has a -different type. - -```cpp -const auto data = toml::parse("example.toml"); -const auto num = toml::find_or(data, "num", 42); -``` - -Also, `toml::get_or` returns a default value if `toml::get` failed. - -```cpp -toml::value v("foo"); // v contains String -const int value = toml::get_or(v, 42); // conversion fails. it returns 42. -``` - -These functions automatically deduce what type you want to get -from the default value you passed. - -To get a reference through this function, take care about the default value. - -```cpp -toml::value v("foo"); // v contains String -toml::integer& i = toml::get_or(v, 42); // does not work because binding `42` - // to `integer&` is invalid -toml::integer opt = 42; -toml::integer& i = toml::get_or(v, opt); // this works. -``` - -## Expecting conversion - -By using `toml::expect`, you will get your expected value or an error message -without throwing `toml::type_error`. - -```cpp -const auto value = toml::expect(data.at("title")); -if(value.is_ok()) { - std::cout << value.unwrap() << std::endl; -} else { - std::cout << value.unwrap_err() << std::endl; -} -``` - -Also, you can pass a function object to modify the expected value. - -```cpp -const auto value = toml::expect(data.at("number")) - .map(// function that receives expected type (here, int) - [](const int number) -> double { - return number * 1.5 + 1.0; - }).unwrap_or(/*default value =*/ 3.14); -``` - -## Visiting a toml::value - -toml11 provides `toml::visit` to apply a function to `toml::value` in the -same way as `std::variant`. - -```cpp -const toml::value v(3.14); -toml::visit([](const auto& val) -> void { - std::cout << val << std::endl; - }, v); -``` - -The function object that would be passed to `toml::visit` must be able to -recieve all the possible TOML types. Also, the result types should be the same -each other. - -## Constructing a toml::value - -`toml::value` can be constructed in various ways. - -```cpp -toml::value v(true); // boolean -toml::value v(42); // integer -toml::value v(3.14); // floating -toml::value v("foobar"); // string -toml::value v(toml::local_date(2019, toml::month_t::Apr, 1)); // date -toml::value v{1, 2, 3, 4, 5}; // array -toml::value v{{"foo", 42}, {"bar", 3.14}, {"baz", "qux"}}; // table -``` - -When constructing a string, you can choose to use either literal or basic string. -By default, it will be a basic string. - -```cpp -toml::value v("foobar", toml::string_t::basic ); -toml::value v("foobar", toml::string_t::literal); -``` - -Datetime objects can be constructed from `std::tm` and -`std::chrono::system_clock::time_point`. But you need to specify what type -you use to avoid ambiguity. - -```cpp -const auto now = std::chrono::system_clock::now(); -toml::value v(toml::local_date(now)); -toml::value v(toml::local_datetime(now)); -toml::value v(toml::offset_datetime(now)); -``` - -Since local time is not equivalent to a time point, because it lacks date -information, it will be constructed from `std::chrono::duration`. - -```cpp -toml::value v(toml::local_time(std::chrono::hours(10))); -``` - -You can construct an array object not only from `initializer_list`, but also -from STL containers. In that case, the element type must be convertible to -`toml::value`. - -```cpp -std::vector vec{1,2,3,4,5}; -toml::value v(vec); -``` - -When you construct an array value, all the elements of `initializer_list` -must be convertible into `toml::value`. - -If a `toml::value` has an array, you can `push_back` an element in it. - -```cpp -toml::value v{1,2,3,4,5}; -v.push_back(6); -``` - -`emplace_back` also works. - -## Preserving comments - -After toml11 v3, you can choose whether comments are preserved or not. - -```cpp -const auto data1 = toml::parse("example.toml"); -const auto data2 = toml::parse("example.toml"); -``` - -Comments related to a value can be obtained by `toml::value::comments()`. -The return value has the same interface as `std::vector`. - -```cpp -const auto& com = v.comments(); -for(const auto& c : com) -{ - std::cout << c << std::endl; -} -``` - -Comments just before and just after (within the same line) a value are kept in a value. - -```toml -# this is a comment for v1. -v1 = "foo" - -v2 = "bar" # this is a comment for v2. -# Note that this comment is NOT a comment for v2. - -# this comment is not related to any value -# because there are empty lines between v3. -# this comment will be ignored even if you set `preserve_comments`. - -# this is a comment for v3 -# this is also a comment for v3. -v3 = "baz" # ditto. -``` - -Each comment line becomes one element of a `std::vector`. - -Hash signs will be removed, but spaces after hash sign will not be removed. - -```cpp -v1.comments().at(0) == " this is a comment for v1."s; - -v2.comments().at(1) == " this is a comment for v1."s; - -v3.comments().at(0) == " this is a comment for v3."s; -v3.comments().at(1) == " this is also a comment for v3."s; -v3.comments().at(2) == " ditto."s; -``` - -Note that a comment just after an opening brace of an array will not be a -comment for the array. - -```toml -# this is a comment for a. -a = [ # this is not a comment for a. this will be ignored. - 1, 2, 3, - # this is a comment for `42`. - 42, # this is also a comment for `42`. - 5 -] # this is a comment for a. -``` - -You can also append and modify comments. -The interfaces are the same as `std::vector`. - -```cpp -toml::basic_value v(42); -v.comments().push_back(" add this comment."); -// # add this comment. -// i = 42 -``` - -Also, you can pass a `std::vector` when constructing a -`toml::basic_value`. - -```cpp -std::vector comments{"comment 1", "comment 2"}; -const toml::basic_value v1(42, std::move(comments)); -const toml::basic_value v2(42, {"comment 1", "comment 2"}); -``` - -When `toml::discard_comments` is chosen, comments will not be contained in a value. -`value::comments()` will always be kept empty. -All the modification on comments would be ignored. -All the element access in a `discard_comments` causes the same error as accessing -an element of an empty `std::vector`. - -The comments will also be serialized. If comments exist, those comments will be -added just before the values. - -__NOTE__: Result types from `toml::parse(...)` and -`toml::parse(...)` are different. - -## Customizing containers - -Actually, `toml::basic_value` has 3 template arguments. - -```cpp -template class Table = std::unordered_map, - template class Array = std::vector> -class basic_value; -``` - -This enables you to change the containers used inside. E.g. you can use -`std::map` to contain a table object instead of `std::unordered_map`. -And also can use `std::deque` as a array object instead of `std::vector`. - -You can set these parameters while calling `toml::parse` function. - -```cpp -const auto data = toml::parse< - toml::preserve_comments, std::map, std::deque - >("example.toml"); -``` - -Needless to say, the result types from `toml::parse(...)` and -`toml::parse(...)` are different (unless you specify the same -types as default). - -Note that, since `toml::table` and `toml::array` is an alias for a table and an -array of a default `toml::value`, so it is different from the types actually -contained in a `toml::basic_value` when you customize containers. -To get the actual type in a generic way, use -`typename toml::basic_type::table_type` and -`typename toml::basic_type::array_type`. - -## TOML literal - -toml11 supports `"..."_toml` literal. -It accept both a bare value and a file content. - -```cpp -using namespace toml::literals::toml_literals; - -// `_toml` can convert a bare value without key -const toml::value v = u8"0xDEADBEEF"_toml; -// v is an Integer value containing 0xDEADBEEF. - -// raw string literal (`R"(...)"` is useful for this purpose) -const toml::value t = u8R"( - title = "this is TOML literal" - [table] - key = "value" -)"_toml; -// the literal will be parsed and the result will be contained in t -``` - -The literal function is defined in the same way as the standard library literals -such as `std::literals::string_literals::operator""s`. - -```cpp -namespace toml -{ -inline namespace literals -{ -inline namespace toml_literals -{ -toml::value operator"" _toml(const char* str, std::size_t len); -} // toml_literals -} // literals -} // toml -``` - -Access to the operator can be gained with `using namespace toml::literals;`, -`using namespace toml::toml_literals`, and `using namespace toml::literals::toml_literals`. - -Note that a key that is composed only of digits is allowed in TOML. -And, unlike the file parser, toml-literal allows a bare value without a key. -Thus it is difficult to distinguish arrays having integers and definitions of -tables that are named as digits. -Currently, literal `[1]` becomes a table named "1". -To ensure a literal to be considered as an array with one element, you need to -add a comma after the first element (like `[1,]`). - -```cpp -"[1,2,3]"_toml; // This is an array -"[table]"_toml; // This is a table that has an empty table named "table" inside. -"[[1,2,3]]"_toml; // This is an array of arrays -"[[table]]"_toml; // This is a table that has an array of tables inside. - -"[[1]]"_toml; // This literal is ambiguous. - // Currently, it becomes a table that has array of table "1". -"1 = [{}]"_toml; // This is a table that has an array of table named 1. -"[[1,]]"_toml; // This is an array of arrays. -"[[1],]"_toml; // ditto. -``` - -NOTE: `_toml` literal returns a `toml::value` that does not have comments. - -## Conversion between toml value and arbitrary types - -You can also use `toml::get` and other related functions with the types -you defined after you implement a way to convert it. - -```cpp -namespace ext -{ -struct foo -{ - int a; - double b; - std::string c; -}; -} // ext - -const auto data = toml::parse("example.toml"); - -// to do this -const foo f = toml::find(data, "foo"); -``` - -There are 3 ways to use `toml::get` with the types that you defined. - -The first one is to implement `from_toml(const toml::value&)` member function. - -```cpp -namespace ext -{ -struct foo -{ - int a; - double b; - std::string c; - - void from_toml(const toml::value& v) - { - this->a = toml::find(v, "a"); - this->b = toml::find(v, "b"); - this->c = toml::find(v, "c"); - return; - } -}; -} // ext -``` - -In this way, because `toml::get` first constructs `foo` without arguments, -the type should be default-constructible. - -The second is to implement `constructor(const toml::value&)`. - -```cpp -namespace ext -{ -struct foo -{ - explicit foo(const toml::value& v) - : a(toml::find(v, "a")), b(toml::find(v, "b")), - c(toml::find(v, "c")) - {} - - int a; - double b; - std::string c; -}; -} // ext -``` - -Note that implicit default constructor declaration will be suppressed -when a constructor is defined. If you want to use the struct (here, `foo`) -in a container (e.g. `std::vector`), you may need to define default -constructor explicitly. - -The third is to implement specialization of `toml::from` for your type. - -```cpp -namespace ext -{ -struct foo -{ - int a; - double b; - std::string c; -}; -} // ext - -namespace toml -{ -template<> -struct from -{ - static ext::foo from_toml(const value& v) - { - ext::foo f; - f.a = find(v, "a"); - f.b = find(v, "b"); - f.c = find(v, "c"); - return f; - } -}; -} // toml -``` - -In this way, since the conversion function is defined outside of the class, -you can add conversion between `toml::value` and classes defined in another library. - -Note that you cannot implement both of the functions because the overload -resolution of `toml::get` will be ambiguous. - -If you want to convert any versions of `toml::basic_value`, -you need to templatize the conversion function as follows. - -```cpp -struct foo -{ - template class M, template class A> - void from_toml(const toml::basic_value& v) - { - this->a = toml::find(v, "a"); - this->b = toml::find(v, "b"); - this->c = toml::find(v, "c"); - return; - } -}; -// or -namespace toml -{ -template<> -struct from -{ - template class M, template class A> - static ext::foo from_toml(const basic_value& v) - { - ext::foo f; - f.a = find(v, "a"); - f.b = find(v, "b"); - f.c = find(v, "c"); - return f; - } -}; -} // toml -``` - ----- - -The opposite direction is also supported in a similar way. You can directly -pass your type to `toml::value`'s constructor by introducing `into_toml` or -`toml::into`. - -```cpp -namespace ext -{ -struct foo -{ - int a; - double b; - std::string c; - - toml::value into_toml() const // you need to mark it const. - { - return toml::value{{"a", this->a}, {"b", this->b}, {"c", this->c}}; - } -}; -} // ext - -ext::foo f{42, 3.14, "foobar"}; -toml::value v(f); -``` - -The definition of `toml::into` is similar to `toml::from`. - -```cpp -namespace ext -{ -struct foo -{ - int a; - double b; - std::string c; -}; -} // ext - -namespace toml -{ -template<> -struct into -{ - static toml::value into_toml(const ext::foo& f) - { - return toml::value{{"a", f.a}, {"b", f.b}, {"c", f.c}}; - } -}; -} // toml - -ext::foo f{42, 3.14, "foobar"}; -toml::value v(f); -``` - -Any type that can be converted to `toml::value`, e.g. `int`, `toml::table` and -`toml::array` are okay to return from `into_toml`. - -You can also return a custom `toml::basic_value` from `toml::into`. - -```cpp -namespace toml -{ -template<> -struct into -{ - static toml::basic_value into_toml(const ext::foo& f) - { - toml::basic_value v{{"a", f.a}, {"b", f.b}, {"c", f.c}}; - v.comments().push_back(" comment"); - return v; - } -}; -} // toml -``` - -But note that, if this `basic_value` would be assigned into other `toml::value` -that discards `comments`, the comments would be dropped. - -### Macro to automatically define conversion functions - -There is a helper macro that automatically generates conversion functions `from` and `into` for a simple struct. - -```cpp -namespace foo -{ -struct Foo -{ - std::string s; - double d; - int i; -}; -} // foo - -TOML11_DEFINE_CONVERSION_NON_INTRUSIVE(foo::Foo, s, d, i) - -int main() -{ - const auto file = toml::parse("example.toml"); - auto f = toml::find(file, "foo"); -} -``` - -And then you can use `toml::find(file, "foo");` - -**Note** that, because of a slight difference in implementation of preprocessor between gcc/clang and MSVC, [you need to define `/Zc:preprocessor`](https://github.com/ToruNiina/toml11/issues/139#issuecomment-803683682) to use it in MSVC (Thank you @glebm !). - -## Formatting user-defined error messages - -When you encounter an error after you read the toml value, you may want to -show the error with the value. - -toml11 provides you a function that formats user-defined error message with -related values. With a code like the following, - -```cpp -const auto value = toml::find(data, "num"); -if(value < 0) -{ - std::cerr << toml::format_error("[error] value should be positive", - data.at("num"), "positive number required") - << std::endl; -} -``` - -you will get an error message like this. - -```console -[error] value should be positive - --> example.toml - 3 | num = -42 - | ~~~ positive number required -``` - -When you pass two values to `toml::format_error`, - -```cpp -const auto min = toml::find(range, "min"); -const auto max = toml::find(range, "max"); -if(max < min) -{ - std::cerr << toml::format_error("[error] max should be larger than min", - data.at("min"), "minimum number here", - data.at("max"), "maximum number here"); - << std::endl; -} -``` - -you will get an error message like this. - -```console -[error] max should be larger than min - --> example.toml - 3 | min = 54 - | ~~ minimum number here - ... - 4 | max = 42 - | ~~ maximum number here -``` - -You can print hints at the end of the message. - -```cpp -std::vector hints; -hints.push_back("positive number means n >= 0."); -hints.push_back("negative number is not positive."); -std::cerr << toml::format_error("[error] value should be positive", - data.at("num"), "positive number required", hints) - << std::endl; -``` - -```console -[error] value should be positive - --> example.toml - 2 | num = 42 - | ~~ positive number required - | -Hint: positive number means n >= 0. -Hint: negative number is not positive. -``` - -## Obtaining location information - -You can also format error messages in your own way by using `source_location`. - -```cpp -struct source_location -{ - std::uint_least32_t line() const noexcept; - std::uint_least32_t column() const noexcept; - std::uint_least32_t region() const noexcept; - std::string const& file_name() const noexcept; - std::string const& line_str() const noexcept; -}; -// +-- line() +--- length of the region (here, region() == 9) -// v .---+---. -// 12 | value = "foo bar" <- line_str() returns the line itself. -// ^-------- column() points here -``` - -You can get this by -```cpp -const toml::value v = /*...*/; -const toml::source_location loc = v.location(); -``` - -## Exceptions - -The following `exception` classes inherits `toml::exception` that inherits -`std::exception`. - -```cpp -namespace toml { -struct exception : public std::exception {/**/}; -struct syntax_error : public toml::exception {/**/}; -struct type_error : public toml::exception {/**/}; -struct internal_error : public toml::exception {/**/}; -} // toml -``` - -`toml::exception` has `toml::exception::location()` member function that returns -`toml::source_location`, in addition to `what()`. - -```cpp -namespace toml { -struct exception : public std::exception -{ - // ... - source_location const& location() const noexcept; -}; -} // toml -``` - -It represents where the error occurs. - -`syntax_error` will be thrown from `toml::parse` and `_toml` literal. -`type_error` will be thrown from `toml::get/find`, `toml::value::as_xxx()`, and -other functions that takes a content inside of `toml::value`. - -Note that, currently, from `toml::value::at()` and `toml::find(value, key)` -may throw an `std::out_of_range` that does not inherits `toml::exception`. - -Also, in some cases, most likely in the file open error, it will throw an -`std::runtime_error`. - -## Colorize Error Messages - -By defining `TOML11_COLORIZE_ERROR_MESSAGE`, the error messages from -`toml::parse` and `toml::find|get` will be colorized. By default, this feature -is turned off. - -With the following toml file taken from `toml-lang/toml/tests/hard_example.toml`, - -```toml -[error] -array = [ - "This might most likely happen in multiline arrays", - Like here, - "or here, - and here" - ] End of array comment, forgot the # -``` - -the error message would be like this. - -![error-message-1](https://github.com/ToruNiina/toml11/blob/misc/misc/toml11-err-msg-1.png) - -With the following, - -```toml -[error] -# array = [ -# "This might most likely happen in multiline arrays", -# Like here, -# "or here, -# and here" -# ] End of array comment, forgot the # -number = 3.14 pi <--again forgot the # -``` - -the error message would be like this. - -![error-message-2](https://github.com/ToruNiina/toml11/blob/misc/misc/toml11-err-msg-2.png) - -The message would be messy when it is written to a file, not a terminal because -it uses [ANSI escape code](https://en.wikipedia.org/wiki/ANSI_escape_code). - -Without `TOML11_COLORIZE_ERROR_MESSAGE`, you can still colorize user-defined -error message by passing `true` to the `toml::format_error` function. -If you define `TOML11_COLORIZE_ERROR_MESSAGE`, the value is `true` by default. -If not, the defalut value would be `false`. - -```cpp -std::cerr << toml::format_error("[error] value should be positive", - data.at("num"), "positive number required", - hints, /*colorize = */ true) << std::endl; -``` - -Note: It colorize `[error]` in red. That means that it detects `[error]` prefix -at the front of the error message. If there is no `[error]` prefix, -`format_error` adds it to the error message. - -## Serializing TOML data - -toml11 enables you to serialize data into toml format. - -```cpp -const toml::value data{{"foo", 42}, {"bar", "baz"}}; -std::cout << data << std::endl; -// bar = "baz" -// foo = 42 -``` - -toml11 automatically makes a small table and small array inline. -You can specify the width to make them inline by `std::setw` for streams. - -```cpp -const toml::value data{ - {"qux", {{"foo", 42}, {"bar", "baz"}}}, - {"quux", {"small", "array", "of", "strings"}}, - {"foobar", {"this", "array", "of", "strings", "is", "too", "long", - "to", "print", "into", "single", "line", "isn't", "it?"}}, -}; - -// the threshold becomes 80. -std::cout << std::setw(80) << data << std::endl; -// foobar = [ -// "this","array","of","strings","is","too","long","to","print","into", -// "single","line","isn't","it?", -// ] -// quux = ["small","array","of","strings"] -// qux = {bar="baz",foo=42} - - -// the width is 0. nothing become inline. -std::cout << std::setw(0) << data << std::endl; -// foobar = [ -// "this", -// ... (snip) -// "it?", -// ] -// quux = [ -// "small", -// "array", -// "of", -// "strings", -// ] -// [qux] -// bar = "baz" -// foo = 42 -``` - -It is recommended to set width before printing data. Some I/O functions changes -width to 0, and it makes all the stuff (including `toml::array`) multiline. -The resulting files becomes too long. - -To control the precision of floating point numbers, you need to pass -`std::setprecision` to stream. - -```cpp -const toml::value data{ - {"pi", 3.141592653589793}, - {"e", 2.718281828459045} -}; -std::cout << std::setprecision(17) << data << std::endl; -// e = 2.7182818284590451 -// pi = 3.1415926535897931 -std::cout << std::setprecision( 7) << data << std::endl; -// e = 2.718282 -// pi = 3.141593 -``` - -There is another way to format toml values, `toml::format()`. -It returns `std::string` that represents a value. - -```cpp -const toml::value v{{"a", 42}}; -const std::string fmt = toml::format(v); -// a = 42 -``` - -Note that since `toml::format` formats a value, the resulting string may lack -the key value. - -```cpp -const toml::value v{3.14}; -const std::string fmt = toml::format(v); -// 3.14 -``` - -To control the width and precision, `toml::format` receives optional second and -third arguments to set them. By default, the witdh is 80 and the precision is -`std::numeric_limits::max_digit10`. - -```cpp -const auto serial = toml::format(data, /*width = */ 0, /*prec = */ 17); -``` - -When you pass a comment-preserving-value, the comment will also be serialized. -An array or a table containing a value that has a comment would not be inlined. - -## Underlying types - -The toml types (can be used as `toml::*` in this library) and corresponding `enum` names are listed in the table below. - -| TOML type | underlying c++ type | enum class | -| -------------- | ---------------------------------- | -------------------------------- | -| Boolean | `bool` | `toml::value_t::boolean` | -| Integer | `std::int64_t` | `toml::value_t::integer` | -| Float | `double` | `toml::value_t::floating` | -| String | `toml::string` | `toml::value_t::string` | -| LocalDate | `toml::local_date` | `toml::value_t::local_date` | -| LocalTime | `toml::local_time` | `toml::value_t::local_time` | -| LocalDatetime | `toml::local_datetime` | `toml::value_t::local_datetime` | -| OffsetDatetime | `toml::offset_datetime` | `toml::value_t::offset_datetime` | -| Array | `array-like` | `toml::value_t::array` | -| Table | `map-like` | `toml::value_t::table` | - -`array-like` and `map-like` are the STL containers that works like a `std::vector` and -`std::unordered_map`, respectively. By default, `std::vector` and `std::unordered_map` -are used. See [Customizing containers](#customizing-containers) for detail. - -`toml::string` is effectively the same as `std::string` but has an additional -flag that represents a kind of a string, `string_t::basic` and `string_t::literal`. -Although `std::string` is not an exact toml type, still you can get a reference -that points to internal `std::string` by using `toml::get()` for convenience. -The most important difference between `std::string` and `toml::string` is that -`toml::string` will be formatted as a TOML string when outputed with `ostream`. -This feature is introduced to make it easy to write a custom serializer. - -`Datetime` variants are `struct` that are defined in this library. -Because `std::chrono::system_clock::time_point` is a __time point__, -not capable of representing a Local Time independent from a specific day. - -## Unreleased TOML features - -Since TOML v1.0.0-rc.1 has been released, those features are now activated by -default. We no longer need to define `TOML11_USE_UNRELEASED_FEATURES`. - -- Leading zeroes in exponent parts of floats are permitted. - - e.g. `1.0e+01`, `5e+05` - - [toml-lang/toml/PR/656](https://github.com/toml-lang/toml/pull/656) -- Allow raw tab characters in basic strings and multi-line basic strings. - - [toml-lang/toml/PR/627](https://github.com/toml-lang/toml/pull/627) -- Allow heterogeneous arrays - - [toml-lang/toml/PR/676](https://github.com/toml-lang/toml/pull/676) - -## Note about heterogeneous arrays - -Although `toml::parse` allows heterogeneous arrays, constructor of `toml::value` -does not. Here the reason is explained. - -```cpp -// this won't be compiled -toml::value v{ - "foo", 3.14, 42, {1,2,3,4,5}, {{"key", "value"}} -} -``` - -There is a workaround for this. By explicitly converting values into -`toml::value`, you can initialize `toml::value` with a heterogeneous array. -Also, you can first initialize a `toml::value` with an array and then -`push_back` into it. - -```cpp -// OK! -toml::value v{ - toml::value("foo"), toml::value(3.14), toml::value(42), - toml::value{1,2,3,4,5}, toml::value{{"key", "value"}} -} - -// OK! -toml::value v(toml::array{}); -v.push_back("foo"); -v.push_back(3.14); - -// OK! -toml::array a; -a.push_back("foo"); -a.push_back(3.14); -toml::value v(std::move(a)); -``` - -The reason why the first example is not allowed is the following. -Let's assume that you are initializing a `toml::value` with a table. - -```cpp - // # expecting TOML table. -toml::value v{ // [v] - {"answer", 42}, // answer = 42 - {"pi", 3.14}, // pi = 3.14 - {"foo", "bar"} // foo = "bar" -}; -``` - -This is indistinguishable from a (heterogeneous) TOML array definition. - -```toml -v = [ - ["answer", 42], - ["pi", 3.14], - ["foo", "bar"], -] -``` - -This means that the above C++ code makes constructor's overload resolution -ambiguous. So a constructor that allows both "table as an initializer-list" and -"heterogeneous array as an initializer-list" cannot be implemented. - -Thus, although it is painful, we need to explicitly cast values into -`toml::value` when you initialize heterogeneous array in a C++ code. - -```cpp -toml::value v{ - toml::value("foo"), toml::value(3.14), toml::value(42), - toml::value{1,2,3,4,5}, toml::value{{"key", "value"}} -}; -``` - -## Breaking Changes from v2 - -Although toml11 is relatively new library (it's three years old now), it had -some confusing and inconvenient user-interfaces because of historical reasons. - -Between v2 and v3, those interfaces are rearranged. - -- `toml::parse` now returns a `toml::value`, not `toml::table`. -- `toml::value` is now an alias of `toml::basic_value`. - - See [Customizing containers](#customizing-containers) for detail. -- The elements of `toml::value_t` are renamed as `snake_case`. - - See [Underlying types](#underlying-types) for detail. -- Supports for the CamelCaseNames are dropped. - - See [Underlying types](#underlying-types) for detail. -- `(is|as)_float` has been removed to make the function names consistent with others. - - Since `float` is a keyword, toml11 named a float type as `toml::floating`. - - Also a `value_t` corresponds to `toml::floating` is named `value_t::floating`. - - So `(is|as)_floating` is introduced and `is_float` has been removed. - - See [Casting a toml::value](#casting-a-tomlvalue) and [Checking value type](#checking-value-type) for detail. -- An overload of `toml::find` for `toml::table` has been dropped. Use `toml::value` version instead. - - Because type conversion between a table and a value causes ambiguity while overload resolution - - Since `toml::parse` now returns a `toml::value`, this feature becomes less important. - - Also because `toml::table` is a normal STL container, implementing utility function is easy. - - See [Finding a toml::value](#finding-a-toml-value) for detail. -- An overload of `operator<<` and `toml::format` for `toml::table`s are dropped. - - Use `toml::value` instead. - - See [Serializing TOML data](#serializing-toml-data) for detail. -- Interface around comments. - - See [Preserving Comments](#preserving-comments) for detail. -- An ancient `from_toml/into_toml` has been removed. Use arbitrary type conversion support. - - See [Conversion between toml value and arbitrary types](#conversion-between-toml-value-and-arbitrary-types) for detail. - -Such a big change will not happen in the coming years. - -## Running Tests - -After cloning this repository, run the following command (thank you @jwillikers -for automating test set fetching!). - -```sh -$ mkdir build -$ cd build -$ cmake .. -Dtoml11_BUILD_TEST=ON -$ make -$ make test -``` - -To run the language agnostic test suite, you need to compile -`tests/check_toml_test.cpp` and pass it to the tester. - -## Contributors - -I appreciate the help of the contributors who introduced the great feature to this library. - -- Guillaume Fraux (@Luthaf) - - Windows support and CI on Appvayor - - Intel Compiler support -- Quentin Khan (@xaxousis) - - Found & Fixed a bug around ODR - - Improved error messages for invaild keys to show the location where the parser fails -- Petr BeneÅ¡ (@wbenny) - - Fixed warnings on MSVC -- Ivan Shynkarenka (@chronoxor) - - Fixed Visual Studio 2019 warnings -- @khoitd1997 - - Fixed warnings while type conversion -- @KerstinKeller - - Added installation script to CMake -- J.C. Moyer (@jcmoyer) - - Fixed an example code in the documentation -- Jt Freeman (@blockparty-sh) - - Fixed feature test macro around `localtime_s` - - Suppress warnings in Debug mode -- OGAWA Kenichi (@kenichiice) - - Suppress warnings on intel compiler -- Jordan Williams (@jwillikers) - - Fixed clang range-loop-analysis warnings - - Fixed feature test macro to suppress -Wundef - - Use cache variables in CMakeLists.txt - - Automate test set fetching, update and refactor CMakeLists.txt -- Scott McCaskill - - Parse 9 digits (nanoseconds) of fractional seconds in a `local_time` -- Shu Wang (@halfelf) - - fix "Finding a value in an array" example in README -- @maass-tv and @SeverinLeonhardt - - Fix MSVC warning C4866 -- OGAWA KenIchi (@kenichiice) - - Fix include path in README -- Mohammed Alyousef (@MoAlyousef) - - Made testing optional in CMake -- Ivan Shynkarenka (@chronoxor) - - Fix compilation error in `` with MinGW -- Alex Merry (@amerry) - - Add missing include files -- sneakypete81 (@sneakypete81) - - Fix typo in error message - - -## Licensing terms - -This product is licensed under the terms of the [MIT License](LICENSE). - -- Copyright (c) 2017-2020 Toru Niina - -All rights reserved. diff --git a/libraries/toml11/include/toml.hpp b/libraries/toml11/include/toml.hpp deleted file mode 100644 index 9ed1216e..00000000 --- a/libraries/toml11/include/toml.hpp +++ /dev/null @@ -1,46 +0,0 @@ -/* - * The MIT License (MIT) - * - * Copyright (c) 2017 Toru Niina - * - * Permission is hereby granted, free of charge, to any person obtaining a copy - * of this software and associated documentation files (the "Software"), to deal - * in the Software without restriction, including without limitation the rights - * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell - * copies of the Software, and to permit persons to whom the Software is - * furnished to do so, subject to the following conditions: - * - * The above copyright notice and this permission notice shall be included in - * all copies or substantial portions of the Software. - * - * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR - * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, - * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE - * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER - * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, - * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN - * THE SOFTWARE. - */ - -#ifndef TOML_FOR_MODERN_CPP -#define TOML_FOR_MODERN_CPP - -#ifndef __cplusplus -# error "__cplusplus is not defined" -#endif - -#if __cplusplus < 201103L && _MSC_VER < 1900 -# error "toml11 requires C++11 or later." -#endif - -#define TOML11_VERSION_MAJOR 3 -#define TOML11_VERSION_MINOR 6 -#define TOML11_VERSION_PATCH 1 - -#include "toml/parser.hpp" -#include "toml/literal.hpp" -#include "toml/serializer.hpp" -#include "toml/get.hpp" -#include "toml/macros.hpp" - -#endif// TOML_FOR_MODERN_CPP diff --git a/libraries/toml11/include/toml/color.hpp b/libraries/toml11/include/toml/color.hpp deleted file mode 100644 index 4cb572cb..00000000 --- a/libraries/toml11/include/toml/color.hpp +++ /dev/null @@ -1,64 +0,0 @@ -#ifndef TOML11_COLOR_HPP -#define TOML11_COLOR_HPP -#include -#include - -#ifdef TOML11_COLORIZE_ERROR_MESSAGE -#define TOML11_ERROR_MESSAGE_COLORIZED true -#else -#define TOML11_ERROR_MESSAGE_COLORIZED false -#endif - -namespace toml -{ - -// put ANSI escape sequence to ostream -namespace color_ansi -{ -namespace detail -{ -inline int colorize_index() -{ - static const int index = std::ios_base::xalloc(); - return index; -} -} // detail - -inline std::ostream& colorize(std::ostream& os) -{ - // by default, it is zero. - os.iword(detail::colorize_index()) = 1; - return os; -} -inline std::ostream& nocolorize(std::ostream& os) -{ - os.iword(detail::colorize_index()) = 0; - return os; -} -inline std::ostream& reset (std::ostream& os) -{if(os.iword(detail::colorize_index()) == 1) {os << "\033[00m";} return os;} -inline std::ostream& bold (std::ostream& os) -{if(os.iword(detail::colorize_index()) == 1) {os << "\033[01m";} return os;} -inline std::ostream& grey (std::ostream& os) -{if(os.iword(detail::colorize_index()) == 1) {os << "\033[30m";} return os;} -inline std::ostream& red (std::ostream& os) -{if(os.iword(detail::colorize_index()) == 1) {os << "\033[31m";} return os;} -inline std::ostream& green (std::ostream& os) -{if(os.iword(detail::colorize_index()) == 1) {os << "\033[32m";} return os;} -inline std::ostream& yellow (std::ostream& os) -{if(os.iword(detail::colorize_index()) == 1) {os << "\033[33m";} return os;} -inline std::ostream& blue (std::ostream& os) -{if(os.iword(detail::colorize_index()) == 1) {os << "\033[34m";} return os;} -inline std::ostream& magenta(std::ostream& os) -{if(os.iword(detail::colorize_index()) == 1) {os << "\033[35m";} return os;} -inline std::ostream& cyan (std::ostream& os) -{if(os.iword(detail::colorize_index()) == 1) {os << "\033[36m";} return os;} -inline std::ostream& white (std::ostream& os) -{if(os.iword(detail::colorize_index()) == 1) {os << "\033[37m";} return os;} -} // color_ansi - -// ANSI escape sequence is the only and default colorization method currently -namespace color = color_ansi; - -} // toml -#endif// TOML11_COLOR_HPP diff --git a/libraries/toml11/include/toml/combinator.hpp b/libraries/toml11/include/toml/combinator.hpp deleted file mode 100644 index e250188f..00000000 --- a/libraries/toml11/include/toml/combinator.hpp +++ /dev/null @@ -1,306 +0,0 @@ -// Copyright Toru Niina 2017. -// Distributed under the MIT License. -#ifndef TOML11_COMBINATOR_HPP -#define TOML11_COMBINATOR_HPP -#include -#include -#include - -#include -#include -#include -#include -#include - -#include "region.hpp" -#include "result.hpp" -#include "traits.hpp" -#include "utility.hpp" - -// they scans characters and returns region if it matches to the condition. -// when they fail, it does not change the location. -// in lexer.hpp, these are used. - -namespace toml -{ -namespace detail -{ - -// to output character as an error message. -inline std::string show_char(const char c) -{ - // It supress an error that occurs only in Debug mode of MSVC++ on Windows. - // I'm not completely sure but they check the value of char to be in the - // range [0, 256) and some of the COMPLETELY VALID utf-8 character sometimes - // has negative value (if char has sign). So here it re-interprets c as - // unsigned char through pointer. In general, converting pointer to a - // pointer that has different type cause UB, but `(signed|unsigned)?char` - // are one of the exceptions. Converting pointer only to char and std::byte - // (c++17) are valid. - if(std::isgraph(*reinterpret_cast(std::addressof(c)))) - { - return std::string(1, c); - } - else - { - std::array buf; - buf.fill('\0'); - const auto r = std::snprintf( - buf.data(), buf.size(), "0x%02x", static_cast(c) & 0xFF); - (void) r; // Unused variable warning - assert(r == static_cast(buf.size()) - 1); - return std::string(buf.data()); - } -} - -template -struct character -{ - static constexpr char target = C; - - static result - invoke(location& loc) - { - if(loc.iter() == loc.end()) {return none();} - const auto first = loc.iter(); - - const char c = *(loc.iter()); - if(c != target) - { - return none(); - } - loc.advance(); // update location - - return ok(region(loc, first, loc.iter())); - } -}; -template -constexpr char character::target; - -// closed interval [Low, Up]. both Low and Up are included. -template -struct in_range -{ - // assuming ascii part of UTF-8... - static_assert(Low <= Up, "lower bound should be less than upper bound."); - - static constexpr char upper = Up; - static constexpr char lower = Low; - - static result - invoke(location& loc) - { - if(loc.iter() == loc.end()) {return none();} - const auto first = loc.iter(); - - const char c = *(loc.iter()); - if(c < lower || upper < c) - { - return none(); - } - - loc.advance(); - return ok(region(loc, first, loc.iter())); - } -}; -template constexpr char in_range::upper; -template constexpr char in_range::lower; - -// keep iterator if `Combinator` matches. otherwise, increment `iter` by 1 char. -// for detecting invalid characters, like control sequences in toml string. -template -struct exclude -{ - static result - invoke(location& loc) - { - if(loc.iter() == loc.end()) {return none();} - auto first = loc.iter(); - - auto rslt = Combinator::invoke(loc); - if(rslt.is_ok()) - { - loc.reset(first); - return none(); - } - loc.reset(std::next(first)); // XXX maybe loc.advance() is okay but... - return ok(region(loc, first, loc.iter())); - } -}; - -// increment `iter`, if matches. otherwise, just return empty string. -template -struct maybe -{ - static result - invoke(location& loc) - { - const auto rslt = Combinator::invoke(loc); - if(rslt.is_ok()) - { - return rslt; - } - return ok(region(loc)); - } -}; - -template -struct sequence; - -template -struct sequence -{ - static result - invoke(location& loc) - { - const auto first = loc.iter(); - const auto rslt = Head::invoke(loc); - if(rslt.is_err()) - { - loc.reset(first); - return none(); - } - return sequence::invoke(loc, std::move(rslt.unwrap()), first); - } - - // called from the above function only, recursively. - template - static result - invoke(location& loc, region reg, Iterator first) - { - const auto rslt = Head::invoke(loc); - if(rslt.is_err()) - { - loc.reset(first); - return none(); - } - reg += rslt.unwrap(); // concat regions - return sequence::invoke(loc, std::move(reg), first); - } -}; - -template -struct sequence -{ - // would be called from sequence::invoke only. - template - static result - invoke(location& loc, region reg, Iterator first) - { - const auto rslt = Head::invoke(loc); - if(rslt.is_err()) - { - loc.reset(first); - return none(); - } - reg += rslt.unwrap(); // concat regions - return ok(reg); - } -}; - -template -struct either; - -template -struct either -{ - static result - invoke(location& loc) - { - const auto rslt = Head::invoke(loc); - if(rslt.is_ok()) {return rslt;} - return either::invoke(loc); - } -}; -template -struct either -{ - static result - invoke(location& loc) - { - return Head::invoke(loc); - } -}; - -template -struct repeat; - -template struct exactly{}; -template struct at_least{}; -struct unlimited{}; - -template -struct repeat> -{ - static result - invoke(location& loc) - { - region retval(loc); - const auto first = loc.iter(); - for(std::size_t i=0; i -struct repeat> -{ - static result - invoke(location& loc) - { - region retval(loc); - - const auto first = loc.iter(); - for(std::size_t i=0; i -struct repeat -{ - static result - invoke(location& loc) - { - region retval(loc); - while(true) - { - auto rslt = T::invoke(loc); - if(rslt.is_err()) - { - return ok(std::move(retval)); - } - retval += rslt.unwrap(); - } - } -}; - -} // detail -} // toml -#endif// TOML11_COMBINATOR_HPP diff --git a/libraries/toml11/include/toml/comments.hpp b/libraries/toml11/include/toml/comments.hpp deleted file mode 100644 index 92fc8e13..00000000 --- a/libraries/toml11/include/toml/comments.hpp +++ /dev/null @@ -1,466 +0,0 @@ -// Copyright Toru Niina 2019. -// Distributed under the MIT License. -#ifndef TOML11_COMMENTS_HPP -#define TOML11_COMMENTS_HPP -#include -#include -#include -#include -#include -#include -#include - -// This file provides mainly two classes, `preserve_comments` and `discard_comments`. -// Those two are a container that have the same interface as `std::vector` -// but bahaves in the opposite way. `preserve_comments` is just the same as -// `std::vector` and each `std::string` corresponds to a comment line. -// Conversely, `discard_comments` discards all the strings and ignores everything -// assigned in it. `discard_comments` is always empty and you will encounter an -// error whenever you access to the element. -namespace toml -{ -struct discard_comments; // forward decl - -// use it in the following way -// -// const toml::basic_value data = -// toml::parse("example.toml"); -// -// the interface is almost the same as std::vector. -struct preserve_comments -{ - // `container_type` is not provided in discard_comments. - // do not use this inner-type in a generic code. - using container_type = std::vector; - - using size_type = container_type::size_type; - using difference_type = container_type::difference_type; - using value_type = container_type::value_type; - using reference = container_type::reference; - using const_reference = container_type::const_reference; - using pointer = container_type::pointer; - using const_pointer = container_type::const_pointer; - using iterator = container_type::iterator; - using const_iterator = container_type::const_iterator; - using reverse_iterator = container_type::reverse_iterator; - using const_reverse_iterator = container_type::const_reverse_iterator; - - preserve_comments() = default; - ~preserve_comments() = default; - preserve_comments(preserve_comments const&) = default; - preserve_comments(preserve_comments &&) = default; - preserve_comments& operator=(preserve_comments const&) = default; - preserve_comments& operator=(preserve_comments &&) = default; - - explicit preserve_comments(const std::vector& c): comments(c){} - explicit preserve_comments(std::vector&& c) - : comments(std::move(c)) - {} - preserve_comments& operator=(const std::vector& c) - { - comments = c; - return *this; - } - preserve_comments& operator=(std::vector&& c) - { - comments = std::move(c); - return *this; - } - - explicit preserve_comments(const discard_comments&) {} - - explicit preserve_comments(size_type n): comments(n) {} - preserve_comments(size_type n, const std::string& x): comments(n, x) {} - preserve_comments(std::initializer_list x): comments(x) {} - template - preserve_comments(InputIterator first, InputIterator last) - : comments(first, last) - {} - - template - void assign(InputIterator first, InputIterator last) {comments.assign(first, last);} - void assign(std::initializer_list ini) {comments.assign(ini);} - void assign(size_type n, const std::string& val) {comments.assign(n, val);} - - // Related to the issue #97. - // - // It is known that `std::vector::insert` and `std::vector::erase` in - // the standard library implementation included in GCC 4.8.5 takes - // `std::vector::iterator` instead of `std::vector::const_iterator`. - // Because of the const-correctness, we cannot convert a `const_iterator` to - // an `iterator`. It causes compilation error in GCC 4.8.5. -#if defined(__GNUC__) && defined(__GNUC_MINOR__) && defined(__GNUC_PATCHLEVEL__) && !defined(__clang__) -# if (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__) <= 40805 -# define TOML11_WORKAROUND_GCC_4_8_X_STANDARD_LIBRARY_IMPLEMENTATION -# endif -#endif - -#ifdef TOML11_WORKAROUND_GCC_4_8_X_STANDARD_LIBRARY_IMPLEMENTATION - iterator insert(iterator p, const std::string& x) - { - return comments.insert(p, x); - } - iterator insert(iterator p, std::string&& x) - { - return comments.insert(p, std::move(x)); - } - void insert(iterator p, size_type n, const std::string& x) - { - return comments.insert(p, n, x); - } - template - void insert(iterator p, InputIterator first, InputIterator last) - { - return comments.insert(p, first, last); - } - void insert(iterator p, std::initializer_list ini) - { - return comments.insert(p, ini); - } - - template - iterator emplace(iterator p, Ts&& ... args) - { - return comments.emplace(p, std::forward(args)...); - } - - iterator erase(iterator pos) {return comments.erase(pos);} - iterator erase(iterator first, iterator last) - { - return comments.erase(first, last); - } -#else - iterator insert(const_iterator p, const std::string& x) - { - return comments.insert(p, x); - } - iterator insert(const_iterator p, std::string&& x) - { - return comments.insert(p, std::move(x)); - } - iterator insert(const_iterator p, size_type n, const std::string& x) - { - return comments.insert(p, n, x); - } - template - iterator insert(const_iterator p, InputIterator first, InputIterator last) - { - return comments.insert(p, first, last); - } - iterator insert(const_iterator p, std::initializer_list ini) - { - return comments.insert(p, ini); - } - - template - iterator emplace(const_iterator p, Ts&& ... args) - { - return comments.emplace(p, std::forward(args)...); - } - - iterator erase(const_iterator pos) {return comments.erase(pos);} - iterator erase(const_iterator first, const_iterator last) - { - return comments.erase(first, last); - } -#endif - - void swap(preserve_comments& other) {comments.swap(other.comments);} - - void push_back(const std::string& v) {comments.push_back(v);} - void push_back(std::string&& v) {comments.push_back(std::move(v));} - void pop_back() {comments.pop_back();} - - template - void emplace_back(Ts&& ... args) {comments.emplace_back(std::forward(args)...);} - - void clear() {comments.clear();} - - size_type size() const noexcept {return comments.size();} - size_type max_size() const noexcept {return comments.max_size();} - size_type capacity() const noexcept {return comments.capacity();} - bool empty() const noexcept {return comments.empty();} - - void reserve(size_type n) {comments.reserve(n);} - void resize(size_type n) {comments.resize(n);} - void resize(size_type n, const std::string& c) {comments.resize(n, c);} - void shrink_to_fit() {comments.shrink_to_fit();} - - reference operator[](const size_type n) noexcept {return comments[n];} - const_reference operator[](const size_type n) const noexcept {return comments[n];} - reference at(const size_type n) {return comments.at(n);} - const_reference at(const size_type n) const {return comments.at(n);} - reference front() noexcept {return comments.front();} - const_reference front() const noexcept {return comments.front();} - reference back() noexcept {return comments.back();} - const_reference back() const noexcept {return comments.back();} - - pointer data() noexcept {return comments.data();} - const_pointer data() const noexcept {return comments.data();} - - iterator begin() noexcept {return comments.begin();} - iterator end() noexcept {return comments.end();} - const_iterator begin() const noexcept {return comments.begin();} - const_iterator end() const noexcept {return comments.end();} - const_iterator cbegin() const noexcept {return comments.cbegin();} - const_iterator cend() const noexcept {return comments.cend();} - - reverse_iterator rbegin() noexcept {return comments.rbegin();} - reverse_iterator rend() noexcept {return comments.rend();} - const_reverse_iterator rbegin() const noexcept {return comments.rbegin();} - const_reverse_iterator rend() const noexcept {return comments.rend();} - const_reverse_iterator crbegin() const noexcept {return comments.crbegin();} - const_reverse_iterator crend() const noexcept {return comments.crend();} - - friend bool operator==(const preserve_comments&, const preserve_comments&); - friend bool operator!=(const preserve_comments&, const preserve_comments&); - friend bool operator< (const preserve_comments&, const preserve_comments&); - friend bool operator<=(const preserve_comments&, const preserve_comments&); - friend bool operator> (const preserve_comments&, const preserve_comments&); - friend bool operator>=(const preserve_comments&, const preserve_comments&); - - friend void swap(preserve_comments&, std::vector&); - friend void swap(std::vector&, preserve_comments&); - - private: - - container_type comments; -}; - -inline bool operator==(const preserve_comments& lhs, const preserve_comments& rhs) {return lhs.comments == rhs.comments;} -inline bool operator!=(const preserve_comments& lhs, const preserve_comments& rhs) {return lhs.comments != rhs.comments;} -inline bool operator< (const preserve_comments& lhs, const preserve_comments& rhs) {return lhs.comments < rhs.comments;} -inline bool operator<=(const preserve_comments& lhs, const preserve_comments& rhs) {return lhs.comments <= rhs.comments;} -inline bool operator> (const preserve_comments& lhs, const preserve_comments& rhs) {return lhs.comments > rhs.comments;} -inline bool operator>=(const preserve_comments& lhs, const preserve_comments& rhs) {return lhs.comments >= rhs.comments;} - -inline void swap(preserve_comments& lhs, preserve_comments& rhs) -{ - lhs.swap(rhs); - return; -} -inline void swap(preserve_comments& lhs, std::vector& rhs) -{ - lhs.comments.swap(rhs); - return; -} -inline void swap(std::vector& lhs, preserve_comments& rhs) -{ - lhs.swap(rhs.comments); - return; -} - -template -std::basic_ostream& -operator<<(std::basic_ostream& os, const preserve_comments& com) -{ - for(const auto& c : com) - { - os << '#' << c << '\n'; - } - return os; -} - -namespace detail -{ - -// To provide the same interface with `preserve_comments`, `discard_comments` -// should have an iterator. But it does not contain anything, so we need to -// add an iterator that points nothing. -// -// It always points null, so DO NOT unwrap this iterator. It always crashes -// your program. -template -struct empty_iterator -{ - using value_type = T; - using reference_type = typename std::conditional::type; - using pointer_type = typename std::conditional::type; - using difference_type = std::ptrdiff_t; - using iterator_category = std::random_access_iterator_tag; - - empty_iterator() = default; - ~empty_iterator() = default; - empty_iterator(empty_iterator const&) = default; - empty_iterator(empty_iterator &&) = default; - empty_iterator& operator=(empty_iterator const&) = default; - empty_iterator& operator=(empty_iterator &&) = default; - - // DO NOT call these operators. - reference_type operator*() const noexcept {std::terminate();} - pointer_type operator->() const noexcept {return nullptr;} - reference_type operator[](difference_type) const noexcept {return this->operator*();} - - // These operators do nothing. - empty_iterator& operator++() noexcept {return *this;} - empty_iterator operator++(int) noexcept {return *this;} - empty_iterator& operator--() noexcept {return *this;} - empty_iterator operator--(int) noexcept {return *this;} - - empty_iterator& operator+=(difference_type) noexcept {return *this;} - empty_iterator& operator-=(difference_type) noexcept {return *this;} - - empty_iterator operator+(difference_type) const noexcept {return *this;} - empty_iterator operator-(difference_type) const noexcept {return *this;} -}; - -template -bool operator==(const empty_iterator&, const empty_iterator&) noexcept {return true;} -template -bool operator!=(const empty_iterator&, const empty_iterator&) noexcept {return false;} -template -bool operator< (const empty_iterator&, const empty_iterator&) noexcept {return false;} -template -bool operator<=(const empty_iterator&, const empty_iterator&) noexcept {return true;} -template -bool operator> (const empty_iterator&, const empty_iterator&) noexcept {return false;} -template -bool operator>=(const empty_iterator&, const empty_iterator&) noexcept {return true;} - -template -typename empty_iterator::difference_type -operator-(const empty_iterator&, const empty_iterator&) noexcept {return 0;} - -template -empty_iterator -operator+(typename empty_iterator::difference_type, const empty_iterator& rhs) noexcept {return rhs;} -template -empty_iterator -operator+(const empty_iterator& lhs, typename empty_iterator::difference_type) noexcept {return lhs;} - -} // detail - -// The default comment type. It discards all the comments. It requires only one -// byte to contain, so the memory footprint is smaller than preserve_comments. -// -// It just ignores `push_back`, `insert`, `erase`, and any other modifications. -// IT always returns size() == 0, the iterator taken by `begin()` is always the -// same as that of `end()`, and accessing through `operator[]` or iterators -// always causes a segmentation fault. DO NOT access to the element of this. -// -// Why this is chose as the default type is because the last version (2.x.y) -// does not contain any comments in a value. To minimize the impact on the -// efficiency, this is choosed as a default. -// -// To reduce the memory footprint, later we can try empty base optimization (EBO). -struct discard_comments -{ - using size_type = std::size_t; - using difference_type = std::ptrdiff_t; - using value_type = std::string; - using reference = std::string&; - using const_reference = std::string const&; - using pointer = std::string*; - using const_pointer = std::string const*; - using iterator = detail::empty_iterator; - using const_iterator = detail::empty_iterator; - using reverse_iterator = detail::empty_iterator; - using const_reverse_iterator = detail::empty_iterator; - - discard_comments() = default; - ~discard_comments() = default; - discard_comments(discard_comments const&) = default; - discard_comments(discard_comments &&) = default; - discard_comments& operator=(discard_comments const&) = default; - discard_comments& operator=(discard_comments &&) = default; - - explicit discard_comments(const std::vector&) noexcept {} - explicit discard_comments(std::vector&&) noexcept {} - discard_comments& operator=(const std::vector&) noexcept {return *this;} - discard_comments& operator=(std::vector&&) noexcept {return *this;} - - explicit discard_comments(const preserve_comments&) noexcept {} - - explicit discard_comments(size_type) noexcept {} - discard_comments(size_type, const std::string&) noexcept {} - discard_comments(std::initializer_list) noexcept {} - template - discard_comments(InputIterator, InputIterator) noexcept {} - - template - void assign(InputIterator, InputIterator) noexcept {} - void assign(std::initializer_list) noexcept {} - void assign(size_type, const std::string&) noexcept {} - - iterator insert(const_iterator, const std::string&) {return iterator{};} - iterator insert(const_iterator, std::string&&) {return iterator{};} - iterator insert(const_iterator, size_type, const std::string&) {return iterator{};} - template - iterator insert(const_iterator, InputIterator, InputIterator) {return iterator{};} - iterator insert(const_iterator, std::initializer_list) {return iterator{};} - - template - iterator emplace(const_iterator, Ts&& ...) {return iterator{};} - iterator erase(const_iterator) {return iterator{};} - iterator erase(const_iterator, const_iterator) {return iterator{};} - - void swap(discard_comments&) {return;} - - void push_back(const std::string&) {return;} - void push_back(std::string&& ) {return;} - void pop_back() {return;} - - template - void emplace_back(Ts&& ...) {return;} - - void clear() {return;} - - size_type size() const noexcept {return 0;} - size_type max_size() const noexcept {return 0;} - size_type capacity() const noexcept {return 0;} - bool empty() const noexcept {return true;} - - void reserve(size_type) {return;} - void resize(size_type) {return;} - void resize(size_type, const std::string&) {return;} - void shrink_to_fit() {return;} - - // DO NOT access to the element of this container. This container is always - // empty, so accessing through operator[], front/back, data causes address - // error. - - reference operator[](const size_type) noexcept {return *data();} - const_reference operator[](const size_type) const noexcept {return *data();} - reference at(const size_type) {throw std::out_of_range("toml::discard_comment is always empty.");} - const_reference at(const size_type) const {throw std::out_of_range("toml::discard_comment is always empty.");} - reference front() noexcept {return *data();} - const_reference front() const noexcept {return *data();} - reference back() noexcept {return *data();} - const_reference back() const noexcept {return *data();} - - pointer data() noexcept {return nullptr;} - const_pointer data() const noexcept {return nullptr;} - - iterator begin() noexcept {return iterator{};} - iterator end() noexcept {return iterator{};} - const_iterator begin() const noexcept {return const_iterator{};} - const_iterator end() const noexcept {return const_iterator{};} - const_iterator cbegin() const noexcept {return const_iterator{};} - const_iterator cend() const noexcept {return const_iterator{};} - - reverse_iterator rbegin() noexcept {return iterator{};} - reverse_iterator rend() noexcept {return iterator{};} - const_reverse_iterator rbegin() const noexcept {return const_iterator{};} - const_reverse_iterator rend() const noexcept {return const_iterator{};} - const_reverse_iterator crbegin() const noexcept {return const_iterator{};} - const_reverse_iterator crend() const noexcept {return const_iterator{};} -}; - -inline bool operator==(const discard_comments&, const discard_comments&) noexcept {return true;} -inline bool operator!=(const discard_comments&, const discard_comments&) noexcept {return false;} -inline bool operator< (const discard_comments&, const discard_comments&) noexcept {return false;} -inline bool operator<=(const discard_comments&, const discard_comments&) noexcept {return true;} -inline bool operator> (const discard_comments&, const discard_comments&) noexcept {return false;} -inline bool operator>=(const discard_comments&, const discard_comments&) noexcept {return true;} - -inline void swap(const discard_comments&, const discard_comments&) noexcept {return;} - -template -std::basic_ostream& -operator<<(std::basic_ostream& os, const discard_comments&) -{ - return os; -} - -} // toml11 -#endif// TOML11_COMMENTS_HPP diff --git a/libraries/toml11/include/toml/datetime.hpp b/libraries/toml11/include/toml/datetime.hpp deleted file mode 100644 index d8127c15..00000000 --- a/libraries/toml11/include/toml/datetime.hpp +++ /dev/null @@ -1,631 +0,0 @@ -// Copyright Toru Niina 2017. -// Distributed under the MIT License. -#ifndef TOML11_DATETIME_HPP -#define TOML11_DATETIME_HPP -#include -#include -#include - -#include -#include -#include -#include -#include - -namespace toml -{ - -// To avoid non-threadsafe std::localtime. In C11 (not C++11!), localtime_s is -// provided in the absolutely same purpose, but C++11 is actually not compatible -// with C11. We need to dispatch the function depending on the OS. -namespace detail -{ -// TODO: find more sophisticated way to handle this -#if (defined(_POSIX_C_SOURCE) && _POSIX_C_SOURCE >= 1) || defined(_XOPEN_SOURCE) || defined(_BSD_SOURCE) || defined(_SVID_SOURCE) || defined(_POSIX_SOURCE) -inline std::tm localtime_s(const std::time_t* src) -{ - std::tm dst; - const auto result = ::localtime_r(src, &dst); - if (!result) { throw std::runtime_error("localtime_r failed."); } - return dst; -} -inline std::tm gmtime_s(const std::time_t* src) -{ - std::tm dst; - const auto result = ::gmtime_r(src, &dst); - if (!result) { throw std::runtime_error("gmtime_r failed."); } - return dst; -} -#elif defined(_MSC_VER) -inline std::tm localtime_s(const std::time_t* src) -{ - std::tm dst; - const auto result = ::localtime_s(&dst, src); - if (result) { throw std::runtime_error("localtime_s failed."); } - return dst; -} -inline std::tm gmtime_s(const std::time_t* src) -{ - std::tm dst; - const auto result = ::gmtime_s(&dst, src); - if (result) { throw std::runtime_error("gmtime_s failed."); } - return dst; -} -#else // fallback. not threadsafe -inline std::tm localtime_s(const std::time_t* src) -{ - const auto result = std::localtime(src); - if (!result) { throw std::runtime_error("localtime failed."); } - return *result; -} -inline std::tm gmtime_s(const std::time_t* src) -{ - const auto result = std::gmtime(src); - if (!result) { throw std::runtime_error("gmtime failed."); } - return *result; -} -#endif -} // detail - -enum class month_t : std::uint8_t -{ - Jan = 0, - Feb = 1, - Mar = 2, - Apr = 3, - May = 4, - Jun = 5, - Jul = 6, - Aug = 7, - Sep = 8, - Oct = 9, - Nov = 10, - Dec = 11 -}; - -struct local_date -{ - std::int16_t year; // A.D. (like, 2018) - std::uint8_t month; // [0, 11] - std::uint8_t day; // [1, 31] - - local_date(int y, month_t m, int d) - : year (static_cast(y)), - month(static_cast(m)), - day (static_cast(d)) - {} - - explicit local_date(const std::tm& t) - : year (static_cast(t.tm_year + 1900)), - month(static_cast(t.tm_mon)), - day (static_cast(t.tm_mday)) - {} - - explicit local_date(const std::chrono::system_clock::time_point& tp) - { - const auto t = std::chrono::system_clock::to_time_t(tp); - const auto time = detail::localtime_s(&t); - *this = local_date(time); - } - - explicit local_date(const std::time_t t) - : local_date(std::chrono::system_clock::from_time_t(t)) - {} - - operator std::chrono::system_clock::time_point() const - { - // std::mktime returns date as local time zone. no conversion needed - std::tm t; - t.tm_sec = 0; - t.tm_min = 0; - t.tm_hour = 0; - t.tm_mday = static_cast(this->day); - t.tm_mon = static_cast(this->month); - t.tm_year = static_cast(this->year) - 1900; - t.tm_wday = 0; // the value will be ignored - t.tm_yday = 0; // the value will be ignored - t.tm_isdst = -1; - return std::chrono::system_clock::from_time_t(std::mktime(&t)); - } - - operator std::time_t() const - { - return std::chrono::system_clock::to_time_t( - std::chrono::system_clock::time_point(*this)); - } - - local_date() = default; - ~local_date() = default; - local_date(local_date const&) = default; - local_date(local_date&&) = default; - local_date& operator=(local_date const&) = default; - local_date& operator=(local_date&&) = default; -}; - -inline bool operator==(const local_date& lhs, const local_date& rhs) -{ - return std::make_tuple(lhs.year, lhs.month, lhs.day) == - std::make_tuple(rhs.year, rhs.month, rhs.day); -} -inline bool operator!=(const local_date& lhs, const local_date& rhs) -{ - return !(lhs == rhs); -} -inline bool operator< (const local_date& lhs, const local_date& rhs) -{ - return std::make_tuple(lhs.year, lhs.month, lhs.day) < - std::make_tuple(rhs.year, rhs.month, rhs.day); -} -inline bool operator<=(const local_date& lhs, const local_date& rhs) -{ - return (lhs < rhs) || (lhs == rhs); -} -inline bool operator> (const local_date& lhs, const local_date& rhs) -{ - return !(lhs <= rhs); -} -inline bool operator>=(const local_date& lhs, const local_date& rhs) -{ - return !(lhs < rhs); -} - -template -std::basic_ostream& -operator<<(std::basic_ostream& os, const local_date& date) -{ - os << std::setfill('0') << std::setw(4) << static_cast(date.year ) << '-'; - os << std::setfill('0') << std::setw(2) << static_cast(date.month) + 1 << '-'; - os << std::setfill('0') << std::setw(2) << static_cast(date.day ) ; - return os; -} - -struct local_time -{ - std::uint8_t hour; // [0, 23] - std::uint8_t minute; // [0, 59] - std::uint8_t second; // [0, 60] - std::uint16_t millisecond; // [0, 999] - std::uint16_t microsecond; // [0, 999] - std::uint16_t nanosecond; // [0, 999] - - local_time(int h, int m, int s, - int ms = 0, int us = 0, int ns = 0) - : hour (static_cast(h)), - minute(static_cast(m)), - second(static_cast(s)), - millisecond(static_cast(ms)), - microsecond(static_cast(us)), - nanosecond (static_cast(ns)) - {} - - explicit local_time(const std::tm& t) - : hour (static_cast(t.tm_hour)), - minute(static_cast(t.tm_min)), - second(static_cast(t.tm_sec)), - millisecond(0), microsecond(0), nanosecond(0) - {} - - template - explicit local_time(const std::chrono::duration& t) - { - const auto h = std::chrono::duration_cast(t); - this->hour = static_cast(h.count()); - const auto t2 = t - h; - const auto m = std::chrono::duration_cast(t2); - this->minute = static_cast(m.count()); - const auto t3 = t2 - m; - const auto s = std::chrono::duration_cast(t3); - this->second = static_cast(s.count()); - const auto t4 = t3 - s; - const auto ms = std::chrono::duration_cast(t4); - this->millisecond = static_cast(ms.count()); - const auto t5 = t4 - ms; - const auto us = std::chrono::duration_cast(t5); - this->microsecond = static_cast(us.count()); - const auto t6 = t5 - us; - const auto ns = std::chrono::duration_cast(t6); - this->nanosecond = static_cast(ns.count()); - } - - operator std::chrono::nanoseconds() const - { - return std::chrono::nanoseconds (this->nanosecond) + - std::chrono::microseconds(this->microsecond) + - std::chrono::milliseconds(this->millisecond) + - std::chrono::seconds(this->second) + - std::chrono::minutes(this->minute) + - std::chrono::hours(this->hour); - } - - local_time() = default; - ~local_time() = default; - local_time(local_time const&) = default; - local_time(local_time&&) = default; - local_time& operator=(local_time const&) = default; - local_time& operator=(local_time&&) = default; -}; - -inline bool operator==(const local_time& lhs, const local_time& rhs) -{ - return std::make_tuple(lhs.hour, lhs.minute, lhs.second, lhs.millisecond, lhs.microsecond, lhs.nanosecond) == - std::make_tuple(rhs.hour, rhs.minute, rhs.second, rhs.millisecond, rhs.microsecond, rhs.nanosecond); -} -inline bool operator!=(const local_time& lhs, const local_time& rhs) -{ - return !(lhs == rhs); -} -inline bool operator< (const local_time& lhs, const local_time& rhs) -{ - return std::make_tuple(lhs.hour, lhs.minute, lhs.second, lhs.millisecond, lhs.microsecond, lhs.nanosecond) < - std::make_tuple(rhs.hour, rhs.minute, rhs.second, rhs.millisecond, rhs.microsecond, rhs.nanosecond); -} -inline bool operator<=(const local_time& lhs, const local_time& rhs) -{ - return (lhs < rhs) || (lhs == rhs); -} -inline bool operator> (const local_time& lhs, const local_time& rhs) -{ - return !(lhs <= rhs); -} -inline bool operator>=(const local_time& lhs, const local_time& rhs) -{ - return !(lhs < rhs); -} - -template -std::basic_ostream& -operator<<(std::basic_ostream& os, const local_time& time) -{ - os << std::setfill('0') << std::setw(2) << static_cast(time.hour ) << ':'; - os << std::setfill('0') << std::setw(2) << static_cast(time.minute) << ':'; - os << std::setfill('0') << std::setw(2) << static_cast(time.second); - if(time.millisecond != 0 || time.microsecond != 0 || time.nanosecond != 0) - { - os << '.'; - os << std::setfill('0') << std::setw(3) << static_cast(time.millisecond); - if(time.microsecond != 0 || time.nanosecond != 0) - { - os << std::setfill('0') << std::setw(3) << static_cast(time.microsecond); - if(time.nanosecond != 0) - { - os << std::setfill('0') << std::setw(3) << static_cast(time.nanosecond); - } - } - } - return os; -} - -struct time_offset -{ - std::int8_t hour; // [-12, 12] - std::int8_t minute; // [-59, 59] - - time_offset(int h, int m) - : hour (static_cast(h)), - minute(static_cast(m)) - {} - - operator std::chrono::minutes() const - { - return std::chrono::minutes(this->minute) + - std::chrono::hours(this->hour); - } - - time_offset() = default; - ~time_offset() = default; - time_offset(time_offset const&) = default; - time_offset(time_offset&&) = default; - time_offset& operator=(time_offset const&) = default; - time_offset& operator=(time_offset&&) = default; -}; - -inline bool operator==(const time_offset& lhs, const time_offset& rhs) -{ - return std::make_tuple(lhs.hour, lhs.minute) == - std::make_tuple(rhs.hour, rhs.minute); -} -inline bool operator!=(const time_offset& lhs, const time_offset& rhs) -{ - return !(lhs == rhs); -} -inline bool operator< (const time_offset& lhs, const time_offset& rhs) -{ - return std::make_tuple(lhs.hour, lhs.minute) < - std::make_tuple(rhs.hour, rhs.minute); -} -inline bool operator<=(const time_offset& lhs, const time_offset& rhs) -{ - return (lhs < rhs) || (lhs == rhs); -} -inline bool operator> (const time_offset& lhs, const time_offset& rhs) -{ - return !(lhs <= rhs); -} -inline bool operator>=(const time_offset& lhs, const time_offset& rhs) -{ - return !(lhs < rhs); -} - -template -std::basic_ostream& -operator<<(std::basic_ostream& os, const time_offset& offset) -{ - if(offset.hour == 0 && offset.minute == 0) - { - os << 'Z'; - return os; - } - int minute = static_cast(offset.hour) * 60 + offset.minute; - if(minute < 0){os << '-'; minute = std::abs(minute);} else {os << '+';} - os << std::setfill('0') << std::setw(2) << minute / 60 << ':'; - os << std::setfill('0') << std::setw(2) << minute % 60; - return os; -} - -struct local_datetime -{ - local_date date; - local_time time; - - local_datetime(local_date d, local_time t): date(d), time(t) {} - - explicit local_datetime(const std::tm& t): date(t), time(t){} - - explicit local_datetime(const std::chrono::system_clock::time_point& tp) - { - const auto t = std::chrono::system_clock::to_time_t(tp); - std::tm ltime = detail::localtime_s(&t); - - this->date = local_date(ltime); - this->time = local_time(ltime); - - // std::tm lacks subsecond information, so diff between tp and tm - // can be used to get millisecond & microsecond information. - const auto t_diff = tp - - std::chrono::system_clock::from_time_t(std::mktime(<ime)); - this->time.millisecond = static_cast( - std::chrono::duration_cast(t_diff).count()); - this->time.microsecond = static_cast( - std::chrono::duration_cast(t_diff).count()); - this->time.nanosecond = static_cast( - std::chrono::duration_cast(t_diff).count()); - } - - explicit local_datetime(const std::time_t t) - : local_datetime(std::chrono::system_clock::from_time_t(t)) - {} - - operator std::chrono::system_clock::time_point() const - { - using internal_duration = - typename std::chrono::system_clock::time_point::duration; - - // Normally DST begins at A.M. 3 or 4. If we re-use conversion operator - // of local_date and local_time independently, the conversion fails if - // it is the day when DST begins or ends. Since local_date considers the - // time is 00:00 A.M. and local_time does not consider DST because it - // does not have any date information. We need to consider both date and - // time information at the same time to convert it correctly. - - std::tm t; - t.tm_sec = static_cast(this->time.second); - t.tm_min = static_cast(this->time.minute); - t.tm_hour = static_cast(this->time.hour); - t.tm_mday = static_cast(this->date.day); - t.tm_mon = static_cast(this->date.month); - t.tm_year = static_cast(this->date.year) - 1900; - t.tm_wday = 0; // the value will be ignored - t.tm_yday = 0; // the value will be ignored - t.tm_isdst = -1; - - // std::mktime returns date as local time zone. no conversion needed - auto dt = std::chrono::system_clock::from_time_t(std::mktime(&t)); - dt += std::chrono::duration_cast( - std::chrono::milliseconds(this->time.millisecond) + - std::chrono::microseconds(this->time.microsecond) + - std::chrono::nanoseconds (this->time.nanosecond)); - return dt; - } - - operator std::time_t() const - { - return std::chrono::system_clock::to_time_t( - std::chrono::system_clock::time_point(*this)); - } - - local_datetime() = default; - ~local_datetime() = default; - local_datetime(local_datetime const&) = default; - local_datetime(local_datetime&&) = default; - local_datetime& operator=(local_datetime const&) = default; - local_datetime& operator=(local_datetime&&) = default; -}; - -inline bool operator==(const local_datetime& lhs, const local_datetime& rhs) -{ - return std::make_tuple(lhs.date, lhs.time) == - std::make_tuple(rhs.date, rhs.time); -} -inline bool operator!=(const local_datetime& lhs, const local_datetime& rhs) -{ - return !(lhs == rhs); -} -inline bool operator< (const local_datetime& lhs, const local_datetime& rhs) -{ - return std::make_tuple(lhs.date, lhs.time) < - std::make_tuple(rhs.date, rhs.time); -} -inline bool operator<=(const local_datetime& lhs, const local_datetime& rhs) -{ - return (lhs < rhs) || (lhs == rhs); -} -inline bool operator> (const local_datetime& lhs, const local_datetime& rhs) -{ - return !(lhs <= rhs); -} -inline bool operator>=(const local_datetime& lhs, const local_datetime& rhs) -{ - return !(lhs < rhs); -} - -template -std::basic_ostream& -operator<<(std::basic_ostream& os, const local_datetime& dt) -{ - os << dt.date << 'T' << dt.time; - return os; -} - -struct offset_datetime -{ - local_date date; - local_time time; - time_offset offset; - - offset_datetime(local_date d, local_time t, time_offset o) - : date(d), time(t), offset(o) - {} - offset_datetime(const local_datetime& dt, time_offset o) - : date(dt.date), time(dt.time), offset(o) - {} - explicit offset_datetime(const local_datetime& ld) - : date(ld.date), time(ld.time), offset(get_local_offset(nullptr)) - // use the current local timezone offset - {} - explicit offset_datetime(const std::chrono::system_clock::time_point& tp) - : offset(0, 0) // use gmtime - { - const auto timet = std::chrono::system_clock::to_time_t(tp); - const auto tm = detail::gmtime_s(&timet); - this->date = local_date(tm); - this->time = local_time(tm); - } - explicit offset_datetime(const std::time_t& t) - : offset(0, 0) // use gmtime - { - const auto tm = detail::gmtime_s(&t); - this->date = local_date(tm); - this->time = local_time(tm); - } - explicit offset_datetime(const std::tm& t) - : offset(0, 0) // assume gmtime - { - this->date = local_date(t); - this->time = local_time(t); - } - - operator std::chrono::system_clock::time_point() const - { - // get date-time - using internal_duration = - typename std::chrono::system_clock::time_point::duration; - - // first, convert it to local date-time information in the same way as - // local_datetime does. later we will use time_t to adjust time offset. - std::tm t; - t.tm_sec = static_cast(this->time.second); - t.tm_min = static_cast(this->time.minute); - t.tm_hour = static_cast(this->time.hour); - t.tm_mday = static_cast(this->date.day); - t.tm_mon = static_cast(this->date.month); - t.tm_year = static_cast(this->date.year) - 1900; - t.tm_wday = 0; // the value will be ignored - t.tm_yday = 0; // the value will be ignored - t.tm_isdst = -1; - const std::time_t tp_loc = std::mktime(std::addressof(t)); - - auto tp = std::chrono::system_clock::from_time_t(tp_loc); - tp += std::chrono::duration_cast( - std::chrono::milliseconds(this->time.millisecond) + - std::chrono::microseconds(this->time.microsecond) + - std::chrono::nanoseconds (this->time.nanosecond)); - - // Since mktime uses local time zone, it should be corrected. - // `12:00:00+09:00` means `03:00:00Z`. So mktime returns `03:00:00Z` if - // we are in `+09:00` timezone. To represent `12:00:00Z` there, we need - // to add `+09:00` to `03:00:00Z`. - // Here, it uses the time_t converted from date-time info to handle - // daylight saving time. - const auto ofs = get_local_offset(std::addressof(tp_loc)); - tp += std::chrono::hours (ofs.hour); - tp += std::chrono::minutes(ofs.minute); - - // We got `12:00:00Z` by correcting local timezone applied by mktime. - // Then we will apply the offset. Let's say `12:00:00-08:00` is given. - // And now, we have `12:00:00Z`. `12:00:00-08:00` means `20:00:00Z`. - // So we need to subtract the offset. - tp -= std::chrono::minutes(this->offset); - return tp; - } - - operator std::time_t() const - { - return std::chrono::system_clock::to_time_t( - std::chrono::system_clock::time_point(*this)); - } - - offset_datetime() = default; - ~offset_datetime() = default; - offset_datetime(offset_datetime const&) = default; - offset_datetime(offset_datetime&&) = default; - offset_datetime& operator=(offset_datetime const&) = default; - offset_datetime& operator=(offset_datetime&&) = default; - - private: - - static time_offset get_local_offset(const std::time_t* tp) - { - // get local timezone with the same date-time information as mktime - const auto t = detail::localtime_s(tp); - - std::array buf; - const auto result = std::strftime(buf.data(), 6, "%z", &t); // +hhmm\0 - if(result != 5) - { - throw std::runtime_error("toml::offset_datetime: cannot obtain " - "timezone information of current env"); - } - const int ofs = std::atoi(buf.data()); - const int ofs_h = ofs / 100; - const int ofs_m = ofs - (ofs_h * 100); - return time_offset(ofs_h, ofs_m); - } -}; - -inline bool operator==(const offset_datetime& lhs, const offset_datetime& rhs) -{ - return std::make_tuple(lhs.date, lhs.time, lhs.offset) == - std::make_tuple(rhs.date, rhs.time, rhs.offset); -} -inline bool operator!=(const offset_datetime& lhs, const offset_datetime& rhs) -{ - return !(lhs == rhs); -} -inline bool operator< (const offset_datetime& lhs, const offset_datetime& rhs) -{ - return std::make_tuple(lhs.date, lhs.time, lhs.offset) < - std::make_tuple(rhs.date, rhs.time, rhs.offset); -} -inline bool operator<=(const offset_datetime& lhs, const offset_datetime& rhs) -{ - return (lhs < rhs) || (lhs == rhs); -} -inline bool operator> (const offset_datetime& lhs, const offset_datetime& rhs) -{ - return !(lhs <= rhs); -} -inline bool operator>=(const offset_datetime& lhs, const offset_datetime& rhs) -{ - return !(lhs < rhs); -} - -template -std::basic_ostream& -operator<<(std::basic_ostream& os, const offset_datetime& dt) -{ - os << dt.date << 'T' << dt.time << dt.offset; - return os; -} - -}//toml -#endif// TOML11_DATETIME diff --git a/libraries/toml11/include/toml/exception.hpp b/libraries/toml11/include/toml/exception.hpp deleted file mode 100644 index c64651d0..00000000 --- a/libraries/toml11/include/toml/exception.hpp +++ /dev/null @@ -1,65 +0,0 @@ -// Copyright Toru Niina 2017. -// Distributed under the MIT License. -#ifndef TOML11_EXCEPTION_HPP -#define TOML11_EXCEPTION_HPP -#include -#include - -#include "source_location.hpp" - -namespace toml -{ - -struct exception : public std::exception -{ - public: - explicit exception(const source_location& loc): loc_(loc) {} - virtual ~exception() noexcept override = default; - virtual const char* what() const noexcept override {return "";} - virtual source_location const& location() const noexcept {return loc_;} - - protected: - source_location loc_; -}; - -struct syntax_error : public toml::exception -{ - public: - explicit syntax_error(const std::string& what_arg, const source_location& loc) - : exception(loc), what_(what_arg) - {} - virtual ~syntax_error() noexcept override = default; - virtual const char* what() const noexcept override {return what_.c_str();} - - protected: - std::string what_; -}; - -struct type_error : public toml::exception -{ - public: - explicit type_error(const std::string& what_arg, const source_location& loc) - : exception(loc), what_(what_arg) - {} - virtual ~type_error() noexcept override = default; - virtual const char* what() const noexcept override {return what_.c_str();} - - protected: - std::string what_; -}; - -struct internal_error : public toml::exception -{ - public: - explicit internal_error(const std::string& what_arg, const source_location& loc) - : exception(loc), what_(what_arg) - {} - virtual ~internal_error() noexcept override = default; - virtual const char* what() const noexcept override {return what_.c_str();} - - protected: - std::string what_; -}; - -} // toml -#endif // TOML_EXCEPTION diff --git a/libraries/toml11/include/toml/from.hpp b/libraries/toml11/include/toml/from.hpp deleted file mode 100644 index 8251973a..00000000 --- a/libraries/toml11/include/toml/from.hpp +++ /dev/null @@ -1,20 +0,0 @@ -// Copyright Toru Niina 2019. -// Distributed under the MIT License. -#ifndef TOML11_FROM_HPP -#define TOML11_FROM_HPP -#include "traits.hpp" - -namespace toml -{ - -template -struct from; -// { -// static T from_toml(const toml::value& v) -// { -// // User-defined conversions ... -// } -// }; - -} // toml -#endif // TOML11_FROM_HPP diff --git a/libraries/toml11/include/toml/get.hpp b/libraries/toml11/include/toml/get.hpp deleted file mode 100644 index 5095caf2..00000000 --- a/libraries/toml11/include/toml/get.hpp +++ /dev/null @@ -1,1068 +0,0 @@ -// Copyright Toru Niina 2017. -// Distributed under the MIT License. -#ifndef TOML11_GET_HPP -#define TOML11_GET_HPP -#include - -#include "from.hpp" -#include "result.hpp" -#include "value.hpp" - -namespace toml -{ - -// ============================================================================ -// exact toml::* type - -template class M, template class V> -detail::enable_if_t>::value, T> & -get(basic_value& v) -{ - return v.template cast>::value>(); -} - -template class M, template class V> -detail::enable_if_t>::value, T> const& -get(const basic_value& v) -{ - return v.template cast>::value>(); -} - -template class M, template class V> -detail::enable_if_t>::value, T> -get(basic_value&& v) -{ - return T(std::move(v).template cast>::value>()); -} - -// ============================================================================ -// T == toml::value; identity transformation. - -template class M, template class V> -inline detail::enable_if_t>::value, T>& -get(basic_value& v) -{ - return v; -} - -template class M, template class V> -inline detail::enable_if_t>::value, T> const& -get(const basic_value& v) -{ - return v; -} - -template class M, template class V> -inline detail::enable_if_t>::value, T> -get(basic_value&& v) -{ - return basic_value(std::move(v)); -} - -// ============================================================================ -// T == toml::basic_value; basic_value -> basic_value - -template class M, template class V> -inline detail::enable_if_t, - detail::negation>> - >::value, T> -get(const basic_value& v) -{ - return T(v); -} - -// ============================================================================ -// integer convertible from toml::Integer - -template class M, template class V> -inline detail::enable_if_t, // T is integral - detail::negation>, // but not bool - detail::negation< // but not toml::integer - detail::is_exact_toml_type>> - >::value, T> -get(const basic_value& v) -{ - return static_cast(v.as_integer()); -} - -// ============================================================================ -// floating point convertible from toml::Float - -template class M, template class V> -inline detail::enable_if_t, // T is floating_point - detail::negation< // but not toml::floating - detail::is_exact_toml_type>> - >::value, T> -get(const basic_value& v) -{ - return static_cast(v.as_floating()); -} - -// ============================================================================ -// std::string; toml uses its own toml::string, but it should be convertible to -// std::string seamlessly - -template class M, template class V> -inline detail::enable_if_t::value, std::string>& -get(basic_value& v) -{ - return v.as_string().str; -} - -template class M, template class V> -inline detail::enable_if_t::value, std::string> const& -get(const basic_value& v) -{ - return v.as_string().str; -} - -template class M, template class V> -inline detail::enable_if_t::value, std::string> -get(basic_value&& v) -{ - return std::string(std::move(v.as_string().str)); -} - -// ============================================================================ -// std::string_view - -#if __cplusplus >= 201703L -template class M, template class V> -inline detail::enable_if_t::value, std::string_view> -get(const basic_value& v) -{ - return std::string_view(v.as_string().str); -} -#endif - -// ============================================================================ -// std::chrono::duration from toml::local_time. - -template class M, template class V> -inline detail::enable_if_t::value, T> -get(const basic_value& v) -{ - return std::chrono::duration_cast( - std::chrono::nanoseconds(v.as_local_time())); -} - -// ============================================================================ -// std::chrono::system_clock::time_point from toml::datetime variants - -template class M, template class V> -inline detail::enable_if_t< - std::is_same::value, T> -get(const basic_value& v) -{ - switch(v.type()) - { - case value_t::local_date: - { - return std::chrono::system_clock::time_point(v.as_local_date()); - } - case value_t::local_datetime: - { - return std::chrono::system_clock::time_point(v.as_local_datetime()); - } - case value_t::offset_datetime: - { - return std::chrono::system_clock::time_point(v.as_offset_datetime()); - } - default: - { - throw type_error(detail::format_underline("toml::value: " - "bad_cast to std::chrono::system_clock::time_point", { - {v.location(), concat_to_string("the actual type is ", v.type())} - }), v.location()); - } - } -} - -// ============================================================================ -// forward declaration to use this recursively. ignore this and go ahead. - -// array-like type with push_back(value) method -template class M, template class V> -detail::enable_if_t, // T is a container - detail::has_push_back_method, // T::push_back(value) works - detail::negation< // but not toml::array - detail::is_exact_toml_type>> - >::value, T> -get(const basic_value&); - -// array-like type without push_back(value) method -template class M, template class V> -detail::enable_if_t, // T is a container - detail::negation>, // w/o push_back(...) - detail::negation< // not toml::array - detail::is_exact_toml_type>> - >::value, T> -get(const basic_value&); - -// std::pair -template class M, template class V> -detail::enable_if_t::value, T> -get(const basic_value&); - -// std::tuple -template class M, template class V> -detail::enable_if_t::value, T> -get(const basic_value&); - -// map-like classes -template class M, template class V> -detail::enable_if_t, // T is map - detail::negation< // but not toml::table - detail::is_exact_toml_type>> - >::value, T> -get(const basic_value&); - -// T.from_toml(v) -template class M, template class V> -detail::enable_if_t>>, - detail::has_from_toml_method, // but has from_toml(toml::value) - std::is_default_constructible // and default constructible - >::value, T> -get(const basic_value&); - -// toml::from::from_toml(v) -template class M, template class V, - std::size_t S = sizeof(::toml::from)> -T get(const basic_value&); - -// T(const toml::value&) and T is not toml::basic_value -template class M, template class V> -detail::enable_if_t>, - std::is_constructible&> - >::value, T> -get(const basic_value&); - -// ============================================================================ -// array-like types; most likely STL container, like std::vector, etc. - -template class M, template class V> -detail::enable_if_t, // T is a container - detail::has_push_back_method, // container.push_back(elem) works - detail::negation< // but not toml::array - detail::is_exact_toml_type>> - >::value, T> -get(const basic_value& v) -{ - using value_type = typename T::value_type; - const auto& ary = v.as_array(); - - T container; - try_reserve(container, ary.size()); - - for(const auto& elem : ary) - { - container.push_back(get(elem)); - } - return container; -} - -// ============================================================================ -// std::forward_list does not have push_back, insert, or emplace. -// It has insert_after, emplace_after, push_front. - -template class M, template class V> -detail::enable_if_t::value, T> -get(const basic_value& v) -{ - using value_type = typename T::value_type; - T container; - for(const auto& elem : v.as_array()) - { - container.push_front(get(elem)); - } - container.reverse(); - return container; -} - -// ============================================================================ -// array-like types, without push_back(). most likely [std|boost]::array. - -template class M, template class V> -detail::enable_if_t, // T is a container - detail::negation>, // w/o push_back - detail::negation< // T is not toml::array - detail::is_exact_toml_type>> - >::value, T> -get(const basic_value& v) -{ - using value_type = typename T::value_type; - const auto& ar = v.as_array(); - - T container; - if(ar.size() != container.size()) - { - throw std::out_of_range(detail::format_underline(concat_to_string( - "toml::get: specified container size is ", container.size(), - " but there are ", ar.size(), " elements in toml array."), { - {v.location(), "here"} - })); - } - for(std::size_t i=0; i(ar[i]); - } - return container; -} - -// ============================================================================ -// std::pair. - -template class M, template class V> -detail::enable_if_t::value, T> -get(const basic_value& v) -{ - using first_type = typename T::first_type; - using second_type = typename T::second_type; - - const auto& ar = v.as_array(); - if(ar.size() != 2) - { - throw std::out_of_range(detail::format_underline(concat_to_string( - "toml::get: specified std::pair but there are ", ar.size(), - " elements in toml array."), {{v.location(), "here"}})); - } - return std::make_pair(::toml::get(ar.at(0)), - ::toml::get(ar.at(1))); -} - -// ============================================================================ -// std::tuple. - -namespace detail -{ -template -T get_tuple_impl(const Array& a, index_sequence) -{ - return std::make_tuple( - ::toml::get::type>(a.at(I))...); -} -} // detail - -template class M, template class V> -detail::enable_if_t::value, T> -get(const basic_value& v) -{ - const auto& ar = v.as_array(); - if(ar.size() != std::tuple_size::value) - { - throw std::out_of_range(detail::format_underline(concat_to_string( - "toml::get: specified std::tuple with ", - std::tuple_size::value, " elements, but there are ", ar.size(), - " elements in toml array."), {{v.location(), "here"}})); - } - return detail::get_tuple_impl(ar, - detail::make_index_sequence::value>{}); -} - -// ============================================================================ -// map-like types; most likely STL map, like std::map or std::unordered_map. - -template class M, template class V> -detail::enable_if_t, // T is map - detail::negation< // but not toml::array - detail::is_exact_toml_type>> - >::value, T> -get(const basic_value& v) -{ - using key_type = typename T::key_type; - using mapped_type = typename T::mapped_type; - static_assert(std::is_convertible::value, - "toml::get only supports map type of which key_type is " - "convertible from std::string."); - T map; - for(const auto& kv : v.as_table()) - { - map.emplace(key_type(kv.first), get(kv.second)); - } - return map; -} - -// ============================================================================ -// user-defined, but compatible types. - -template class M, template class V> -detail::enable_if_t>>, - detail::has_from_toml_method, // but has from_toml(toml::value) memfn - std::is_default_constructible // and default constructible - >::value, T> -get(const basic_value& v) -{ - T ud; - ud.from_toml(v); - return ud; -} -template class M, template class V, - std::size_t> -T get(const basic_value& v) -{ - return ::toml::from::from_toml(v); -} - -template class M, template class V> -detail::enable_if_t>, - std::is_constructible&> - >::value, T> -get(const basic_value& v) -{ - return T(v); -} - -// ============================================================================ -// find - -// ---------------------------------------------------------------------------- -// these overloads do not require to set T. and returns value itself. -template class M, template class V> -basic_value const& find(const basic_value& v, const key& ky) -{ - const auto& tab = v.as_table(); - if(tab.count(ky) == 0) - { - detail::throw_key_not_found_error(v, ky); - } - return tab.at(ky); -} -template class M, template class V> -basic_value& find(basic_value& v, const key& ky) -{ - auto& tab = v.as_table(); - if(tab.count(ky) == 0) - { - detail::throw_key_not_found_error(v, ky); - } - return tab.at(ky); -} -template class M, template class V> -basic_value find(basic_value&& v, const key& ky) -{ - typename basic_value::table_type tab = std::move(v).as_table(); - if(tab.count(ky) == 0) - { - detail::throw_key_not_found_error(v, ky); - } - return basic_value(std::move(tab.at(ky))); -} - -// ---------------------------------------------------------------------------- -// find(value, idx) -template class M, template class V> -basic_value const& -find(const basic_value& v, const std::size_t idx) -{ - const auto& ary = v.as_array(); - if(ary.size() <= idx) - { - throw std::out_of_range(detail::format_underline(concat_to_string( - "index ", idx, " is out of range"), {{v.location(), "in this array"}})); - } - return ary.at(idx); -} -template class M, template class V> -basic_value& find(basic_value& v, const std::size_t idx) -{ - auto& ary = v.as_array(); - if(ary.size() <= idx) - { - throw std::out_of_range(detail::format_underline(concat_to_string( - "index ", idx, " is out of range"), {{v.location(), "in this array"}})); - } - return ary.at(idx); -} -template class M, template class V> -basic_value find(basic_value&& v, const std::size_t idx) -{ - auto& ary = v.as_array(); - if(ary.size() <= idx) - { - throw std::out_of_range(detail::format_underline(concat_to_string( - "index ", idx, " is out of range"), {{v.location(), "in this array"}})); - } - return basic_value(std::move(ary.at(idx))); -} - -// ---------------------------------------------------------------------------- -// find(value, key); - -template class M, template class V> -decltype(::toml::get(std::declval const&>())) -find(const basic_value& v, const key& ky) -{ - const auto& tab = v.as_table(); - if(tab.count(ky) == 0) - { - detail::throw_key_not_found_error(v, ky); - } - return ::toml::get(tab.at(ky)); -} - -template class M, template class V> -decltype(::toml::get(std::declval&>())) -find(basic_value& v, const key& ky) -{ - auto& tab = v.as_table(); - if(tab.count(ky) == 0) - { - detail::throw_key_not_found_error(v, ky); - } - return ::toml::get(tab.at(ky)); -} - -template class M, template class V> -decltype(::toml::get(std::declval&&>())) -find(basic_value&& v, const key& ky) -{ - typename basic_value::table_type tab = std::move(v).as_table(); - if(tab.count(ky) == 0) - { - detail::throw_key_not_found_error(v, ky); - } - return ::toml::get(std::move(tab.at(ky))); -} - -// ---------------------------------------------------------------------------- -// find(value, idx) -template class M, template class V> -decltype(::toml::get(std::declval const&>())) -find(const basic_value& v, const std::size_t idx) -{ - const auto& ary = v.as_array(); - if(ary.size() <= idx) - { - throw std::out_of_range(detail::format_underline(concat_to_string( - "index ", idx, " is out of range"), {{v.location(), "in this array"}})); - } - return ::toml::get(ary.at(idx)); -} -template class M, template class V> -decltype(::toml::get(std::declval&>())) -find(basic_value& v, const std::size_t idx) -{ - auto& ary = v.as_array(); - if(ary.size() <= idx) - { - throw std::out_of_range(detail::format_underline(concat_to_string( - "index ", idx, " is out of range"), {{v.location(), "in this array"}})); - } - return ::toml::get(ary.at(idx)); -} -template class M, template class V> -decltype(::toml::get(std::declval&&>())) -find(basic_value&& v, const std::size_t idx) -{ - typename basic_value::array_type ary = std::move(v).as_array(); - if(ary.size() <= idx) - { - throw std::out_of_range(detail::format_underline(concat_to_string( - "index ", idx, " is out of range"), {{v.location(), "in this array"}})); - } - return ::toml::get(std::move(ary.at(idx))); -} - -// -------------------------------------------------------------------------- -// toml::find(toml::value, toml::key, Ts&& ... keys) - -namespace detail -{ -// It suppresses warnings by -Wsign-conversion. Let's say we have the following -// code. -// ```cpp -// const auto x = toml::find(data, "array", 0); -// ``` -// Here, the type of literal number `0` is `int`. `int` is a signed integer. -// `toml::find` takes `std::size_t` as an index. So it causes implicit sign -// conversion and `-Wsign-conversion` warns about it. Using `0u` instead of `0` -// suppresses the warning, but it makes user code messy. -// To suppress this warning, we need to be aware of type conversion caused -// by `toml::find(v, key1, key2, ... keys)`. But the thing is that the types of -// keys can be any combination of {string-like, size_t-like}. Of course we can't -// write down all the combinations. Thus we need to use some function that -// recognize the type of argument and cast it into `std::string` or -// `std::size_t` depending on the context. -// `key_cast` does the job. It has 2 overloads. One is invoked when the -// argument type is an integer and cast the argument into `std::size_t`. The -// other is invoked when the argument type is not an integer, possibly one of -// std::string, const char[N] or const char*, and construct std::string from -// the argument. -// `toml::find(v, k1, k2, ... ks)` uses `key_cast` before passing `ks` to -// `toml::find(v, k)` to suppress -Wsign-conversion. - -template -enable_if_t>, - negation, bool>>>::value, std::size_t> -key_cast(T&& v) noexcept -{ - return std::size_t(v); -} -template -enable_if_t>, - negation, bool>>>>::value, std::string> -key_cast(T&& v) noexcept -{ - return std::string(std::forward(v)); -} -} // detail - -template class M, template class V, - typename Key1, typename Key2, typename ... Keys> -const basic_value& -find(const basic_value& v, Key1&& k1, Key2&& k2, Keys&& ... keys) -{ - return ::toml::find(::toml::find(v, detail::key_cast(k1)), - detail::key_cast(k2), std::forward(keys)...); -} -template class M, template class V, - typename Key1, typename Key2, typename ... Keys> -basic_value& -find(basic_value& v, Key1&& k1, Key2&& k2, Keys&& ... keys) -{ - return ::toml::find(::toml::find(v, detail::key_cast(k1)), - detail::key_cast(k2), std::forward(keys)...); -} -template class M, template class V, - typename Key1, typename Key2, typename ... Keys> -basic_value -find(basic_value&& v, Key1&& k1, Key2&& k2, Keys&& ... keys) -{ - return ::toml::find(::toml::find(std::move(v), std::forward(k1)), - detail::key_cast(k2), std::forward(keys)...); -} - -template class M, template class V, - typename Key1, typename Key2, typename ... Keys> -decltype(::toml::get(std::declval&>())) -find(const basic_value& v, Key1&& k1, Key2&& k2, Keys&& ... keys) -{ - return ::toml::find(::toml::find(v, detail::key_cast(k1)), - detail::key_cast(k2), std::forward(keys)...); -} -template class M, template class V, - typename Key1, typename Key2, typename ... Keys> -decltype(::toml::get(std::declval&>())) -find(basic_value& v, Key1&& k1, Key2&& k2, Keys&& ... keys) -{ - return ::toml::find(::toml::find(v, detail::key_cast(k1)), - detail::key_cast(k2), std::forward(keys)...); -} -template class M, template class V, - typename Key1, typename Key2, typename ... Keys> -decltype(::toml::get(std::declval&&>())) -find(basic_value&& v, Key1&& k1, Key2&& k2, Keys&& ... keys) -{ - return ::toml::find(::toml::find(std::move(v), detail::key_cast(k1)), - detail::key_cast(k2), std::forward(keys)...); -} - -// ============================================================================ -// get_or(value, fallback) - -template class M, template class V> -basic_value const& -get_or(const basic_value& v, const basic_value&) -{ - return v; -} -template class M, template class V> -basic_value& -get_or(basic_value& v, basic_value&) -{ - return v; -} -template class M, template class V> -basic_value -get_or(basic_value&& v, basic_value&&) -{ - return v; -} - -// ---------------------------------------------------------------------------- -// specialization for the exact toml types (return type becomes lvalue ref) - -template class M, template class V> -detail::enable_if_t< - detail::is_exact_toml_type>::value, T> const& -get_or(const basic_value& v, const T& opt) -{ - try - { - return get>(v); - } - catch(...) - { - return opt; - } -} -template class M, template class V> -detail::enable_if_t< - detail::is_exact_toml_type>::value, T>& -get_or(basic_value& v, T& opt) -{ - try - { - return get>(v); - } - catch(...) - { - return opt; - } -} -template class M, template class V> -detail::enable_if_t, - basic_value>::value, detail::remove_cvref_t> -get_or(basic_value&& v, T&& opt) -{ - try - { - return get>(std::move(v)); - } - catch(...) - { - return detail::remove_cvref_t(std::forward(opt)); - } -} - -// ---------------------------------------------------------------------------- -// specialization for std::string (return type becomes lvalue ref) - -template class M, template class V> -detail::enable_if_t, std::string>::value, - std::string> const& -get_or(const basic_value& v, const T& opt) -{ - try - { - return v.as_string().str; - } - catch(...) - { - return opt; - } -} -template class M, template class V> -detail::enable_if_t::value, std::string>& -get_or(basic_value& v, T& opt) -{ - try - { - return v.as_string().str; - } - catch(...) - { - return opt; - } -} -template class M, template class V> -detail::enable_if_t< - std::is_same, std::string>::value, std::string> -get_or(basic_value&& v, T&& opt) -{ - try - { - return std::move(v.as_string().str); - } - catch(...) - { - return std::string(std::forward(opt)); - } -} - -// ---------------------------------------------------------------------------- -// specialization for string literal - -template class M, template class V> -detail::enable_if_t::type>::value, std::string> -get_or(const basic_value& v, T&& opt) -{ - try - { - return std::move(v.as_string().str); - } - catch(...) - { - return std::string(std::forward(opt)); - } -} - -// ---------------------------------------------------------------------------- -// others (require type conversion and return type cannot be lvalue reference) - -template class M, template class V> -detail::enable_if_t, - basic_value>>, - detail::negation>>, - detail::negation::type>> - >::value, detail::remove_cvref_t> -get_or(const basic_value& v, T&& opt) -{ - try - { - return get>(v); - } - catch(...) - { - return detail::remove_cvref_t(std::forward(opt)); - } -} - -// =========================================================================== -// find_or(value, key, fallback) - -template class M, template class V> -basic_value const& -find_or(const basic_value& v, const key& ky, - const basic_value& opt) -{ - if(!v.is_table()) {return opt;} - const auto& tab = v.as_table(); - if(tab.count(ky) == 0) {return opt;} - return tab.at(ky); -} - -template class M, template class V> -basic_value& -find_or(basic_value& v, const toml::key& ky, basic_value& opt) -{ - if(!v.is_table()) {return opt;} - auto& tab = v.as_table(); - if(tab.count(ky) == 0) {return opt;} - return tab.at(ky); -} - -template class M, template class V> -basic_value -find_or(basic_value&& v, const toml::key& ky, basic_value&& opt) -{ - if(!v.is_table()) {return opt;} - auto tab = std::move(v).as_table(); - if(tab.count(ky) == 0) {return opt;} - return basic_value(std::move(tab.at(ky))); -} - -// --------------------------------------------------------------------------- -// exact types (return type can be a reference) -template class M, template class V> -detail::enable_if_t< - detail::is_exact_toml_type>::value, T> const& -find_or(const basic_value& v, const key& ky, const T& opt) -{ - if(!v.is_table()) {return opt;} - const auto& tab = v.as_table(); - if(tab.count(ky) == 0) {return opt;} - return get_or(tab.at(ky), opt); -} - -template class M, template class V> -detail::enable_if_t< - detail::is_exact_toml_type>::value, T>& -find_or(basic_value& v, const toml::key& ky, T& opt) -{ - if(!v.is_table()) {return opt;} - auto& tab = v.as_table(); - if(tab.count(ky) == 0) {return opt;} - return get_or(tab.at(ky), opt); -} - -template class M, template class V> -detail::enable_if_t< - detail::is_exact_toml_type>::value, - detail::remove_cvref_t> -find_or(basic_value&& v, const toml::key& ky, T&& opt) -{ - if(!v.is_table()) {return std::forward(opt);} - auto tab = std::move(v).as_table(); - if(tab.count(ky) == 0) {return std::forward(opt);} - return get_or(std::move(tab.at(ky)), std::forward(opt)); -} - -// --------------------------------------------------------------------------- -// std::string (return type can be a reference) - -template class M, template class V> -detail::enable_if_t::value, std::string> const& -find_or(const basic_value& v, const key& ky, const T& opt) -{ - if(!v.is_table()) {return opt;} - const auto& tab = v.as_table(); - if(tab.count(ky) == 0) {return opt;} - return get_or(tab.at(ky), opt); -} -template class M, template class V> -detail::enable_if_t::value, std::string>& -find_or(basic_value& v, const toml::key& ky, T& opt) -{ - if(!v.is_table()) {return opt;} - auto& tab = v.as_table(); - if(tab.count(ky) == 0) {return opt;} - return get_or(tab.at(ky), opt); -} -template class M, template class V> -detail::enable_if_t::value, std::string> -find_or(basic_value&& v, const toml::key& ky, T&& opt) -{ - if(!v.is_table()) {return std::forward(opt);} - auto tab = std::move(v).as_table(); - if(tab.count(ky) == 0) {return std::forward(opt);} - return get_or(std::move(tab.at(ky)), std::forward(opt)); -} - -// --------------------------------------------------------------------------- -// string literal (deduced as std::string) -template class M, template class V> -detail::enable_if_t< - detail::is_string_literal::type>::value, - std::string> -find_or(const basic_value& v, const toml::key& ky, T&& opt) -{ - if(!v.is_table()) {return std::string(opt);} - const auto& tab = v.as_table(); - if(tab.count(ky) == 0) {return std::string(opt);} - return get_or(tab.at(ky), std::forward(opt)); -} - -// --------------------------------------------------------------------------- -// others (require type conversion and return type cannot be lvalue reference) -template class M, template class V> -detail::enable_if_t, basic_value>>, - // T is not std::string - detail::negation>>, - // T is not a string literal - detail::negation::type>> - >::value, detail::remove_cvref_t> -find_or(const basic_value& v, const toml::key& ky, T&& opt) -{ - if(!v.is_table()) {return std::forward(opt);} - const auto& tab = v.as_table(); - if(tab.count(ky) == 0) {return std::forward(opt);} - return get_or(tab.at(ky), std::forward(opt)); -} - -// ============================================================================ -// expect - -template class M, template class V> -result expect(const basic_value& v) noexcept -{ - try - { - return ok(get(v)); - } - catch(const std::exception& e) - { - return err(e.what()); - } -} -template class M, template class V> -result -expect(const basic_value& v, const toml::key& k) noexcept -{ - try - { - return ok(find(v, k)); - } - catch(const std::exception& e) - { - return err(e.what()); - } -} - -} // toml -#endif// TOML11_GET diff --git a/libraries/toml11/include/toml/into.hpp b/libraries/toml11/include/toml/into.hpp deleted file mode 100644 index 17f22488..00000000 --- a/libraries/toml11/include/toml/into.hpp +++ /dev/null @@ -1,20 +0,0 @@ -// Copyright Toru Niina 2019. -// Distributed under the MIT License. -#ifndef TOML11_INTO_HPP -#define TOML11_INTO_HPP -#include "traits.hpp" - -namespace toml -{ - -template -struct into; -// { -// static toml::value into_toml(const T& user_defined_type) -// { -// // User-defined conversions ... -// } -// }; - -} // toml -#endif // TOML11_INTO_HPP diff --git a/libraries/toml11/include/toml/lexer.hpp b/libraries/toml11/include/toml/lexer.hpp deleted file mode 100644 index 2eea996e..00000000 --- a/libraries/toml11/include/toml/lexer.hpp +++ /dev/null @@ -1,270 +0,0 @@ -// Copyright Toru Niina 2017. -// Distributed under the MIT License. -#ifndef TOML11_LEXER_HPP -#define TOML11_LEXER_HPP -#include -#include -#include -#include - -#include "combinator.hpp" - -namespace toml -{ -namespace detail -{ - -// these scans contents from current location in a container of char -// and extract a region that matches their own pattern. -// to see the implementation of each component, see combinator.hpp. - -using lex_wschar = either, character<'\t'>>; -using lex_ws = repeat>; -using lex_newline = either, - sequence, character<'\n'>>>; -using lex_lower = in_range<'a', 'z'>; -using lex_upper = in_range<'A', 'Z'>; -using lex_alpha = either; -using lex_digit = in_range<'0', '9'>; -using lex_nonzero = in_range<'1', '9'>; -using lex_oct_dig = in_range<'0', '7'>; -using lex_bin_dig = in_range<'0', '1'>; -using lex_hex_dig = either, in_range<'a', 'f'>>; - -using lex_hex_prefix = sequence, character<'x'>>; -using lex_oct_prefix = sequence, character<'o'>>; -using lex_bin_prefix = sequence, character<'b'>>; -using lex_underscore = character<'_'>; -using lex_plus = character<'+'>; -using lex_minus = character<'-'>; -using lex_sign = either; - -// digit | nonzero 1*(digit | _ digit) -using lex_unsigned_dec_int = either>, at_least<1>>>, - lex_digit>; -// (+|-)? unsigned_dec_int -using lex_dec_int = sequence, lex_unsigned_dec_int>; - -// hex_prefix hex_dig *(hex_dig | _ hex_dig) -using lex_hex_int = sequence>, unlimited>>>; -// oct_prefix oct_dig *(oct_dig | _ oct_dig) -using lex_oct_int = sequence>, unlimited>>>; -// bin_prefix bin_dig *(bin_dig | _ bin_dig) -using lex_bin_int = sequence>, unlimited>>>; - -// (dec_int | hex_int | oct_int | bin_int) -using lex_integer = either; - -// =========================================================================== - -using lex_inf = sequence, character<'n'>, character<'f'>>; -using lex_nan = sequence, character<'a'>, character<'n'>>; -using lex_special_float = sequence, either>; - -using lex_zero_prefixable_int = sequence>, unlimited>>; - -using lex_fractional_part = sequence, lex_zero_prefixable_int>; - -using lex_exponent_part = sequence, character<'E'>>, - maybe, lex_zero_prefixable_int>; - -using lex_float = either>>>>; - -// =========================================================================== - -using lex_true = sequence, character<'r'>, - character<'u'>, character<'e'>>; -using lex_false = sequence, character<'a'>, character<'l'>, - character<'s'>, character<'e'>>; -using lex_boolean = either; - -// =========================================================================== - -using lex_date_fullyear = repeat>; -using lex_date_month = repeat>; -using lex_date_mday = repeat>; -using lex_time_delim = either, character<'t'>, character<' '>>; -using lex_time_hour = repeat>; -using lex_time_minute = repeat>; -using lex_time_second = repeat>; -using lex_time_secfrac = sequence, - repeat>>; - -using lex_time_numoffset = sequence, character<'-'>>, - sequence, - lex_time_minute>>; -using lex_time_offset = either, character<'z'>, - lex_time_numoffset>; - -using lex_partial_time = sequence, - lex_time_minute, character<':'>, - lex_time_second, maybe>; -using lex_full_date = sequence, - lex_date_month, character<'-'>, - lex_date_mday>; -using lex_full_time = sequence; - -using lex_offset_date_time = sequence; -using lex_local_date_time = sequence; -using lex_local_date = lex_full_date; -using lex_local_time = lex_partial_time; - -// =========================================================================== - -using lex_quotation_mark = character<'"'>; -using lex_basic_unescaped = exclude, // 0x09 (tab) - in_range<0x0a, 0x1F>, // is allowed - character<0x22>, character<0x5C>, - character<0x7F>>>; - -using lex_escape = character<'\\'>; -using lex_escape_unicode_short = sequence, - repeat>>; -using lex_escape_unicode_long = sequence, - repeat>>; -using lex_escape_seq_char = either, character<'\\'>, - character<'b'>, character<'f'>, - character<'n'>, character<'r'>, - character<'t'>, - lex_escape_unicode_short, - lex_escape_unicode_long - >; -using lex_escaped = sequence; -using lex_basic_char = either; -using lex_basic_string = sequence, - lex_quotation_mark>; - -// After toml post-v0.5.0, it is explicitly clarified how quotes in ml-strings -// are allowed to be used. -// After this, the following strings are *explicitly* allowed. -// - One or two `"`s in a multi-line basic string is allowed wherever it is. -// - Three consecutive `"`s in a multi-line basic string is considered as a delimiter. -// - One or two `"`s can appear just before or after the delimiter. -// ```toml -// str4 = """Here are two quotation marks: "". Simple enough.""" -// str5 = """Here are three quotation marks: ""\".""" -// str6 = """Here are fifteen quotation marks: ""\"""\"""\"""\"""\".""" -// str7 = """"This," she said, "is just a pointless statement."""" -// ``` -// In the current implementation (v3.3.0), it is difficult to parse `str7` in -// the above example. It is difficult to recognize `"` at the end of string body -// collectly. It will be misunderstood as a `"""` delimiter and an additional, -// invalid `"`. Like this: -// ```console -// what(): [error] toml::parse_table: invalid line format -// --> hoge.toml -// | -// 13 | str7 = """"This," she said, "is just a pointless statement."""" -// | ^- expected newline, but got '"'. -// ``` -// As a quick workaround for this problem, `lex_ml_basic_string_delim` was -// splitted into two, `lex_ml_basic_string_open` and `lex_ml_basic_string_close`. -// `lex_ml_basic_string_open` allows only `"""`. `_close` allows 3-5 `"`s. -// In parse_ml_basic_string() function, the trailing `"`s will be attached to -// the string body. -// -using lex_ml_basic_string_delim = repeat>; -using lex_ml_basic_string_open = lex_ml_basic_string_delim; -using lex_ml_basic_string_close = sequence< - repeat>, - maybe, maybe - >; - -using lex_ml_basic_unescaped = exclude, // 0x09 - in_range<0x0a, 0x1F>, // is tab - character<0x5C>, // backslash - character<0x7F>, // DEL - lex_ml_basic_string_delim>>; - -using lex_ml_basic_escaped_newline = sequence< - lex_escape, maybe, lex_newline, - repeat, unlimited>>; - -using lex_ml_basic_char = either; -using lex_ml_basic_body = repeat, - unlimited>; -using lex_ml_basic_string = sequence; - -using lex_literal_char = exclude, - in_range<0x10, 0x19>, character<0x27>>>; -using lex_apostrophe = character<'\''>; -using lex_literal_string = sequence, - lex_apostrophe>; - -// the same reason as above. -using lex_ml_literal_string_delim = repeat>; -using lex_ml_literal_string_open = lex_ml_literal_string_delim; -using lex_ml_literal_string_close = sequence< - repeat>, - maybe, maybe - >; - -using lex_ml_literal_char = exclude, - in_range<0x10, 0x1F>, - character<0x7F>, - lex_ml_literal_string_delim>>; -using lex_ml_literal_body = repeat, - unlimited>; -using lex_ml_literal_string = sequence; - -using lex_string = either; - -// =========================================================================== - -using lex_comment_start_symbol = character<'#'>; -using lex_non_eol = either, exclude>>; -using lex_comment = sequence>; - -using lex_dot_sep = sequence, character<'.'>, maybe>; - -using lex_unquoted_key = repeat, character<'_'>>, - at_least<1>>; -using lex_quoted_key = either; -using lex_simple_key = either; -using lex_dotted_key = sequence, - at_least<1> - > - >; -using lex_key = either; - -using lex_keyval_sep = sequence, - character<'='>, - maybe>; - -using lex_std_table_open = character<'['>; -using lex_std_table_close = character<']'>; -using lex_std_table = sequence, - lex_key, - maybe, - lex_std_table_close>; - -using lex_array_table_open = sequence; -using lex_array_table_close = sequence; -using lex_array_table = sequence, - lex_key, - maybe, - lex_array_table_close>; - -} // detail -} // toml -#endif // TOML_LEXER_HPP diff --git a/libraries/toml11/include/toml/literal.hpp b/libraries/toml11/include/toml/literal.hpp deleted file mode 100644 index 0824f838..00000000 --- a/libraries/toml11/include/toml/literal.hpp +++ /dev/null @@ -1,112 +0,0 @@ -// Copyright Toru Niina 2019. -// Distributed under the MIT License. -#ifndef TOML11_LITERAL_HPP -#define TOML11_LITERAL_HPP -#include "parser.hpp" - -namespace toml -{ -inline namespace literals -{ -inline namespace toml_literals -{ - -// implementation -inline ::toml::basic_value<::toml::discard_comments, std::unordered_map, std::vector> -literal_internal_impl(::toml::detail::location loc) -{ - using value_type = ::toml::basic_value< - ::toml::discard_comments, std::unordered_map, std::vector>; - // if there are some comments or empty lines, skip them. - using skip_line = ::toml::detail::repeat, - ::toml::detail::maybe<::toml::detail::lex_comment>, - ::toml::detail::lex_newline - >, ::toml::detail::at_least<1>>; - skip_line::invoke(loc); - - // if there are some whitespaces before a value, skip them. - using skip_ws = ::toml::detail::repeat< - ::toml::detail::lex_ws, ::toml::detail::at_least<1>>; - skip_ws::invoke(loc); - - // to distinguish arrays and tables, first check it is a table or not. - // - // "[1,2,3]"_toml; // this is an array - // "[table]"_toml; // a table that has an empty table named "table" inside. - // "[[1,2,3]]"_toml; // this is an array of arrays - // "[[table]]"_toml; // this is a table that has an array of tables inside. - // - // "[[1]]"_toml; // this can be both... (currently it becomes a table) - // "1 = [{}]"_toml; // this is a table that has an array of table named 1. - // "[[1,]]"_toml; // this is an array of arrays. - // "[[1],]"_toml; // this also. - - const auto the_front = loc.iter(); - - const bool is_table_key = ::toml::detail::lex_std_table::invoke(loc); - loc.reset(the_front); - - const bool is_aots_key = ::toml::detail::lex_array_table::invoke(loc); - loc.reset(the_front); - - // If it is neither a table-key or a array-of-table-key, it may be a value. - if(!is_table_key && !is_aots_key) - { - if(auto data = ::toml::detail::parse_value(loc)) - { - return data.unwrap(); - } - } - - // Note that still it can be a table, because the literal might be something - // like the following. - // ```cpp - // R"( // c++11 raw string literals - // key = "value" - // int = 42 - // )"_toml; - // ``` - // It is a valid toml file. - // It should be parsed as if we parse a file with this content. - - if(auto data = ::toml::detail::parse_toml_file(loc)) - { - return data.unwrap(); - } - else // none of them. - { - throw ::toml::syntax_error(data.unwrap_err(), source_location(loc)); - } - -} - -inline ::toml::basic_value<::toml::discard_comments, std::unordered_map, std::vector> -operator"" _toml(const char* str, std::size_t len) -{ - ::toml::detail::location loc( - std::string("TOML literal encoded in a C++ code"), - std::vector(str, str + len)); - return literal_internal_impl(std::move(loc)); -} - -// value of __cplusplus in C++2a/20 mode is not fixed yet along compilers. -// So here we use the feature test macro for `char8_t` itself. -#if defined(__cpp_char8_t) && __cpp_char8_t >= 201811L -// value of u8"" literal has been changed from char to char8_t and char8_t is -// NOT compatible to char -inline ::toml::basic_value<::toml::discard_comments, std::unordered_map, std::vector> -operator"" _toml(const char8_t* str, std::size_t len) -{ - ::toml::detail::location loc( - std::string("TOML literal encoded in a C++ code"), - std::vector(reinterpret_cast(str), - reinterpret_cast(str) + len)); - return literal_internal_impl(std::move(loc)); -} -#endif - -} // toml_literals -} // literals -} // toml -#endif//TOML11_LITERAL_HPP diff --git a/libraries/toml11/include/toml/macros.hpp b/libraries/toml11/include/toml/macros.hpp deleted file mode 100644 index e8f91aec..00000000 --- a/libraries/toml11/include/toml/macros.hpp +++ /dev/null @@ -1,121 +0,0 @@ -#ifndef TOML11_MACROS_HPP -#define TOML11_MACROS_HPP - -#define TOML11_STRINGIZE_AUX(x) #x -#define TOML11_STRINGIZE(x) TOML11_STRINGIZE_AUX(x) - -#define TOML11_CONCATENATE_AUX(x, y) x##y -#define TOML11_CONCATENATE(x, y) TOML11_CONCATENATE_AUX(x, y) - -// ============================================================================ -// TOML11_DEFINE_CONVERSION_NON_INTRUSIVE - -#ifndef TOML11_WITHOUT_DEFINE_NON_INTRUSIVE - -// ---------------------------------------------------------------------------- -// TOML11_ARGS_SIZE - -#define TOML11_INDEX_RSEQ() \ - 32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, \ - 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 -#define TOML11_ARGS_SIZE_IMPL(\ - ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7, ARG8, ARG9, ARG10, \ - ARG11, ARG12, ARG13, ARG14, ARG15, ARG16, ARG17, ARG18, ARG19, ARG20, \ - ARG21, ARG22, ARG23, ARG24, ARG25, ARG26, ARG27, ARG28, ARG29, ARG30, \ - ARG31, ARG32, N, ...) N -#define TOML11_ARGS_SIZE_AUX(...) TOML11_ARGS_SIZE_IMPL(__VA_ARGS__) -#define TOML11_ARGS_SIZE(...) TOML11_ARGS_SIZE_AUX(__VA_ARGS__, TOML11_INDEX_RSEQ()) - -// ---------------------------------------------------------------------------- -// TOML11_FOR_EACH_VA_ARGS - -#define TOML11_FOR_EACH_VA_ARGS_AUX_1( FUNCTOR, ARG1 ) FUNCTOR(ARG1) -#define TOML11_FOR_EACH_VA_ARGS_AUX_2( FUNCTOR, ARG1, ...) FUNCTOR(ARG1) TOML11_FOR_EACH_VA_ARGS_AUX_1( FUNCTOR, __VA_ARGS__) -#define TOML11_FOR_EACH_VA_ARGS_AUX_3( FUNCTOR, ARG1, ...) FUNCTOR(ARG1) TOML11_FOR_EACH_VA_ARGS_AUX_2( FUNCTOR, __VA_ARGS__) -#define TOML11_FOR_EACH_VA_ARGS_AUX_4( FUNCTOR, ARG1, ...) FUNCTOR(ARG1) TOML11_FOR_EACH_VA_ARGS_AUX_3( FUNCTOR, __VA_ARGS__) -#define TOML11_FOR_EACH_VA_ARGS_AUX_5( FUNCTOR, ARG1, ...) FUNCTOR(ARG1) TOML11_FOR_EACH_VA_ARGS_AUX_4( FUNCTOR, __VA_ARGS__) -#define TOML11_FOR_EACH_VA_ARGS_AUX_6( FUNCTOR, ARG1, ...) FUNCTOR(ARG1) TOML11_FOR_EACH_VA_ARGS_AUX_5( FUNCTOR, __VA_ARGS__) -#define TOML11_FOR_EACH_VA_ARGS_AUX_7( FUNCTOR, ARG1, ...) FUNCTOR(ARG1) TOML11_FOR_EACH_VA_ARGS_AUX_6( FUNCTOR, __VA_ARGS__) -#define TOML11_FOR_EACH_VA_ARGS_AUX_8( FUNCTOR, ARG1, ...) FUNCTOR(ARG1) TOML11_FOR_EACH_VA_ARGS_AUX_7( FUNCTOR, __VA_ARGS__) -#define TOML11_FOR_EACH_VA_ARGS_AUX_9( FUNCTOR, ARG1, ...) FUNCTOR(ARG1) TOML11_FOR_EACH_VA_ARGS_AUX_8( FUNCTOR, __VA_ARGS__) -#define TOML11_FOR_EACH_VA_ARGS_AUX_10(FUNCTOR, ARG1, ...) FUNCTOR(ARG1) TOML11_FOR_EACH_VA_ARGS_AUX_9( FUNCTOR, __VA_ARGS__) -#define TOML11_FOR_EACH_VA_ARGS_AUX_11(FUNCTOR, ARG1, ...) FUNCTOR(ARG1) TOML11_FOR_EACH_VA_ARGS_AUX_10(FUNCTOR, __VA_ARGS__) -#define TOML11_FOR_EACH_VA_ARGS_AUX_12(FUNCTOR, ARG1, ...) FUNCTOR(ARG1) TOML11_FOR_EACH_VA_ARGS_AUX_11(FUNCTOR, __VA_ARGS__) -#define TOML11_FOR_EACH_VA_ARGS_AUX_13(FUNCTOR, ARG1, ...) FUNCTOR(ARG1) TOML11_FOR_EACH_VA_ARGS_AUX_12(FUNCTOR, __VA_ARGS__) -#define TOML11_FOR_EACH_VA_ARGS_AUX_14(FUNCTOR, ARG1, ...) FUNCTOR(ARG1) TOML11_FOR_EACH_VA_ARGS_AUX_13(FUNCTOR, __VA_ARGS__) -#define TOML11_FOR_EACH_VA_ARGS_AUX_15(FUNCTOR, ARG1, ...) FUNCTOR(ARG1) TOML11_FOR_EACH_VA_ARGS_AUX_14(FUNCTOR, __VA_ARGS__) -#define TOML11_FOR_EACH_VA_ARGS_AUX_16(FUNCTOR, ARG1, ...) FUNCTOR(ARG1) TOML11_FOR_EACH_VA_ARGS_AUX_15(FUNCTOR, __VA_ARGS__) -#define TOML11_FOR_EACH_VA_ARGS_AUX_17(FUNCTOR, ARG1, ...) FUNCTOR(ARG1) TOML11_FOR_EACH_VA_ARGS_AUX_16(FUNCTOR, __VA_ARGS__) -#define TOML11_FOR_EACH_VA_ARGS_AUX_18(FUNCTOR, ARG1, ...) FUNCTOR(ARG1) TOML11_FOR_EACH_VA_ARGS_AUX_17(FUNCTOR, __VA_ARGS__) -#define TOML11_FOR_EACH_VA_ARGS_AUX_19(FUNCTOR, ARG1, ...) FUNCTOR(ARG1) TOML11_FOR_EACH_VA_ARGS_AUX_18(FUNCTOR, __VA_ARGS__) -#define TOML11_FOR_EACH_VA_ARGS_AUX_20(FUNCTOR, ARG1, ...) FUNCTOR(ARG1) TOML11_FOR_EACH_VA_ARGS_AUX_19(FUNCTOR, __VA_ARGS__) -#define TOML11_FOR_EACH_VA_ARGS_AUX_21(FUNCTOR, ARG1, ...) FUNCTOR(ARG1) TOML11_FOR_EACH_VA_ARGS_AUX_20(FUNCTOR, __VA_ARGS__) -#define TOML11_FOR_EACH_VA_ARGS_AUX_22(FUNCTOR, ARG1, ...) FUNCTOR(ARG1) TOML11_FOR_EACH_VA_ARGS_AUX_21(FUNCTOR, __VA_ARGS__) -#define TOML11_FOR_EACH_VA_ARGS_AUX_23(FUNCTOR, ARG1, ...) FUNCTOR(ARG1) TOML11_FOR_EACH_VA_ARGS_AUX_22(FUNCTOR, __VA_ARGS__) -#define TOML11_FOR_EACH_VA_ARGS_AUX_24(FUNCTOR, ARG1, ...) FUNCTOR(ARG1) TOML11_FOR_EACH_VA_ARGS_AUX_23(FUNCTOR, __VA_ARGS__) -#define TOML11_FOR_EACH_VA_ARGS_AUX_25(FUNCTOR, ARG1, ...) FUNCTOR(ARG1) TOML11_FOR_EACH_VA_ARGS_AUX_24(FUNCTOR, __VA_ARGS__) -#define TOML11_FOR_EACH_VA_ARGS_AUX_26(FUNCTOR, ARG1, ...) FUNCTOR(ARG1) TOML11_FOR_EACH_VA_ARGS_AUX_25(FUNCTOR, __VA_ARGS__) -#define TOML11_FOR_EACH_VA_ARGS_AUX_27(FUNCTOR, ARG1, ...) FUNCTOR(ARG1) TOML11_FOR_EACH_VA_ARGS_AUX_26(FUNCTOR, __VA_ARGS__) -#define TOML11_FOR_EACH_VA_ARGS_AUX_28(FUNCTOR, ARG1, ...) FUNCTOR(ARG1) TOML11_FOR_EACH_VA_ARGS_AUX_27(FUNCTOR, __VA_ARGS__) -#define TOML11_FOR_EACH_VA_ARGS_AUX_29(FUNCTOR, ARG1, ...) FUNCTOR(ARG1) TOML11_FOR_EACH_VA_ARGS_AUX_28(FUNCTOR, __VA_ARGS__) -#define TOML11_FOR_EACH_VA_ARGS_AUX_30(FUNCTOR, ARG1, ...) FUNCTOR(ARG1) TOML11_FOR_EACH_VA_ARGS_AUX_29(FUNCTOR, __VA_ARGS__) -#define TOML11_FOR_EACH_VA_ARGS_AUX_31(FUNCTOR, ARG1, ...) FUNCTOR(ARG1) TOML11_FOR_EACH_VA_ARGS_AUX_30(FUNCTOR, __VA_ARGS__) -#define TOML11_FOR_EACH_VA_ARGS_AUX_32(FUNCTOR, ARG1, ...) FUNCTOR(ARG1) TOML11_FOR_EACH_VA_ARGS_AUX_31(FUNCTOR, __VA_ARGS__) - -#define TOML11_FOR_EACH_VA_ARGS(FUNCTOR, ...)\ - TOML11_CONCATENATE(TOML11_FOR_EACH_VA_ARGS_AUX_, TOML11_ARGS_SIZE(__VA_ARGS__))(FUNCTOR, __VA_ARGS__) - -// ---------------------------------------------------------------------------- -// TOML11_DEFINE_CONVERSION_NON_INTRUSIVE - -// use it in the following way. -// ```cpp -// namespace foo -// { -// struct Foo -// { -// std::string s; -// double d; -// int i; -// }; -// } // foo -// -// TOML11_DEFINE_CONVERSION_NON_INTRUSIVE(foo::Foo, s, d, i) -// ``` -// And then you can use `toml::find(file, "foo");` -// -#define TOML11_FIND_MEMBER_VARIABLE_FROM_VALUE(VAR_NAME)\ - obj.VAR_NAME = toml::find(v, TOML11_STRINGIZE(VAR_NAME)); - -#define TOML11_ASSIGN_MEMBER_VARIABLE_TO_VALUE(VAR_NAME)\ - v[TOML11_STRINGIZE(VAR_NAME)] = obj.VAR_NAME; - -#define TOML11_DEFINE_CONVERSION_NON_INTRUSIVE(NAME, ...)\ - namespace toml { \ - template<> \ - struct from \ - { \ - template class T, \ - template class A> \ - static NAME from_toml(const basic_value& v) \ - { \ - NAME obj; \ - TOML11_FOR_EACH_VA_ARGS(TOML11_FIND_MEMBER_VARIABLE_FROM_VALUE, __VA_ARGS__) \ - return obj; \ - } \ - }; \ - template<> \ - struct into \ - { \ - static value into_toml(const NAME& obj) \ - { \ - ::toml::value v = ::toml::table{}; \ - TOML11_FOR_EACH_VA_ARGS(TOML11_ASSIGN_MEMBER_VARIABLE_TO_VALUE, __VA_ARGS__) \ - return v; \ - } \ - }; \ - } /* toml */ - -#endif// TOML11_WITHOUT_DEFINE_NON_INTRUSIVE - -#endif// TOML11_MACROS_HPP diff --git a/libraries/toml11/include/toml/parser.hpp b/libraries/toml11/include/toml/parser.hpp deleted file mode 100644 index 3ab74209..00000000 --- a/libraries/toml11/include/toml/parser.hpp +++ /dev/null @@ -1,2221 +0,0 @@ -// Copyright Toru Niina 2017. -// Distributed under the MIT License. -#ifndef TOML11_PARSER_HPP -#define TOML11_PARSER_HPP -#include -#include -#include -#include - -#include "combinator.hpp" -#include "lexer.hpp" -#include "region.hpp" -#include "result.hpp" -#include "types.hpp" -#include "value.hpp" - -#ifndef TOML11_DISABLE_STD_FILESYSTEM -#ifdef __cpp_lib_filesystem -#if __has_include() -#define TOML11_HAS_STD_FILESYSTEM -#include -#endif // has_include() -#endif // __cpp_lib_filesystem -#endif // TOML11_DISABLE_STD_FILESYSTEM - -namespace toml -{ -namespace detail -{ - -inline result, std::string> -parse_boolean(location& loc) -{ - const auto first = loc.iter(); - if(const auto token = lex_boolean::invoke(loc)) - { - const auto reg = token.unwrap(); - if (reg.str() == "true") {return ok(std::make_pair(true, reg));} - else if(reg.str() == "false") {return ok(std::make_pair(false, reg));} - else // internal error. - { - throw internal_error(format_underline( - "toml::parse_boolean: internal error", - {{source_location(reg), "invalid token"}}), - source_location(reg)); - } - } - loc.reset(first); //rollback - return err(format_underline("toml::parse_boolean: ", - {{source_location(loc), "the next token is not a boolean"}})); -} - -inline result, std::string> -parse_binary_integer(location& loc) -{ - const auto first = loc.iter(); - if(const auto token = lex_bin_int::invoke(loc)) - { - auto str = token.unwrap().str(); - assert(str.size() > 2); // minimum -> 0b1 - integer retval(0), base(1); - for(auto i(str.rbegin()), e(str.rend() - 2); i!=e; ++i) - { - if (*i == '1'){retval += base; base *= 2;} - else if(*i == '0'){base *= 2;} - else if(*i == '_'){/* do nothing. */} - else // internal error. - { - throw internal_error(format_underline( - "toml::parse_integer: internal error", - {{source_location(token.unwrap()), "invalid token"}}), - source_location(loc)); - } - } - return ok(std::make_pair(retval, token.unwrap())); - } - loc.reset(first); - return err(format_underline("toml::parse_binary_integer:", - {{source_location(loc), "the next token is not an integer"}})); -} - -inline result, std::string> -parse_octal_integer(location& loc) -{ - const auto first = loc.iter(); - if(const auto token = lex_oct_int::invoke(loc)) - { - auto str = token.unwrap().str(); - str.erase(std::remove(str.begin(), str.end(), '_'), str.end()); - str.erase(str.begin()); str.erase(str.begin()); // remove `0o` prefix - - std::istringstream iss(str); - integer retval(0); - iss >> std::oct >> retval; - return ok(std::make_pair(retval, token.unwrap())); - } - loc.reset(first); - return err(format_underline("toml::parse_octal_integer:", - {{source_location(loc), "the next token is not an integer"}})); -} - -inline result, std::string> -parse_hexadecimal_integer(location& loc) -{ - const auto first = loc.iter(); - if(const auto token = lex_hex_int::invoke(loc)) - { - auto str = token.unwrap().str(); - str.erase(std::remove(str.begin(), str.end(), '_'), str.end()); - str.erase(str.begin()); str.erase(str.begin()); // remove `0x` prefix - - std::istringstream iss(str); - integer retval(0); - iss >> std::hex >> retval; - return ok(std::make_pair(retval, token.unwrap())); - } - loc.reset(first); - return err(format_underline("toml::parse_hexadecimal_integer", - {{source_location(loc), "the next token is not an integer"}})); -} - -inline result, std::string> -parse_integer(location& loc) -{ - const auto first = loc.iter(); - if(first != loc.end() && *first == '0') - { - const auto second = std::next(first); - if(second == loc.end()) // the token is just zero. - { - loc.advance(); - return ok(std::make_pair(0, region(loc, first, second))); - } - - if(*second == 'b') {return parse_binary_integer (loc);} // 0b1100 - if(*second == 'o') {return parse_octal_integer (loc);} // 0o775 - if(*second == 'x') {return parse_hexadecimal_integer(loc);} // 0xC0FFEE - - if(std::isdigit(*second)) - { - return err(format_underline("toml::parse_integer: " - "leading zero in an Integer is not allowed.", - {{source_location(loc), "leading zero"}})); - } - else if(std::isalpha(*second)) - { - return err(format_underline("toml::parse_integer: " - "unknown integer prefix appeared.", - {{source_location(loc), "none of 0x, 0o, 0b"}})); - } - } - - if(const auto token = lex_dec_int::invoke(loc)) - { - auto str = token.unwrap().str(); - str.erase(std::remove(str.begin(), str.end(), '_'), str.end()); - - std::istringstream iss(str); - integer retval(0); - iss >> retval; - return ok(std::make_pair(retval, token.unwrap())); - } - loc.reset(first); - return err(format_underline("toml::parse_integer: ", - {{source_location(loc), "the next token is not an integer"}})); -} - -inline result, std::string> -parse_floating(location& loc) -{ - const auto first = loc.iter(); - if(const auto token = lex_float::invoke(loc)) - { - auto str = token.unwrap().str(); - if(str == "inf" || str == "+inf") - { - if(std::numeric_limits::has_infinity) - { - return ok(std::make_pair( - std::numeric_limits::infinity(), token.unwrap())); - } - else - { - throw std::domain_error("toml::parse_floating: inf value found" - " but the current environment does not support inf. Please" - " make sure that the floating-point implementation conforms" - " IEEE 754/ISO 60559 international standard."); - } - } - else if(str == "-inf") - { - if(std::numeric_limits::has_infinity) - { - return ok(std::make_pair( - -std::numeric_limits::infinity(), token.unwrap())); - } - else - { - throw std::domain_error("toml::parse_floating: inf value found" - " but the current environment does not support inf. Please" - " make sure that the floating-point implementation conforms" - " IEEE 754/ISO 60559 international standard."); - } - } - else if(str == "nan" || str == "+nan") - { - if(std::numeric_limits::has_quiet_NaN) - { - return ok(std::make_pair( - std::numeric_limits::quiet_NaN(), token.unwrap())); - } - else if(std::numeric_limits::has_signaling_NaN) - { - return ok(std::make_pair( - std::numeric_limits::signaling_NaN(), token.unwrap())); - } - else - { - throw std::domain_error("toml::parse_floating: NaN value found" - " but the current environment does not support NaN. Please" - " make sure that the floating-point implementation conforms" - " IEEE 754/ISO 60559 international standard."); - } - } - else if(str == "-nan") - { - if(std::numeric_limits::has_quiet_NaN) - { - return ok(std::make_pair( - -std::numeric_limits::quiet_NaN(), token.unwrap())); - } - else if(std::numeric_limits::has_signaling_NaN) - { - return ok(std::make_pair( - -std::numeric_limits::signaling_NaN(), token.unwrap())); - } - else - { - throw std::domain_error("toml::parse_floating: NaN value found" - " but the current environment does not support NaN. Please" - " make sure that the floating-point implementation conforms" - " IEEE 754/ISO 60559 international standard."); - } - } - str.erase(std::remove(str.begin(), str.end(), '_'), str.end()); - std::istringstream iss(str); - floating v(0.0); - iss >> v; - return ok(std::make_pair(v, token.unwrap())); - } - loc.reset(first); - return err(format_underline("toml::parse_floating: ", - {{source_location(loc), "the next token is not a float"}})); -} - -inline std::string read_utf8_codepoint(const region& reg, const location& loc) -{ - const auto str = reg.str().substr(1); - std::uint_least32_t codepoint; - std::istringstream iss(str); - iss >> std::hex >> codepoint; - - const auto to_char = [](const std::uint_least32_t i) noexcept -> char { - const auto uc = static_cast(i); - return *reinterpret_cast(std::addressof(uc)); - }; - - std::string character; - if(codepoint < 0x80) // U+0000 ... U+0079 ; just an ASCII. - { - character += static_cast(codepoint); - } - else if(codepoint < 0x800) //U+0080 ... U+07FF - { - // 110yyyyx 10xxxxxx; 0x3f == 0b0011'1111 - character += to_char(0xC0| codepoint >> 6); - character += to_char(0x80|(codepoint & 0x3F)); - } - else if(codepoint < 0x10000) // U+0800...U+FFFF - { - if(0xD800 <= codepoint && codepoint <= 0xDFFF) - { - throw syntax_error(format_underline( - "toml::read_utf8_codepoint: codepoints in the range " - "[0xD800, 0xDFFF] are not valid UTF-8.", {{ - source_location(loc), "not a valid UTF-8 codepoint" - }}), source_location(loc)); - } - assert(codepoint < 0xD800 || 0xDFFF < codepoint); - // 1110yyyy 10yxxxxx 10xxxxxx - character += to_char(0xE0| codepoint >> 12); - character += to_char(0x80|(codepoint >> 6 & 0x3F)); - character += to_char(0x80|(codepoint & 0x3F)); - } - else if(codepoint < 0x110000) // U+010000 ... U+10FFFF - { - // 11110yyy 10yyxxxx 10xxxxxx 10xxxxxx - character += to_char(0xF0| codepoint >> 18); - character += to_char(0x80|(codepoint >> 12 & 0x3F)); - character += to_char(0x80|(codepoint >> 6 & 0x3F)); - character += to_char(0x80|(codepoint & 0x3F)); - } - else // out of UTF-8 region - { - throw syntax_error(format_underline("toml::read_utf8_codepoint:" - " input codepoint is too large.", - {{source_location(loc), "should be in [0x00..0x10FFFF]"}}), - source_location(loc)); - } - return character; -} - -inline result parse_escape_sequence(location& loc) -{ - const auto first = loc.iter(); - if(first == loc.end() || *first != '\\') - { - return err(format_underline("toml::parse_escape_sequence: ", {{ - source_location(loc), "the next token is not a backslash \"\\\""}})); - } - loc.advance(); - switch(*loc.iter()) - { - case '\\':{loc.advance(); return ok(std::string("\\"));} - case '"' :{loc.advance(); return ok(std::string("\""));} - case 'b' :{loc.advance(); return ok(std::string("\b"));} - case 't' :{loc.advance(); return ok(std::string("\t"));} - case 'n' :{loc.advance(); return ok(std::string("\n"));} - case 'f' :{loc.advance(); return ok(std::string("\f"));} - case 'r' :{loc.advance(); return ok(std::string("\r"));} - case 'u' : - { - if(const auto token = lex_escape_unicode_short::invoke(loc)) - { - return ok(read_utf8_codepoint(token.unwrap(), loc)); - } - else - { - return err(format_underline("parse_escape_sequence: " - "invalid token found in UTF-8 codepoint uXXXX.", - {{source_location(loc), "here"}})); - } - } - case 'U': - { - if(const auto token = lex_escape_unicode_long::invoke(loc)) - { - return ok(read_utf8_codepoint(token.unwrap(), loc)); - } - else - { - return err(format_underline("parse_escape_sequence: " - "invalid token found in UTF-8 codepoint Uxxxxxxxx", - {{source_location(loc), "here"}})); - } - } - } - - const auto msg = format_underline("parse_escape_sequence: " - "unknown escape sequence appeared.", {{source_location(loc), - "escape sequence is one of \\, \", b, t, n, f, r, uxxxx, Uxxxxxxxx"}}, - /* Hints = */{"if you want to write backslash as just one backslash, " - "use literal string like: regex = '<\\i\\c*\\s*>'"}); - loc.reset(first); - return err(msg); -} - -inline result, std::string> -parse_ml_basic_string(location& loc) -{ - const auto first = loc.iter(); - if(const auto token = lex_ml_basic_string::invoke(loc)) - { - auto inner_loc = loc; - inner_loc.reset(first); - - std::string retval; - retval.reserve(token.unwrap().size()); - - auto delim = lex_ml_basic_string_open::invoke(inner_loc); - if(!delim) - { - throw internal_error(format_underline( - "parse_ml_basic_string: invalid token", - {{source_location(inner_loc), "should be \"\"\""}}), - source_location(inner_loc)); - } - // immediate newline is ignored (if exists) - /* discard return value */ lex_newline::invoke(inner_loc); - - delim = none(); - while(!delim) - { - using lex_unescaped_seq = repeat< - either, unlimited>; - if(auto unescaped = lex_unescaped_seq::invoke(inner_loc)) - { - retval += unescaped.unwrap().str(); - } - if(auto escaped = parse_escape_sequence(inner_loc)) - { - retval += escaped.unwrap(); - } - if(auto esc_nl = lex_ml_basic_escaped_newline::invoke(inner_loc)) - { - // ignore newline after escape until next non-ws char - } - if(inner_loc.iter() == inner_loc.end()) - { - throw internal_error(format_underline( - "parse_ml_basic_string: unexpected end of region", - {{source_location(inner_loc), "not sufficient token"}}), - source_location(inner_loc)); - } - delim = lex_ml_basic_string_close::invoke(inner_loc); - } - // `lex_ml_basic_string_close` allows 3 to 5 `"`s to allow 1 or 2 `"`s - // at just before the delimiter. Here, we need to attach `"`s at the - // end of the string body, if it exists. - // For detail, see the definition of `lex_ml_basic_string_close`. - assert(std::all_of(delim.unwrap().first(), delim.unwrap().last(), - [](const char c) noexcept {return c == '\"';})); - switch(delim.unwrap().size()) - { - case 3: {break;} - case 4: {retval += "\""; break;} - case 5: {retval += "\"\""; break;} - default: - { - throw internal_error(format_underline( - "parse_ml_basic_string: closing delimiter has invalid length", - {{source_location(inner_loc), "end of this"}}), - source_location(inner_loc)); - } - } - return ok(std::make_pair(toml::string(retval), token.unwrap())); - } - else - { - loc.reset(first); - return err(format_underline("toml::parse_ml_basic_string: " - "the next token is not a valid multiline string", - {{source_location(loc), "here"}})); - } -} - -inline result, std::string> -parse_basic_string(location& loc) -{ - const auto first = loc.iter(); - if(const auto token = lex_basic_string::invoke(loc)) - { - auto inner_loc = loc; - inner_loc.reset(first); - - auto quot = lex_quotation_mark::invoke(inner_loc); - if(!quot) - { - throw internal_error(format_underline("parse_basic_string: " - "invalid token", {{source_location(inner_loc), "should be \""}}), - source_location(inner_loc)); - } - - std::string retval; - retval.reserve(token.unwrap().size()); - - quot = none(); - while(!quot) - { - using lex_unescaped_seq = repeat; - if(auto unescaped = lex_unescaped_seq::invoke(inner_loc)) - { - retval += unescaped.unwrap().str(); - } - if(auto escaped = parse_escape_sequence(inner_loc)) - { - retval += escaped.unwrap(); - } - if(inner_loc.iter() == inner_loc.end()) - { - throw internal_error(format_underline( - "parse_basic_string: unexpected end of region", - {{source_location(inner_loc), "not sufficient token"}}), - source_location(inner_loc)); - } - quot = lex_quotation_mark::invoke(inner_loc); - } - return ok(std::make_pair(toml::string(retval), token.unwrap())); - } - else - { - loc.reset(first); // rollback - return err(format_underline("toml::parse_basic_string: " - "the next token is not a valid string", - {{source_location(loc), "here"}})); - } -} - -inline result, std::string> -parse_ml_literal_string(location& loc) -{ - const auto first = loc.iter(); - if(const auto token = lex_ml_literal_string::invoke(loc)) - { - location inner_loc(loc.name(), token.unwrap().str()); - - const auto open = lex_ml_literal_string_open::invoke(inner_loc); - if(!open) - { - throw internal_error(format_underline( - "parse_ml_literal_string: invalid token", - {{source_location(inner_loc), "should be '''"}}), - source_location(inner_loc)); - } - // immediate newline is ignored (if exists) - /* discard return value */ lex_newline::invoke(inner_loc); - - const auto body = lex_ml_literal_body::invoke(inner_loc); - - const auto close = lex_ml_literal_string_close::invoke(inner_loc); - if(!close) - { - throw internal_error(format_underline( - "parse_ml_literal_string: invalid token", - {{source_location(inner_loc), "should be '''"}}), - source_location(inner_loc)); - } - // `lex_ml_literal_string_close` allows 3 to 5 `'`s to allow 1 or 2 `'`s - // at just before the delimiter. Here, we need to attach `'`s at the - // end of the string body, if it exists. - // For detail, see the definition of `lex_ml_basic_string_close`. - - std::string retval = body.unwrap().str(); - assert(std::all_of(close.unwrap().first(), close.unwrap().last(), - [](const char c) noexcept {return c == '\'';})); - switch(close.unwrap().size()) - { - case 3: {break;} - case 4: {retval += "'"; break;} - case 5: {retval += "''"; break;} - default: - { - throw internal_error(format_underline( - "parse_ml_literal_string: closing delimiter has invalid length", - {{source_location(inner_loc), "end of this"}}), - source_location(inner_loc)); - } - } - return ok(std::make_pair(toml::string(retval, toml::string_t::literal), - token.unwrap())); - } - else - { - loc.reset(first); // rollback - return err(format_underline("toml::parse_ml_literal_string: " - "the next token is not a valid multiline literal string", - {{source_location(loc), "here"}})); - } -} - -inline result, std::string> -parse_literal_string(location& loc) -{ - const auto first = loc.iter(); - if(const auto token = lex_literal_string::invoke(loc)) - { - location inner_loc(loc.name(), token.unwrap().str()); - - const auto open = lex_apostrophe::invoke(inner_loc); - if(!open) - { - throw internal_error(format_underline( - "parse_literal_string: invalid token", - {{source_location(inner_loc), "should be '"}}), - source_location(inner_loc)); - } - - const auto body = repeat::invoke(inner_loc); - - const auto close = lex_apostrophe::invoke(inner_loc); - if(!close) - { - throw internal_error(format_underline( - "parse_literal_string: invalid token", - {{source_location(inner_loc), "should be '"}}), - source_location(inner_loc)); - } - return ok(std::make_pair( - toml::string(body.unwrap().str(), toml::string_t::literal), - token.unwrap())); - } - else - { - loc.reset(first); // rollback - return err(format_underline("toml::parse_literal_string: " - "the next token is not a valid literal string", - {{source_location(loc), "here"}})); - } -} - -inline result, std::string> -parse_string(location& loc) -{ - if(loc.iter() != loc.end() && *(loc.iter()) == '"') - { - if(loc.iter() + 1 != loc.end() && *(loc.iter() + 1) == '"' && - loc.iter() + 2 != loc.end() && *(loc.iter() + 2) == '"') - { - return parse_ml_basic_string(loc); - } - else - { - return parse_basic_string(loc); - } - } - else if(loc.iter() != loc.end() && *(loc.iter()) == '\'') - { - if(loc.iter() + 1 != loc.end() && *(loc.iter() + 1) == '\'' && - loc.iter() + 2 != loc.end() && *(loc.iter() + 2) == '\'') - { - return parse_ml_literal_string(loc); - } - else - { - return parse_literal_string(loc); - } - } - return err(format_underline("toml::parse_string: ", - {{source_location(loc), "the next token is not a string"}})); -} - -inline result, std::string> -parse_local_date(location& loc) -{ - const auto first = loc.iter(); - if(const auto token = lex_local_date::invoke(loc)) - { - location inner_loc(loc.name(), token.unwrap().str()); - - const auto y = lex_date_fullyear::invoke(inner_loc); - if(!y || inner_loc.iter() == inner_loc.end() || *inner_loc.iter() != '-') - { - throw internal_error(format_underline( - "toml::parse_inner_local_date: invalid year format", - {{source_location(inner_loc), "should be `-`"}}), - source_location(inner_loc)); - } - inner_loc.advance(); - const auto m = lex_date_month::invoke(inner_loc); - if(!m || inner_loc.iter() == inner_loc.end() || *inner_loc.iter() != '-') - { - throw internal_error(format_underline( - "toml::parse_local_date: invalid month format", - {{source_location(inner_loc), "should be `-`"}}), - source_location(inner_loc)); - } - inner_loc.advance(); - const auto d = lex_date_mday::invoke(inner_loc); - if(!d) - { - throw internal_error(format_underline( - "toml::parse_local_date: invalid day format", - {{source_location(inner_loc), "here"}}), - source_location(inner_loc)); - } - return ok(std::make_pair(local_date( - static_cast(from_string(y.unwrap().str(), 0)), - static_cast( - static_cast(from_string(m.unwrap().str(), 0)-1)), - static_cast(from_string(d.unwrap().str(), 0))), - token.unwrap())); - } - else - { - loc.reset(first); - return err(format_underline("toml::parse_local_date: ", - {{source_location(loc), "the next token is not a local_date"}})); - } -} - -inline result, std::string> -parse_local_time(location& loc) -{ - const auto first = loc.iter(); - if(const auto token = lex_local_time::invoke(loc)) - { - location inner_loc(loc.name(), token.unwrap().str()); - - const auto h = lex_time_hour::invoke(inner_loc); - if(!h || inner_loc.iter() == inner_loc.end() || *inner_loc.iter() != ':') - { - throw internal_error(format_underline( - "toml::parse_local_time: invalid year format", - {{source_location(inner_loc), "should be `:`"}}), - source_location(inner_loc)); - } - inner_loc.advance(); - const auto m = lex_time_minute::invoke(inner_loc); - if(!m || inner_loc.iter() == inner_loc.end() || *inner_loc.iter() != ':') - { - throw internal_error(format_underline( - "toml::parse_local_time: invalid month format", - {{source_location(inner_loc), "should be `:`"}}), - source_location(inner_loc)); - } - inner_loc.advance(); - const auto s = lex_time_second::invoke(inner_loc); - if(!s) - { - throw internal_error(format_underline( - "toml::parse_local_time: invalid second format", - {{source_location(inner_loc), "here"}}), - source_location(inner_loc)); - } - local_time time( - from_string(h.unwrap().str(), 0), - from_string(m.unwrap().str(), 0), - from_string(s.unwrap().str(), 0), 0, 0); - - const auto before_secfrac = inner_loc.iter(); - if(const auto secfrac = lex_time_secfrac::invoke(inner_loc)) - { - auto sf = secfrac.unwrap().str(); - sf.erase(sf.begin()); // sf.front() == '.' - switch(sf.size() % 3) - { - case 2: sf += '0'; break; - case 1: sf += "00"; break; - case 0: break; - default: break; - } - if(sf.size() >= 9) - { - time.millisecond = from_string(sf.substr(0, 3), 0u); - time.microsecond = from_string(sf.substr(3, 3), 0u); - time.nanosecond = from_string(sf.substr(6, 3), 0u); - } - else if(sf.size() >= 6) - { - time.millisecond = from_string(sf.substr(0, 3), 0u); - time.microsecond = from_string(sf.substr(3, 3), 0u); - } - else if(sf.size() >= 3) - { - time.millisecond = from_string(sf, 0u); - time.microsecond = 0u; - } - } - else - { - if(before_secfrac != inner_loc.iter()) - { - throw internal_error(format_underline( - "toml::parse_local_time: invalid subsecond format", - {{source_location(inner_loc), "here"}}), - source_location(inner_loc)); - } - } - return ok(std::make_pair(time, token.unwrap())); - } - else - { - loc.reset(first); - return err(format_underline("toml::parse_local_time: ", - {{source_location(loc), "the next token is not a local_time"}})); - } -} - -inline result, std::string> -parse_local_datetime(location& loc) -{ - const auto first = loc.iter(); - if(const auto token = lex_local_date_time::invoke(loc)) - { - location inner_loc(loc.name(), token.unwrap().str()); - const auto date = parse_local_date(inner_loc); - if(!date || inner_loc.iter() == inner_loc.end()) - { - throw internal_error(format_underline( - "toml::parse_local_datetime: invalid datetime format", - {{source_location(inner_loc), "date, not datetime"}}), - source_location(inner_loc)); - } - const char delim = *(inner_loc.iter()); - if(delim != 'T' && delim != 't' && delim != ' ') - { - throw internal_error(format_underline( - "toml::parse_local_datetime: invalid datetime format", - {{source_location(inner_loc), "should be `T` or ` ` (space)"}}), - source_location(inner_loc)); - } - inner_loc.advance(); - const auto time = parse_local_time(inner_loc); - if(!time) - { - throw internal_error(format_underline( - "toml::parse_local_datetime: invalid datetime format", - {{source_location(inner_loc), "invalid time fomrat"}}), - source_location(inner_loc)); - } - return ok(std::make_pair( - local_datetime(date.unwrap().first, time.unwrap().first), - token.unwrap())); - } - else - { - loc.reset(first); - return err(format_underline("toml::parse_local_datetime: ", - {{source_location(loc), "the next token is not a local_datetime"}})); - } -} - -inline result, std::string> -parse_offset_datetime(location& loc) -{ - const auto first = loc.iter(); - if(const auto token = lex_offset_date_time::invoke(loc)) - { - location inner_loc(loc.name(), token.unwrap().str()); - const auto datetime = parse_local_datetime(inner_loc); - if(!datetime || inner_loc.iter() == inner_loc.end()) - { - throw internal_error(format_underline( - "toml::parse_offset_datetime: invalid datetime format", - {{source_location(inner_loc), "date, not datetime"}}), - source_location(inner_loc)); - } - time_offset offset(0, 0); - if(const auto ofs = lex_time_numoffset::invoke(inner_loc)) - { - const auto str = ofs.unwrap().str(); - if(str.front() == '+') - { - offset = time_offset(from_string(str.substr(1,2), 0), - from_string(str.substr(4,2), 0)); - } - else - { - offset = time_offset(-from_string(str.substr(1,2), 0), - -from_string(str.substr(4,2), 0)); - } - } - else if(*inner_loc.iter() != 'Z' && *inner_loc.iter() != 'z') - { - throw internal_error(format_underline( - "toml::parse_offset_datetime: invalid datetime format", - {{source_location(inner_loc), "should be `Z` or `+HH:MM`"}}), - source_location(inner_loc)); - } - return ok(std::make_pair(offset_datetime(datetime.unwrap().first, offset), - token.unwrap())); - } - else - { - loc.reset(first); - return err(format_underline("toml::parse_offset_datetime: ", - {{source_location(loc), "the next token is not a offset_datetime"}})); - } -} - -inline result, std::string> -parse_simple_key(location& loc) -{ - if(const auto bstr = parse_basic_string(loc)) - { - return ok(std::make_pair(bstr.unwrap().first.str, bstr.unwrap().second)); - } - if(const auto lstr = parse_literal_string(loc)) - { - return ok(std::make_pair(lstr.unwrap().first.str, lstr.unwrap().second)); - } - if(const auto bare = lex_unquoted_key::invoke(loc)) - { - const auto reg = bare.unwrap(); - return ok(std::make_pair(reg.str(), reg)); - } - return err(format_underline("toml::parse_simple_key: ", - {{source_location(loc), "the next token is not a simple key"}})); -} - -// dotted key become vector of keys -inline result, region>, std::string> -parse_key(location& loc) -{ - const auto first = loc.iter(); - // dotted key -> `foo.bar.baz` where several single keys are chained by - // dots. Whitespaces between keys and dots are allowed. - if(const auto token = lex_dotted_key::invoke(loc)) - { - const auto reg = token.unwrap(); - location inner_loc(loc.name(), reg.str()); - std::vector keys; - - while(inner_loc.iter() != inner_loc.end()) - { - lex_ws::invoke(inner_loc); - if(const auto k = parse_simple_key(inner_loc)) - { - keys.push_back(k.unwrap().first); - } - else - { - throw internal_error(format_underline( - "toml::detail::parse_key: dotted key contains invalid key", - {{source_location(inner_loc), k.unwrap_err()}}), - source_location(inner_loc)); - } - - lex_ws::invoke(inner_loc); - if(inner_loc.iter() == inner_loc.end()) - { - break; - } - else if(*inner_loc.iter() == '.') - { - inner_loc.advance(); // to skip `.` - } - else - { - throw internal_error(format_underline("toml::parse_key: " - "dotted key contains invalid key ", - {{source_location(inner_loc), "should be `.`"}}), - source_location(inner_loc)); - } - } - return ok(std::make_pair(keys, reg)); - } - loc.reset(first); - - // simple_key: a single (basic_string|literal_string|bare key) - if(const auto smpl = parse_simple_key(loc)) - { - return ok(std::make_pair(std::vector(1, smpl.unwrap().first), - smpl.unwrap().second)); - } - return err(format_underline("toml::parse_key: an invalid key appeared.", - {{source_location(loc), "is not a valid key"}}, { - "bare keys : non-empty strings composed only of [A-Za-z0-9_-].", - "quoted keys: same as \"basic strings\" or 'literal strings'.", - "dotted keys: sequence of bare or quoted keys joined with a dot." - })); -} - -// forward-decl to implement parse_array and parse_table -template -result parse_value(location&); - -template -result, std::string> -parse_array(location& loc) -{ - using value_type = Value; - using array_type = typename value_type::array_type; - - const auto first = loc.iter(); - if(loc.iter() == loc.end()) - { - return err("toml::parse_array: input is empty"); - } - if(*loc.iter() != '[') - { - return err("toml::parse_array: token is not an array"); - } - loc.advance(); - - using lex_ws_comment_newline = repeat< - either, unlimited>; - - array_type retval; - while(loc.iter() != loc.end()) - { - lex_ws_comment_newline::invoke(loc); // skip - - if(loc.iter() != loc.end() && *loc.iter() == ']') - { - loc.advance(); // skip ']' - return ok(std::make_pair(retval, - region(loc, first, loc.iter()))); - } - - if(auto val = parse_value(loc)) - { - // After TOML v1.0.0-rc.1, array becomes to be able to have values - // with different types. So here we will omit this by default. - // - // But some of the test-suite checks if the parser accepts a hetero- - // geneous arrays, so we keep this for a while. -#ifdef TOML11_DISALLOW_HETEROGENEOUS_ARRAYS - if(!retval.empty() && retval.front().type() != val.as_ok().type()) - { - auto array_start_loc = loc; - array_start_loc.reset(first); - - throw syntax_error(format_underline("toml::parse_array: " - "type of elements should be the same each other.", { - {source_location(array_start_loc), "array starts here"}, - { - retval.front().location(), - "value has type " + stringize(retval.front().type()) - }, - { - val.unwrap().location(), - "value has different type, " + stringize(val.unwrap().type()) - } - }), source_location(loc)); - } -#endif - retval.push_back(std::move(val.unwrap())); - } - else - { - auto array_start_loc = loc; - array_start_loc.reset(first); - - throw syntax_error(format_underline("toml::parse_array: " - "value having invalid format appeared in an array", { - {source_location(array_start_loc), "array starts here"}, - {source_location(loc), "it is not a valid value."} - }), source_location(loc)); - } - - using lex_array_separator = sequence, character<','>>; - const auto sp = lex_array_separator::invoke(loc); - if(!sp) - { - lex_ws_comment_newline::invoke(loc); - if(loc.iter() != loc.end() && *loc.iter() == ']') - { - loc.advance(); // skip ']' - return ok(std::make_pair(retval, - region(loc, first, loc.iter()))); - } - else - { - auto array_start_loc = loc; - array_start_loc.reset(first); - - throw syntax_error(format_underline("toml::parse_array:" - " missing array separator `,` after a value", { - {source_location(array_start_loc), "array starts here"}, - {source_location(loc), "should be `,`"} - }), source_location(loc)); - } - } - } - loc.reset(first); - throw syntax_error(format_underline("toml::parse_array: " - "array did not closed by `]`", - {{source_location(loc), "should be closed"}}), - source_location(loc)); -} - -template -result, region>, Value>, std::string> -parse_key_value_pair(location& loc) -{ - using value_type = Value; - - const auto first = loc.iter(); - auto key_reg = parse_key(loc); - if(!key_reg) - { - std::string msg = std::move(key_reg.unwrap_err()); - // if the next token is keyvalue-separator, it means that there are no - // key. then we need to show error as "empty key is not allowed". - if(const auto keyval_sep = lex_keyval_sep::invoke(loc)) - { - loc.reset(first); - msg = format_underline("toml::parse_key_value_pair: " - "empty key is not allowed.", - {{source_location(loc), "key expected before '='"}}); - } - return err(std::move(msg)); - } - - const auto kvsp = lex_keyval_sep::invoke(loc); - if(!kvsp) - { - std::string msg; - // if the line contains '=' after the invalid sequence, possibly the - // error is in the key (like, invalid character in bare key). - const auto line_end = std::find(loc.iter(), loc.end(), '\n'); - if(std::find(loc.iter(), line_end, '=') != line_end) - { - msg = format_underline("toml::parse_key_value_pair: " - "invalid format for key", - {{source_location(loc), "invalid character in key"}}, - {"Did you forget '.' to separate dotted-key?", - "Allowed characters for bare key are [0-9a-zA-Z_-]."}); - } - else // if not, the error is lack of key-value separator. - { - msg = format_underline("toml::parse_key_value_pair: " - "missing key-value separator `=`", - {{source_location(loc), "should be `=`"}}); - } - loc.reset(first); - return err(std::move(msg)); - } - - const auto after_kvsp = loc.iter(); // err msg - auto val = parse_value(loc); - if(!val) - { - std::string msg; - loc.reset(after_kvsp); - // check there is something not a comment/whitespace after `=` - if(sequence, maybe, lex_newline>::invoke(loc)) - { - loc.reset(after_kvsp); - msg = format_underline("toml::parse_key_value_pair: " - "missing value after key-value separator '='", - {{source_location(loc), "expected value, but got nothing"}}); - } - else // there is something not a comment/whitespace, so invalid format. - { - msg = std::move(val.unwrap_err()); - } - loc.reset(first); - return err(msg); - } - return ok(std::make_pair(std::move(key_reg.unwrap()), - std::move(val.unwrap()))); -} - -// for error messages. -template -std::string format_dotted_keys(InputIterator first, const InputIterator last) -{ - static_assert(std::is_same::value_type>::value,""); - - std::string retval(*first++); - for(; first != last; ++first) - { - retval += '.'; - retval += *first; - } - return retval; -} - -// forward decl for is_valid_forward_table_definition -result, region>, std::string> -parse_table_key(location& loc); - -// The following toml file is allowed. -// ```toml -// [a.b.c] # here, table `a` has element `b`. -// foo = "bar" -// [a] # merge a = {baz = "qux"} to a = {b = {...}} -// baz = "qux" -// ``` -// But the following is not allowed. -// ```toml -// [a] -// b.c.foo = "bar" -// [a] # error! the same table [a] defined! -// baz = "qux" -// ``` -// The following is neither allowed. -// ```toml -// a = { b.c.foo = "bar"} -// [a] # error! the same table [a] defined! -// baz = "qux" -// ``` -// Here, it parses region of `tab->at(k)` as a table key and check the depth -// of the key. If the key region points deeper node, it would be allowed. -// Otherwise, the key points the same node. It would be rejected. -template -bool is_valid_forward_table_definition(const Value& fwd, - Iterator key_first, Iterator key_curr, Iterator key_last) -{ - std::string internal = ""; - if(const auto ptr = detail::get_region(fwd)) - { - internal = ptr->str(); - } - location def("internal", std::move(internal)); - if(const auto tabkeys = parse_table_key(def)) - { - // table keys always contains all the nodes from the root. - const auto& tks = tabkeys.unwrap().first; - if(std::size_t(std::distance(key_first, key_last)) == tks.size() && - std::equal(tks.begin(), tks.end(), key_first)) - { - // the keys are equivalent. it is not allowed. - return false; - } - // the keys are not equivalent. it is allowed. - return true; - } - if(const auto dotkeys = parse_key(def)) - { - // consider the following case. - // [a] - // b.c = {d = 42} - // [a.b.c] - // e = 2.71 - // this defines the table [a.b.c] twice. no? - - // a dotted key starts from the node representing a table in which the - // dotted key belongs to. - const auto& dks = dotkeys.unwrap().first; - if(std::size_t(std::distance(key_curr, key_last)) == dks.size() && - std::equal(dks.begin(), dks.end(), key_curr)) - { - // the keys are equivalent. it is not allowed. - return false; - } - // the keys are not equivalent. it is allowed. - return true; - } - return false; -} - -template -result -insert_nested_key(typename Value::table_type& root, const Value& v, - InputIterator iter, const InputIterator last, - region key_reg, - const bool is_array_of_table = false) -{ - static_assert(std::is_same::value_type>::value,""); - - using value_type = Value; - using table_type = typename value_type::table_type; - using array_type = typename value_type::array_type; - - const auto first = iter; - assert(iter != last); - - table_type* tab = std::addressof(root); - for(; iter != last; ++iter) // search recursively - { - const key& k = *iter; - if(std::next(iter) == last) // k is the last key - { - // XXX if the value is array-of-tables, there can be several - // tables that are in the same array. in that case, we need to - // find the last element and insert it to there. - if(is_array_of_table) - { - if(tab->count(k) == 1) // there is already an array of table - { - if(tab->at(k).is_table()) - { - // show special err msg for conflicting table - throw syntax_error(format_underline(concat_to_string( - "toml::insert_value: array of table (\"", - format_dotted_keys(first, last), - "\") cannot be defined"), { - {tab->at(k).location(), "table already defined"}, - {v.location(), "this conflicts with the previous table"} - }), v.location()); - } - else if(!(tab->at(k).is_array())) - { - throw syntax_error(format_underline(concat_to_string( - "toml::insert_value: array of table (\"", - format_dotted_keys(first, last), "\") collides with" - " existing value"), { - {tab->at(k).location(), - concat_to_string("this ", tab->at(k).type(), - " value already exists")}, - {v.location(), - "while inserting this array-of-tables"} - }), v.location()); - } - // the above if-else-if checks tab->at(k) is an array - auto& a = tab->at(k).as_array(); - if(!(a.front().is_table())) - { - throw syntax_error(format_underline(concat_to_string( - "toml::insert_value: array of table (\"", - format_dotted_keys(first, last), "\") collides with" - " existing value"), { - {tab->at(k).location(), - concat_to_string("this ", tab->at(k).type(), - " value already exists")}, - {v.location(), - "while inserting this array-of-tables"} - }), v.location()); - } - // avoid conflicting array of table like the following. - // ```toml - // a = [{b = 42}] # define a as an array of *inline* tables - // [[a]] # a is an array of *multi-line* tables - // b = 54 - // ``` - // Here, from the type information, these cannot be detected - // bacause inline table is also a table. - // But toml v0.5.0 explicitly says it is invalid. The above - // array-of-tables has a static size and appending to the - // array is invalid. - // In this library, multi-line table value has a region - // that points to the key of the table (e.g. [[a]]). By - // comparing the first two letters in key, we can detect - // the array-of-table is inline or multiline. - if(const auto ptr = detail::get_region(a.front())) - { - if(ptr->str().substr(0,2) != "[[") - { - throw syntax_error(format_underline(concat_to_string( - "toml::insert_value: array of table (\"", - format_dotted_keys(first, last), "\") collides " - "with existing array-of-tables"), { - {tab->at(k).location(), - concat_to_string("this ", tab->at(k).type(), - " value has static size")}, - {v.location(), - "appending it to the statically sized array"} - }), v.location()); - } - } - a.push_back(v); - return ok(true); - } - else // if not, we need to create the array of table - { - // XXX: Consider the following array of tables. - // ```toml - // # This is a comment. - // [[aot]] - // foo = "bar" - // ``` - // Here, the comment is for `aot`. But here, actually two - // values are defined. An array that contains tables, named - // `aot`, and the 0th element of the `aot`, `{foo = "bar"}`. - // Those two are different from each other. But both of them - // points to the same portion of the TOML file, `[[aot]]`, - // so `key_reg.comments()` returns `# This is a comment`. - // If it is assigned as a comment of `aot` defined here, the - // comment will be duplicated. Both the `aot` itself and - // the 0-th element will have the same comment. This causes - // "duplication of the same comments" bug when the data is - // serialized. - // Next, consider the following. - // ```toml - // # comment 1 - // aot = [ - // # coment 2 - // {foo = "bar"}, - // ] - // ``` - // In this case, we can distinguish those two comments. So - // here we need to add "comment 1" to the `aot` and - // "comment 2" to the 0th element of that. - // To distinguish those two, we check the key region. - std::vector comments{/* empty by default */}; - if(key_reg.str().substr(0, 2) != "[[") - { - comments = key_reg.comments(); - } - value_type aot(array_type(1, v), key_reg, std::move(comments)); - tab->insert(std::make_pair(k, aot)); - return ok(true); - } - } // end if(array of table) - - if(tab->count(k) == 1) - { - if(tab->at(k).is_table() && v.is_table()) - { - if(!is_valid_forward_table_definition( - tab->at(k), first, iter, last)) - { - throw syntax_error(format_underline(concat_to_string( - "toml::insert_value: table (\"", - format_dotted_keys(first, last), - "\") already exists."), { - {tab->at(k).location(), "table already exists here"}, - {v.location(), "table defined twice"} - }), v.location()); - } - // to allow the following toml file. - // [a.b.c] - // d = 42 - // [a] - // e = 2.71 - auto& t = tab->at(k).as_table(); - for(const auto& kv : v.as_table()) - { - t[kv.first] = kv.second; - } - detail::change_region(tab->at(k), key_reg); - return ok(true); - } - else if(v.is_table() && - tab->at(k).is_array() && - tab->at(k).as_array().size() > 0 && - tab->at(k).as_array().front().is_table()) - { - throw syntax_error(format_underline(concat_to_string( - "toml::insert_value: array of tables (\"", - format_dotted_keys(first, last), "\") already exists."), { - {tab->at(k).location(), "array of tables defined here"}, - {v.location(), "table conflicts with the previous array of table"} - }), v.location()); - } - else - { - throw syntax_error(format_underline(concat_to_string( - "toml::insert_value: value (\"", - format_dotted_keys(first, last), "\") already exists."), { - {tab->at(k).location(), "value already exists here"}, - {v.location(), "value defined twice"} - }), v.location()); - } - } - tab->insert(std::make_pair(k, v)); - return ok(true); - } - else // k is not the last one, we should insert recursively - { - // if there is no corresponding value, insert it first. - // related: you don't need to write - // # [x] - // # [x.y] - // to write - // [x.y.z] - if(tab->count(k) == 0) - { - // a table that is defined implicitly doesn't have any comments. - (*tab)[k] = value_type(table_type{}, key_reg, {/*no comment*/}); - } - - // type checking... - if(tab->at(k).is_table()) - { - // According to toml-lang/toml:36d3091b3 "Clarify that inline - // tables are immutable", check if it adds key-value pair to an - // inline table. - if(const auto* ptr = get_region(tab->at(k))) - { - // here, if the value is a (multi-line) table, the region - // should be something like `[table-name]`. - if(ptr->front() == '{') - { - throw syntax_error(format_underline(concat_to_string( - "toml::insert_value: inserting to an inline table (", - format_dotted_keys(first, std::next(iter)), - ") but inline tables are immutable"), { - {tab->at(k).location(), "inline tables are immutable"}, - {v.location(), "inserting this"} - }), v.location()); - } - } - tab = std::addressof((*tab)[k].as_table()); - } - else if(tab->at(k).is_array()) // inserting to array-of-tables? - { - auto& a = (*tab)[k].as_array(); - if(!a.back().is_table()) - { - throw syntax_error(format_underline(concat_to_string( - "toml::insert_value: target (", - format_dotted_keys(first, std::next(iter)), - ") is neither table nor an array of tables"), { - {a.back().location(), concat_to_string( - "actual type is ", a.back().type())}, - {v.location(), "inserting this"} - }), v.location()); - } - tab = std::addressof(a.back().as_table()); - } - else - { - throw syntax_error(format_underline(concat_to_string( - "toml::insert_value: target (", - format_dotted_keys(first, std::next(iter)), - ") is neither table nor an array of tables"), { - {tab->at(k).location(), concat_to_string( - "actual type is ", tab->at(k).type())}, - {v.location(), "inserting this"} - }), v.location()); - } - } - } - return err(std::string("toml::detail::insert_nested_key: never reach here")); -} - -template -result, std::string> -parse_inline_table(location& loc) -{ - using value_type = Value; - using table_type = typename value_type::table_type; - - const auto first = loc.iter(); - table_type retval; - if(!(loc.iter() != loc.end() && *loc.iter() == '{')) - { - return err(format_underline("toml::parse_inline_table: ", - {{source_location(loc), "the next token is not an inline table"}})); - } - loc.advance(); - // it starts from "{". it should be formatted as inline-table - while(loc.iter() != loc.end()) - { - maybe::invoke(loc); - if(loc.iter() != loc.end() && *loc.iter() == '}') - { - loc.advance(); // skip `}` - return ok(std::make_pair(retval, - region(loc, first, loc.iter()))); - } - - const auto kv_r = parse_key_value_pair(loc); - if(!kv_r) - { - return err(kv_r.unwrap_err()); - } - const auto& kvpair = kv_r.unwrap(); - const std::vector& keys = kvpair.first.first; - const auto& key_reg = kvpair.first.second; - const value_type& val = kvpair.second; - - const auto inserted = - insert_nested_key(retval, val, keys.begin(), keys.end(), key_reg); - if(!inserted) - { - throw internal_error("toml::parse_inline_table: " - "failed to insert value into table: " + inserted.unwrap_err(), - source_location(loc)); - } - - using lex_table_separator = sequence, character<','>>; - const auto sp = lex_table_separator::invoke(loc); - if(!sp) - { - maybe::invoke(loc); - if(loc.iter() != loc.end() && *loc.iter() == '}') - { - loc.advance(); // skip `}` - return ok(std::make_pair( - retval, region(loc, first, loc.iter()))); - } - else if(*loc.iter() == '#' || *loc.iter() == '\r' || *loc.iter() == '\n') - { - throw syntax_error(format_underline( - "toml::parse_inline_table: missing curly brace `}`", - {{source_location(loc), "should be `}`"}}), - source_location(loc)); - } - else - { - throw syntax_error(format_underline( - "toml::parse_inline_table: missing table separator `,` ", - {{source_location(loc), "should be `,`"}}), - source_location(loc)); - } - } - } - loc.reset(first); - throw syntax_error(format_underline("toml::parse_inline_table: " - "inline table did not closed by `}`", - {{source_location(loc), "should be closed"}}), - source_location(loc)); -} - -inline result guess_number_type(const location& l) -{ - // This function tries to find some (common) mistakes by checking characters - // that follows the last character of a value. But it is often difficult - // because some non-newline characters can appear after a value. E.g. - // spaces, tabs, commas (in an array or inline table), closing brackets - // (of an array or inline table), comment-sign (#). Since this function - // does not parse further, those characters are always allowed to be there. - location loc = l; - - if(lex_offset_date_time::invoke(loc)) {return ok(value_t::offset_datetime);} - loc.reset(l.iter()); - - if(lex_local_date_time::invoke(loc)) - { - // bad offset may appear after this. - if(loc.iter() != loc.end() && (*loc.iter() == '+' || *loc.iter() == '-' - || *loc.iter() == 'Z' || *loc.iter() == 'z')) - { - return err(format_underline("bad offset: should be [+-]HH:MM or Z", - {{source_location(loc), "[+-]HH:MM or Z"}}, - {"pass: +09:00, -05:30", "fail: +9:00, -5:30"})); - } - return ok(value_t::local_datetime); - } - loc.reset(l.iter()); - - if(lex_local_date::invoke(loc)) - { - // bad time may appear after this. - // A space is allowed as a delimiter between local time. But there are - // both cases in which a space becomes valid or invalid. - // - invalid: 2019-06-16 7:00:00 - // - valid : 2019-06-16 07:00:00 - if(loc.iter() != loc.end()) - { - const auto c = *loc.iter(); - if(c == 'T' || c == 't') - { - return err(format_underline("bad time: should be HH:MM:SS.subsec", - {{source_location(loc), "HH:MM:SS.subsec"}}, - {"pass: 1979-05-27T07:32:00, 1979-05-27 07:32:00.999999", - "fail: 1979-05-27T7:32:00, 1979-05-27 17:32"})); - } - if('0' <= c && c <= '9') - { - return err(format_underline("bad time: missing T", - {{source_location(loc), "T or space required here"}}, - {"pass: 1979-05-27T07:32:00, 1979-05-27 07:32:00.999999", - "fail: 1979-05-27T7:32:00, 1979-05-27 7:32"})); - } - if(c == ' ' && std::next(loc.iter()) != loc.end() && - ('0' <= *std::next(loc.iter()) && *std::next(loc.iter())<= '9')) - { - loc.advance(); - return err(format_underline("bad time: should be HH:MM:SS.subsec", - {{source_location(loc), "HH:MM:SS.subsec"}}, - {"pass: 1979-05-27T07:32:00, 1979-05-27 07:32:00.999999", - "fail: 1979-05-27T7:32:00, 1979-05-27 7:32"})); - } - } - return ok(value_t::local_date); - } - loc.reset(l.iter()); - - if(lex_local_time::invoke(loc)) {return ok(value_t::local_time);} - loc.reset(l.iter()); - - if(lex_float::invoke(loc)) - { - if(loc.iter() != loc.end() && *loc.iter() == '_') - { - return err(format_underline("bad float: `_` should be surrounded by digits", - {{source_location(loc), "here"}}, - {"pass: +1.0, -2e-2, 3.141_592_653_589, inf, nan", - "fail: .0, 1., _1.0, 1.0_, 1_.0, 1.0__0"})); - } - return ok(value_t::floating); - } - loc.reset(l.iter()); - - if(lex_integer::invoke(loc)) - { - if(loc.iter() != loc.end()) - { - const auto c = *loc.iter(); - if(c == '_') - { - return err(format_underline("bad integer: `_` should be surrounded by digits", - {{source_location(loc), "here"}}, - {"pass: -42, 1_000, 1_2_3_4_5, 0xC0FFEE, 0b0010, 0o755", - "fail: 1__000, 0123"})); - } - if('0' <= c && c <= '9') - { - // leading zero. point '0' - loc.retrace(); - return err(format_underline("bad integer: leading zero", - {{source_location(loc), "here"}}, - {"pass: -42, 1_000, 1_2_3_4_5, 0xC0FFEE, 0b0010, 0o755", - "fail: 1__000, 0123"})); - } - if(c == ':' || c == '-') - { - return err(format_underline("bad datetime: invalid format", - {{source_location(loc), "here"}}, - {"pass: 1979-05-27T07:32:00-07:00, 1979-05-27 07:32:00.999999Z", - "fail: 1979-05-27T7:32:00-7:00, 1979-05-27 7:32-00:30"})); - } - if(c == '.' || c == 'e' || c == 'E') - { - return err(format_underline("bad float: invalid format", - {{source_location(loc), "here"}}, - {"pass: +1.0, -2e-2, 3.141_592_653_589, inf, nan", - "fail: .0, 1., _1.0, 1.0_, 1_.0, 1.0__0"})); - } - } - return ok(value_t::integer); - } - if(loc.iter() != loc.end() && *loc.iter() == '.') - { - return err(format_underline("bad float: invalid format", - {{source_location(loc), "integer part required before this"}}, - {"pass: +1.0, -2e-2, 3.141_592_653_589, inf, nan", - "fail: .0, 1., _1.0, 1.0_, 1_.0, 1.0__0"})); - } - if(loc.iter() != loc.end() && *loc.iter() == '_') - { - return err(format_underline("bad number: `_` should be surrounded by digits", - {{source_location(loc), "`_` is not surrounded by digits"}}, - {"pass: -42, 1_000, 1_2_3_4_5, 0xC0FFEE, 0b0010, 0o755", - "fail: 1__000, 0123"})); - } - return err(format_underline("bad format: unknown value appeared", - {{source_location(loc), "here"}})); -} - -inline result guess_value_type(const location& loc) -{ - switch(*loc.iter()) - { - case '"' : {return ok(value_t::string); } - case '\'': {return ok(value_t::string); } - case 't' : {return ok(value_t::boolean); } - case 'f' : {return ok(value_t::boolean); } - case '[' : {return ok(value_t::array); } - case '{' : {return ok(value_t::table); } - case 'i' : {return ok(value_t::floating);} // inf. - case 'n' : {return ok(value_t::floating);} // nan. - default : {return guess_number_type(loc);} - } -} - -template -result -parse_value_helper(result, std::string> rslt) -{ - if(rslt.is_ok()) - { - auto comments = rslt.as_ok().second.comments(); - return ok(Value(std::move(rslt.as_ok()), std::move(comments))); - } - else - { - return err(std::move(rslt.as_err())); - } -} - -template -result parse_value(location& loc) -{ - const auto first = loc.iter(); - if(first == loc.end()) - { - return err(format_underline("toml::parse_value: input is empty", - {{source_location(loc), ""}})); - } - - const auto type = guess_value_type(loc); - if(!type) - { - return err(type.unwrap_err()); - } - - switch(type.unwrap()) - { - case value_t::boolean : {return parse_value_helper(parse_boolean(loc) );} - case value_t::integer : {return parse_value_helper(parse_integer(loc) );} - case value_t::floating : {return parse_value_helper(parse_floating(loc) );} - case value_t::string : {return parse_value_helper(parse_string(loc) );} - case value_t::offset_datetime: {return parse_value_helper(parse_offset_datetime(loc) );} - case value_t::local_datetime : {return parse_value_helper(parse_local_datetime(loc) );} - case value_t::local_date : {return parse_value_helper(parse_local_date(loc) );} - case value_t::local_time : {return parse_value_helper(parse_local_time(loc) );} - case value_t::array : {return parse_value_helper(parse_array(loc) );} - case value_t::table : {return parse_value_helper(parse_inline_table(loc));} - default: - { - const auto msg = format_underline("toml::parse_value: " - "unknown token appeared", {{source_location(loc), "unknown"}}); - loc.reset(first); - return err(msg); - } - } -} - -inline result, region>, std::string> -parse_table_key(location& loc) -{ - if(auto token = lex_std_table::invoke(loc)) - { - location inner_loc(loc.name(), token.unwrap().str()); - - const auto open = lex_std_table_open::invoke(inner_loc); - if(!open || inner_loc.iter() == inner_loc.end()) - { - throw internal_error(format_underline( - "toml::parse_table_key: no `[`", - {{source_location(inner_loc), "should be `[`"}}), - source_location(inner_loc)); - } - // to skip [ a . b . c ] - // ^----------- this whitespace - lex_ws::invoke(inner_loc); - const auto keys = parse_key(inner_loc); - if(!keys) - { - throw internal_error(format_underline( - "toml::parse_table_key: invalid key", - {{source_location(inner_loc), "not key"}}), - source_location(inner_loc)); - } - // to skip [ a . b . c ] - // ^-- this whitespace - lex_ws::invoke(inner_loc); - const auto close = lex_std_table_close::invoke(inner_loc); - if(!close) - { - throw internal_error(format_underline( - "toml::parse_table_key: no `]`", - {{source_location(inner_loc), "should be `]`"}}), - source_location(inner_loc)); - } - - // after [table.key], newline or EOF(empty table) requried. - if(loc.iter() != loc.end()) - { - using lex_newline_after_table_key = - sequence, maybe, lex_newline>; - const auto nl = lex_newline_after_table_key::invoke(loc); - if(!nl) - { - throw syntax_error(format_underline( - "toml::parse_table_key: newline required after [table.key]", - {{source_location(loc), "expected newline"}}), - source_location(loc)); - } - } - return ok(std::make_pair(keys.unwrap().first, token.unwrap())); - } - else - { - return err(format_underline("toml::parse_table_key: " - "not a valid table key", {{source_location(loc), "here"}})); - } -} - -inline result, region>, std::string> -parse_array_table_key(location& loc) -{ - if(auto token = lex_array_table::invoke(loc)) - { - location inner_loc(loc.name(), token.unwrap().str()); - - const auto open = lex_array_table_open::invoke(inner_loc); - if(!open || inner_loc.iter() == inner_loc.end()) - { - throw internal_error(format_underline( - "toml::parse_array_table_key: no `[[`", - {{source_location(inner_loc), "should be `[[`"}}), - source_location(inner_loc)); - } - lex_ws::invoke(inner_loc); - const auto keys = parse_key(inner_loc); - if(!keys) - { - throw internal_error(format_underline( - "toml::parse_array_table_key: invalid key", - {{source_location(inner_loc), "not a key"}}), - source_location(inner_loc)); - } - lex_ws::invoke(inner_loc); - const auto close = lex_array_table_close::invoke(inner_loc); - if(!close) - { - throw internal_error(format_underline( - "toml::parse_table_key: no `]]`", - {{source_location(inner_loc), "should be `]]`"}}), - source_location(inner_loc)); - } - - // after [[table.key]], newline or EOF(empty table) requried. - if(loc.iter() != loc.end()) - { - using lex_newline_after_table_key = - sequence, maybe, lex_newline>; - const auto nl = lex_newline_after_table_key::invoke(loc); - if(!nl) - { - throw syntax_error(format_underline("toml::" - "parse_array_table_key: newline required after [[table.key]]", - {{source_location(loc), "expected newline"}}), - source_location(loc)); - } - } - return ok(std::make_pair(keys.unwrap().first, token.unwrap())); - } - else - { - return err(format_underline("toml::parse_array_table_key: " - "not a valid table key", {{source_location(loc), "here"}})); - } -} - -// parse table body (key-value pairs until the iter hits the next [tablekey]) -template -result -parse_ml_table(location& loc) -{ - using value_type = Value; - using table_type = typename value_type::table_type; - - const auto first = loc.iter(); - if(first == loc.end()) - { - return ok(table_type{}); - } - - // XXX at lest one newline is needed. - using skip_line = repeat< - sequence, maybe, lex_newline>, at_least<1>>; - skip_line::invoke(loc); - lex_ws::invoke(loc); - - table_type tab; - while(loc.iter() != loc.end()) - { - lex_ws::invoke(loc); - const auto before = loc.iter(); - if(const auto tmp = parse_array_table_key(loc)) // next table found - { - loc.reset(before); - return ok(tab); - } - if(const auto tmp = parse_table_key(loc)) // next table found - { - loc.reset(before); - return ok(tab); - } - - if(const auto kv = parse_key_value_pair(loc)) - { - const auto& kvpair = kv.unwrap(); - const std::vector& keys = kvpair.first.first; - const auto& key_reg = kvpair.first.second; - const value_type& val = kvpair.second; - const auto inserted = - insert_nested_key(tab, val, keys.begin(), keys.end(), key_reg); - if(!inserted) - { - return err(inserted.unwrap_err()); - } - } - else - { - return err(kv.unwrap_err()); - } - - // comment lines are skipped by the above function call. - // However, since the `skip_line` requires at least 1 newline, it fails - // if the file ends with ws and/or comment without newline. - // `skip_line` matches `ws? + comment? + newline`, not `ws` or `comment` - // itself. To skip the last ws and/or comment, call lexers. - // It does not matter if these fails, so the return value is discarded. - lex_ws::invoke(loc); - lex_comment::invoke(loc); - - // skip_line is (whitespace? comment? newline)_{1,}. multiple empty lines - // and comments after the last key-value pairs are allowed. - const auto newline = skip_line::invoke(loc); - if(!newline && loc.iter() != loc.end()) - { - const auto before2 = loc.iter(); - lex_ws::invoke(loc); // skip whitespace - const auto msg = format_underline("toml::parse_table: " - "invalid line format", {{source_location(loc), concat_to_string( - "expected newline, but got '", show_char(*loc.iter()), "'.")}}); - loc.reset(before2); - return err(msg); - } - - // the skip_lines only matches with lines that includes newline. - // to skip the last line that includes comment and/or whitespace - // but no newline, call them one more time. - lex_ws::invoke(loc); - lex_comment::invoke(loc); - } - return ok(tab); -} - -template -result parse_toml_file(location& loc) -{ - using value_type = Value; - using table_type = typename value_type::table_type; - - const auto first = loc.iter(); - if(first == loc.end()) - { - return ok(value_type(table_type{} /*, empty file has no region ...*/)); - } - - // put the first line as a region of a file - // Here first != loc.end(), so taking std::next is okay - const region file(loc, first, std::next(loc.iter())); - - // The first successive comments that are separated from the first value - // by an empty line are for a file itself. - // ```toml - // # this is a comment for a file. - // - // key = "the first value" - // ``` - // ```toml - // # this is a comment for "the first value". - // key = "the first value" - // ``` - std::vector comments; - using lex_first_comments = sequence< - repeat, lex_comment, lex_newline>, at_least<1>>, - sequence, lex_newline> - >; - if(const auto token = lex_first_comments::invoke(loc)) - { - location inner_loc(loc.name(), token.unwrap().str()); - while(inner_loc.iter() != inner_loc.end()) - { - maybe::invoke(inner_loc); // remove ws if exists - if(lex_newline::invoke(inner_loc)) - { - assert(inner_loc.iter() == inner_loc.end()); - break; // empty line found. - } - auto com = lex_comment::invoke(inner_loc).unwrap().str(); - com.erase(com.begin()); // remove # sign - comments.push_back(std::move(com)); - lex_newline::invoke(inner_loc); - } - } - - table_type data; - // root object is also a table, but without [tablename] - if(auto tab = parse_ml_table(loc)) - { - data = std::move(tab.unwrap()); - } - else // failed (empty table is regarded as success in parse_ml_table) - { - return err(tab.unwrap_err()); - } - while(loc.iter() != loc.end()) - { - // here, the region of [table] is regarded as the table-key because - // the table body is normally too big and it is not so informative - // if the first key-value pair of the table is shown in the error - // message. - if(const auto tabkey = parse_array_table_key(loc)) - { - const auto tab = parse_ml_table(loc); - if(!tab){return err(tab.unwrap_err());} - - const auto& tk = tabkey.unwrap(); - const auto& keys = tk.first; - const auto& reg = tk.second; - - const auto inserted = insert_nested_key(data, - value_type(tab.unwrap(), reg, reg.comments()), - keys.begin(), keys.end(), reg, - /*is_array_of_table=*/ true); - if(!inserted) {return err(inserted.unwrap_err());} - - continue; - } - if(const auto tabkey = parse_table_key(loc)) - { - const auto tab = parse_ml_table(loc); - if(!tab){return err(tab.unwrap_err());} - - const auto& tk = tabkey.unwrap(); - const auto& keys = tk.first; - const auto& reg = tk.second; - - const auto inserted = insert_nested_key(data, - value_type(tab.unwrap(), reg, reg.comments()), - keys.begin(), keys.end(), reg); - if(!inserted) {return err(inserted.unwrap_err());} - - continue; - } - return err(format_underline("toml::parse_toml_file: " - "unknown line appeared", {{source_location(loc), "unknown format"}})); - } - - return ok(Value(std::move(data), file, comments)); -} - -} // detail - -template class Table = std::unordered_map, - template class Array = std::vector> -basic_value -parse(std::istream& is, const std::string& fname = "unknown file") -{ - using value_type = basic_value; - - const auto beg = is.tellg(); - is.seekg(0, std::ios::end); - const auto end = is.tellg(); - const auto fsize = end - beg; - is.seekg(beg); - - // read whole file as a sequence of char - assert(fsize >= 0); - std::vector letters(static_cast(fsize)); - is.read(letters.data(), fsize); - - while(!letters.empty() && letters.back() == '\0') - { - letters.pop_back(); - } - assert(letters.empty() || letters.back() != '\0'); - - detail::location loc(std::move(fname), std::move(letters)); - - // skip BOM if exists. - // XXX component of BOM (like 0xEF) exceeds the representable range of - // signed char, so on some (actually, most) of the environment, these cannot - // be compared to char. However, since we are always out of luck, we need to - // check our chars are equivalent to BOM. To do this, first we need to - // convert char to unsigned char to guarantee the comparability. - if(loc.source()->size() >= 3) - { - std::array BOM; - std::memcpy(BOM.data(), loc.source()->data(), 3); - if(BOM[0] == 0xEF && BOM[1] == 0xBB && BOM[2] == 0xBF) - { - loc.advance(3); // BOM found. skip. - } - } - - const auto data = detail::parse_toml_file(loc); - if(!data) - { - throw syntax_error(data.unwrap_err(), source_location(loc)); - } - return data.unwrap(); -} - -template class Table = std::unordered_map, - template class Array = std::vector> -basic_value -parse(QByteArray qba, const std::string& fname = "unknown file") -{ - using value_type = basic_value; - - // convert QByteArray to vector - std::vector letters(qba.begin(), qba.end()); - - while(!letters.empty() && letters.back() == '\0') - { - letters.pop_back(); - } - assert(letters.empty() || letters.back() != '\0'); - - detail::location loc(std::move(fname), std::move(letters)); - - // skip BOM if exists. - // XXX component of BOM (like 0xEF) exceeds the representable range of - // signed char, so on some (actually, most) of the environment, these cannot - // be compared to char. However, since we are always out of luck, we need to - // check our chars are equivalent to BOM. To do this, first we need to - // convert char to unsigned char to guarantee the comparability. - if(loc.source()->size() >= 3) - { - std::array BOM; - std::memcpy(BOM.data(), loc.source()->data(), 3); - if(BOM[0] == 0xEF && BOM[1] == 0xBB && BOM[2] == 0xBF) - { - loc.advance(3); // BOM found. skip. - } - } - - const auto data = detail::parse_toml_file(loc); - if(!data) - { - throw syntax_error(data.unwrap_err(), source_location(loc)); - } - return data.unwrap(); -} - -template class Table = std::unordered_map, - template class Array = std::vector> -basic_value parse(const std::string& fname) -{ - std::ifstream ifs(fname.c_str(), std::ios_base::binary); - if(!ifs.good()) - { - throw std::runtime_error("toml::parse: file open error -> " + fname); - } - return parse(ifs, fname); -} - -#ifdef TOML11_HAS_STD_FILESYSTEM -// This function just forwards `parse("filename.toml")` to std::string version -// to avoid the ambiguity in overload resolution. -// -// Both std::string and std::filesystem::path are convertible from const char*. -// Without this, both parse(std::string) and parse(std::filesystem::path) -// matches to parse("filename.toml"). This breaks the existing code. -// -// This function exactly matches to the invokation with c-string. -// So this function is preferred than others and the ambiguity disappears. -template class Table = std::unordered_map, - template class Array = std::vector> -basic_value parse(const char* fname) -{ - return parse(std::string(fname)); -} - -template class Table = std::unordered_map, - template class Array = std::vector> -basic_value parse(const std::filesystem::path& fpath) -{ - std::ifstream ifs(fpath, std::ios_base::binary); - if(!ifs.good()) - { - throw std::runtime_error("toml::parse: file open error -> " + - fpath.string()); - } - return parse(ifs, fpath.string()); -} -#endif // TOML11_HAS_STD_FILESYSTEM - -} // toml -#endif// TOML11_PARSER_HPP diff --git a/libraries/toml11/include/toml/region.hpp b/libraries/toml11/include/toml/region.hpp deleted file mode 100644 index 37ba3a30..00000000 --- a/libraries/toml11/include/toml/region.hpp +++ /dev/null @@ -1,417 +0,0 @@ -// Copyright Toru Niina 2017. -// Distributed under the MIT License. -#ifndef TOML11_REGION_HPP -#define TOML11_REGION_HPP -#include -#include -#include -#include -#include -#include -#include -#include "color.hpp" - -namespace toml -{ -namespace detail -{ - -// helper function to avoid std::string(0, 'c') or std::string(iter, iter) -template -std::string make_string(Iterator first, Iterator last) -{ - if(first == last) {return "";} - return std::string(first, last); -} -inline std::string make_string(std::size_t len, char c) -{ - if(len == 0) {return "";} - return std::string(len, c); -} - -// region_base is a base class of location and region that are defined below. -// it will be used to generate better error messages. -struct region_base -{ - region_base() = default; - virtual ~region_base() = default; - region_base(const region_base&) = default; - region_base(region_base&& ) = default; - region_base& operator=(const region_base&) = default; - region_base& operator=(region_base&& ) = default; - - virtual bool is_ok() const noexcept {return false;} - virtual char front() const noexcept {return '\0';} - - virtual std::string str() const {return std::string("unknown region");} - virtual std::string name() const {return std::string("unknown file");} - virtual std::string line() const {return std::string("unknown line");} - virtual std::string line_num() const {return std::string("?");} - - // length of the region - virtual std::size_t size() const noexcept {return 0;} - // number of characters in the line before the region - virtual std::size_t before() const noexcept {return 0;} - // number of characters in the line after the region - virtual std::size_t after() const noexcept {return 0;} - - virtual std::vector comments() const {return {};} - // ```toml - // # comment_before - // key = "value" # comment_inline - // ``` -}; - -// location represents a position in a container, which contains a file content. -// it can be considered as a region that contains only one character. -// -// it contains pointer to the file content and iterator that points the current -// location. -struct location final : public region_base -{ - using const_iterator = typename std::vector::const_iterator; - using difference_type = typename const_iterator::difference_type; - using source_ptr = std::shared_ptr>; - - location(std::string name, std::vector cont) - : source_(std::make_shared>(std::move(cont))), - line_number_(1), source_name_(std::move(name)), iter_(source_->cbegin()) - {} - location(std::string name, const std::string& cont) - : source_(std::make_shared>(cont.begin(), cont.end())), - line_number_(1), source_name_(std::move(name)), iter_(source_->cbegin()) - {} - - location(const location&) = default; - location(location&&) = default; - location& operator=(const location&) = default; - location& operator=(location&&) = default; - ~location() = default; - - bool is_ok() const noexcept override {return static_cast(source_);} - char front() const noexcept override {return *iter_;} - - // this const prohibits codes like `++(loc.iter())`. - const const_iterator iter() const noexcept {return iter_;} - - const_iterator begin() const noexcept {return source_->cbegin();} - const_iterator end() const noexcept {return source_->cend();} - - // XXX `location::line_num()` used to be implemented using `std::count` to - // count a number of '\n'. But with a long toml file (typically, 10k lines), - // it becomes intolerably slow because each time it generates error messages, - // it counts '\n' from thousands of characters. To workaround it, I decided - // to introduce `location::line_number_` member variable and synchronize it - // to the location changes the point to look. So an overload of `iter()` - // which returns mutable reference is removed and `advance()`, `retrace()` - // and `reset()` is added. - void advance(difference_type n = 1) noexcept - { - this->line_number_ += static_cast( - std::count(this->iter_, std::next(this->iter_, n), '\n')); - this->iter_ += n; - return; - } - void retrace(difference_type n = 1) noexcept - { - this->line_number_ -= static_cast( - std::count(std::prev(this->iter_, n), this->iter_, '\n')); - this->iter_ -= n; - return; - } - void reset(const_iterator rollback) noexcept - { - // since c++11, std::distance works in both ways for random-access - // iterators and returns a negative value if `first > last`. - if(0 <= std::distance(rollback, this->iter_)) // rollback < iter - { - this->line_number_ -= static_cast( - std::count(rollback, this->iter_, '\n')); - } - else // iter < rollback [[unlikely]] - { - this->line_number_ += static_cast( - std::count(this->iter_, rollback, '\n')); - } - this->iter_ = rollback; - return; - } - - std::string str() const override {return make_string(1, *this->iter());} - std::string name() const override {return source_name_;} - - std::string line_num() const override - { - return std::to_string(this->line_number_); - } - - std::string line() const override - { - return make_string(this->line_begin(), this->line_end()); - } - - const_iterator line_begin() const noexcept - { - using reverse_iterator = std::reverse_iterator; - return std::find(reverse_iterator(this->iter()), - reverse_iterator(this->begin()), '\n').base(); - } - const_iterator line_end() const noexcept - { - return std::find(this->iter(), this->end(), '\n'); - } - - // location is always points a character. so the size is 1. - std::size_t size() const noexcept override - { - return 1u; - } - std::size_t before() const noexcept override - { - const auto sz = std::distance(this->line_begin(), this->iter()); - assert(sz >= 0); - return static_cast(sz); - } - std::size_t after() const noexcept override - { - const auto sz = std::distance(this->iter(), this->line_end()); - assert(sz >= 0); - return static_cast(sz); - } - - source_ptr const& source() const& noexcept {return source_;} - source_ptr&& source() && noexcept {return std::move(source_);} - - private: - - source_ptr source_; - std::size_t line_number_; - std::string source_name_; - const_iterator iter_; -}; - -// region represents a range in a container, which contains a file content. -// -// it contains pointer to the file content and iterator that points the first -// and last location. -struct region final : public region_base -{ - using const_iterator = typename std::vector::const_iterator; - using source_ptr = std::shared_ptr>; - - // delete default constructor. source_ never be null. - region() = delete; - - explicit region(const location& loc) - : source_(loc.source()), source_name_(loc.name()), - first_(loc.iter()), last_(loc.iter()) - {} - explicit region(location&& loc) - : source_(loc.source()), source_name_(loc.name()), - first_(loc.iter()), last_(loc.iter()) - {} - - region(const location& loc, const_iterator f, const_iterator l) - : source_(loc.source()), source_name_(loc.name()), first_(f), last_(l) - {} - region(location&& loc, const_iterator f, const_iterator l) - : source_(loc.source()), source_name_(loc.name()), first_(f), last_(l) - {} - - region(const region&) = default; - region(region&&) = default; - region& operator=(const region&) = default; - region& operator=(region&&) = default; - ~region() = default; - - region& operator+=(const region& other) - { - // different regions cannot be concatenated - assert(this->begin() == other.begin() && this->end() == other.end() && - this->last_ == other.first_); - - this->last_ = other.last_; - return *this; - } - - bool is_ok() const noexcept override {return static_cast(source_);} - char front() const noexcept override {return *first_;} - - std::string str() const override {return make_string(first_, last_);} - std::string line() const override - { - if(this->contain_newline()) - { - return make_string(this->line_begin(), - std::find(this->line_begin(), this->last(), '\n')); - } - return make_string(this->line_begin(), this->line_end()); - } - std::string line_num() const override - { - return std::to_string(1 + std::count(this->begin(), this->first(), '\n')); - } - - std::size_t size() const noexcept override - { - const auto sz = std::distance(first_, last_); - assert(sz >= 0); - return static_cast(sz); - } - std::size_t before() const noexcept override - { - const auto sz = std::distance(this->line_begin(), this->first()); - assert(sz >= 0); - return static_cast(sz); - } - std::size_t after() const noexcept override - { - const auto sz = std::distance(this->last(), this->line_end()); - assert(sz >= 0); - return static_cast(sz); - } - - bool contain_newline() const noexcept - { - return std::find(this->first(), this->last(), '\n') != this->last(); - } - - const_iterator line_begin() const noexcept - { - using reverse_iterator = std::reverse_iterator; - return std::find(reverse_iterator(this->first()), - reverse_iterator(this->begin()), '\n').base(); - } - const_iterator line_end() const noexcept - { - return std::find(this->last(), this->end(), '\n'); - } - - const_iterator begin() const noexcept {return source_->cbegin();} - const_iterator end() const noexcept {return source_->cend();} - const_iterator first() const noexcept {return first_;} - const_iterator last() const noexcept {return last_;} - - source_ptr const& source() const& noexcept {return source_;} - source_ptr&& source() && noexcept {return std::move(source_);} - - std::string name() const override {return source_name_;} - - std::vector comments() const override - { - // assuming the current region (`*this`) points a value. - // ```toml - // a = "value" - // ^^^^^^^- this region - // ``` - using rev_iter = std::reverse_iterator; - - std::vector com{}; - { - // find comments just before the current region. - // ```toml - // # this should be collected. - // # this also. - // a = value # not this. - // ``` - - // # this is a comment for `a`, not array elements. - // a = [1, 2, 3, 4, 5] - if(this->first() == std::find_if(this->line_begin(), this->first(), - [](const char c) noexcept -> bool {return c == '[' || c == '{';})) - { - auto iter = this->line_begin(); // points the first character - while(iter != this->begin()) - { - iter = std::prev(iter); - - // range [line_start, iter) represents the previous line - const auto line_start = std::find( - rev_iter(iter), rev_iter(this->begin()), '\n').base(); - const auto comment_found = std::find(line_start, iter, '#'); - if(comment_found == iter) - { - break; // comment not found. - } - - // exclude the following case. - // > a = "foo" # comment // <-- this is not a comment for b but a. - // > b = "current value" - if(std::all_of(line_start, comment_found, - [](const char c) noexcept -> bool { - return c == ' ' || c == '\t'; - })) - { - // unwrap the first '#' by std::next. - auto str = make_string(std::next(comment_found), iter); - if(!str.empty() && str.back() == '\r') {str.pop_back();} - com.push_back(std::move(str)); - } - else - { - break; - } - iter = line_start; - } - } - } - - if(com.size() > 1) - { - std::reverse(com.begin(), com.end()); - } - - { - // find comments just after the current region. - // ```toml - // # not this. - // a = value # this one. - // a = [ # not this (technically difficult) - // - // ] # and this. - // ``` - // The reason why it's difficult is that it requires parsing in the - // following case. - // ```toml - // a = [ 10 # this comment is for `10`. not for `a` but `a[0]`. - // # ... - // ] # this is apparently a comment for a. - // - // b = [ - // 3.14 ] # there is no way to add a comment to `3.14` currently. - // - // c = [ - // 3.14 # do this if you need a comment here. - // ] - // ``` - const auto comment_found = - std::find(this->last(), this->line_end(), '#'); - if(comment_found != this->line_end()) // '#' found - { - // table = {key = "value"} # what is this for? - // the above comment is not for "value", but {key="value"}. - if(comment_found == std::find_if(this->last(), comment_found, - [](const char c) noexcept -> bool { - return !(c == ' ' || c == '\t' || c == ','); - })) - { - // unwrap the first '#' by std::next. - auto str = make_string(std::next(comment_found), this->line_end()); - if(!str.empty() && str.back() == '\r') {str.pop_back();} - com.push_back(std::move(str)); - } - } - } - return com; - } - - private: - - source_ptr source_; - std::string source_name_; - const_iterator first_, last_; -}; - -} // detail -} // toml -#endif// TOML11_REGION_H diff --git a/libraries/toml11/include/toml/result.hpp b/libraries/toml11/include/toml/result.hpp deleted file mode 100644 index 77cd46c6..00000000 --- a/libraries/toml11/include/toml/result.hpp +++ /dev/null @@ -1,717 +0,0 @@ -// Copyright Toru Niina 2017. -// Distributed under the MIT License. -#ifndef TOML11_RESULT_HPP -#define TOML11_RESULT_HPP -#include "traits.hpp" -#include -#include -#include -#include -#include -#include -#include - -namespace toml -{ - -template -struct success -{ - using value_type = T; - value_type value; - - explicit success(const value_type& v) - noexcept(std::is_nothrow_copy_constructible::value) - : value(v) - {} - explicit success(value_type&& v) - noexcept(std::is_nothrow_move_constructible::value) - : value(std::move(v)) - {} - - template - explicit success(U&& v): value(std::forward(v)) {} - - template - explicit success(const success& v): value(v.value) {} - template - explicit success(success&& v): value(std::move(v.value)) {} - - ~success() = default; - success(const success&) = default; - success(success&&) = default; - success& operator=(const success&) = default; - success& operator=(success&&) = default; -}; - -template -struct failure -{ - using value_type = T; - value_type value; - - explicit failure(const value_type& v) - noexcept(std::is_nothrow_copy_constructible::value) - : value(v) - {} - explicit failure(value_type&& v) - noexcept(std::is_nothrow_move_constructible::value) - : value(std::move(v)) - {} - - template - explicit failure(U&& v): value(std::forward(v)) {} - - template - explicit failure(const failure& v): value(v.value) {} - template - explicit failure(failure&& v): value(std::move(v.value)) {} - - ~failure() = default; - failure(const failure&) = default; - failure(failure&&) = default; - failure& operator=(const failure&) = default; - failure& operator=(failure&&) = default; -}; - -template -success::type>::type> -ok(T&& v) -{ - return success< - typename std::remove_cv::type>::type - >(std::forward(v)); -} -template -failure::type>::type> -err(T&& v) -{ - return failure< - typename std::remove_cv::type>::type - >(std::forward(v)); -} - -inline success ok(const char* literal) -{ - return success(std::string(literal)); -} -inline failure err(const char* literal) -{ - return failure(std::string(literal)); -} - - -template -struct result -{ - using value_type = T; - using error_type = E; - using success_type = success; - using failure_type = failure; - - result(const success_type& s): is_ok_(true) - { - auto tmp = ::new(std::addressof(this->succ)) success_type(s); - assert(tmp == std::addressof(this->succ)); - (void)tmp; - } - result(const failure_type& f): is_ok_(false) - { - auto tmp = ::new(std::addressof(this->fail)) failure_type(f); - assert(tmp == std::addressof(this->fail)); - (void)tmp; - } - result(success_type&& s): is_ok_(true) - { - auto tmp = ::new(std::addressof(this->succ)) success_type(std::move(s)); - assert(tmp == std::addressof(this->succ)); - (void)tmp; - } - result(failure_type&& f): is_ok_(false) - { - auto tmp = ::new(std::addressof(this->fail)) failure_type(std::move(f)); - assert(tmp == std::addressof(this->fail)); - (void)tmp; - } - - template - result(const success& s): is_ok_(true) - { - auto tmp = ::new(std::addressof(this->succ)) success_type(s.value); - assert(tmp == std::addressof(this->succ)); - (void)tmp; - } - template - result(const failure& f): is_ok_(false) - { - auto tmp = ::new(std::addressof(this->fail)) failure_type(f.value); - assert(tmp == std::addressof(this->fail)); - (void)tmp; - } - template - result(success&& s): is_ok_(true) - { - auto tmp = ::new(std::addressof(this->succ)) success_type(std::move(s.value)); - assert(tmp == std::addressof(this->succ)); - (void)tmp; - } - template - result(failure&& f): is_ok_(false) - { - auto tmp = ::new(std::addressof(this->fail)) failure_type(std::move(f.value)); - assert(tmp == std::addressof(this->fail)); - (void)tmp; - } - - result& operator=(const success_type& s) - { - this->cleanup(); - this->is_ok_ = true; - auto tmp = ::new(std::addressof(this->succ)) success_type(s); - assert(tmp == std::addressof(this->succ)); - (void)tmp; - return *this; - } - result& operator=(const failure_type& f) - { - this->cleanup(); - this->is_ok_ = false; - auto tmp = ::new(std::addressof(this->fail)) failure_type(f); - assert(tmp == std::addressof(this->fail)); - (void)tmp; - return *this; - } - result& operator=(success_type&& s) - { - this->cleanup(); - this->is_ok_ = true; - auto tmp = ::new(std::addressof(this->succ)) success_type(std::move(s)); - assert(tmp == std::addressof(this->succ)); - (void)tmp; - return *this; - } - result& operator=(failure_type&& f) - { - this->cleanup(); - this->is_ok_ = false; - auto tmp = ::new(std::addressof(this->fail)) failure_type(std::move(f)); - assert(tmp == std::addressof(this->fail)); - (void)tmp; - return *this; - } - - template - result& operator=(const success& s) - { - this->cleanup(); - this->is_ok_ = true; - auto tmp = ::new(std::addressof(this->succ)) success_type(s.value); - assert(tmp == std::addressof(this->succ)); - (void)tmp; - return *this; - } - template - result& operator=(const failure& f) - { - this->cleanup(); - this->is_ok_ = false; - auto tmp = ::new(std::addressof(this->fail)) failure_type(f.value); - assert(tmp == std::addressof(this->fail)); - (void)tmp; - return *this; - } - template - result& operator=(success&& s) - { - this->cleanup(); - this->is_ok_ = true; - auto tmp = ::new(std::addressof(this->succ)) success_type(std::move(s.value)); - assert(tmp == std::addressof(this->succ)); - (void)tmp; - return *this; - } - template - result& operator=(failure&& f) - { - this->cleanup(); - this->is_ok_ = false; - auto tmp = ::new(std::addressof(this->fail)) failure_type(std::move(f.value)); - assert(tmp == std::addressof(this->fail)); - (void)tmp; - return *this; - } - - ~result() noexcept {this->cleanup();} - - result(const result& other): is_ok_(other.is_ok()) - { - if(other.is_ok()) - { - auto tmp = ::new(std::addressof(this->succ)) success_type(other.as_ok()); - assert(tmp == std::addressof(this->succ)); - (void)tmp; - } - else - { - auto tmp = ::new(std::addressof(this->fail)) failure_type(other.as_err()); - assert(tmp == std::addressof(this->fail)); - (void)tmp; - } - } - result(result&& other): is_ok_(other.is_ok()) - { - if(other.is_ok()) - { - auto tmp = ::new(std::addressof(this->succ)) success_type(std::move(other.as_ok())); - assert(tmp == std::addressof(this->succ)); - (void)tmp; - } - else - { - auto tmp = ::new(std::addressof(this->fail)) failure_type(std::move(other.as_err())); - assert(tmp == std::addressof(this->fail)); - (void)tmp; - } - } - - template - result(const result& other): is_ok_(other.is_ok()) - { - if(other.is_ok()) - { - auto tmp = ::new(std::addressof(this->succ)) success_type(other.as_ok()); - assert(tmp == std::addressof(this->succ)); - (void)tmp; - } - else - { - auto tmp = ::new(std::addressof(this->fail)) failure_type(other.as_err()); - assert(tmp == std::addressof(this->fail)); - (void)tmp; - } - } - template - result(result&& other): is_ok_(other.is_ok()) - { - if(other.is_ok()) - { - auto tmp = ::new(std::addressof(this->succ)) success_type(std::move(other.as_ok())); - assert(tmp == std::addressof(this->succ)); - (void)tmp; - } - else - { - auto tmp = ::new(std::addressof(this->fail)) failure_type(std::move(other.as_err())); - assert(tmp == std::addressof(this->fail)); - (void)tmp; - } - } - - result& operator=(const result& other) - { - this->cleanup(); - if(other.is_ok()) - { - auto tmp = ::new(std::addressof(this->succ)) success_type(other.as_ok()); - assert(tmp == std::addressof(this->succ)); - (void)tmp; - } - else - { - auto tmp = ::new(std::addressof(this->fail)) failure_type(other.as_err()); - assert(tmp == std::addressof(this->fail)); - (void)tmp; - } - is_ok_ = other.is_ok(); - return *this; - } - result& operator=(result&& other) - { - this->cleanup(); - if(other.is_ok()) - { - auto tmp = ::new(std::addressof(this->succ)) success_type(std::move(other.as_ok())); - assert(tmp == std::addressof(this->succ)); - (void)tmp; - } - else - { - auto tmp = ::new(std::addressof(this->fail)) failure_type(std::move(other.as_err())); - assert(tmp == std::addressof(this->fail)); - (void)tmp; - } - is_ok_ = other.is_ok(); - return *this; - } - - template - result& operator=(const result& other) - { - this->cleanup(); - if(other.is_ok()) - { - auto tmp = ::new(std::addressof(this->succ)) success_type(other.as_ok()); - assert(tmp == std::addressof(this->succ)); - (void)tmp; - } - else - { - auto tmp = ::new(std::addressof(this->fail)) failure_type(other.as_err()); - assert(tmp == std::addressof(this->fail)); - (void)tmp; - } - is_ok_ = other.is_ok(); - return *this; - } - template - result& operator=(result&& other) - { - this->cleanup(); - if(other.is_ok()) - { - auto tmp = ::new(std::addressof(this->succ)) success_type(std::move(other.as_ok())); - assert(tmp == std::addressof(this->succ)); - (void)tmp; - } - else - { - auto tmp = ::new(std::addressof(this->fail)) failure_type(std::move(other.as_err())); - assert(tmp == std::addressof(this->fail)); - (void)tmp; - } - is_ok_ = other.is_ok(); - return *this; - } - - bool is_ok() const noexcept {return is_ok_;} - bool is_err() const noexcept {return !is_ok_;} - - operator bool() const noexcept {return is_ok_;} - - value_type& unwrap() & - { - if(is_err()) - { - throw std::runtime_error("toml::result: bad unwrap: " + - format_error(this->as_err())); - } - return this->succ.value; - } - value_type const& unwrap() const& - { - if(is_err()) - { - throw std::runtime_error("toml::result: bad unwrap: " + - format_error(this->as_err())); - } - return this->succ.value; - } - value_type&& unwrap() && - { - if(is_err()) - { - throw std::runtime_error("toml::result: bad unwrap: " + - format_error(this->as_err())); - } - return std::move(this->succ.value); - } - - value_type& unwrap_or(value_type& opt) & - { - if(is_err()) {return opt;} - return this->succ.value; - } - value_type const& unwrap_or(value_type const& opt) const& - { - if(is_err()) {return opt;} - return this->succ.value; - } - value_type unwrap_or(value_type opt) && - { - if(is_err()) {return opt;} - return this->succ.value; - } - - error_type& unwrap_err() & - { - if(is_ok()) {throw std::runtime_error("toml::result: bad unwrap_err");} - return this->fail.value; - } - error_type const& unwrap_err() const& - { - if(is_ok()) {throw std::runtime_error("toml::result: bad unwrap_err");} - return this->fail.value; - } - error_type&& unwrap_err() && - { - if(is_ok()) {throw std::runtime_error("toml::result: bad unwrap_err");} - return std::move(this->fail.value); - } - - value_type& as_ok() & noexcept {return this->succ.value;} - value_type const& as_ok() const& noexcept {return this->succ.value;} - value_type&& as_ok() && noexcept {return std::move(this->succ.value);} - - error_type& as_err() & noexcept {return this->fail.value;} - error_type const& as_err() const& noexcept {return this->fail.value;} - error_type&& as_err() && noexcept {return std::move(this->fail.value);} - - - // prerequisities - // F: T -> U - // retval: result - template - result, error_type> - map(F&& f) & - { - if(this->is_ok()){return ok(f(this->as_ok()));} - return err(this->as_err()); - } - template - result, error_type> - map(F&& f) const& - { - if(this->is_ok()){return ok(f(this->as_ok()));} - return err(this->as_err()); - } - template - result, error_type> - map(F&& f) && - { - if(this->is_ok()){return ok(f(std::move(this->as_ok())));} - return err(std::move(this->as_err())); - } - - // prerequisities - // F: E -> F - // retval: result - template - result> - map_err(F&& f) & - { - if(this->is_err()){return err(f(this->as_err()));} - return ok(this->as_ok()); - } - template - result> - map_err(F&& f) const& - { - if(this->is_err()){return err(f(this->as_err()));} - return ok(this->as_ok()); - } - template - result> - map_err(F&& f) && - { - if(this->is_err()){return err(f(std::move(this->as_err())));} - return ok(std::move(this->as_ok())); - } - - // prerequisities - // F: T -> U - // retval: U - template - detail::return_type_of_t - map_or_else(F&& f, U&& opt) & - { - if(this->is_err()){return std::forward(opt);} - return f(this->as_ok()); - } - template - detail::return_type_of_t - map_or_else(F&& f, U&& opt) const& - { - if(this->is_err()){return std::forward(opt);} - return f(this->as_ok()); - } - template - detail::return_type_of_t - map_or_else(F&& f, U&& opt) && - { - if(this->is_err()){return std::forward(opt);} - return f(std::move(this->as_ok())); - } - - // prerequisities - // F: E -> U - // retval: U - template - detail::return_type_of_t - map_err_or_else(F&& f, U&& opt) & - { - if(this->is_ok()){return std::forward(opt);} - return f(this->as_err()); - } - template - detail::return_type_of_t - map_err_or_else(F&& f, U&& opt) const& - { - if(this->is_ok()){return std::forward(opt);} - return f(this->as_err()); - } - template - detail::return_type_of_t - map_err_or_else(F&& f, U&& opt) && - { - if(this->is_ok()){return std::forward(opt);} - return f(std::move(this->as_err())); - } - - // prerequisities: - // F: func T -> U - // toml::err(error_type) should be convertible to U. - // normally, type U is another result and E is convertible to F - template - detail::return_type_of_t - and_then(F&& f) & - { - if(this->is_ok()){return f(this->as_ok());} - return err(this->as_err()); - } - template - detail::return_type_of_t - and_then(F&& f) const& - { - if(this->is_ok()){return f(this->as_ok());} - return err(this->as_err()); - } - template - detail::return_type_of_t - and_then(F&& f) && - { - if(this->is_ok()){return f(std::move(this->as_ok()));} - return err(std::move(this->as_err())); - } - - // prerequisities: - // F: func E -> U - // toml::ok(value_type) should be convertible to U. - // normally, type U is another result and T is convertible to S - template - detail::return_type_of_t - or_else(F&& f) & - { - if(this->is_err()){return f(this->as_err());} - return ok(this->as_ok()); - } - template - detail::return_type_of_t - or_else(F&& f) const& - { - if(this->is_err()){return f(this->as_err());} - return ok(this->as_ok()); - } - template - detail::return_type_of_t - or_else(F&& f) && - { - if(this->is_err()){return f(std::move(this->as_err()));} - return ok(std::move(this->as_ok())); - } - - // if *this is error, returns *this. otherwise, returns other. - result and_other(const result& other) const& - { - return this->is_err() ? *this : other; - } - result and_other(result&& other) && - { - return this->is_err() ? std::move(*this) : std::move(other); - } - - // if *this is okay, returns *this. otherwise, returns other. - result or_other(const result& other) const& - { - return this->is_ok() ? *this : other; - } - result or_other(result&& other) && - { - return this->is_ok() ? std::move(*this) : std::move(other); - } - - void swap(result& other) - { - result tmp(std::move(*this)); - *this = std::move(other); - other = std::move(tmp); - return ; - } - - private: - - static std::string format_error(std::exception const& excpt) - { - return std::string(excpt.what()); - } - template::value, std::nullptr_t>::type = nullptr> - static std::string format_error(U const& others) - { - std::ostringstream oss; oss << others; - return oss.str(); - } - - void cleanup() noexcept - { - if(this->is_ok_) {this->succ.~success_type();} - else {this->fail.~failure_type();} - return; - } - - private: - - bool is_ok_; - union - { - success_type succ; - failure_type fail; - }; -}; - -template -void swap(result& lhs, result& rhs) -{ - lhs.swap(rhs); - return; -} - -// this might be confusing because it eagerly evaluated, while in the other -// cases operator && and || are short-circuited. -// -// template -// inline result -// operator&&(const result& lhs, const result& rhs) noexcept -// { -// return lhs.is_ok() ? rhs : lhs; -// } -// -// template -// inline result -// operator||(const result& lhs, const result& rhs) noexcept -// { -// return lhs.is_ok() ? lhs : rhs; -// } - -// ---------------------------------------------------------------------------- -// re-use result as a optional with none_t - -namespace detail -{ -struct none_t {}; -inline bool operator==(const none_t&, const none_t&) noexcept {return true;} -inline bool operator!=(const none_t&, const none_t&) noexcept {return false;} -inline bool operator< (const none_t&, const none_t&) noexcept {return false;} -inline bool operator<=(const none_t&, const none_t&) noexcept {return true;} -inline bool operator> (const none_t&, const none_t&) noexcept {return false;} -inline bool operator>=(const none_t&, const none_t&) noexcept {return true;} -template -std::basic_ostream& -operator<<(std::basic_ostream& os, const none_t&) -{ - os << "none"; - return os; -} -inline failure none() noexcept {return failure{none_t{}};} -} // detail -} // toml11 -#endif// TOML11_RESULT_H diff --git a/libraries/toml11/include/toml/serializer.hpp b/libraries/toml11/include/toml/serializer.hpp deleted file mode 100644 index 77aef589..00000000 --- a/libraries/toml11/include/toml/serializer.hpp +++ /dev/null @@ -1,853 +0,0 @@ -// Copyright Toru Niina 2019. -// Distributed under the MIT License. -#ifndef TOML11_SERIALIZER_HPP -#define TOML11_SERIALIZER_HPP -#include - -#include - -#include "lexer.hpp" -#include "value.hpp" - -namespace toml -{ - -// This function serialize a key. It checks a string is a bare key and -// escapes special characters if the string is not compatible to a bare key. -// ```cpp -// std::string k("non.bare.key"); // the key itself includes `.`s. -// std::string formatted = toml::format_key(k); -// assert(formatted == "\"non.bare.key\""); -// ``` -// -// This function is exposed to make it easy to write a user-defined serializer. -// Since toml restricts characters available in a bare key, generally a string -// should be escaped. But checking whether a string needs to be surrounded by -// a `"` and escaping some special character is boring. -template -std::basic_string -format_key(const std::basic_string& key) -{ - // check the key can be a bare (unquoted) key - detail::location loc(key, std::vector(key.begin(), key.end())); - detail::lex_unquoted_key::invoke(loc); - if(loc.iter() == loc.end()) - { - return key; // all the tokens are consumed. the key is unquoted-key. - } - - //if it includes special characters, then format it in a "quoted" key. - std::basic_string serialized("\""); - for(const char c : key) - { - switch(c) - { - case '\\': {serialized += "\\\\"; break;} - case '\"': {serialized += "\\\""; break;} - case '\b': {serialized += "\\b"; break;} - case '\t': {serialized += "\\t"; break;} - case '\f': {serialized += "\\f"; break;} - case '\n': {serialized += "\\n"; break;} - case '\r': {serialized += "\\r"; break;} - default : {serialized += c; break;} - } - } - serialized += "\""; - return serialized; -} - -template -std::basic_string -format_keys(const std::vector>& keys) -{ - std::basic_string serialized; - if(keys.empty()) {return serialized;} - - for(const auto& ky : keys) - { - serialized += format_key(ky); - serialized += charT('.'); - } - serialized.pop_back(); // remove the last dot '.' - return serialized; -} - -template -struct serializer -{ - static_assert(detail::is_basic_value::value, - "toml::serializer is for toml::value and its variants, " - "toml::basic_value<...>."); - - using value_type = Value; - using key_type = typename value_type::key_type ; - using comment_type = typename value_type::comment_type ; - using boolean_type = typename value_type::boolean_type ; - using integer_type = typename value_type::integer_type ; - using floating_type = typename value_type::floating_type ; - using string_type = typename value_type::string_type ; - using local_time_type = typename value_type::local_time_type ; - using local_date_type = typename value_type::local_date_type ; - using local_datetime_type = typename value_type::local_datetime_type ; - using offset_datetime_type = typename value_type::offset_datetime_type; - using array_type = typename value_type::array_type ; - using table_type = typename value_type::table_type ; - - serializer(const std::size_t w = 80u, - const int float_prec = std::numeric_limits::max_digits10, - const bool can_be_inlined = false, - const bool no_comment = false, - std::vector ks = {}, - const bool value_has_comment = false) - : can_be_inlined_(can_be_inlined), no_comment_(no_comment), - value_has_comment_(value_has_comment && !no_comment), - float_prec_(float_prec), width_(w), keys_(std::move(ks)) - {} - ~serializer() = default; - - std::string operator()(const boolean_type& b) const - { - return b ? "true" : "false"; - } - std::string operator()(const integer_type i) const - { - return std::to_string(i); - } - std::string operator()(const floating_type f) const - { - const auto fmt = "%.*g"; - const auto bsz = std::snprintf(nullptr, 0, fmt, this->float_prec_, f); - // +1 for null character(\0) - std::vector buf(static_cast(bsz + 1), '\0'); - std::snprintf(buf.data(), buf.size(), fmt, this->float_prec_, f); - - std::string token(buf.begin(), std::prev(buf.end())); - if(!token.empty() && token.back() == '.') // 1. => 1.0 - { - token += '0'; - } - - const auto e = std::find_if( - token.cbegin(), token.cend(), [](const char c) noexcept -> bool { - return c == 'e' || c == 'E'; - }); - const auto has_exponent = (token.cend() != e); - const auto has_fraction = (token.cend() != std::find( - token.cbegin(), token.cend(), '.')); - - if(!has_exponent && !has_fraction) - { - // the resulting value does not have any float specific part! - token += ".0"; - } - return token; - } - std::string operator()(const string_type& s) const - { - if(s.kind == string_t::basic) - { - if(std::find(s.str.cbegin(), s.str.cend(), '\n') != s.str.cend() || - std::find(s.str.cbegin(), s.str.cend(), '\"') != s.str.cend()) - { - // if linefeed or double-quote is contained, - // make it multiline basic string. - const auto escaped = this->escape_ml_basic_string(s.str); - std::string open("\"\"\""); - std::string close("\"\"\""); - if(escaped.find('\n') != std::string::npos || - this->width_ < escaped.size() + 6) - { - // if the string body contains newline or is enough long, - // add newlines after and before delimiters. - open += "\n"; - close = std::string("\\\n") + close; - } - return open + escaped + close; - } - - // no linefeed. try to make it oneline-string. - std::string oneline = this->escape_basic_string(s.str); - if(oneline.size() + 2 < width_ || width_ < 2) - { - const std::string quote("\""); - return quote + oneline + quote; - } - - // the line is too long compared to the specified width. - // split it into multiple lines. - std::string token("\"\"\"\n"); - while(!oneline.empty()) - { - if(oneline.size() < width_) - { - token += oneline; - oneline.clear(); - } - else if(oneline.at(width_-2) == '\\') - { - token += oneline.substr(0, width_-2); - token += "\\\n"; - oneline.erase(0, width_-2); - } - else - { - token += oneline.substr(0, width_-1); - token += "\\\n"; - oneline.erase(0, width_-1); - } - } - return token + std::string("\\\n\"\"\""); - } - else // the string `s` is literal-string. - { - if(std::find(s.str.cbegin(), s.str.cend(), '\n') != s.str.cend() || - std::find(s.str.cbegin(), s.str.cend(), '\'') != s.str.cend() ) - { - std::string open("'''"); - if(this->width_ + 6 < s.str.size()) - { - open += '\n'; // the first newline is ignored by TOML spec - } - const std::string close("'''"); - return open + s.str + close; - } - else - { - const std::string quote("'"); - return quote + s.str + quote; - } - } - } - - std::string operator()(const local_date_type& d) const - { - std::ostringstream oss; - oss << d; - return oss.str(); - } - std::string operator()(const local_time_type& t) const - { - std::ostringstream oss; - oss << t; - return oss.str(); - } - std::string operator()(const local_datetime_type& dt) const - { - std::ostringstream oss; - oss << dt; - return oss.str(); - } - std::string operator()(const offset_datetime_type& odt) const - { - std::ostringstream oss; - oss << odt; - return oss.str(); - } - - std::string operator()(const array_type& v) const - { - if(v.empty()) - { - return std::string("[]"); - } - if(this->is_array_of_tables(v)) - { - return make_array_of_tables(v); - } - - // not an array of tables. normal array. - // first, try to make it inline if none of the elements have a comment. - if( ! this->has_comment_inside(v)) - { - const auto inl = this->make_inline_array(v); - if(inl.size() < this->width_ && - std::find(inl.cbegin(), inl.cend(), '\n') == inl.cend()) - { - return inl; - } - } - - // if the length exceeds this->width_, print multiline array. - // key = [ - // # ... - // 42, - // ... - // ] - std::string token; - std::string current_line; - token += "[\n"; - for(const auto& item : v) - { - if( ! item.comments().empty() && !no_comment_) - { - // if comment exists, the element must be the only element in the line. - // e.g. the following is not allowed. - // ```toml - // array = [ - // # comment for what? - // 1, 2, 3, 4, 5 - // ] - // ``` - if(!current_line.empty()) - { - if(current_line.back() != '\n') - { - current_line += '\n'; - } - token += current_line; - current_line.clear(); - } - for(const auto& c : item.comments()) - { - token += '#'; - token += c; - token += '\n'; - } - token += toml::visit(*this, item); - if(!token.empty() && token.back() == '\n') {token.pop_back();} - token += ",\n"; - continue; - } - std::string next_elem; - next_elem += toml::visit(*this, item); - - // comma before newline. - if(!next_elem.empty() && next_elem.back() == '\n') {next_elem.pop_back();} - - // if current line does not exceeds the width limit, continue. - if(current_line.size() + next_elem.size() + 1 < this->width_) - { - current_line += next_elem; - current_line += ','; - } - else if(current_line.empty()) - { - // if current line was empty, force put the next_elem because - // next_elem is not splittable - token += next_elem; - token += ",\n"; - // current_line is kept empty - } - else // reset current_line - { - assert(current_line.back() == ','); - token += current_line; - token += '\n'; - current_line = next_elem; - current_line += ','; - } - } - if(!current_line.empty()) - { - if(!current_line.empty() && current_line.back() != '\n') - { - current_line += '\n'; - } - token += current_line; - } - token += "]\n"; - return token; - } - - // templatize for any table-like container - std::string operator()(const table_type& v) const - { - // if an element has a comment, then it can't be inlined. - // table = {# how can we write a comment for this? key = "value"} - if(this->can_be_inlined_ && !(this->has_comment_inside(v))) - { - std::string token; - if(!this->keys_.empty()) - { - token += format_key(this->keys_.back()); - token += " = "; - } - token += this->make_inline_table(v); - if(token.size() < this->width_ && - token.end() == std::find(token.begin(), token.end(), '\n')) - { - return token; - } - } - - std::string token; - if(!keys_.empty()) - { - token += '['; - token += format_keys(keys_); - token += "]\n"; - } - token += this->make_multiline_table(v); - return token; - } - - private: - - std::string escape_basic_string(const std::string& s) const - { - //XXX assuming `s` is a valid utf-8 sequence. - std::string retval; - for(const char c : s) - { - switch(c) - { - case '\\': {retval += "\\\\"; break;} - case '\"': {retval += "\\\""; break;} - case '\b': {retval += "\\b"; break;} - case '\t': {retval += "\\t"; break;} - case '\f': {retval += "\\f"; break;} - case '\n': {retval += "\\n"; break;} - case '\r': {retval += "\\r"; break;} - default : {retval += c; break;} - } - } - return retval; - } - - std::string escape_ml_basic_string(const std::string& s) const - { - std::string retval; - for(auto i=s.cbegin(), e=s.cend(); i!=e; ++i) - { - switch(*i) - { - case '\\': {retval += "\\\\"; break;} - // One or two consecutive "s are allowed. - // Later we will check there are no three consecutive "s. - // case '\"': {retval += "\\\""; break;} - case '\b': {retval += "\\b"; break;} - case '\t': {retval += "\\t"; break;} - case '\f': {retval += "\\f"; break;} - case '\n': {retval += "\n"; break;} - case '\r': - { - if(std::next(i) != e && *std::next(i) == '\n') - { - retval += "\r\n"; - ++i; - } - else - { - retval += "\\r"; - } - break; - } - default: {retval += *i; break;} - } - } - // Only 1 or 2 consecutive `"`s are allowed in multiline basic string. - // 3 consecutive `"`s are considered as a closing delimiter. - // We need to check if there are 3 or more consecutive `"`s and insert - // backslash to break them down into several short `"`s like the `str6` - // in the following example. - // ```toml - // str4 = """Here are two quotation marks: "". Simple enough.""" - // # str5 = """Here are three quotation marks: """.""" # INVALID - // str5 = """Here are three quotation marks: ""\".""" - // str6 = """Here are fifteen quotation marks: ""\"""\"""\"""\"""\".""" - // ``` - auto found_3_quotes = retval.find("\"\"\""); - while(found_3_quotes != std::string::npos) - { - retval.replace(found_3_quotes, 3, "\"\"\\\""); - found_3_quotes = retval.find("\"\"\""); - } - return retval; - } - - // if an element of a table or an array has a comment, it cannot be inlined. - bool has_comment_inside(const array_type& a) const noexcept - { - // if no_comment is set, comments would not be written. - if(this->no_comment_) {return false;} - - for(const auto& v : a) - { - if(!v.comments().empty()) {return true;} - } - return false; - } - bool has_comment_inside(const table_type& t) const noexcept - { - // if no_comment is set, comments would not be written. - if(this->no_comment_) {return false;} - - for(const auto& kv : t) - { - if(!kv.second.comments().empty()) {return true;} - } - return false; - } - - std::string make_inline_array(const array_type& v) const - { - assert(!has_comment_inside(v)); - std::string token; - token += '['; - bool is_first = true; - for(const auto& item : v) - { - if(is_first) {is_first = false;} else {token += ',';} - token += visit(serializer( - (std::numeric_limits::max)(), this->float_prec_, - /* inlined */ true, /*no comment*/ false, /*keys*/ {}, - /*has_comment*/ !item.comments().empty()), item); - } - token += ']'; - return token; - } - - std::string make_inline_table(const table_type& v) const - { - assert(!has_comment_inside(v)); - assert(this->can_be_inlined_); - std::string token; - token += '{'; - bool is_first = true; - for(const auto& kv : v) - { - // in inline tables, trailing comma is not allowed (toml-lang #569). - if(is_first) {is_first = false;} else {token += ',';} - token += format_key(kv.first); - token += '='; - token += visit(serializer( - (std::numeric_limits::max)(), this->float_prec_, - /* inlined */ true, /*no comment*/ false, /*keys*/ {}, - /*has_comment*/ !kv.second.comments().empty()), kv.second); - } - token += '}'; - return token; - } - - std::string make_multiline_table(const table_type& v) const - { - std::string token; - - // print non-table elements first. - // ```toml - // [foo] # a table we're writing now here - // key = "value" # <- non-table element, "key" - // # ... - // [foo.bar] # <- table element, "bar" - // ``` - // because after printing [foo.bar], the remaining non-table values will - // be assigned into [foo.bar], not [foo]. Those values should be printed - // earlier. - for(const auto& kv : v) - { - if(kv.second.is_table() || is_array_of_tables(kv.second)) - { - continue; - } - - token += write_comments(kv.second); - - const auto key_and_sep = format_key(kv.first) + " = "; - const auto residual_width = (this->width_ > key_and_sep.size()) ? - this->width_ - key_and_sep.size() : 0; - token += key_and_sep; - token += visit(serializer(residual_width, this->float_prec_, - /*can be inlined*/ true, /*no comment*/ false, /*keys*/ {}, - /*has_comment*/ !kv.second.comments().empty()), kv.second); - - if(token.back() != '\n') - { - token += '\n'; - } - } - - // normal tables / array of tables - - // after multiline table appeared, the other tables cannot be inline - // because the table would be assigned into the table. - // [foo] - // ... - // bar = {...} # <- bar will be a member of [foo]. - bool multiline_table_printed = false; - for(const auto& kv : v) - { - if(!kv.second.is_table() && !is_array_of_tables(kv.second)) - { - continue; // other stuff are already serialized. skip them. - } - - std::vector ks(this->keys_); - ks.push_back(kv.first); - - auto tmp = visit(serializer(this->width_, this->float_prec_, - !multiline_table_printed, this->no_comment_, ks, - /*has_comment*/ !kv.second.comments().empty()), kv.second); - - // If it is the first time to print a multi-line table, it would be - // helpful to separate normal key-value pair and subtables by a - // newline. - // (this checks if the current key-value pair contains newlines. - // but it is not perfect because multi-line string can also contain - // a newline. in such a case, an empty line will be written) TODO - if((!multiline_table_printed) && - std::find(tmp.cbegin(), tmp.cend(), '\n') != tmp.cend()) - { - multiline_table_printed = true; - token += '\n'; // separate key-value pairs and subtables - - token += write_comments(kv.second); - token += tmp; - - // care about recursive tables (all tables in each level prints - // newline and there will be a full of newlines) - if(tmp.substr(tmp.size() - 2, 2) != "\n\n" && - tmp.substr(tmp.size() - 4, 4) != "\r\n\r\n" ) - { - token += '\n'; - } - } - else - { - token += write_comments(kv.second); - token += tmp; - token += '\n'; - } - } - return token; - } - - std::string make_array_of_tables(const array_type& v) const - { - // if it's not inlined, we need to add `[[table.key]]`. - // but if it can be inlined, we can format it as the following. - // ``` - // table.key = [ - // {...}, - // # comment - // {...}, - // ] - // ``` - // This function checks if inlinization is possible or not, and then - // format the array-of-tables in a proper way. - // - // Note about comments: - // - // If the array itself has a comment (value_has_comment_ == true), we - // should try to make it inline. - // ```toml - // # comment about array - // array = [ - // # comment about table element - // {of = "table"} - // ] - // ``` - // If it is formatted as a multiline table, the two comments becomes - // indistinguishable. - // ```toml - // # comment about array - // # comment about table element - // [[array]] - // of = "table" - // ``` - // So we need to try to make it inline, and it force-inlines regardless - // of the line width limit. - // It may fail if the element of a table has comment. In that case, - // the array-of-tables will be formatted as a multiline table. - if(this->can_be_inlined_ || this->value_has_comment_) - { - std::string token; - if(!keys_.empty()) - { - token += format_key(keys_.back()); - token += " = "; - } - - bool failed = false; - token += "[\n"; - for(const auto& item : v) - { - // if an element of the table has a comment, the table - // cannot be inlined. - if(this->has_comment_inside(item.as_table())) - { - failed = true; - break; - } - // write comments for the table itself - token += write_comments(item); - - const auto t = this->make_inline_table(item.as_table()); - - if(t.size() + 1 > width_ || // +1 for the last comma {...}, - std::find(t.cbegin(), t.cend(), '\n') != t.cend()) - { - // if the value itself has a comment, ignore the line width limit - if( ! this->value_has_comment_) - { - failed = true; - break; - } - } - token += t; - token += ",\n"; - } - - if( ! failed) - { - token += "]\n"; - return token; - } - // if failed, serialize them as [[array.of.tables]]. - } - - std::string token; - for(const auto& item : v) - { - token += write_comments(item); - token += "[["; - token += format_keys(keys_); - token += "]]\n"; - token += this->make_multiline_table(item.as_table()); - } - return token; - } - - std::string write_comments(const value_type& v) const - { - std::string retval; - if(this->no_comment_) {return retval;} - - for(const auto& c : v.comments()) - { - retval += '#'; - retval += c; - retval += '\n'; - } - return retval; - } - - bool is_array_of_tables(const value_type& v) const - { - if(!v.is_array() || v.as_array().empty()) {return false;} - return is_array_of_tables(v.as_array()); - } - bool is_array_of_tables(const array_type& v) const - { - // Since TOML v0.5.0, heterogeneous arrays are allowed. So we need to - // check all the element in an array to check if the array is an array - // of tables. - return std::all_of(v.begin(), v.end(), [](const value_type& elem) { - return elem.is_table(); - }); - } - - private: - - bool can_be_inlined_; - bool no_comment_; - bool value_has_comment_; - int float_prec_; - std::size_t width_; - std::vector keys_; -}; - -template class M, template class V> -std::string -format(const basic_value& v, std::size_t w = 80u, - int fprec = std::numeric_limits::max_digits10, - bool no_comment = false, bool force_inline = false) -{ - using value_type = basic_value; - // if value is a table, it is considered to be a root object. - // the root object can't be an inline table. - if(v.is_table()) - { - std::ostringstream oss; - if(!v.comments().empty()) - { - oss << v.comments(); - oss << '\n'; // to split the file comment from the first element - } - const auto serialized = visit(serializer(w, fprec, no_comment, false), v); - oss << serialized; - return oss.str(); - } - return visit(serializer(w, fprec, force_inline), v); -} - -namespace detail -{ -template -int comment_index(std::basic_ostream&) -{ - static const int index = std::ios_base::xalloc(); - return index; -} -} // detail - -template -std::basic_ostream& -nocomment(std::basic_ostream& os) -{ - // by default, it is zero. and by defalut, it shows comments. - os.iword(detail::comment_index(os)) = 1; - return os; -} - -template -std::basic_ostream& -showcomment(std::basic_ostream& os) -{ - // by default, it is zero. and by defalut, it shows comments. - os.iword(detail::comment_index(os)) = 0; - return os; -} - -template class M, template class V> -std::basic_ostream& -operator<<(std::basic_ostream& os, const basic_value& v) -{ - using value_type = basic_value; - - // get status of std::setw(). - const auto w = static_cast(os.width()); - const int fprec = static_cast(os.precision()); - os.width(0); - - // by defualt, iword is initialized byl 0. And by default, toml11 outputs - // comments. So `0` means showcomment. 1 means nocommnet. - const bool no_comment = (1 == os.iword(detail::comment_index(os))); - - if(!no_comment && v.is_table() && !v.comments().empty()) - { - os << v.comments(); - os << '\n'; // to split the file comment from the first element - } - // the root object can't be an inline table. so pass `false`. - const auto serialized = visit(serializer(w, fprec, no_comment, false), v); - os << serialized; - - // if v is a non-table value, and has only one comment, then - // put a comment just after a value. in the following way. - // - // ```toml - // key = "value" # comment. - // ``` - // - // Since the top-level toml object is a table, one who want to put a - // non-table toml value must use this in a following way. - // - // ```cpp - // toml::value v; - // std::cout << "user-defined-key = " << v << std::endl; - // ``` - // - // In this case, it is impossible to put comments before key-value pair. - // The only way to preserve comments is to put all of them after a value. - if(!no_comment && !v.is_table() && !v.comments().empty()) - { - os << " #"; - for(const auto& c : v.comments()) {os << c;} - } - return os; -} - -} // toml -#endif// TOML11_SERIALIZER_HPP diff --git a/libraries/toml11/include/toml/source_location.hpp b/libraries/toml11/include/toml/source_location.hpp deleted file mode 100644 index fa175b5b..00000000 --- a/libraries/toml11/include/toml/source_location.hpp +++ /dev/null @@ -1,233 +0,0 @@ -// Copyright Toru Niina 2019. -// Distributed under the MIT License. -#ifndef TOML11_SOURCE_LOCATION_HPP -#define TOML11_SOURCE_LOCATION_HPP -#include -#include - -#include "region.hpp" - -namespace toml -{ - -// A struct to contain location in a toml file. -// The interface imitates std::experimental::source_location, -// but not completely the same. -// -// It would be constructed by toml::value. It can be used to generate -// user-defined error messages. -// -// - std::uint_least32_t line() const noexcept -// - returns the line number where the region is on. -// - std::uint_least32_t column() const noexcept -// - returns the column number where the region starts. -// - std::uint_least32_t region() const noexcept -// - returns the size of the region. -// -// +-- line() +-- region of interest (region() == 9) -// v .---+---. -// 12 | value = "foo bar" -// ^ -// +-- column() -// -// - std::string const& file_name() const noexcept; -// - name of the file. -// - std::string const& line_str() const noexcept; -// - the whole line that contains the region of interest. -// -struct source_location -{ - public: - - source_location() - : line_num_(1), column_num_(1), region_size_(1), - file_name_("unknown file"), line_str_("") - {} - - explicit source_location(const detail::region_base* reg) - : line_num_(1), column_num_(1), region_size_(1), - file_name_("unknown file"), line_str_("") - { - if(reg) - { - if(reg->line_num() != detail::region_base().line_num()) - { - line_num_ = static_cast( - std::stoul(reg->line_num())); - } - column_num_ = static_cast(reg->before() + 1); - region_size_ = static_cast(reg->size()); - file_name_ = reg->name(); - line_str_ = reg->line(); - } - } - - explicit source_location(const detail::region& reg) - : line_num_(static_cast(std::stoul(reg.line_num()))), - column_num_(static_cast(reg.before() + 1)), - region_size_(static_cast(reg.size())), - file_name_(reg.name()), - line_str_ (reg.line()) - {} - explicit source_location(const detail::location& loc) - : line_num_(static_cast(std::stoul(loc.line_num()))), - column_num_(static_cast(loc.before() + 1)), - region_size_(static_cast(loc.size())), - file_name_(loc.name()), - line_str_ (loc.line()) - {} - - ~source_location() = default; - source_location(source_location const&) = default; - source_location(source_location &&) = default; - source_location& operator=(source_location const&) = default; - source_location& operator=(source_location &&) = default; - - std::uint_least32_t line() const noexcept {return line_num_;} - std::uint_least32_t column() const noexcept {return column_num_;} - std::uint_least32_t region() const noexcept {return region_size_;} - - std::string const& file_name() const noexcept {return file_name_;} - std::string const& line_str() const noexcept {return line_str_;} - - private: - - std::uint_least32_t line_num_; - std::uint_least32_t column_num_; - std::uint_least32_t region_size_; - std::string file_name_; - std::string line_str_; -}; - -namespace detail -{ - -// internal error message generation. -inline std::string format_underline(const std::string& message, - const std::vector>& loc_com, - const std::vector& helps = {}, - const bool colorize = TOML11_ERROR_MESSAGE_COLORIZED) -{ - std::size_t line_num_width = 0; - for(const auto& lc : loc_com) - { - std::uint_least32_t line = lc.first.line(); - std::size_t digit = 0; - while(line != 0) - { - line /= 10; - digit += 1; - } - line_num_width = (std::max)(line_num_width, digit); - } - // 1 is the minimum width - line_num_width = std::max(line_num_width, 1); - - std::ostringstream retval; - - if(colorize) - { - retval << color::colorize; // turn on ANSI color - } - - // XXX - // Here, before `colorize` support, it does not output `[error]` prefix - // automatically. So some user may output it manually and this change may - // duplicate the prefix. To avoid it, check the first 7 characters and - // if it is "[error]", it removes that part from the message shown. - if(message.size() > 7 && message.substr(0, 7) == "[error]") - { - retval << color::bold << color::red << "[error]" << color::reset - << color::bold << message.substr(7) << color::reset << '\n'; - } - else - { - retval << color::bold << color::red << "[error] " << color::reset - << color::bold << message << color::reset << '\n'; - } - - const auto format_one_location = [line_num_width] - (std::ostringstream& oss, - const source_location& loc, const std::string& comment) -> void - { - oss << ' ' << color::bold << color::blue - << std::setw(static_cast(line_num_width)) - << std::right << loc.line() << " | " << color::reset - << loc.line_str() << '\n'; - - oss << make_string(line_num_width + 1, ' ') - << color::bold << color::blue << " | " << color::reset - << make_string(loc.column()-1 /*1-origin*/, ' '); - - if(loc.region() == 1) - { - // invalid - // ^------ - oss << color::bold << color::red << "^---" << color::reset; - } - else - { - // invalid - // ~~~~~~~ - const auto underline_len = (std::min)( - static_cast(loc.region()), loc.line_str().size()); - oss << color::bold << color::red - << make_string(underline_len, '~') << color::reset; - } - oss << ' '; - oss << comment; - return; - }; - - assert(!loc_com.empty()); - - // --> example.toml - // | - retval << color::bold << color::blue << " --> " << color::reset - << loc_com.front().first.file_name() << '\n'; - retval << make_string(line_num_width + 1, ' ') - << color::bold << color::blue << " |\n" << color::reset; - // 1 | key value - // | ^--- missing = - format_one_location(retval, loc_com.front().first, loc_com.front().second); - - // process the rest of the locations - for(std::size_t i=1; i filename.toml" again - { - retval << color::bold << color::blue << " --> " << color::reset - << curr.first.file_name() << '\n'; - retval << make_string(line_num_width + 1, ' ') - << color::bold << color::blue << " |\n" << color::reset; - } - - format_one_location(retval, curr.first, curr.second); - } - - if(!helps.empty()) - { - retval << '\n'; - retval << make_string(line_num_width + 1, ' '); - retval << color::bold << color::blue << " |" << color::reset; - for(const auto& help : helps) - { - retval << color::bold << "\nHint: " << color::reset; - retval << help; - } - } - return retval.str(); -} - -} // detail -} // toml -#endif// TOML11_SOURCE_LOCATION_HPP diff --git a/libraries/toml11/include/toml/storage.hpp b/libraries/toml11/include/toml/storage.hpp deleted file mode 100644 index 202f9035..00000000 --- a/libraries/toml11/include/toml/storage.hpp +++ /dev/null @@ -1,43 +0,0 @@ -// Copyright Toru Niina 2017. -// Distributed under the MIT License. -#ifndef TOML11_STORAGE_HPP -#define TOML11_STORAGE_HPP -#include "utility.hpp" - -namespace toml -{ -namespace detail -{ - -// this contains pointer and deep-copy the content if copied. -// to avoid recursive pointer. -template -struct storage -{ - using value_type = T; - - explicit storage(value_type const& v): ptr(toml::make_unique(v)) {} - explicit storage(value_type&& v): ptr(toml::make_unique(std::move(v))) {} - ~storage() = default; - storage(const storage& rhs): ptr(toml::make_unique(*rhs.ptr)) {} - storage& operator=(const storage& rhs) - { - this->ptr = toml::make_unique(*rhs.ptr); - return *this; - } - storage(storage&&) = default; - storage& operator=(storage&&) = default; - - bool is_ok() const noexcept {return static_cast(ptr);} - - value_type& value() & noexcept {return *ptr;} - value_type const& value() const& noexcept {return *ptr;} - value_type&& value() && noexcept {return std::move(*ptr);} - - private: - std::unique_ptr ptr; -}; - -} // detail -} // toml -#endif// TOML11_STORAGE_HPP diff --git a/libraries/toml11/include/toml/string.hpp b/libraries/toml11/include/toml/string.hpp deleted file mode 100644 index a6ed0801..00000000 --- a/libraries/toml11/include/toml/string.hpp +++ /dev/null @@ -1,224 +0,0 @@ -// Copyright Toru Niina 2017. -// Distributed under the MIT License. -#ifndef TOML11_STRING_HPP -#define TOML11_STRING_HPP -#include - -#include -#include - -#if __cplusplus >= 201703L -#if __has_include() -#include -#endif -#endif - -namespace toml -{ - -enum class string_t : std::uint8_t -{ - basic = 0, - literal = 1, -}; - -struct string -{ - string() = default; - ~string() = default; - string(const string& s) = default; - string(string&& s) = default; - string& operator=(const string& s) = default; - string& operator=(string&& s) = default; - - string(const std::string& s): kind(string_t::basic), str(s){} - string(const std::string& s, string_t k): kind(k), str(s){} - string(const char* s): kind(string_t::basic), str(s){} - string(const char* s, string_t k): kind(k), str(s){} - - string(std::string&& s): kind(string_t::basic), str(std::move(s)){} - string(std::string&& s, string_t k): kind(k), str(std::move(s)){} - - string& operator=(const std::string& s) - {kind = string_t::basic; str = s; return *this;} - string& operator=(std::string&& s) - {kind = string_t::basic; str = std::move(s); return *this;} - - operator std::string& () & noexcept {return str;} - operator std::string const& () const& noexcept {return str;} - operator std::string&& () && noexcept {return std::move(str);} - - string& operator+=(const char* rhs) {str += rhs; return *this;} - string& operator+=(const char rhs) {str += rhs; return *this;} - string& operator+=(const std::string& rhs) {str += rhs; return *this;} - string& operator+=(const string& rhs) {str += rhs.str; return *this;} - -#if __cplusplus >= 201703L - explicit string(std::string_view s): kind(string_t::basic), str(s){} - string(std::string_view s, string_t k): kind(k), str(s){} - - string& operator=(std::string_view s) - {kind = string_t::basic; str = s; return *this;} - - explicit operator std::string_view() const noexcept - {return std::string_view(str);} - - string& operator+=(const std::string_view& rhs) {str += rhs; return *this;} -#endif - - string_t kind; - std::string str; -}; - -inline bool operator==(const string& lhs, const string& rhs) -{ - return lhs.kind == rhs.kind && lhs.str == rhs.str; -} -inline bool operator!=(const string& lhs, const string& rhs) -{ - return !(lhs == rhs); -} -inline bool operator<(const string& lhs, const string& rhs) -{ - return (lhs.kind == rhs.kind) ? (lhs.str < rhs.str) : (lhs.kind < rhs.kind); -} -inline bool operator>(const string& lhs, const string& rhs) -{ - return rhs < lhs; -} -inline bool operator<=(const string& lhs, const string& rhs) -{ - return !(rhs < lhs); -} -inline bool operator>=(const string& lhs, const string& rhs) -{ - return !(lhs < rhs); -} - -inline bool -operator==(const string& lhs, const std::string& rhs) {return lhs.str == rhs;} -inline bool -operator!=(const string& lhs, const std::string& rhs) {return lhs.str != rhs;} -inline bool -operator< (const string& lhs, const std::string& rhs) {return lhs.str < rhs;} -inline bool -operator> (const string& lhs, const std::string& rhs) {return lhs.str > rhs;} -inline bool -operator<=(const string& lhs, const std::string& rhs) {return lhs.str <= rhs;} -inline bool -operator>=(const string& lhs, const std::string& rhs) {return lhs.str >= rhs;} - -inline bool -operator==(const std::string& lhs, const string& rhs) {return lhs == rhs.str;} -inline bool -operator!=(const std::string& lhs, const string& rhs) {return lhs != rhs.str;} -inline bool -operator< (const std::string& lhs, const string& rhs) {return lhs < rhs.str;} -inline bool -operator> (const std::string& lhs, const string& rhs) {return lhs > rhs.str;} -inline bool -operator<=(const std::string& lhs, const string& rhs) {return lhs <= rhs.str;} -inline bool -operator>=(const std::string& lhs, const string& rhs) {return lhs >= rhs.str;} - -inline bool -operator==(const string& lhs, const char* rhs) {return lhs.str == std::string(rhs);} -inline bool -operator!=(const string& lhs, const char* rhs) {return lhs.str != std::string(rhs);} -inline bool -operator< (const string& lhs, const char* rhs) {return lhs.str < std::string(rhs);} -inline bool -operator> (const string& lhs, const char* rhs) {return lhs.str > std::string(rhs);} -inline bool -operator<=(const string& lhs, const char* rhs) {return lhs.str <= std::string(rhs);} -inline bool -operator>=(const string& lhs, const char* rhs) {return lhs.str >= std::string(rhs);} - -inline bool -operator==(const char* lhs, const string& rhs) {return std::string(lhs) == rhs.str;} -inline bool -operator!=(const char* lhs, const string& rhs) {return std::string(lhs) != rhs.str;} -inline bool -operator< (const char* lhs, const string& rhs) {return std::string(lhs) < rhs.str;} -inline bool -operator> (const char* lhs, const string& rhs) {return std::string(lhs) > rhs.str;} -inline bool -operator<=(const char* lhs, const string& rhs) {return std::string(lhs) <= rhs.str;} -inline bool -operator>=(const char* lhs, const string& rhs) {return std::string(lhs) >= rhs.str;} - -template -std::basic_ostream& -operator<<(std::basic_ostream& os, const string& s) -{ - if(s.kind == string_t::basic) - { - if(std::find(s.str.cbegin(), s.str.cend(), '\n') != s.str.cend()) - { - // it contains newline. make it multiline string. - os << "\"\"\"\n"; - for(auto i=s.str.cbegin(), e=s.str.cend(); i!=e; ++i) - { - switch(*i) - { - case '\\': {os << "\\\\"; break;} - case '\"': {os << "\\\""; break;} - case '\b': {os << "\\b"; break;} - case '\t': {os << "\\t"; break;} - case '\f': {os << "\\f"; break;} - case '\n': {os << '\n'; break;} - case '\r': - { - // since it is a multiline string, - // CRLF is not needed to be escaped. - if(std::next(i) != e && *std::next(i) == '\n') - { - os << "\r\n"; - ++i; - } - else - { - os << "\\r"; - } - break; - } - default: {os << *i; break;} - } - } - os << "\\\n\"\"\""; - return os; - } - // no newline. make it inline. - os << "\""; - for(const auto c : s.str) - { - switch(c) - { - case '\\': {os << "\\\\"; break;} - case '\"': {os << "\\\""; break;} - case '\b': {os << "\\b"; break;} - case '\t': {os << "\\t"; break;} - case '\f': {os << "\\f"; break;} - case '\n': {os << "\\n"; break;} - case '\r': {os << "\\r"; break;} - default : {os << c; break;} - } - } - os << "\""; - return os; - } - // the string `s` is literal-string. - if(std::find(s.str.cbegin(), s.str.cend(), '\n') != s.str.cend() || - std::find(s.str.cbegin(), s.str.cend(), '\'') != s.str.cend() ) - { - // contains newline or single quote. make it multiline. - os << "'''\n" << s.str << "'''"; - return os; - } - // normal literal string - os << '\'' << s.str << '\''; - return os; -} - -} // toml -#endif// TOML11_STRING_H diff --git a/libraries/toml11/include/toml/traits.hpp b/libraries/toml11/include/toml/traits.hpp deleted file mode 100644 index eafa6afe..00000000 --- a/libraries/toml11/include/toml/traits.hpp +++ /dev/null @@ -1,300 +0,0 @@ -// Copyright Toru Niina 2017. -// Distributed under the MIT License. -#ifndef TOML11_TRAITS_HPP -#define TOML11_TRAITS_HPP -#include -#include -#include -#include -#include -#include - -#if __cplusplus >= 201703L -#if __has_include() -#include -#endif // has_include() -#endif // cplusplus >= C++17 - -namespace toml -{ -template class T, template class A> -class basic_value; - -namespace detail -{ -// --------------------------------------------------------------------------- -// check whether type T is a kind of container/map class - -struct has_iterator_impl -{ - template static std::true_type check(typename T::iterator*); - template static std::false_type check(...); -}; -struct has_value_type_impl -{ - template static std::true_type check(typename T::value_type*); - template static std::false_type check(...); -}; -struct has_key_type_impl -{ - template static std::true_type check(typename T::key_type*); - template static std::false_type check(...); -}; -struct has_mapped_type_impl -{ - template static std::true_type check(typename T::mapped_type*); - template static std::false_type check(...); -}; -struct has_reserve_method_impl -{ - template static std::false_type check(...); - template static std::true_type check( - decltype(std::declval().reserve(std::declval()))*); -}; -struct has_push_back_method_impl -{ - template static std::false_type check(...); - template static std::true_type check( - decltype(std::declval().push_back(std::declval()))*); -}; -struct is_comparable_impl -{ - template static std::false_type check(...); - template static std::true_type check( - decltype(std::declval() < std::declval())*); -}; - -struct has_from_toml_method_impl -{ - template class Tb, template class A> - static std::true_type check( - decltype(std::declval().from_toml( - std::declval<::toml::basic_value>()))*); - - template class Tb, template class A> - static std::false_type check(...); -}; -struct has_into_toml_method_impl -{ - template - static std::true_type check(decltype(std::declval().into_toml())*); - template - static std::false_type check(...); -}; - -/// Intel C++ compiler can not use decltype in parent class declaration, here -/// is a hack to work around it. https://stackoverflow.com/a/23953090/4692076 -#ifdef __INTEL_COMPILER -#define decltype(...) std::enable_if::type -#endif - -template -struct has_iterator : decltype(has_iterator_impl::check(nullptr)){}; -template -struct has_value_type : decltype(has_value_type_impl::check(nullptr)){}; -template -struct has_key_type : decltype(has_key_type_impl::check(nullptr)){}; -template -struct has_mapped_type : decltype(has_mapped_type_impl::check(nullptr)){}; -template -struct has_reserve_method : decltype(has_reserve_method_impl::check(nullptr)){}; -template -struct has_push_back_method : decltype(has_push_back_method_impl::check(nullptr)){}; -template -struct is_comparable : decltype(is_comparable_impl::check(nullptr)){}; - -template class Tb, template class A> -struct has_from_toml_method -: decltype(has_from_toml_method_impl::check(nullptr)){}; - -template -struct has_into_toml_method -: decltype(has_into_toml_method_impl::check(nullptr)){}; - -#ifdef __INTEL_COMPILER -#undef decltype -#endif - -// --------------------------------------------------------------------------- -// C++17 and/or/not - -#if __cplusplus >= 201703L - -using std::conjunction; -using std::disjunction; -using std::negation; - -#else - -template struct conjunction : std::true_type{}; -template struct conjunction : T{}; -template -struct conjunction : - std::conditional(T::value), conjunction, T>::type -{}; - -template struct disjunction : std::false_type{}; -template struct disjunction : T {}; -template -struct disjunction : - std::conditional(T::value), T, disjunction>::type -{}; - -template -struct negation : std::integral_constant(T::value)>{}; - -#endif - -// --------------------------------------------------------------------------- -// type checkers - -template struct is_std_pair : std::false_type{}; -template -struct is_std_pair> : std::true_type{}; - -template struct is_std_tuple : std::false_type{}; -template -struct is_std_tuple> : std::true_type{}; - -template struct is_std_forward_list : std::false_type{}; -template -struct is_std_forward_list> : std::true_type{}; - -template struct is_chrono_duration: std::false_type{}; -template -struct is_chrono_duration>: std::true_type{}; - -template -struct is_map : conjunction< // map satisfies all the following conditions - has_iterator, // has T::iterator - has_value_type, // has T::value_type - has_key_type, // has T::key_type - has_mapped_type // has T::mapped_type - >{}; -template struct is_map : is_map{}; -template struct is_map : is_map{}; -template struct is_map : is_map{}; -template struct is_map : is_map{}; - -template -struct is_container : conjunction< - negation>, // not a map - negation>, // not a std::string -#if __cplusplus >= 201703L - negation>, // not a std::string_view -#endif - has_iterator, // has T::iterator - has_value_type // has T::value_type - >{}; -template struct is_container : is_container{}; -template struct is_container : is_container{}; -template struct is_container : is_container{}; -template struct is_container : is_container{}; - -template -struct is_basic_value: std::false_type{}; -template struct is_basic_value : is_basic_value{}; -template struct is_basic_value : is_basic_value{}; -template struct is_basic_value : is_basic_value{}; -template struct is_basic_value : is_basic_value{}; -template class M, template class V> -struct is_basic_value<::toml::basic_value>: std::true_type{}; - -// --------------------------------------------------------------------------- -// C++14 index_sequence - -#if __cplusplus >= 201402L - -using std::index_sequence; -using std::make_index_sequence; - -#else - -template struct index_sequence{}; - -template struct push_back_index_sequence{}; -template -struct push_back_index_sequence, N> -{ - typedef index_sequence type; -}; - -template -struct index_sequence_maker -{ - typedef typename push_back_index_sequence< - typename index_sequence_maker::type, N>::type type; -}; -template<> -struct index_sequence_maker<0> -{ - typedef index_sequence<0> type; -}; -template -using make_index_sequence = typename index_sequence_maker::type; - -#endif // __cplusplus >= 2014 - -// --------------------------------------------------------------------------- -// C++14 enable_if_t - -#if __cplusplus >= 201402L - -using std::enable_if_t; - -#else - -template -using enable_if_t = typename std::enable_if::type; - -#endif // __cplusplus >= 2014 - -// --------------------------------------------------------------------------- -// return_type_of_t - -#if __cplusplus >= 201703L - -template -using return_type_of_t = std::invoke_result_t; - -#else -// result_of is deprecated after C++17 -template -using return_type_of_t = typename std::result_of::type; - -#endif - -// --------------------------------------------------------------------------- -// is_string_literal -// -// to use this, pass `typename remove_reference::type` to T. - -template -struct is_string_literal: -disjunction< - std::is_same, - conjunction< - std::is_array, - std::is_same::type> - > - >{}; - -// --------------------------------------------------------------------------- -// C++20 remove_cvref_t - -template -struct remove_cvref -{ - using type = typename std::remove_cv< - typename std::remove_reference::type>::type; -}; - -template -using remove_cvref_t = typename remove_cvref::type; - -}// detail -}//toml -#endif // TOML_TRAITS diff --git a/libraries/toml11/include/toml/types.hpp b/libraries/toml11/include/toml/types.hpp deleted file mode 100644 index 0818ebd1..00000000 --- a/libraries/toml11/include/toml/types.hpp +++ /dev/null @@ -1,150 +0,0 @@ -// Copyright Toru Niina 2017. -// Distributed under the MIT License. -#ifndef TOML11_TYPES_HPP -#define TOML11_TYPES_HPP -#include -#include - -#include "comments.hpp" -#include "datetime.hpp" -#include "string.hpp" -#include "traits.hpp" - -namespace toml -{ - -template class Table, // map-like class - template class Array> // vector-like class -class basic_value; - -using character = char; -using key = std::string; - -using boolean = bool; -using integer = std::int64_t; -using floating = double; // "float" is a keyward, cannot use it here. -// the following stuffs are structs defined here, so aliases are not needed. -// - string -// - offset_datetime -// - offset_datetime -// - local_datetime -// - local_date -// - local_time - -// default toml::value and default array/table. these are defined after defining -// basic_value itself. -// using value = basic_value; -// using array = typename value::array_type; -// using table = typename value::table_type; - -enum class value_t : std::uint8_t -{ - empty = 0, - boolean = 1, - integer = 2, - floating = 3, - string = 4, - offset_datetime = 5, - local_datetime = 6, - local_date = 7, - local_time = 8, - array = 9, - table = 10, -}; - -template -inline std::basic_ostream& -operator<<(std::basic_ostream& os, value_t t) -{ - switch(t) - { - case value_t::boolean : os << "boolean"; return os; - case value_t::integer : os << "integer"; return os; - case value_t::floating : os << "floating"; return os; - case value_t::string : os << "string"; return os; - case value_t::offset_datetime : os << "offset_datetime"; return os; - case value_t::local_datetime : os << "local_datetime"; return os; - case value_t::local_date : os << "local_date"; return os; - case value_t::local_time : os << "local_time"; return os; - case value_t::array : os << "array"; return os; - case value_t::table : os << "table"; return os; - case value_t::empty : os << "empty"; return os; - default : os << "unknown"; return os; - } -} - -template, - typename alloc = std::allocator> -inline std::basic_string stringize(value_t t) -{ - std::basic_ostringstream oss; - oss << t; - return oss.str(); -} - -namespace detail -{ - -// helper to define a type that represents a value_t value. -template -using value_t_constant = std::integral_constant; - -// meta-function that convertes from value_t to the exact toml type that corresponds to. -// It takes toml::basic_value type because array and table types depend on it. -template struct enum_to_type {using type = void ;}; -template struct enum_to_type{using type = void ;}; -template struct enum_to_type{using type = boolean ;}; -template struct enum_to_type{using type = integer ;}; -template struct enum_to_type{using type = floating ;}; -template struct enum_to_type{using type = string ;}; -template struct enum_to_type{using type = offset_datetime ;}; -template struct enum_to_type{using type = local_datetime ;}; -template struct enum_to_type{using type = local_date ;}; -template struct enum_to_type{using type = local_time ;}; -template struct enum_to_type{using type = typename Value::array_type;}; -template struct enum_to_type{using type = typename Value::table_type;}; - -// meta-function that converts from an exact toml type to the enum that corresponds to. -template -struct type_to_enum : std::conditional< - std::is_same::value, // if T == array_type, - value_t_constant, // then value_t::array - typename std::conditional< // else... - std::is_same::value, // if T == table_type - value_t_constant, // then value_t::table - value_t_constant // else value_t::empty - >::type - >::type {}; -template struct type_to_enum: value_t_constant {}; -template struct type_to_enum: value_t_constant {}; -template struct type_to_enum: value_t_constant {}; -template struct type_to_enum: value_t_constant {}; -template struct type_to_enum: value_t_constant {}; -template struct type_to_enum: value_t_constant {}; -template struct type_to_enum: value_t_constant {}; -template struct type_to_enum: value_t_constant {}; - -// meta-function that checks the type T is the same as one of the toml::* types. -template -struct is_exact_toml_type : disjunction< - std::is_same, - std::is_same, - std::is_same, - std::is_same, - std::is_same, - std::is_same, - std::is_same, - std::is_same, - std::is_same, - std::is_same - >{}; -template struct is_exact_toml_type : is_exact_toml_type{}; -template struct is_exact_toml_type : is_exact_toml_type{}; -template struct is_exact_toml_type : is_exact_toml_type{}; -template struct is_exact_toml_type: is_exact_toml_type{}; - -} // detail -} // toml -#endif// TOML11_TYPES_H diff --git a/libraries/toml11/include/toml/utility.hpp b/libraries/toml11/include/toml/utility.hpp deleted file mode 100644 index 113bec61..00000000 --- a/libraries/toml11/include/toml/utility.hpp +++ /dev/null @@ -1,93 +0,0 @@ -// Copyright Toru Niina 2017. -// Distributed under the MIT License. -#ifndef TOML11_UTILITY_HPP -#define TOML11_UTILITY_HPP -#include -#include -#include - -#include "traits.hpp" - -#if __cplusplus >= 201402L -# define TOML11_MARK_AS_DEPRECATED(msg) [[deprecated(msg)]] -#elif defined(__GNUC__) -# define TOML11_MARK_AS_DEPRECATED(msg) __attribute__((deprecated(msg))) -#elif defined(_MSC_VER) -# define TOML11_MARK_AS_DEPRECATED(msg) __declspec(deprecated(msg)) -#else -# define TOML11_MARK_AS_DEPRECATED -#endif - -namespace toml -{ - -#if __cplusplus >= 201402L - -using std::make_unique; - -#else - -template -inline std::unique_ptr make_unique(Ts&& ... args) -{ - return std::unique_ptr(new T(std::forward(args)...)); -} - -#endif // __cplusplus >= 2014 - -namespace detail -{ -template -void try_reserve_impl(Container& container, std::size_t N, std::true_type) -{ - container.reserve(N); - return; -} -template -void try_reserve_impl(Container&, std::size_t, std::false_type) noexcept -{ - return; -} -} // detail - -template -void try_reserve(Container& container, std::size_t N) -{ - if(N <= container.size()) {return;} - detail::try_reserve_impl(container, N, detail::has_reserve_method{}); - return; -} - -namespace detail -{ -inline std::string concat_to_string_impl(std::ostringstream& oss) -{ - return oss.str(); -} -template -std::string concat_to_string_impl(std::ostringstream& oss, T&& head, Ts&& ... tail) -{ - oss << std::forward(head); - return concat_to_string_impl(oss, std::forward(tail) ... ); -} -} // detail - -template -std::string concat_to_string(Ts&& ... args) -{ - std::ostringstream oss; - oss << std::boolalpha << std::fixed; - return detail::concat_to_string_impl(oss, std::forward(args) ...); -} - -template -T from_string(const std::string& str, T opt) -{ - T v(opt); - std::istringstream iss(str); - iss >> v; - return v; -} - -}// toml -#endif // TOML11_UTILITY diff --git a/libraries/toml11/include/toml/value.hpp b/libraries/toml11/include/toml/value.hpp deleted file mode 100644 index e374c3b5..00000000 --- a/libraries/toml11/include/toml/value.hpp +++ /dev/null @@ -1,2023 +0,0 @@ -// Copyright Toru Niina 2017. -// Distributed under the MIT License. -#ifndef TOML11_VALUE_HPP -#define TOML11_VALUE_HPP -#include - -#include "comments.hpp" -#include "exception.hpp" -#include "into.hpp" -#include "region.hpp" -#include "source_location.hpp" -#include "storage.hpp" -#include "traits.hpp" -#include "types.hpp" -#include "utility.hpp" - -namespace toml -{ - -namespace detail -{ - -// to show error messages. not recommended for users. -template -inline region_base const* get_region(const Value& v) -{ - return v.region_info_.get(); -} - -template -void change_region(Value& v, region reg) -{ - v.region_info_ = std::make_shared(std::move(reg)); - return; -} - -template -[[noreturn]] inline void -throw_bad_cast(const std::string& funcname, value_t actual, const Value& v) -{ - throw type_error(detail::format_underline( - concat_to_string(funcname, "bad_cast to ", Expected), { - {v.location(), concat_to_string("the actual type is ", actual)} - }), v.location()); -} - -// Throw `out_of_range` from `toml::value::at()` and `toml::find()` -// after generating an error message. -// -// The implementation is a bit complicated and there are many edge-cases. -// If you are not interested in the error message generation, just skip this. -template -[[noreturn]] void -throw_key_not_found_error(const Value& v, const key& ky) -{ - // The top-level table has its region at the first character of the file. - // That means that, in the case when a key is not found in the top-level - // table, the error message points to the first character. If the file has - // its first table at the first line, the error message would be like this. - // ```console - // [error] key "a" not found - // --> example.toml - // | - // 1 | [table] - // | ^------ in this table - // ``` - // It actually points to the top-level table at the first character, - // not `[table]`. But it is too confusing. To avoid the confusion, the error - // message should explicitly say "key not found in the top-level table". - const auto loc = v.location(); - if(loc.line() == 1 && loc.region() == 1) - { - // Here it assumes that top-level table starts at the first character. - // The region corresponds to the top-level table will be generated at - // `parse_toml_file` function. - // It also assumes that the top-level table size is just one and - // the line number is `1`. It is always satisfied. And those conditions - // are satisfied only if the table is the top-level table. - // - // 1. one-character dot-key at the first line - // ```toml - // a.b = "c" - // ``` - // toml11 counts whole key as the table key. Here, `a.b` is the region - // of the table "a". It could be counter intuitive, but it works. - // The size of the region is 3, not 1. The above example is the shortest - // dot-key example. The size cannot be 1. - // - // 2. one-character inline-table at the first line - // ```toml - // a = {b = "c"} - // ``` - // toml11 consideres the inline table body as the table region. Here, - // `{b = "c"}` is the region of the table "a". The size of the region - // is 9, not 1. The shotest inline table still has two characters, `{` - // and `}`. The size cannot be 1. - // - // 3. one-character table declaration at the first line - // ```toml - // [a] - // ``` - // toml11 consideres the whole table key as the table region. Here, - // `[a]` is the table region. The size is 3, not 1. - // - throw std::out_of_range(format_underline(concat_to_string( - "key \"", ky, "\" not found in the top-level table"), { - {loc, "the top-level table starts here"} - })); - } - else - { - // normal table. - throw std::out_of_range(format_underline(concat_to_string( - "key \"", ky, "\" not found"), { {loc, "in this table"} })); - } -} - -// switch by `value_t` at the compile time. -template -struct switch_cast {}; -#define TOML11_GENERATE_SWITCH_CASTER(TYPE) \ - template<> \ - struct switch_cast \ - { \ - template \ - static typename Value::TYPE##_type& invoke(Value& v) \ - { \ - return v.as_##TYPE(); \ - } \ - template \ - static typename Value::TYPE##_type const& invoke(const Value& v) \ - { \ - return v.as_##TYPE(); \ - } \ - template \ - static typename Value::TYPE##_type&& invoke(Value&& v) \ - { \ - return std::move(v).as_##TYPE(); \ - } \ - }; \ - /**/ -TOML11_GENERATE_SWITCH_CASTER(boolean) -TOML11_GENERATE_SWITCH_CASTER(integer) -TOML11_GENERATE_SWITCH_CASTER(floating) -TOML11_GENERATE_SWITCH_CASTER(string) -TOML11_GENERATE_SWITCH_CASTER(offset_datetime) -TOML11_GENERATE_SWITCH_CASTER(local_datetime) -TOML11_GENERATE_SWITCH_CASTER(local_date) -TOML11_GENERATE_SWITCH_CASTER(local_time) -TOML11_GENERATE_SWITCH_CASTER(array) -TOML11_GENERATE_SWITCH_CASTER(table) - -#undef TOML11_GENERATE_SWITCH_CASTER - -}// detail - -template class Table = std::unordered_map, - template class Array = std::vector> -class basic_value -{ - template - static void assigner(T& dst, U&& v) - { - const auto tmp = ::new(std::addressof(dst)) T(std::forward(v)); - assert(tmp == std::addressof(dst)); - (void)tmp; - } - - using region_base = detail::region_base; - - template class T, - template class A> - friend class basic_value; - - public: - - using comment_type = Comment; - using key_type = ::toml::key; - using value_type = basic_value; - using boolean_type = ::toml::boolean; - using integer_type = ::toml::integer; - using floating_type = ::toml::floating; - using string_type = ::toml::string; - using local_time_type = ::toml::local_time; - using local_date_type = ::toml::local_date; - using local_datetime_type = ::toml::local_datetime; - using offset_datetime_type = ::toml::offset_datetime; - using array_type = Array; - using table_type = Table; - - public: - - basic_value() noexcept - : type_(value_t::empty), - region_info_(std::make_shared(region_base{})) - {} - ~basic_value() noexcept {this->cleanup();} - - basic_value(const basic_value& v) - : type_(v.type()), region_info_(v.region_info_), comments_(v.comments_) - { - switch(v.type()) - { - case value_t::boolean : assigner(boolean_ , v.boolean_ ); break; - case value_t::integer : assigner(integer_ , v.integer_ ); break; - case value_t::floating : assigner(floating_ , v.floating_ ); break; - case value_t::string : assigner(string_ , v.string_ ); break; - case value_t::offset_datetime: assigner(offset_datetime_, v.offset_datetime_); break; - case value_t::local_datetime : assigner(local_datetime_ , v.local_datetime_ ); break; - case value_t::local_date : assigner(local_date_ , v.local_date_ ); break; - case value_t::local_time : assigner(local_time_ , v.local_time_ ); break; - case value_t::array : assigner(array_ , v.array_ ); break; - case value_t::table : assigner(table_ , v.table_ ); break; - default: break; - } - } - basic_value(basic_value&& v) - : type_(v.type()), region_info_(std::move(v.region_info_)), - comments_(std::move(v.comments_)) - { - switch(this->type_) // here this->type_ is already initialized - { - case value_t::boolean : assigner(boolean_ , std::move(v.boolean_ )); break; - case value_t::integer : assigner(integer_ , std::move(v.integer_ )); break; - case value_t::floating : assigner(floating_ , std::move(v.floating_ )); break; - case value_t::string : assigner(string_ , std::move(v.string_ )); break; - case value_t::offset_datetime: assigner(offset_datetime_, std::move(v.offset_datetime_)); break; - case value_t::local_datetime : assigner(local_datetime_ , std::move(v.local_datetime_ )); break; - case value_t::local_date : assigner(local_date_ , std::move(v.local_date_ )); break; - case value_t::local_time : assigner(local_time_ , std::move(v.local_time_ )); break; - case value_t::array : assigner(array_ , std::move(v.array_ )); break; - case value_t::table : assigner(table_ , std::move(v.table_ )); break; - default: break; - } - } - basic_value& operator=(const basic_value& v) - { - this->cleanup(); - this->region_info_ = v.region_info_; - this->comments_ = v.comments_; - this->type_ = v.type(); - switch(this->type_) - { - case value_t::boolean : assigner(boolean_ , v.boolean_ ); break; - case value_t::integer : assigner(integer_ , v.integer_ ); break; - case value_t::floating : assigner(floating_ , v.floating_ ); break; - case value_t::string : assigner(string_ , v.string_ ); break; - case value_t::offset_datetime: assigner(offset_datetime_, v.offset_datetime_); break; - case value_t::local_datetime : assigner(local_datetime_ , v.local_datetime_ ); break; - case value_t::local_date : assigner(local_date_ , v.local_date_ ); break; - case value_t::local_time : assigner(local_time_ , v.local_time_ ); break; - case value_t::array : assigner(array_ , v.array_ ); break; - case value_t::table : assigner(table_ , v.table_ ); break; - default: break; - } - return *this; - } - basic_value& operator=(basic_value&& v) - { - this->cleanup(); - this->region_info_ = std::move(v.region_info_); - this->comments_ = std::move(v.comments_); - this->type_ = v.type(); - switch(this->type_) - { - case value_t::boolean : assigner(boolean_ , std::move(v.boolean_ )); break; - case value_t::integer : assigner(integer_ , std::move(v.integer_ )); break; - case value_t::floating : assigner(floating_ , std::move(v.floating_ )); break; - case value_t::string : assigner(string_ , std::move(v.string_ )); break; - case value_t::offset_datetime: assigner(offset_datetime_, std::move(v.offset_datetime_)); break; - case value_t::local_datetime : assigner(local_datetime_ , std::move(v.local_datetime_ )); break; - case value_t::local_date : assigner(local_date_ , std::move(v.local_date_ )); break; - case value_t::local_time : assigner(local_time_ , std::move(v.local_time_ )); break; - case value_t::array : assigner(array_ , std::move(v.array_ )); break; - case value_t::table : assigner(table_ , std::move(v.table_ )); break; - default: break; - } - return *this; - } - - // overwrite comments ---------------------------------------------------- - - basic_value(const basic_value& v, std::vector comments) - : type_(v.type()), region_info_(v.region_info_), - comments_(std::move(comments)) - { - switch(v.type()) - { - case value_t::boolean : assigner(boolean_ , v.boolean_ ); break; - case value_t::integer : assigner(integer_ , v.integer_ ); break; - case value_t::floating : assigner(floating_ , v.floating_ ); break; - case value_t::string : assigner(string_ , v.string_ ); break; - case value_t::offset_datetime: assigner(offset_datetime_, v.offset_datetime_); break; - case value_t::local_datetime : assigner(local_datetime_ , v.local_datetime_ ); break; - case value_t::local_date : assigner(local_date_ , v.local_date_ ); break; - case value_t::local_time : assigner(local_time_ , v.local_time_ ); break; - case value_t::array : assigner(array_ , v.array_ ); break; - case value_t::table : assigner(table_ , v.table_ ); break; - default: break; - } - } - - basic_value(basic_value&& v, std::vector comments) - : type_(v.type()), region_info_(std::move(v.region_info_)), - comments_(std::move(comments)) - { - switch(this->type_) // here this->type_ is already initialized - { - case value_t::boolean : assigner(boolean_ , std::move(v.boolean_ )); break; - case value_t::integer : assigner(integer_ , std::move(v.integer_ )); break; - case value_t::floating : assigner(floating_ , std::move(v.floating_ )); break; - case value_t::string : assigner(string_ , std::move(v.string_ )); break; - case value_t::offset_datetime: assigner(offset_datetime_, std::move(v.offset_datetime_)); break; - case value_t::local_datetime : assigner(local_datetime_ , std::move(v.local_datetime_ )); break; - case value_t::local_date : assigner(local_date_ , std::move(v.local_date_ )); break; - case value_t::local_time : assigner(local_time_ , std::move(v.local_time_ )); break; - case value_t::array : assigner(array_ , std::move(v.array_ )); break; - case value_t::table : assigner(table_ , std::move(v.table_ )); break; - default: break; - } - } - - // ----------------------------------------------------------------------- - // conversion between different basic_values. - template class T, - template class A> - basic_value(const basic_value& v) - : type_(v.type()), region_info_(v.region_info_), comments_(v.comments()) - { - switch(v.type()) - { - case value_t::boolean : assigner(boolean_ , v.boolean_ ); break; - case value_t::integer : assigner(integer_ , v.integer_ ); break; - case value_t::floating : assigner(floating_ , v.floating_ ); break; - case value_t::string : assigner(string_ , v.string_ ); break; - case value_t::offset_datetime: assigner(offset_datetime_, v.offset_datetime_); break; - case value_t::local_datetime : assigner(local_datetime_ , v.local_datetime_ ); break; - case value_t::local_date : assigner(local_date_ , v.local_date_ ); break; - case value_t::local_time : assigner(local_time_ , v.local_time_ ); break; - case value_t::array : - { - array_type tmp(v.as_array(std::nothrow).begin(), - v.as_array(std::nothrow).end()); - assigner(array_, std::move(tmp)); - break; - } - case value_t::table : - { - table_type tmp(v.as_table(std::nothrow).begin(), - v.as_table(std::nothrow).end()); - assigner(table_, std::move(tmp)); - break; - } - default: break; - } - } - template class T, - template class A> - basic_value(const basic_value& v, std::vector comments) - : type_(v.type()), region_info_(v.region_info_), - comments_(std::move(comments)) - { - switch(v.type()) - { - case value_t::boolean : assigner(boolean_ , v.boolean_ ); break; - case value_t::integer : assigner(integer_ , v.integer_ ); break; - case value_t::floating : assigner(floating_ , v.floating_ ); break; - case value_t::string : assigner(string_ , v.string_ ); break; - case value_t::offset_datetime: assigner(offset_datetime_, v.offset_datetime_); break; - case value_t::local_datetime : assigner(local_datetime_ , v.local_datetime_ ); break; - case value_t::local_date : assigner(local_date_ , v.local_date_ ); break; - case value_t::local_time : assigner(local_time_ , v.local_time_ ); break; - case value_t::array : - { - array_type tmp(v.as_array(std::nothrow).begin(), - v.as_array(std::nothrow).end()); - assigner(array_, std::move(tmp)); - break; - } - case value_t::table : - { - table_type tmp(v.as_table(std::nothrow).begin(), - v.as_table(std::nothrow).end()); - assigner(table_, std::move(tmp)); - break; - } - default: break; - } - } - template class T, - template class A> - basic_value& operator=(const basic_value& v) - { - this->region_info_ = v.region_info_; - this->comments_ = comment_type(v.comments()); - this->type_ = v.type(); - switch(v.type()) - { - case value_t::boolean : assigner(boolean_ , v.boolean_ ); break; - case value_t::integer : assigner(integer_ , v.integer_ ); break; - case value_t::floating : assigner(floating_ , v.floating_ ); break; - case value_t::string : assigner(string_ , v.string_ ); break; - case value_t::offset_datetime: assigner(offset_datetime_, v.offset_datetime_); break; - case value_t::local_datetime : assigner(local_datetime_ , v.local_datetime_ ); break; - case value_t::local_date : assigner(local_date_ , v.local_date_ ); break; - case value_t::local_time : assigner(local_time_ , v.local_time_ ); break; - case value_t::array : - { - array_type tmp(v.as_array(std::nothrow).begin(), - v.as_array(std::nothrow).end()); - assigner(array_, std::move(tmp)); - break; - } - case value_t::table : - { - table_type tmp(v.as_table(std::nothrow).begin(), - v.as_table(std::nothrow).end()); - assigner(table_, std::move(tmp)); - break; - } - default: break; - } - return *this; - } - - // boolean ============================================================== - - basic_value(boolean b) - : type_(value_t::boolean), - region_info_(std::make_shared(region_base{})) - { - assigner(this->boolean_, b); - } - basic_value& operator=(boolean b) - { - this->cleanup(); - this->type_ = value_t::boolean; - this->region_info_ = std::make_shared(region_base{}); - assigner(this->boolean_, b); - return *this; - } - basic_value(boolean b, std::vector comments) - : type_(value_t::boolean), - region_info_(std::make_shared(region_base{})), - comments_(std::move(comments)) - { - assigner(this->boolean_, b); - } - - // integer ============================================================== - - template, detail::negation>>::value, - std::nullptr_t>::type = nullptr> - basic_value(T i) - : type_(value_t::integer), - region_info_(std::make_shared(region_base{})) - { - assigner(this->integer_, static_cast(i)); - } - - template, detail::negation>>::value, - std::nullptr_t>::type = nullptr> - basic_value& operator=(T i) - { - this->cleanup(); - this->type_ = value_t::integer; - this->region_info_ = std::make_shared(region_base{}); - assigner(this->integer_, static_cast(i)); - return *this; - } - - template, detail::negation>>::value, - std::nullptr_t>::type = nullptr> - basic_value(T i, std::vector comments) - : type_(value_t::integer), - region_info_(std::make_shared(region_base{})), - comments_(std::move(comments)) - { - assigner(this->integer_, static_cast(i)); - } - - // floating ============================================================= - - template::value, std::nullptr_t>::type = nullptr> - basic_value(T f) - : type_(value_t::floating), - region_info_(std::make_shared(region_base{})) - { - assigner(this->floating_, static_cast(f)); - } - - - template::value, std::nullptr_t>::type = nullptr> - basic_value& operator=(T f) - { - this->cleanup(); - this->type_ = value_t::floating; - this->region_info_ = std::make_shared(region_base{}); - assigner(this->floating_, static_cast(f)); - return *this; - } - - template::value, std::nullptr_t>::type = nullptr> - basic_value(T f, std::vector comments) - : type_(value_t::floating), - region_info_(std::make_shared(region_base{})), - comments_(std::move(comments)) - { - assigner(this->floating_, f); - } - - // string =============================================================== - - basic_value(toml::string s) - : type_(value_t::string), - region_info_(std::make_shared(region_base{})) - { - assigner(this->string_, std::move(s)); - } - basic_value& operator=(toml::string s) - { - this->cleanup(); - this->type_ = value_t::string ; - this->region_info_ = std::make_shared(region_base{}); - assigner(this->string_, s); - return *this; - } - basic_value(toml::string s, std::vector comments) - : type_(value_t::string), - region_info_(std::make_shared(region_base{})), - comments_(std::move(comments)) - { - assigner(this->string_, std::move(s)); - } - - basic_value(std::string s) - : type_(value_t::string), - region_info_(std::make_shared(region_base{})) - { - assigner(this->string_, toml::string(std::move(s))); - } - basic_value& operator=(std::string s) - { - this->cleanup(); - this->type_ = value_t::string ; - this->region_info_ = std::make_shared(region_base{}); - assigner(this->string_, toml::string(std::move(s))); - return *this; - } - basic_value(std::string s, string_t kind) - : type_(value_t::string), - region_info_(std::make_shared(region_base{})) - { - assigner(this->string_, toml::string(std::move(s), kind)); - } - basic_value(std::string s, std::vector comments) - : type_(value_t::string), - region_info_(std::make_shared(region_base{})), - comments_(std::move(comments)) - { - assigner(this->string_, toml::string(std::move(s))); - } - basic_value(std::string s, string_t kind, std::vector comments) - : type_(value_t::string), - region_info_(std::make_shared(region_base{})), - comments_(std::move(comments)) - { - assigner(this->string_, toml::string(std::move(s), kind)); - } - - basic_value(const char* s) - : type_(value_t::string), - region_info_(std::make_shared(region_base{})) - { - assigner(this->string_, toml::string(std::string(s))); - } - basic_value& operator=(const char* s) - { - this->cleanup(); - this->type_ = value_t::string ; - this->region_info_ = std::make_shared(region_base{}); - assigner(this->string_, toml::string(std::string(s))); - return *this; - } - basic_value(const char* s, string_t kind) - : type_(value_t::string), - region_info_(std::make_shared(region_base{})) - { - assigner(this->string_, toml::string(std::string(s), kind)); - } - basic_value(const char* s, std::vector comments) - : type_(value_t::string), - region_info_(std::make_shared(region_base{})), - comments_(std::move(comments)) - { - assigner(this->string_, toml::string(std::string(s))); - } - basic_value(const char* s, string_t kind, std::vector comments) - : type_(value_t::string), - region_info_(std::make_shared(region_base{})), - comments_(std::move(comments)) - { - assigner(this->string_, toml::string(std::string(s), kind)); - } - -#if __cplusplus >= 201703L - basic_value(std::string_view s) - : type_(value_t::string), - region_info_(std::make_shared(region_base{})) - { - assigner(this->string_, toml::string(s)); - } - basic_value& operator=(std::string_view s) - { - this->cleanup(); - this->type_ = value_t::string ; - this->region_info_ = std::make_shared(region_base{}); - assigner(this->string_, toml::string(s)); - return *this; - } - basic_value(std::string_view s, std::vector comments) - : type_(value_t::string), - region_info_(std::make_shared(region_base{})), - comments_(std::move(comments)) - { - assigner(this->string_, toml::string(s)); - } - basic_value(std::string_view s, string_t kind) - : type_(value_t::string), - region_info_(std::make_shared(region_base{})) - { - assigner(this->string_, toml::string(s, kind)); - } - basic_value(std::string_view s, string_t kind, std::vector comments) - : type_(value_t::string), - region_info_(std::make_shared(region_base{})), - comments_(std::move(comments)) - { - assigner(this->string_, toml::string(s, kind)); - } -#endif - - // local date =========================================================== - - basic_value(const local_date& ld) - : type_(value_t::local_date), - region_info_(std::make_shared(region_base{})) - { - assigner(this->local_date_, ld); - } - basic_value& operator=(const local_date& ld) - { - this->cleanup(); - this->type_ = value_t::local_date; - this->region_info_ = std::make_shared(region_base{}); - assigner(this->local_date_, ld); - return *this; - } - basic_value(const local_date& ld, std::vector comments) - : type_(value_t::local_date), - region_info_(std::make_shared(region_base{})), - comments_(std::move(comments)) - { - assigner(this->local_date_, ld); - } - - // local time =========================================================== - - basic_value(const local_time& lt) - : type_(value_t::local_time), - region_info_(std::make_shared(region_base{})) - { - assigner(this->local_time_, lt); - } - basic_value(const local_time& lt, std::vector comments) - : type_(value_t::local_time), - region_info_(std::make_shared(region_base{})), - comments_(std::move(comments)) - { - assigner(this->local_time_, lt); - } - basic_value& operator=(const local_time& lt) - { - this->cleanup(); - this->type_ = value_t::local_time; - this->region_info_ = std::make_shared(region_base{}); - assigner(this->local_time_, lt); - return *this; - } - - template - basic_value(const std::chrono::duration& dur) - : type_(value_t::local_time), - region_info_(std::make_shared(region_base{})) - { - assigner(this->local_time_, local_time(dur)); - } - template - basic_value(const std::chrono::duration& dur, - std::vector comments) - : type_(value_t::local_time), - region_info_(std::make_shared(region_base{})), - comments_(std::move(comments)) - { - assigner(this->local_time_, local_time(dur)); - } - template - basic_value& operator=(const std::chrono::duration& dur) - { - this->cleanup(); - this->type_ = value_t::local_time; - this->region_info_ = std::make_shared(region_base{}); - assigner(this->local_time_, local_time(dur)); - return *this; - } - - // local datetime ======================================================= - - basic_value(const local_datetime& ldt) - : type_(value_t::local_datetime), - region_info_(std::make_shared(region_base{})) - { - assigner(this->local_datetime_, ldt); - } - basic_value(const local_datetime& ldt, std::vector comments) - : type_(value_t::local_datetime), - region_info_(std::make_shared(region_base{})), - comments_(std::move(comments)) - { - assigner(this->local_datetime_, ldt); - } - basic_value& operator=(const local_datetime& ldt) - { - this->cleanup(); - this->type_ = value_t::local_datetime; - this->region_info_ = std::make_shared(region_base{}); - assigner(this->local_datetime_, ldt); - return *this; - } - - // offset datetime ====================================================== - - basic_value(const offset_datetime& odt) - : type_(value_t::offset_datetime), - region_info_(std::make_shared(region_base{})) - { - assigner(this->offset_datetime_, odt); - } - basic_value(const offset_datetime& odt, std::vector comments) - : type_(value_t::offset_datetime), - region_info_(std::make_shared(region_base{})), - comments_(std::move(comments)) - { - assigner(this->offset_datetime_, odt); - } - basic_value& operator=(const offset_datetime& odt) - { - this->cleanup(); - this->type_ = value_t::offset_datetime; - this->region_info_ = std::make_shared(region_base{}); - assigner(this->offset_datetime_, odt); - return *this; - } - basic_value(const std::chrono::system_clock::time_point& tp) - : type_(value_t::offset_datetime), - region_info_(std::make_shared(region_base{})) - { - assigner(this->offset_datetime_, offset_datetime(tp)); - } - basic_value(const std::chrono::system_clock::time_point& tp, - std::vector comments) - : type_(value_t::offset_datetime), - region_info_(std::make_shared(region_base{})), - comments_(std::move(comments)) - { - assigner(this->offset_datetime_, offset_datetime(tp)); - } - basic_value& operator=(const std::chrono::system_clock::time_point& tp) - { - this->cleanup(); - this->type_ = value_t::offset_datetime; - this->region_info_ = std::make_shared(region_base{}); - assigner(this->offset_datetime_, offset_datetime(tp)); - return *this; - } - - // array ================================================================ - - basic_value(const array_type& ary) - : type_(value_t::array), - region_info_(std::make_shared(region_base{})) - { - assigner(this->array_, ary); - } - basic_value(const array_type& ary, std::vector comments) - : type_(value_t::array), - region_info_(std::make_shared(region_base{})), - comments_(std::move(comments)) - { - assigner(this->array_, ary); - } - basic_value& operator=(const array_type& ary) - { - this->cleanup(); - this->type_ = value_t::array ; - this->region_info_ = std::make_shared(region_base{}); - assigner(this->array_, ary); - return *this; - } - - // array (initializer_list) ---------------------------------------------- - - template::value, - std::nullptr_t>::type = nullptr> - basic_value(std::initializer_list list) - : type_(value_t::array), - region_info_(std::make_shared(region_base{})) - { - array_type ary(list.begin(), list.end()); - assigner(this->array_, std::move(ary)); - } - template::value, - std::nullptr_t>::type = nullptr> - basic_value(std::initializer_list list, std::vector comments) - : type_(value_t::array), - region_info_(std::make_shared(region_base{})), - comments_(std::move(comments)) - { - array_type ary(list.begin(), list.end()); - assigner(this->array_, std::move(ary)); - } - template::value, - std::nullptr_t>::type = nullptr> - basic_value& operator=(std::initializer_list list) - { - this->cleanup(); - this->type_ = value_t::array; - this->region_info_ = std::make_shared(region_base{}); - - array_type ary(list.begin(), list.end()); - assigner(this->array_, std::move(ary)); - return *this; - } - - // array (STL Containers) ------------------------------------------------ - - template>, - detail::is_container - >::value, std::nullptr_t>::type = nullptr> - basic_value(const T& list) - : type_(value_t::array), - region_info_(std::make_shared(region_base{})) - { - static_assert(std::is_convertible::value, - "elements of a container should be convertible to toml::value"); - - array_type ary(list.size()); - std::copy(list.begin(), list.end(), ary.begin()); - assigner(this->array_, std::move(ary)); - } - template>, - detail::is_container - >::value, std::nullptr_t>::type = nullptr> - basic_value(const T& list, std::vector comments) - : type_(value_t::array), - region_info_(std::make_shared(region_base{})), - comments_(std::move(comments)) - { - static_assert(std::is_convertible::value, - "elements of a container should be convertible to toml::value"); - - array_type ary(list.size()); - std::copy(list.begin(), list.end(), ary.begin()); - assigner(this->array_, std::move(ary)); - } - template>, - detail::is_container - >::value, std::nullptr_t>::type = nullptr> - basic_value& operator=(const T& list) - { - static_assert(std::is_convertible::value, - "elements of a container should be convertible to toml::value"); - - this->cleanup(); - this->type_ = value_t::array; - this->region_info_ = std::make_shared(region_base{}); - - array_type ary(list.size()); - std::copy(list.begin(), list.end(), ary.begin()); - assigner(this->array_, std::move(ary)); - return *this; - } - - // table ================================================================ - - basic_value(const table_type& tab) - : type_(value_t::table), - region_info_(std::make_shared(region_base{})) - { - assigner(this->table_, tab); - } - basic_value(const table_type& tab, std::vector comments) - : type_(value_t::table), - region_info_(std::make_shared(region_base{})), - comments_(std::move(comments)) - { - assigner(this->table_, tab); - } - basic_value& operator=(const table_type& tab) - { - this->cleanup(); - this->type_ = value_t::table; - this->region_info_ = std::make_shared(region_base{}); - assigner(this->table_, tab); - return *this; - } - - // initializer-list ------------------------------------------------------ - - basic_value(std::initializer_list> list) - : type_(value_t::table), - region_info_(std::make_shared(region_base{})) - { - table_type tab; - for(const auto& elem : list) {tab[elem.first] = elem.second;} - assigner(this->table_, std::move(tab)); - } - - basic_value(std::initializer_list> list, - std::vector comments) - : type_(value_t::table), - region_info_(std::make_shared(region_base{})), - comments_(std::move(comments)) - { - table_type tab; - for(const auto& elem : list) {tab[elem.first] = elem.second;} - assigner(this->table_, std::move(tab)); - } - basic_value& operator=(std::initializer_list> list) - { - this->cleanup(); - this->type_ = value_t::table; - this->region_info_ = std::make_shared(region_base{}); - - table_type tab; - for(const auto& elem : list) {tab[elem.first] = elem.second;} - assigner(this->table_, std::move(tab)); - return *this; - } - - // other table-like ----------------------------------------------------- - - template>, - detail::is_map - >::value, std::nullptr_t>::type = nullptr> - basic_value(const Map& mp) - : type_(value_t::table), - region_info_(std::make_shared(region_base{})) - { - table_type tab; - for(const auto& elem : mp) {tab[elem.first] = elem.second;} - assigner(this->table_, std::move(tab)); - } - template>, - detail::is_map - >::value, std::nullptr_t>::type = nullptr> - basic_value(const Map& mp, std::vector comments) - : type_(value_t::table), - region_info_(std::make_shared(region_base{})), - comments_(std::move(comments)) - { - table_type tab; - for(const auto& elem : mp) {tab[elem.first] = elem.second;} - assigner(this->table_, std::move(tab)); - } - template>, - detail::is_map - >::value, std::nullptr_t>::type = nullptr> - basic_value& operator=(const Map& mp) - { - this->cleanup(); - this->type_ = value_t::table; - this->region_info_ = std::make_shared(region_base{}); - - table_type tab; - for(const auto& elem : mp) {tab[elem.first] = elem.second;} - assigner(this->table_, std::move(tab)); - return *this; - } - - // user-defined ========================================================= - - // convert using into_toml() method ------------------------------------- - - template::value, std::nullptr_t>::type = nullptr> - basic_value(const T& ud): basic_value(ud.into_toml()) {} - - template::value, std::nullptr_t>::type = nullptr> - basic_value(const T& ud, std::vector comments) - : basic_value(ud.into_toml(), std::move(comments)) - {} - template::value, std::nullptr_t>::type = nullptr> - basic_value& operator=(const T& ud) - { - *this = ud.into_toml(); - return *this; - } - - // convert using into struct ----------------------------------------- - - template)> - basic_value(const T& ud): basic_value(::toml::into::into_toml(ud)) {} - template)> - basic_value(const T& ud, std::vector comments) - : basic_value(::toml::into::into_toml(ud), std::move(comments)) - {} - template)> - basic_value& operator=(const T& ud) - { - *this = ::toml::into::into_toml(ud); - return *this; - } - - // for internal use ------------------------------------------------------ - // - // Those constructors take detail::region that contains parse result. - - basic_value(boolean b, detail::region reg, std::vector cm) - : type_(value_t::boolean), - region_info_(std::make_shared(std::move(reg))), - comments_(std::move(cm)) - { - assigner(this->boolean_, b); - } - template, detail::negation> - >::value, std::nullptr_t>::type = nullptr> - basic_value(T i, detail::region reg, std::vector cm) - : type_(value_t::integer), - region_info_(std::make_shared(std::move(reg))), - comments_(std::move(cm)) - { - assigner(this->integer_, static_cast(i)); - } - template::value, std::nullptr_t>::type = nullptr> - basic_value(T f, detail::region reg, std::vector cm) - : type_(value_t::floating), - region_info_(std::make_shared(std::move(reg))), - comments_(std::move(cm)) - { - assigner(this->floating_, static_cast(f)); - } - basic_value(toml::string s, detail::region reg, - std::vector cm) - : type_(value_t::string), - region_info_(std::make_shared(std::move(reg))), - comments_(std::move(cm)) - { - assigner(this->string_, std::move(s)); - } - basic_value(const local_date& ld, detail::region reg, - std::vector cm) - : type_(value_t::local_date), - region_info_(std::make_shared(std::move(reg))), - comments_(std::move(cm)) - { - assigner(this->local_date_, ld); - } - basic_value(const local_time& lt, detail::region reg, - std::vector cm) - : type_(value_t::local_time), - region_info_(std::make_shared(std::move(reg))), - comments_(std::move(cm)) - { - assigner(this->local_time_, lt); - } - basic_value(const local_datetime& ldt, detail::region reg, - std::vector cm) - : type_(value_t::local_datetime), - region_info_(std::make_shared(std::move(reg))), - comments_(std::move(cm)) - { - assigner(this->local_datetime_, ldt); - } - basic_value(const offset_datetime& odt, detail::region reg, - std::vector cm) - : type_(value_t::offset_datetime), - region_info_(std::make_shared(std::move(reg))), - comments_(std::move(cm)) - { - assigner(this->offset_datetime_, odt); - } - basic_value(const array_type& ary, detail::region reg, - std::vector cm) - : type_(value_t::array), - region_info_(std::make_shared(std::move(reg))), - comments_(std::move(cm)) - { - assigner(this->array_, ary); - } - basic_value(const table_type& tab, detail::region reg, - std::vector cm) - : type_(value_t::table), - region_info_(std::make_shared(std::move(reg))), - comments_(std::move(cm)) - { - assigner(this->table_, tab); - } - - template::value, - std::nullptr_t>::type = nullptr> - basic_value(std::pair parse_result, std::vector comments) - : basic_value(std::move(parse_result.first), - std::move(parse_result.second), - std::move(comments)) - {} - - // type checking and casting ============================================ - - template::value, - std::nullptr_t>::type = nullptr> - bool is() const noexcept - { - return detail::type_to_enum::value == this->type_; - } - bool is(value_t t) const noexcept {return t == this->type_;} - - bool is_uninitialized() const noexcept {return this->is(value_t::empty );} - bool is_boolean() const noexcept {return this->is(value_t::boolean );} - bool is_integer() const noexcept {return this->is(value_t::integer );} - bool is_floating() const noexcept {return this->is(value_t::floating );} - bool is_string() const noexcept {return this->is(value_t::string );} - bool is_offset_datetime() const noexcept {return this->is(value_t::offset_datetime);} - bool is_local_datetime() const noexcept {return this->is(value_t::local_datetime );} - bool is_local_date() const noexcept {return this->is(value_t::local_date );} - bool is_local_time() const noexcept {return this->is(value_t::local_time );} - bool is_array() const noexcept {return this->is(value_t::array );} - bool is_table() const noexcept {return this->is(value_t::table );} - - value_t type() const noexcept {return type_;} - - template - typename detail::enum_to_type::type& cast() & - { - if(this->type_ != T) - { - detail::throw_bad_cast("toml::value::cast: ", this->type_, *this); - } - return detail::switch_cast::invoke(*this); - } - template - typename detail::enum_to_type::type const& cast() const& - { - if(this->type_ != T) - { - detail::throw_bad_cast("toml::value::cast: ", this->type_, *this); - } - return detail::switch_cast::invoke(*this); - } - template - typename detail::enum_to_type::type&& cast() && - { - if(this->type_ != T) - { - detail::throw_bad_cast("toml::value::cast: ", this->type_, *this); - } - return detail::switch_cast::invoke(std::move(*this)); - } - - // ------------------------------------------------------------------------ - // nothrow version - - boolean const& as_boolean (const std::nothrow_t&) const& noexcept {return this->boolean_;} - integer const& as_integer (const std::nothrow_t&) const& noexcept {return this->integer_;} - floating const& as_floating (const std::nothrow_t&) const& noexcept {return this->floating_;} - string const& as_string (const std::nothrow_t&) const& noexcept {return this->string_;} - offset_datetime const& as_offset_datetime(const std::nothrow_t&) const& noexcept {return this->offset_datetime_;} - local_datetime const& as_local_datetime (const std::nothrow_t&) const& noexcept {return this->local_datetime_;} - local_date const& as_local_date (const std::nothrow_t&) const& noexcept {return this->local_date_;} - local_time const& as_local_time (const std::nothrow_t&) const& noexcept {return this->local_time_;} - array_type const& as_array (const std::nothrow_t&) const& noexcept {return this->array_.value();} - table_type const& as_table (const std::nothrow_t&) const& noexcept {return this->table_.value();} - - boolean & as_boolean (const std::nothrow_t&) & noexcept {return this->boolean_;} - integer & as_integer (const std::nothrow_t&) & noexcept {return this->integer_;} - floating & as_floating (const std::nothrow_t&) & noexcept {return this->floating_;} - string & as_string (const std::nothrow_t&) & noexcept {return this->string_;} - offset_datetime& as_offset_datetime(const std::nothrow_t&) & noexcept {return this->offset_datetime_;} - local_datetime & as_local_datetime (const std::nothrow_t&) & noexcept {return this->local_datetime_;} - local_date & as_local_date (const std::nothrow_t&) & noexcept {return this->local_date_;} - local_time & as_local_time (const std::nothrow_t&) & noexcept {return this->local_time_;} - array_type & as_array (const std::nothrow_t&) & noexcept {return this->array_.value();} - table_type & as_table (const std::nothrow_t&) & noexcept {return this->table_.value();} - - boolean && as_boolean (const std::nothrow_t&) && noexcept {return std::move(this->boolean_);} - integer && as_integer (const std::nothrow_t&) && noexcept {return std::move(this->integer_);} - floating && as_floating (const std::nothrow_t&) && noexcept {return std::move(this->floating_);} - string && as_string (const std::nothrow_t&) && noexcept {return std::move(this->string_);} - offset_datetime&& as_offset_datetime(const std::nothrow_t&) && noexcept {return std::move(this->offset_datetime_);} - local_datetime && as_local_datetime (const std::nothrow_t&) && noexcept {return std::move(this->local_datetime_);} - local_date && as_local_date (const std::nothrow_t&) && noexcept {return std::move(this->local_date_);} - local_time && as_local_time (const std::nothrow_t&) && noexcept {return std::move(this->local_time_);} - array_type && as_array (const std::nothrow_t&) && noexcept {return std::move(this->array_.value());} - table_type && as_table (const std::nothrow_t&) && noexcept {return std::move(this->table_.value());} - - // ======================================================================== - // throw version - // ------------------------------------------------------------------------ - // const reference {{{ - - boolean const& as_boolean() const& - { - if(this->type_ != value_t::boolean) - { - detail::throw_bad_cast( - "toml::value::as_boolean(): ", this->type_, *this); - } - return this->boolean_; - } - integer const& as_integer() const& - { - if(this->type_ != value_t::integer) - { - detail::throw_bad_cast( - "toml::value::as_integer(): ", this->type_, *this); - } - return this->integer_; - } - floating const& as_floating() const& - { - if(this->type_ != value_t::floating) - { - detail::throw_bad_cast( - "toml::value::as_floating(): ", this->type_, *this); - } - return this->floating_; - } - string const& as_string() const& - { - if(this->type_ != value_t::string) - { - detail::throw_bad_cast( - "toml::value::as_string(): ", this->type_, *this); - } - return this->string_; - } - offset_datetime const& as_offset_datetime() const& - { - if(this->type_ != value_t::offset_datetime) - { - detail::throw_bad_cast( - "toml::value::as_offset_datetime(): ", this->type_, *this); - } - return this->offset_datetime_; - } - local_datetime const& as_local_datetime() const& - { - if(this->type_ != value_t::local_datetime) - { - detail::throw_bad_cast( - "toml::value::as_local_datetime(): ", this->type_, *this); - } - return this->local_datetime_; - } - local_date const& as_local_date() const& - { - if(this->type_ != value_t::local_date) - { - detail::throw_bad_cast( - "toml::value::as_local_date(): ", this->type_, *this); - } - return this->local_date_; - } - local_time const& as_local_time() const& - { - if(this->type_ != value_t::local_time) - { - detail::throw_bad_cast( - "toml::value::as_local_time(): ", this->type_, *this); - } - return this->local_time_; - } - array_type const& as_array() const& - { - if(this->type_ != value_t::array) - { - detail::throw_bad_cast( - "toml::value::as_array(): ", this->type_, *this); - } - return this->array_.value(); - } - table_type const& as_table() const& - { - if(this->type_ != value_t::table) - { - detail::throw_bad_cast( - "toml::value::as_table(): ", this->type_, *this); - } - return this->table_.value(); - } - // }}} - // ------------------------------------------------------------------------ - // nonconst reference {{{ - - boolean & as_boolean() & - { - if(this->type_ != value_t::boolean) - { - detail::throw_bad_cast( - "toml::value::as_boolean(): ", this->type_, *this); - } - return this->boolean_; - } - integer & as_integer() & - { - if(this->type_ != value_t::integer) - { - detail::throw_bad_cast( - "toml::value::as_integer(): ", this->type_, *this); - } - return this->integer_; - } - floating & as_floating() & - { - if(this->type_ != value_t::floating) - { - detail::throw_bad_cast( - "toml::value::as_floating(): ", this->type_, *this); - } - return this->floating_; - } - string & as_string() & - { - if(this->type_ != value_t::string) - { - detail::throw_bad_cast( - "toml::value::as_string(): ", this->type_, *this); - } - return this->string_; - } - offset_datetime & as_offset_datetime() & - { - if(this->type_ != value_t::offset_datetime) - { - detail::throw_bad_cast( - "toml::value::as_offset_datetime(): ", this->type_, *this); - } - return this->offset_datetime_; - } - local_datetime & as_local_datetime() & - { - if(this->type_ != value_t::local_datetime) - { - detail::throw_bad_cast( - "toml::value::as_local_datetime(): ", this->type_, *this); - } - return this->local_datetime_; - } - local_date & as_local_date() & - { - if(this->type_ != value_t::local_date) - { - detail::throw_bad_cast( - "toml::value::as_local_date(): ", this->type_, *this); - } - return this->local_date_; - } - local_time & as_local_time() & - { - if(this->type_ != value_t::local_time) - { - detail::throw_bad_cast( - "toml::value::as_local_time(): ", this->type_, *this); - } - return this->local_time_; - } - array_type & as_array() & - { - if(this->type_ != value_t::array) - { - detail::throw_bad_cast( - "toml::value::as_array(): ", this->type_, *this); - } - return this->array_.value(); - } - table_type & as_table() & - { - if(this->type_ != value_t::table) - { - detail::throw_bad_cast( - "toml::value::as_table(): ", this->type_, *this); - } - return this->table_.value(); - } - - // }}} - // ------------------------------------------------------------------------ - // rvalue reference {{{ - - boolean && as_boolean() && - { - if(this->type_ != value_t::boolean) - { - detail::throw_bad_cast( - "toml::value::as_boolean(): ", this->type_, *this); - } - return std::move(this->boolean_); - } - integer && as_integer() && - { - if(this->type_ != value_t::integer) - { - detail::throw_bad_cast( - "toml::value::as_integer(): ", this->type_, *this); - } - return std::move(this->integer_); - } - floating && as_floating() && - { - if(this->type_ != value_t::floating) - { - detail::throw_bad_cast( - "toml::value::as_floating(): ", this->type_, *this); - } - return std::move(this->floating_); - } - string && as_string() && - { - if(this->type_ != value_t::string) - { - detail::throw_bad_cast( - "toml::value::as_string(): ", this->type_, *this); - } - return std::move(this->string_); - } - offset_datetime && as_offset_datetime() && - { - if(this->type_ != value_t::offset_datetime) - { - detail::throw_bad_cast( - "toml::value::as_offset_datetime(): ", this->type_, *this); - } - return std::move(this->offset_datetime_); - } - local_datetime && as_local_datetime() && - { - if(this->type_ != value_t::local_datetime) - { - detail::throw_bad_cast( - "toml::value::as_local_datetime(): ", this->type_, *this); - } - return std::move(this->local_datetime_); - } - local_date && as_local_date() && - { - if(this->type_ != value_t::local_date) - { - detail::throw_bad_cast( - "toml::value::as_local_date(): ", this->type_, *this); - } - return std::move(this->local_date_); - } - local_time && as_local_time() && - { - if(this->type_ != value_t::local_time) - { - detail::throw_bad_cast( - "toml::value::as_local_time(): ", this->type_, *this); - } - return std::move(this->local_time_); - } - array_type && as_array() && - { - if(this->type_ != value_t::array) - { - detail::throw_bad_cast( - "toml::value::as_array(): ", this->type_, *this); - } - return std::move(this->array_.value()); - } - table_type && as_table() && - { - if(this->type_ != value_t::table) - { - detail::throw_bad_cast( - "toml::value::as_table(): ", this->type_, *this); - } - return std::move(this->table_.value()); - } - // }}} - - // accessors ============================================================= - // - // may throw type_error or out_of_range - // - value_type& at(const key& k) - { - if(!this->is_table()) - { - detail::throw_bad_cast( - "toml::value::at(key): ", this->type_, *this); - } - if(this->as_table(std::nothrow).count(k) == 0) - { - detail::throw_key_not_found_error(*this, k); - } - return this->as_table(std::nothrow).at(k); - } - value_type const& at(const key& k) const - { - if(!this->is_table()) - { - detail::throw_bad_cast( - "toml::value::at(key): ", this->type_, *this); - } - if(this->as_table(std::nothrow).count(k) == 0) - { - detail::throw_key_not_found_error(*this, k); - } - return this->as_table(std::nothrow).at(k); - } - value_type& operator[](const key& k) - { - if(this->is_uninitialized()) - { - *this = table_type{}; - } - else if(!this->is_table()) // initialized, but not a table - { - detail::throw_bad_cast( - "toml::value::operator[](key): ", this->type_, *this); - } - return this->as_table(std::nothrow)[k]; - } - - value_type& at(const std::size_t idx) - { - if(!this->is_array()) - { - detail::throw_bad_cast( - "toml::value::at(idx): ", this->type_, *this); - } - if(this->as_array(std::nothrow).size() <= idx) - { - throw std::out_of_range(detail::format_underline( - "toml::value::at(idx): no element corresponding to the index", { - {this->location(), concat_to_string("the length is ", - this->as_array(std::nothrow).size(), - ", and the specified index is ", idx)} - })); - } - return this->as_array().at(idx); - } - value_type const& at(const std::size_t idx) const - { - if(!this->is_array()) - { - detail::throw_bad_cast( - "toml::value::at(idx): ", this->type_, *this); - } - if(this->as_array(std::nothrow).size() <= idx) - { - throw std::out_of_range(detail::format_underline( - "toml::value::at(idx): no element corresponding to the index", { - {this->location(), concat_to_string("the length is ", - this->as_array(std::nothrow).size(), - ", and the specified index is ", idx)} - })); - } - return this->as_array(std::nothrow).at(idx); - } - - value_type& operator[](const std::size_t idx) noexcept - { - // no check... - return this->as_array(std::nothrow)[idx]; - } - value_type const& operator[](const std::size_t idx) const noexcept - { - // no check... - return this->as_array(std::nothrow)[idx]; - } - - void push_back(const value_type& x) - { - if(!this->is_array()) - { - detail::throw_bad_cast( - "toml::value::push_back(value): ", this->type_, *this); - } - this->as_array(std::nothrow).push_back(x); - return; - } - void push_back(value_type&& x) - { - if(!this->is_array()) - { - detail::throw_bad_cast( - "toml::value::push_back(value): ", this->type_, *this); - } - this->as_array(std::nothrow).push_back(std::move(x)); - return; - } - - template - value_type& emplace_back(Ts&& ... args) - { - if(!this->is_array()) - { - detail::throw_bad_cast( - "toml::value::emplace_back(...): ", this->type_, *this); - } - this->as_array(std::nothrow).emplace_back(std::forward(args) ...); - return this->as_array(std::nothrow).back(); - } - - std::size_t size() const - { - switch(this->type_) - { - case value_t::array: - { - return this->as_array(std::nothrow).size(); - } - case value_t::table: - { - return this->as_table(std::nothrow).size(); - } - case value_t::string: - { - return this->as_string(std::nothrow).str.size(); - } - default: - { - throw type_error(detail::format_underline( - "toml::value::size(): bad_cast to container types", { - {this->location(), - concat_to_string("the actual type is ", this->type_)} - }), this->location()); - } - } - } - - std::size_t count(const key_type& k) const - { - if(!this->is_table()) - { - detail::throw_bad_cast( - "toml::value::count(key): ", this->type_, *this); - } - return this->as_table(std::nothrow).count(k); - } - - bool contains(const key_type& k) const - { - if(!this->is_table()) - { - detail::throw_bad_cast( - "toml::value::contains(key): ", this->type_, *this); - } - return (this->as_table(std::nothrow).count(k) != 0); - } - - source_location location() const - { - return source_location(this->region_info_.get()); - } - - comment_type const& comments() const noexcept {return this->comments_;} - comment_type& comments() noexcept {return this->comments_;} - - private: - - void cleanup() noexcept - { - switch(this->type_) - { - case value_t::string : {string_.~string(); return;} - case value_t::array : {array_.~array_storage(); return;} - case value_t::table : {table_.~table_storage(); return;} - default : return; - } - } - - // for error messages - template - friend region_base const* detail::get_region(const Value& v); - - template - friend void detail::change_region(Value& v, detail::region reg); - - private: - - using array_storage = detail::storage; - using table_storage = detail::storage; - - value_t type_; - union - { - boolean boolean_; - integer integer_; - floating floating_; - string string_; - offset_datetime offset_datetime_; - local_datetime local_datetime_; - local_date local_date_; - local_time local_time_; - array_storage array_; - table_storage table_; - }; - std::shared_ptr region_info_; - comment_type comments_; -}; - -// default toml::value and default array/table. -using value = basic_value; -using array = typename value::array_type; -using table = typename value::table_type; - -template class T, template class A> -inline bool -operator==(const basic_value& lhs, const basic_value& rhs) -{ - if(lhs.type() != rhs.type()) {return false;} - if(lhs.comments() != rhs.comments()) {return false;} - - switch(lhs.type()) - { - case value_t::boolean : - { - return lhs.as_boolean() == rhs.as_boolean(); - } - case value_t::integer : - { - return lhs.as_integer() == rhs.as_integer(); - } - case value_t::floating : - { - return lhs.as_floating() == rhs.as_floating(); - } - case value_t::string : - { - return lhs.as_string() == rhs.as_string(); - } - case value_t::offset_datetime: - { - return lhs.as_offset_datetime() == rhs.as_offset_datetime(); - } - case value_t::local_datetime: - { - return lhs.as_local_datetime() == rhs.as_local_datetime(); - } - case value_t::local_date: - { - return lhs.as_local_date() == rhs.as_local_date(); - } - case value_t::local_time: - { - return lhs.as_local_time() == rhs.as_local_time(); - } - case value_t::array : - { - return lhs.as_array() == rhs.as_array(); - } - case value_t::table : - { - return lhs.as_table() == rhs.as_table(); - } - case value_t::empty : {return true; } - default: {return false;} - } -} - -template class T, template class A> -inline bool operator!=(const basic_value& lhs, const basic_value& rhs) -{ - return !(lhs == rhs); -} - -template class T, template class A> -typename std::enable_if::array_type>, - detail::is_comparable::table_type> - >::value, bool>::type -operator<(const basic_value& lhs, const basic_value& rhs) -{ - if(lhs.type() != rhs.type()){return (lhs.type() < rhs.type());} - switch(lhs.type()) - { - case value_t::boolean : - { - return lhs.as_boolean() < rhs.as_boolean() || - (lhs.as_boolean() == rhs.as_boolean() && - lhs.comments() < rhs.comments()); - } - case value_t::integer : - { - return lhs.as_integer() < rhs.as_integer() || - (lhs.as_integer() == rhs.as_integer() && - lhs.comments() < rhs.comments()); - } - case value_t::floating : - { - return lhs.as_floating() < rhs.as_floating() || - (lhs.as_floating() == rhs.as_floating() && - lhs.comments() < rhs.comments()); - } - case value_t::string : - { - return lhs.as_string() < rhs.as_string() || - (lhs.as_string() == rhs.as_string() && - lhs.comments() < rhs.comments()); - } - case value_t::offset_datetime: - { - return lhs.as_offset_datetime() < rhs.as_offset_datetime() || - (lhs.as_offset_datetime() == rhs.as_offset_datetime() && - lhs.comments() < rhs.comments()); - } - case value_t::local_datetime: - { - return lhs.as_local_datetime() < rhs.as_local_datetime() || - (lhs.as_local_datetime() == rhs.as_local_datetime() && - lhs.comments() < rhs.comments()); - } - case value_t::local_date: - { - return lhs.as_local_date() < rhs.as_local_date() || - (lhs.as_local_date() == rhs.as_local_date() && - lhs.comments() < rhs.comments()); - } - case value_t::local_time: - { - return lhs.as_local_time() < rhs.as_local_time() || - (lhs.as_local_time() == rhs.as_local_time() && - lhs.comments() < rhs.comments()); - } - case value_t::array : - { - return lhs.as_array() < rhs.as_array() || - (lhs.as_array() == rhs.as_array() && - lhs.comments() < rhs.comments()); - } - case value_t::table : - { - return lhs.as_table() < rhs.as_table() || - (lhs.as_table() == rhs.as_table() && - lhs.comments() < rhs.comments()); - } - case value_t::empty : - { - return lhs.comments() < rhs.comments(); - } - default: - { - return lhs.comments() < rhs.comments(); - } - } -} - -template class T, template class A> -typename std::enable_if::array_type>, - detail::is_comparable::table_type> - >::value, bool>::type -operator<=(const basic_value& lhs, const basic_value& rhs) -{ - return (lhs < rhs) || (lhs == rhs); -} -template class T, template class A> -typename std::enable_if::array_type>, - detail::is_comparable::table_type> - >::value, bool>::type -operator>(const basic_value& lhs, const basic_value& rhs) -{ - return !(lhs <= rhs); -} -template class T, template class A> -typename std::enable_if::array_type>, - detail::is_comparable::table_type> - >::value, bool>::type -operator>=(const basic_value& lhs, const basic_value& rhs) -{ - return !(lhs < rhs); -} - -template class T, template class A> -inline std::string format_error(const std::string& err_msg, - const basic_value& v, const std::string& comment, - std::vector hints = {}, - const bool colorize = TOML11_ERROR_MESSAGE_COLORIZED) -{ - return detail::format_underline(err_msg, {{v.location(), comment}}, - std::move(hints), colorize); -} - -template class T, template class A> -inline std::string format_error(const std::string& err_msg, - const toml::basic_value& v1, const std::string& comment1, - const toml::basic_value& v2, const std::string& comment2, - std::vector hints = {}, - const bool colorize = TOML11_ERROR_MESSAGE_COLORIZED) -{ - return detail::format_underline(err_msg, { - {v1.location(), comment1}, {v2.location(), comment2} - }, std::move(hints), colorize); -} - -template class T, template class A> -inline std::string format_error(const std::string& err_msg, - const toml::basic_value& v1, const std::string& comment1, - const toml::basic_value& v2, const std::string& comment2, - const toml::basic_value& v3, const std::string& comment3, - std::vector hints = {}, - const bool colorize = TOML11_ERROR_MESSAGE_COLORIZED) -{ - return detail::format_underline(err_msg, {{v1.location(), comment1}, - {v2.location(), comment2}, {v3.location(), comment3} - }, std::move(hints), colorize); -} - -template class T, template class A> -detail::return_type_of_t -visit(Visitor&& visitor, const toml::basic_value& v) -{ - switch(v.type()) - { - case value_t::boolean : {return visitor(v.as_boolean ());} - case value_t::integer : {return visitor(v.as_integer ());} - case value_t::floating : {return visitor(v.as_floating ());} - case value_t::string : {return visitor(v.as_string ());} - case value_t::offset_datetime: {return visitor(v.as_offset_datetime());} - case value_t::local_datetime : {return visitor(v.as_local_datetime ());} - case value_t::local_date : {return visitor(v.as_local_date ());} - case value_t::local_time : {return visitor(v.as_local_time ());} - case value_t::array : {return visitor(v.as_array ());} - case value_t::table : {return visitor(v.as_table ());} - case value_t::empty : break; - default: break; - } - throw std::runtime_error(format_error("[error] toml::visit: toml::basic_value " - "does not have any valid basic_value.", v, "here")); -} - -template class T, template class A> -detail::return_type_of_t -visit(Visitor&& visitor, toml::basic_value& v) -{ - switch(v.type()) - { - case value_t::boolean : {return visitor(v.as_boolean ());} - case value_t::integer : {return visitor(v.as_integer ());} - case value_t::floating : {return visitor(v.as_floating ());} - case value_t::string : {return visitor(v.as_string ());} - case value_t::offset_datetime: {return visitor(v.as_offset_datetime());} - case value_t::local_datetime : {return visitor(v.as_local_datetime ());} - case value_t::local_date : {return visitor(v.as_local_date ());} - case value_t::local_time : {return visitor(v.as_local_time ());} - case value_t::array : {return visitor(v.as_array ());} - case value_t::table : {return visitor(v.as_table ());} - case value_t::empty : break; - default: break; - } - throw std::runtime_error(format_error("[error] toml::visit: toml::basic_value " - "does not have any valid basic_value.", v, "here")); -} - -template class T, template class A> -detail::return_type_of_t -visit(Visitor&& visitor, toml::basic_value&& v) -{ - switch(v.type()) - { - case value_t::boolean : {return visitor(std::move(v.as_boolean ()));} - case value_t::integer : {return visitor(std::move(v.as_integer ()));} - case value_t::floating : {return visitor(std::move(v.as_floating ()));} - case value_t::string : {return visitor(std::move(v.as_string ()));} - case value_t::offset_datetime: {return visitor(std::move(v.as_offset_datetime()));} - case value_t::local_datetime : {return visitor(std::move(v.as_local_datetime ()));} - case value_t::local_date : {return visitor(std::move(v.as_local_date ()));} - case value_t::local_time : {return visitor(std::move(v.as_local_time ()));} - case value_t::array : {return visitor(std::move(v.as_array ()));} - case value_t::table : {return visitor(std::move(v.as_table ()));} - case value_t::empty : break; - default: break; - } - throw std::runtime_error(format_error("[error] toml::visit: toml::basic_value " - "does not have any valid basic_value.", v, "here")); -} - -}// toml -#endif// TOML11_VALUE diff --git a/libraries/tomlc99/CMakeLists.txt b/libraries/tomlc99/CMakeLists.txt new file mode 100644 index 00000000..60786923 --- /dev/null +++ b/libraries/tomlc99/CMakeLists.txt @@ -0,0 +1,10 @@ +project(tomlc99) + +set(tomlc99_SOURCES +include/toml.h +src/toml.c +) + +add_library(tomlc99 STATIC ${tomlc99_SOURCES}) + +target_include_directories(tomlc99 PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/include) diff --git a/libraries/toml11/LICENSE b/libraries/tomlc99/LICENSE similarity index 85% rename from libraries/toml11/LICENSE rename to libraries/tomlc99/LICENSE index f55c511d..a3292b16 100644 --- a/libraries/toml11/LICENSE +++ b/libraries/tomlc99/LICENSE @@ -1,6 +1,7 @@ -The MIT License (MIT) +MIT License -Copyright (c) 2017 Toru Niina +Copyright (c) 2017 CK Tan +https://github.com/cktan/tomlc99 Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal @@ -9,13 +10,13 @@ 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 above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN -THE SOFTWARE. +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/libraries/tomlc99/README.md b/libraries/tomlc99/README.md new file mode 100644 index 00000000..6715b5be --- /dev/null +++ b/libraries/tomlc99/README.md @@ -0,0 +1,194 @@ +# tomlc99 + +TOML in c99; v1.0 compliant. + +If you are looking for a C++ library, you might try this wrapper: [https://github.com/cktan/tomlcpp](https://github.com/cktan/tomlcpp). + +* Compatible with [TOML v1.0.0](https://toml.io/en/v1.0.0). +* Tested with multiple test suites, including +[BurntSushi/toml-test](https://github.com/BurntSushi/toml-test) and +[iarna/toml-spec-tests](https://github.com/iarna/toml-spec-tests). +* Provides very simple and intuitive interface. + + +## Usage + +Please see the `toml.h` file for details. What follows is a simple example that +parses this config file: + +```toml +[server] + host = "www.example.com" + port = [ 8080, 8181, 8282 ] +``` + +The steps for getting values from our file is usually : + +1. Parse the TOML file. +2. Traverse and locate a table in TOML. +3. Extract values from the table. +4. Free up allocated memory. + +Below is an example of parsing the values from the example table. + +```c +#include +#include +#include +#include +#include "toml.h" + +static void error(const char* msg, const char* msg1) +{ + fprintf(stderr, "ERROR: %s%s\n", msg, msg1?msg1:""); + exit(1); +} + + +int main() +{ + FILE* fp; + char errbuf[200]; + + // 1. Read and parse toml file + fp = fopen("sample.toml", "r"); + if (!fp) { + error("cannot open sample.toml - ", strerror(errno)); + } + + toml_table_t* conf = toml_parse_file(fp, errbuf, sizeof(errbuf)); + fclose(fp); + + if (!conf) { + error("cannot parse - ", errbuf); + } + + // 2. Traverse to a table. + toml_table_t* server = toml_table_in(conf, "server"); + if (!server) { + error("missing [server]", ""); + } + + // 3. Extract values + toml_datum_t host = toml_string_in(server, "host"); + if (!host.ok) { + error("cannot read server.host", ""); + } + + toml_array_t* portarray = toml_array_in(server, "port"); + if (!portarray) { + error("cannot read server.port", ""); + } + + printf("host: %s\n", host.u.s); + printf("port: "); + for (int i = 0; ; i++) { + toml_datum_t port = toml_int_at(portarray, i); + if (!port.ok) break; + printf("%d ", (int)port.u.i); + } + printf("\n"); + + // 4. Free memory + free(host.u.s); + toml_free(conf); + return 0; +} +``` + +#### Accessing Table Content + +TOML tables are dictionaries where lookups are done using string keys. In +general, all access functions on tables are named `toml_*_in(...)`. + +In the normal case, you know the key and its content type, and retrievals can be done +using one of these functions: +```c +toml_string_in(tab, key); +toml_bool_in(tab, key); +toml_int_in(tab, key); +toml_double_in(tab, key); +toml_timestamp_in(tab, key); +toml_table_in(tab, key); +toml_array_in(tab, key); +``` + +You can also interrogate the keys in a table using an integer index: +```c +toml_table_t* tab = toml_parse_file(...); +for (int i = 0; ; i++) { + const char* key = toml_key_in(tab, i); + if (!key) break; + printf("key %d: %s\n", i, key); +} +``` + +#### Accessing Array Content + +TOML arrays can be deref-ed using integer indices. In general, all access methods on arrays are named `toml_*_at()`. + +To obtain the size of an array: +```c +int size = toml_array_nelem(arr); +``` + +To obtain the content of an array, use a valid index and call one of these functions: +```c +toml_string_at(arr, idx); +toml_bool_at(arr, idx); +toml_int_at(arr, idx); +toml_double_at(arr, idx); +toml_timestamp_at(arr, idx); +toml_table_at(arr, idx); +toml_array_at(arr, idx); +``` + +#### toml_datum_t + +Some `toml_*_at` and `toml_*_in` functions return a toml_datum_t +structure. The `ok` flag in the structure indicates if the function +call was successful. If so, you may proceed to read the value +corresponding to the type of the content. + +For example: +``` +toml_datum_t host = toml_string_in(tab, "host"); +if (host.ok) { + printf("host: %s\n", host.u.s); + free(host.u.s); /* FREE applies to string and timestamp types only */ +} +``` + +** IMPORTANT: if the accessed value is a string or a timestamp, you must call `free(datum.u.s)` or `free(datum.u.ts)` respectively after usage. ** + +## Building and installing + +A normal *make* suffices. You can also simply include the +`toml.c` and `toml.h` files in your project. + +Invoking `make install` will install the header and library files into +/usr/local/{include,lib}. + +Alternatively, specify `make install prefix=/a/file/path` to install into +/a/file/path/{include,lib}. + +## Testing + +To test against the standard test set provided by BurntSushi/toml-test: + +```sh +% make +% cd test1 +% bash build.sh # do this once +% bash run.sh # this will run the test suite +``` + + +To test against the standard test set provided by iarna/toml: + +```sh +% make +% cd test2 +% bash build.sh # do this once +% bash run.sh # this will run the test suite +``` diff --git a/libraries/tomlc99/include/toml.h b/libraries/tomlc99/include/toml.h new file mode 100644 index 00000000..b91ef890 --- /dev/null +++ b/libraries/tomlc99/include/toml.h @@ -0,0 +1,175 @@ +/* + MIT License + + Copyright (c) 2017 - 2019 CK Tan + https://github.com/cktan/tomlc99 + + Permission is hereby granted, free of charge, to any person obtaining a copy + of this software and associated documentation files (the "Software"), to deal + in the Software without restriction, including without limitation the rights + to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + copies of the Software, and to permit persons to whom the Software is + furnished to do so, subject to the following conditions: + + The above copyright notice and this permission notice shall be included in all + copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + SOFTWARE. +*/ +#ifndef TOML_H +#define TOML_H + + +#include +#include + + +#ifdef __cplusplus +#define TOML_EXTERN extern "C" +#else +#define TOML_EXTERN extern +#endif + +typedef struct toml_timestamp_t toml_timestamp_t; +typedef struct toml_table_t toml_table_t; +typedef struct toml_array_t toml_array_t; +typedef struct toml_datum_t toml_datum_t; + +/* Parse a file. Return a table on success, or 0 otherwise. + * Caller must toml_free(the-return-value) after use. + */ +TOML_EXTERN toml_table_t* toml_parse_file(FILE* fp, + char* errbuf, + int errbufsz); + +/* Parse a string containing the full config. + * Return a table on success, or 0 otherwise. + * Caller must toml_free(the-return-value) after use. + */ +TOML_EXTERN toml_table_t* toml_parse(char* conf, /* NUL terminated, please. */ + char* errbuf, + int errbufsz); + +/* Free the table returned by toml_parse() or toml_parse_file(). Once + * this function is called, any handles accessed through this tab + * directly or indirectly are no longer valid. + */ +TOML_EXTERN void toml_free(toml_table_t* tab); + + +/* Timestamp types. The year, month, day, hour, minute, second, z + * fields may be NULL if they are not relevant. e.g. In a DATE + * type, the hour, minute, second and z fields will be NULLs. + */ +struct toml_timestamp_t { + struct { /* internal. do not use. */ + int year, month, day; + int hour, minute, second, millisec; + char z[10]; + } __buffer; + int *year, *month, *day; + int *hour, *minute, *second, *millisec; + char* z; +}; + + +/*----------------------------------------------------------------- + * Enhanced access methods + */ +struct toml_datum_t { + int ok; + union { + toml_timestamp_t* ts; /* ts must be freed after use */ + char* s; /* string value. s must be freed after use */ + int b; /* bool value */ + int64_t i; /* int value */ + double d; /* double value */ + } u; +}; + +/* on arrays: */ +/* ... retrieve size of array. */ +TOML_EXTERN int toml_array_nelem(const toml_array_t* arr); +/* ... retrieve values using index. */ +TOML_EXTERN toml_datum_t toml_string_at(const toml_array_t* arr, int idx); +TOML_EXTERN toml_datum_t toml_bool_at(const toml_array_t* arr, int idx); +TOML_EXTERN toml_datum_t toml_int_at(const toml_array_t* arr, int idx); +TOML_EXTERN toml_datum_t toml_double_at(const toml_array_t* arr, int idx); +TOML_EXTERN toml_datum_t toml_timestamp_at(const toml_array_t* arr, int idx); +/* ... retrieve array or table using index. */ +TOML_EXTERN toml_array_t* toml_array_at(const toml_array_t* arr, int idx); +TOML_EXTERN toml_table_t* toml_table_at(const toml_array_t* arr, int idx); + +/* on tables: */ +/* ... retrieve the key in table at keyidx. Return 0 if out of range. */ +TOML_EXTERN const char* toml_key_in(const toml_table_t* tab, int keyidx); +/* ... retrieve values using key. */ +TOML_EXTERN toml_datum_t toml_string_in(const toml_table_t* arr, const char* key); +TOML_EXTERN toml_datum_t toml_bool_in(const toml_table_t* arr, const char* key); +TOML_EXTERN toml_datum_t toml_int_in(const toml_table_t* arr, const char* key); +TOML_EXTERN toml_datum_t toml_double_in(const toml_table_t* arr, const char* key); +TOML_EXTERN toml_datum_t toml_timestamp_in(const toml_table_t* arr, const char* key); +/* .. retrieve array or table using key. */ +TOML_EXTERN toml_array_t* toml_array_in(const toml_table_t* tab, + const char* key); +TOML_EXTERN toml_table_t* toml_table_in(const toml_table_t* tab, + const char* key); + +/*----------------------------------------------------------------- + * lesser used + */ +/* Return the array kind: 't'able, 'a'rray, 'v'alue, 'm'ixed */ +TOML_EXTERN char toml_array_kind(const toml_array_t* arr); + +/* For array kind 'v'alue, return the type of values + i:int, d:double, b:bool, s:string, t:time, D:date, T:timestamp, 'm'ixed + 0 if unknown +*/ +TOML_EXTERN char toml_array_type(const toml_array_t* arr); + +/* Return the key of an array */ +TOML_EXTERN const char* toml_array_key(const toml_array_t* arr); + +/* Return the number of key-values in a table */ +TOML_EXTERN int toml_table_nkval(const toml_table_t* tab); + +/* Return the number of arrays in a table */ +TOML_EXTERN int toml_table_narr(const toml_table_t* tab); + +/* Return the number of sub-tables in a table */ +TOML_EXTERN int toml_table_ntab(const toml_table_t* tab); + +/* Return the key of a table*/ +TOML_EXTERN const char* toml_table_key(const toml_table_t* tab); + +/*-------------------------------------------------------------- + * misc + */ +TOML_EXTERN int toml_utf8_to_ucs(const char* orig, int len, int64_t* ret); +TOML_EXTERN int toml_ucs_to_utf8(int64_t code, char buf[6]); +TOML_EXTERN void toml_set_memutil(void* (*xxmalloc)(size_t), + void (*xxfree)(void*)); + + +/*-------------------------------------------------------------- + * deprecated + */ +/* A raw value, must be processed by toml_rto* before using. */ +typedef const char* toml_raw_t; +TOML_EXTERN toml_raw_t toml_raw_in(const toml_table_t* tab, const char* key); +TOML_EXTERN toml_raw_t toml_raw_at(const toml_array_t* arr, int idx); +TOML_EXTERN int toml_rtos(toml_raw_t s, char** ret); +TOML_EXTERN int toml_rtob(toml_raw_t s, int* ret); +TOML_EXTERN int toml_rtoi(toml_raw_t s, int64_t* ret); +TOML_EXTERN int toml_rtod(toml_raw_t s, double* ret); +TOML_EXTERN int toml_rtod_ex(toml_raw_t s, double* ret, char* buf, int buflen); +TOML_EXTERN int toml_rtots(toml_raw_t s, toml_timestamp_t* ret); + + +#endif /* TOML_H */ diff --git a/libraries/tomlc99/src/toml.c b/libraries/tomlc99/src/toml.c new file mode 100644 index 00000000..e46e62e6 --- /dev/null +++ b/libraries/tomlc99/src/toml.c @@ -0,0 +1,2300 @@ +/* + + MIT License + + Copyright (c) 2017 - 2021 CK Tan + https://github.com/cktan/tomlc99 + + Permission is hereby granted, free of charge, to any person obtaining a copy + of this software and associated documentation files (the "Software"), to deal + in the Software without restriction, including without limitation the rights + to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + copies of the Software, and to permit persons to whom the Software is + furnished to do so, subject to the following conditions: + + The above copyright notice and this permission notice shall be included in all + copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + SOFTWARE. + +*/ +#define _POSIX_C_SOURCE 200809L +#include +#include +#include +#include +#include +#include +#include +#include +#include "toml.h" + + +static void* (*ppmalloc)(size_t) = malloc; +static void (*ppfree)(void*) = free; + +void toml_set_memutil(void* (*xxmalloc)(size_t), + void (*xxfree)(void*)) +{ + if (xxmalloc) ppmalloc = xxmalloc; + if (xxfree) ppfree = xxfree; +} + + +#define MALLOC(a) ppmalloc(a) +#define FREE(a) ppfree(a) + +static void* CALLOC(size_t nmemb, size_t sz) +{ + int nb = sz * nmemb; + void* p = MALLOC(nb); + if (p) { + memset(p, 0, nb); + } + return p; +} + + +static char* STRDUP(const char* s) +{ + int len = strlen(s); + char* p = MALLOC(len+1); + if (p) { + memcpy(p, s, len); + p[len] = 0; + } + return p; +} + +static char* STRNDUP(const char* s, size_t n) +{ + size_t len = strnlen(s, n); + char* p = MALLOC(len+1); + if (p) { + memcpy(p, s, len); + p[len] = 0; + } + return p; +} + + + +/** + * Convert a char in utf8 into UCS, and store it in *ret. + * Return #bytes consumed or -1 on failure. + */ +int toml_utf8_to_ucs(const char* orig, int len, int64_t* ret) +{ + const unsigned char* buf = (const unsigned char*) orig; + unsigned i = *buf++; + int64_t v; + + /* 0x00000000 - 0x0000007F: + 0xxxxxxx + */ + if (0 == (i >> 7)) { + if (len < 1) return -1; + v = i; + return *ret = v, 1; + } + /* 0x00000080 - 0x000007FF: + 110xxxxx 10xxxxxx + */ + if (0x6 == (i >> 5)) { + if (len < 2) return -1; + v = i & 0x1f; + for (int j = 0; j < 1; j++) { + i = *buf++; + if (0x2 != (i >> 6)) return -1; + v = (v << 6) | (i & 0x3f); + } + return *ret = v, (const char*) buf - orig; + } + + /* 0x00000800 - 0x0000FFFF: + 1110xxxx 10xxxxxx 10xxxxxx + */ + if (0xE == (i >> 4)) { + if (len < 3) return -1; + v = i & 0x0F; + for (int j = 0; j < 2; j++) { + i = *buf++; + if (0x2 != (i >> 6)) return -1; + v = (v << 6) | (i & 0x3f); + } + return *ret = v, (const char*) buf - orig; + } + + /* 0x00010000 - 0x001FFFFF: + 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx + */ + if (0x1E == (i >> 3)) { + if (len < 4) return -1; + v = i & 0x07; + for (int j = 0; j < 3; j++) { + i = *buf++; + if (0x2 != (i >> 6)) return -1; + v = (v << 6) | (i & 0x3f); + } + return *ret = v, (const char*) buf - orig; + } + + /* 0x00200000 - 0x03FFFFFF: + 111110xx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx + */ + if (0x3E == (i >> 2)) { + if (len < 5) return -1; + v = i & 0x03; + for (int j = 0; j < 4; j++) { + i = *buf++; + if (0x2 != (i >> 6)) return -1; + v = (v << 6) | (i & 0x3f); + } + return *ret = v, (const char*) buf - orig; + } + + /* 0x04000000 - 0x7FFFFFFF: + 1111110x 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx + */ + if (0x7e == (i >> 1)) { + if (len < 6) return -1; + v = i & 0x01; + for (int j = 0; j < 5; j++) { + i = *buf++; + if (0x2 != (i >> 6)) return -1; + v = (v << 6) | (i & 0x3f); + } + return *ret = v, (const char*) buf - orig; + } + return -1; +} + + +/** + * Convert a UCS char to utf8 code, and return it in buf. + * Return #bytes used in buf to encode the char, or + * -1 on error. + */ +int toml_ucs_to_utf8(int64_t code, char buf[6]) +{ + /* http://stackoverflow.com/questions/6240055/manually-converting-unicode-codepoints-into-utf-8-and-utf-16 */ + /* The UCS code values 0xd800–0xdfff (UTF-16 surrogates) as well + * as 0xfffe and 0xffff (UCS noncharacters) should not appear in + * conforming UTF-8 streams. + */ + if (0xd800 <= code && code <= 0xdfff) return -1; + if (0xfffe <= code && code <= 0xffff) return -1; + + /* 0x00000000 - 0x0000007F: + 0xxxxxxx + */ + if (code < 0) return -1; + if (code <= 0x7F) { + buf[0] = (unsigned char) code; + return 1; + } + + /* 0x00000080 - 0x000007FF: + 110xxxxx 10xxxxxx + */ + if (code <= 0x000007FF) { + buf[0] = 0xc0 | (code >> 6); + buf[1] = 0x80 | (code & 0x3f); + return 2; + } + + /* 0x00000800 - 0x0000FFFF: + 1110xxxx 10xxxxxx 10xxxxxx + */ + if (code <= 0x0000FFFF) { + buf[0] = 0xe0 | (code >> 12); + buf[1] = 0x80 | ((code >> 6) & 0x3f); + buf[2] = 0x80 | (code & 0x3f); + return 3; + } + + /* 0x00010000 - 0x001FFFFF: + 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx + */ + if (code <= 0x001FFFFF) { + buf[0] = 0xf0 | (code >> 18); + buf[1] = 0x80 | ((code >> 12) & 0x3f); + buf[2] = 0x80 | ((code >> 6) & 0x3f); + buf[3] = 0x80 | (code & 0x3f); + return 4; + } + + /* 0x00200000 - 0x03FFFFFF: + 111110xx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx + */ + if (code <= 0x03FFFFFF) { + buf[0] = 0xf8 | (code >> 24); + buf[1] = 0x80 | ((code >> 18) & 0x3f); + buf[2] = 0x80 | ((code >> 12) & 0x3f); + buf[3] = 0x80 | ((code >> 6) & 0x3f); + buf[4] = 0x80 | (code & 0x3f); + return 5; + } + + /* 0x04000000 - 0x7FFFFFFF: + 1111110x 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx + */ + if (code <= 0x7FFFFFFF) { + buf[0] = 0xfc | (code >> 30); + buf[1] = 0x80 | ((code >> 24) & 0x3f); + buf[2] = 0x80 | ((code >> 18) & 0x3f); + buf[3] = 0x80 | ((code >> 12) & 0x3f); + buf[4] = 0x80 | ((code >> 6) & 0x3f); + buf[5] = 0x80 | (code & 0x3f); + return 6; + } + + return -1; +} + +/* + * TOML has 3 data structures: value, array, table. + * Each of them can have identification key. + */ +typedef struct toml_keyval_t toml_keyval_t; +struct toml_keyval_t { + const char* key; /* key to this value */ + const char* val; /* the raw value */ +}; + +typedef struct toml_arritem_t toml_arritem_t; +struct toml_arritem_t { + int valtype; /* for value kind: 'i'nt, 'd'ouble, 'b'ool, 's'tring, 't'ime, 'D'ate, 'T'imestamp */ + char* val; + toml_array_t* arr; + toml_table_t* tab; +}; + + +struct toml_array_t { + const char* key; /* key to this array */ + int kind; /* element kind: 'v'alue, 'a'rray, or 't'able, 'm'ixed */ + int type; /* for value kind: 'i'nt, 'd'ouble, 'b'ool, 's'tring, 't'ime, 'D'ate, 'T'imestamp, 'm'ixed */ + + int nitem; /* number of elements */ + toml_arritem_t* item; +}; + + +struct toml_table_t { + const char* key; /* key to this table */ + bool implicit; /* table was created implicitly */ + bool readonly; /* no more modification allowed */ + + /* key-values in the table */ + int nkval; + toml_keyval_t** kval; + + /* arrays in the table */ + int narr; + toml_array_t** arr; + + /* tables in the table */ + int ntab; + toml_table_t** tab; +}; + + +static inline void xfree(const void* x) { if (x) FREE((void*)(intptr_t)x); } + + +enum tokentype_t { + INVALID, + DOT, + COMMA, + EQUAL, + LBRACE, + RBRACE, + NEWLINE, + LBRACKET, + RBRACKET, + STRING, +}; +typedef enum tokentype_t tokentype_t; + +typedef struct token_t token_t; +struct token_t { + tokentype_t tok; + int lineno; + char* ptr; /* points into context->start */ + int len; + int eof; +}; + + +typedef struct context_t context_t; +struct context_t { + char* start; + char* stop; + char* errbuf; + int errbufsz; + + token_t tok; + toml_table_t* root; + toml_table_t* curtab; + + struct { + int top; + char* key[10]; + token_t tok[10]; + } tpath; + +}; + +#define STRINGIFY(x) #x +#define TOSTRING(x) STRINGIFY(x) +#define FLINE __FILE__ ":" TOSTRING(__LINE__) + +static int next_token(context_t* ctx, int dotisspecial); + +/* + Error reporting. Call when an error is detected. Always return -1. +*/ +static int e_outofmemory(context_t* ctx, const char* fline) +{ + snprintf(ctx->errbuf, ctx->errbufsz, "ERROR: out of memory (%s)", fline); + return -1; +} + + +static int e_internal(context_t* ctx, const char* fline) +{ + snprintf(ctx->errbuf, ctx->errbufsz, "internal error (%s)", fline); + return -1; +} + +static int e_syntax(context_t* ctx, int lineno, const char* msg) +{ + snprintf(ctx->errbuf, ctx->errbufsz, "line %d: %s", lineno, msg); + return -1; +} + +static int e_badkey(context_t* ctx, int lineno) +{ + snprintf(ctx->errbuf, ctx->errbufsz, "line %d: bad key", lineno); + return -1; +} + +static int e_keyexists(context_t* ctx, int lineno) +{ + snprintf(ctx->errbuf, ctx->errbufsz, "line %d: key exists", lineno); + return -1; +} + +static int e_forbid(context_t* ctx, int lineno, const char* msg) +{ + snprintf(ctx->errbuf, ctx->errbufsz, "line %d: %s", lineno, msg); + return -1; +} + +static void* expand(void* p, int sz, int newsz) +{ + void* s = MALLOC(newsz); + if (!s) return 0; + + memcpy(s, p, sz); + FREE(p); + return s; +} + +static void** expand_ptrarr(void** p, int n) +{ + void** s = MALLOC((n+1) * sizeof(void*)); + if (!s) return 0; + + s[n] = 0; + memcpy(s, p, n * sizeof(void*)); + FREE(p); + return s; +} + +static toml_arritem_t* expand_arritem(toml_arritem_t* p, int n) +{ + toml_arritem_t* pp = expand(p, n*sizeof(*p), (n+1)*sizeof(*p)); + if (!pp) return 0; + + memset(&pp[n], 0, sizeof(pp[n])); + return pp; +} + + +static char* norm_lit_str(const char* src, int srclen, + int multiline, + char* errbuf, int errbufsz) +{ + char* dst = 0; /* will write to dst[] and return it */ + int max = 0; /* max size of dst[] */ + int off = 0; /* cur offset in dst[] */ + const char* sp = src; + const char* sq = src + srclen; + int ch; + + /* scan forward on src */ + for (;;) { + if (off >= max - 10) { /* have some slack for misc stuff */ + int newmax = max + 50; + char* x = expand(dst, max, newmax); + if (!x) { + xfree(dst); + snprintf(errbuf, errbufsz, "out of memory"); + return 0; + } + dst = x; + max = newmax; + } + + /* finished? */ + if (sp >= sq) break; + + ch = *sp++; + /* control characters other than tab is not allowed */ + if ((0 <= ch && ch <= 0x08) + || (0x0a <= ch && ch <= 0x1f) + || (ch == 0x7f)) { + if (! (multiline && (ch == '\r' || ch == '\n'))) { + xfree(dst); + snprintf(errbuf, errbufsz, "invalid char U+%04x", ch); + return 0; + } + } + + // a plain copy suffice + dst[off++] = ch; + } + + dst[off++] = 0; + return dst; +} + + + + +/* + * Convert src to raw unescaped utf-8 string. + * Returns NULL if error with errmsg in errbuf. + */ +static char* norm_basic_str(const char* src, int srclen, + int multiline, + char* errbuf, int errbufsz) +{ + char* dst = 0; /* will write to dst[] and return it */ + int max = 0; /* max size of dst[] */ + int off = 0; /* cur offset in dst[] */ + const char* sp = src; + const char* sq = src + srclen; + int ch; + + /* scan forward on src */ + for (;;) { + if (off >= max - 10) { /* have some slack for misc stuff */ + int newmax = max + 50; + char* x = expand(dst, max, newmax); + if (!x) { + xfree(dst); + snprintf(errbuf, errbufsz, "out of memory"); + return 0; + } + dst = x; + max = newmax; + } + + /* finished? */ + if (sp >= sq) break; + + ch = *sp++; + if (ch != '\\') { + /* these chars must be escaped: U+0000 to U+0008, U+000A to U+001F, U+007F */ + if ((0 <= ch && ch <= 0x08) + || (0x0a <= ch && ch <= 0x1f) + || (ch == 0x7f)) { + if (! (multiline && (ch == '\r' || ch == '\n'))) { + xfree(dst); + snprintf(errbuf, errbufsz, "invalid char U+%04x", ch); + return 0; + } + } + + // a plain copy suffice + dst[off++] = ch; + continue; + } + + /* ch was backslash. we expect the escape char. */ + if (sp >= sq) { + snprintf(errbuf, errbufsz, "last backslash is invalid"); + xfree(dst); + return 0; + } + + /* for multi-line, we want to kill line-ending-backslash ... */ + if (multiline) { + + // if there is only whitespace after the backslash ... + if (sp[strspn(sp, " \t\r")] == '\n') { + /* skip all the following whitespaces */ + sp += strspn(sp, " \t\r\n"); + continue; + } + } + + /* get the escaped char */ + ch = *sp++; + switch (ch) { + case 'u': case 'U': + { + int64_t ucs = 0; + int nhex = (ch == 'u' ? 4 : 8); + for (int i = 0; i < nhex; i++) { + if (sp >= sq) { + snprintf(errbuf, errbufsz, "\\%c expects %d hex chars", ch, nhex); + xfree(dst); + return 0; + } + ch = *sp++; + int v = ('0' <= ch && ch <= '9') + ? ch - '0' + : (('A' <= ch && ch <= 'F') ? ch - 'A' + 10 : -1); + if (-1 == v) { + snprintf(errbuf, errbufsz, "invalid hex chars for \\u or \\U"); + xfree(dst); + return 0; + } + ucs = ucs * 16 + v; + } + int n = toml_ucs_to_utf8(ucs, &dst[off]); + if (-1 == n) { + snprintf(errbuf, errbufsz, "illegal ucs code in \\u or \\U"); + xfree(dst); + return 0; + } + off += n; + } + continue; + + case 'b': ch = '\b'; break; + case 't': ch = '\t'; break; + case 'n': ch = '\n'; break; + case 'f': ch = '\f'; break; + case 'r': ch = '\r'; break; + case '"': ch = '"'; break; + case '\\': ch = '\\'; break; + default: + snprintf(errbuf, errbufsz, "illegal escape char \\%c", ch); + xfree(dst); + return 0; + } + + dst[off++] = ch; + } + + // Cap with NUL and return it. + dst[off++] = 0; + return dst; +} + + +/* Normalize a key. Convert all special chars to raw unescaped utf-8 chars. */ +static char* normalize_key(context_t* ctx, token_t strtok) +{ + const char* sp = strtok.ptr; + const char* sq = strtok.ptr + strtok.len; + int lineno = strtok.lineno; + char* ret; + int ch = *sp; + char ebuf[80]; + + /* handle quoted string */ + if (ch == '\'' || ch == '\"') { + /* if ''' or """, take 3 chars off front and back. Else, take 1 char off. */ + int multiline = 0; + if (sp[1] == ch && sp[2] == ch) { + sp += 3, sq -= 3; + multiline = 1; + } + else + sp++, sq--; + + if (ch == '\'') { + /* for single quote, take it verbatim. */ + if (! (ret = STRNDUP(sp, sq - sp))) { + e_outofmemory(ctx, FLINE); + return 0; + } + } else { + /* for double quote, we need to normalize */ + ret = norm_basic_str(sp, sq - sp, multiline, ebuf, sizeof(ebuf)); + if (!ret) { + e_syntax(ctx, lineno, ebuf); + return 0; + } + } + + /* newlines are not allowed in keys */ + if (strchr(ret, '\n')) { + xfree(ret); + e_badkey(ctx, lineno); + return 0; + } + return ret; + } + + /* for bare-key allow only this regex: [A-Za-z0-9_-]+ */ + const char* xp; + for (xp = sp; xp != sq; xp++) { + int k = *xp; + if (isalnum(k)) continue; + if (k == '_' || k == '-') continue; + e_badkey(ctx, lineno); + return 0; + } + + /* dup and return it */ + if (! (ret = STRNDUP(sp, sq - sp))) { + e_outofmemory(ctx, FLINE); + return 0; + } + return ret; +} + + +/* + * Look up key in tab. Return 0 if not found, or + * 'v'alue, 'a'rray or 't'able depending on the element. + */ +static int check_key(toml_table_t* tab, const char* key, + toml_keyval_t** ret_val, + toml_array_t** ret_arr, + toml_table_t** ret_tab) +{ + int i; + void* dummy; + + if (!ret_tab) ret_tab = (toml_table_t**) &dummy; + if (!ret_arr) ret_arr = (toml_array_t**) &dummy; + if (!ret_val) ret_val = (toml_keyval_t**) &dummy; + + *ret_tab = 0; *ret_arr = 0; *ret_val = 0; + + for (i = 0; i < tab->nkval; i++) { + if (0 == strcmp(key, tab->kval[i]->key)) { + *ret_val = tab->kval[i]; + return 'v'; + } + } + for (i = 0; i < tab->narr; i++) { + if (0 == strcmp(key, tab->arr[i]->key)) { + *ret_arr = tab->arr[i]; + return 'a'; + } + } + for (i = 0; i < tab->ntab; i++) { + if (0 == strcmp(key, tab->tab[i]->key)) { + *ret_tab = tab->tab[i]; + return 't'; + } + } + return 0; +} + + +static int key_kind(toml_table_t* tab, const char* key) +{ + return check_key(tab, key, 0, 0, 0); +} + +/* Create a keyval in the table. + */ +static toml_keyval_t* create_keyval_in_table(context_t* ctx, toml_table_t* tab, token_t keytok) +{ + /* first, normalize the key to be used for lookup. + * remember to free it if we error out. + */ + char* newkey = normalize_key(ctx, keytok); + if (!newkey) return 0; + + /* if key exists: error out. */ + toml_keyval_t* dest = 0; + if (key_kind(tab, newkey)) { + xfree(newkey); + e_keyexists(ctx, keytok.lineno); + return 0; + } + + /* make a new entry */ + int n = tab->nkval; + toml_keyval_t** base; + if (0 == (base = (toml_keyval_t**) expand_ptrarr((void**)tab->kval, n))) { + xfree(newkey); + e_outofmemory(ctx, FLINE); + return 0; + } + tab->kval = base; + + if (0 == (base[n] = (toml_keyval_t*) CALLOC(1, sizeof(*base[n])))) { + xfree(newkey); + e_outofmemory(ctx, FLINE); + return 0; + } + dest = tab->kval[tab->nkval++]; + + /* save the key in the new value struct */ + dest->key = newkey; + return dest; +} + + +/* Create a table in the table. + */ +static toml_table_t* create_keytable_in_table(context_t* ctx, toml_table_t* tab, token_t keytok) +{ + /* first, normalize the key to be used for lookup. + * remember to free it if we error out. + */ + char* newkey = normalize_key(ctx, keytok); + if (!newkey) return 0; + + /* if key exists: error out */ + toml_table_t* dest = 0; + if (check_key(tab, newkey, 0, 0, &dest)) { + xfree(newkey); /* don't need this anymore */ + + /* special case: if table exists, but was created implicitly ... */ + if (dest && dest->implicit) { + /* we make it explicit now, and simply return it. */ + dest->implicit = false; + return dest; + } + e_keyexists(ctx, keytok.lineno); + return 0; + } + + /* create a new table entry */ + int n = tab->ntab; + toml_table_t** base; + if (0 == (base = (toml_table_t**) expand_ptrarr((void**)tab->tab, n))) { + xfree(newkey); + e_outofmemory(ctx, FLINE); + return 0; + } + tab->tab = base; + + if (0 == (base[n] = (toml_table_t*) CALLOC(1, sizeof(*base[n])))) { + xfree(newkey); + e_outofmemory(ctx, FLINE); + return 0; + } + dest = tab->tab[tab->ntab++]; + + /* save the key in the new table struct */ + dest->key = newkey; + return dest; +} + + +/* Create an array in the table. + */ +static toml_array_t* create_keyarray_in_table(context_t* ctx, + toml_table_t* tab, + token_t keytok, + char kind) +{ + /* first, normalize the key to be used for lookup. + * remember to free it if we error out. + */ + char* newkey = normalize_key(ctx, keytok); + if (!newkey) return 0; + + /* if key exists: error out */ + if (key_kind(tab, newkey)) { + xfree(newkey); /* don't need this anymore */ + e_keyexists(ctx, keytok.lineno); + return 0; + } + + /* make a new array entry */ + int n = tab->narr; + toml_array_t** base; + if (0 == (base = (toml_array_t**) expand_ptrarr((void**)tab->arr, n))) { + xfree(newkey); + e_outofmemory(ctx, FLINE); + return 0; + } + tab->arr = base; + + if (0 == (base[n] = (toml_array_t*) CALLOC(1, sizeof(*base[n])))) { + xfree(newkey); + e_outofmemory(ctx, FLINE); + return 0; + } + toml_array_t* dest = tab->arr[tab->narr++]; + + /* save the key in the new array struct */ + dest->key = newkey; + dest->kind = kind; + return dest; +} + + +static toml_arritem_t* create_value_in_array(context_t* ctx, + toml_array_t* parent) +{ + const int n = parent->nitem; + toml_arritem_t* base = expand_arritem(parent->item, n); + if (!base) { + e_outofmemory(ctx, FLINE); + return 0; + } + parent->item = base; + parent->nitem++; + return &parent->item[n]; +} + +/* Create an array in an array + */ +static toml_array_t* create_array_in_array(context_t* ctx, + toml_array_t* parent) +{ + const int n = parent->nitem; + toml_arritem_t* base = expand_arritem(parent->item, n); + if (!base) { + e_outofmemory(ctx, FLINE); + return 0; + } + toml_array_t* ret = (toml_array_t*) CALLOC(1, sizeof(toml_array_t)); + if (!ret) { + e_outofmemory(ctx, FLINE); + return 0; + } + base[n].arr = ret; + parent->item = base; + parent->nitem++; + return ret; +} + +/* Create a table in an array + */ +static toml_table_t* create_table_in_array(context_t* ctx, + toml_array_t* parent) +{ + int n = parent->nitem; + toml_arritem_t* base = expand_arritem(parent->item, n); + if (!base) { + e_outofmemory(ctx, FLINE); + return 0; + } + toml_table_t* ret = (toml_table_t*) CALLOC(1, sizeof(toml_table_t)); + if (!ret) { + e_outofmemory(ctx, FLINE); + return 0; + } + base[n].tab = ret; + parent->item = base; + parent->nitem++; + return ret; +} + + +static int skip_newlines(context_t* ctx, int isdotspecial) +{ + while (ctx->tok.tok == NEWLINE) { + if (next_token(ctx, isdotspecial)) return -1; + if (ctx->tok.eof) break; + } + return 0; +} + + +static int parse_keyval(context_t* ctx, toml_table_t* tab); + +static inline int eat_token(context_t* ctx, tokentype_t typ, int isdotspecial, const char* fline) +{ + if (ctx->tok.tok != typ) + return e_internal(ctx, fline); + + if (next_token(ctx, isdotspecial)) + return -1; + + return 0; +} + + + +/* We are at '{ ... }'. + * Parse the table. + */ +static int parse_inline_table(context_t* ctx, toml_table_t* tab) +{ + if (eat_token(ctx, LBRACE, 1, FLINE)) + return -1; + + for (;;) { + if (ctx->tok.tok == NEWLINE) + return e_syntax(ctx, ctx->tok.lineno, "newline not allowed in inline table"); + + /* until } */ + if (ctx->tok.tok == RBRACE) + break; + + if (ctx->tok.tok != STRING) + return e_syntax(ctx, ctx->tok.lineno, "expect a string"); + + if (parse_keyval(ctx, tab)) + return -1; + + if (ctx->tok.tok == NEWLINE) + return e_syntax(ctx, ctx->tok.lineno, "newline not allowed in inline table"); + + /* on comma, continue to scan for next keyval */ + if (ctx->tok.tok == COMMA) { + if (eat_token(ctx, COMMA, 1, FLINE)) + return -1; + continue; + } + break; + } + + if (eat_token(ctx, RBRACE, 1, FLINE)) + return -1; + + tab->readonly = 1; + + return 0; +} + +static int valtype(const char* val) +{ + toml_timestamp_t ts; + if (*val == '\'' || *val == '"') return 's'; + if (0 == toml_rtob(val, 0)) return 'b'; + if (0 == toml_rtoi(val, 0)) return 'i'; + if (0 == toml_rtod(val, 0)) return 'd'; + if (0 == toml_rtots(val, &ts)) { + if (ts.year && ts.hour) return 'T'; /* timestamp */ + if (ts.year) return 'D'; /* date */ + return 't'; /* time */ + } + return 'u'; /* unknown */ +} + + +/* We are at '[...]' */ +static int parse_array(context_t* ctx, toml_array_t* arr) +{ + if (eat_token(ctx, LBRACKET, 0, FLINE)) return -1; + + for (;;) { + if (skip_newlines(ctx, 0)) return -1; + + /* until ] */ + if (ctx->tok.tok == RBRACKET) break; + + switch (ctx->tok.tok) { + case STRING: + { + /* set array kind if this will be the first entry */ + if (arr->kind == 0) + arr->kind = 'v'; + else if (arr->kind != 'v') + arr->kind = 'm'; + + char* val = ctx->tok.ptr; + int vlen = ctx->tok.len; + + /* make a new value in array */ + toml_arritem_t* newval = create_value_in_array(ctx, arr); + if (!newval) + return e_outofmemory(ctx, FLINE); + + if (! (newval->val = STRNDUP(val, vlen))) + return e_outofmemory(ctx, FLINE); + + newval->valtype = valtype(newval->val); + + /* set array type if this is the first entry */ + if (arr->nitem == 1) + arr->type = newval->valtype; + else if (arr->type != newval->valtype) + arr->type = 'm'; /* mixed */ + + if (eat_token(ctx, STRING, 0, FLINE)) return -1; + break; + } + + case LBRACKET: + { /* [ [array], [array] ... ] */ + /* set the array kind if this will be the first entry */ + if (arr->kind == 0) + arr->kind = 'a'; + else if (arr->kind != 'a') + arr->kind = 'm'; + + toml_array_t* subarr = create_array_in_array(ctx, arr); + if (!subarr) return -1; + if (parse_array(ctx, subarr)) return -1; + break; + } + + case LBRACE: + { /* [ {table}, {table} ... ] */ + /* set the array kind if this will be the first entry */ + if (arr->kind == 0) + arr->kind = 't'; + else if (arr->kind != 't') + arr->kind = 'm'; + + toml_table_t* subtab = create_table_in_array(ctx, arr); + if (!subtab) return -1; + if (parse_inline_table(ctx, subtab)) return -1; + break; + } + + default: + return e_syntax(ctx, ctx->tok.lineno, "syntax error"); + } + + if (skip_newlines(ctx, 0)) return -1; + + /* on comma, continue to scan for next element */ + if (ctx->tok.tok == COMMA) { + if (eat_token(ctx, COMMA, 0, FLINE)) return -1; + continue; + } + break; + } + + if (eat_token(ctx, RBRACKET, 1, FLINE)) return -1; + return 0; +} + + +/* handle lines like these: + key = "value" + key = [ array ] + key = { table } +*/ +static int parse_keyval(context_t* ctx, toml_table_t* tab) +{ + if (tab->readonly) { + return e_forbid(ctx, ctx->tok.lineno, "cannot insert new entry into existing table"); + } + + token_t key = ctx->tok; + if (eat_token(ctx, STRING, 1, FLINE)) return -1; + + if (ctx->tok.tok == DOT) { + /* handle inline dotted key. + e.g. + physical.color = "orange" + physical.shape = "round" + */ + toml_table_t* subtab = 0; + { + char* subtabstr = normalize_key(ctx, key); + if (!subtabstr) return -1; + + subtab = toml_table_in(tab, subtabstr); + xfree(subtabstr); + } + if (!subtab) { + subtab = create_keytable_in_table(ctx, tab, key); + if (!subtab) return -1; + } + if (next_token(ctx, 1)) return -1; + if (parse_keyval(ctx, subtab)) return -1; + return 0; + } + + if (ctx->tok.tok != EQUAL) { + return e_syntax(ctx, ctx->tok.lineno, "missing ="); + } + + if (next_token(ctx, 0)) return -1; + + switch (ctx->tok.tok) { + case STRING: + { /* key = "value" */ + toml_keyval_t* keyval = create_keyval_in_table(ctx, tab, key); + if (!keyval) return -1; + token_t val = ctx->tok; + + assert(keyval->val == 0); + if (! (keyval->val = STRNDUP(val.ptr, val.len))) + return e_outofmemory(ctx, FLINE); + + if (next_token(ctx, 1)) return -1; + + return 0; + } + + case LBRACKET: + { /* key = [ array ] */ + toml_array_t* arr = create_keyarray_in_table(ctx, tab, key, 0); + if (!arr) return -1; + if (parse_array(ctx, arr)) return -1; + return 0; + } + + case LBRACE: + { /* key = { table } */ + toml_table_t* nxttab = create_keytable_in_table(ctx, tab, key); + if (!nxttab) return -1; + if (parse_inline_table(ctx, nxttab)) return -1; + return 0; + } + + default: + return e_syntax(ctx, ctx->tok.lineno, "syntax error"); + } + return 0; +} + + +typedef struct tabpath_t tabpath_t; +struct tabpath_t { + int cnt; + token_t key[10]; +}; + +/* at [x.y.z] or [[x.y.z]] + * Scan forward and fill tabpath until it enters ] or ]] + * There will be at least one entry on return. + */ +static int fill_tabpath(context_t* ctx) +{ + int lineno = ctx->tok.lineno; + int i; + + /* clear tpath */ + for (i = 0; i < ctx->tpath.top; i++) { + char** p = &ctx->tpath.key[i]; + xfree(*p); + *p = 0; + } + ctx->tpath.top = 0; + + for (;;) { + if (ctx->tpath.top >= 10) + return e_syntax(ctx, lineno, "table path is too deep; max allowed is 10."); + + if (ctx->tok.tok != STRING) + return e_syntax(ctx, lineno, "invalid or missing key"); + + char* key = normalize_key(ctx, ctx->tok); + if (!key) return -1; + ctx->tpath.tok[ctx->tpath.top] = ctx->tok; + ctx->tpath.key[ctx->tpath.top] = key; + ctx->tpath.top++; + + if (next_token(ctx, 1)) return -1; + + if (ctx->tok.tok == RBRACKET) break; + + if (ctx->tok.tok != DOT) + return e_syntax(ctx, lineno, "invalid key"); + + if (next_token(ctx, 1)) return -1; + } + + if (ctx->tpath.top <= 0) + return e_syntax(ctx, lineno, "empty table selector"); + + return 0; +} + + +/* Walk tabpath from the root, and create new tables on the way. + * Sets ctx->curtab to the final table. + */ +static int walk_tabpath(context_t* ctx) +{ + /* start from root */ + toml_table_t* curtab = ctx->root; + + for (int i = 0; i < ctx->tpath.top; i++) { + const char* key = ctx->tpath.key[i]; + + toml_keyval_t* nextval = 0; + toml_array_t* nextarr = 0; + toml_table_t* nexttab = 0; + switch (check_key(curtab, key, &nextval, &nextarr, &nexttab)) { + case 't': + /* found a table. nexttab is where we will go next. */ + break; + + case 'a': + /* found an array. nexttab is the last table in the array. */ + if (nextarr->kind != 't') + return e_internal(ctx, FLINE); + + if (nextarr->nitem == 0) + return e_internal(ctx, FLINE); + + nexttab = nextarr->item[nextarr->nitem-1].tab; + break; + + case 'v': + return e_keyexists(ctx, ctx->tpath.tok[i].lineno); + + default: + { /* Not found. Let's create an implicit table. */ + int n = curtab->ntab; + toml_table_t** base = (toml_table_t**) expand_ptrarr((void**)curtab->tab, n); + if (0 == base) + return e_outofmemory(ctx, FLINE); + + curtab->tab = base; + + if (0 == (base[n] = (toml_table_t*) CALLOC(1, sizeof(*base[n])))) + return e_outofmemory(ctx, FLINE); + + if (0 == (base[n]->key = STRDUP(key))) + return e_outofmemory(ctx, FLINE); + + nexttab = curtab->tab[curtab->ntab++]; + + /* tabs created by walk_tabpath are considered implicit */ + nexttab->implicit = true; + } + break; + } + + /* switch to next tab */ + curtab = nexttab; + } + + /* save it */ + ctx->curtab = curtab; + + return 0; +} + + +/* handle lines like [x.y.z] or [[x.y.z]] */ +static int parse_select(context_t* ctx) +{ + assert(ctx->tok.tok == LBRACKET); + + /* true if [[ */ + int llb = (ctx->tok.ptr + 1 < ctx->stop && ctx->tok.ptr[1] == '['); + /* need to detect '[[' on our own because next_token() will skip whitespace, + and '[ [' would be taken as '[[', which is wrong. */ + + /* eat [ or [[ */ + if (eat_token(ctx, LBRACKET, 1, FLINE)) return -1; + if (llb) { + assert(ctx->tok.tok == LBRACKET); + if (eat_token(ctx, LBRACKET, 1, FLINE)) return -1; + } + + if (fill_tabpath(ctx)) return -1; + + /* For [x.y.z] or [[x.y.z]], remove z from tpath. + */ + token_t z = ctx->tpath.tok[ctx->tpath.top-1]; + xfree(ctx->tpath.key[ctx->tpath.top-1]); + ctx->tpath.top--; + + /* set up ctx->curtab */ + if (walk_tabpath(ctx)) return -1; + + if (! llb) { + /* [x.y.z] -> create z = {} in x.y */ + toml_table_t* curtab = create_keytable_in_table(ctx, ctx->curtab, z); + if (!curtab) return -1; + ctx->curtab = curtab; + } else { + /* [[x.y.z]] -> create z = [] in x.y */ + toml_array_t* arr = 0; + { + char* zstr = normalize_key(ctx, z); + if (!zstr) return -1; + arr = toml_array_in(ctx->curtab, zstr); + xfree(zstr); + } + if (!arr) { + arr = create_keyarray_in_table(ctx, ctx->curtab, z, 't'); + if (!arr) return -1; + } + if (arr->kind != 't') + return e_syntax(ctx, z.lineno, "array mismatch"); + + /* add to z[] */ + toml_table_t* dest; + { + toml_table_t* t = create_table_in_array(ctx, arr); + if (!t) return -1; + + if (0 == (t->key = STRDUP("__anon__"))) + return e_outofmemory(ctx, FLINE); + + dest = t; + } + + ctx->curtab = dest; + } + + if (ctx->tok.tok != RBRACKET) { + return e_syntax(ctx, ctx->tok.lineno, "expects ]"); + } + if (llb) { + if (! (ctx->tok.ptr + 1 < ctx->stop && ctx->tok.ptr[1] == ']')) { + return e_syntax(ctx, ctx->tok.lineno, "expects ]]"); + } + if (eat_token(ctx, RBRACKET, 1, FLINE)) return -1; + } + + if (eat_token(ctx, RBRACKET, 1, FLINE)) + return -1; + + if (ctx->tok.tok != NEWLINE) + return e_syntax(ctx, ctx->tok.lineno, "extra chars after ] or ]]"); + + return 0; +} + + + + +toml_table_t* toml_parse(char* conf, + char* errbuf, + int errbufsz) +{ + context_t ctx; + + // clear errbuf + if (errbufsz <= 0) errbufsz = 0; + if (errbufsz > 0) errbuf[0] = 0; + + // init context + memset(&ctx, 0, sizeof(ctx)); + ctx.start = conf; + ctx.stop = ctx.start + strlen(conf); + ctx.errbuf = errbuf; + ctx.errbufsz = errbufsz; + + // start with an artificial newline of length 0 + ctx.tok.tok = NEWLINE; + ctx.tok.lineno = 1; + ctx.tok.ptr = conf; + ctx.tok.len = 0; + + // make a root table + if (0 == (ctx.root = CALLOC(1, sizeof(*ctx.root)))) { + e_outofmemory(&ctx, FLINE); + // Do not goto fail, root table not set up yet + return 0; + } + + // set root as default table + ctx.curtab = ctx.root; + + /* Scan forward until EOF */ + for (token_t tok = ctx.tok; ! tok.eof ; tok = ctx.tok) { + switch (tok.tok) { + + case NEWLINE: + if (next_token(&ctx, 1)) goto fail; + break; + + case STRING: + if (parse_keyval(&ctx, ctx.curtab)) goto fail; + + if (ctx.tok.tok != NEWLINE) { + e_syntax(&ctx, ctx.tok.lineno, "extra chars after value"); + goto fail; + } + + if (eat_token(&ctx, NEWLINE, 1, FLINE)) goto fail; + break; + + case LBRACKET: /* [ x.y.z ] or [[ x.y.z ]] */ + if (parse_select(&ctx)) goto fail; + break; + + default: + e_syntax(&ctx, tok.lineno, "syntax error"); + goto fail; + } + } + + /* success */ + for (int i = 0; i < ctx.tpath.top; i++) xfree(ctx.tpath.key[i]); + return ctx.root; + +fail: + // Something bad has happened. Free resources and return error. + for (int i = 0; i < ctx.tpath.top; i++) xfree(ctx.tpath.key[i]); + toml_free(ctx.root); + return 0; +} + + +toml_table_t* toml_parse_file(FILE* fp, + char* errbuf, + int errbufsz) +{ + int bufsz = 0; + char* buf = 0; + int off = 0; + + /* read from fp into buf */ + while (! feof(fp)) { + + if (off == bufsz) { + int xsz = bufsz + 1000; + char* x = expand(buf, bufsz, xsz); + if (!x) { + snprintf(errbuf, errbufsz, "out of memory"); + xfree(buf); + return 0; + } + buf = x; + bufsz = xsz; + } + + errno = 0; + int n = fread(buf + off, 1, bufsz - off, fp); + if (ferror(fp)) { + snprintf(errbuf, errbufsz, "%s", + errno ? strerror(errno) : "Error reading file"); + xfree(buf); + return 0; + } + off += n; + } + + /* tag on a NUL to cap the string */ + if (off == bufsz) { + int xsz = bufsz + 1; + char* x = expand(buf, bufsz, xsz); + if (!x) { + snprintf(errbuf, errbufsz, "out of memory"); + xfree(buf); + return 0; + } + buf = x; + bufsz = xsz; + } + buf[off] = 0; + + /* parse it, cleanup and finish */ + toml_table_t* ret = toml_parse(buf, errbuf, errbufsz); + xfree(buf); + return ret; +} + + +static void xfree_kval(toml_keyval_t* p) +{ + if (!p) return; + xfree(p->key); + xfree(p->val); + xfree(p); +} + +static void xfree_tab(toml_table_t* p); + +static void xfree_arr(toml_array_t* p) +{ + if (!p) return; + + xfree(p->key); + const int n = p->nitem; + for (int i = 0; i < n; i++) { + toml_arritem_t* a = &p->item[i]; + if (a->val) + xfree(a->val); + else if (a->arr) + xfree_arr(a->arr); + else if (a->tab) + xfree_tab(a->tab); + } + xfree(p->item); + xfree(p); +} + + +static void xfree_tab(toml_table_t* p) +{ + int i; + + if (!p) return; + + xfree(p->key); + + for (i = 0; i < p->nkval; i++) xfree_kval(p->kval[i]); + xfree(p->kval); + + for (i = 0; i < p->narr; i++) xfree_arr(p->arr[i]); + xfree(p->arr); + + for (i = 0; i < p->ntab; i++) xfree_tab(p->tab[i]); + xfree(p->tab); + + xfree(p); +} + + +void toml_free(toml_table_t* tab) +{ + xfree_tab(tab); +} + + +static void set_token(context_t* ctx, tokentype_t tok, int lineno, char* ptr, int len) +{ + token_t t; + t.tok = tok; + t.lineno = lineno; + t.ptr = ptr; + t.len = len; + t.eof = 0; + ctx->tok = t; +} + +static void set_eof(context_t* ctx, int lineno) +{ + set_token(ctx, NEWLINE, lineno, ctx->stop, 0); + ctx->tok.eof = 1; +} + + +/* Scan p for n digits compositing entirely of [0-9] */ +static int scan_digits(const char* p, int n) +{ + int ret = 0; + for ( ; n > 0 && isdigit(*p); n--, p++) { + ret = 10 * ret + (*p - '0'); + } + return n ? -1 : ret; +} + +static int scan_date(const char* p, int* YY, int* MM, int* DD) +{ + int year, month, day; + year = scan_digits(p, 4); + month = (year >= 0 && p[4] == '-') ? scan_digits(p+5, 2) : -1; + day = (month >= 0 && p[7] == '-') ? scan_digits(p+8, 2) : -1; + if (YY) *YY = year; + if (MM) *MM = month; + if (DD) *DD = day; + return (year >= 0 && month >= 0 && day >= 0) ? 0 : -1; +} + +static int scan_time(const char* p, int* hh, int* mm, int* ss) +{ + int hour, minute, second; + hour = scan_digits(p, 2); + minute = (hour >= 0 && p[2] == ':') ? scan_digits(p+3, 2) : -1; + second = (minute >= 0 && p[5] == ':') ? scan_digits(p+6, 2) : -1; + if (hh) *hh = hour; + if (mm) *mm = minute; + if (ss) *ss = second; + return (hour >= 0 && minute >= 0 && second >= 0) ? 0 : -1; +} + + +static int scan_string(context_t* ctx, char* p, int lineno, int dotisspecial) +{ + char* orig = p; + if (0 == strncmp(p, "'''", 3)) { + char* q = p + 3; + + while (1) { + q = strstr(q, "'''"); + if (0 == q) { + return e_syntax(ctx, lineno, "unterminated triple-s-quote"); + } + while (q[3] == '\'') q++; + break; + } + + set_token(ctx, STRING, lineno, orig, q + 3 - orig); + return 0; + } + + if (0 == strncmp(p, "\"\"\"", 3)) { + char* q = p + 3; + + while (1) { + q = strstr(q, "\"\"\""); + if (0 == q) { + return e_syntax(ctx, lineno, "unterminated triple-d-quote"); + } + if (q[-1] == '\\') { + q++; + continue; + } + while (q[3] == '\"') q++; + break; + } + + // the string is [p+3, q-1] + + int hexreq = 0; /* #hex required */ + int escape = 0; + for (p += 3; p < q; p++) { + if (escape) { + escape = 0; + if (strchr("btnfr\"\\", *p)) continue; + if (*p == 'u') { hexreq = 4; continue; } + if (*p == 'U') { hexreq = 8; continue; } + if (p[strspn(p, " \t\r")] == '\n') continue; /* allow for line ending backslash */ + return e_syntax(ctx, lineno, "bad escape char"); + } + if (hexreq) { + hexreq--; + if (strchr("0123456789ABCDEF", *p)) continue; + return e_syntax(ctx, lineno, "expect hex char"); + } + if (*p == '\\') { escape = 1; continue; } + } + if (escape) + return e_syntax(ctx, lineno, "expect an escape char"); + if (hexreq) + return e_syntax(ctx, lineno, "expected more hex char"); + + set_token(ctx, STRING, lineno, orig, q + 3 - orig); + return 0; + } + + if ('\'' == *p) { + for (p++; *p && *p != '\n' && *p != '\''; p++); + if (*p != '\'') { + return e_syntax(ctx, lineno, "unterminated s-quote"); + } + + set_token(ctx, STRING, lineno, orig, p + 1 - orig); + return 0; + } + + if ('\"' == *p) { + int hexreq = 0; /* #hex required */ + int escape = 0; + for (p++; *p; p++) { + if (escape) { + escape = 0; + if (strchr("btnfr\"\\", *p)) continue; + if (*p == 'u') { hexreq = 4; continue; } + if (*p == 'U') { hexreq = 8; continue; } + return e_syntax(ctx, lineno, "bad escape char"); + } + if (hexreq) { + hexreq--; + if (strchr("0123456789ABCDEF", *p)) continue; + return e_syntax(ctx, lineno, "expect hex char"); + } + if (*p == '\\') { escape = 1; continue; } + if (*p == '\'') { + if (p[1] == '\'' && p[2] == '\'') { + return e_syntax(ctx, lineno, "triple-s-quote inside string lit"); + } + continue; + } + if (*p == '\n') break; + if (*p == '"') break; + } + if (*p != '"') { + return e_syntax(ctx, lineno, "unterminated quote"); + } + + set_token(ctx, STRING, lineno, orig, p + 1 - orig); + return 0; + } + + /* check for timestamp without quotes */ + if (0 == scan_date(p, 0, 0, 0) || 0 == scan_time(p, 0, 0, 0)) { + // forward thru the timestamp + for ( ; strchr("0123456789.:+-T Z", toupper(*p)); p++); + // squeeze out any spaces at end of string + for ( ; p[-1] == ' '; p--); + // tokenize + set_token(ctx, STRING, lineno, orig, p - orig); + return 0; + } + + /* literals */ + for ( ; *p && *p != '\n'; p++) { + int ch = *p; + if (ch == '.' && dotisspecial) break; + if ('A' <= ch && ch <= 'Z') continue; + if ('a' <= ch && ch <= 'z') continue; + if (strchr("0123456789+-_.", ch)) continue; + break; + } + + set_token(ctx, STRING, lineno, orig, p - orig); + return 0; +} + + +static int next_token(context_t* ctx, int dotisspecial) +{ + int lineno = ctx->tok.lineno; + char* p = ctx->tok.ptr; + int i; + + /* eat this tok */ + for (i = 0; i < ctx->tok.len; i++) { + if (*p++ == '\n') + lineno++; + } + + /* make next tok */ + while (p < ctx->stop) { + /* skip comment. stop just before the \n. */ + if (*p == '#') { + for (p++; p < ctx->stop && *p != '\n'; p++); + continue; + } + + if (dotisspecial && *p == '.') { + set_token(ctx, DOT, lineno, p, 1); + return 0; + } + + switch (*p) { + case ',': set_token(ctx, COMMA, lineno, p, 1); return 0; + case '=': set_token(ctx, EQUAL, lineno, p, 1); return 0; + case '{': set_token(ctx, LBRACE, lineno, p, 1); return 0; + case '}': set_token(ctx, RBRACE, lineno, p, 1); return 0; + case '[': set_token(ctx, LBRACKET, lineno, p, 1); return 0; + case ']': set_token(ctx, RBRACKET, lineno, p, 1); return 0; + case '\n': set_token(ctx, NEWLINE, lineno, p, 1); return 0; + case '\r': case ' ': case '\t': + /* ignore white spaces */ + p++; + continue; + } + + return scan_string(ctx, p, lineno, dotisspecial); + } + + set_eof(ctx, lineno); + return 0; +} + + +const char* toml_key_in(const toml_table_t* tab, int keyidx) +{ + if (keyidx < tab->nkval) return tab->kval[keyidx]->key; + + keyidx -= tab->nkval; + if (keyidx < tab->narr) return tab->arr[keyidx]->key; + + keyidx -= tab->narr; + if (keyidx < tab->ntab) return tab->tab[keyidx]->key; + + return 0; +} + +toml_raw_t toml_raw_in(const toml_table_t* tab, const char* key) +{ + int i; + for (i = 0; i < tab->nkval; i++) { + if (0 == strcmp(key, tab->kval[i]->key)) + return tab->kval[i]->val; + } + return 0; +} + +toml_array_t* toml_array_in(const toml_table_t* tab, const char* key) +{ + int i; + for (i = 0; i < tab->narr; i++) { + if (0 == strcmp(key, tab->arr[i]->key)) + return tab->arr[i]; + } + return 0; +} + + +toml_table_t* toml_table_in(const toml_table_t* tab, const char* key) +{ + int i; + for (i = 0; i < tab->ntab; i++) { + if (0 == strcmp(key, tab->tab[i]->key)) + return tab->tab[i]; + } + return 0; +} + +toml_raw_t toml_raw_at(const toml_array_t* arr, int idx) +{ + return (0 <= idx && idx < arr->nitem) ? arr->item[idx].val : 0; +} + +char toml_array_kind(const toml_array_t* arr) +{ + return arr->kind; +} + +char toml_array_type(const toml_array_t* arr) +{ + if (arr->kind != 'v') + return 0; + + if (arr->nitem == 0) + return 0; + + return arr->type; +} + + +int toml_array_nelem(const toml_array_t* arr) +{ + return arr->nitem; +} + +const char* toml_array_key(const toml_array_t* arr) +{ + return arr ? arr->key : (const char*) NULL; +} + +int toml_table_nkval(const toml_table_t* tab) +{ + return tab->nkval; +} + +int toml_table_narr(const toml_table_t* tab) +{ + return tab->narr; +} + +int toml_table_ntab(const toml_table_t* tab) +{ + return tab->ntab; +} + +const char* toml_table_key(const toml_table_t* tab) +{ + return tab ? tab->key : (const char*) NULL; +} + +toml_array_t* toml_array_at(const toml_array_t* arr, int idx) +{ + return (0 <= idx && idx < arr->nitem) ? arr->item[idx].arr : 0; +} + +toml_table_t* toml_table_at(const toml_array_t* arr, int idx) +{ + return (0 <= idx && idx < arr->nitem) ? arr->item[idx].tab : 0; +} + + +int toml_rtots(toml_raw_t src_, toml_timestamp_t* ret) +{ + if (! src_) return -1; + + const char* p = src_; + int must_parse_time = 0; + + memset(ret, 0, sizeof(*ret)); + + int* year = &ret->__buffer.year; + int* month = &ret->__buffer.month; + int* day = &ret->__buffer.day; + int* hour = &ret->__buffer.hour; + int* minute = &ret->__buffer.minute; + int* second = &ret->__buffer.second; + int* millisec = &ret->__buffer.millisec; + + /* parse date YYYY-MM-DD */ + if (0 == scan_date(p, year, month, day)) { + ret->year = year; + ret->month = month; + ret->day = day; + + p += 10; + if (*p) { + // parse the T or space separator + if (*p != 'T' && *p != ' ') return -1; + must_parse_time = 1; + p++; + } + } + + /* parse time HH:MM:SS */ + if (0 == scan_time(p, hour, minute, second)) { + ret->hour = hour; + ret->minute = minute; + ret->second = second; + + /* optionally, parse millisec */ + p += 8; + if (*p == '.') { + char* qq; + p++; + errno = 0; + *millisec = strtol(p, &qq, 0); + if (errno) { + return -1; + } + while (*millisec > 999) { + *millisec /= 10; + } + + ret->millisec = millisec; + p = qq; + } + + if (*p) { + /* parse and copy Z */ + char* z = ret->__buffer.z; + ret->z = z; + if (*p == 'Z' || *p == 'z') { + *z++ = 'Z'; p++; + *z = 0; + + } else if (*p == '+' || *p == '-') { + *z++ = *p++; + + if (! (isdigit(p[0]) && isdigit(p[1]))) return -1; + *z++ = *p++; + *z++ = *p++; + + if (*p == ':') { + *z++ = *p++; + + if (! (isdigit(p[0]) && isdigit(p[1]))) return -1; + *z++ = *p++; + *z++ = *p++; + } + + *z = 0; + } + } + } + if (*p != 0) + return -1; + + if (must_parse_time && !ret->hour) + return -1; + + return 0; +} + + +/* Raw to boolean */ +int toml_rtob(toml_raw_t src, int* ret_) +{ + if (!src) return -1; + int dummy; + int* ret = ret_ ? ret_ : &dummy; + + if (0 == strcmp(src, "true")) { + *ret = 1; + return 0; + } + if (0 == strcmp(src, "false")) { + *ret = 0; + return 0; + } + return -1; +} + + +/* Raw to integer */ +int toml_rtoi(toml_raw_t src, int64_t* ret_) +{ + if (!src) return -1; + + char buf[100]; + char* p = buf; + char* q = p + sizeof(buf); + const char* s = src; + int base = 0; + int64_t dummy; + int64_t* ret = ret_ ? ret_ : &dummy; + + + /* allow +/- */ + if (s[0] == '+' || s[0] == '-') + *p++ = *s++; + + /* disallow +_100 */ + if (s[0] == '_') + return -1; + + /* if 0 ... */ + if ('0' == s[0]) { + switch (s[1]) { + case 'x': base = 16; s += 2; break; + case 'o': base = 8; s += 2; break; + case 'b': base = 2; s += 2; break; + case '\0': return *ret = 0, 0; + default: + /* ensure no other digits after it */ + if (s[1]) return -1; + } + } + + /* just strip underscores and pass to strtoll */ + while (*s && p < q) { + int ch = *s++; + switch (ch) { + case '_': + // disallow '__' + if (s[0] == '_') return -1; + continue; /* skip _ */ + default: + break; + } + *p++ = ch; + } + if (*s || p == q) return -1; + + /* last char cannot be '_' */ + if (s[-1] == '_') return -1; + + /* cap with NUL */ + *p = 0; + + /* Run strtoll on buf to get the integer */ + char* endp; + errno = 0; + *ret = strtoll(buf, &endp, base); + return (errno || *endp) ? -1 : 0; +} + + +int toml_rtod_ex(toml_raw_t src, double* ret_, char* buf, int buflen) +{ + if (!src) return -1; + + char* p = buf; + char* q = p + buflen; + const char* s = src; + double dummy; + double* ret = ret_ ? ret_ : &dummy; + + + /* allow +/- */ + if (s[0] == '+' || s[0] == '-') + *p++ = *s++; + + /* disallow +_1.00 */ + if (s[0] == '_') + return -1; + + /* decimal point, if used, must be surrounded by at least one digit on each side */ + { + char* dot = strchr(s, '.'); + if (dot) { + if (dot == s || !isdigit(dot[-1]) || !isdigit(dot[1])) + return -1; + } + } + + /* zero must be followed by . or 'e', or NUL */ + if (s[0] == '0' && s[1] && !strchr("eE.", s[1])) + return -1; + + /* just strip underscores and pass to strtod */ + while (*s && p < q) { + int ch = *s++; + if (ch == '_') { + // disallow '__' + if (s[0] == '_') return -1; + // disallow last char '_' + if (s[0] == 0) return -1; + continue; /* skip _ */ + } + *p++ = ch; + } + if (*s || p == q) return -1; /* reached end of string or buffer is full? */ + + /* cap with NUL */ + *p = 0; + + /* Run strtod on buf to get the value */ + char* endp; + errno = 0; + *ret = strtod(buf, &endp); + return (errno || *endp) ? -1 : 0; +} + +int toml_rtod(toml_raw_t src, double* ret_) +{ + char buf[100]; + return toml_rtod_ex(src, ret_, buf, sizeof(buf)); +} + + + + +int toml_rtos(toml_raw_t src, char** ret) +{ + int multiline = 0; + const char* sp; + const char* sq; + + *ret = 0; + if (!src) return -1; + + int qchar = src[0]; + int srclen = strlen(src); + if (! (qchar == '\'' || qchar == '"')) { + return -1; + } + + // triple quotes? + if (qchar == src[1] && qchar == src[2]) { + multiline = 1; + sp = src + 3; + sq = src + srclen - 3; + /* last 3 chars in src must be qchar */ + if (! (sp <= sq && sq[0] == qchar && sq[1] == qchar && sq[2] == qchar)) + return -1; + + /* skip new line immediate after qchar */ + if (sp[0] == '\n') + sp++; + else if (sp[0] == '\r' && sp[1] == '\n') + sp += 2; + + } else { + sp = src + 1; + sq = src + srclen - 1; + /* last char in src must be qchar */ + if (! (sp <= sq && *sq == qchar)) + return -1; + } + + if (qchar == '\'') { + *ret = norm_lit_str(sp, sq - sp, + multiline, + 0, 0); + } else { + *ret = norm_basic_str(sp, sq - sp, + multiline, + 0, 0); + } + + return *ret ? 0 : -1; +} + + +toml_datum_t toml_string_at(const toml_array_t* arr, int idx) +{ + toml_datum_t ret; + memset(&ret, 0, sizeof(ret)); + ret.ok = (0 == toml_rtos(toml_raw_at(arr, idx), &ret.u.s)); + return ret; +} + +toml_datum_t toml_bool_at(const toml_array_t* arr, int idx) +{ + toml_datum_t ret; + memset(&ret, 0, sizeof(ret)); + ret.ok = (0 == toml_rtob(toml_raw_at(arr, idx), &ret.u.b)); + return ret; +} + +toml_datum_t toml_int_at(const toml_array_t* arr, int idx) +{ + toml_datum_t ret; + memset(&ret, 0, sizeof(ret)); + ret.ok = (0 == toml_rtoi(toml_raw_at(arr, idx), &ret.u.i)); + return ret; +} + +toml_datum_t toml_double_at(const toml_array_t* arr, int idx) +{ + toml_datum_t ret; + memset(&ret, 0, sizeof(ret)); + ret.ok = (0 == toml_rtod(toml_raw_at(arr, idx), &ret.u.d)); + return ret; +} + +toml_datum_t toml_timestamp_at(const toml_array_t* arr, int idx) +{ + toml_timestamp_t ts; + toml_datum_t ret; + memset(&ret, 0, sizeof(ret)); + ret.ok = (0 == toml_rtots(toml_raw_at(arr, idx), &ts)); + if (ret.ok) { + ret.ok = !!(ret.u.ts = malloc(sizeof(*ret.u.ts))); + if (ret.ok) { + *ret.u.ts = ts; + if (ret.u.ts->year) ret.u.ts->year = &ret.u.ts->__buffer.year; + if (ret.u.ts->month) ret.u.ts->month = &ret.u.ts->__buffer.month; + if (ret.u.ts->day) ret.u.ts->day = &ret.u.ts->__buffer.day; + if (ret.u.ts->hour) ret.u.ts->hour = &ret.u.ts->__buffer.hour; + if (ret.u.ts->minute) ret.u.ts->minute = &ret.u.ts->__buffer.minute; + if (ret.u.ts->second) ret.u.ts->second = &ret.u.ts->__buffer.second; + if (ret.u.ts->millisec) ret.u.ts->millisec = &ret.u.ts->__buffer.millisec; + if (ret.u.ts->z) ret.u.ts->z = ret.u.ts->__buffer.z; + } + } + return ret; +} + +toml_datum_t toml_string_in(const toml_table_t* arr, const char* key) +{ + toml_datum_t ret; + memset(&ret, 0, sizeof(ret)); + toml_raw_t raw = toml_raw_in(arr, key); + if (raw) { + ret.ok = (0 == toml_rtos(raw, &ret.u.s)); + } + return ret; +} + +toml_datum_t toml_bool_in(const toml_table_t* arr, const char* key) +{ + toml_datum_t ret; + memset(&ret, 0, sizeof(ret)); + ret.ok = (0 == toml_rtob(toml_raw_in(arr, key), &ret.u.b)); + return ret; +} + +toml_datum_t toml_int_in(const toml_table_t* arr, const char* key) +{ + toml_datum_t ret; + memset(&ret, 0, sizeof(ret)); + ret.ok = (0 == toml_rtoi(toml_raw_in(arr, key), &ret.u.i)); + return ret; +} + +toml_datum_t toml_double_in(const toml_table_t* arr, const char* key) +{ + toml_datum_t ret; + memset(&ret, 0, sizeof(ret)); + ret.ok = (0 == toml_rtod(toml_raw_in(arr, key), &ret.u.d)); + return ret; +} + +toml_datum_t toml_timestamp_in(const toml_table_t* arr, const char* key) +{ + toml_timestamp_t ts; + toml_datum_t ret; + memset(&ret, 0, sizeof(ret)); + ret.ok = (0 == toml_rtots(toml_raw_in(arr, key), &ts)); + if (ret.ok) { + ret.ok = !!(ret.u.ts = malloc(sizeof(*ret.u.ts))); + if (ret.ok) { + *ret.u.ts = ts; + if (ret.u.ts->year) ret.u.ts->year = &ret.u.ts->__buffer.year; + if (ret.u.ts->month) ret.u.ts->month = &ret.u.ts->__buffer.month; + if (ret.u.ts->day) ret.u.ts->day = &ret.u.ts->__buffer.day; + if (ret.u.ts->hour) ret.u.ts->hour = &ret.u.ts->__buffer.hour; + if (ret.u.ts->minute) ret.u.ts->minute = &ret.u.ts->__buffer.minute; + if (ret.u.ts->second) ret.u.ts->second = &ret.u.ts->__buffer.second; + if (ret.u.ts->millisec) ret.u.ts->millisec = &ret.u.ts->__buffer.millisec; + if (ret.u.ts->z) ret.u.ts->z = ret.u.ts->__buffer.z; + } + } + return ret; +} From e2e5294fb9930024c18f8def55ce79c7f7767f2c Mon Sep 17 00:00:00 2001 From: kumquat-ir <66188216+kumquat-ir@users.noreply.github.com> Date: Sat, 17 Apr 2021 10:33:45 -0700 Subject: [PATCH 09/57] reimplement parsing logic for tomlc99 --- api/logic/minecraft/mod/LocalModParseTask.cpp | 162 ++++++++++++------ 1 file changed, 111 insertions(+), 51 deletions(-) diff --git a/api/logic/minecraft/mod/LocalModParseTask.cpp b/api/logic/minecraft/mod/LocalModParseTask.cpp index d8475fe2..0d6972fb 100644 --- a/api/logic/minecraft/mod/LocalModParseTask.cpp +++ b/api/logic/minecraft/mod/LocalModParseTask.cpp @@ -91,64 +91,124 @@ std::shared_ptr ReadMCModInfo(QByteArray contents) return nullptr; } -/* +// https://github.com/MinecraftForge/Documentation/blob/5ab4ba6cf9abc0ac4c0abd96ad187461aefd72af/docs/gettingstarted/structuring.md std::shared_ptr ReadMCModTOML(QByteArray contents) { std::shared_ptr details = std::make_shared(); - // toml11 throws an error when something goes wrong in parsing, so we need to catch that - try { - // data under the root table - auto tomlData = toml::parse(contents); - // data under [[mods]] - auto tomlModsArr = toml::find>(tomlData, "mods"); + char errbuf[200]; + // top-level table + toml_table_t* tomlData = toml_parse(contents.data(), errbuf, sizeof(errbuf)); - // these properties are required in this location by forge, and thus can be assumed to exist - // forge supports multiple mods in one file, details of which are accessable here from tomlModsArr[n] - details->mod_id = QString::fromStdString(toml::find(tomlModsArr[0], "modId")); - details->version = QString::fromStdString(toml::find(tomlModsArr[0], "version")); - details->name = QString::fromStdString(toml::find(tomlModsArr[0], "displayName")); - // known issue: sometimes overflows the description box for some reason - details->description = QString::fromStdString(toml::find(tomlModsArr[0], "description")); - - // optional properties - can be stored either in the root table or in [[mods]] - auto authors = QString::fromStdString(toml::find_or(tomlData, "authors", "")); - if(authors.isEmpty()) - { - authors = QString::fromStdString(toml::find_or(tomlModsArr[0], "authors", "")); - } - if(!authors.isEmpty()) - { - // author information is stored as a string now, not a list - details->authors.append(authors); - } - // is credits even used anywhere? including this for completion/parity with old data version - auto credits = QString::fromStdString(toml::find_or(tomlData, "credits", "")); - if(credits.isEmpty()) - { - credits = QString::fromStdString(toml::find_or(tomlModsArr[0], "credits", "")); - } - details->credits = credits; - auto homeurl = QString::fromStdString(toml::find_or(tomlData, "displayURL", "")); - if(homeurl.isEmpty()) - { - homeurl = QString::fromStdString(toml::find_or(tomlModsArr[0], "displayURL", "")); - } - if(!homeurl.isEmpty()) - { - // fix up url. - if (!homeurl.startsWith("http://") && !homeurl.startsWith("https://") && !homeurl.startsWith("ftp://")) - { - homeurl.prepend("http://"); - } - } - details->homeurl = homeurl; - } catch (toml::syntax_error&) { + if(!tomlData) + { return nullptr; } + + // array defined by [[mods]] + toml_array_t* tomlModsArr = toml_array_in(tomlData, "mods"); + // we only really care about the first element, since multiple mods in one file is not supported by us at the moment + toml_table_t* tomlModsTable0 = toml_table_at(tomlModsArr, 0); + + // mandatory properties - always in [[mods]] + toml_datum_t modIdDatum = toml_string_in(tomlModsTable0, "modId"); + if(modIdDatum.ok) + { + details->mod_id = modIdDatum.u.s; + // library says this is required for strings + free(modIdDatum.u.s); + } + toml_datum_t versionDatum = toml_string_in(tomlModsTable0, "version"); + if(versionDatum.ok) + { + details->version = versionDatum.u.s; + free(versionDatum.u.s); + } + toml_datum_t displayNameDatum = toml_string_in(tomlModsTable0, "displayName"); + if(displayNameDatum.ok) + { + details->name = displayNameDatum.u.s; + free(displayNameDatum.u.s); + } + toml_datum_t descriptionDatum = toml_string_in(tomlModsTable0, "description"); + if(descriptionDatum.ok) + { + details->description = descriptionDatum.u.s; + free(descriptionDatum.u.s); + } + + // optional properties - can be in the root table or [[mods]] + toml_datum_t authorsDatum = toml_string_in(tomlData, "authors"); + QString authors = ""; + if(authorsDatum.ok) + { + authors = authorsDatum.u.s; + free(authorsDatum.u.s); + } + else + { + authorsDatum = toml_string_in(tomlModsTable0, "authors"); + if(authorsDatum.ok) + { + authors = authorsDatum.u.s; + free(authorsDatum.u.s); + } + } + if(!authors.isEmpty()) + { + // author information is stored as a string now, not a list + details->authors.append(authors); + } + // is credits even used anywhere? including this for completion/parity with old data version + toml_datum_t creditsDatum = toml_string_in(tomlData, "credits"); + QString credits = ""; + if(creditsDatum.ok) + { + authors = creditsDatum.u.s; + free(creditsDatum.u.s); + } + else + { + creditsDatum = toml_string_in(tomlModsTable0, "credits"); + if(creditsDatum.ok) + { + credits = creditsDatum.u.s; + free(creditsDatum.u.s); + } + } + details->credits = credits; + toml_datum_t homeurlDatum = toml_string_in(tomlData, "displayURL"); + QString homeurl = ""; + if(homeurlDatum.ok) + { + homeurl = homeurlDatum.u.s; + free(homeurlDatum.u.s); + } + else + { + homeurlDatum = toml_string_in(tomlModsTable0, "displayURL"); + if(homeurlDatum.ok) + { + homeurl = homeurlDatum.u.s; + free(homeurlDatum.u.s); + } + } + if(!homeurl.isEmpty()) + { + // fix up url. + if (!homeurl.startsWith("http://") && !homeurl.startsWith("https://") && !homeurl.startsWith("ftp://")) + { + homeurl.prepend("http://"); + } + } + details->homeurl = homeurl; + + // this seems to be recursive, so it should free everything + toml_free(tomlData); + return details; } -*/ + // https://fabricmc.net/wiki/documentation:fabric_mod_json std::shared_ptr ReadFabricModInfo(QByteArray contents) { @@ -257,7 +317,7 @@ void LocalModParseTask::processAsZip() QuaZipFile file(&zip); - /*if (zip.setCurrentFile("META-INF/mods.toml")) + if (zip.setCurrentFile("META-INF/mods.toml")) { if (!file.open(QIODevice::ReadOnly)) { @@ -307,7 +367,7 @@ void LocalModParseTask::processAsZip() zip.close(); return; } - else*/ if (zip.setCurrentFile("mcmod.info")) + else if (zip.setCurrentFile("mcmod.info")) { if (!file.open(QIODevice::ReadOnly)) { From c2fd714f8d77db3223c5cb1a2d7f902d3e3e73fd Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Trung=20L=C3=AA?= Date: Thu, 29 Apr 2021 12:42:49 +1000 Subject: [PATCH 10/57] Add limits header --- libraries/systeminfo/src/sys_unix.cpp | 1 + 1 file changed, 1 insertion(+) diff --git a/libraries/systeminfo/src/sys_unix.cpp b/libraries/systeminfo/src/sys_unix.cpp index ab3f302e..42c0d319 100644 --- a/libraries/systeminfo/src/sys_unix.cpp +++ b/libraries/systeminfo/src/sys_unix.cpp @@ -4,6 +4,7 @@ #include #include +#include Sys::KernelInfo Sys::getKernelInfo() { From df7873eb9a44c70710d86ccdf9975597e941351e Mon Sep 17 00:00:00 2001 From: Jamie Mansfield Date: Thu, 6 May 2021 17:14:49 +0100 Subject: [PATCH 11/57] GH-3764 Only install client mods for ATLauncher packs --- api/logic/modplatform/atlauncher/ATLPackInstallTask.cpp | 3 +++ api/logic/modplatform/atlauncher/ATLPackManifest.cpp | 1 + api/logic/modplatform/atlauncher/ATLPackManifest.h | 1 + 3 files changed, 5 insertions(+) diff --git a/api/logic/modplatform/atlauncher/ATLPackInstallTask.cpp b/api/logic/modplatform/atlauncher/ATLPackInstallTask.cpp index 192dd0b1..89c4dfd3 100644 --- a/api/logic/modplatform/atlauncher/ATLPackInstallTask.cpp +++ b/api/logic/modplatform/atlauncher/ATLPackInstallTask.cpp @@ -462,6 +462,9 @@ void PackInstallTask::downloadMods() jarmods.clear(); jobPtr.reset(new NetJob(tr("Mod download"))); for(const auto& mod : m_version.mods) { + // skip non-client mods + if (!mod.client) continue; + // skip optional mods for now if(mod.optional) continue; diff --git a/api/logic/modplatform/atlauncher/ATLPackManifest.cpp b/api/logic/modplatform/atlauncher/ATLPackManifest.cpp index df42c5bb..57cc52b6 100644 --- a/api/logic/modplatform/atlauncher/ATLPackManifest.cpp +++ b/api/logic/modplatform/atlauncher/ATLPackManifest.cpp @@ -144,6 +144,7 @@ static void loadVersionMod(ATLauncher::VersionMod & p, QJsonObject & obj) { } p.optional = Json::ensureBoolean(obj, QString("optional"), false); + p.client = Json::ensureBoolean(obj, QString("client"), false); } void ATLauncher::loadVersion(PackVersion & v, QJsonObject & obj) diff --git a/api/logic/modplatform/atlauncher/ATLPackManifest.h b/api/logic/modplatform/atlauncher/ATLPackManifest.h index 1adf889b..937106a5 100644 --- a/api/logic/modplatform/atlauncher/ATLPackManifest.h +++ b/api/logic/modplatform/atlauncher/ATLPackManifest.h @@ -87,6 +87,7 @@ struct VersionMod QString decompFile; bool optional; + bool client; }; struct PackVersion From de089195cdb79c7f5cf46dd78782d6da5401d8da Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jo=C3=ABl=20Troch?= Date: Wed, 9 Dec 2020 23:16:01 +0100 Subject: [PATCH 12/57] GH-3450 Add checkboxes to display and record game time --- api/logic/BaseInstance.cpp | 6 +++ api/logic/minecraft/MinecraftInstance.cpp | 7 ++- application/MultiMC.cpp | 4 ++ application/pages/global/MinecraftPage.cpp | 7 +++ application/pages/global/MinecraftPage.ui | 23 ++++++++ .../pages/instance/InstanceSettingsPage.cpp | 19 +++++++ .../pages/instance/InstanceSettingsPage.ui | 54 +++++++++++++++++++ 7 files changed, 119 insertions(+), 1 deletion(-) diff --git a/api/logic/BaseInstance.cpp b/api/logic/BaseInstance.cpp index d08ceb2b..cff16631 100644 --- a/api/logic/BaseInstance.cpp +++ b/api/logic/BaseInstance.cpp @@ -134,6 +134,12 @@ void BaseInstance::setRunning(bool running) m_isRunning = running; + if(!m_settings->get("RecordGameTime").toBool()) + { + emit runningStatusChanged(running); + return; + } + if(running) { m_timeStarted = QDateTime::currentDateTime(); diff --git a/api/logic/minecraft/MinecraftInstance.cpp b/api/logic/minecraft/MinecraftInstance.cpp index 37cdece7..2d112757 100644 --- a/api/logic/minecraft/MinecraftInstance.cpp +++ b/api/logic/minecraft/MinecraftInstance.cpp @@ -106,6 +106,11 @@ MinecraftInstance::MinecraftInstance(SettingsObjectPtr globalSettings, SettingsO m_settings->registerOverride(globalSettings->getSetting("UseNativeOpenAL"), nativeLibraryWorkaroundsOverride); m_settings->registerOverride(globalSettings->getSetting("UseNativeGLFW"), nativeLibraryWorkaroundsOverride); + // Game time + auto gameTimeOverride = m_settings->registerSetting("OverrideGameTime", false); + m_settings->registerOverride(globalSettings->getSetting("ShowGameTime"), gameTimeOverride); + m_settings->registerOverride(globalSettings->getSetting("RecordGameTime"), gameTimeOverride); + // DEPRECATED: Read what versions the user configuration thinks should be used m_settings->registerSetting({"IntendedVersion", "MinecraftVersion"}, ""); m_settings->registerSetting("LWJGLVersion", ""); @@ -769,7 +774,7 @@ QString MinecraftInstance::getStatusbarDescription() QString description; description.append(tr("Minecraft %1 (%2)").arg(m_components->getComponentVersion("net.minecraft")).arg(typeName())); - if(totalTimePlayed() > 0) + if(m_settings->get("ShowGameTime").toBool() && totalTimePlayed() > 0) { description.append(tr(", played for %1").arg(prettifyTimeDuration(totalTimePlayed()))); } diff --git a/application/MultiMC.cpp b/application/MultiMC.cpp index 22946e08..3429a377 100644 --- a/application/MultiMC.cpp +++ b/application/MultiMC.cpp @@ -514,6 +514,10 @@ MultiMC::MultiMC(int &argc, char **argv) : QApplication(argc, argv) m_settings->registerSetting("UseNativeOpenAL", false); m_settings->registerSetting("UseNativeGLFW", false); + // Game time + m_settings->registerSetting("ShowGameTime", true); + m_settings->registerSetting("RecordGameTime", true); + // Minecraft launch method m_settings->registerSetting("MCLaunchMethod", "LauncherPart"); diff --git a/application/pages/global/MinecraftPage.cpp b/application/pages/global/MinecraftPage.cpp index 6a780fb4..6c9bd307 100644 --- a/application/pages/global/MinecraftPage.cpp +++ b/application/pages/global/MinecraftPage.cpp @@ -67,6 +67,10 @@ void MinecraftPage::applySettings() // Native library workarounds s->set("UseNativeOpenAL", ui->useNativeOpenALCheck->isChecked()); s->set("UseNativeGLFW", ui->useNativeGLFWCheck->isChecked()); + + // Game time + s->set("ShowGameTime", ui->showGameTime->isChecked()); + s->set("RecordGameTime", ui->recordGameTime->isChecked()); } void MinecraftPage::loadSettings() @@ -80,4 +84,7 @@ void MinecraftPage::loadSettings() ui->useNativeOpenALCheck->setChecked(s->get("UseNativeOpenAL").toBool()); ui->useNativeGLFWCheck->setChecked(s->get("UseNativeGLFW").toBool()); + + ui->showGameTime->setChecked(s->get("ShowGameTime").toBool()); + ui->recordGameTime->setChecked(s->get("RecordGameTime").toBool()); } diff --git a/application/pages/global/MinecraftPage.ui b/application/pages/global/MinecraftPage.ui index c096c969..2abd4bd4 100644 --- a/application/pages/global/MinecraftPage.ui +++ b/application/pages/global/MinecraftPage.ui @@ -134,6 +134,29 @@ + + + + Game time + + + + + + Show time spent playing instances + + + + + + + Record time spent playing instances + + + + + + diff --git a/application/pages/instance/InstanceSettingsPage.cpp b/application/pages/instance/InstanceSettingsPage.cpp index 9a39b034..05041c82 100644 --- a/application/pages/instance/InstanceSettingsPage.cpp +++ b/application/pages/instance/InstanceSettingsPage.cpp @@ -177,6 +177,20 @@ void InstanceSettingsPage::applySettings() m_settings->reset("UseNativeOpenAL"); m_settings->reset("UseNativeGLFW"); } + + // Game time + bool gameTime = ui->gameTimeGroupBox->isChecked(); + m_settings->set("OverrideGameTime", gameTime); + if (gameTime) + { + m_settings->set("ShowGameTime", ui->showGameTime->isChecked()); + m_settings->set("RecordGameTime", ui->recordGameTime->isChecked()); + } + else + { + m_settings->reset("ShowGameTime"); + m_settings->reset("RecordGameTime"); + } } void InstanceSettingsPage::loadSettings() @@ -238,6 +252,11 @@ void InstanceSettingsPage::loadSettings() ui->nativeWorkaroundsGroupBox->setChecked(m_settings->get("OverrideNativeWorkarounds").toBool()); ui->useNativeGLFWCheck->setChecked(m_settings->get("UseNativeGLFW").toBool()); ui->useNativeOpenALCheck->setChecked(m_settings->get("UseNativeOpenAL").toBool()); + + // Miscellanous + ui->gameTimeGroupBox->setChecked(m_settings->get("OverrideGameTime").toBool()); + ui->showGameTime->setChecked(m_settings->get("ShowGameTime").toBool()); + ui->recordGameTime->setChecked(m_settings->get("RecordGameTime").toBool()); } void InstanceSettingsPage::on_javaDetectBtn_clicked() diff --git a/application/pages/instance/InstanceSettingsPage.ui b/application/pages/instance/InstanceSettingsPage.ui index c91570c6..64f90fad 100644 --- a/application/pages/instance/InstanceSettingsPage.ui +++ b/application/pages/instance/InstanceSettingsPage.ui @@ -416,6 +416,58 @@ + + + Miscellanous + + + + + + true + + + Override global game time settings + + + true + + + false + + + + + + Show time spent playing this instance + + + + + + + Record time spent playing this instance + + + + + + + + + + Qt::Vertical + + + + 20 + 40 + + + + + + @@ -453,6 +505,8 @@ nativeWorkaroundsGroupBox useNativeGLFWCheck useNativeOpenALCheck + showGameTime + recordGameTime From 2e2a5d0943a43f16c2d52a98c69323d34815cfd0 Mon Sep 17 00:00:00 2001 From: Janrupf Date: Sat, 22 May 2021 13:15:59 +0200 Subject: [PATCH 13/57] NOISSUE Required UI elements for setting a server --- .../pages/instance/InstanceSettingsPage.ui | 54 ++++++++++++++++++- 1 file changed, 53 insertions(+), 1 deletion(-) diff --git a/application/pages/instance/InstanceSettingsPage.ui b/application/pages/instance/InstanceSettingsPage.ui index 64f90fad..50c3ac6b 100644 --- a/application/pages/instance/InstanceSettingsPage.ui +++ b/application/pages/instance/InstanceSettingsPage.ui @@ -39,7 +39,7 @@ QTabWidget::Rounded - 0 + 4 @@ -453,6 +453,58 @@ + + + + Set a server to join on launch + + + true + + + false + + + + + + + + + 0 + 0 + + + + Server address: + + + + + + + + + + Server port: + + + + + + + 65535 + + + 25565 + + + + + + + + From f0eb5b4a0c16b0ddd17ee73e7ecebae2def16df7 Mon Sep 17 00:00:00 2001 From: Janrupf Date: Sat, 22 May 2021 13:28:23 +0200 Subject: [PATCH 14/57] NOISSUE Register settings for setting a server --- api/logic/minecraft/MinecraftInstance.cpp | 5 +++++ .../pages/instance/InstanceSettingsPage.cpp | 18 ++++++++++++++++++ 2 files changed, 23 insertions(+) diff --git a/api/logic/minecraft/MinecraftInstance.cpp b/api/logic/minecraft/MinecraftInstance.cpp index 2d112757..a84071c3 100644 --- a/api/logic/minecraft/MinecraftInstance.cpp +++ b/api/logic/minecraft/MinecraftInstance.cpp @@ -111,6 +111,11 @@ MinecraftInstance::MinecraftInstance(SettingsObjectPtr globalSettings, SettingsO m_settings->registerOverride(globalSettings->getSetting("ShowGameTime"), gameTimeOverride); m_settings->registerOverride(globalSettings->getSetting("RecordGameTime"), gameTimeOverride); + // Join server on launch, this does not have a global override + m_settings->registerSetting("JoinServerOnLaunch", false); + m_settings->registerSetting("JoinServerOnLaunchAddress", ""); + m_settings->registerSetting("JoinServerOnLaunchPort", 25565); + // DEPRECATED: Read what versions the user configuration thinks should be used m_settings->registerSetting({"IntendedVersion", "MinecraftVersion"}, ""); m_settings->registerSetting("LWJGLVersion", ""); diff --git a/application/pages/instance/InstanceSettingsPage.cpp b/application/pages/instance/InstanceSettingsPage.cpp index 05041c82..ff8659c5 100644 --- a/application/pages/instance/InstanceSettingsPage.cpp +++ b/application/pages/instance/InstanceSettingsPage.cpp @@ -191,6 +191,20 @@ void InstanceSettingsPage::applySettings() m_settings->reset("ShowGameTime"); m_settings->reset("RecordGameTime"); } + + // Join server on launch + bool joinServerOnLaunch = ui->serverJoinGroupBox->isChecked(); + m_settings->set("JoinServerOnLaunch", joinServerOnLaunch); + if (joinServerOnLaunch) + { + m_settings->set("JoinServerOnLaunchAddress", ui->serverJoinAddress->text()); + m_settings->set("JoinServerOnLaunchPort", ui->serverJoinPort->value()); + } + else + { + m_settings->reset("JoinServerOnLaunchAddress"); + m_settings->reset("JoinServerOnLaunchPort"); + } } void InstanceSettingsPage::loadSettings() @@ -257,6 +271,10 @@ void InstanceSettingsPage::loadSettings() ui->gameTimeGroupBox->setChecked(m_settings->get("OverrideGameTime").toBool()); ui->showGameTime->setChecked(m_settings->get("ShowGameTime").toBool()); ui->recordGameTime->setChecked(m_settings->get("RecordGameTime").toBool()); + + ui->serverJoinGroupBox->setChecked(m_settings->get("JoinServerOnLaunch").toBool()); + ui->serverJoinAddress->setText(m_settings->get("JoinServerOnLaunchAddress").toString()); + ui->serverJoinPort->setValue(m_settings->get("JoinServerOnLaunchPort").toInt()); } void InstanceSettingsPage::on_javaDetectBtn_clicked() From f78152d725c83ddaf8c58b50996eac2e998b2e5c Mon Sep 17 00:00:00 2001 From: Philip T <2097483+phit@users.noreply.github.com> Date: Sat, 22 May 2021 13:37:51 +0200 Subject: [PATCH 15/57] NOISSUE Fix new Oracle Java Detection on Windows Those were changed with Java 9 https://docs.oracle.com/javase/9/install/installation-jdk-and-jre-microsoft-windows-platforms.htm#JSJIG-GUID-47C269A3-5220-412F-9E31-4B8C37A82BFB --- api/logic/java/JavaUtils.cpp | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/api/logic/java/JavaUtils.cpp b/api/logic/java/JavaUtils.cpp index 647711e5..18a731ca 100644 --- a/api/logic/java/JavaUtils.cpp +++ b/api/logic/java/JavaUtils.cpp @@ -241,21 +241,33 @@ QList JavaUtils::FindJavaPaths() KEY_WOW64_64KEY, "SOFTWARE\\JavaSoft\\Java Runtime Environment"); QList JDK64s = this->FindJavaFromRegistryKey( KEY_WOW64_64KEY, "SOFTWARE\\JavaSoft\\Java Development Kit"); + QList NEWJRE64s = this->FindJavaFromRegistryKey( + KEY_WOW64_64KEY, "SOFTWARE\\JavaSoft\\JRE"); + QList NEWJDK64s = this->FindJavaFromRegistryKey( + KEY_WOW64_64KEY, "SOFTWARE\\JavaSoft\\JDK"); QList JRE32s = this->FindJavaFromRegistryKey( KEY_WOW64_32KEY, "SOFTWARE\\JavaSoft\\Java Runtime Environment"); QList JDK32s = this->FindJavaFromRegistryKey( KEY_WOW64_32KEY, "SOFTWARE\\JavaSoft\\Java Development Kit"); + QList NEWJRE32s = this->FindJavaFromRegistryKey( + KEY_WOW64_32KEY, "SOFTWARE\\JavaSoft\\JRE"); + QList NEWJDK32s = this->FindJavaFromRegistryKey( + KEY_WOW64_32KEY, "SOFTWARE\\JavaSoft\\JDK"); java_candidates.append(JRE64s); + java_candidates.append(NEWJRE64s); java_candidates.append(MakeJavaPtr("C:/Program Files/Java/jre8/bin/javaw.exe")); java_candidates.append(MakeJavaPtr("C:/Program Files/Java/jre7/bin/javaw.exe")); java_candidates.append(MakeJavaPtr("C:/Program Files/Java/jre6/bin/javaw.exe")); java_candidates.append(JDK64s); + java_candidates.append(NEWJDK64s); java_candidates.append(JRE32s); + java_candidates.append(NEWJRE32s); java_candidates.append(MakeJavaPtr("C:/Program Files (x86)/Java/jre8/bin/javaw.exe")); java_candidates.append(MakeJavaPtr("C:/Program Files (x86)/Java/jre7/bin/javaw.exe")); java_candidates.append(MakeJavaPtr("C:/Program Files (x86)/Java/jre6/bin/javaw.exe")); java_candidates.append(JDK32s); + java_candidates.append(NEWJDK32s); java_candidates.append(MakeJavaPtr(this->GetDefaultJava()->path)); QList candidates; From cc6cd0648a0fcda419bb5469d6322ed86d49c03e Mon Sep 17 00:00:00 2001 From: Janrupf Date: Sat, 22 May 2021 13:54:34 +0200 Subject: [PATCH 16/57] NOISSUE Add server launch arguments --- api/logic/minecraft/MinecraftInstance.cpp | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/api/logic/minecraft/MinecraftInstance.cpp b/api/logic/minecraft/MinecraftInstance.cpp index a84071c3..4dd70ed1 100644 --- a/api/logic/minecraft/MinecraftInstance.cpp +++ b/api/logic/minecraft/MinecraftInstance.cpp @@ -409,6 +409,12 @@ QStringList MinecraftInstance::processMinecraftArgs(AuthSessionPtr session) cons args_pattern += " --tweakClass " + tweaker; } + if (m_settings->get("JoinServerOnLaunch").toBool()) + { + args_pattern += " --server " + m_settings->get("JoinServerOnLaunchAddress").toString(); + args_pattern += " --port " + m_settings->get("JoinServerOnLaunchPort").toString(); + } + QMap token_mapping; // yggdrasil! if(session) From 23a706bbaebcc8ec9126d019a276c158581bdb53 Mon Sep 17 00:00:00 2001 From: Janrupf Date: Sat, 22 May 2021 16:14:25 +0200 Subject: [PATCH 17/57] NOISSUE Resolve minecraft server using DNS SRV --- api/logic/BaseInstance.h | 6 +- api/logic/CMakeLists.txt | 3 + api/logic/NullInstance.h | 2 +- .../launch/steps/LookupServerAddress.cpp | 95 +++++++++++++++++++ api/logic/launch/steps/LookupServerAddress.h | 51 ++++++++++ api/logic/minecraft/MinecraftInstance.cpp | 34 +++++-- api/logic/minecraft/MinecraftInstance.h | 7 +- .../minecraft/launch/DirectJavaLaunch.cpp | 2 +- api/logic/minecraft/launch/DirectJavaLaunch.h | 9 ++ .../minecraft/launch/LauncherPartLaunch.cpp | 2 +- .../minecraft/launch/LauncherPartLaunch.h | 9 ++ .../minecraft/launch/MinecraftServerTarget.h | 25 +++++ .../minecraft/launch/PrintInstanceInfo.cpp | 2 +- .../minecraft/launch/PrintInstanceInfo.h | 5 +- api/logic/minecraft/legacy/LegacyInstance.cpp | 2 +- api/logic/minecraft/legacy/LegacyInstance.h | 2 +- 16 files changed, 235 insertions(+), 21 deletions(-) create mode 100644 api/logic/launch/steps/LookupServerAddress.cpp create mode 100644 api/logic/launch/steps/LookupServerAddress.h create mode 100644 api/logic/minecraft/launch/MinecraftServerTarget.h diff --git a/api/logic/BaseInstance.h b/api/logic/BaseInstance.h index bbeabb41..7ea4e045 100644 --- a/api/logic/BaseInstance.h +++ b/api/logic/BaseInstance.h @@ -34,6 +34,8 @@ #include "multimc_logic_export.h" +#include "minecraft/launch/MinecraftServerTarget.h" + class QDir; class Task; class LaunchTask; @@ -221,9 +223,9 @@ public: bool reloadSettings(); /** - * 'print' a verbose desription of the instance into a QStringList + * 'print' a verbose description of the instance into a QStringList */ - virtual QStringList verboseDescription(AuthSessionPtr session) = 0; + virtual QStringList verboseDescription(AuthSessionPtr session, MinecraftServerTargetPtr serverToJoin) = 0; Status currentStatus() const; diff --git a/api/logic/CMakeLists.txt b/api/logic/CMakeLists.txt index 91155ea7..52821a61 100644 --- a/api/logic/CMakeLists.txt +++ b/api/logic/CMakeLists.txt @@ -124,6 +124,8 @@ set(NET_SOURCES # Game launch logic set(LAUNCH_SOURCES + launch/steps/LookupServerAddress.cpp + launch/steps/LookupServerAddress.h launch/steps/PostLaunchCommand.cpp launch/steps/PostLaunchCommand.h launch/steps/PreLaunchCommand.cpp @@ -236,6 +238,7 @@ set(MINECRAFT_SOURCES minecraft/launch/ExtractNatives.h minecraft/launch/LauncherPartLaunch.cpp minecraft/launch/LauncherPartLaunch.h + minecraft/launch/MinecraftServerTarget.h minecraft/launch/PrintInstanceInfo.cpp minecraft/launch/PrintInstanceInfo.h minecraft/launch/ReconstructAssets.cpp diff --git a/api/logic/NullInstance.h b/api/logic/NullInstance.h index e9ba1a13..ad39c179 100644 --- a/api/logic/NullInstance.h +++ b/api/logic/NullInstance.h @@ -67,7 +67,7 @@ public: { return false; } - QStringList verboseDescription(AuthSessionPtr session) override + QStringList verboseDescription(AuthSessionPtr session, MinecraftServerTargetPtr serverToJoin) override { QStringList out; out << "Null instance - placeholder."; diff --git a/api/logic/launch/steps/LookupServerAddress.cpp b/api/logic/launch/steps/LookupServerAddress.cpp new file mode 100644 index 00000000..c8e2a20c --- /dev/null +++ b/api/logic/launch/steps/LookupServerAddress.cpp @@ -0,0 +1,95 @@ +#include "LookupServerAddress.h" + +#include + +LookupServerAddress::LookupServerAddress(LaunchTask *parent) : + LaunchStep(parent), m_dnsLookup(new QDnsLookup(this)) +{ + connect(m_dnsLookup, &QDnsLookup::finished, this, &LookupServerAddress::on_dnsLookupFinished); + + m_dnsLookup->setType(QDnsLookup::SRV); +} + +void LookupServerAddress::setLookupAddress(const QString &lookupAddress) +{ + m_lookupAddress = lookupAddress; + m_dnsLookup->setName(QString("_minecraft._tcp.%1").arg(lookupAddress)); +} + +void LookupServerAddress::setPort(quint16 port) +{ + m_port = port; +} + +void LookupServerAddress::setOutputAddressPtr(MinecraftServerTargetPtr output) +{ + m_output = std::move(output); +} + +bool LookupServerAddress::abort() +{ + m_dnsLookup->abort(); + emitFailed("Aborted"); + return true; +} + +void LookupServerAddress::executeTask() +{ + m_dnsLookup->lookup(); +} + +void LookupServerAddress::on_dnsLookupFinished() +{ + if (isFinished()) + { + // Aborted + return; + } + + if (m_dnsLookup->error() != QDnsLookup::NoError) + { + emit logLine(QString("Failed to resolve server address (this is NOT an error!) %1: %2\n") + .arg(m_dnsLookup->name(), m_dnsLookup->errorString()), MessageLevel::MultiMC); + resolve(m_lookupAddress, m_port); // Technically the task failed, however, we don't abort the launch + // and leave it up to minecraft to fail (or maybe not) when connecting + return; + } + + const auto records = m_dnsLookup->serviceRecords(); + if (records.empty()) + { + emit logLine( + QString("Failed to resolve server address %1: the DNS lookup succeeded, but no records were returned.\n") + .arg(m_dnsLookup->name()), MessageLevel::Warning); + resolve(m_lookupAddress, m_port); // Technically the task failed, however, we don't abort the launch + // and leave it up to minecraft to fail (or maybe not) when connecting + return; + } + + const auto &firstRecord = records.at(0); + + if (firstRecord.port() != m_port && m_port != 0) + { + emit logLine( + QString("DNS record for %1 suggested %2 as server port, but user supplied %3. Using user override," + " but the port may be wrong!\n").arg(m_dnsLookup->name(), QString::number(firstRecord.port()), QString::number(m_port)), + MessageLevel::Warning); + } + else if (m_port == 0) + { + m_port = firstRecord.port(); + } + + emit logLine(QString("Resolved server address %1 to %2 with port %3\n").arg( + m_dnsLookup->name(), firstRecord.target(), QString::number(m_port)),MessageLevel::MultiMC); + resolve(firstRecord.target(), m_port); +} + +void LookupServerAddress::resolve(const QString &address, quint16 port) +{ + m_output->address = address; + m_output->port = port; + + emitSucceeded(); + m_dnsLookup->deleteLater(); +} diff --git a/api/logic/launch/steps/LookupServerAddress.h b/api/logic/launch/steps/LookupServerAddress.h new file mode 100644 index 00000000..1f70e97b --- /dev/null +++ b/api/logic/launch/steps/LookupServerAddress.h @@ -0,0 +1,51 @@ +/* Copyright 2013-2021 MultiMC Contributors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#pragma once + +#include +#include +#include + +#include "minecraft/launch/MinecraftServerTarget.h" + +class LookupServerAddress: public LaunchStep { +Q_OBJECT +public: + explicit LookupServerAddress(LaunchTask *parent); + virtual ~LookupServerAddress() {}; + + virtual void executeTask(); + virtual bool abort(); + virtual bool canAbort() const + { + return true; + } + + void setLookupAddress(const QString &lookupAddress); + void setPort(quint16 port); + void setOutputAddressPtr(MinecraftServerTargetPtr output); + +private slots: + void on_dnsLookupFinished(); + +private: + void resolve(const QString &address, quint16 port); + + QDnsLookup *m_dnsLookup; + QString m_lookupAddress; + quint16 m_port; + MinecraftServerTargetPtr m_output; +}; diff --git a/api/logic/minecraft/MinecraftInstance.cpp b/api/logic/minecraft/MinecraftInstance.cpp index 4dd70ed1..e426d5c4 100644 --- a/api/logic/minecraft/MinecraftInstance.cpp +++ b/api/logic/minecraft/MinecraftInstance.cpp @@ -12,6 +12,7 @@ #include #include "launch/LaunchTask.h" +#include "launch/steps/LookupServerAddress.h" #include "launch/steps/PostLaunchCommand.h" #include "launch/steps/Update.h" #include "launch/steps/PreLaunchCommand.h" @@ -400,7 +401,8 @@ static QString replaceTokensIn(QString text, QMap with) return result; } -QStringList MinecraftInstance::processMinecraftArgs(AuthSessionPtr session) const +QStringList MinecraftInstance::processMinecraftArgs( + AuthSessionPtr session, MinecraftServerTargetPtr serverToJoin) const { auto profile = m_components->getProfile(); QString args_pattern = profile->getMinecraftArguments(); @@ -409,10 +411,10 @@ QStringList MinecraftInstance::processMinecraftArgs(AuthSessionPtr session) cons args_pattern += " --tweakClass " + tweaker; } - if (m_settings->get("JoinServerOnLaunch").toBool()) + if (serverToJoin && !serverToJoin->address.isEmpty()) { - args_pattern += " --server " + m_settings->get("JoinServerOnLaunchAddress").toString(); - args_pattern += " --port " + m_settings->get("JoinServerOnLaunchPort").toString(); + args_pattern += " --server " + serverToJoin->address; + args_pattern += " --port " + QString::number(serverToJoin->port); } QMap token_mapping; @@ -451,7 +453,7 @@ QStringList MinecraftInstance::processMinecraftArgs(AuthSessionPtr session) cons return parts; } -QString MinecraftInstance::createLaunchScript(AuthSessionPtr session) +QString MinecraftInstance::createLaunchScript(AuthSessionPtr session, MinecraftServerTargetPtr serverToJoin) { QString launchScript; @@ -473,7 +475,7 @@ QString MinecraftInstance::createLaunchScript(AuthSessionPtr session) } // generic minecraft params - for (auto param : processMinecraftArgs(session)) + for (auto param : processMinecraftArgs(session, serverToJoin)) { launchScript += "param " + param + "\n"; } @@ -523,7 +525,7 @@ QString MinecraftInstance::createLaunchScript(AuthSessionPtr session) return launchScript; } -QStringList MinecraftInstance::verboseDescription(AuthSessionPtr session) +QStringList MinecraftInstance::verboseDescription(AuthSessionPtr session, MinecraftServerTargetPtr serverToJoin) { QStringList out; out << "Main Class:" << " " + getMainClass() << ""; @@ -638,7 +640,7 @@ QStringList MinecraftInstance::verboseDescription(AuthSessionPtr session) out << ""; } - auto params = processMinecraftArgs(nullptr); + auto params = processMinecraftArgs(nullptr, serverToJoin); out << "Params:"; out << " " + params.join(' '); out << ""; @@ -844,6 +846,18 @@ shared_qobject_ptr MinecraftInstance::createLaunchTask(AuthSessionPt process->appendStep(new CreateGameFolders(pptr)); } + MinecraftServerTargetPtr serverToJoin = std::make_shared(); + + if (m_settings->get("JoinServerOnLaunch").toBool()) + { + // Resolve server address to join on launch + auto *step = new LookupServerAddress(pptr); + step->setLookupAddress(m_settings->get("JoinServerOnLaunchAddress").toString()); + step->setPort(m_settings->get("JoinServerOnLaunchPort").toInt()); + step->setOutputAddressPtr(serverToJoin); + process->appendStep(step); + } + // run pre-launch command if that's needed if(getPreLaunchCommand().size()) { @@ -875,7 +889,7 @@ shared_qobject_ptr MinecraftInstance::createLaunchTask(AuthSessionPt // print some instance info here... { - process->appendStep(new PrintInstanceInfo(pptr, session)); + process->appendStep(new PrintInstanceInfo(pptr, session, serverToJoin)); } // extract native jars if needed @@ -896,6 +910,7 @@ shared_qobject_ptr MinecraftInstance::createLaunchTask(AuthSessionPt auto step = new LauncherPartLaunch(pptr); step->setWorkingDirectory(gameRoot()); step->setAuthSession(session); + step->setServerToJoin(serverToJoin); process->appendStep(step); } else if (method == "DirectJava") @@ -903,6 +918,7 @@ shared_qobject_ptr MinecraftInstance::createLaunchTask(AuthSessionPt auto step = new DirectJavaLaunch(pptr); step->setWorkingDirectory(gameRoot()); step->setAuthSession(session); + step->setServerToJoin(serverToJoin); process->appendStep(step); } } diff --git a/api/logic/minecraft/MinecraftInstance.h b/api/logic/minecraft/MinecraftInstance.h index 985a8a76..eb1a9005 100644 --- a/api/logic/minecraft/MinecraftInstance.h +++ b/api/logic/minecraft/MinecraftInstance.h @@ -5,6 +5,7 @@ #include #include #include "multimc_logic_export.h" +#include "minecraft/launch/MinecraftServerTarget.h" class ModFolderModel; class WorldList; @@ -78,9 +79,9 @@ public: shared_qobject_ptr createUpdateTask(Net::Mode mode) override; shared_qobject_ptr createLaunchTask(AuthSessionPtr account) override; QStringList extraArguments() const override; - QStringList verboseDescription(AuthSessionPtr session) override; + QStringList verboseDescription(AuthSessionPtr session, MinecraftServerTargetPtr serverToJoin) override; QList getJarMods() const; - QString createLaunchScript(AuthSessionPtr session); + QString createLaunchScript(AuthSessionPtr session, MinecraftServerTargetPtr serverToJoin); /// get arguments passed to java QStringList javaArguments() const; @@ -107,7 +108,7 @@ public: virtual QString getMainClass() const; // FIXME: remove - virtual QStringList processMinecraftArgs(AuthSessionPtr account) const; + virtual QStringList processMinecraftArgs(AuthSessionPtr account, MinecraftServerTargetPtr serverToJoin) const; virtual JavaVersion getJavaVersion() const; diff --git a/api/logic/minecraft/launch/DirectJavaLaunch.cpp b/api/logic/minecraft/launch/DirectJavaLaunch.cpp index d9841a43..cf4564b6 100644 --- a/api/logic/minecraft/launch/DirectJavaLaunch.cpp +++ b/api/logic/minecraft/launch/DirectJavaLaunch.cpp @@ -55,7 +55,7 @@ void DirectJavaLaunch::executeTask() // make detachable - this will keep the process running even if the object is destroyed m_process.setDetachable(true); - auto mcArgs = minecraftInstance->processMinecraftArgs(m_session); + auto mcArgs = minecraftInstance->processMinecraftArgs(m_session, m_serverToJoin); args.append(mcArgs); QString wrapperCommandStr = instance->getWrapperCommand().trimmed(); diff --git a/api/logic/minecraft/launch/DirectJavaLaunch.h b/api/logic/minecraft/launch/DirectJavaLaunch.h index d9d9bdc2..58b119b8 100644 --- a/api/logic/minecraft/launch/DirectJavaLaunch.h +++ b/api/logic/minecraft/launch/DirectJavaLaunch.h @@ -19,6 +19,8 @@ #include #include +#include "MinecraftServerTarget.h" + class DirectJavaLaunch: public LaunchStep { Q_OBJECT @@ -38,6 +40,12 @@ public: { m_session = session; } + + void setServerToJoin(MinecraftServerTargetPtr serverToJoin) + { + m_serverToJoin = std::move(serverToJoin); + } + private slots: void on_state(LoggedProcess::State state); @@ -45,5 +53,6 @@ private: LoggedProcess m_process; QString m_command; AuthSessionPtr m_session; + MinecraftServerTargetPtr m_serverToJoin; }; diff --git a/api/logic/minecraft/launch/LauncherPartLaunch.cpp b/api/logic/minecraft/launch/LauncherPartLaunch.cpp index 1408e6ad..ab3b6d10 100644 --- a/api/logic/minecraft/launch/LauncherPartLaunch.cpp +++ b/api/logic/minecraft/launch/LauncherPartLaunch.cpp @@ -59,7 +59,7 @@ void LauncherPartLaunch::executeTask() auto instance = m_parent->instance(); std::shared_ptr minecraftInstance = std::dynamic_pointer_cast(instance); - m_launchScript = minecraftInstance->createLaunchScript(m_session); + m_launchScript = minecraftInstance->createLaunchScript(m_session, m_serverToJoin); QStringList args = minecraftInstance->javaArguments(); QString allArgs = args.join(", "); emit logLine("Java Arguments:\n[" + m_parent->censorPrivateInfo(allArgs) + "]\n\n", MessageLevel::MultiMC); diff --git a/api/logic/minecraft/launch/LauncherPartLaunch.h b/api/logic/minecraft/launch/LauncherPartLaunch.h index 9e951849..6a7ee0e5 100644 --- a/api/logic/minecraft/launch/LauncherPartLaunch.h +++ b/api/logic/minecraft/launch/LauncherPartLaunch.h @@ -19,6 +19,8 @@ #include #include +#include "MinecraftServerTarget.h" + class LauncherPartLaunch: public LaunchStep { Q_OBJECT @@ -39,6 +41,11 @@ public: m_session = session; } + void setServerToJoin(MinecraftServerTargetPtr serverToJoin) + { + m_serverToJoin = std::move(serverToJoin); + } + private slots: void on_state(LoggedProcess::State state); @@ -47,5 +54,7 @@ private: QString m_command; AuthSessionPtr m_session; QString m_launchScript; + MinecraftServerTargetPtr m_serverToJoin; + bool mayProceed = false; }; diff --git a/api/logic/minecraft/launch/MinecraftServerTarget.h b/api/logic/minecraft/launch/MinecraftServerTarget.h new file mode 100644 index 00000000..f9b407e0 --- /dev/null +++ b/api/logic/minecraft/launch/MinecraftServerTarget.h @@ -0,0 +1,25 @@ +/* Copyright 2013-2021 MultiMC Contributors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#pragma once + +#include + +struct MinecraftServerTarget { + QString address; + quint16 port; +}; + +typedef std::shared_ptr MinecraftServerTargetPtr; diff --git a/api/logic/minecraft/launch/PrintInstanceInfo.cpp b/api/logic/minecraft/launch/PrintInstanceInfo.cpp index af0b5bbf..0b9611ad 100644 --- a/api/logic/minecraft/launch/PrintInstanceInfo.cpp +++ b/api/logic/minecraft/launch/PrintInstanceInfo.cpp @@ -101,6 +101,6 @@ void PrintInstanceInfo::executeTask() #endif logLines(log, MessageLevel::MultiMC); - logLines(instance->verboseDescription(m_session), MessageLevel::MultiMC); + logLines(instance->verboseDescription(m_session, m_serverToJoin), MessageLevel::MultiMC); emitSucceeded(); } diff --git a/api/logic/minecraft/launch/PrintInstanceInfo.h b/api/logic/minecraft/launch/PrintInstanceInfo.h index 168eff9d..fdc30f31 100644 --- a/api/logic/minecraft/launch/PrintInstanceInfo.h +++ b/api/logic/minecraft/launch/PrintInstanceInfo.h @@ -18,13 +18,15 @@ #include #include #include "minecraft/auth/AuthSession.h" +#include "minecraft/launch/MinecraftServerTarget.h" // FIXME: temporary wrapper for existing task. class PrintInstanceInfo: public LaunchStep { Q_OBJECT public: - explicit PrintInstanceInfo(LaunchTask *parent, AuthSessionPtr session) : LaunchStep(parent), m_session(session) {}; + explicit PrintInstanceInfo(LaunchTask *parent, AuthSessionPtr session, MinecraftServerTargetPtr serverToJoin) : + LaunchStep(parent), m_session(session), m_serverToJoin(serverToJoin) {}; virtual ~PrintInstanceInfo(){}; virtual void executeTask(); @@ -34,5 +36,6 @@ public: } private: AuthSessionPtr m_session; + MinecraftServerTargetPtr m_serverToJoin; }; diff --git a/api/logic/minecraft/legacy/LegacyInstance.cpp b/api/logic/minecraft/legacy/LegacyInstance.cpp index f86e5d05..9f9bda5a 100644 --- a/api/logic/minecraft/legacy/LegacyInstance.cpp +++ b/api/logic/minecraft/legacy/LegacyInstance.cpp @@ -225,7 +225,7 @@ QString LegacyInstance::getStatusbarDescription() return tr("Instance from previous versions."); } -QStringList LegacyInstance::verboseDescription(AuthSessionPtr session) +QStringList LegacyInstance::verboseDescription(AuthSessionPtr session, MinecraftServerTargetPtr serverToJoin) { QStringList out; diff --git a/api/logic/minecraft/legacy/LegacyInstance.h b/api/logic/minecraft/legacy/LegacyInstance.h index 9caddcba..7450fdda 100644 --- a/api/logic/minecraft/legacy/LegacyInstance.h +++ b/api/logic/minecraft/legacy/LegacyInstance.h @@ -125,7 +125,7 @@ public: } QString getStatusbarDescription() override; - QStringList verboseDescription(AuthSessionPtr session) override; + QStringList verboseDescription(AuthSessionPtr session, MinecraftServerTargetPtr serverToJoin) override; QProcessEnvironment createEnvironment() override { From 0ccd7223fd554f86272dbffddd2e7818c26ffa53 Mon Sep 17 00:00:00 2001 From: Janrupf Date: Sat, 22 May 2021 16:32:15 +0200 Subject: [PATCH 18/57] NOISSUE Make LauncherPart aware of server to join --- api/logic/minecraft/MinecraftInstance.cpp | 11 ++++++++++- .../launcher/org/multimc/LegacyFrame.java | 18 +++++++++++++++++- .../org/multimc/onesix/OneSixLauncher.java | 16 +++++++++++++++- 3 files changed, 42 insertions(+), 3 deletions(-) diff --git a/api/logic/minecraft/MinecraftInstance.cpp b/api/logic/minecraft/MinecraftInstance.cpp index e426d5c4..54c7f594 100644 --- a/api/logic/minecraft/MinecraftInstance.cpp +++ b/api/logic/minecraft/MinecraftInstance.cpp @@ -474,8 +474,17 @@ QString MinecraftInstance::createLaunchScript(AuthSessionPtr session, MinecraftS launchScript += "appletClass " + appletClass + "\n"; } + if (serverToJoin && !serverToJoin->address.isEmpty()) + { + launchScript += "serverAddress " + serverToJoin->address + "\n"; + launchScript += "serverPort " + QString::number(serverToJoin->port) + "\n"; + } + // generic minecraft params - for (auto param : processMinecraftArgs(session, serverToJoin)) + for (auto param : processMinecraftArgs( + session, + nullptr /* When using a launch script, the server parameters are handled by it*/ + )) { launchScript += "param " + param + "\n"; } diff --git a/libraries/launcher/org/multimc/LegacyFrame.java b/libraries/launcher/org/multimc/LegacyFrame.java index c72c053e..985a10e6 100644 --- a/libraries/launcher/org/multimc/LegacyFrame.java +++ b/libraries/launcher/org/multimc/LegacyFrame.java @@ -46,7 +46,16 @@ public class LegacyFrame extends Frame implements WindowListener this.addWindowListener ( this ); } - public void start ( Applet mcApplet, String user, String session, int winSizeW, int winSizeH, boolean maximize ) + public void start ( + Applet mcApplet, + String user, + String session, + int winSizeW, + int winSizeH, + boolean maximize, + String serverAddress, + String serverPort + ) { try { appletWrap = new Launcher( mcApplet, new URL ( "http://www.minecraft.net/game" ) ); @@ -95,6 +104,13 @@ public class LegacyFrame extends Frame implements WindowListener e.printStackTrace(System.err); System.exit(-1); } + + if (serverAddress != null) + { + appletWrap.setParameter("server", serverAddress); + appletWrap.setParameter("port", serverPort); + } + appletWrap.setParameter ( "username", user ); appletWrap.setParameter ( "sessionid", session ); appletWrap.setParameter ( "stand-alone", "true" ); // Show the quit button. diff --git a/libraries/launcher/org/multimc/onesix/OneSixLauncher.java b/libraries/launcher/org/multimc/onesix/OneSixLauncher.java index b6b384ab..ea445995 100644 --- a/libraries/launcher/org/multimc/onesix/OneSixLauncher.java +++ b/libraries/launcher/org/multimc/onesix/OneSixLauncher.java @@ -47,6 +47,9 @@ public class OneSixLauncher implements Launcher private boolean maximize; private String cwd; + private String serverAddress; + private String serverPort; + // the much abused system classloader, for convenience (for further abuse) private ClassLoader cl; @@ -64,6 +67,9 @@ public class OneSixLauncher implements Launcher windowTitle = params.firstSafe("windowTitle", "Minecraft"); windowParams = params.firstSafe("windowParams", "854x480"); + serverAddress = params.firstSafe("serverAddress", null); + serverPort = params.firstSafe("serverPort", null); + cwd = System.getProperty("user.dir"); winSizeW = 854; @@ -122,7 +128,7 @@ public class OneSixLauncher implements Launcher Class MCAppletClass = cl.loadClass(appletClass); Applet mcappl = (Applet) MCAppletClass.newInstance(); LegacyFrame mcWindow = new LegacyFrame(windowTitle); - mcWindow.start(mcappl, userName, sessionId, winSizeW, winSizeH, maximize); + mcWindow.start(mcappl, userName, sessionId, winSizeW, winSizeH, maximize, serverAddress, serverPort); return 0; } catch (Exception e) { @@ -164,6 +170,14 @@ public class OneSixLauncher implements Launcher mcparams.add(Integer.toString(winSizeH)); } + if (serverAddress != null) + { + mcparams.add("--server"); + mcparams.add(serverAddress); + mcparams.add("--port"); + mcparams.add(serverPort); + } + // Get the Minecraft Class. Class mc; try From d97f13b4aacd00b7157735702fa4484317640a4f Mon Sep 17 00:00:00 2001 From: Janrupf Date: Sat, 22 May 2021 17:00:14 +0200 Subject: [PATCH 19/57] NOISSUE Use Vanilla logic for resolving servers --- .../launch/steps/LookupServerAddress.cpp | 26 ++++--------------- api/logic/launch/steps/LookupServerAddress.h | 2 -- api/logic/minecraft/MinecraftInstance.cpp | 20 +++++++++----- .../pages/instance/InstanceSettingsPage.ui | 2 +- 4 files changed, 20 insertions(+), 30 deletions(-) diff --git a/api/logic/launch/steps/LookupServerAddress.cpp b/api/logic/launch/steps/LookupServerAddress.cpp index c8e2a20c..c6ca5bd5 100644 --- a/api/logic/launch/steps/LookupServerAddress.cpp +++ b/api/logic/launch/steps/LookupServerAddress.cpp @@ -16,11 +16,6 @@ void LookupServerAddress::setLookupAddress(const QString &lookupAddress) m_dnsLookup->setName(QString("_minecraft._tcp.%1").arg(lookupAddress)); } -void LookupServerAddress::setPort(quint16 port) -{ - m_port = port; -} - void LookupServerAddress::setOutputAddressPtr(MinecraftServerTargetPtr output) { m_output = std::move(output); @@ -50,7 +45,7 @@ void LookupServerAddress::on_dnsLookupFinished() { emit logLine(QString("Failed to resolve server address (this is NOT an error!) %1: %2\n") .arg(m_dnsLookup->name(), m_dnsLookup->errorString()), MessageLevel::MultiMC); - resolve(m_lookupAddress, m_port); // Technically the task failed, however, we don't abort the launch + resolve(m_lookupAddress, 25565); // Technically the task failed, however, we don't abort the launch // and leave it up to minecraft to fail (or maybe not) when connecting return; } @@ -61,28 +56,17 @@ void LookupServerAddress::on_dnsLookupFinished() emit logLine( QString("Failed to resolve server address %1: the DNS lookup succeeded, but no records were returned.\n") .arg(m_dnsLookup->name()), MessageLevel::Warning); - resolve(m_lookupAddress, m_port); // Technically the task failed, however, we don't abort the launch + resolve(m_lookupAddress, 25565); // Technically the task failed, however, we don't abort the launch // and leave it up to minecraft to fail (or maybe not) when connecting return; } const auto &firstRecord = records.at(0); - - if (firstRecord.port() != m_port && m_port != 0) - { - emit logLine( - QString("DNS record for %1 suggested %2 as server port, but user supplied %3. Using user override," - " but the port may be wrong!\n").arg(m_dnsLookup->name(), QString::number(firstRecord.port()), QString::number(m_port)), - MessageLevel::Warning); - } - else if (m_port == 0) - { - m_port = firstRecord.port(); - } + quint16 port = firstRecord.port(); emit logLine(QString("Resolved server address %1 to %2 with port %3\n").arg( - m_dnsLookup->name(), firstRecord.target(), QString::number(m_port)),MessageLevel::MultiMC); - resolve(firstRecord.target(), m_port); + m_dnsLookup->name(), firstRecord.target(), QString::number(port)),MessageLevel::MultiMC); + resolve(firstRecord.target(), port); } void LookupServerAddress::resolve(const QString &address, quint16 port) diff --git a/api/logic/launch/steps/LookupServerAddress.h b/api/logic/launch/steps/LookupServerAddress.h index 1f70e97b..5a5c3de1 100644 --- a/api/logic/launch/steps/LookupServerAddress.h +++ b/api/logic/launch/steps/LookupServerAddress.h @@ -35,7 +35,6 @@ public: } void setLookupAddress(const QString &lookupAddress); - void setPort(quint16 port); void setOutputAddressPtr(MinecraftServerTargetPtr output); private slots: @@ -46,6 +45,5 @@ private: QDnsLookup *m_dnsLookup; QString m_lookupAddress; - quint16 m_port; MinecraftServerTargetPtr m_output; }; diff --git a/api/logic/minecraft/MinecraftInstance.cpp b/api/logic/minecraft/MinecraftInstance.cpp index 54c7f594..abb360f2 100644 --- a/api/logic/minecraft/MinecraftInstance.cpp +++ b/api/logic/minecraft/MinecraftInstance.cpp @@ -859,12 +859,20 @@ shared_qobject_ptr MinecraftInstance::createLaunchTask(AuthSessionPt if (m_settings->get("JoinServerOnLaunch").toBool()) { - // Resolve server address to join on launch - auto *step = new LookupServerAddress(pptr); - step->setLookupAddress(m_settings->get("JoinServerOnLaunchAddress").toString()); - step->setPort(m_settings->get("JoinServerOnLaunchPort").toInt()); - step->setOutputAddressPtr(serverToJoin); - process->appendStep(step); + quint16 port = m_settings->get("JoinServerOnLaunchPort").toInt(); + QString address = m_settings->get("JoinServerOnLaunchAddress").toString(); + + serverToJoin->port = port; + serverToJoin->address = address; + + if(port == 25565) + { + // Resolve server address to join on launch + auto *step = new LookupServerAddress(pptr); + step->setLookupAddress(address); + step->setOutputAddressPtr(serverToJoin); + process->appendStep(step); + } } // run pre-launch command if that's needed diff --git a/application/pages/instance/InstanceSettingsPage.ui b/application/pages/instance/InstanceSettingsPage.ui index 50c3ac6b..eb8ed13a 100644 --- a/application/pages/instance/InstanceSettingsPage.ui +++ b/application/pages/instance/InstanceSettingsPage.ui @@ -39,7 +39,7 @@ QTabWidget::Rounded - 4 + 0 From f33fe05e5febf76d8e11ccd44073d99e00946d71 Mon Sep 17 00:00:00 2001 From: Janrupf Date: Sat, 22 May 2021 17:24:37 +0200 Subject: [PATCH 20/57] NOISSUE Use minecraft logic for parsing adresses --- api/logic/minecraft/MinecraftInstance.cpp | 55 ++++++++++++++++--- .../pages/instance/InstanceSettingsPage.cpp | 3 - .../pages/instance/InstanceSettingsPage.ui | 19 +------ 3 files changed, 49 insertions(+), 28 deletions(-) diff --git a/api/logic/minecraft/MinecraftInstance.cpp b/api/logic/minecraft/MinecraftInstance.cpp index abb360f2..00ac7964 100644 --- a/api/logic/minecraft/MinecraftInstance.cpp +++ b/api/logic/minecraft/MinecraftInstance.cpp @@ -115,7 +115,6 @@ MinecraftInstance::MinecraftInstance(SettingsObjectPtr globalSettings, SettingsO // Join server on launch, this does not have a global override m_settings->registerSetting("JoinServerOnLaunch", false); m_settings->registerSetting("JoinServerOnLaunchAddress", ""); - m_settings->registerSetting("JoinServerOnLaunchPort", 25565); // DEPRECATED: Read what versions the user configuration thinks should be used m_settings->registerSetting({"IntendedVersion", "MinecraftVersion"}, ""); @@ -859,17 +858,59 @@ shared_qobject_ptr MinecraftInstance::createLaunchTask(AuthSessionPt if (m_settings->get("JoinServerOnLaunch").toBool()) { - quint16 port = m_settings->get("JoinServerOnLaunchPort").toInt(); - QString address = m_settings->get("JoinServerOnLaunchAddress").toString(); + QString fullAddress = m_settings->get("JoinServerOnLaunchAddress").toString(); + QStringList split = fullAddress.split(":"); - serverToJoin->port = port; - serverToJoin->address = address; + // The logic below replicates the exact logic minecraft uses for parsing server addresses. + // While the conversion is not lossless and eats errors, it ensures the same behavior + // within Minecraft and MultiMC when entering server addresses. + if (fullAddress.startsWith("[")) + { + int bracket = fullAddress.indexOf("]"); + if (bracket > 0) + { + QString ipv6 = fullAddress.mid(1, bracket - 1); + QString port = fullAddress.mid(bracket + 1).trimmed(); - if(port == 25565) + if (port.startsWith(":") && !ipv6.isEmpty()) + { + port = port.mid(1); + split = QStringList({ ipv6, port }); + } + else + { + split = QStringList({ipv6}); + } + } + } + + if (split.size() > 2) + { + split = QStringList({fullAddress}); + } + + QString realAddress = split[0]; + + quint16 realPort = 25565; + if (split.size() > 1) + { + bool ok; + realPort = split[1].toUInt(&ok); + + if (!ok) + { + realPort = 25565; + } + } + + serverToJoin->port = realPort; + serverToJoin->address = realAddress; + + if(realPort == 25565) { // Resolve server address to join on launch auto *step = new LookupServerAddress(pptr); - step->setLookupAddress(address); + step->setLookupAddress(realAddress); step->setOutputAddressPtr(serverToJoin); process->appendStep(step); } diff --git a/application/pages/instance/InstanceSettingsPage.cpp b/application/pages/instance/InstanceSettingsPage.cpp index ff8659c5..00fc19af 100644 --- a/application/pages/instance/InstanceSettingsPage.cpp +++ b/application/pages/instance/InstanceSettingsPage.cpp @@ -198,12 +198,10 @@ void InstanceSettingsPage::applySettings() if (joinServerOnLaunch) { m_settings->set("JoinServerOnLaunchAddress", ui->serverJoinAddress->text()); - m_settings->set("JoinServerOnLaunchPort", ui->serverJoinPort->value()); } else { m_settings->reset("JoinServerOnLaunchAddress"); - m_settings->reset("JoinServerOnLaunchPort"); } } @@ -274,7 +272,6 @@ void InstanceSettingsPage::loadSettings() ui->serverJoinGroupBox->setChecked(m_settings->get("JoinServerOnLaunch").toBool()); ui->serverJoinAddress->setText(m_settings->get("JoinServerOnLaunchAddress").toString()); - ui->serverJoinPort->setValue(m_settings->get("JoinServerOnLaunchPort").toInt()); } void InstanceSettingsPage::on_javaDetectBtn_clicked() diff --git a/application/pages/instance/InstanceSettingsPage.ui b/application/pages/instance/InstanceSettingsPage.ui index eb8ed13a..de9fa9e3 100644 --- a/application/pages/instance/InstanceSettingsPage.ui +++ b/application/pages/instance/InstanceSettingsPage.ui @@ -39,7 +39,7 @@ QTabWidget::Rounded - 0 + 4 @@ -483,23 +483,6 @@ - - - - Server port: - - - - - - - 65535 - - - 25565 - - - From ea6c42a93c95e3e62d7ac984ff2cc4f461dc43dd Mon Sep 17 00:00:00 2001 From: Janrupf Date: Sat, 22 May 2021 18:07:08 +0200 Subject: [PATCH 21/57] NOISSUE Allow joining servers from the servers page --- api/logic/BaseInstance.h | 3 +- api/logic/CMakeLists.txt | 1 + api/logic/NullInstance.h | 2 +- api/logic/minecraft/MinecraftInstance.cpp | 69 +++---------------- api/logic/minecraft/MinecraftInstance.h | 2 +- .../launch/MinecraftServerTarget.cpp | 66 ++++++++++++++++++ .../minecraft/launch/MinecraftServerTarget.h | 5 ++ api/logic/minecraft/legacy/LegacyInstance.h | 3 +- application/InstancePageProvider.h | 2 +- application/LaunchController.cpp | 2 +- application/LaunchController.h | 7 ++ application/MultiMC.cpp | 9 ++- application/MultiMC.h | 9 ++- .../pages/instance/InstanceSettingsPage.ui | 2 +- application/pages/instance/ServersPage.cpp | 11 ++- application/pages/instance/ServersPage.h | 5 +- application/pages/instance/ServersPage.ui | 6 ++ 17 files changed, 132 insertions(+), 72 deletions(-) create mode 100644 api/logic/minecraft/launch/MinecraftServerTarget.cpp diff --git a/api/logic/BaseInstance.h b/api/logic/BaseInstance.h index 7ea4e045..64de4bb3 100644 --- a/api/logic/BaseInstance.h +++ b/api/logic/BaseInstance.h @@ -147,7 +147,8 @@ public: virtual shared_qobject_ptr createUpdateTask(Net::Mode mode) = 0; /// returns a valid launcher (task container) - virtual shared_qobject_ptr createLaunchTask(AuthSessionPtr account) = 0; + virtual shared_qobject_ptr createLaunchTask( + AuthSessionPtr account, MinecraftServerTargetPtr serverToJoin) = 0; /// returns the current launch task (if any) shared_qobject_ptr getLaunchTask(); diff --git a/api/logic/CMakeLists.txt b/api/logic/CMakeLists.txt index 52821a61..c3322955 100644 --- a/api/logic/CMakeLists.txt +++ b/api/logic/CMakeLists.txt @@ -238,6 +238,7 @@ set(MINECRAFT_SOURCES minecraft/launch/ExtractNatives.h minecraft/launch/LauncherPartLaunch.cpp minecraft/launch/LauncherPartLaunch.h + minecraft/launch/MinecraftServerTarget.cpp minecraft/launch/MinecraftServerTarget.h minecraft/launch/PrintInstanceInfo.cpp minecraft/launch/PrintInstanceInfo.h diff --git a/api/logic/NullInstance.h b/api/logic/NullInstance.h index ad39c179..94ed6c3a 100644 --- a/api/logic/NullInstance.h +++ b/api/logic/NullInstance.h @@ -27,7 +27,7 @@ public: { return instanceRoot(); }; - shared_qobject_ptr createLaunchTask(AuthSessionPtr) override + shared_qobject_ptr createLaunchTask(AuthSessionPtr, MinecraftServerTargetPtr) override { return nullptr; } diff --git a/api/logic/minecraft/MinecraftInstance.cpp b/api/logic/minecraft/MinecraftInstance.cpp index 00ac7964..a1341e69 100644 --- a/api/logic/minecraft/MinecraftInstance.cpp +++ b/api/logic/minecraft/MinecraftInstance.cpp @@ -822,7 +822,7 @@ shared_qobject_ptr MinecraftInstance::createUpdateTask(Net::Mode mode) return nullptr; } -shared_qobject_ptr MinecraftInstance::createLaunchTask(AuthSessionPtr session) +shared_qobject_ptr MinecraftInstance::createLaunchTask(AuthSessionPtr session, MinecraftServerTargetPtr serverToJoin) { // FIXME: get rid of shared_from_this ... auto process = LaunchTask::create(std::dynamic_pointer_cast(shared_from_this())); @@ -854,66 +854,19 @@ shared_qobject_ptr MinecraftInstance::createLaunchTask(AuthSessionPt process->appendStep(new CreateGameFolders(pptr)); } - MinecraftServerTargetPtr serverToJoin = std::make_shared(); - - if (m_settings->get("JoinServerOnLaunch").toBool()) + if (!serverToJoin && m_settings->get("JoinServerOnLaunch").toBool()) { QString fullAddress = m_settings->get("JoinServerOnLaunchAddress").toString(); - QStringList split = fullAddress.split(":"); + serverToJoin.reset(new MinecraftServerTarget(MinecraftServerTarget::parse(fullAddress))); + } - // The logic below replicates the exact logic minecraft uses for parsing server addresses. - // While the conversion is not lossless and eats errors, it ensures the same behavior - // within Minecraft and MultiMC when entering server addresses. - if (fullAddress.startsWith("[")) - { - int bracket = fullAddress.indexOf("]"); - if (bracket > 0) - { - QString ipv6 = fullAddress.mid(1, bracket - 1); - QString port = fullAddress.mid(bracket + 1).trimmed(); - - if (port.startsWith(":") && !ipv6.isEmpty()) - { - port = port.mid(1); - split = QStringList({ ipv6, port }); - } - else - { - split = QStringList({ipv6}); - } - } - } - - if (split.size() > 2) - { - split = QStringList({fullAddress}); - } - - QString realAddress = split[0]; - - quint16 realPort = 25565; - if (split.size() > 1) - { - bool ok; - realPort = split[1].toUInt(&ok); - - if (!ok) - { - realPort = 25565; - } - } - - serverToJoin->port = realPort; - serverToJoin->address = realAddress; - - if(realPort == 25565) - { - // Resolve server address to join on launch - auto *step = new LookupServerAddress(pptr); - step->setLookupAddress(realAddress); - step->setOutputAddressPtr(serverToJoin); - process->appendStep(step); - } + if(serverToJoin && serverToJoin->port == 25565) + { + // Resolve server address to join on launch + auto *step = new LookupServerAddress(pptr); + step->setLookupAddress(serverToJoin->address); + step->setOutputAddressPtr(serverToJoin); + process->appendStep(step); } // run pre-launch command if that's needed diff --git a/api/logic/minecraft/MinecraftInstance.h b/api/logic/minecraft/MinecraftInstance.h index eb1a9005..05600797 100644 --- a/api/logic/minecraft/MinecraftInstance.h +++ b/api/logic/minecraft/MinecraftInstance.h @@ -77,7 +77,7 @@ public: ////// Launch stuff ////// shared_qobject_ptr createUpdateTask(Net::Mode mode) override; - shared_qobject_ptr createLaunchTask(AuthSessionPtr account) override; + shared_qobject_ptr createLaunchTask(AuthSessionPtr account, MinecraftServerTargetPtr serverToJoin) override; QStringList extraArguments() const override; QStringList verboseDescription(AuthSessionPtr session, MinecraftServerTargetPtr serverToJoin) override; QList getJarMods() const; diff --git a/api/logic/minecraft/launch/MinecraftServerTarget.cpp b/api/logic/minecraft/launch/MinecraftServerTarget.cpp new file mode 100644 index 00000000..569273b6 --- /dev/null +++ b/api/logic/minecraft/launch/MinecraftServerTarget.cpp @@ -0,0 +1,66 @@ +/* Copyright 2013-2021 MultiMC Contributors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "MinecraftServerTarget.h" + +#include + +MinecraftServerTarget MinecraftServerTarget::parse(const QString &fullAddress) { + QStringList split = fullAddress.split(":"); + + // The logic below replicates the exact logic minecraft uses for parsing server addresses. + // While the conversion is not lossless and eats errors, it ensures the same behavior + // within Minecraft and MultiMC when entering server addresses. + if (fullAddress.startsWith("[")) + { + int bracket = fullAddress.indexOf("]"); + if (bracket > 0) + { + QString ipv6 = fullAddress.mid(1, bracket - 1); + QString port = fullAddress.mid(bracket + 1).trimmed(); + + if (port.startsWith(":") && !ipv6.isEmpty()) + { + port = port.mid(1); + split = QStringList({ ipv6, port }); + } + else + { + split = QStringList({ipv6}); + } + } + } + + if (split.size() > 2) + { + split = QStringList({fullAddress}); + } + + QString realAddress = split[0]; + + quint16 realPort = 25565; + if (split.size() > 1) + { + bool ok; + realPort = split[1].toUInt(&ok); + + if (!ok) + { + realPort = 25565; + } + } + + return MinecraftServerTarget { realAddress, realPort }; +} diff --git a/api/logic/minecraft/launch/MinecraftServerTarget.h b/api/logic/minecraft/launch/MinecraftServerTarget.h index f9b407e0..3c5786f4 100644 --- a/api/logic/minecraft/launch/MinecraftServerTarget.h +++ b/api/logic/minecraft/launch/MinecraftServerTarget.h @@ -17,9 +17,14 @@ #include +#include +#include + struct MinecraftServerTarget { QString address; quint16 port; + + static MULTIMC_LOGIC_EXPORT MinecraftServerTarget parse(const QString &fullAddress); }; typedef std::shared_ptr MinecraftServerTargetPtr; diff --git a/api/logic/minecraft/legacy/LegacyInstance.h b/api/logic/minecraft/legacy/LegacyInstance.h index 7450fdda..325bac7a 100644 --- a/api/logic/minecraft/legacy/LegacyInstance.h +++ b/api/logic/minecraft/legacy/LegacyInstance.h @@ -111,7 +111,8 @@ public: { return false; } - shared_qobject_ptr createLaunchTask(AuthSessionPtr account) override + shared_qobject_ptr createLaunchTask( + AuthSessionPtr account, MinecraftServerTargetPtr serverToJoin) override { return nullptr; } diff --git a/application/InstancePageProvider.h b/application/InstancePageProvider.h index dde36aef..3cb723c4 100644 --- a/application/InstancePageProvider.h +++ b/application/InstancePageProvider.h @@ -46,7 +46,7 @@ public: values.append(new TexturePackPage(onesix.get())); values.append(new NotesPage(onesix.get())); values.append(new WorldListPage(onesix.get(), onesix->worldList())); - values.append(new ServersPage(onesix.get())); + values.append(new ServersPage(onesix)); // values.append(new GameOptionsPage(onesix.get())); values.append(new ScreenshotsPage(FS::PathCombine(onesix->gameRoot(), "screenshots"))); values.append(new InstanceSettingsPage(onesix.get())); diff --git a/application/LaunchController.cpp b/application/LaunchController.cpp index bebc3db1..3c4491a3 100644 --- a/application/LaunchController.cpp +++ b/application/LaunchController.cpp @@ -197,7 +197,7 @@ void LaunchController::launchInstance() return; } - m_launcher = m_instance->createLaunchTask(m_session); + m_launcher = m_instance->createLaunchTask(m_session, m_serverToJoin); if (!m_launcher) { emitFailed(tr("Couldn't instantiate a launcher.")); diff --git a/application/LaunchController.h b/application/LaunchController.h index 1d879028..5f177e00 100644 --- a/application/LaunchController.h +++ b/application/LaunchController.h @@ -3,6 +3,8 @@ #include #include +#include "minecraft/launch/MinecraftServerTarget.h" + class InstanceWindow; class LaunchController: public Task { @@ -33,6 +35,10 @@ public: { m_parentWidget = widget; } + void setServerToJoin(MinecraftServerTargetPtr serverToJoin) + { + m_serverToJoin = std::move(serverToJoin); + } QString id() { return m_instance->id(); @@ -58,4 +64,5 @@ private: InstanceWindow *m_console = nullptr; AuthSessionPtr m_session; shared_qobject_ptr m_launcher; + MinecraftServerTargetPtr m_serverToJoin; }; diff --git a/application/MultiMC.cpp b/application/MultiMC.cpp index 3429a377..8a81238e 100644 --- a/application/MultiMC.cpp +++ b/application/MultiMC.cpp @@ -1014,8 +1014,12 @@ bool MultiMC::openJsonEditor(const QString &filename) } } -bool MultiMC::launch(InstancePtr instance, bool online, BaseProfilerFactory *profiler) -{ +bool MultiMC::launch( + InstancePtr instance, + bool online, + BaseProfilerFactory *profiler, + MinecraftServerTargetPtr serverToJoin +) { if(m_updateRunning) { qDebug() << "Cannot launch instances while an update is running. Please try again when updates are completed."; @@ -1036,6 +1040,7 @@ bool MultiMC::launch(InstancePtr instance, bool online, BaseProfilerFactory *pro controller->setInstance(instance); controller->setOnline(online); controller->setProfiler(profiler); + controller->setServerToJoin(serverToJoin); if(window) { controller->setParentWidget(window); diff --git a/application/MultiMC.h b/application/MultiMC.h index e6588a14..57a43cb9 100644 --- a/application/MultiMC.h +++ b/application/MultiMC.h @@ -11,6 +11,8 @@ #include +#include "minecraft/launch/MinecraftServerTarget.h" + class LaunchController; class LocalPeer; class InstanceWindow; @@ -150,7 +152,12 @@ signals: void globalSettingsClosed(); public slots: - bool launch(InstancePtr instance, bool online = true, BaseProfilerFactory *profiler = nullptr); + bool launch( + InstancePtr instance, + bool online = true, + BaseProfilerFactory *profiler = nullptr, + MinecraftServerTargetPtr serverToJoin = nullptr + ); bool kill(InstancePtr instance); private slots: diff --git a/application/pages/instance/InstanceSettingsPage.ui b/application/pages/instance/InstanceSettingsPage.ui index de9fa9e3..29024b65 100644 --- a/application/pages/instance/InstanceSettingsPage.ui +++ b/application/pages/instance/InstanceSettingsPage.ui @@ -39,7 +39,7 @@ QTabWidget::Rounded - 4 + 0 diff --git a/application/pages/instance/ServersPage.cpp b/application/pages/instance/ServersPage.cpp index 8b0c655c..d63c6e70 100644 --- a/application/pages/instance/ServersPage.cpp +++ b/application/pages/instance/ServersPage.cpp @@ -556,7 +556,7 @@ private: QTimer m_saveTimer; }; -ServersPage::ServersPage(MinecraftInstance * inst, QWidget* parent) +ServersPage::ServersPage(InstancePtr inst, QWidget* parent) : QMainWindow(parent), ui(new Ui::ServersPage) { ui->setupUi(this); @@ -579,7 +579,7 @@ ServersPage::ServersPage(MinecraftInstance * inst, QWidget* parent) auto selectionModel = ui->serversView->selectionModel(); connect(selectionModel, &QItemSelectionModel::currentChanged, this, &ServersPage::currentChanged); - connect(m_inst, &MinecraftInstance::runningStatusChanged, this, &ServersPage::on_RunningState_changed); + connect(m_inst.get(), &MinecraftInstance::runningStatusChanged, this, &ServersPage::on_RunningState_changed); connect(ui->nameLine, &QLineEdit::textEdited, this, &ServersPage::nameEdited); connect(ui->addressLine, &QLineEdit::textEdited, this, &ServersPage::addressEdited); connect(ui->resourceComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(resourceIndexChanged(int))); @@ -695,6 +695,7 @@ void ServersPage::updateState() ui->actionMove_Down->setEnabled(serverEditEnabled); ui->actionMove_Up->setEnabled(serverEditEnabled); ui->actionRemove->setEnabled(serverEditEnabled); + ui->actionJoin->setEnabled(serverEditEnabled); if(server) { @@ -758,4 +759,10 @@ void ServersPage::on_actionMove_Down_triggered() } } +void ServersPage::on_actionJoin_triggered() +{ + const auto &address = m_model->at(currentServer)->m_address; + MMC->launch(m_inst, true, nullptr, std::make_shared(MinecraftServerTarget::parse(address))); +} + #include "ServersPage.moc" diff --git a/application/pages/instance/ServersPage.h b/application/pages/instance/ServersPage.h index f164da1e..8c5b7eb8 100644 --- a/application/pages/instance/ServersPage.h +++ b/application/pages/instance/ServersPage.h @@ -35,7 +35,7 @@ class ServersPage : public QMainWindow, public BasePage Q_OBJECT public: - explicit ServersPage(MinecraftInstance *inst, QWidget *parent = 0); + explicit ServersPage(InstancePtr inst, QWidget *parent = 0); virtual ~ServersPage(); void openedImpl() override; @@ -74,6 +74,7 @@ private slots: void on_actionRemove_triggered(); void on_actionMove_Up_triggered(); void on_actionMove_Down_triggered(); + void on_actionJoin_triggered(); void on_RunningState_changed(bool running); @@ -88,6 +89,6 @@ private: // data bool m_locked = true; Ui::ServersPage *ui = nullptr; ServersModel * m_model = nullptr; - MinecraftInstance * m_inst = nullptr; + InstancePtr m_inst = nullptr; }; diff --git a/application/pages/instance/ServersPage.ui b/application/pages/instance/ServersPage.ui index e9518e35..d89b7cba 100644 --- a/application/pages/instance/ServersPage.ui +++ b/application/pages/instance/ServersPage.ui @@ -148,6 +148,7 @@ + @@ -169,6 +170,11 @@ Move Down + + + Join + + From 58ab005f7e22785a47402b17c54880c5b32292db Mon Sep 17 00:00:00 2001 From: Janrupf Date: Sat, 22 May 2021 18:10:17 +0200 Subject: [PATCH 22/57] NOISSUE Add missing license header --- api/logic/launch/steps/LookupServerAddress.cpp | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) diff --git a/api/logic/launch/steps/LookupServerAddress.cpp b/api/logic/launch/steps/LookupServerAddress.cpp index c6ca5bd5..de56c28a 100644 --- a/api/logic/launch/steps/LookupServerAddress.cpp +++ b/api/logic/launch/steps/LookupServerAddress.cpp @@ -1,3 +1,19 @@ +/* Copyright 2013-2021 MultiMC Contributors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + + #include "LookupServerAddress.h" #include From 52c1150522139f042903321387c6582a99e8ad9a Mon Sep 17 00:00:00 2001 From: Janrupf Date: Sun, 23 May 2021 14:42:20 +0200 Subject: [PATCH 23/57] NOISSUE Add --server argument for --launch --- application/MultiMC.cpp | 67 +++++++++++++++++++++++++++++++++++++++-- application/MultiMC.h | 1 + 2 files changed, 65 insertions(+), 3 deletions(-) diff --git a/application/MultiMC.cpp b/application/MultiMC.cpp index 8a81238e..2dd4f83f 100644 --- a/application/MultiMC.cpp +++ b/application/MultiMC.cpp @@ -191,6 +191,11 @@ MultiMC::MultiMC(int &argc, char **argv) : QApplication(argc, argv) parser.addOption("launch"); parser.addShortOpt("launch", 'l'); parser.addDocumentation("launch", "Launch the specified instance (by instance ID)"); + // --server + parser.addOption("server"); + parser.addShortOpt("server", 's'); + parser.addDocumentation("server", "Join the specified server on launch " + "(only valid in combination with --launch)"); // --alive parser.addSwitch("alive"); parser.addDocumentation("alive", "Write a small '" + liveCheckFile + "' file after MultiMC starts"); @@ -232,6 +237,7 @@ MultiMC::MultiMC(int &argc, char **argv) : QApplication(argc, argv) } } m_instanceIdToLaunch = args["launch"].toString(); + m_serverToJoin = args["server"].toString(); m_liveCheck = args["alive"].toBool(); m_zipToImport = args["import"].toUrl(); @@ -293,6 +299,13 @@ MultiMC::MultiMC(int &argc, char **argv) : QApplication(argc, argv) return; } + if(m_instanceIdToLaunch.isEmpty() && !m_serverToJoin.isEmpty()) + { + std::cerr << "--server can only be used in combination with --launch!" << std::endl; + m_status = MultiMC::Failed; + return; + } + /* * Establish the mechanism for communication with an already running MultiMC that uses the same data path. * If there is one, tell it what the user actually wanted to do and exit. @@ -318,7 +331,15 @@ MultiMC::MultiMC(int &argc, char **argv) : QApplication(argc, argv) } else { - m_peerInstance->sendMessage("launch " + m_instanceIdToLaunch, timeout); + if(!m_serverToJoin.isEmpty()) + { + m_peerInstance->sendMessage( + "launch-with-server " + m_instanceIdToLaunch + " " + m_serverToJoin, timeout); + } + else + { + m_peerInstance->sendMessage("launch " + m_instanceIdToLaunch, timeout); + } } m_status = MultiMC::Succeeded; return; @@ -399,6 +420,10 @@ MultiMC::MultiMC(int &argc, char **argv) : QApplication(argc, argv) { qDebug() << "ID of instance to launch : " << m_instanceIdToLaunch; } + if(!m_serverToJoin.isEmpty()) + { + qDebug() << "Address of server to join :" << m_serverToJoin; + } qDebug() << "<> Paths set."; } @@ -844,8 +869,19 @@ void MultiMC::performMainStartupAction() auto inst = instances()->getInstanceById(m_instanceIdToLaunch); if(inst) { - qDebug() << "<> Instance launching:" << m_instanceIdToLaunch; - launch(inst, true, nullptr); + MinecraftServerTargetPtr serverToJoin = nullptr; + + if(!m_serverToJoin.isEmpty()) + { + serverToJoin.reset(new MinecraftServerTarget(MinecraftServerTarget::parse(m_serverToJoin))); + qDebug() << "<> Instance" << m_instanceIdToLaunch << "launching with server" << m_serverToJoin; + } + else + { + qDebug() << "<> Instance" << m_instanceIdToLaunch << "launching"; + } + + launch(inst, true, nullptr, serverToJoin); return; } } @@ -927,6 +963,31 @@ void MultiMC::messageReceived(const QString& message) launch(inst, true, nullptr); } } + else if(command == "launch-with-server") + { + QString instanceID = message.section(' ', 1, 1); + QString serverToJoin = message.section(' ', 2, 2); + if(instanceID.isEmpty()) + { + qWarning() << "Received" << command << "message without an instance ID."; + return; + } + if(serverToJoin.isEmpty()) + { + qWarning() << "Received" << command << "message without a server to join."; + return; + } + auto inst = instances()->getInstanceById(instanceID); + if(inst) + { + launch( + inst, + true, + nullptr, + std::make_shared(MinecraftServerTarget::parse(serverToJoin)) + ); + } + } else { qWarning() << "Received invalid message" << message; diff --git a/application/MultiMC.h b/application/MultiMC.h index 57a43cb9..af2b41c1 100644 --- a/application/MultiMC.h +++ b/application/MultiMC.h @@ -228,6 +228,7 @@ private: SetupWizard * m_setupWizard = nullptr; public: QString m_instanceIdToLaunch; + QString m_serverToJoin; bool m_liveCheck = false; QUrl m_zipToImport; std::unique_ptr logFile; From efa3bb33f52f811727819132b526cfb75558a4cd Mon Sep 17 00:00:00 2001 From: Jamie Mansfield Date: Thu, 3 Jun 2021 15:03:19 +0100 Subject: [PATCH 24/57] NOISSUE Disable 'Install Forge' button when game is running --- application/pages/instance/VersionPage.cpp | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/application/pages/instance/VersionPage.cpp b/application/pages/instance/VersionPage.cpp index 54d75d06..7f7ba860 100644 --- a/application/pages/instance/VersionPage.cpp +++ b/application/pages/instance/VersionPage.cpp @@ -203,11 +203,11 @@ void VersionPage::updateVersionControls() { // FIXME: this is a dirty hack auto minecraftVersion = Version(m_profile->getComponentVersion("net.minecraft")); - bool newCraft = controlsEnabled && (minecraftVersion >= Version("1.14")); - bool oldCraft = controlsEnabled && (minecraftVersion <= Version("1.12.2")); - ui->actionInstall_Fabric->setEnabled(newCraft); - ui->actionInstall_Forge->setEnabled(true); - ui->actionInstall_LiteLoader->setEnabled(oldCraft); + bool newCraft = minecraftVersion >= Version("1.14"); + bool oldCraft = minecraftVersion <= Version("1.12.2"); + ui->actionInstall_Fabric->setEnabled(controlsEnabled && newCraft); + ui->actionInstall_Forge->setEnabled(controlsEnabled); + ui->actionInstall_LiteLoader->setEnabled(controlsEnabled && oldCraft); ui->actionReload->setEnabled(true); updateButtons(); } From 6dd1fdbaf96ebd4845d1596c06dc37099e7b4caa Mon Sep 17 00:00:00 2001 From: Jamie Mansfield Date: Thu, 3 Jun 2021 15:16:03 +0100 Subject: [PATCH 25/57] NOISSUE Fail pack installation for download errors for FTB This effectively reverts the changes made in [1] to resolve GH-3304. [1] 05ffcf706bff92bdc48f3063d6a64508f8b7674c --- api/logic/modplatform/modpacksch/FTBPackInstallTask.cpp | 7 +------ 1 file changed, 1 insertion(+), 6 deletions(-) diff --git a/api/logic/modplatform/modpacksch/FTBPackInstallTask.cpp b/api/logic/modplatform/modpacksch/FTBPackInstallTask.cpp index 068e3592..ddc7fe35 100644 --- a/api/logic/modplatform/modpacksch/FTBPackInstallTask.cpp +++ b/api/logic/modplatform/modpacksch/FTBPackInstallTask.cpp @@ -109,12 +109,7 @@ void PackInstallTask::downloadPack() connect(jobPtr.get(), &NetJob::failed, [&](QString reason) { jobPtr.reset(); - - // FIXME: Temporarily ignore file download failures (matching FTB's installer), - // while FTB's data is fucked. - qWarning() << "Failed to download files for modpack: " + reason; - - install(); + emitFailed(reason); }); connect(jobPtr.get(), &NetJob::progress, [&](qint64 current, qint64 total) { From 3390367d931cc47a8c9980d456546326d5c5e2cd Mon Sep 17 00:00:00 2001 From: Jamie Mansfield Date: Wed, 9 Jun 2021 20:48:46 +0100 Subject: [PATCH 26/57] NOISSUE Support CurseForge modpacks using Fabric Loader --- api/logic/InstanceImportTask.cpp | 11 +++++++++++ 1 file changed, 11 insertions(+) diff --git a/api/logic/InstanceImportTask.cpp b/api/logic/InstanceImportTask.cpp index fe2cdd75..3eac4d57 100644 --- a/api/logic/InstanceImportTask.cpp +++ b/api/logic/InstanceImportTask.cpp @@ -238,6 +238,7 @@ void InstanceImportTask::processFlame() } QString forgeVersion; + QString fabricVersion; for(auto &loader: pack.minecraft.modLoaders) { auto id = loader.id; @@ -247,6 +248,12 @@ void InstanceImportTask::processFlame() forgeVersion = id; continue; } + if(id.startsWith("fabric-")) + { + id.remove("fabric-"); + fabricVersion = id; + continue; + } logWarning(tr("Unknown mod loader in manifest: %1").arg(id)); } @@ -281,6 +288,10 @@ void InstanceImportTask::processFlame() } components->setComponentVersion("net.minecraftforge", forgeVersion); } + if(!fabricVersion.isEmpty()) + { + components->setComponentVersion("net.fabricmc.fabric-loader", fabricVersion); + } if (m_instIcon != "default") { instance.setIconKey(m_instIcon); From 40f41e5fbea137c758ea688d53d66844e933a1f4 Mon Sep 17 00:00:00 2001 From: Jamie Mansfield Date: Fri, 18 Jun 2021 12:24:20 +0100 Subject: [PATCH 27/57] NOISSUE Specify support URLs at build time Support URLs (bug tracker, Discord guild, subreddit) are now specified as cache variables in cmake, and the buttons are not shown if no value is set for them. This is an early-stage move towards debranding the MultiMC codebase, and will (hopefully) alleviate support requests coming to us from illicit forks. --- CMakeLists.txt | 9 ++++++ application/MainWindow.cpp | 54 +++++++++++++++++++--------------- buildconfig/BuildConfig.cpp.in | 4 +++ buildconfig/BuildConfig.h | 4 +++ 4 files changed, 47 insertions(+), 24 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 4ea92f68..bcf931c0 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -78,6 +78,15 @@ set(MultiMC_PASTE_EE_API_KEY "utLvciUouSURFzfjPxLBf5W4ISsUX4pwBDF7N1AfZ" CACHE S # Google analytics ID set(MultiMC_ANALYTICS_ID "UA-87731965-2" CACHE STRING "ID you can get from Google analytics") +# Bug tracker URL +set(MultiMC_BUG_TRACKER_URL "" CACHE STRING "URL for the bug tracker.") + +# Discord URL +set(MultiMC_DISCORD_URL "" CACHE STRING "URL for the Discord guild.") + +# Subreddit URL +set(MultiMC_SUBREDDIT_URL "" CACHE STRING "URL for the subreddit.") + #### Check the current Git commit and branch include(GetGitRevisionDescription) get_git_head_revision(MultiMC_GIT_REFSPEC MultiMC_GIT_COMMIT) diff --git a/application/MainWindow.cpp b/application/MainWindow.cpp index 1286007d..9d046ddb 100644 --- a/application/MainWindow.cpp +++ b/application/MainWindow.cpp @@ -306,29 +306,35 @@ public: helpMenu = new QMenu(MainWindow); helpMenu->setToolTipsVisible(true); - actionReportBug = TranslatedAction(MainWindow); - actionReportBug->setObjectName(QStringLiteral("actionReportBug")); - actionReportBug->setIcon(MMC->getThemedIcon("bug")); - actionReportBug.setTextId(QT_TRANSLATE_NOOP("MainWindow", "Report a Bug")); - actionReportBug.setTooltipId(QT_TRANSLATE_NOOP("MainWindow", "Open the bug tracker to report a bug with MultiMC.")); - all_actions.append(&actionReportBug); - helpMenu->addAction(actionReportBug); + if (!BuildConfig.BUG_TRACKER_URL.isEmpty()) { + actionReportBug = TranslatedAction(MainWindow); + actionReportBug->setObjectName(QStringLiteral("actionReportBug")); + actionReportBug->setIcon(MMC->getThemedIcon("bug")); + actionReportBug.setTextId(QT_TRANSLATE_NOOP("MainWindow", "Report a Bug")); + actionReportBug.setTooltipId(QT_TRANSLATE_NOOP("MainWindow", "Open the bug tracker to report a bug with MultiMC.")); + all_actions.append(&actionReportBug); + helpMenu->addAction(actionReportBug); + } - actionDISCORD = TranslatedAction(MainWindow); - actionDISCORD->setObjectName(QStringLiteral("actionDISCORD")); - actionDISCORD->setIcon(MMC->getThemedIcon("discord")); - actionDISCORD.setTextId(QT_TRANSLATE_NOOP("MainWindow", "Discord")); - actionDISCORD.setTooltipId(QT_TRANSLATE_NOOP("MainWindow", "Open MultiMC discord voice chat.")); - all_actions.append(&actionDISCORD); - helpMenu->addAction(actionDISCORD); + if (!BuildConfig.DISCORD_URL.isEmpty()) { + actionDISCORD = TranslatedAction(MainWindow); + actionDISCORD->setObjectName(QStringLiteral("actionDISCORD")); + actionDISCORD->setIcon(MMC->getThemedIcon("discord")); + actionDISCORD.setTextId(QT_TRANSLATE_NOOP("MainWindow", "Discord")); + actionDISCORD.setTooltipId(QT_TRANSLATE_NOOP("MainWindow", "Open MultiMC discord voice chat.")); + all_actions.append(&actionDISCORD); + helpMenu->addAction(actionDISCORD); + } - actionREDDIT = TranslatedAction(MainWindow); - actionREDDIT->setObjectName(QStringLiteral("actionREDDIT")); - actionREDDIT->setIcon(MMC->getThemedIcon("reddit-alien")); - actionREDDIT.setTextId(QT_TRANSLATE_NOOP("MainWindow", "Reddit")); - actionREDDIT.setTooltipId(QT_TRANSLATE_NOOP("MainWindow", "Open MultiMC subreddit.")); - all_actions.append(&actionREDDIT); - helpMenu->addAction(actionREDDIT); + if (!BuildConfig.SUBREDDIT_URL.isEmpty()) { + actionREDDIT = TranslatedAction(MainWindow); + actionREDDIT->setObjectName(QStringLiteral("actionREDDIT")); + actionREDDIT->setIcon(MMC->getThemedIcon("reddit-alien")); + actionREDDIT.setTextId(QT_TRANSLATE_NOOP("MainWindow", "Reddit")); + actionREDDIT.setTooltipId(QT_TRANSLATE_NOOP("MainWindow", "Open MultiMC subreddit.")); + all_actions.append(&actionREDDIT); + helpMenu->addAction(actionREDDIT); + } actionAbout = TranslatedAction(MainWindow); actionAbout->setObjectName(QStringLiteral("actionAbout")); @@ -1455,12 +1461,12 @@ void MainWindow::droppedURLs(QList urls) void MainWindow::on_actionREDDIT_triggered() { - DesktopServices::openUrl(QUrl("https://www.reddit.com/r/MultiMC/")); + DesktopServices::openUrl(QUrl(BuildConfig.SUBREDDIT_URL)); } void MainWindow::on_actionDISCORD_triggered() { - DesktopServices::openUrl(QUrl("https://discord.gg/multimc")); + DesktopServices::openUrl(QUrl(BuildConfig.DISCORD_URL)); } void MainWindow::on_actionChangeInstIcon_triggered() @@ -1638,7 +1644,7 @@ void MainWindow::on_actionManageAccounts_triggered() void MainWindow::on_actionReportBug_triggered() { - DesktopServices::openUrl(QUrl("https://github.com/MultiMC/MultiMC5/issues")); + DesktopServices::openUrl(QUrl(BuildConfig.BUG_TRACKER_URL)); } void MainWindow::on_actionPatreon_triggered() diff --git a/buildconfig/BuildConfig.cpp.in b/buildconfig/BuildConfig.cpp.in index 86ea83ee..577bdcb2 100644 --- a/buildconfig/BuildConfig.cpp.in +++ b/buildconfig/BuildConfig.cpp.in @@ -34,6 +34,10 @@ Config::Config() NEWS_RSS_URL = "@MultiMC_NEWS_RSS_URL@"; PASTE_EE_KEY = "@MultiMC_PASTE_EE_API_KEY@"; META_URL = "@MultiMC_META_URL@"; + + BUG_TRACKER_URL = "@MultiMC_BUG_TRACKER_URL@"; + DISCORD_URL = "@MultiMC_DISCORD_URL@"; + SUBREDDIT_URL = "@MultiMC_SUBREDDIT_URL@"; } QString Config::printableVersionString() const diff --git a/buildconfig/BuildConfig.h b/buildconfig/BuildConfig.h index 9feb7786..66d05ae0 100644 --- a/buildconfig/BuildConfig.h +++ b/buildconfig/BuildConfig.h @@ -65,6 +65,10 @@ public: */ QString META_URL; + QString BUG_TRACKER_URL; + QString DISCORD_URL; + QString SUBREDDIT_URL; + QString RESOURCE_BASE = "https://resources.download.minecraft.net/"; QString LIBRARY_BASE = "https://libraries.minecraft.net/"; QString SKINS_BASE = "https://crafatar.com/skins/"; From fd04ff2b08cbc214c8c97cd3c4b2995221089424 Mon Sep 17 00:00:00 2001 From: phit <2097483+phit@users.noreply.github.com> Date: Tue, 8 Jun 2021 19:48:12 +0200 Subject: [PATCH 28/57] NOISSUE Add AdoptOpenJDK Java detection --- api/logic/java/JavaUtils.cpp | 109 ++++++++++++++++++++++++++++++----- api/logic/java/JavaUtils.h | 3 +- 2 files changed, 98 insertions(+), 14 deletions(-) diff --git a/api/logic/java/JavaUtils.cpp b/api/logic/java/JavaUtils.cpp index 18a731ca..ec87e7bf 100644 --- a/api/logic/java/JavaUtils.cpp +++ b/api/logic/java/JavaUtils.cpp @@ -150,7 +150,7 @@ JavaInstallPtr JavaUtils::GetDefaultJava() } #if defined(Q_OS_WIN32) -QList JavaUtils::FindJavaFromRegistryKey(DWORD keyType, QString keyName) +QList JavaUtils::FindOracleJavaFromRegistryKey(DWORD keyType, QString keyName) { QList javas; @@ -175,8 +175,6 @@ QList JavaUtils::FindJavaFromRegistryKey(DWORD keyType, QString RegQueryValueExA(jreKey, "CurrentVersion", NULL, NULL, (BYTE *)value, &valueSz); } - QString recommended = value; - TCHAR subKeyName[255]; DWORD subKeyNameSize, numSubKeys, retCode; @@ -233,41 +231,126 @@ QList JavaUtils::FindJavaFromRegistryKey(DWORD keyType, QString return javas; } +QList JavaUtils::FindAdoptJavaFromRegistryKey(DWORD keyType, QString keyName) +{ + QList javas; + + QString archType = "unknown"; + if (keyType == KEY_WOW64_64KEY) + archType = "64"; + else if (keyType == KEY_WOW64_32KEY) + archType = "32"; + + HKEY jreKey; + if (RegOpenKeyExA(HKEY_LOCAL_MACHINE, keyName.toStdString().c_str(), 0, KEY_READ | keyType | KEY_ENUMERATE_SUB_KEYS, &jreKey) == ERROR_SUCCESS) + { + char *value = new char[0]; + DWORD valueSz = 0; + TCHAR subKeyName[255]; + DWORD subKeyNameSize, numSubKeys, retCode; + + // Get the number of subkeys + RegQueryInfoKey(jreKey, NULL, NULL, NULL, &numSubKeys, NULL, NULL, NULL, NULL, NULL, NULL, NULL); + + // Iterate until RegEnumKeyEx fails + if (numSubKeys > 0) + { + for (DWORD i = 0; i < numSubKeys; i++) + { + subKeyNameSize = 255; + retCode = RegEnumKeyEx(jreKey, i, subKeyName, &subKeyNameSize, NULL, NULL, NULL, NULL); + if (retCode == ERROR_SUCCESS) + { + // Now open the registry key for the version that we just got. + QString newKeyName = keyName + "\\" + subKeyName + "\\hotspot\\MSI"; + + HKEY newKey; + if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, newKeyName.toStdString().c_str(), 0, KEY_READ | KEY_WOW64_64KEY, &newKey) == ERROR_SUCCESS) + { + // Read the Path value to find where Java is installed. + value = new char[0]; + valueSz = 0; + if (RegQueryValueEx(newKey, "Path", NULL, NULL, (BYTE *)value, &valueSz) == ERROR_MORE_DATA) + { + value = new char[valueSz]; + RegQueryValueEx(newKey, "Path", NULL, NULL, (BYTE *)value, &valueSz); + + // Now, we construct the version object and add it to the list. + JavaInstallPtr javaVersion(new JavaInstall()); + + javaVersion->id = subKeyName; + javaVersion->arch = archType; + javaVersion->path = QDir(FS::PathCombine(value, "bin")).absoluteFilePath("javaw.exe"); + javas.append(javaVersion); + } + + RegCloseKey(newKey); + } + } + } + } + + RegCloseKey(jreKey); + } + + return javas; +} + QList JavaUtils::FindJavaPaths() { QList java_candidates; - QList JRE64s = this->FindJavaFromRegistryKey( + // Oracle + QList JRE64s = this->FindOracleJavaFromRegistryKey( KEY_WOW64_64KEY, "SOFTWARE\\JavaSoft\\Java Runtime Environment"); - QList JDK64s = this->FindJavaFromRegistryKey( + QList JDK64s = this->FindOracleJavaFromRegistryKey( KEY_WOW64_64KEY, "SOFTWARE\\JavaSoft\\Java Development Kit"); - QList NEWJRE64s = this->FindJavaFromRegistryKey( - KEY_WOW64_64KEY, "SOFTWARE\\JavaSoft\\JRE"); - QList NEWJDK64s = this->FindJavaFromRegistryKey( - KEY_WOW64_64KEY, "SOFTWARE\\JavaSoft\\JDK"); - QList JRE32s = this->FindJavaFromRegistryKey( + QList JRE32s = this->FindOracleJavaFromRegistryKey( KEY_WOW64_32KEY, "SOFTWARE\\JavaSoft\\Java Runtime Environment"); - QList JDK32s = this->FindJavaFromRegistryKey( + QList JDK32s = this->FindOracleJavaFromRegistryKey( KEY_WOW64_32KEY, "SOFTWARE\\JavaSoft\\Java Development Kit"); - QList NEWJRE32s = this->FindJavaFromRegistryKey( + + // Oracle for Java 9 and newer + QList NEWJRE64s = this->FindOracleJavaFromRegistryKey( + KEY_WOW64_64KEY, "SOFTWARE\\JavaSoft\\JRE"); + QList NEWJDK64s = this->FindOracleJavaFromRegistryKey( + KEY_WOW64_64KEY, "SOFTWARE\\JavaSoft\\JDK"); + QList NEWJRE32s = this->FindOracleJavaFromRegistryKey( KEY_WOW64_32KEY, "SOFTWARE\\JavaSoft\\JRE"); - QList NEWJDK32s = this->FindJavaFromRegistryKey( + QList NEWJDK32s = this->FindOracleJavaFromRegistryKey( KEY_WOW64_32KEY, "SOFTWARE\\JavaSoft\\JDK"); + // AdoptOpenJDK + QList ADOPTOPENJRE32s = this->FindAdoptJavaFromRegistryKey( + KEY_WOW64_32KEY, "SOFTWARE\\AdoptOpenJDK\\JRE"); + QList ADOPTOPENJRE64s = this->FindAdoptJavaFromRegistryKey( + KEY_WOW64_64KEY, "SOFTWARE\\AdoptOpenJDK\\JRE"); + QList ADOPTOPENJDK32s = this->FindAdoptJavaFromRegistryKey( + KEY_WOW64_32KEY, "SOFTWARE\\AdoptOpenJDK\\JDK"); + QList ADOPTOPENJDK64s = this->FindAdoptJavaFromRegistryKey( + KEY_WOW64_64KEY, "SOFTWARE\\AdoptOpenJDK\\JDK"); + + // List x64 before x86 java_candidates.append(JRE64s); java_candidates.append(NEWJRE64s); + java_candidates.append(ADOPTOPENJRE64s); java_candidates.append(MakeJavaPtr("C:/Program Files/Java/jre8/bin/javaw.exe")); java_candidates.append(MakeJavaPtr("C:/Program Files/Java/jre7/bin/javaw.exe")); java_candidates.append(MakeJavaPtr("C:/Program Files/Java/jre6/bin/javaw.exe")); java_candidates.append(JDK64s); java_candidates.append(NEWJDK64s); + java_candidates.append(ADOPTOPENJDK64s); + java_candidates.append(JRE32s); java_candidates.append(NEWJRE32s); + java_candidates.append(ADOPTOPENJRE32s); java_candidates.append(MakeJavaPtr("C:/Program Files (x86)/Java/jre8/bin/javaw.exe")); java_candidates.append(MakeJavaPtr("C:/Program Files (x86)/Java/jre7/bin/javaw.exe")); java_candidates.append(MakeJavaPtr("C:/Program Files (x86)/Java/jre6/bin/javaw.exe")); java_candidates.append(JDK32s); java_candidates.append(NEWJDK32s); + java_candidates.append(ADOPTOPENJDK32s); + java_candidates.append(MakeJavaPtr(this->GetDefaultJava()->path)); QList candidates; diff --git a/api/logic/java/JavaUtils.h b/api/logic/java/JavaUtils.h index 7474c494..9becd9e4 100644 --- a/api/logic/java/JavaUtils.h +++ b/api/logic/java/JavaUtils.h @@ -39,6 +39,7 @@ public: JavaInstallPtr GetDefaultJava(); #ifdef Q_OS_WIN - QList FindJavaFromRegistryKey(DWORD keyType, QString keyName); + QList FindOracleJavaFromRegistryKey(DWORD keyType, QString keyName); + QList FindAdoptJavaFromRegistryKey(DWORD keyType, QString keyName); #endif }; From 7ac6c4f3d9f55d4be86c96d0e52001e7ecc5448b Mon Sep 17 00:00:00 2001 From: phit <2097483+phit@users.noreply.github.com> Date: Fri, 18 Jun 2021 17:02:41 +0200 Subject: [PATCH 29/57] NOISSUE Cleanup duplication and Microsoft JDK --- api/logic/java/JavaUtils.cpp | 126 +++++++++-------------------------- api/logic/java/JavaUtils.h | 3 +- 2 files changed, 34 insertions(+), 95 deletions(-) diff --git a/api/logic/java/JavaUtils.cpp b/api/logic/java/JavaUtils.cpp index ec87e7bf..10ffa018 100644 --- a/api/logic/java/JavaUtils.cpp +++ b/api/logic/java/JavaUtils.cpp @@ -150,7 +150,7 @@ JavaInstallPtr JavaUtils::GetDefaultJava() } #if defined(Q_OS_WIN32) -QList JavaUtils::FindOracleJavaFromRegistryKey(DWORD keyType, QString keyName) +QList JavaUtils::FindJavaFromRegistryKey(DWORD keyType, QString keyName, QString keyJavaDir, QString subkeySuffix) { QList javas; @@ -193,7 +193,7 @@ QList JavaUtils::FindOracleJavaFromRegistryKey(DWORD keyType, QS if (retCode == ERROR_SUCCESS) { // Now open the registry key for the version that we just got. - QString newKeyName = keyName + "\\" + subKeyName; + QString newKeyName = keyName + "\\" + subKeyName + subkeySuffix; HKEY newKey; if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, newKeyName.toStdString().c_str(), 0, @@ -202,11 +202,11 @@ QList JavaUtils::FindOracleJavaFromRegistryKey(DWORD keyType, QS // Read the JavaHome value to find where Java is installed. value = new char[0]; valueSz = 0; - if (RegQueryValueEx(newKey, "JavaHome", NULL, NULL, (BYTE *)value, + if (RegQueryValueEx(newKey, keyJavaDir.toStdString().c_str(), NULL, NULL, (BYTE *)value, &valueSz) == ERROR_MORE_DATA) { value = new char[valueSz]; - RegQueryValueEx(newKey, "JavaHome", NULL, NULL, (BYTE *)value, + RegQueryValueEx(newKey, keyJavaDir.toStdString().c_str(), NULL, NULL, (BYTE *)value, &valueSz); // Now, we construct the version object and add it to the list. @@ -231,104 +231,43 @@ QList JavaUtils::FindOracleJavaFromRegistryKey(DWORD keyType, QS return javas; } -QList JavaUtils::FindAdoptJavaFromRegistryKey(DWORD keyType, QString keyName) -{ - QList javas; - - QString archType = "unknown"; - if (keyType == KEY_WOW64_64KEY) - archType = "64"; - else if (keyType == KEY_WOW64_32KEY) - archType = "32"; - - HKEY jreKey; - if (RegOpenKeyExA(HKEY_LOCAL_MACHINE, keyName.toStdString().c_str(), 0, KEY_READ | keyType | KEY_ENUMERATE_SUB_KEYS, &jreKey) == ERROR_SUCCESS) - { - char *value = new char[0]; - DWORD valueSz = 0; - TCHAR subKeyName[255]; - DWORD subKeyNameSize, numSubKeys, retCode; - - // Get the number of subkeys - RegQueryInfoKey(jreKey, NULL, NULL, NULL, &numSubKeys, NULL, NULL, NULL, NULL, NULL, NULL, NULL); - - // Iterate until RegEnumKeyEx fails - if (numSubKeys > 0) - { - for (DWORD i = 0; i < numSubKeys; i++) - { - subKeyNameSize = 255; - retCode = RegEnumKeyEx(jreKey, i, subKeyName, &subKeyNameSize, NULL, NULL, NULL, NULL); - if (retCode == ERROR_SUCCESS) - { - // Now open the registry key for the version that we just got. - QString newKeyName = keyName + "\\" + subKeyName + "\\hotspot\\MSI"; - - HKEY newKey; - if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, newKeyName.toStdString().c_str(), 0, KEY_READ | KEY_WOW64_64KEY, &newKey) == ERROR_SUCCESS) - { - // Read the Path value to find where Java is installed. - value = new char[0]; - valueSz = 0; - if (RegQueryValueEx(newKey, "Path", NULL, NULL, (BYTE *)value, &valueSz) == ERROR_MORE_DATA) - { - value = new char[valueSz]; - RegQueryValueEx(newKey, "Path", NULL, NULL, (BYTE *)value, &valueSz); - - // Now, we construct the version object and add it to the list. - JavaInstallPtr javaVersion(new JavaInstall()); - - javaVersion->id = subKeyName; - javaVersion->arch = archType; - javaVersion->path = QDir(FS::PathCombine(value, "bin")).absoluteFilePath("javaw.exe"); - javas.append(javaVersion); - } - - RegCloseKey(newKey); - } - } - } - } - - RegCloseKey(jreKey); - } - - return javas; -} - QList JavaUtils::FindJavaPaths() { QList java_candidates; // Oracle - QList JRE64s = this->FindOracleJavaFromRegistryKey( - KEY_WOW64_64KEY, "SOFTWARE\\JavaSoft\\Java Runtime Environment"); - QList JDK64s = this->FindOracleJavaFromRegistryKey( - KEY_WOW64_64KEY, "SOFTWARE\\JavaSoft\\Java Development Kit"); - QList JRE32s = this->FindOracleJavaFromRegistryKey( - KEY_WOW64_32KEY, "SOFTWARE\\JavaSoft\\Java Runtime Environment"); - QList JDK32s = this->FindOracleJavaFromRegistryKey( - KEY_WOW64_32KEY, "SOFTWARE\\JavaSoft\\Java Development Kit"); + QList JRE64s = this->FindJavaFromRegistryKey( + KEY_WOW64_64KEY, "SOFTWARE\\JavaSoft\\Java Runtime Environment", "JavaHome"); + QList JDK64s = this->FindJavaFromRegistryKey( + KEY_WOW64_64KEY, "SOFTWARE\\JavaSoft\\Java Development Kit", "JavaHome"); + QList JRE32s = this->FindJavaFromRegistryKey( + KEY_WOW64_32KEY, "SOFTWARE\\JavaSoft\\Java Runtime Environment", "JavaHome"); + QList JDK32s = this->FindJavaFromRegistryKey( + KEY_WOW64_32KEY, "SOFTWARE\\JavaSoft\\Java Development Kit", "JavaHome"); // Oracle for Java 9 and newer - QList NEWJRE64s = this->FindOracleJavaFromRegistryKey( - KEY_WOW64_64KEY, "SOFTWARE\\JavaSoft\\JRE"); - QList NEWJDK64s = this->FindOracleJavaFromRegistryKey( - KEY_WOW64_64KEY, "SOFTWARE\\JavaSoft\\JDK"); - QList NEWJRE32s = this->FindOracleJavaFromRegistryKey( - KEY_WOW64_32KEY, "SOFTWARE\\JavaSoft\\JRE"); - QList NEWJDK32s = this->FindOracleJavaFromRegistryKey( - KEY_WOW64_32KEY, "SOFTWARE\\JavaSoft\\JDK"); + QList NEWJRE64s = this->FindJavaFromRegistryKey( + KEY_WOW64_64KEY, "SOFTWARE\\JavaSoft\\JRE", "JavaHome"); + QList NEWJDK64s = this->FindJavaFromRegistryKey( + KEY_WOW64_64KEY, "SOFTWARE\\JavaSoft\\JDK", "JavaHome"); + QList NEWJRE32s = this->FindJavaFromRegistryKey( + KEY_WOW64_32KEY, "SOFTWARE\\JavaSoft\\JRE", "JavaHome"); + QList NEWJDK32s = this->FindJavaFromRegistryKey( + KEY_WOW64_32KEY, "SOFTWARE\\JavaSoft\\JDK", "JavaHome"); // AdoptOpenJDK - QList ADOPTOPENJRE32s = this->FindAdoptJavaFromRegistryKey( - KEY_WOW64_32KEY, "SOFTWARE\\AdoptOpenJDK\\JRE"); - QList ADOPTOPENJRE64s = this->FindAdoptJavaFromRegistryKey( - KEY_WOW64_64KEY, "SOFTWARE\\AdoptOpenJDK\\JRE"); - QList ADOPTOPENJDK32s = this->FindAdoptJavaFromRegistryKey( - KEY_WOW64_32KEY, "SOFTWARE\\AdoptOpenJDK\\JDK"); - QList ADOPTOPENJDK64s = this->FindAdoptJavaFromRegistryKey( - KEY_WOW64_64KEY, "SOFTWARE\\AdoptOpenJDK\\JDK"); + QList ADOPTOPENJRE32s = this->FindJavaFromRegistryKey( + KEY_WOW64_32KEY, "SOFTWARE\\AdoptOpenJDK\\JRE", "Path", "\\hotspot\\MSI"); + QList ADOPTOPENJRE64s = this->FindJavaFromRegistryKey( + KEY_WOW64_64KEY, "SOFTWARE\\AdoptOpenJDK\\JRE", "Path", "\\hotspot\\MSI"); + QList ADOPTOPENJDK32s = this->FindJavaFromRegistryKey( + KEY_WOW64_32KEY, "SOFTWARE\\AdoptOpenJDK\\JDK", "Path", "\\hotspot\\MSI"); + QList ADOPTOPENJDK64s = this->FindJavaFromRegistryKey( + KEY_WOW64_64KEY, "SOFTWARE\\AdoptOpenJDK\\JDK", "Path", "\\hotspot\\MSI"); + + // Microsoft + QList MICROSOFTJDK64s = this->FindJavaFromRegistryKey( + KEY_WOW64_64KEY, "SOFTWARE\\Microsoft\\JDK", "Path", "\\hotspot\\MSI"); // List x64 before x86 java_candidates.append(JRE64s); @@ -340,6 +279,7 @@ QList JavaUtils::FindJavaPaths() java_candidates.append(JDK64s); java_candidates.append(NEWJDK64s); java_candidates.append(ADOPTOPENJDK64s); + java_candidates.append(MICROSOFTJDK64s); java_candidates.append(JRE32s); java_candidates.append(NEWJRE32s); diff --git a/api/logic/java/JavaUtils.h b/api/logic/java/JavaUtils.h index 9becd9e4..206acf89 100644 --- a/api/logic/java/JavaUtils.h +++ b/api/logic/java/JavaUtils.h @@ -39,7 +39,6 @@ public: JavaInstallPtr GetDefaultJava(); #ifdef Q_OS_WIN - QList FindOracleJavaFromRegistryKey(DWORD keyType, QString keyName); - QList FindAdoptJavaFromRegistryKey(DWORD keyType, QString keyName); + QList FindJavaFromRegistryKey(DWORD keyType, QString keyName, QString keyJavaDir, QString subkeySuffix = ""); #endif }; From c2c288a95657b8aa4e0fb56167e9cc4e6551916f Mon Sep 17 00:00:00 2001 From: phit <2097483+phit@users.noreply.github.com> Date: Fri, 18 Jun 2021 17:12:44 +0200 Subject: [PATCH 30/57] NOISSUE Add BellSoft and Azul Java --- api/logic/java/JavaUtils.cpp | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) diff --git a/api/logic/java/JavaUtils.cpp b/api/logic/java/JavaUtils.cpp index 10ffa018..5f004a10 100644 --- a/api/logic/java/JavaUtils.cpp +++ b/api/logic/java/JavaUtils.cpp @@ -269,6 +269,18 @@ QList JavaUtils::FindJavaPaths() QList MICROSOFTJDK64s = this->FindJavaFromRegistryKey( KEY_WOW64_64KEY, "SOFTWARE\\Microsoft\\JDK", "Path", "\\hotspot\\MSI"); + // Azul Zulu + QList ZULU64s = this->FindJavaFromRegistryKey( + KEY_WOW64_64KEY, "SOFTWARE\\Azul Systems\\Zulu", "InstallationPath"); + QList ZULU32s = this->FindJavaFromRegistryKey( + KEY_WOW64_64KEY, "SOFTWARE\\Azul Systems\\Zulu", "InstallationPath"); + + // BellSoft Liberica + QList LIBERICA64s = this->FindJavaFromRegistryKey( + KEY_WOW64_64KEY, "SOFTWARE\\BellSoft\\Liberica", "InstallationPath"); + QList LIBERICA32s = this->FindJavaFromRegistryKey( + KEY_WOW64_64KEY, "SOFTWARE\\BellSoft\\Liberica", "InstallationPath"); + // List x64 before x86 java_candidates.append(JRE64s); java_candidates.append(NEWJRE64s); @@ -280,6 +292,8 @@ QList JavaUtils::FindJavaPaths() java_candidates.append(NEWJDK64s); java_candidates.append(ADOPTOPENJDK64s); java_candidates.append(MICROSOFTJDK64s); + java_candidates.append(ZULU64s); + java_candidates.append(LIBERICA64s); java_candidates.append(JRE32s); java_candidates.append(NEWJRE32s); @@ -290,6 +304,8 @@ QList JavaUtils::FindJavaPaths() java_candidates.append(JDK32s); java_candidates.append(NEWJDK32s); java_candidates.append(ADOPTOPENJDK32s); + java_candidates.append(ZULU32s); + java_candidates.append(LIBERICA32s); java_candidates.append(MakeJavaPtr(this->GetDefaultJava()->path)); From 00820df656a5c6fce8fd1023e2de73a269545b80 Mon Sep 17 00:00:00 2001 From: phit <2097483+phit@users.noreply.github.com> Date: Fri, 18 Jun 2021 18:31:14 +0200 Subject: [PATCH 31/57] GH-3731 Limit Curserforge version height --- application/pages/modplatform/flame/FlamePage.cpp | 2 ++ 1 file changed, 2 insertions(+) diff --git a/application/pages/modplatform/flame/FlamePage.cpp b/application/pages/modplatform/flame/FlamePage.cpp index 1fadc501..171d8d65 100644 --- a/application/pages/modplatform/flame/FlamePage.cpp +++ b/application/pages/modplatform/flame/FlamePage.cpp @@ -17,6 +17,8 @@ FlamePage::FlamePage(NewInstanceDialog* dialog, QWidget *parent) listModel = new Flame::ListModel(this); ui->packView->setModel(listModel); + ui->versionSelectionBox->setMaxVisibleItems(10); + // index is used to set the sorting with the curseforge api ui->sortByBox->addItem(tr("Sort by featured")); ui->sortByBox->addItem(tr("Sort by popularity")); From d08a2f00a2e403937b38254595cea6af5c5b236c Mon Sep 17 00:00:00 2001 From: phit <2097483+phit@users.noreply.github.com> Date: Fri, 18 Jun 2021 20:27:25 +0200 Subject: [PATCH 32/57] GH-3507 Modernize MacOS Icon full credit to @ThePotatoKing55 --- application/resources/MultiMC.icns | Bin 782703 -> 728772 bytes 1 file changed, 0 insertions(+), 0 deletions(-) diff --git a/application/resources/MultiMC.icns b/application/resources/MultiMC.icns index c4eb59d5de1e414bcfb1ade85063bd6c4c49edf3..a7cab40dae7c387e60acbdfbc591e948f198c4c0 100644 GIT binary patch literal 728772 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⩰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

NP-PV!Y?@m;!`{_+$r>WWsTEs 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

usgI{dlJD&4-K~n#e7kcMeKDe@Q=oND$heUt@{y ziUNmsjWMNQ#!MB(At4HPx z|02L3P@BSR*jyu1DI`^zdFvdJljxIv`%&$uQIBS9RpzsrXKdE4;gT+O{rfKeU3_*W zXyqL{K!PBKaLN%SfcySmD?*epHI7H~R1l34Nz41v))j}v#OqOr==AoT3$3>K|O03^^0d8y)K4?C6B_`ZqJutf50lR$wZUbjbC?kBE z7J(^{ARdv

3AmaY<2j>-%msXm)ko_ZI}MdpmmXLAvisqX~;7G{i0>n%WM{$I131 zbo18vAAggJk}Ha|fHp(Y>&)aDdP-!ZYm09EFmwl+$IizR_`@_ezY0}LqHU&6sO}4P zv)do?eL$DuXs^$LoW3_d-iLsis_VQg-QA4u*4-;n*VTn}wy|lxr2S8`2xGL%zh3Ui z1j$1R?lA#FEo-81ykzU$)L8tzfE&96u4R>L3IEDlzUiA_k>r_VMOZwk?+-XQIOf8) zLlm{`kcs#gbN37I?zR+3>-${EWDIwT-%sjKx7NWVZ*vat)`xc6h=o&3TW(2uF#m&g zkEpS7arg>{a!GoEu*yPaNW?O94nII+SHlL;!UuZ^*oxsRy_>x5(ER_z)n;g$$6mLZ z!(Q!BzTS1M-n%g9S^DcsUfUx{rIi~x`mNl@K%KVwx;oc?1E|0EH58u}KBi5)a31wi zvo)cfI}Da@voZ}D`(sY?Ruj~^!=-}L%J>4DzuTvOzLXGoCMR(nh+k6udf_ba zj|^YizOnZD<7O$hdE+XPMk$luai_0WDwf38%gy}3r1x%qHfWho@No6w?EblxBVYI} zyOD>$?(Xs+`t4x~GF2bws~MoF>P(sOw>BSMt1S|@%wUN_|%om z=J;fcbgX+=^kF;MdE`nJ1G`IOdl6 zsTmnLSs8;gzC=2y8CklihN%MVoeqZ%or@Vo7GL(C+aZi2Bnq5AsG-&wv&!}@uUVD& z%QzQP(~2so;apgH>J&Crn}nwfMXSKX5yvhVYlSzNY|XRV%t=X@H1=>Q7qd@hvEw^7 z%{eKG8H>ZsqZ$`kg?9SAM!mPm6$QRKeJA{ux!osTG2Jrx+;h?REq?Zqp{Lx@Pvz5N z=Wz-3p6uBW($x6e{MU9Nf-_~l+Ik@(JCw%81)j#xlhq8ujNWbT2)AXTidh&>DTJcV z=GB~hJWS3!P+_b0&HlLluQi}%UK~GNkn~)&Q{Fy?3=uoceci5UY=Z6SBwp0GZ9?e< zvZ?+#I}GPn*JUY`OUM?+Fd=)2^m*KWcG-aXeGU#B6Evo!`jv2vdbCE-+&(NS^ylw(cuFd?FT1^aMqwkvxKo0%@G z8P1`LXAb^U;`vJ(j8%Hd%cmMWK1XLd8Yn(|zp{hWI#ZuR?R^Y=d9%YRkx99%v3or_ z6DPNMI+)oW5g9RgUsIu^<{0)yC#Pg8(=zE}%i#!NO{Yx8W`)3O&8Ib*LziWEltV-h z;AwC&^QCYCm8s%_CA(Bs<>SeSUQ{29-}=w<8dP?ixoU@HO2Wahu&D9WkAR1W7EU(7 z__)`VSrlQkCU~umT&0&8v*DLBCSd7Xd*4vK6q$K|LW=K@f40lRwqnUq!kQ*y{w|lo zma9yMB6=oPkn5o;eSXZR!e8297|5$OOg?V&VbV#z0=!cK{+OoL$`Fq>s~(e%CSeMn znAU_TF07i~A7FR~I;vcgn=M#2PvR8|AYRnkS-E4t?fRMEQ;lX0X@@1a3PMS{)?|+q zA85EBdokKrEYoIX@68Q(4Q#a}k92Xe#>pj=C@yGEBu&W(VesMnvJoG?t0?ReVa&{{j9iFPr-qX`xadKKWh0>D+SLE-8tp00Be)tUImCzpMrV&;#@|HfLmtsa= z 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%0Aa+?1FBT4M| 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 z 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%0AkusDWP}R3r*q;5)YLI?mhq=;*LVM0 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 literal 782703 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®r+bRpXa^h9B{ni`hDnmFRsR1M7Go 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

k3giqZJ}R|9@Kly#M@Y&?EXxd6zksy)aqdJ} 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

%n*m^PMgt*~VdYXBxu`O7GP;mf_qz2wVyJwWrd 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

4e$jKHDp>^W6Mxkpb%-{NfpOdIhL~VZ`U1U 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 From c0f72488d042b8f7503b7f13fdcc53ea9e185b76 Mon Sep 17 00:00:00 2001 From: Jamie Mansfield Date: Fri, 18 Jun 2021 23:21:12 +0100 Subject: [PATCH 33/57] GH-3033 Add filtering for version components --- application/pages/instance/ModFolderPage.cpp | 2 +- application/pages/instance/VersionPage.cpp | 20 +++++++++++++++++--- application/pages/instance/VersionPage.h | 4 +++- application/pages/instance/VersionPage.ui | 18 ++++++++++++++++++ 4 files changed, 39 insertions(+), 5 deletions(-) diff --git a/application/pages/instance/ModFolderPage.cpp b/application/pages/instance/ModFolderPage.cpp index c3d6483a..98f20e77 100644 --- a/application/pages/instance/ModFolderPage.cpp +++ b/application/pages/instance/ModFolderPage.cpp @@ -163,7 +163,7 @@ ModFolderPage::ModFolderPage( auto smodel = ui->modTreeView->selectionModel(); connect(smodel, &QItemSelectionModel::currentChanged, this, &ModFolderPage::modCurrent); - connect(ui->filterEdit, &QLineEdit::textChanged, this, &ModFolderPage::on_filterTextChanged ); + connect(ui->filterEdit, &QLineEdit::textChanged, this, &ModFolderPage::on_filterTextChanged); connect(m_inst, &BaseInstance::runningStatusChanged, this, &ModFolderPage::on_RunningState_changed); } diff --git a/application/pages/instance/VersionPage.cpp b/application/pages/instance/VersionPage.cpp index 7f7ba860..eff12c9c 100644 --- a/application/pages/instance/VersionPage.cpp +++ b/application/pages/instance/VersionPage.cpp @@ -120,7 +120,15 @@ VersionPage::VersionPage(MinecraftInstance *inst, QWidget *parent) auto proxy = new IconProxy(ui->packageView); proxy->setSourceModel(m_profile.get()); - ui->packageView->setModel(proxy); + + m_filterModel = new QSortFilterProxyModel(); + m_filterModel->setDynamicSortFilter(true); + m_filterModel->setFilterCaseSensitivity(Qt::CaseInsensitive); + m_filterModel->setSortCaseSensitivity(Qt::CaseInsensitive); + m_filterModel->setSourceModel(proxy); + m_filterModel->setFilterKeyColumn(-1); + + ui->packageView->setModel(m_filterModel); ui->packageView->installEventFilter(this); ui->packageView->setSelectionMode(QAbstractItemView::SingleSelection); ui->packageView->setContextMenuPolicy(Qt::CustomContextMenu); @@ -134,7 +142,8 @@ VersionPage::VersionPage(MinecraftInstance *inst, QWidget *parent) updateVersionControls(); preselect(0); connect(m_inst, &BaseInstance::runningStatusChanged, this, &VersionPage::updateRunningStatus); - connect(ui->packageView, &ModListView::customContextMenuRequested, this, &VersionPage::ShowContextMenu); + connect(ui->packageView, &ModListView::customContextMenuRequested, this, &VersionPage::showContextMenu); + connect(ui->filterEdit, &QLineEdit::textChanged, this, &VersionPage::onFilterTextChanged); } VersionPage::~VersionPage() @@ -142,7 +151,7 @@ VersionPage::~VersionPage() delete ui; } -void VersionPage::ShowContextMenu(const QPoint& pos) +void VersionPage::showContextMenu(const QPoint& pos) { auto menu = ui->toolBar->createContextMenu(this, tr("Context menu")); menu->exec(ui->packageView->mapToGlobal(pos)); @@ -620,5 +629,10 @@ void VersionPage::on_actionRevert_triggered() m_container->refreshContainer(); } +void VersionPage::onFilterTextChanged(const QString &newContents) +{ + m_filterModel->setFilterFixedString(newContents); +} + #include "VersionPage.moc" diff --git a/application/pages/instance/VersionPage.h b/application/pages/instance/VersionPage.h index dbd9c1ee..b5b4a6f5 100644 --- a/application/pages/instance/VersionPage.h +++ b/application/pages/instance/VersionPage.h @@ -86,6 +86,7 @@ protected: private: Ui::VersionPage *ui; + QSortFilterProxyModel *m_filterModel; std::shared_ptr m_profile; MinecraftInstance *m_inst; int currentIdx = 0; @@ -98,5 +99,6 @@ private slots: void updateRunningStatus(bool running); void onGameUpdateError(QString error); void packageCurrent(const QModelIndex ¤t, const QModelIndex &previous); - void ShowContextMenu(const QPoint &pos); + void showContextMenu(const QPoint &pos); + void onFilterTextChanged(const QString & newContents); }; diff --git a/application/pages/instance/VersionPage.ui b/application/pages/instance/VersionPage.ui index 718ad067..84d06e2e 100644 --- a/application/pages/instance/VersionPage.ui +++ b/application/pages/instance/VersionPage.ui @@ -45,6 +45,24 @@ + + + + + + true + + + + + + + Filter: + + + + + From e148cfbbfd4af632afa484e2f9f164f0b1e642d4 Mon Sep 17 00:00:00 2001 From: Jamie Mansfield Date: Fri, 18 Jun 2021 23:42:40 +0100 Subject: [PATCH 34/57] NOISSUE Don't translate logged entries --- .../minecraft/launch/CreateGameFolders.cpp | 2 +- .../minecraft/launch/DirectJavaLaunch.cpp | 19 +++++++++---------- api/logic/minecraft/launch/ExtractNatives.cpp | 6 +++--- .../minecraft/launch/LauncherPartLaunch.cpp | 17 ++++++++--------- application/pages/instance/LogPage.cpp | 6 +++--- 5 files changed, 24 insertions(+), 26 deletions(-) diff --git a/api/logic/minecraft/launch/CreateGameFolders.cpp b/api/logic/minecraft/launch/CreateGameFolders.cpp index 415b7e23..4081e72e 100644 --- a/api/logic/minecraft/launch/CreateGameFolders.cpp +++ b/api/logic/minecraft/launch/CreateGameFolders.cpp @@ -15,7 +15,7 @@ void CreateGameFolders::executeTask() if(!FS::ensureFolderPathExists(minecraftInstance->gameRoot())) { emit logLine("Couldn't create the main game folder", MessageLevel::Error); - emitFailed("Couldn't create the main game folder"); + emitFailed(tr("Couldn't create the main game folder")); return; } diff --git a/api/logic/minecraft/launch/DirectJavaLaunch.cpp b/api/logic/minecraft/launch/DirectJavaLaunch.cpp index cf4564b6..2110384f 100644 --- a/api/logic/minecraft/launch/DirectJavaLaunch.cpp +++ b/api/logic/minecraft/launch/DirectJavaLaunch.cpp @@ -66,9 +66,9 @@ void DirectJavaLaunch::executeTask() auto realWrapperCommand = QStandardPaths::findExecutable(wrapperCommand); if (realWrapperCommand.isEmpty()) { - QString reason = tr("The wrapper command \"%1\" couldn't be found.").arg(wrapperCommand); - emit logLine(reason, MessageLevel::Fatal); - emitFailed(reason); + const char *reason = QT_TR_NOOP("The wrapper command \"%1\" couldn't be found."); + emit logLine(QString(reason).arg(wrapperCommand), MessageLevel::Fatal); + emitFailed(tr(reason).arg(wrapperCommand)); return; } emit logLine("Wrapper command is:\n" + wrapperCommandStr + "\n\n", MessageLevel::MultiMC); @@ -87,18 +87,17 @@ void DirectJavaLaunch::on_state(LoggedProcess::State state) { case LoggedProcess::FailedToStart: { - //: Error message displayed if instace can't start - QString reason = tr("Could not launch minecraft!"); + //: Error message displayed if instance can't start + const char *reason = QT_TR_NOOP("Could not launch minecraft!"); emit logLine(reason, MessageLevel::Fatal); - emitFailed(reason); + emitFailed(tr(reason)); return; } case LoggedProcess::Aborted: case LoggedProcess::Crashed: - { m_parent->setPid(-1); - emitFailed("Game crashed."); + emitFailed(tr("Game crashed.")); return; } case LoggedProcess::Finished: @@ -108,7 +107,7 @@ void DirectJavaLaunch::on_state(LoggedProcess::State state) auto exitCode = m_process.exitCode(); if(exitCode != 0) { - emitFailed("Game crashed."); + emitFailed(tr("Game crashed.")); return; } //FIXME: make this work again @@ -118,7 +117,7 @@ void DirectJavaLaunch::on_state(LoggedProcess::State state) break; } case LoggedProcess::Running: - emit logLine(tr("Minecraft process ID: %1\n\n").arg(m_process.processId()), MessageLevel::MultiMC); + emit logLine(QString("Minecraft process ID: %1\n\n").arg(m_process.processId()), MessageLevel::MultiMC); m_parent->setPid(m_process.processId()); m_parent->instance()->setLastLaunch(); break; diff --git a/api/logic/minecraft/launch/ExtractNatives.cpp b/api/logic/minecraft/launch/ExtractNatives.cpp index d41cb8fd..d57499aa 100644 --- a/api/logic/minecraft/launch/ExtractNatives.cpp +++ b/api/logic/minecraft/launch/ExtractNatives.cpp @@ -94,9 +94,9 @@ void ExtractNatives::executeTask() { if(!unzipNatives(source, outputPath, jniHackEnabled, nativeOpenAL, nativeGLFW)) { - auto reason = tr("Couldn't extract native jar '%1' to destination '%2'").arg(source, outputPath); - emit logLine(reason, MessageLevel::Fatal); - emitFailed(reason); + const char *reason = QT_TR_NOOP("Couldn't extract native jar '%1' to destination '%2'"); + emit logLine(QString(reason).arg(source, outputPath), MessageLevel::Fatal); + emitFailed(tr(reason).arg(source, outputPath)); } } emitSucceeded(); diff --git a/api/logic/minecraft/launch/LauncherPartLaunch.cpp b/api/logic/minecraft/launch/LauncherPartLaunch.cpp index ab3b6d10..ee469770 100644 --- a/api/logic/minecraft/launch/LauncherPartLaunch.cpp +++ b/api/logic/minecraft/launch/LauncherPartLaunch.cpp @@ -118,9 +118,9 @@ void LauncherPartLaunch::executeTask() auto realWrapperCommand = QStandardPaths::findExecutable(wrapperCommand); if (realWrapperCommand.isEmpty()) { - QString reason = tr("The wrapper command \"%1\" couldn't be found.").arg(wrapperCommand); - emit logLine(reason, MessageLevel::Fatal); - emitFailed(reason); + const char *reason = QT_TR_NOOP("The wrapper command \"%1\" couldn't be found."); + emit logLine(QString(reason).arg(wrapperCommand), MessageLevel::Fatal); + emitFailed(tr(reason).arg(wrapperCommand)); return; } emit logLine("Wrapper command is:\n" + wrapperCommandStr + "\n\n", MessageLevel::MultiMC); @@ -140,17 +140,16 @@ void LauncherPartLaunch::on_state(LoggedProcess::State state) case LoggedProcess::FailedToStart: { //: Error message displayed if instace can't start - QString reason = tr("Could not launch minecraft!"); + const char *reason = QT_TR_NOOP("Could not launch minecraft!"); emit logLine(reason, MessageLevel::Fatal); - emitFailed(reason); + emitFailed(tr(reason)); return; } case LoggedProcess::Aborted: case LoggedProcess::Crashed: - { m_parent->setPid(-1); - emitFailed("Game crashed."); + emitFailed(tr("Game crashed.")); return; } case LoggedProcess::Finished: @@ -160,7 +159,7 @@ void LauncherPartLaunch::on_state(LoggedProcess::State state) auto exitCode = m_process.exitCode(); if(exitCode != 0) { - emitFailed("Game crashed."); + emitFailed(tr("Game crashed.")); return; } //FIXME: make this work again @@ -170,7 +169,7 @@ void LauncherPartLaunch::on_state(LoggedProcess::State state) break; } case LoggedProcess::Running: - emit logLine(tr("Minecraft process ID: %1\n\n").arg(m_process.processId()), MessageLevel::MultiMC); + emit logLine(QString("Minecraft process ID: %1\n\n").arg(m_process.processId()), MessageLevel::MultiMC); m_parent->setPid(m_process.processId()); m_parent->instance()->setLastLaunch(); // send the launch script to the launcher part diff --git a/application/pages/instance/LogPage.cpp b/application/pages/instance/LogPage.cpp index 94ada424..3d2085c6 100644 --- a/application/pages/instance/LogPage.cpp +++ b/application/pages/instance/LogPage.cpp @@ -236,15 +236,15 @@ void LogPage::on_btnPaste_clicked() return; //FIXME: turn this into a proper task and move the upload logic out of GuiUtil! - m_model->append(MessageLevel::MultiMC, tr("MultiMC: Log upload triggered at: %1").arg(QDateTime::currentDateTime().toString(Qt::RFC2822Date))); + m_model->append(MessageLevel::MultiMC, QString("MultiMC: Log upload triggered at: %1").arg(QDateTime::currentDateTime().toString(Qt::RFC2822Date))); auto url = GuiUtil::uploadPaste(m_model->toPlainText(), this); if(!url.isEmpty()) { - m_model->append(MessageLevel::MultiMC, tr("MultiMC: Log uploaded to: %1").arg(url)); + m_model->append(MessageLevel::MultiMC, QString("MultiMC: Log uploaded to: %1").arg(url)); } else { - m_model->append(MessageLevel::Error, tr("MultiMC: Log upload failed!")); + m_model->append(MessageLevel::Error, "MultiMC: Log upload failed!"); } } From c92b44e6d6b376f3a114276f5deeaa5cfafd8b0d Mon Sep 17 00:00:00 2001 From: Jamie Mansfield Date: Sat, 19 Jun 2021 00:12:54 +0100 Subject: [PATCH 35/57] GH-3719 Translate some missing strings when changing locale --- application/MainWindow.cpp | 18 ++++++++++++++++-- application/MainWindow.h | 2 ++ 2 files changed, 18 insertions(+), 2 deletions(-) diff --git a/application/MainWindow.cpp b/application/MainWindow.cpp index 9d046ddb..13a7c7ae 100644 --- a/application/MainWindow.cpp +++ b/application/MainWindow.cpp @@ -738,7 +738,6 @@ MainWindow::MainWindow(QWidget *parent) : QMainWindow(parent), ui(new MainWindow repopulateAccountsMenu(); accountMenuButton = new QToolButton(this); - accountMenuButton->setText(tr("Profiles")); accountMenuButton->setMenu(accountMenu); accountMenuButton->setPopupMode(QToolButton::InstantPopup); accountMenuButton->setToolButtonStyle(Qt::ToolButtonTextBesideIcon); @@ -837,6 +836,21 @@ MainWindow::MainWindow(QWidget *parent) : QMainWindow(parent), ui(new MainWindow // removing this looks stupid view->setFocus(); + + retranslateUi(); +} + +void MainWindow::retranslateUi() +{ + accountMenuButton->setText(tr("Profiles")); + + if (m_selectedInstance) { + m_statusLeft->setText(m_selectedInstance->getStatusbarDescription()); + } else { + m_statusLeft->setText(tr("No instance selected")); + } + + ui->retranslateUi(this); } MainWindow::~MainWindow() @@ -1751,7 +1765,7 @@ void MainWindow::changeEvent(QEvent* event) { if (event->type() == QEvent::LanguageChange) { - ui->retranslateUi(this); + retranslateUi(); } QMainWindow::changeEvent(event); } diff --git a/application/MainWindow.h b/application/MainWindow.h index 3d4114de..08c6b969 100644 --- a/application/MainWindow.h +++ b/application/MainWindow.h @@ -187,6 +187,8 @@ private slots: void globalSettingsClosed(); private: + void retranslateUi(); + void addInstance(QString url = QString()); void activateInstance(InstancePtr instance); void setCatBackground(bool enabled); From b246fc171e1e8c747b0aedd6b0b47b923cc8cfb7 Mon Sep 17 00:00:00 2001 From: Jamie Mansfield Date: Sat, 19 Jun 2021 00:59:48 +0100 Subject: [PATCH 36/57] GH-2971 Brand mod model for resource/texture pack pages --- api/logic/CMakeLists.txt | 4 ++++ api/logic/minecraft/MinecraftInstance.cpp | 6 +++-- .../minecraft/mod/ResourcePackFolderModel.cpp | 23 +++++++++++++++++++ .../minecraft/mod/ResourcePackFolderModel.h | 13 +++++++++++ .../minecraft/mod/TexturePackFolderModel.cpp | 23 +++++++++++++++++++ .../minecraft/mod/TexturePackFolderModel.h | 13 +++++++++++ application/pages/instance/ResourcePackPage.h | 3 ++- application/pages/instance/TexturePackPage.h | 2 ++ 8 files changed, 84 insertions(+), 3 deletions(-) create mode 100644 api/logic/minecraft/mod/ResourcePackFolderModel.cpp create mode 100644 api/logic/minecraft/mod/ResourcePackFolderModel.h create mode 100644 api/logic/minecraft/mod/TexturePackFolderModel.cpp create mode 100644 api/logic/minecraft/mod/TexturePackFolderModel.h diff --git a/api/logic/CMakeLists.txt b/api/logic/CMakeLists.txt index c3322955..17e22458 100644 --- a/api/logic/CMakeLists.txt +++ b/api/logic/CMakeLists.txt @@ -302,6 +302,10 @@ set(MINECRAFT_SOURCES minecraft/mod/ModFolderLoadTask.cpp minecraft/mod/LocalModParseTask.h minecraft/mod/LocalModParseTask.cpp + minecraft/mod/ResourcePackFolderModel.h + minecraft/mod/ResourcePackFolderModel.cpp + minecraft/mod/TexturePackFolderModel.h + minecraft/mod/TexturePackFolderModel.cpp # Assets minecraft/AssetsUtils.h diff --git a/api/logic/minecraft/MinecraftInstance.cpp b/api/logic/minecraft/MinecraftInstance.cpp index a1341e69..fdf9bd61 100644 --- a/api/logic/minecraft/MinecraftInstance.cpp +++ b/api/logic/minecraft/MinecraftInstance.cpp @@ -29,6 +29,8 @@ #include "meta/VersionList.h" #include "mod/ModFolderModel.h" +#include "mod/ResourcePackFolderModel.h" +#include "mod/TexturePackFolderModel.h" #include "WorldList.h" #include "icons/IIconList.h" @@ -986,7 +988,7 @@ std::shared_ptr MinecraftInstance::resourcePackList() const { if (!m_resource_pack_list) { - m_resource_pack_list.reset(new ModFolderModel(resourcePacksDir())); + m_resource_pack_list.reset(new ResourcePackFolderModel(resourcePacksDir())); m_resource_pack_list->disableInteraction(isRunning()); connect(this, &BaseInstance::runningStatusChanged, m_resource_pack_list.get(), &ModFolderModel::disableInteraction); } @@ -997,7 +999,7 @@ std::shared_ptr MinecraftInstance::texturePackList() const { if (!m_texture_pack_list) { - m_texture_pack_list.reset(new ModFolderModel(texturePacksDir())); + m_texture_pack_list.reset(new TexturePackFolderModel(texturePacksDir())); m_texture_pack_list->disableInteraction(isRunning()); connect(this, &BaseInstance::runningStatusChanged, m_texture_pack_list.get(), &ModFolderModel::disableInteraction); } diff --git a/api/logic/minecraft/mod/ResourcePackFolderModel.cpp b/api/logic/minecraft/mod/ResourcePackFolderModel.cpp new file mode 100644 index 00000000..f3d7f566 --- /dev/null +++ b/api/logic/minecraft/mod/ResourcePackFolderModel.cpp @@ -0,0 +1,23 @@ +#include "ResourcePackFolderModel.h" + +ResourcePackFolderModel::ResourcePackFolderModel(const QString &dir) : ModFolderModel(dir) { +} + +QVariant ResourcePackFolderModel::headerData(int section, Qt::Orientation orientation, int role) const { + if (role == Qt::ToolTipRole) { + switch (section) { + case ActiveColumn: + return tr("Is the resource pack enabled?"); + case NameColumn: + return tr("The name of the resource pack."); + case VersionColumn: + return tr("The version of the resource pack."); + case DateColumn: + return tr("The date and time this resource pack was last changed (or added)."); + default: + return QVariant(); + } + } + + return ModFolderModel::headerData(section, orientation, role); +} diff --git a/api/logic/minecraft/mod/ResourcePackFolderModel.h b/api/logic/minecraft/mod/ResourcePackFolderModel.h new file mode 100644 index 00000000..47eb4bb2 --- /dev/null +++ b/api/logic/minecraft/mod/ResourcePackFolderModel.h @@ -0,0 +1,13 @@ +#pragma once + +#include "ModFolderModel.h" + +class MULTIMC_LOGIC_EXPORT ResourcePackFolderModel : public ModFolderModel +{ + Q_OBJECT + +public: + explicit ResourcePackFolderModel(const QString &dir); + + QVariant headerData(int section, Qt::Orientation orientation, int role) const override; +}; diff --git a/api/logic/minecraft/mod/TexturePackFolderModel.cpp b/api/logic/minecraft/mod/TexturePackFolderModel.cpp new file mode 100644 index 00000000..d5956da1 --- /dev/null +++ b/api/logic/minecraft/mod/TexturePackFolderModel.cpp @@ -0,0 +1,23 @@ +#include "TexturePackFolderModel.h" + +TexturePackFolderModel::TexturePackFolderModel(const QString &dir) : ModFolderModel(dir) { +} + +QVariant TexturePackFolderModel::headerData(int section, Qt::Orientation orientation, int role) const { + if (role == Qt::ToolTipRole) { + switch (section) { + case ActiveColumn: + return tr("Is the texture pack enabled?"); + case NameColumn: + return tr("The name of the texture pack."); + case VersionColumn: + return tr("The version of the texture pack."); + case DateColumn: + return tr("The date and time this texture pack was last changed (or added)."); + default: + return QVariant(); + } + } + + return ModFolderModel::headerData(section, orientation, role); +} diff --git a/api/logic/minecraft/mod/TexturePackFolderModel.h b/api/logic/minecraft/mod/TexturePackFolderModel.h new file mode 100644 index 00000000..d773b17b --- /dev/null +++ b/api/logic/minecraft/mod/TexturePackFolderModel.h @@ -0,0 +1,13 @@ +#pragma once + +#include "ModFolderModel.h" + +class MULTIMC_LOGIC_EXPORT TexturePackFolderModel : public ModFolderModel +{ + Q_OBJECT + +public: + explicit TexturePackFolderModel(const QString &dir); + + QVariant headerData(int section, Qt::Orientation orientation, int role) const override; +}; diff --git a/application/pages/instance/ResourcePackPage.h b/application/pages/instance/ResourcePackPage.h index e11c78a3..1486bf52 100644 --- a/application/pages/instance/ResourcePackPage.h +++ b/application/pages/instance/ResourcePackPage.h @@ -1,4 +1,5 @@ #pragma once + #include "ModFolderPage.h" #include "ui_ModFolderPage.h" @@ -12,8 +13,8 @@ public: { ui->actionView_configs->setVisible(false); } - virtual ~ResourcePackPage() {} + virtual bool shouldDisplay() const override { return !m_inst->traits().contains("no-texturepacks") && diff --git a/application/pages/instance/TexturePackPage.h b/application/pages/instance/TexturePackPage.h index a792ba07..3f04997d 100644 --- a/application/pages/instance/TexturePackPage.h +++ b/application/pages/instance/TexturePackPage.h @@ -1,4 +1,5 @@ #pragma once + #include "ModFolderPage.h" #include "ui_ModFolderPage.h" @@ -13,6 +14,7 @@ public: ui->actionView_configs->setVisible(false); } virtual ~TexturePackPage() {} + virtual bool shouldDisplay() const override { return m_inst->traits().contains("texturepacks"); From 6db6ebe37f245bba3de285a4ad8a65b667e6ffb0 Mon Sep 17 00:00:00 2001 From: Adrian Date: Sat, 19 Jun 2021 03:15:21 +0200 Subject: [PATCH 37/57] NOISSUE Add info for instance launch mode and server status when online --- application/LaunchController.cpp | 42 ++++++++++++++++++++++++++++++++ 1 file changed, 42 insertions(+) diff --git a/application/LaunchController.cpp b/application/LaunchController.cpp index 3c4491a3..ee764082 100644 --- a/application/LaunchController.cpp +++ b/application/LaunchController.cpp @@ -15,6 +15,9 @@ #include #include #include +#include +#include +#include LaunchController::LaunchController(QObject *parent) : Task(parent) { @@ -215,7 +218,46 @@ void LaunchController::launchInstance() connect(m_launcher.get(), &LaunchTask::failed, this, &LaunchController::onFailed); connect(m_launcher.get(), &LaunchTask::requestProgress, this, &LaunchController::onProgressRequested); + // Prepend Online and Auth Status + QString online_mode; + if(m_session->wants_online) { + online_mode = "online"; + // Prepend Server Status + QStringList servers = {"authserver.mojang.com", "session.minecraft.net", "textures.minecraft.net", "api.mojang.com"}; + QString resolved_servers = ""; + QHostInfo host_info; + + for(QString server : servers) { + host_info = QHostInfo::fromName(server); + resolved_servers = resolved_servers + server + " resolves to:\n ["; + if(!host_info.addresses().isEmpty()) { + for(QHostAddress address : host_info.addresses()) { + resolved_servers = resolved_servers + address.toString(); + if(!host_info.addresses().endsWith(address)) { + resolved_servers = resolved_servers + ", "; + } + } + } else { + resolved_servers = resolved_servers + "N/A"; + } + resolved_servers = resolved_servers + "]\n\n"; + } + m_launcher->prependStep(new TextPrint(m_launcher.get(), resolved_servers, MessageLevel::MultiMC)); + } else { + online_mode = "offline"; + } + + QString auth_server_status; + if(m_session->auth_server_online) { + auth_server_status = "online"; + } else { + auth_server_status = "offline"; + } + + m_launcher->prependStep(new TextPrint(m_launcher.get(), "Launched instance in " + online_mode + " mode\nAuthentication server is " + auth_server_status + "\n", MessageLevel::MultiMC)); + + // Prepend Version m_launcher->prependStep(new TextPrint(m_launcher.get(), "MultiMC version: " + BuildConfig.printableVersionString() + "\n\n", MessageLevel::MultiMC)); m_launcher->start(); } From 81d4dc09ccef1df5c95164681d9f0f72dceeff64 Mon Sep 17 00:00:00 2001 From: Jamie Mansfield Date: Sat, 19 Jun 2021 20:21:07 +0100 Subject: [PATCH 38/57] NOISSUE Add notice re MSA to login dialog This commit should be reverted when support for Microsoft/Xbox authentication is introduced. --- application/dialogs/LoginDialog.ui | 14 ++++++++++++-- 1 file changed, 12 insertions(+), 2 deletions(-) diff --git a/application/dialogs/LoginDialog.ui b/application/dialogs/LoginDialog.ui index d92fbae3..dbdb3b93 100644 --- a/application/dialogs/LoginDialog.ui +++ b/application/dialogs/LoginDialog.ui @@ -6,8 +6,8 @@ 0 0 - 400 - 162 + 421 + 238 @@ -20,6 +20,16 @@ Add Account + + + + NOTICE: MultiMC does not currently support Microsoft accounts. This means that accounts created from December 2020 onwards cannot be used. + + + true + + + From f7c144c3932a18e1cd96e1ad7505e53ea706a47d Mon Sep 17 00:00:00 2001 From: phit <2097483+phit@users.noreply.github.com> Date: Sat, 19 Jun 2021 16:19:39 +0200 Subject: [PATCH 39/57] GH-3720 Fix UI inconsistencies with Modplatforms Fixes GH-3118 Fixes GH-3720 Fixes GH-3731 Icons and Ok button state will now switch consistently when moving between tabs. ATLaunchers packlist is now no longer redownloaded each time you open its Tab. All lists are striped now. And all search and filter fields now have a placeholder text. --- application/dialogs/NewInstanceDialog.cpp | 8 ++ application/dialogs/NewInstanceDialog.h | 1 + application/pages/modplatform/ImportPage.cpp | 2 + application/pages/modplatform/VanillaPage.cpp | 13 ++- .../pages/modplatform/atlauncher/AtlPage.cpp | 20 +++- .../pages/modplatform/atlauncher/AtlPage.h | 2 + .../pages/modplatform/atlauncher/AtlPage.ui | 12 +- .../pages/modplatform/flame/FlamePage.cpp | 8 ++ application/pages/modplatform/ftb/FtbPage.cpp | 31 ++++-- application/pages/modplatform/ftb/FtbPage.ui | 9 +- .../pages/modplatform/legacy_ftb/Page.cpp | 79 +++++++------- .../pages/modplatform/legacy_ftb/Page.ui | 9 ++ .../modplatform/technic/TechnicModel.cpp | 17 ++- .../pages/modplatform/technic/TechnicPage.cpp | 103 +++++++++--------- .../pages/modplatform/technic/TechnicPage.ui | 6 +- 15 files changed, 205 insertions(+), 115 deletions(-) diff --git a/application/dialogs/NewInstanceDialog.cpp b/application/dialogs/NewInstanceDialog.cpp index 112e46ff..86963149 100644 --- a/application/dialogs/NewInstanceDialog.cpp +++ b/application/dialogs/NewInstanceDialog.cpp @@ -173,6 +173,14 @@ void NewInstanceDialog::setSuggestedIconFromFile(const QString &path, const QStr ui->iconButton->setIcon(QIcon(path)); } +void NewInstanceDialog::setSuggestedIcon(const QString &key) +{ + auto icon = MMC->icons()->getIcon(key); + importIcon = false; + + ui->iconButton->setIcon(icon); +} + InstanceTask * NewInstanceDialog::extractTask() { InstanceTask * extracted = creationTask.get(); diff --git a/application/dialogs/NewInstanceDialog.h b/application/dialogs/NewInstanceDialog.h index f8d96dbf..53abf8cf 100644 --- a/application/dialogs/NewInstanceDialog.h +++ b/application/dialogs/NewInstanceDialog.h @@ -43,6 +43,7 @@ public: void setSuggestedPack(const QString & name = QString(), InstanceTask * task = nullptr); void setSuggestedIconFromFile(const QString &path, const QString &name); + void setSuggestedIcon(const QString &key); InstanceTask * extractTask(); diff --git a/application/pages/modplatform/ImportPage.cpp b/application/pages/modplatform/ImportPage.cpp index 3910dfda..c2369bdc 100644 --- a/application/pages/modplatform/ImportPage.cpp +++ b/application/pages/modplatform/ImportPage.cpp @@ -71,6 +71,7 @@ void ImportPage::updateState() { QFileInfo fi(url.fileName()); dialog->setSuggestedPack(fi.completeBaseName(), new InstanceImportTask(url)); + dialog->setSuggestedIcon("default"); } } else @@ -83,6 +84,7 @@ void ImportPage::updateState() // hook, line and sinker. QFileInfo fi(url.fileName()); dialog->setSuggestedPack(fi.completeBaseName(), new InstanceImportTask(url)); + dialog->setSuggestedIcon("default"); } } else diff --git a/application/pages/modplatform/VanillaPage.cpp b/application/pages/modplatform/VanillaPage.cpp index 17535f1e..02638315 100644 --- a/application/pages/modplatform/VanillaPage.cpp +++ b/application/pages/modplatform/VanillaPage.cpp @@ -82,10 +82,19 @@ BaseVersionPtr VanillaPage::selectedVersion() const void VanillaPage::suggestCurrent() { - if(m_selectedVersion && isOpened) + if (!isOpened) { - dialog->setSuggestedPack(m_selectedVersion->descriptor(), new InstanceCreationTask(m_selectedVersion)); + return; } + + if(!m_selectedVersion) + { + dialog->setSuggestedPack(); + return; + } + + dialog->setSuggestedPack(m_selectedVersion->descriptor(), new InstanceCreationTask(m_selectedVersion)); + dialog->setSuggestedIcon("default"); } void VanillaPage::setSelectedVersion(BaseVersionPtr version) diff --git a/application/pages/modplatform/atlauncher/AtlPage.cpp b/application/pages/modplatform/atlauncher/AtlPage.cpp index 748f467c..1b61ebd0 100644 --- a/application/pages/modplatform/atlauncher/AtlPage.cpp +++ b/application/pages/modplatform/atlauncher/AtlPage.cpp @@ -45,15 +45,29 @@ bool AtlPage::shouldDisplay() const void AtlPage::openedImpl() { - listModel->request(); + if(!initialized) + { + listModel->request(); + initialized = true; + } + + suggestCurrent(); } void AtlPage::suggestCurrent() { - if(isOpened) { - dialog->setSuggestedPack(selected.name, new ATLauncher::PackInstallTask(this, selected.safeName, selectedVersion)); + if(!isOpened) + { + return; } + if (selectedVersion.isEmpty()) + { + dialog->setSuggestedPack(); + return; + } + + dialog->setSuggestedPack(selected.name, new ATLauncher::PackInstallTask(this, selected.safeName, selectedVersion)); auto editedLogoName = selected.safeName; auto url = QString(BuildConfig.ATL_DOWNLOAD_SERVER_URL + "launcher/images/%1.png").arg(selected.safeName.toLower()); listModel->getLogo(selected.safeName, url, [this, editedLogoName](QString logo) diff --git a/application/pages/modplatform/atlauncher/AtlPage.h b/application/pages/modplatform/atlauncher/AtlPage.h index 6a89b609..18f8b1c6 100644 --- a/application/pages/modplatform/atlauncher/AtlPage.h +++ b/application/pages/modplatform/atlauncher/AtlPage.h @@ -81,4 +81,6 @@ private: ATLauncher::IndexedPack selected; QString selectedVersion; + + bool initialized = false; }; diff --git a/application/pages/modplatform/atlauncher/AtlPage.ui b/application/pages/modplatform/atlauncher/AtlPage.ui index bb0d5310..0860a873 100644 --- a/application/pages/modplatform/atlauncher/AtlPage.ui +++ b/application/pages/modplatform/atlauncher/AtlPage.ui @@ -21,6 +21,9 @@ 48 + + true + @@ -48,7 +51,14 @@ - + + + + 0 + 0 + + + diff --git a/application/pages/modplatform/flame/FlamePage.cpp b/application/pages/modplatform/flame/FlamePage.cpp index 171d8d65..2dd58e16 100644 --- a/application/pages/modplatform/flame/FlamePage.cpp +++ b/application/pages/modplatform/flame/FlamePage.cpp @@ -18,6 +18,8 @@ FlamePage::FlamePage(NewInstanceDialog* dialog, QWidget *parent) ui->packView->setModel(listModel); ui->versionSelectionBox->setMaxVisibleItems(10); + // fix height for themes that dont respect max visible like fusion + ui->versionSelectionBox->setStyleSheet("combobox-popup: 0;"); // index is used to set the sorting with the curseforge api ui->sortByBox->addItem(tr("Sort by featured")); @@ -157,6 +159,12 @@ void FlamePage::suggestCurrent() return; } + if (selectedVersion.isEmpty()) + { + dialog->setSuggestedPack(); + return; + } + dialog->setSuggestedPack(current.name, new InstanceImportTask(selectedVersion)); QString editedLogoName; editedLogoName = "curseforge_" + current.logoName.section(".", 0, 0); diff --git a/application/pages/modplatform/ftb/FtbPage.cpp b/application/pages/modplatform/ftb/FtbPage.cpp index dd2ff666..b49982d5 100644 --- a/application/pages/modplatform/ftb/FtbPage.cpp +++ b/application/pages/modplatform/ftb/FtbPage.cpp @@ -60,26 +60,33 @@ bool FtbPage::shouldDisplay() const void FtbPage::openedImpl() { - dialog->setSuggestedPack(); triggerSearch(); + suggestCurrent(); } void FtbPage::suggestCurrent() { - if(isOpened) + if(!isOpened) { - dialog->setSuggestedPack(selected.name, new ModpacksCH::PackInstallTask(selected, selectedVersion)); + return; + } - for(auto art : selected.art) { - if(art.type == "square") { - QString editedLogoName; - editedLogoName = selected.name; + if (selectedVersion.isEmpty()) + { + dialog->setSuggestedPack(); + return; + } - listModel->getLogo(selected.name, art.url, [this, editedLogoName](QString logo) - { - dialog->setSuggestedIconFromFile(logo + ".small", editedLogoName); - }); - } + dialog->setSuggestedPack(selected.name, new ModpacksCH::PackInstallTask(selected, selectedVersion)); + for(auto art : selected.art) { + if(art.type == "square") { + QString editedLogoName; + editedLogoName = selected.name; + + listModel->getLogo(selected.name, art.url, [this, editedLogoName](QString logo) + { + dialog->setSuggestedIconFromFile(logo + ".small", editedLogoName); + }); } } } diff --git a/application/pages/modplatform/ftb/FtbPage.ui b/application/pages/modplatform/ftb/FtbPage.ui index 475d78bb..135afc6d 100644 --- a/application/pages/modplatform/ftb/FtbPage.ui +++ b/application/pages/modplatform/ftb/FtbPage.ui @@ -32,7 +32,11 @@ - + + + Search and filter ... + + @@ -51,6 +55,9 @@ 48 + + true + diff --git a/application/pages/modplatform/legacy_ftb/Page.cpp b/application/pages/modplatform/legacy_ftb/Page.cpp index 8e40ba9e..3bcc42c1 100644 --- a/application/pages/modplatform/legacy_ftb/Page.cpp +++ b/application/pages/modplatform/legacy_ftb/Page.cpp @@ -122,49 +122,50 @@ void Page::openedImpl() void Page::suggestCurrent() { - if(isOpened) + if(!isOpened) { - if(!selected.broken) - { - dialog->setSuggestedPack(selected.name, new PackInstallTask(selected, selectedVersion)); - QString editedLogoName; - if(selected.logo.toLower().startsWith("ftb")) - { - editedLogoName = selected.logo; - } - else - { - editedLogoName = "ftb_" + selected.logo; - } + return; + } - editedLogoName = editedLogoName.left(editedLogoName.lastIndexOf(".png")); + if(!selected.broken || !selectedVersion.isEmpty()) + { + dialog->setSuggestedPack(); + return; + } - if(selected.type == PackType::Public) - { - publicListModel->getLogo(selected.logo, [this, editedLogoName](QString logo) - { - dialog->setSuggestedIconFromFile(logo, editedLogoName); - }); - } - else if (selected.type == PackType::ThirdParty) - { - thirdPartyModel->getLogo(selected.logo, [this, editedLogoName](QString logo) - { - dialog->setSuggestedIconFromFile(logo, editedLogoName); - }); - } - else if (selected.type == PackType::Private) - { - privateListModel->getLogo(selected.logo, [this, editedLogoName](QString logo) - { - dialog->setSuggestedIconFromFile(logo, editedLogoName); - }); - } - } - else + dialog->setSuggestedPack(selected.name, new PackInstallTask(selected, selectedVersion)); + QString editedLogoName; + if(selected.logo.toLower().startsWith("ftb")) + { + editedLogoName = selected.logo; + } + else + { + editedLogoName = "ftb_" + selected.logo; + } + + editedLogoName = editedLogoName.left(editedLogoName.lastIndexOf(".png")); + + if(selected.type == PackType::Public) + { + publicListModel->getLogo(selected.logo, [this, editedLogoName](QString logo) { - dialog->setSuggestedPack(); - } + dialog->setSuggestedIconFromFile(logo, editedLogoName); + }); + } + else if (selected.type == PackType::ThirdParty) + { + thirdPartyModel->getLogo(selected.logo, [this, editedLogoName](QString logo) + { + dialog->setSuggestedIconFromFile(logo, editedLogoName); + }); + } + else if (selected.type == PackType::Private) + { + privateListModel->getLogo(selected.logo, [this, editedLogoName](QString logo) + { + dialog->setSuggestedIconFromFile(logo, editedLogoName); + }); } } diff --git a/application/pages/modplatform/legacy_ftb/Page.ui b/application/pages/modplatform/legacy_ftb/Page.ui index 36fb2359..15e5d432 100644 --- a/application/pages/modplatform/legacy_ftb/Page.ui +++ b/application/pages/modplatform/legacy_ftb/Page.ui @@ -29,6 +29,9 @@ 16777215 + + true + @@ -52,6 +55,9 @@ 16777215 + + true + @@ -69,6 +75,9 @@ 16777215 + + true + diff --git a/application/pages/modplatform/technic/TechnicModel.cpp b/application/pages/modplatform/technic/TechnicModel.cpp index bf256ab6..a240a94a 100644 --- a/application/pages/modplatform/technic/TechnicModel.cpp +++ b/application/pages/modplatform/technic/TechnicModel.cpp @@ -72,7 +72,7 @@ int Technic::ListModel::rowCount(const QModelIndex&) const void Technic::ListModel::searchWithTerm(const QString& term) { - if(currentSearchTerm == term) { + if(currentSearchTerm == term && currentSearchTerm.isNull() == term.isNull()) { return; } currentSearchTerm = term; @@ -93,9 +93,18 @@ void Technic::ListModel::searchWithTerm(const QString& term) void Technic::ListModel::performSearch() { NetJob *netJob = new NetJob("Technic::Search"); - auto searchUrl = QString( - "https://api.technicpack.net/search?build=multimc&q=%1" - ).arg(currentSearchTerm); + QString searchUrl = ""; + if (currentSearchTerm.isEmpty()) { + searchUrl = QString( + "https://api.technicpack.net/trending?build=multimc" + ).arg(currentSearchTerm); + } + else + { + searchUrl = QString( + "https://api.technicpack.net/search?build=multimc&q=%1" + ).arg(currentSearchTerm); + } netJob->addNetAction(Net::Download::makeByteArray(QUrl(searchUrl), &response)); jobPtr = netJob; jobPtr->start(); diff --git a/application/pages/modplatform/technic/TechnicPage.cpp b/application/pages/modplatform/technic/TechnicPage.cpp index d246edf2..e836f767 100644 --- a/application/pages/modplatform/technic/TechnicPage.cpp +++ b/application/pages/modplatform/technic/TechnicPage.cpp @@ -60,7 +60,8 @@ bool TechnicPage::shouldDisplay() const void TechnicPage::openedImpl() { - dialog->setSuggestedPack(); + suggestCurrent(); + triggerSearch(); } void TechnicPage::triggerSearch() { @@ -95,8 +96,7 @@ void TechnicPage::suggestCurrent() return; } - QString editedLogoName; - editedLogoName = "technic_" + current.logoName.section(".", 0, 0); + QString editedLogoName = "technic_" + current.logoName.section(".", 0, 0); model->getLogo(current.logoName, current.logoUrl, [this, editedLogoName](QString logo) { dialog->setSuggestedIconFromFile(logo, editedLogoName); @@ -105,67 +105,66 @@ void TechnicPage::suggestCurrent() if (current.metadataLoaded) { metadataLoaded(); + return; } - else + + NetJob *netJob = new NetJob(QString("Technic::PackMeta(%1)").arg(current.name)); + std::shared_ptr response = std::make_shared(); + QString slug = current.slug; + netJob->addNetAction(Net::Download::makeByteArray(QString("https://api.technicpack.net/modpack/%1?build=multimc").arg(slug), response.get())); + QObject::connect(netJob, &NetJob::succeeded, this, [this, response, slug] { - NetJob *netJob = new NetJob(QString("Technic::PackMeta(%1)").arg(current.name)); - std::shared_ptr response = std::make_shared(); - QString slug = current.slug; - netJob->addNetAction(Net::Download::makeByteArray(QString("https://api.technicpack.net/modpack/%1?build=multimc").arg(slug), response.get())); - QObject::connect(netJob, &NetJob::succeeded, this, [this, response, slug] + if (current.slug != slug) { - if (current.slug != slug) + return; + } + QJsonParseError parse_error; + QJsonDocument doc = QJsonDocument::fromJson(*response, &parse_error); + QJsonObject obj = doc.object(); + if(parse_error.error != QJsonParseError::NoError) + { + qWarning() << "Error while parsing JSON response from Technic at " << parse_error.offset << " reason: " << parse_error.errorString(); + qWarning() << *response; + return; + } + if (!obj.contains("url")) + { + qWarning() << "Json doesn't contain an url key"; + return; + } + QJsonValueRef url = obj["url"]; + if (url.isString()) + { + current.url = url.toString(); + } + else + { + if (!obj.contains("solder")) { + qWarning() << "Json doesn't contain a valid url or solder key"; return; } - QJsonParseError parse_error; - QJsonDocument doc = QJsonDocument::fromJson(*response, &parse_error); - QJsonObject obj = doc.object(); - if(parse_error.error != QJsonParseError::NoError) + QJsonValueRef solderUrl = obj["solder"]; + if (solderUrl.isString()) { - qWarning() << "Error while parsing JSON response from Technic at " << parse_error.offset << " reason: " << parse_error.errorString(); - qWarning() << *response; - return; - } - if (!obj.contains("url")) - { - qWarning() << "Json doesn't contain an url key"; - return; - } - QJsonValueRef url = obj["url"]; - if (url.isString()) - { - current.url = url.toString(); + current.url = solderUrl.toString(); + current.isSolder = true; } else { - if (!obj.contains("solder")) - { - qWarning() << "Json doesn't contain a valid url or solder key"; - return; - } - QJsonValueRef solderUrl = obj["solder"]; - if (solderUrl.isString()) - { - current.url = solderUrl.toString(); - current.isSolder = true; - } - else - { - qWarning() << "Json doesn't contain a valid url or solder key"; - return; - } + qWarning() << "Json doesn't contain a valid url or solder key"; + return; } + } - current.minecraftVersion = Json::ensureString(obj, "minecraft", QString(), "__placeholder__"); - current.websiteUrl = Json::ensureString(obj, "platformUrl", QString(), "__placeholder__"); - current.author = Json::ensureString(obj, "user", QString(), "__placeholder__"); - current.description = Json::ensureString(obj, "description", QString(), "__placeholder__"); - current.metadataLoaded = true; - metadataLoaded(); - }); - netJob->start(); - } + current.minecraftVersion = Json::ensureString(obj, "minecraft", QString(), "__placeholder__"); + current.websiteUrl = Json::ensureString(obj, "platformUrl", QString(), "__placeholder__"); + current.author = Json::ensureString(obj, "user", QString(), "__placeholder__"); + current.description = Json::ensureString(obj, "description", QString(), "__placeholder__"); + current.metadataLoaded = true; + metadataLoaded(); + }); + netJob->start(); } // expects current.metadataLoaded to be true diff --git a/application/pages/modplatform/technic/TechnicPage.ui b/application/pages/modplatform/technic/TechnicPage.ui index 36ce2ecf..2ca45dd2 100644 --- a/application/pages/modplatform/technic/TechnicPage.ui +++ b/application/pages/modplatform/technic/TechnicPage.ui @@ -27,7 +27,11 @@ 0 - + + + Search and filter ... + + From a487234968591361482be18a7de050bc5e7b127d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Petr=20Mr=C3=A1zek?= Date: Sun, 20 Jun 2021 21:52:41 +0200 Subject: [PATCH 40/57] Revert "GH-3507 Modernize MacOS Icon" This reverts commit d08a2f00a2e403937b38254595cea6af5c5b236c. --- application/resources/MultiMC.icns | Bin 728772 -> 782703 bytes 1 file changed, 0 insertions(+), 0 deletions(-) diff --git a/application/resources/MultiMC.icns b/application/resources/MultiMC.icns index a7cab40dae7c387e60acbdfbc591e948f198c4c0..c4eb59d5de1e414bcfb1ade85063bd6c4c49edf3 100644 GIT binary patch literal 782703 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®r+bRpXa^h9B{ni`hDnmFRsR1M7Go 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

k3giqZJ}R|9@Kly#M@Y&?EXxd6zksy)aqdJ} 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

%n*m^PMgt*~VdYXBxu`O7GP;mf_qz2wVyJwWrd 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

4e$jKHDp>^W6Mxkpb%-{NfpOdIhL~VZ`U1U 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 literal 728772 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⩰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

NP-PV!Y?@m;!`{_+$r>WWsTEs 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

usgI{dlJD&4-K~n#e7kcMeKDe@Q=oND$heUt@{y ziUNmsjWMNQ#!MB(At4HPx z|02L3P@BSR*jyu1DI`^zdFvdJljxIv`%&$uQIBS9RpzsrXKdE4;gT+O{rfKeU3_*W zXyqL{K!PBKaLN%SfcySmD?*epHI7H~R1l34Nz41v))j}v#OqOr==AoT3$3>K|O03^^0d8y)K4?C6B_`ZqJutf50lR$wZUbjbC?kBE z7J(^{ARdv

3AmaY<2j>-%msXm)ko_ZI}MdpmmXLAvisqX~;7G{i0>n%WM{$I131 zbo18vAAggJk}Ha|fHp(Y>&)aDdP-!ZYm09EFmwl+$IizR_`@_ezY0}LqHU&6sO}4P zv)do?eL$DuXs^$LoW3_d-iLsis_VQg-QA4u*4-;n*VTn}wy|lxr2S8`2xGL%zh3Ui z1j$1R?lA#FEo-81ykzU$)L8tzfE&96u4R>L3IEDlzUiA_k>r_VMOZwk?+-XQIOf8) zLlm{`kcs#gbN37I?zR+3>-${EWDIwT-%sjKx7NWVZ*vat)`xc6h=o&3TW(2uF#m&g zkEpS7arg>{a!GoEu*yPaNW?O94nII+SHlL;!UuZ^*oxsRy_>x5(ER_z)n;g$$6mLZ z!(Q!BzTS1M-n%g9S^DcsUfUx{rIi~x`mNl@K%KVwx;oc?1E|0EH58u}KBi5)a31wi zvo)cfI}Da@voZ}D`(sY?Ruj~^!=-}L%J>4DzuTvOzLXGoCMR(nh+k6udf_ba zj|^YizOnZD<7O$hdE+XPMk$luai_0WDwf38%gy}3r1x%qHfWho@No6w?EblxBVYI} zyOD>$?(Xs+`t4x~GF2bws~MoF>P(sOw>BSMt1S|@%wUN_|%om z=J;fcbgX+=^kF;MdE`nJ1G`IOdl6 zsTmnLSs8;gzC=2y8CklihN%MVoeqZ%or@Vo7GL(C+aZi2Bnq5AsG-&wv&!}@uUVD& z%QzQP(~2so;apgH>J&Crn}nwfMXSKX5yvhVYlSzNY|XRV%t=X@H1=>Q7qd@hvEw^7 z%{eKG8H>ZsqZ$`kg?9SAM!mPm6$QRKeJA{ux!osTG2Jrx+;h?REq?Zqp{Lx@Pvz5N z=Wz-3p6uBW($x6e{MU9Nf-_~l+Ik@(JCw%81)j#xlhq8ujNWbT2)AXTidh&>DTJcV z=GB~hJWS3!P+_b0&HlLluQi}%UK~GNkn~)&Q{Fy?3=uoceci5UY=Z6SBwp0GZ9?e< zvZ?+#I}GPn*JUY`OUM?+Fd=)2^m*KWcG-aXeGU#B6Evo!`jv2vdbCE-+&(NS^ylw(cuFd?FT1^aMqwkvxKo0%@G z8P1`LXAb^U;`vJ(j8%Hd%cmMWK1XLd8Yn(|zp{hWI#ZuR?R^Y=d9%YRkx99%v3or_ z6DPNMI+)oW5g9RgUsIu^<{0)yC#Pg8(=zE}%i#!NO{Yx8W`)3O&8Ib*LziWEltV-h z;AwC&^QCYCm8s%_CA(Bs<>SeSUQ{29-}=w<8dP?ixoU@HO2Wahu&D9WkAR1W7EU(7 z__)`VSrlQkCU~umT&0&8v*DLBCSd7Xd*4vK6q$K|LW=K@f40lRwqnUq!kQ*y{w|lo zma9yMB6=oPkn5o;eSXZR!e8297|5$OOg?V&VbV#z0=!cK{+OoL$`Fq>s~(e%CSeMn znAU_TF07i~A7FR~I;vcgn=M#2PvR8|AYRnkS-E4t?fRMEQ;lX0X@@1a3PMS{)?|+q zA85EBdokKrEYoIX@68Q(4Q#a}k92Xe#>pj=C@yGEBu&W(VesMnvJoG?t0?ReVa&{{j9iFPr-qX`xadKKWh0>D+SLE-8tp00Be)tUImCzpMrV&;#@|HfLmtsa= z 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%0Aa+?1FBT4M| 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 z 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%0AkusDWP}R3r*q;5)YLI?mhq=;*LVM0 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 From f6d6e4c1c463073c44b991e56381d4c1d8e498f8 Mon Sep 17 00:00:00 2001 From: phit <2097483+phit@users.noreply.github.com> Date: Sun, 20 Jun 2021 22:52:10 +0200 Subject: [PATCH 41/57] NOISSUE Fix FTB Legacy Pack Selection --- application/pages/modplatform/legacy_ftb/Page.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/application/pages/modplatform/legacy_ftb/Page.cpp b/application/pages/modplatform/legacy_ftb/Page.cpp index 3bcc42c1..a438f76c 100644 --- a/application/pages/modplatform/legacy_ftb/Page.cpp +++ b/application/pages/modplatform/legacy_ftb/Page.cpp @@ -127,7 +127,7 @@ void Page::suggestCurrent() return; } - if(!selected.broken || !selectedVersion.isEmpty()) + if(selected.broken || selectedVersion.isEmpty()) { dialog->setSuggestedPack(); return; From e439ce6e0b8bed288a5a821ed5db80e42dd71e03 Mon Sep 17 00:00:00 2001 From: phit <2097483+phit@users.noreply.github.com> Date: Sun, 20 Jun 2021 22:55:09 +0200 Subject: [PATCH 42/57] NOISSUE Fix Modplatform Scrollbars properly --- application/pages/modplatform/atlauncher/AtlPage.cpp | 3 +++ application/pages/modplatform/flame/FlamePage.cpp | 5 ++--- application/pages/modplatform/ftb/FtbPage.cpp | 3 +++ 3 files changed, 8 insertions(+), 3 deletions(-) diff --git a/application/pages/modplatform/atlauncher/AtlPage.cpp b/application/pages/modplatform/atlauncher/AtlPage.cpp index 1b61ebd0..3c19804f 100644 --- a/application/pages/modplatform/atlauncher/AtlPage.cpp +++ b/application/pages/modplatform/atlauncher/AtlPage.cpp @@ -20,6 +20,9 @@ AtlPage::AtlPage(NewInstanceDialog* dialog, QWidget *parent) ui->packView->header()->hide(); ui->packView->setIndentation(0); + ui->versionSelectionBox->view()->setVerticalScrollBarPolicy(Qt::ScrollBarAsNeeded); + ui->versionSelectionBox->view()->parentWidget()->setMaximumHeight(300); + for(int i = 0; i < filterModel->getAvailableSortings().size(); i++) { ui->sortByBox->addItem(filterModel->getAvailableSortings().keys().at(i)); diff --git a/application/pages/modplatform/flame/FlamePage.cpp b/application/pages/modplatform/flame/FlamePage.cpp index 2dd58e16..ade58431 100644 --- a/application/pages/modplatform/flame/FlamePage.cpp +++ b/application/pages/modplatform/flame/FlamePage.cpp @@ -17,9 +17,8 @@ FlamePage::FlamePage(NewInstanceDialog* dialog, QWidget *parent) listModel = new Flame::ListModel(this); ui->packView->setModel(listModel); - ui->versionSelectionBox->setMaxVisibleItems(10); - // fix height for themes that dont respect max visible like fusion - ui->versionSelectionBox->setStyleSheet("combobox-popup: 0;"); + ui->versionSelectionBox->view()->setVerticalScrollBarPolicy(Qt::ScrollBarAsNeeded); + ui->versionSelectionBox->view()->parentWidget()->setMaximumHeight(300); // index is used to set the sorting with the curseforge api ui->sortByBox->addItem(tr("Sort by featured")); diff --git a/application/pages/modplatform/ftb/FtbPage.cpp b/application/pages/modplatform/ftb/FtbPage.cpp index b49982d5..b7f35c5d 100644 --- a/application/pages/modplatform/ftb/FtbPage.cpp +++ b/application/pages/modplatform/ftb/FtbPage.cpp @@ -23,6 +23,9 @@ FtbPage::FtbPage(NewInstanceDialog* dialog, QWidget *parent) ui->searchEdit->installEventFilter(this); + ui->versionSelectionBox->view()->setVerticalScrollBarPolicy(Qt::ScrollBarAsNeeded); + ui->versionSelectionBox->view()->parentWidget()->setMaximumHeight(300); + for(int i = 0; i < filterModel->getAvailableSortings().size(); i++) { ui->sortByBox->addItem(filterModel->getAvailableSortings().keys().at(i)); From a87c64d7d1fb505bb18f52a65a0d85c2476b07d7 Mon Sep 17 00:00:00 2001 From: Jamie Mansfield Date: Mon, 21 Jun 2021 15:26:10 +0100 Subject: [PATCH 43/57] NOISSUE Fix ATLauncher version selection combo box width Resolves a bug that was introduced with [1], furthermore and in specific relation to the intent of said commit, this brings the version selection combo box inline with other mod platforms. [1] f7c144c3932a18e1cd96e1ad7505e53ea706a47d --- application/pages/modplatform/atlauncher/AtlPage.ui | 9 +-------- 1 file changed, 1 insertion(+), 8 deletions(-) diff --git a/application/pages/modplatform/atlauncher/AtlPage.ui b/application/pages/modplatform/atlauncher/AtlPage.ui index 0860a873..f16c24b8 100644 --- a/application/pages/modplatform/atlauncher/AtlPage.ui +++ b/application/pages/modplatform/atlauncher/AtlPage.ui @@ -51,14 +51,7 @@ - - - - 0 - 0 - - - + From 74311a54cf2f423a160ce0999bd5ad7e5c62f243 Mon Sep 17 00:00:00 2001 From: Jamie Mansfield Date: Fri, 28 May 2021 15:03:14 +0100 Subject: [PATCH 44/57] NOISSUE Support ATLauncher optional mods --- .../atlauncher/ATLPackInstallTask.cpp | 21 ++- .../atlauncher/ATLPackInstallTask.h | 5 + .../atlauncher/ATLPackManifest.cpp | 3 + .../modplatform/atlauncher/ATLPackManifest.h | 3 + application/CMakeLists.txt | 5 + .../atlauncher/AtlOptionalModDialog.cpp | 138 ++++++++++++++++++ .../atlauncher/AtlOptionalModDialog.h | 60 ++++++++ .../atlauncher/AtlOptionalModDialog.ui | 65 +++++++++ .../pages/modplatform/atlauncher/AtlPage.cpp | 7 + .../pages/modplatform/atlauncher/AtlPage.h | 1 + 10 files changed, 305 insertions(+), 3 deletions(-) create mode 100644 application/pages/modplatform/atlauncher/AtlOptionalModDialog.cpp create mode 100644 application/pages/modplatform/atlauncher/AtlOptionalModDialog.h create mode 100644 application/pages/modplatform/atlauncher/AtlOptionalModDialog.ui diff --git a/api/logic/modplatform/atlauncher/ATLPackInstallTask.cpp b/api/logic/modplatform/atlauncher/ATLPackInstallTask.cpp index 89c4dfd3..89829c05 100644 --- a/api/logic/modplatform/atlauncher/ATLPackInstallTask.cpp +++ b/api/logic/modplatform/atlauncher/ATLPackInstallTask.cpp @@ -457,16 +457,31 @@ void PackInstallTask::extractConfigs() void PackInstallTask::downloadMods() { qDebug() << "PackInstallTask::installMods: " << QThread::currentThreadId(); + + QVector optionalMods; + for (const auto& mod : m_version.mods) { + if (mod.optional) { + optionalMods.push_back(mod); + } + } + + // Select optional mods, if pack contains any + QVector selectedMods; + if (!optionalMods.isEmpty()) { + setStatus(tr("Selecting optional mods...")); + selectedMods = m_support->chooseOptionalMods(optionalMods); + } + setStatus(tr("Downloading mods...")); jarmods.clear(); jobPtr.reset(new NetJob(tr("Mod download"))); for(const auto& mod : m_version.mods) { // skip non-client mods - if (!mod.client) continue; + if(!mod.client) continue; - // skip optional mods for now - if(mod.optional) continue; + // skip optional mods that were not selected + if(mod.optional && !selectedMods.contains(mod.name)) continue; QString url; switch(mod.download) { diff --git a/api/logic/modplatform/atlauncher/ATLPackInstallTask.h b/api/logic/modplatform/atlauncher/ATLPackInstallTask.h index 3647e471..8233c376 100644 --- a/api/logic/modplatform/atlauncher/ATLPackInstallTask.h +++ b/api/logic/modplatform/atlauncher/ATLPackInstallTask.h @@ -18,6 +18,11 @@ namespace ATLauncher { class MULTIMC_LOGIC_EXPORT UserInteractionSupport { public: + /** + * Requests a user interaction to select which optional mods should be installed. + */ + virtual QVector chooseOptionalMods(QVector mods) = 0; + /** * Requests a user interaction to select a component version from a given version list * and constrained to a given Minecraft version. diff --git a/api/logic/modplatform/atlauncher/ATLPackManifest.cpp b/api/logic/modplatform/atlauncher/ATLPackManifest.cpp index 57cc52b6..149cb9c1 100644 --- a/api/logic/modplatform/atlauncher/ATLPackManifest.cpp +++ b/api/logic/modplatform/atlauncher/ATLPackManifest.cpp @@ -143,7 +143,10 @@ static void loadVersionMod(ATLauncher::VersionMod & p, QJsonObject & obj) { p.decompFile = Json::requireString(obj, "decompFile"); } + p.description = Json::ensureString(obj, QString("description"), ""); p.optional = Json::ensureBoolean(obj, QString("optional"), false); + p.recommended = Json::ensureBoolean(obj, QString("recommended"), false); + p.selected = Json::ensureBoolean(obj, QString("selected"), false); p.client = Json::ensureBoolean(obj, QString("client"), false); } diff --git a/api/logic/modplatform/atlauncher/ATLPackManifest.h b/api/logic/modplatform/atlauncher/ATLPackManifest.h index 937106a5..48e1d344 100644 --- a/api/logic/modplatform/atlauncher/ATLPackManifest.h +++ b/api/logic/modplatform/atlauncher/ATLPackManifest.h @@ -86,7 +86,10 @@ struct VersionMod QString decompType_raw; QString decompFile; + QString description; bool optional; + bool recommended; + bool selected; bool client; }; diff --git a/application/CMakeLists.txt b/application/CMakeLists.txt index c5be22d0..ab2b9960 100644 --- a/application/CMakeLists.txt +++ b/application/CMakeLists.txt @@ -129,6 +129,8 @@ SET(MULTIMC_SOURCES pages/modplatform/atlauncher/AtlFilterModel.h pages/modplatform/atlauncher/AtlListModel.cpp pages/modplatform/atlauncher/AtlListModel.h + pages/modplatform/atlauncher/AtlOptionalModDialog.cpp + pages/modplatform/atlauncher/AtlOptionalModDialog.h pages/modplatform/atlauncher/AtlPage.cpp pages/modplatform/atlauncher/AtlPage.h @@ -278,6 +280,9 @@ SET(MULTIMC_UIS pages/modplatform/technic/TechnicPage.ui pages/modplatform/ImportPage.ui + # Platform Dialogs + pages/modplatform/atlauncher/AtlOptionalModDialog.ui + # Dialogs dialogs/CopyInstanceDialog.ui dialogs/NewComponentDialog.ui diff --git a/application/pages/modplatform/atlauncher/AtlOptionalModDialog.cpp b/application/pages/modplatform/atlauncher/AtlOptionalModDialog.cpp new file mode 100644 index 00000000..129d9fed --- /dev/null +++ b/application/pages/modplatform/atlauncher/AtlOptionalModDialog.cpp @@ -0,0 +1,138 @@ +#include "AtlOptionalModDialog.h" +#include "ui_AtlOptionalModDialog.h" + +AtlOptionalModListModel::AtlOptionalModListModel(QWidget *parent, QVector mods) + : QAbstractListModel(parent), m_mods(mods) { + + for (const auto& mod : mods) { + m_selection[mod.name] = mod.selected; + } +} + +QVector AtlOptionalModListModel::getResult() { + QVector result; + + for (const auto& mod : m_mods) { + if (m_selection[mod.name]) { + result.push_back(mod.name); + } + } + + return result; +} + +int AtlOptionalModListModel::rowCount(const QModelIndex &parent) const { + return m_mods.size(); +} + +int AtlOptionalModListModel::columnCount(const QModelIndex &parent) const { + // Enabled, Name, Description + return 3; +} + +QVariant AtlOptionalModListModel::data(const QModelIndex &index, int role) const { + auto row = index.row(); + auto mod = m_mods.at(row); + + if (role == Qt::DisplayRole) { + if (index.column() == NameColumn) { + return mod.name; + } + if (index.column() == DescriptionColumn) { + return mod.description; + } + } + else if (role == Qt::ToolTipRole) { + if (index.column() == DescriptionColumn) { + return mod.description; + } + } + else if (role == Qt::CheckStateRole) { + if (index.column() == EnabledColumn) { + return m_selection[mod.name] ? Qt::Checked : Qt::Unchecked; + } + } + + return QVariant(); +} + +bool AtlOptionalModListModel::setData(const QModelIndex &index, const QVariant &value, int role) { + if (role == Qt::CheckStateRole) { + auto row = index.row(); + auto mod = m_mods.at(row); + + // toggle the state + m_selection[mod.name] = !m_selection[mod.name]; + + emit dataChanged(AtlOptionalModListModel::index(index.row(), EnabledColumn), + AtlOptionalModListModel::index(index.row(), EnabledColumn)); + return true; + } + + return false; +} + +QVariant AtlOptionalModListModel::headerData(int section, Qt::Orientation orientation, int role) const { + if (role == Qt::DisplayRole && orientation == Qt::Horizontal) { + switch (section) { + case EnabledColumn: + return QString(); + case NameColumn: + return QString("Name"); + case DescriptionColumn: + return QString("Description"); + } + } + + return QVariant(); +} + +Qt::ItemFlags AtlOptionalModListModel::flags(const QModelIndex &index) const { + auto flags = QAbstractListModel::flags(index); + if (index.isValid() && index.column() == EnabledColumn) { + flags |= Qt::ItemIsUserCheckable; + } + return flags; +} + +void AtlOptionalModListModel::selectRecommended() { + for (const auto& mod : m_mods) { + m_selection[mod.name] = mod.recommended; + } + + emit dataChanged(AtlOptionalModListModel::index(0, EnabledColumn), + AtlOptionalModListModel::index(m_mods.size() - 1, EnabledColumn)); +} + +void AtlOptionalModListModel::clearAll() { + for (const auto& mod : m_mods) { + m_selection[mod.name] = false; + } + + emit dataChanged(AtlOptionalModListModel::index(0, EnabledColumn), + AtlOptionalModListModel::index(m_mods.size() - 1, EnabledColumn)); +} + + +AtlOptionalModDialog::AtlOptionalModDialog(QWidget *parent, QVector mods) + : QDialog(parent), ui(new Ui::AtlOptionalModDialog) { + ui->setupUi(this); + + listModel = new AtlOptionalModListModel(this, mods); + ui->treeView->setModel(listModel); + + ui->treeView->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff); + ui->treeView->header()->setSectionResizeMode( + AtlOptionalModListModel::NameColumn, QHeaderView::ResizeToContents); + ui->treeView->header()->setSectionResizeMode( + AtlOptionalModListModel::DescriptionColumn, QHeaderView::Stretch); + + connect(ui->selectRecommendedButton, &QPushButton::pressed, + listModel, &AtlOptionalModListModel::selectRecommended); + connect(ui->clearAllButton, &QPushButton::pressed, + listModel, &AtlOptionalModListModel::clearAll); +} + +AtlOptionalModDialog::~AtlOptionalModDialog() { + delete ui; +} diff --git a/application/pages/modplatform/atlauncher/AtlOptionalModDialog.h b/application/pages/modplatform/atlauncher/AtlOptionalModDialog.h new file mode 100644 index 00000000..8b0dbdb6 --- /dev/null +++ b/application/pages/modplatform/atlauncher/AtlOptionalModDialog.h @@ -0,0 +1,60 @@ +#pragma once + +#include +#include + +#include "modplatform/atlauncher/ATLPackIndex.h" + +namespace Ui { +class AtlOptionalModDialog; +} + +class AtlOptionalModListModel : public QAbstractListModel { + Q_OBJECT + +public: + enum Columns + { + EnabledColumn = 0, + NameColumn, + DescriptionColumn, + }; + + AtlOptionalModListModel(QWidget *parent, QVector mods); + + QVector getResult(); + + int rowCount(const QModelIndex &parent) const override; + int columnCount(const QModelIndex &parent) const override; + + QVariant data(const QModelIndex &index, int role) const override; + bool setData(const QModelIndex &index, const QVariant &value, int role) override; + QVariant headerData(int section, Qt::Orientation orientation, int role) const override; + + Qt::ItemFlags flags(const QModelIndex &index) const override; + +public slots: + void selectRecommended(); + void clearAll(); + +private: + QVector m_mods; + QMap m_selection; +}; + +class AtlOptionalModDialog : public QDialog { + Q_OBJECT + +public: + AtlOptionalModDialog(QWidget *parent, QVector mods); + ~AtlOptionalModDialog() override; + + QVector getResult() { + return listModel->getResult(); + } + +private: + Ui::AtlOptionalModDialog *ui; + + AtlOptionalModListModel *listModel; +}; diff --git a/application/pages/modplatform/atlauncher/AtlOptionalModDialog.ui b/application/pages/modplatform/atlauncher/AtlOptionalModDialog.ui new file mode 100644 index 00000000..5d3193a4 --- /dev/null +++ b/application/pages/modplatform/atlauncher/AtlOptionalModDialog.ui @@ -0,0 +1,65 @@ + + + AtlOptionalModDialog + + + + 0 + 0 + 550 + 310 + + + + Select Mods To Install + + + + + + Install + + + true + + + + + + + Select Recommended + + + + + + + false + + + Use Share Code + + + + + + + Clear All + + + + + + + + + + + ModListView + QTreeView +

widgets/ModListView.h
+ + + + + diff --git a/application/pages/modplatform/atlauncher/AtlPage.cpp b/application/pages/modplatform/atlauncher/AtlPage.cpp index 3c19804f..9fdf111f 100644 --- a/application/pages/modplatform/atlauncher/AtlPage.cpp +++ b/application/pages/modplatform/atlauncher/AtlPage.cpp @@ -2,6 +2,7 @@ #include "ui_AtlPage.h" #include "dialogs/NewInstanceDialog.h" +#include "AtlOptionalModDialog.h" #include #include #include @@ -131,6 +132,12 @@ void AtlPage::onVersionSelectionChanged(QString data) suggestCurrent(); } +QVector AtlPage::chooseOptionalMods(QVector mods) { + AtlOptionalModDialog optionalModDialog(this, mods); + optionalModDialog.exec(); + return optionalModDialog.getResult(); +} + QString AtlPage::chooseVersion(Meta::VersionListPtr vlist, QString minecraftVersion) { VersionSelectDialog vselect(vlist.get(), "Choose Version", MMC->activeWindow(), false); if (minecraftVersion != Q_NULLPTR) { diff --git a/application/pages/modplatform/atlauncher/AtlPage.h b/application/pages/modplatform/atlauncher/AtlPage.h index 18f8b1c6..932ec6a6 100644 --- a/application/pages/modplatform/atlauncher/AtlPage.h +++ b/application/pages/modplatform/atlauncher/AtlPage.h @@ -63,6 +63,7 @@ private: void suggestCurrent(); QString chooseVersion(Meta::VersionListPtr vlist, QString minecraftVersion) override; + QVector chooseOptionalMods(QVector mods) override; private slots: void triggerSearch(); From 4ba0c9c2986d9fb133db923d2da60de9272ccc0a Mon Sep 17 00:00:00 2001 From: Jamie Mansfield Date: Fri, 28 May 2021 23:10:02 +0100 Subject: [PATCH 45/57] NOISSUE Support mod grouping and dependencies --- .../atlauncher/ATLPackManifest.cpp | 13 +++ .../modplatform/atlauncher/ATLPackManifest.h | 8 ++ .../atlauncher/AtlOptionalModDialog.cpp | 83 +++++++++++++++++-- .../atlauncher/AtlOptionalModDialog.h | 6 ++ 4 files changed, 103 insertions(+), 7 deletions(-) diff --git a/api/logic/modplatform/atlauncher/ATLPackManifest.cpp b/api/logic/modplatform/atlauncher/ATLPackManifest.cpp index 149cb9c1..f28fd35c 100644 --- a/api/logic/modplatform/atlauncher/ATLPackManifest.cpp +++ b/api/logic/modplatform/atlauncher/ATLPackManifest.cpp @@ -147,7 +147,20 @@ static void loadVersionMod(ATLauncher::VersionMod & p, QJsonObject & obj) { p.optional = Json::ensureBoolean(obj, QString("optional"), false); p.recommended = Json::ensureBoolean(obj, QString("recommended"), false); p.selected = Json::ensureBoolean(obj, QString("selected"), false); + p.hidden = Json::ensureBoolean(obj, QString("hidden"), false); + p.library = Json::ensureBoolean(obj, QString("library"), false); + p.group = Json::ensureString(obj, QString("group"), ""); + if(obj.contains("depends")) { + auto dependsArr = Json::requireArray(obj, "depends"); + for (const auto depends : dependsArr) { + p.depends.append(Json::requireString(depends)); + } + } + p.client = Json::ensureBoolean(obj, QString("client"), false); + + // computed + p.effectively_hidden = p.hidden || p.library; } void ATLauncher::loadVersion(PackVersion & v, QJsonObject & obj) diff --git a/api/logic/modplatform/atlauncher/ATLPackManifest.h b/api/logic/modplatform/atlauncher/ATLPackManifest.h index 48e1d344..376587b0 100644 --- a/api/logic/modplatform/atlauncher/ATLPackManifest.h +++ b/api/logic/modplatform/atlauncher/ATLPackManifest.h @@ -90,7 +90,15 @@ struct VersionMod bool optional; bool recommended; bool selected; + bool hidden; + bool library; + QString group; + QVector depends; + bool client; + + // computed + bool effectively_hidden; }; struct PackVersion diff --git a/application/pages/modplatform/atlauncher/AtlOptionalModDialog.cpp b/application/pages/modplatform/atlauncher/AtlOptionalModDialog.cpp index 129d9fed..cffe5d55 100644 --- a/application/pages/modplatform/atlauncher/AtlOptionalModDialog.cpp +++ b/application/pages/modplatform/atlauncher/AtlOptionalModDialog.cpp @@ -4,8 +4,16 @@ AtlOptionalModListModel::AtlOptionalModListModel(QWidget *parent, QVector mods) : QAbstractListModel(parent), m_mods(mods) { - for (const auto& mod : mods) { - m_selection[mod.name] = mod.selected; + // fill mod index + for (int i = 0; i < m_mods.size(); i++) { + auto mod = m_mods.at(i); + m_index[mod.name] = i; + } + // set initial state + for (int i = 0; i < m_mods.size(); i++) { + auto mod = m_mods.at(i); + m_selection[mod.name] = false; + setMod(mod, i, mod.selected, false); } } @@ -61,11 +69,7 @@ bool AtlOptionalModListModel::setData(const QModelIndex &index, const QVariant & auto row = index.row(); auto mod = m_mods.at(row); - // toggle the state - m_selection[mod.name] = !m_selection[mod.name]; - - emit dataChanged(AtlOptionalModListModel::index(index.row(), EnabledColumn), - AtlOptionalModListModel::index(index.row(), EnabledColumn)); + toggleMod(mod, row); return true; } @@ -113,6 +117,71 @@ void AtlOptionalModListModel::clearAll() { AtlOptionalModListModel::index(m_mods.size() - 1, EnabledColumn)); } +void AtlOptionalModListModel::toggleMod(ATLauncher::VersionMod mod, int index) { + setMod(mod, index, !m_selection[mod.name]); +} + +void AtlOptionalModListModel::setMod(ATLauncher::VersionMod mod, int index, bool enable, bool shouldEmit) { + if (m_selection[mod.name] == enable) return; + + m_selection[mod.name] = enable; + + // disable other mods in the group, if applicable + if (enable && !mod.group.isEmpty()) { + for (int i = 0; i < m_mods.size(); i++) { + if (index == i) continue; + auto other = m_mods.at(i); + + if (mod.group == other.group) { + setMod(other, i, false, shouldEmit); + } + } + } + + for (const auto& dependencyName : mod.depends) { + auto dependencyIndex = m_index[dependencyName]; + auto dependencyMod = m_mods.at(dependencyIndex); + + // enable/disable dependencies + if (enable) { + setMod(dependencyMod, dependencyIndex, true, shouldEmit); + } + + // if the dependency is 'effectively hidden', then track which mods + // depend on it - so we can efficiently disable it when no more dependents + // depend on it. + auto dependants = m_dependants[dependencyName]; + + if (enable) { + dependants.append(mod.name); + } + else { + dependants.removeAll(mod.name); + + // if there are no longer any dependents, let's disable the mod + if (dependencyMod.effectively_hidden && dependants.isEmpty()) { + setMod(dependencyMod, dependencyIndex, false, shouldEmit); + } + } + } + + // disable mods that depend on this one, if disabling + if (!enable) { + auto dependants = m_dependants[mod.name]; + for (const auto& dependencyName : dependants) { + auto dependencyIndex = m_index[dependencyName]; + auto dependencyMod = m_mods.at(dependencyIndex); + + setMod(dependencyMod, dependencyIndex, false, shouldEmit); + } + } + + if (shouldEmit) { + emit dataChanged(AtlOptionalModListModel::index(index, EnabledColumn), + AtlOptionalModListModel::index(index, EnabledColumn)); + } +} + AtlOptionalModDialog::AtlOptionalModDialog(QWidget *parent, QVector mods) : QDialog(parent), ui(new Ui::AtlOptionalModDialog) { diff --git a/application/pages/modplatform/atlauncher/AtlOptionalModDialog.h b/application/pages/modplatform/atlauncher/AtlOptionalModDialog.h index 8b0dbdb6..a1df43f6 100644 --- a/application/pages/modplatform/atlauncher/AtlOptionalModDialog.h +++ b/application/pages/modplatform/atlauncher/AtlOptionalModDialog.h @@ -37,9 +37,15 @@ public slots: void selectRecommended(); void clearAll(); +private: + void toggleMod(ATLauncher::VersionMod mod, int index); + void setMod(ATLauncher::VersionMod mod, int index, bool enable, bool shouldEmit = true); + private: QVector m_mods; QMap m_selection; + QMap m_index; + QMap> m_dependants; }; class AtlOptionalModDialog : public QDialog { From ba8af797a9ba5dc102febd7b7d032f03434c5afe Mon Sep 17 00:00:00 2001 From: Colbie Dison Date: Tue, 22 Jun 2021 11:56:05 -0500 Subject: [PATCH 46/57] Add detection of manually installed JDKs in /opt --- api/logic/java/JavaUtils.cpp | 3 +++ 1 file changed, 3 insertions(+) diff --git a/api/logic/java/JavaUtils.cpp b/api/logic/java/JavaUtils.cpp index 5f004a10..ff6a9ac5 100644 --- a/api/logic/java/JavaUtils.cpp +++ b/api/logic/java/JavaUtils.cpp @@ -381,6 +381,9 @@ QList JavaUtils::FindJavaPaths() scanJavaDir("/usr/lib32/jvm"); // javas stored in MultiMC's folder scanJavaDir("java"); + // manually installed JDKs in /opt + scanJavaDir("/opt/jdk"); + scanJavaDir("/opt/jdks"); return javas; } #else From d8598d6901cc4c7b58d9afdeeba868107ec0789d Mon Sep 17 00:00:00 2001 From: Jamie Mansfield Date: Wed, 23 Jun 2021 09:55:09 +0100 Subject: [PATCH 47/57] NOISSUE Use MiB suffix for Java memory options --- application/pages/global/JavaPage.cpp | 4 ++-- application/pages/global/JavaPage.ui | 6 +++--- application/pages/instance/InstanceSettingsPage.cpp | 2 +- application/pages/instance/InstanceSettingsPage.ui | 6 +++--- application/widgets/JavaSettingsWidget.cpp | 2 +- libraries/systeminfo/include/sys.h | 2 +- 6 files changed, 11 insertions(+), 11 deletions(-) diff --git a/application/pages/global/JavaPage.cpp b/application/pages/global/JavaPage.cpp index 95271c91..cde0e035 100644 --- a/application/pages/global/JavaPage.cpp +++ b/application/pages/global/JavaPage.cpp @@ -37,8 +37,8 @@ JavaPage::JavaPage(QWidget *parent) : QWidget(parent), ui(new Ui::JavaPage) ui->setupUi(this); ui->tabWidget->tabBar()->hide(); - auto sysMB = Sys::getSystemRam() / Sys::megabyte; - ui->maxMemSpinBox->setMaximum(sysMB); + auto sysMiB = Sys::getSystemRam() / Sys::mebibyte; + ui->maxMemSpinBox->setMaximum(sysMiB); loadSettings(); } diff --git a/application/pages/global/JavaPage.ui b/application/pages/global/JavaPage.ui index 201b310c..b67e9994 100644 --- a/application/pages/global/JavaPage.ui +++ b/application/pages/global/JavaPage.ui @@ -51,7 +51,7 @@ The maximum amount of memory Minecraft is allowed to use. - MB + MiB 128 @@ -87,7 +87,7 @@ The amount of memory Minecraft is started with. - MB + MiB 128 @@ -116,7 +116,7 @@ The amount of memory available to store loaded Java classes. - MB + MiB 64 diff --git a/application/pages/instance/InstanceSettingsPage.cpp b/application/pages/instance/InstanceSettingsPage.cpp index 00fc19af..7bd424c0 100644 --- a/application/pages/instance/InstanceSettingsPage.cpp +++ b/application/pages/instance/InstanceSettingsPage.cpp @@ -19,7 +19,7 @@ InstanceSettingsPage::InstanceSettingsPage(BaseInstance *inst, QWidget *parent) { m_settings = inst->settings(); ui->setupUi(this); - auto sysMB = Sys::getSystemRam() / Sys::megabyte; + auto sysMB = Sys::getSystemRam() / Sys::mebibyte; ui->maxMemSpinBox->setMaximum(sysMB); connect(ui->openGlobalJavaSettingsButton, &QCommandLinkButton::clicked, this, &InstanceSettingsPage::globalSettingsButtonClicked); connect(MMC, &MultiMC::globalSettingsAboutToOpen, this, &InstanceSettingsPage::applySettings); diff --git a/application/pages/instance/InstanceSettingsPage.ui b/application/pages/instance/InstanceSettingsPage.ui index 29024b65..e569ce56 100644 --- a/application/pages/instance/InstanceSettingsPage.ui +++ b/application/pages/instance/InstanceSettingsPage.ui @@ -116,7 +116,7 @@ The maximum amount of memory Minecraft is allowed to use. - MB + MiB 128 @@ -138,7 +138,7 @@ The amount of memory Minecraft is started with. - MB + MiB 128 @@ -160,7 +160,7 @@ The amount of memory available to store loaded Java classes. - MB + MiB 64 diff --git a/application/widgets/JavaSettingsWidget.cpp b/application/widgets/JavaSettingsWidget.cpp index a11dd1aa..7f53dc23 100644 --- a/application/widgets/JavaSettingsWidget.cpp +++ b/application/widgets/JavaSettingsWidget.cpp @@ -19,7 +19,7 @@ JavaSettingsWidget::JavaSettingsWidget(QWidget* parent) : QWidget(parent) { - m_availableMemory = Sys::getSystemRam() / Sys::megabyte; + m_availableMemory = Sys::getSystemRam() / Sys::mebibyte; goodIcon = MMC->getThemedIcon("status-good"); yellowIcon = MMC->getThemedIcon("status-yellow"); diff --git a/libraries/systeminfo/include/sys.h b/libraries/systeminfo/include/sys.h index 7980dfdf..914d2555 100644 --- a/libraries/systeminfo/include/sys.h +++ b/libraries/systeminfo/include/sys.h @@ -3,7 +3,7 @@ namespace Sys { -const uint64_t megabyte = 1024ull * 1024ull; +const uint64_t mebibyte = 1024ull * 1024ull; struct KernelInfo { QString kernelName; From c77f5285e3ff3d19d0546419ef9300da8932402f Mon Sep 17 00:00:00 2001 From: Jamie Mansfield Date: Wed, 23 Jun 2021 15:49:31 +0100 Subject: [PATCH 48/57] NOISSUE Close optional mod dialog with Install button This was a silly ommision I made. --- .../pages/modplatform/atlauncher/AtlOptionalModDialog.cpp | 2 ++ 1 file changed, 2 insertions(+) diff --git a/application/pages/modplatform/atlauncher/AtlOptionalModDialog.cpp b/application/pages/modplatform/atlauncher/AtlOptionalModDialog.cpp index cffe5d55..14bbd18b 100644 --- a/application/pages/modplatform/atlauncher/AtlOptionalModDialog.cpp +++ b/application/pages/modplatform/atlauncher/AtlOptionalModDialog.cpp @@ -200,6 +200,8 @@ AtlOptionalModDialog::AtlOptionalModDialog(QWidget *parent, QVectorclearAllButton, &QPushButton::pressed, listModel, &AtlOptionalModListModel::clearAll); + connect(ui->installButton, &QPushButton::pressed, + this, &QDialog::close); } AtlOptionalModDialog::~AtlOptionalModDialog() { From 7c0fdaa7303125b26d0a6882d4616016c3923bca Mon Sep 17 00:00:00 2001 From: Jamie Mansfield Date: Wed, 23 Jun 2021 18:19:48 +0100 Subject: [PATCH 49/57] NOISSUE Check mod and config checksums for ATLauncher --- .../atlauncher/ATLPackInstallTask.cpp | 20 ++++++++++++++++++- .../atlauncher/ATLPackManifest.cpp | 11 +++++++++- .../modplatform/atlauncher/ATLPackManifest.h | 7 +++++++ 3 files changed, 36 insertions(+), 2 deletions(-) diff --git a/api/logic/modplatform/atlauncher/ATLPackInstallTask.cpp b/api/logic/modplatform/atlauncher/ATLPackInstallTask.cpp index 89829c05..dac80e8c 100644 --- a/api/logic/modplatform/atlauncher/ATLPackInstallTask.cpp +++ b/api/logic/modplatform/atlauncher/ATLPackInstallTask.cpp @@ -4,6 +4,7 @@ #include #include #include +#include #include "ATLPackInstallTask.h" #include "BuildConfig.h" @@ -407,7 +408,12 @@ void PackInstallTask::installConfigs() auto entry = ENV.metacache()->resolveEntry("ATLauncherPacks", path); entry->setStale(true); - jobPtr->addNetAction(Net::Download::makeCached(url, entry)); + auto dl = Net::Download::makeCached(url, entry); + if (!m_version.configs.sha1.isEmpty()) { + auto rawSha1 = QByteArray::fromHex(m_version.configs.sha1.toLatin1()); + dl->addValidator(new Net::ChecksumValidator(QCryptographicHash::Sha1, rawSha1)); + } + jobPtr->addNetAction(dl); archivePath = entry->getFullPath(); connect(jobPtr.get(), &NetJob::succeeded, this, [&]() @@ -508,6 +514,10 @@ void PackInstallTask::downloadMods() modsToExtract.insert(entry->getFullPath(), mod); auto dl = Net::Download::makeCached(url, entry); + if (!mod.md5.isEmpty()) { + auto rawMd5 = QByteArray::fromHex(mod.md5.toLatin1()); + dl->addValidator(new Net::ChecksumValidator(QCryptographicHash::Md5, rawMd5)); + } jobPtr->addNetAction(dl); } else if(mod.type == ModType::Decomp) { @@ -516,6 +526,10 @@ void PackInstallTask::downloadMods() modsToDecomp.insert(entry->getFullPath(), mod); auto dl = Net::Download::makeCached(url, entry); + if (!mod.md5.isEmpty()) { + auto rawMd5 = QByteArray::fromHex(mod.md5.toLatin1()); + dl->addValidator(new Net::ChecksumValidator(QCryptographicHash::Md5, rawMd5)); + } jobPtr->addNetAction(dl); } else { @@ -526,6 +540,10 @@ void PackInstallTask::downloadMods() entry->setStale(true); auto dl = Net::Download::makeCached(url, entry); + if (!mod.md5.isEmpty()) { + auto rawMd5 = QByteArray::fromHex(mod.md5.toLatin1()); + dl->addValidator(new Net::ChecksumValidator(QCryptographicHash::Md5, rawMd5)); + } jobPtr->addNetAction(dl); auto path = FS::PathCombine(m_stagingPath, "minecraft", relpath, mod.file); diff --git a/api/logic/modplatform/atlauncher/ATLPackManifest.cpp b/api/logic/modplatform/atlauncher/ATLPackManifest.cpp index f28fd35c..e25d8346 100644 --- a/api/logic/modplatform/atlauncher/ATLPackManifest.cpp +++ b/api/logic/modplatform/atlauncher/ATLPackManifest.cpp @@ -109,6 +109,11 @@ static void loadVersionLibrary(ATLauncher::VersionLibrary & p, QJsonObject & obj p.server = Json::ensureString(obj, "server", ""); } +static void loadVersionConfigs(ATLauncher::VersionConfigs & p, QJsonObject & obj) { + p.filesize = Json::requireInteger(obj, "filesize"); + p.sha1 = Json::requireString(obj, "sha1"); +} + static void loadVersionMod(ATLauncher::VersionMod & p, QJsonObject & obj) { p.name = Json::requireString(obj, "name"); p.version = Json::requireString(obj, "version"); @@ -195,7 +200,6 @@ void ATLauncher::loadVersion(PackVersion & v, QJsonObject & obj) } } - if(obj.contains("mods")) { auto mods = Json::requireArray(obj, "mods"); for (const auto modRaw : mods) @@ -206,4 +210,9 @@ void ATLauncher::loadVersion(PackVersion & v, QJsonObject & obj) v.mods.append(mod); } } + + if(obj.contains("configs")) { + auto configsObj = Json::requireObject(obj, "configs"); + loadVersionConfigs(v.configs, configsObj); + } } diff --git a/api/logic/modplatform/atlauncher/ATLPackManifest.h b/api/logic/modplatform/atlauncher/ATLPackManifest.h index 376587b0..17821e4c 100644 --- a/api/logic/modplatform/atlauncher/ATLPackManifest.h +++ b/api/logic/modplatform/atlauncher/ATLPackManifest.h @@ -101,6 +101,12 @@ struct VersionMod bool effectively_hidden; }; +struct VersionConfigs +{ + int filesize; + QString sha1; +}; + struct PackVersion { QString version; @@ -112,6 +118,7 @@ struct PackVersion VersionLoader loader; QVector libraries; QVector mods; + VersionConfigs configs; }; MULTIMC_LOGIC_EXPORT void loadVersion(PackVersion & v, QJsonObject & obj); From a20a7e987fcc6e2d43a1686a175447495245615c Mon Sep 17 00:00:00 2001 From: Jamie Mansfield Date: Wed, 23 Jun 2021 21:24:25 +0100 Subject: [PATCH 50/57] NOISSUE Fail launch if minimum Java requirement is not met This will fail launch in the following conditions: 1. A version greater than or equal to Minecraft 17w13a, and less than 21w19a - and the Java version is less than 8. 2. A version greater than or equal to Minecraft 21w19a - and the Java version is less than 16. --- api/logic/CMakeLists.txt | 2 ++ api/logic/minecraft/MinecraftInstance.cpp | 6 ++++ api/logic/minecraft/VersionFilterData.cpp | 3 ++ api/logic/minecraft/VersionFilterData.h | 4 +++ .../minecraft/launch/VerifyJavaInstall.cpp | 34 +++++++++++++++++++ .../minecraft/launch/VerifyJavaInstall.h | 17 ++++++++++ 6 files changed, 66 insertions(+) create mode 100644 api/logic/minecraft/launch/VerifyJavaInstall.cpp create mode 100644 api/logic/minecraft/launch/VerifyJavaInstall.h diff --git a/api/logic/CMakeLists.txt b/api/logic/CMakeLists.txt index 17e22458..6d269714 100644 --- a/api/logic/CMakeLists.txt +++ b/api/logic/CMakeLists.txt @@ -246,6 +246,8 @@ set(MINECRAFT_SOURCES minecraft/launch/ReconstructAssets.h minecraft/launch/ScanModFolders.cpp minecraft/launch/ScanModFolders.h + minecraft/launch/VerifyJavaInstall.cpp + minecraft/launch/VerifyJavaInstall.h minecraft/legacy/LegacyModList.h minecraft/legacy/LegacyModList.cpp diff --git a/api/logic/minecraft/MinecraftInstance.cpp b/api/logic/minecraft/MinecraftInstance.cpp index fdf9bd61..ea1e47b6 100644 --- a/api/logic/minecraft/MinecraftInstance.cpp +++ b/api/logic/minecraft/MinecraftInstance.cpp @@ -23,6 +23,7 @@ #include "minecraft/launch/ClaimAccount.h" #include "minecraft/launch/ReconstructAssets.h" #include "minecraft/launch/ScanModFolders.h" +#include "minecraft/launch/VerifyJavaInstall.h" #include "java/launch/CheckJava.h" #include "java/JavaUtils.h" #include "meta/Index.h" @@ -915,6 +916,11 @@ shared_qobject_ptr MinecraftInstance::createLaunchTask(AuthSessionPt process->appendStep(new ReconstructAssets(pptr)); } + // verify that minimum Java requirements are met + { + process->appendStep(new VerifyJavaInstall(pptr)); + } + { // actually launch the game auto method = launchMethod(); diff --git a/api/logic/minecraft/VersionFilterData.cpp b/api/logic/minecraft/VersionFilterData.cpp index a47fc0a0..38e7b60c 100644 --- a/api/logic/minecraft/VersionFilterData.cpp +++ b/api/logic/minecraft/VersionFilterData.cpp @@ -65,4 +65,7 @@ VersionFilterData::VersionFilterData() QSet{"net.java.jinput:jinput", "net.java.jinput:jinput-platform", "net.java.jutils:jutils", "org.lwjgl.lwjgl:lwjgl", "org.lwjgl.lwjgl:lwjgl_util", "org.lwjgl.lwjgl:lwjgl-platform"}; + + java8BeginsDate = timeFromS3Time("2017-03-30T09:32:19+00:00"); + java16BeginsDate = timeFromS3Time("2021-05-12T11:19:15+00:00"); } diff --git a/api/logic/minecraft/VersionFilterData.h b/api/logic/minecraft/VersionFilterData.h index afd4502b..d100acc3 100644 --- a/api/logic/minecraft/VersionFilterData.h +++ b/api/logic/minecraft/VersionFilterData.h @@ -23,5 +23,9 @@ struct VersionFilterData QDateTime legacyCutoffDate; // Libraries that belong to LWJGL QSet lwjglWhitelist; + // release date of first version to require Java 8 (17w13a) + QDateTime java8BeginsDate; + // release data of first version to require Java 16 (21w19a) + QDateTime java16BeginsDate; }; extern VersionFilterData MULTIMC_LOGIC_EXPORT g_VersionFilterData; diff --git a/api/logic/minecraft/launch/VerifyJavaInstall.cpp b/api/logic/minecraft/launch/VerifyJavaInstall.cpp new file mode 100644 index 00000000..657669af --- /dev/null +++ b/api/logic/minecraft/launch/VerifyJavaInstall.cpp @@ -0,0 +1,34 @@ +#include "VerifyJavaInstall.h" + +#include +#include +#include +#include + +void VerifyJavaInstall::executeTask() { + auto m_inst = std::dynamic_pointer_cast(m_parent->instance()); + + auto javaVersion = m_inst->getJavaVersion(); + auto minecraftComponent = m_inst->getPackProfile()->getComponent("net.minecraft"); + + // Java 16 requirement + if (minecraftComponent->getReleaseDateTime() >= g_VersionFilterData.java16BeginsDate) { + if (javaVersion.major() < 16) { + emit logLine("Minecraft 21w19a and above require the use of Java 16", + MessageLevel::Fatal); + emitFailed(tr("Minecraft 21w19a and above require the use of Java 16")); + return; + } + } + // Java 8 requirement + else if (minecraftComponent->getReleaseDateTime() >= g_VersionFilterData.java8BeginsDate) { + if (javaVersion.major() < 8) { + emit logLine("Minecraft 17w13a and above require the use of Java 8", + MessageLevel::Fatal); + emitFailed(tr("Minecraft 17w13a and above require the use of Java 8")); + return; + } + } + + emitSucceeded(); +} diff --git a/api/logic/minecraft/launch/VerifyJavaInstall.h b/api/logic/minecraft/launch/VerifyJavaInstall.h new file mode 100644 index 00000000..a553106d --- /dev/null +++ b/api/logic/minecraft/launch/VerifyJavaInstall.h @@ -0,0 +1,17 @@ +#pragma once + +#include + +class VerifyJavaInstall : public LaunchStep { + Q_OBJECT + +public: + explicit VerifyJavaInstall(LaunchTask *parent) : LaunchStep(parent) { + }; + ~VerifyJavaInstall() override = default; + + void executeTask() override; + bool canAbort() const override { + return false; + } +}; From f51efc9109c3bddd8dd83737f5600cfcef57a6f6 Mon Sep 17 00:00:00 2001 From: Jamie Mansfield Date: Mon, 28 Jun 2021 22:09:52 +0100 Subject: [PATCH 51/57] NOISSUE Verify file checksums for modpacks.ch --- api/logic/modplatform/modpacksch/FTBPackInstallTask.cpp | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/api/logic/modplatform/modpacksch/FTBPackInstallTask.cpp b/api/logic/modplatform/modpacksch/FTBPackInstallTask.cpp index ddc7fe35..b3c97c7b 100644 --- a/api/logic/modplatform/modpacksch/FTBPackInstallTask.cpp +++ b/api/logic/modplatform/modpacksch/FTBPackInstallTask.cpp @@ -5,6 +5,7 @@ #include "Json.h" #include "minecraft/MinecraftInstance.h" #include "minecraft/PackProfile.h" +#include "net/ChecksumValidator.h" #include "settings/INISettingsObject.h" namespace ModpacksCH { @@ -98,6 +99,10 @@ void PackInstallTask::downloadPack() qDebug() << "Will download" << file.url << "to" << path; auto dl = Net::Download::makeFile(file.url, path); + if (!file.sha1.isEmpty()) { + auto rawSha1 = QByteArray::fromHex(file.sha1.toLatin1()); + dl->addValidator(new Net::ChecksumValidator(QCryptographicHash::Sha1, rawSha1)); + } jobPtr->addNetAction(dl); } From c15bd655f1b9c87ec2950f898a157acb64b8e474 Mon Sep 17 00:00:00 2001 From: Jamie Mansfield Date: Mon, 28 Jun 2021 22:34:38 +0100 Subject: [PATCH 52/57] NOISSUE Cache file downloads for modpacks.ch --- .../modpacksch/FTBPackInstallTask.cpp | 24 ++++++++++++++++++- .../modpacksch/FTBPackInstallTask.h | 2 ++ 2 files changed, 25 insertions(+), 1 deletion(-) diff --git a/api/logic/modplatform/modpacksch/FTBPackInstallTask.cpp b/api/logic/modplatform/modpacksch/FTBPackInstallTask.cpp index b3c97c7b..6067c56a 100644 --- a/api/logic/modplatform/modpacksch/FTBPackInstallTask.cpp +++ b/api/logic/modplatform/modpacksch/FTBPackInstallTask.cpp @@ -1,6 +1,7 @@ #include "FTBPackInstallTask.h" #include "BuildConfig.h" +#include "Env.h" #include "FileSystem.h" #include "Json.h" #include "minecraft/MinecraftInstance.h" @@ -94,11 +95,19 @@ void PackInstallTask::downloadPack() for(auto file : m_version.files) { if(file.serverOnly) continue; + QFileInfo fileName(file.name); + auto cacheName = fileName.completeBaseName() + "-" + file.sha1 + "." + fileName.suffix(); + + auto entry = ENV.metacache()->resolveEntry("ModpacksCHPacks", cacheName); + entry->setStale(true); + auto relpath = FS::PathCombine("minecraft", file.path, file.name); auto path = FS::PathCombine(m_stagingPath, relpath); qDebug() << "Will download" << file.url << "to" << path; - auto dl = Net::Download::makeFile(file.url, path); + filesToCopy[entry->getFullPath()] = path; + + auto dl = Net::Download::makeCached(file.url, entry); if (!file.sha1.isEmpty()) { auto rawSha1 = QByteArray::fromHex(file.sha1.toLatin1()); dl->addValidator(new Net::ChecksumValidator(QCryptographicHash::Sha1, rawSha1)); @@ -126,6 +135,19 @@ void PackInstallTask::downloadPack() void PackInstallTask::install() { + setStatus(tr("Copying modpack files")); + + for (auto iter = filesToCopy.begin(); iter != filesToCopy.end(); iter++) { + auto &from = iter.key(); + auto &to = iter.value(); + FS::copy fileCopyOperation(from, to); + if(!fileCopyOperation()) { + qWarning() << "Failed to copy" << from << "to" << to; + emitFailed(tr("Failed to copy files")); + return; + } + } + setStatus(tr("Installing modpack")); auto instanceConfigPath = FS::PathCombine(m_stagingPath, "instance.cfg"); diff --git a/api/logic/modplatform/modpacksch/FTBPackInstallTask.h b/api/logic/modplatform/modpacksch/FTBPackInstallTask.h index 4f7786fd..3b2d60de 100644 --- a/api/logic/modplatform/modpacksch/FTBPackInstallTask.h +++ b/api/logic/modplatform/modpacksch/FTBPackInstallTask.h @@ -37,6 +37,8 @@ private: QString m_version_name; Version m_version; + QMap filesToCopy; + }; } From 2e78b64058925aca0c7a6e7013be7119b66f20d7 Mon Sep 17 00:00:00 2001 From: Jamie Mansfield Date: Wed, 30 Jun 2021 00:51:33 +0100 Subject: [PATCH 53/57] NOISSUE Fix detection for 32-bit Azul or Bellsoft Java Co-authored-by: Pedro Cunha --- api/logic/java/JavaUtils.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/api/logic/java/JavaUtils.cpp b/api/logic/java/JavaUtils.cpp index ff6a9ac5..4b231e6a 100644 --- a/api/logic/java/JavaUtils.cpp +++ b/api/logic/java/JavaUtils.cpp @@ -273,13 +273,13 @@ QList JavaUtils::FindJavaPaths() QList ZULU64s = this->FindJavaFromRegistryKey( KEY_WOW64_64KEY, "SOFTWARE\\Azul Systems\\Zulu", "InstallationPath"); QList ZULU32s = this->FindJavaFromRegistryKey( - KEY_WOW64_64KEY, "SOFTWARE\\Azul Systems\\Zulu", "InstallationPath"); + KEY_WOW64_32KEY, "SOFTWARE\\Azul Systems\\Zulu", "InstallationPath"); // BellSoft Liberica QList LIBERICA64s = this->FindJavaFromRegistryKey( KEY_WOW64_64KEY, "SOFTWARE\\BellSoft\\Liberica", "InstallationPath"); QList LIBERICA32s = this->FindJavaFromRegistryKey( - KEY_WOW64_64KEY, "SOFTWARE\\BellSoft\\Liberica", "InstallationPath"); + KEY_WOW64_32KEY, "SOFTWARE\\BellSoft\\Liberica", "InstallationPath"); // List x64 before x86 java_candidates.append(JRE64s); From d1a142f040d66b6c6dafc243d98f97b53473455c Mon Sep 17 00:00:00 2001 From: Jamie Mansfield Date: Tue, 6 Jul 2021 15:10:35 +0100 Subject: [PATCH 54/57] GH-1949 Allow Legacy FTB pack downloads to be aborted It looks like this was just an mistake when implementing support for legacy FTB. --- api/logic/modplatform/legacy_ftb/PackInstallTask.h | 1 + 1 file changed, 1 insertion(+) diff --git a/api/logic/modplatform/legacy_ftb/PackInstallTask.h b/api/logic/modplatform/legacy_ftb/PackInstallTask.h index 7868d1c4..f3515781 100644 --- a/api/logic/modplatform/legacy_ftb/PackInstallTask.h +++ b/api/logic/modplatform/legacy_ftb/PackInstallTask.h @@ -20,6 +20,7 @@ public: explicit PackInstallTask(Modpack pack, QString version); virtual ~PackInstallTask(){} + bool canAbort() const override { return true; } bool abort() override; protected: From db392b49943d7f575cef29ec26e2490d49eb60a7 Mon Sep 17 00:00:00 2001 From: Jamie Mansfield Date: Tue, 6 Jul 2021 15:12:07 +0100 Subject: [PATCH 55/57] GH-1949 Allow modpacks.ch pack downloads to be aborted --- api/logic/modplatform/modpacksch/FTBPackInstallTask.cpp | 9 ++++++++- api/logic/modplatform/modpacksch/FTBPackInstallTask.h | 3 +++ 2 files changed, 11 insertions(+), 1 deletion(-) diff --git a/api/logic/modplatform/modpacksch/FTBPackInstallTask.cpp b/api/logic/modplatform/modpacksch/FTBPackInstallTask.cpp index 6067c56a..f22373bc 100644 --- a/api/logic/modplatform/modpacksch/FTBPackInstallTask.cpp +++ b/api/logic/modplatform/modpacksch/FTBPackInstallTask.cpp @@ -19,7 +19,11 @@ PackInstallTask::PackInstallTask(Modpack pack, QString version) bool PackInstallTask::abort() { - return true; + if(abortable) + { + return jobPtr->abort(); + } + return false; } void PackInstallTask::executeTask() @@ -117,16 +121,19 @@ void PackInstallTask::downloadPack() connect(jobPtr.get(), &NetJob::succeeded, this, [&]() { + abortable = false; jobPtr.reset(); install(); }); connect(jobPtr.get(), &NetJob::failed, [&](QString reason) { + abortable = false; jobPtr.reset(); emitFailed(reason); }); connect(jobPtr.get(), &NetJob::progress, [&](qint64 current, qint64 total) { + abortable = true; setProgress(current, total); }); diff --git a/api/logic/modplatform/modpacksch/FTBPackInstallTask.h b/api/logic/modplatform/modpacksch/FTBPackInstallTask.h index 3b2d60de..55db3d3c 100644 --- a/api/logic/modplatform/modpacksch/FTBPackInstallTask.h +++ b/api/logic/modplatform/modpacksch/FTBPackInstallTask.h @@ -16,6 +16,7 @@ public: explicit PackInstallTask(Modpack pack, QString version); virtual ~PackInstallTask(){} + bool canAbort() const override { return true; } bool abort() override; protected: @@ -30,6 +31,8 @@ private: void install(); private: + bool abortable = false; + NetJobPtr jobPtr; QByteArray response; From d5c448931344a6cee5f89fddf9a8e64dec1f8da6 Mon Sep 17 00:00:00 2001 From: Jamie Mansfield Date: Tue, 6 Jul 2021 15:12:39 +0100 Subject: [PATCH 56/57] GH-1949 Allow Technic pack downloads to be aborted This supports both 'single zip' modpacks and Solder packs, through the Technic mod platform page. --- .../modplatform/technic/SingleZipPackInstallTask.cpp | 12 ++++++++++++ .../modplatform/technic/SingleZipPackInstallTask.h | 5 +++++ .../modplatform/technic/SolderPackInstallTask.cpp | 12 ++++++++++++ .../modplatform/technic/SolderPackInstallTask.h | 5 +++++ 4 files changed, 34 insertions(+) diff --git a/api/logic/modplatform/technic/SingleZipPackInstallTask.cpp b/api/logic/modplatform/technic/SingleZipPackInstallTask.cpp index 96e1804d..dbce8e53 100644 --- a/api/logic/modplatform/technic/SingleZipPackInstallTask.cpp +++ b/api/logic/modplatform/technic/SingleZipPackInstallTask.cpp @@ -28,6 +28,14 @@ Technic::SingleZipPackInstallTask::SingleZipPackInstallTask(const QUrl &sourceUr m_minecraftVersion = minecraftVersion; } +bool Technic::SingleZipPackInstallTask::abort() { + if(m_abortable) + { + return m_filesNetJob->abort(); + } + return false; +} + void Technic::SingleZipPackInstallTask::executeTask() { setStatus(tr("Downloading modpack:\n%1").arg(m_sourceUrl.toString())); @@ -47,6 +55,8 @@ void Technic::SingleZipPackInstallTask::executeTask() void Technic::SingleZipPackInstallTask::downloadSucceeded() { + m_abortable = false; + setStatus(tr("Extracting modpack")); QDir extractDir(FS::PathCombine(m_stagingPath, ".minecraft")); qDebug() << "Attempting to create instance from" << m_archivePath; @@ -67,12 +77,14 @@ void Technic::SingleZipPackInstallTask::downloadSucceeded() void Technic::SingleZipPackInstallTask::downloadFailed(QString reason) { + m_abortable = false; emitFailed(reason); m_filesNetJob.reset(); } void Technic::SingleZipPackInstallTask::downloadProgressChanged(qint64 current, qint64 total) { + m_abortable = true; setProgress(current / 2, total); } diff --git a/api/logic/modplatform/technic/SingleZipPackInstallTask.h b/api/logic/modplatform/technic/SingleZipPackInstallTask.h index c56b9e46..ec2ff605 100644 --- a/api/logic/modplatform/technic/SingleZipPackInstallTask.h +++ b/api/logic/modplatform/technic/SingleZipPackInstallTask.h @@ -36,6 +36,9 @@ class MULTIMC_LOGIC_EXPORT SingleZipPackInstallTask : public InstanceTask public: SingleZipPackInstallTask(const QUrl &sourceUrl, const QString &minecraftVersion); + bool canAbort() const override { return true; } + bool abort() override; + protected: void executeTask() override; @@ -48,6 +51,8 @@ private slots: void extractAborted(); private: + bool m_abortable = false; + QUrl m_sourceUrl; QString m_minecraftVersion; QString m_archivePath; diff --git a/api/logic/modplatform/technic/SolderPackInstallTask.cpp b/api/logic/modplatform/technic/SolderPackInstallTask.cpp index 1d17073c..1b4186d4 100644 --- a/api/logic/modplatform/technic/SolderPackInstallTask.cpp +++ b/api/logic/modplatform/technic/SolderPackInstallTask.cpp @@ -27,6 +27,14 @@ Technic::SolderPackInstallTask::SolderPackInstallTask(const QUrl &sourceUrl, con m_minecraftVersion = minecraftVersion; } +bool Technic::SolderPackInstallTask::abort() { + if(m_abortable) + { + return m_filesNetJob->abort(); + } + return false; +} + void Technic::SolderPackInstallTask::executeTask() { setStatus(tr("Finding recommended version:\n%1").arg(m_sourceUrl.toString())); @@ -106,6 +114,8 @@ void Technic::SolderPackInstallTask::fileListSucceeded() void Technic::SolderPackInstallTask::downloadSucceeded() { + m_abortable = false; + setStatus(tr("Extracting modpack")); m_filesNetJob.reset(); m_extractFuture = QtConcurrent::run([this]() @@ -132,12 +142,14 @@ void Technic::SolderPackInstallTask::downloadSucceeded() void Technic::SolderPackInstallTask::downloadFailed(QString reason) { + m_abortable = false; emitFailed(reason); m_filesNetJob.reset(); } void Technic::SolderPackInstallTask::downloadProgressChanged(qint64 current, qint64 total) { + m_abortable = true; setProgress(current / 2, total); } diff --git a/api/logic/modplatform/technic/SolderPackInstallTask.h b/api/logic/modplatform/technic/SolderPackInstallTask.h index 0fe6cb83..9f0f20a9 100644 --- a/api/logic/modplatform/technic/SolderPackInstallTask.h +++ b/api/logic/modplatform/technic/SolderPackInstallTask.h @@ -29,6 +29,9 @@ namespace Technic public: explicit SolderPackInstallTask(const QUrl &sourceUrl, const QString &minecraftVersion); + bool canAbort() const override { return true; } + bool abort() override; + protected: //! Entry point for tasks. virtual void executeTask() override; @@ -43,6 +46,8 @@ namespace Technic void extractAborted(); private: + bool m_abortable = false; + NetJobPtr m_filesNetJob; QUrl m_sourceUrl; QString m_minecraftVersion; From 220971fadd8cc2def071818c17cda14bad0f6f45 Mon Sep 17 00:00:00 2001 From: Jamie Mansfield Date: Tue, 6 Jul 2021 15:22:41 +0100 Subject: [PATCH 57/57] GH-1949 Allow ATLauncher pack downloads to be aborted --- .../modplatform/atlauncher/ATLPackInstallTask.cpp | 13 ++++++++++++- .../modplatform/atlauncher/ATLPackInstallTask.h | 3 +++ 2 files changed, 15 insertions(+), 1 deletion(-) diff --git a/api/logic/modplatform/atlauncher/ATLPackInstallTask.cpp b/api/logic/modplatform/atlauncher/ATLPackInstallTask.cpp index dac80e8c..55087a27 100644 --- a/api/logic/modplatform/atlauncher/ATLPackInstallTask.cpp +++ b/api/logic/modplatform/atlauncher/ATLPackInstallTask.cpp @@ -28,7 +28,11 @@ PackInstallTask::PackInstallTask(UserInteractionSupport *support, QString pack, bool PackInstallTask::abort() { - return true; + if(abortable) + { + return jobPtr->abort(); + } + return false; } void PackInstallTask::executeTask() @@ -418,16 +422,19 @@ void PackInstallTask::installConfigs() connect(jobPtr.get(), &NetJob::succeeded, this, [&]() { + abortable = false; jobPtr.reset(); extractConfigs(); }); connect(jobPtr.get(), &NetJob::failed, [&](QString reason) { + abortable = false; jobPtr.reset(); emitFailed(reason); }); connect(jobPtr.get(), &NetJob::progress, [&](qint64 current, qint64 total) { + abortable = true; setProgress(current, total); }); @@ -576,11 +583,13 @@ void PackInstallTask::downloadMods() connect(jobPtr.get(), &NetJob::succeeded, this, &PackInstallTask::onModsDownloaded); connect(jobPtr.get(), &NetJob::failed, [&](QString reason) { + abortable = false; jobPtr.reset(); emitFailed(reason); }); connect(jobPtr.get(), &NetJob::progress, [&](qint64 current, qint64 total) { + abortable = true; setProgress(current, total); }); @@ -588,6 +597,8 @@ void PackInstallTask::downloadMods() } void PackInstallTask::onModsDownloaded() { + abortable = false; + qDebug() << "PackInstallTask::onModsDownloaded: " << QThread::currentThreadId(); jobPtr.reset(); diff --git a/api/logic/modplatform/atlauncher/ATLPackInstallTask.h b/api/logic/modplatform/atlauncher/ATLPackInstallTask.h index 8233c376..15fd9b32 100644 --- a/api/logic/modplatform/atlauncher/ATLPackInstallTask.h +++ b/api/logic/modplatform/atlauncher/ATLPackInstallTask.h @@ -39,6 +39,7 @@ public: explicit PackInstallTask(UserInteractionSupport *support, QString pack, QString version); virtual ~PackInstallTask(){} + bool canAbort() const override { return true; } bool abort() override; protected: @@ -72,6 +73,8 @@ private: private: UserInteractionSupport *m_support; + bool abortable = false; + NetJobPtr jobPtr; QByteArray response;