diff --git a/.gitignore b/.gitignore index c9aaecb..bf5c5d6 100644 --- a/.gitignore +++ b/.gitignore @@ -1,6 +1,6 @@ -.idea -.cache -.vscode -_old -cmake-build-debug -build.sh +*.so +*.so* +endlauncher.l5 +test.l5 +forespend.l5 + diff --git a/.gitmodules b/.gitmodules index f7273c5..ba0978d 100644 --- a/.gitmodules +++ b/.gitmodules @@ -23,6 +23,3 @@ path = lib/luajit url = https://github.com/LuaJIT/LuaJIT.git branch = v2.0 -[submodule "lib/ultralight"] - path = lib/ultralight - url = https://github.com/ultralight-ux/Ultralight.git diff --git a/CMakeLists.txt b/CMakeLists.txt index dcaac78..021dc09 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -7,10 +7,8 @@ else() set(PLATFORM_DIR "linux") endif() + add_subdirectory(engine) add_subdirectory(games/forespend) -add_subdirectory(games/pretend) -add_subdirectory(games/animatronical/q1/a1) add_subdirectory(games/endlauncher) -add_subdirectory(apps/kstralight) include(ExternalProject) \ No newline at end of file diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md deleted file mode 100644 index 20bd1f7..0000000 --- a/CONTRIBUTING.md +++ /dev/null @@ -1,8 +0,0 @@ -# IF YOU DONT FOLLOW THESE RULES, YOU WILL BE BLOCKED - -DO NOT AI SLOP PULL REQUEST, IF YOU USE AI FOR CODE PLEASE VERIFY INTEGRITY MANUALLY. - -ONLY PULL REQUEST FOR WHAT IS TOLD ON ISSUES, MANUALLY LOOK THROUGH ISSUES ON THE BUG ASPECT AND APPROVED FEATURE REQUESTS - -DO NOT MAKE "SYNTAX FIX" OR "STYLE FIX" PULL REQUESTS OR ISSUES, AS THEY ARE BASICALLY USELESS. -# THE COMPUTER DOESNT GIVE A DAMN IF YOU ARE SAYING C, COL, COLOR OR COLOUR. diff --git a/MEDIA_LICENSE.MD b/MEDIA_LICENSE.MD deleted file mode 100644 index be4fd25..0000000 --- a/MEDIA_LICENSE.MD +++ /dev/null @@ -1,112 +0,0 @@ -Free Art License 1.3 (FAL 1.3) - -Preamble - -The Free Art License grants the right to freely copy, distribute, and transform creative works without infringing the author’s rights. - -The Free Art License recognizes and protects these rights. Their implementation has been reformulated in order to allow everyone to use creations of the human mind in a creative manner, regardless of their types and ways of expression. - -While the public’s access to creations of the human mind usually is restricted by the implementation of copyright law, it is favoured by the Free Art License. This license intends to allow the use of a work’s resources; to establish new conditions for creating in order to increase creation opportunities. The Free Art License grants the right to use a work, and acknowledges the right holder’s and the user’s rights and responsibility. - -The invention and development of digital technologies, Internet and Free Software have changed creation methods: creations of the human mind can obviously be distributed, exchanged, and transformed. They allow to produce common works to which everyone can contribute to the benefit of all. - -The main rationale for this Free Art License is to promote and protect these creations of the human mind according to the principles of copyleft: freedom to use, copy, distribute, transform, and prohibition of exclusive appropriation. - -Definitions - -« work » either means the initial work, the subsequent works or the common work as defined hereafter: - -« common work » means a work composed of the initial work and all subsequent contributions to it (originals and copies). The initial author is the one who, by choosing this license, defines the conditions under which contributions are made. - -« Initial work » means the work created by the initiator of the common work (as defined above), the copies of which can be modified by whoever wants to - -« Subsequent works » means the contributions made by authors who participate in the evolution of the common work by exercising the rights to reproduce, distribute, and modify that are granted by the license. - -« Originals » (sources or resources of the work) means all copies of either the initial work or any subsequent work mentioning a date and used by their author(s) as references for any subsequent updates, interpretations, copies or reproductions. - -« Copy » means any reproduction of an original as defined by this license. - -1. OBJECT - The aim of this license is to define the conditions under which one can use this work freely. - -2. SCOPE - This work is subject to copyright law. Through this license its author specifies the extent to which you can copy, distribute, and modify it. - -2.1 FREEDOM TO COPY (OR TO MAKE REPRODUCTIONS) -You have the right to copy this work for yourself, your friends or any other person, whatever the technique used. - -2.2 FREEDOM TO DISTRIBUTE, TO PERFORM IN PUBLIC -You have the right to distribute copies of this work; whether modified or not, whatever the medium and the place, with or without any charge, provided that you: -attach this license without any modification to the copies of this work or indicate precisely where the license can be found, -specify to the recipient the names of the author(s) of the originals, including yours if you have modified the work, -specify to the recipient where to access the originals (either initial or subsequent). -The authors of the originals may, if they wish to, give you the right to distribute the originals under the same conditions as the copies. - -2.3 FREEDOM TO MODIFY -You have the right to modify copies of the originals (whether initial or subsequent) provided you comply with the following conditions: -all conditions in article 2.2 above, if you distribute modified copies; -indicate that the work has been modified and, if it is possible, what kind of modifications have been made; -distribute the subsequent work under the same license or any compatible license. -The author(s) of the original work may give you the right to modify it under the same conditions as the copies. - -3. RELATED RIGHTS - Activities giving rise to author’s rights and related rights shall not challenge the rights granted by this license. - For example, this is the reason why performances must be subject to the same license or a compatible license. Similarly, integrating the work in a database, a compilation or an anthology shall not prevent anyone from using the work under the same conditions as those defined in this license. - -4. INCORPORATION OF THE WORK - Incorporating this work into a larger work that is not subject to the Free Art License shall not challenge the rights granted by this license. - If the work can no longer be accessed apart from the larger work in which it is incorporated, then incorporation shall only be allowed under the condition that the larger work is subject either to the Free Art License or a compatible license. - -5. COMPATIBILITY - A license is compatible with the Free Art License provided: - it gives the right to copy, distribute, and modify copies of the work including for commercial purposes and without any other restrictions than those required by the respect of the other compatibility criteria; - it ensures proper attribution of the work to its authors and access to previous versions of the work when possible; - it recognizes the Free Art License as compatible (reciprocity); - it requires that changes made to the work be subject to the same license or to a license which also meets these compatibility criteria. - -6. YOUR INTELLECTUAL RIGHTS - This license does not aim at denying your author’s rights in your contribution or any related right. By choosing to contribute to the development of this common work, you only agree to grant others the same rights with regard to your contribution as those you were granted by this license. Conferring these rights does not mean you have to give up your intellectual rights. - -7. YOUR RESPONSIBILITIES - The freedom to use the work as defined by the Free Art License (right to copy, distribute, modify) implies that everyone is responsible for their own actions. - -8. DURATION OF THE LICENSE - This license takes effect as of your acceptance of its terms. The act of copying, distributing, or modifying the work constitutes a tacit agreement. This license will remain in effect for as long as the copyright which is attached to the work. If you do not respect the terms of this license, you automatically lose the rights that it confers. - If the legal status or legislation to which you are subject makes it impossible for you to respect the terms of this license, you may not make use of the rights which it confers. - -9. VARIOUS VERSIONS OF THE LICENSE - This license may undergo periodic modifications to incorporate improvements by its authors (instigators of the « Copyleft Attitude » movement) by way of new, numbered versions. - You will always have the choice of accepting the terms contained in the version under which the copy of the work was distributed to you, or alternatively, to use the provisions of one of the subsequent versions. - -10. SUB-LICENSING - Sub-licenses are not authorized by this license. Any person wishing to make use of the rights that it confers will be directly bound to the authors of the common work. - -11. LEGAL FRAMEWORK - This license is written with respect to both French law and the Berne Convention for the Protection of Literary and Artistic Works. - -USER GUIDE - -– How to use the Free Art License? -To benefit from the Free Art License, you only need to mention the following elements on your work: -[Name of the author, title, date of the work. When applicable, names of authors of the common work and, if possible, where to find the originals]. -Copyleft: This is a free work, you can copy, distribute, and modify it under the terms of the Free Art License https://artlibre.org/licence/lal/en/ - -– Why to use the Free Art License? -1.To give the greatest number of people access to your work. -2.To allow it to be distributed freely. -3.To allow it to evolve by allowing its copy, distribution, and transformation by others. -4.So that you benefit from the resources of a work when it is under the Free Art License: to be able to copy, distribute or transform it freely. -5.But also, because the Free Art License offers a legal framework to disallow any misappropriation. It is forbidden to take hold of your work and bypass the creative process for one’s exclusive possession. - -– When to use the Free Art License? -Any time you want to benefit and make others benefit from the right to copy, distribute and transform creative works without any exclusive appropriation, you should use the Free Art License. You can for example use it for scientific, artistic or educational projects. - -– What kinds of works can be subject to the Free Art License? -The Free Art License can be applied to digital as well as physical works. -You can choose to apply the Free Art License on any text, picture, sound, gesture, or whatever sort of stuff on which you have sufficient author’s rights. - -– Historical background of this license: -It is the result of observing, using and creating digital technologies, free software, the Internet and art. It arose from the « Copyleft Attitude » meetings which took place in Paris in 2000. For the first time, these meetings brought together members of the Free Software community, artists, and members of the art world. The goal was to adapt the principles of Copyleft and free software to all sorts of creations. http://www.artlibre.org - -Copyleft Attitude, 2007. -You can make reproductions and distribute this license verbatim (without any changes). \ No newline at end of file diff --git a/apps/kstralight/CMakeLists.txt b/apps/kstralight/CMakeLists.txt deleted file mode 100644 index 9021988..0000000 --- a/apps/kstralight/CMakeLists.txt +++ /dev/null @@ -1,23 +0,0 @@ -cmake_minimum_required(VERSION 3.20) - -set(CMAKE_CXX_FLAGS "-std=c++26 -Wno-error -Oz -w -g -mavx2") -file(GLOB_RECURSE kstralight_SOURCES CONFIGURE_DEPENDS "src/*.cpp") -add_executable(kstralight ${kstralight_SOURCES}) -if(NOT DEFINED ${ARCH}) - set(ARCH "linux-64") -endif(NOT DEFINED ${ARCH}) -set_target_properties(kstralight PROPERTIES - RUNTIME_OUTPUT_DIRECTORY "${CMAKE_SOURCE_DIR}/built/kstralight/${PLATFORM_DIR}/bin" -) - -target_link_directories( - kstralight PUBLIC - "${CMAKE_SOURCE_DIR}/link") -target_link_libraries(kstralight PRIVATE - enginend - raylib - -) -target_include_directories(kstralight PUBLIC - ${CMAKE_SOURCE_DIR}/include -) \ No newline at end of file diff --git a/apps/kstralight/res/index.tsf.tdf b/apps/kstralight/res/index.tsf.tdf deleted file mode 100644 index aca6eae..0000000 --- a/apps/kstralight/res/index.tsf.tdf +++ /dev/null @@ -1,37 +0,0 @@ - -" font eagle.ttf - -{ text -f r 255 -f g 255 -f b 255 -f a 255 -} - -{ link -" font dos.ttf -{ normal - -} -{ hover - -} -{ click - -} -} - -{ button -{ normal - -} -{ hover - -} -{ click - -} -{ disabled - -} -} diff --git a/apps/kstralight/res/index.twf.tdf b/apps/kstralight/res/index.twf.tdf deleted file mode 100644 index 1e9b8f5..0000000 --- a/apps/kstralight/res/index.twf.tdf +++ /dev/null @@ -1,80 +0,0 @@ -{ style main -" path index.tsf.tdf - -{ sub -{ col header -b rel T -f x 0 -f y 0 -f w 1 -f h 0.2 -f r 0.25 -f g 0 -f b 0 -f a 1 -{ sub -{ text welcome -b rel T -f x 0 -f y 0 -f w 1 -f h 0.75 -S txt - welcome to tiny web ^^ -\ -} -{ text message -b rel T -f x 0 -f y 0.75 -f w 1 -f h 0.25 -S txt - here you will learn the basics of how to create a tiny webpage -\ -} -} -} -# header end -{ col body -b rel T -f x 0.2 -f y 0 -f w 1 -f h 5.0 -f r 0.125 -f g 0.125 -f b 0.125 -f a 1 -{ sub -{ text message -b rel T -f x 0.1 -f y 0.1 -f w 0.9 -f h 0.2 -S txt - first of all, sorry to tell you but you will have to create these tiny files that.. are not the most readable - so until i can create an editor, i deeply recommend you to keep your pages very simple in styling. - - but i do plan to create a proper IDE for TDF and TMK where you will not have to worry about the code at all... - just have to place nodes and blocks and pointers and u can be happy heh. -\ -} -{ link repo -b rel T -f x 0.3 -f y 0.1 -f w 0.9 -f h 0.02 -S txt - look at my other projects! -\ -" path https://github.com/kin-fuyuki -} -} -} -# body end -} -# end of the style sub-elements -} \ No newline at end of file diff --git a/apps/kstralight/src/data/browser/config.cpp b/apps/kstralight/src/data/browser/config.cpp deleted file mode 100644 index 1ac2545..0000000 --- a/apps/kstralight/src/data/browser/config.cpp +++ /dev/null @@ -1 +0,0 @@ -#include "config.h" diff --git a/apps/kstralight/src/data/browser/config.h b/apps/kstralight/src/data/browser/config.h deleted file mode 100644 index cf5d2aa..0000000 --- a/apps/kstralight/src/data/browser/config.h +++ /dev/null @@ -1,5 +0,0 @@ -#pragma once - - -class config { -}; \ No newline at end of file diff --git a/apps/kstralight/src/data/browser/session.cpp b/apps/kstralight/src/data/browser/session.cpp deleted file mode 100644 index a977594..0000000 --- a/apps/kstralight/src/data/browser/session.cpp +++ /dev/null @@ -1 +0,0 @@ -#include "session.h" diff --git a/apps/kstralight/src/data/browser/session.h b/apps/kstralight/src/data/browser/session.h deleted file mode 100644 index 7f34113..0000000 --- a/apps/kstralight/src/data/browser/session.h +++ /dev/null @@ -1,5 +0,0 @@ -#pragma once - - -class session { -}; \ No newline at end of file diff --git a/apps/kstralight/src/data/formats.cpp b/apps/kstralight/src/data/formats.cpp deleted file mode 100644 index 5ddd541..0000000 --- a/apps/kstralight/src/data/formats.cpp +++ /dev/null @@ -1,20 +0,0 @@ -#include "formats.h" - - - -std::map cookie{ - -}; - - -std::map tinywebformat{ - {"point",datagroup({TWFPOINT})}, - {"rect",datagroup({TWFRECT})}, - {"text",datagroup({TWFTEXT})}, - {"img",datagroup({TWFIMG})}, - {"link",datagroup({TWFLINK})}, - {"col",datagroup({TWFCOL})}, -}; -std::map tinywebstyle{ - -}; \ No newline at end of file diff --git a/apps/kstralight/src/data/formats.h b/apps/kstralight/src/data/formats.h deleted file mode 100644 index 0d103c3..0000000 --- a/apps/kstralight/src/data/formats.h +++ /dev/null @@ -1,24 +0,0 @@ -#pragma once -#include -#include - -struct datagroup { - std::map data; - datagroup(std::map data):data(data){} -}; - -extern std::map cookie; -#define TWFELEMENT {"sub",tiny::TDF_CLASS}, -#define TWFSTYLE TWFELEMENT {"path",tiny::TDF_STR}, -#define TWFSTYLED {"style",tiny::TDF_CLASS}, -#define TWFPOINT TWFELEMENT {"x",tiny::TDF_FLOAT},{"y",tiny::TDF_FLOAT},{"rel",tiny::TDF_BOOL}, -#define TWFRECT TWFPOINT {"w",tiny::TDF_FLOAT},{"h",tiny::TDF_FLOAT}, -#define TWFCOL TWFRECT {"r",tiny::TDF_FLOAT},{"g",tiny::TDF_FLOAT},{"b",tiny::TDF_FLOAT},{"a",tiny::TDF_FLOAT}, -#define TWFTEXT TWFRECT TWFSTYLED {"txt",tiny::TDF_BLOCK}, -#define TWFLINK TWFTEXT {"path",tiny::TDF_STR}, -#define TWFBUTTON TWFLINK {"disabled",tiny::TDF_BOOL}, -#define TWFIMG TWFRECT {"path",tiny::TDF_STR}, - -extern std::map tinywebformat; - -extern std::map tinywebstyle; diff --git a/apps/kstralight/src/data/web/cookies.cpp b/apps/kstralight/src/data/web/cookies.cpp deleted file mode 100644 index ababbeb..0000000 --- a/apps/kstralight/src/data/web/cookies.cpp +++ /dev/null @@ -1 +0,0 @@ -#include "cookies.h" diff --git a/apps/kstralight/src/data/web/cookies.h b/apps/kstralight/src/data/web/cookies.h deleted file mode 100644 index 9389354..0000000 --- a/apps/kstralight/src/data/web/cookies.h +++ /dev/null @@ -1,5 +0,0 @@ -#pragma once - - -class cookies { -}; \ No newline at end of file diff --git a/apps/kstralight/src/gui/browser.cpp b/apps/kstralight/src/gui/browser.cpp deleted file mode 100644 index eb7493a..0000000 --- a/apps/kstralight/src/gui/browser.cpp +++ /dev/null @@ -1 +0,0 @@ -#include "browser.h" \ No newline at end of file diff --git a/apps/kstralight/src/gui/browser.h b/apps/kstralight/src/gui/browser.h deleted file mode 100644 index f104df4..0000000 --- a/apps/kstralight/src/gui/browser.h +++ /dev/null @@ -1,22 +0,0 @@ -#pragma once -#include - - -class basic : public enginend::program{ -public: - basic(); - void boot() override; - void draw() override; - void tick() override; - void exit() override; - ~basic(); -}; -class browser: public basic { -public: - browser(); - void boot() final; - void draw() final; - void tick() final; - void exit() final; - ~browser(); -}; \ No newline at end of file diff --git a/apps/kstralight/src/main.cpp b/apps/kstralight/src/main.cpp deleted file mode 100644 index d8a03a3..0000000 --- a/apps/kstralight/src/main.cpp +++ /dev/null @@ -1 +0,0 @@ -#include "gui/browser.h" diff --git a/engine/CMakeLists.txt b/engine/CMakeLists.txt index c83eb06..0d39f1e 100644 --- a/engine/CMakeLists.txt +++ b/engine/CMakeLists.txt @@ -21,15 +21,11 @@ set_target_properties(enginend PROPERTIES LIBRARY_OUTPUT_DIRECTORY "${CMAKE_SOURCE_DIR}/link/${CURRPLATFORM}" RUNTIME_OUTPUT_DIRECTORY "${CMAKE_SOURCE_DIR}/link/${CURRPLATFORM}" ) -target_include_directories(enginend PUBLIC - ${CMAKE_SOURCE_DIR}/include - -) - add_executable(test test.cpp) + set_target_properties(test PROPERTIES RUNTIME_OUTPUT_DIRECTORY "${CMAKE_SOURCE_DIR}/engine/test" ) @@ -43,4 +39,7 @@ target_link_libraries(test PRIVATE target_include_directories(test PUBLIC ${CMAKE_SOURCE_DIR}/include ) -add_executable(noisemake test.cpp) \ No newline at end of file +target_include_directories(enginend PUBLIC + ${CMAKE_SOURCE_DIR}/include + +) diff --git a/games/pretend/src/main.cpp b/engine/noisedev/cloud.lua similarity index 100% rename from games/pretend/src/main.cpp rename to engine/noisedev/cloud.lua diff --git a/engine/noisedev/main.cpp b/engine/noisedev/main.cpp new file mode 100644 index 0000000..8aa9af5 --- /dev/null +++ b/engine/noisedev/main.cpp @@ -0,0 +1,118 @@ +#include +#include +#include +#include + + +Texture2D* noiseresult; +std::vector* gui=new std::vector{ + new enginend::nodes::twod::textured(noiseresult,0,0,512,512), + new enginend::nodes::twod::text(NULL,enginend::DEFAULT,0,0,512,32,32,"") +}; + + +class noiserenderer :public enginend::program{ +public: + tiny::TDF_FILE* config; + std::string currentscript; + std::vector scripts; + const char* CONF()override{return "scripts.tdf";} + Image noiseout; + noiserenderer(){ + config=new tiny::TDF_FILE; + config->filepath=(char*)this->CONF(); + config->read(); + boost::unordered_mapluascripts=*(config->getclass({"lua"})); + for (auto data:luascripts){ + if (data.second.type==tiny::TDF_STR){ + scripts.push_back(*static_cast(data.second.datapointer)); + } + } + currentscript=scripts[0]; + } + void boot() override{ + SetConfigFlags(FLAG_VSYNC_HINT); + InitWindow(512, 512, "lua noise viewer"); + noiseout=GenImageColor(512,512,{255,255,255,255}); + + + this->currentscene=new enginend::scene(); + this->tickrate=3; + this->framerate=3; + } + void tick() override{} + void draw() override { + + } + void exit() override{} + ~noiserenderer() {}; + +}; + +void refreshstuf(noiserenderer *program,char *refreshtdf,char *refreshnoise); + +int main() { + noiserenderer program; + program.boot(); + struct timespec peepy; + long time=1000000000L/((long)(program.framerate)); + char refreshtdf=program.config->getint({"tdfrefresh"}); + char refreshnoise=program.config->getint({"refreshsecs"}); + char checkrefresh=0,checkrefreshtdf=0,checkrefreshnoise=0; + peepy.tv_nsec=time; + peepy.tv_sec=0; + + while (true) { + program.tick(); + program.draw(); + nanosleep(&peepy, nullptr); + if (++checkrefresh==3) { + checkrefresh=0; + if (++checkrefreshnoise==refreshnoise) { + checkrefreshnoise=0; + + } + if (++checkrefreshtdf==refreshtdf) { + checkrefreshtdf=0; + refreshstuf(&program,&refreshtdf,&refreshnoise); + } + } + if (IsKeyDown(KEY_LEFT_ALT)&&IsKeyDown(KEY_F4)){break;} + } + program.exit(); +} + + +void refreshstuf(noiserenderer *program,char *refreshtdf,char *refreshnoise){ + tiny::TDF_FILE *tocheck=new tiny::TDF_FILE; + tocheck->filepath=(char*)program->CONF(); + tocheck->read(); + bool isequal=true; + if (tocheck->todelete.size()!=program->config->todelete.size())isequal=false; + else { + std::string og=""; + std::string justread=""; + program->config->crawl(program->config->data,&og); + tocheck->crawl(tocheck->data,&justread); + isequal=og==justread; + } + if (!isequal){ + program->config->close(); + delete program->config; + program->config=tocheck; + boost::unordered_mapluascripts=*(program->config->getclass({"lua"})); + for (auto data:luascripts){ + if (data.second.type==tiny::TDF_STR){ + program->scripts.push_back(*static_cast(data.second.datapointer)); + } + } + *refreshtdf=program->config->getint({"tdfrefresh"}); + *refreshnoise=program->config->getint({"refreshsecs"}); + program->currentscript=program->scripts[0]; + } + else { + tocheck->close(); + delete tocheck; + } + +} \ No newline at end of file diff --git a/engine/noisedev/scripts.tdf b/engine/noisedev/scripts.tdf new file mode 100644 index 0000000..fb403c3 --- /dev/null +++ b/engine/noisedev/scripts.tdf @@ -0,0 +1,7 @@ +{ lua +" CLOUD cloud.lua +" NOISE noise.lua +} +i refreshsecs 3 +i tdfrefresh 5 +i imagesize 512 \ No newline at end of file diff --git a/engine/src/gr.h b/engine/src/gr.h index dd8e48b..8c898e6 100644 --- a/engine/src/gr.h +++ b/engine/src/gr.h @@ -1,2 +1,2 @@ -#include "graph/window.h" +#include "graph/window.h" \ No newline at end of file diff --git a/engine/src/graph/noise.cpp b/engine/src/graph/noise.cpp new file mode 100644 index 0000000..50cb03a --- /dev/null +++ b/engine/src/graph/noise.cpp @@ -0,0 +1,22 @@ +#include "noise.h" + +#include + +Image* noise::gen(short w, short h, int x, int y) { + switch (this->type) { + case CLOUD: + return cloud(this,w, h, x, y); + case RANDOM: + return random(this,w, h, x, y); + default: + return nullptr; + } +} + +Image* cloud(noise* noise,short w, short h,int x, int y) { + + +} +Image* random(noise* noise,short w, short h,int x, int y) { + +} \ No newline at end of file diff --git a/engine/src/graph/noise.h b/engine/src/graph/noise.h new file mode 100644 index 0000000..d3f8478 --- /dev/null +++ b/engine/src/graph/noise.h @@ -0,0 +1,32 @@ +#pragma once +#include "window.h" +enum NOISETYPE { + CLOUD, + RANDOM, + +}; +enum DIMENSION { + ONE,TWO,THREE,FOUR +}; + +class noise { + public: + int freq; + int octave; + int amp; + NOISETYPE type; + DIMENSION dims; + noise(int freq,int octave, int amp, NOISETYPE type, DIMENSION dims): + freq(freq), octave(octave), amp(amp), type(type),dims(dims) {} +/// to explain the image generator +/// \param x int +/// \param y int +/// ^ these here is the position the noise will start rendering +/// \param w +/// \param h +/// these are the image width and height. PLEASE DO NOT GET CONFUSED + Image* gen(short w, short h,int x, int y); +}; + +Image* cloud(noise* noise,short w, short h,int x, int y); +Image* random(noise* noise, short w, short h,int x, int y); \ No newline at end of file diff --git a/engine/src/graph/window.h b/engine/src/graph/window.h index 2d82549..3d7be25 100644 --- a/engine/src/graph/window.h +++ b/engine/src/graph/window.h @@ -1,5 +1 @@ -#pragma once - -#ifndef DOS -#include -#endif +#include \ No newline at end of file diff --git a/engine/src/program.h b/engine/src/program.h index ed36e1d..1d7d517 100644 --- a/engine/src/program.h +++ b/engine/src/program.h @@ -15,7 +15,6 @@ public: scene *currentscene; int tickrate; int framerate; - bool shouldclose=false; void changescene(scene*scn); program():client(false){} program(bool isclient):client(isclient){} diff --git a/engine/src/scenes/node2d.h b/engine/src/scenes/node2d.h index 05c3def..604b681 100644 --- a/engine/src/scenes/node2d.h +++ b/engine/src/scenes/node2d.h @@ -6,22 +6,26 @@ namespace enginend::nodes::twod { struct node2d :public node { Vector2 pos; - node2d(); - node2d(float x,float y); + node2d(){} + node2d(float x,float y):pos(Vector2{x,y}){} }; struct rect :virtual public node2d{ Vector2 size; - rect(); - rect(float x,float y,float w,float h); + rect(){} + rect(float x,float y,float w,float h):size(Vector2{w,h}){ + this->pos=Vector2{x,y}; + } }; struct textured :virtual public rect{ Texture2D* texture; - textured(); - textured(Texture2D* texture,float x,float y,float w,float h); - void boot()override; - void tick()override; - void draw()override; - void exit()override; + textured(){} + textured(Texture2D* texture,float x,float y,float w,float h):texture(texture){ + this->pos=Vector2{x,y};this->size=Vector2{w,h}; + } + void boot()override{} + void tick()override{} + void draw()override{if(texture!=nullptr)DrawTexture(*texture,pos.x,pos.y,rl::WHITE);} + void exit()override{} }; struct animated : virtual public textured { Image animimage; @@ -31,30 +35,73 @@ namespace enginend::nodes::twod { int framecounter; unsigned int nextframeoffset; int prevframe; - const char*path; - animated(); - animated(const char* gifpath, Vector2 position, Vector2 size, int delay = 6); - void boot()override; - void tick()override; - void draw()override; - void exit()override; + + animated() : frames(0), currentframe(0), framedelay(6), framecounter(0), nextframeoffset(0) { + animimage.data = nullptr; + } + + animated(const char* gifpath, Vector2 position, Vector2 size, int delay = 6) + : textured(nullptr, position.x, position.y, size.x, size.y), + framedelay(delay), currentframe(0), framecounter(0), frames(0), nextframeoffset(0) + { + animimage = LoadImageAnim(gifpath, &frames); + if (frames > 0) { + texture = new Texture2D(LoadTextureFromImage(animimage)); + } + } + + void tick() override { + textured::tick(); + if (frames <= 1) return; + + framecounter++; + if (framecounter >= framedelay) { + framecounter = 0; + currentframe++; + if (currentframe >= frames) currentframe = 0; + nextframeoffset = animimage.width * animimage.height * 4 * currentframe; + } + } + void draw() override { + + if (prevframe!=currentframe){ + prevframe=currentframe; + UpdateTexture(*this->texture,((unsigned char*)animimage.data)+nextframeoffset); + } + textured::draw(); + } + void exit() override { + if (animimage.data) UnloadImage(animimage); + if (texture) { + UnloadTexture(*texture); + delete texture; + texture = nullptr; + } + } }; struct colored :virtual public rect{ Color c; - colored(); - colored(Color color,float x,float y,float w,float h); - void boot()override; - void tick()override; - void draw()override; - void exit()override; + colored(){} + colored(Color color,float x,float y,float w,float h):c(color){ + this->pos=Vector2{x,y};this->size=Vector2{w,h}; + } + void boot()override{} + void tick()override{} + void draw()override{DrawRectangle(pos.x,pos.y,size.x,size.y,c);} + void exit()override{} }; struct tinted :virtual public colored,virtual public textured{ - tinted(); - tinted(Texture2D* texture,Color color,float x,float y,float w,float h); - void boot()override; - void tick()override; - void draw()override; - void exit()override; + tinted(){} + tinted(Texture2D* texture,Color color,float x,float y,float w,float h): + node2d(x,y), + rect(x,y,w,h), + colored(color,x,y,w,h), + textured(texture,x,y,w,h) + {} + void boot()override{this->colored::boot();this->textured::boot();} + void tick()override{this->colored::tick();this->textured::tick();} + void draw()override{if(texture!=nullptr)DrawTexture(*texture,pos.x,pos.y,c);} + void exit()override{this->colored::exit();this->textured::exit();} }; struct text :public tinted { protected: @@ -63,12 +110,42 @@ namespace enginend::nodes::twod { float fs; Color txc; std::string content; - text(); - text(Texture2D* texture,enginend::theme* theme,float x,float y,float w,float h,float fsize,std::string txt); - void boot()override; - void tick()override; - void draw()override; - void exit()override; + text(){fs=20;} + text(Texture2D* texture,enginend::theme* theme,float x,float y,float w,float h,float fsize,std::string txt): + fs(fsize),content(txt) + { + this->pos=Vector2{x,y};this->size=Vector2{w,h};this->texture=texture;this->theme=theme; + + result=content; + size_t initp=0; + while((initp=result.find("\n",initp))!=std::string::npos){ + result.replace(initp,1,"\\n"); + initp+=2; + } + } + void boot()override{this->tinted::boot();} + void tick()override { + this->tinted::tick(); + if(result!=content){ + result=content; + size_t initp=0; + while((initp=result.find("\n",initp))!=std::string::npos){ + result.replace(initp,1,"\\n"); + initp+=2; + } + } + } + void draw()override { + Vector2 minsize=MeasureTextEx(this->theme->font,content.c_str(),fs,1); + Vector2 charsize=MeasureTextEx(this->theme->font," ",fs,1); + float p=charsize.x>charsize.y?charsize.x/minsize.x:charsize.y/minsize.y; + p=p*2; + int minh=(minsize.y>size.y)?minsize.y:size.y; + int minw=(minsize.x>size.x)?minsize.x:size.x; + DrawRectangle(pos.x-charsize.x,pos.y-charsize.y,minw+p,minh+p,this->theme->background); + DrawTextEx(this->theme->font,content.c_str(),pos,fs,1,this->theme->text); + } + void exit()override{this->tinted::exit();} }; struct button :virtual public tinted{ std::function func; @@ -76,62 +153,220 @@ namespace enginend::nodes::twod { bool hover; const bool isboolean; bool boolean=false; - button(); - button(Texture2D* texture,enginend::theme* theme,float x,float y,float w,float h,std::function f); - button(Texture2D* texture,enginend::theme* theme,float x,float y,float w,float h,std::function f,bool isboolean); - void boot()override; - void tick()override; - void draw()override; - void exit()override; + button():pressed(false),isboolean(false){} + button(Texture2D* texture,enginend::theme* theme,float x,float y,float w,float h,std::function f):func(f),pressed(false),isboolean(false){ + this->pos=Vector2{x,y};this->size=Vector2{w,h};this->texture=texture;this->c=theme->tint;this->theme=theme; + } + button(Texture2D* texture,enginend::theme* theme,float x,float y,float w,float h,std::function f,bool isboolean):func(f),pressed(false),isboolean(isboolean){ + this->pos=Vector2{x,y};this->size=Vector2{w,h};this->texture=texture;this->c=theme->tint;this->theme=theme; + } + void boot()override{this->tinted::boot();} + void tick()override{ + } + void draw()override { + + this->tinted::tick(); + Vector2 mouse=GetMousePosition(); + if(CheckCollisionPointRec(mouse,{pos.x,pos.y,size.x,size.y})){hover=true; + if(IsMouseButtonPressed(MOUSE_LEFT_BUTTON)){ + pressed=true; + if(func)func(); + }else{ + pressed=false; + } + }else{ + hover=false; + } + if (hover) { + if (pressed) { + c=isboolean?boolean? + this->theme->booleanbutton[5]:this->theme->booleanbutton[2]: + this->theme->button[2]; + }else { + c=isboolean?boolean? + this->theme->booleanbutton[4]:this->theme->booleanbutton[1]: + this->theme->button[1]; + } + }else { + c=isboolean?boolean? + this->theme->booleanbutton[3]:this->theme->booleanbutton[0]: + this->theme->button[0]; + } + if(this->texture!=nullptr)DrawTexture(*texture,pos.x,pos.y,this->theme->tint); + else DrawRectangle(pos.x,pos.y,size.x,size.y,this->theme->tint); + + } + void exit()override{this->tinted::exit();} }; struct labeledbutton :virtual public button { std::string label; + Font font; int fs; Color txc; labeledbutton(std::string name,Texture2D* texture,enginend::theme* theme, - float x,float y,float w,float h,std::function f,int size); - void boot()override; - void tick()override; - void draw()override; - void exit()override; + float x,float y,float w,float h,std::function f,int size):fs(size){ + this->pos=Vector2{x,y};this->size=Vector2{w,h};this->texture=texture;this->theme=theme; + this->func=f;this->pressed=false; + this->label=name; + } + void boot()override{this->button::boot();} + void tick()override{this->button::tick();} + void draw()override{ + this->button::draw(); + + if (hover) { + if (pressed) { + txc=isboolean?boolean? + this->theme->booleantext[5]:this->theme->booleantext[2]: + this->theme->buttontext[2]; + }else { + txc=isboolean?boolean? + this->theme->booleantext[4]:this->theme->booleantext[1]: + this->theme->buttontext[1]; + } + }else { + txc=isboolean?boolean? + this->theme->booleantext[3]:this->theme->booleantext[0]: + this->theme->buttontext[0]; + } + Vector2 tsize=MeasureTextEx(font,label.c_str(),fs,1); + Vector2 tpos={ + pos.x+(size.x-tsize.x)/2, + pos.y+(size.y-tsize.y)/2 + }; + DrawTextEx(font,label.c_str(),tpos,fs,1,txc); + } + void exit()override{this->button::exit();} }; struct slider :virtual public tinted{ float val; float minv; float maxv; - slider(); - slider(Texture2D* texture,Color color,float x,float y,float w,float h,float min,float max,float v); - void boot()override; - void tick()override; - void draw()override; - void exit()override; + slider():val(0),minv(0),maxv(1){} + slider(Texture2D* texture,Color color,float x,float y,float w,float h,float min,float max,float v):val(v),minv(min),maxv(max){ + this->pos=Vector2{x,y};this->size=Vector2{x,y};this->texture=texture;this->c=color; + } + void boot()override{this->tinted::boot();} + void tick()override{ + this->tinted::tick(); + Vector2 mouse=GetMousePosition(); + if(CheckCollisionPointRec(mouse,{pos.x,pos.y,size.x,size.y})&&IsMouseButtonDown(MOUSE_LEFT_BUTTON)){ + float t=(mouse.x-pos.x)/size.x; + val=minv+t*(maxv-minv); + if(valmaxv)val=maxv; + } + } + void draw()override{ + DrawRectangle(pos.x,pos.y,size.x,size.y,rl::DARKGRAY); + float t=(val-minv)/(maxv-minv); + DrawRectangle(pos.x,pos.y,size.x*t,size.y,c); + } + void exit()override{this->tinted::exit();} }; struct textfield :public text{ - textfield(); - textfield(Texture2D* texture,enginend::theme* theme,float x,float y,float w,float h,float fsize,std::string txt); - void boot()override; - void tick()override; - void draw()override; - void exit()override; + textfield(){} + textfield(Texture2D* texture,enginend::theme* theme,float x,float y,float w,float h,float fsize,std::string txt): + text(texture,theme,x,y,w,h,fsize,txt){} + void boot()override{this->text::boot();} + void tick()override{this->text::tick();} + void draw()override{ + Vector2 p=pos; + Vector2 charsize=MeasureTextEx(this->theme->font," ",fs,0); + Vector2 minsize=MeasureTextEx(this->theme->font,content.c_str(),fs,charsize.x/2); + float po=charsize.x>charsize.y?charsize.x/charsize.y:charsize.y/charsize.x;po=po*5; + int minh=(minsize.y>size.y)?minsize.y:size.y; + int minw=(minsize.x>size.x)?minsize.x:size.x; + DrawRectangle(pos.x-(po/2),pos.y-(po/2),minw+(po*1.1),minh+(po*1.1),c); + DrawTextEx(this->theme->font,content.c_str(),p,fs,charsize.x/2,this->txc); + } + void exit()override{this->text::exit();} }; struct textinput :public text{ bool active; int cpos; - textinput(); - textinput(Texture2D* texture,enginend::theme* theme,float x,float y,float w,float h,float fsize); - void boot()override; - void tick()override; - void draw()override; - void exit()override; + textinput():active(false),cpos(0){} + textinput(Texture2D* texture,enginend::theme* theme,float x,float y,float w,float h,float fsize):active(false),cpos(0){ + this->pos=Vector2{x,y};this->size=Vector2{x,y};this->texture=texture;this->theme=theme;this->content=""; + this->fs=fsize; + } + void boot()override{this->text::boot();} + void tick()override{ + this->text::tick(); + Vector2 mouse=GetMousePosition(); + if(IsMouseButtonPressed(MOUSE_LEFT_BUTTON)){ + active=CheckCollisionPointRec(mouse,{pos.x,pos.y,size.x,size.y}); + } + if(active){ + int key=GetCharPressed(); + while(key>0){ + if(key>=32&&key<=125){ + content+=static_cast(key); + cpos++; + } + key=GetCharPressed(); + } + if(IsKeyPressed(KEY_BACKSPACE)&&content.length()>0){ + content.pop_back(); + cpos--; + } + } + } + void draw()override{ + this->text::draw(); + if(active)DrawRectangle(pos.x+MeasureText(content.c_str(),fs),pos.y,2,fs,{0,0,0,127}); + } + void exit()override{this->text::exit();} }; struct textinputfield :public textfield{ bool active; int cpos; - textinputfield(); - textinputfield(Texture2D* texture,enginend::theme* theme,float x,float y,float w,float h,float fsize); - void boot()override; - void tick()override; - void draw()override; - void exit()override; + textinputfield():active(false),cpos(0){} + textinputfield(Texture2D* texture,enginend::theme* theme,float x,float y,float w,float h,float fsize):active(false),cpos(0), + textfield(texture,theme,x,y,w,h,fsize,""){} + void boot()override{this->textfield::boot();} + void tick()override{ + this->textfield::tick(); + Vector2 mouse=GetMousePosition(); + if(IsMouseButtonPressed(MOUSE_LEFT_BUTTON)){ + active=CheckCollisionPointRec(mouse,{pos.x,pos.y,size.x,size.y}); + } + if(active){ + int key=GetCharPressed(); + while(key>0){ + if(key>=32&&key<=125){ + content+=static_cast(key); + cpos++; + } + key=GetCharPressed(); + } + if(IsKeyPressed(KEY_BACKSPACE)&&content.length()>0){ + content.pop_back(); + cpos--; + } + if(IsKeyPressed(KEY_ENTER)){ + content+='\n'; + cpos++; + } + } + } + void draw()override{ + this->textfield::draw(); + if(active){ + Vector2 p=pos; + float lh=fs+2; + std::string line=""; + for(char ch:content){ + if(ch=='\n'){ + p.y+=lh; + line=""; + }else{ + line+=ch; + } + } + DrawRectangle(p.x+MeasureText(line.c_str(),fs),p.y,2,fs,rl::BLACK); + } + } + void exit()override{this->textfield::exit();} }; } diff --git a/engine/src/scenes/node2drelative.h b/engine/src/scenes/node2drelative.h index beede6a..06cc329 100644 --- a/engine/src/scenes/node2drelative.h +++ b/engine/src/scenes/node2drelative.h @@ -1,7 +1,6 @@ #pragma once #include -#include #include "nodes.h" #include namespace enginend::nodes::twod::relative { @@ -10,21 +9,38 @@ namespace enginend::nodes::twod::relative { double y; double w; double h; - node2d(); - node2d(double x,double y,double w=0,double h=0); + node2d(){x=0;y=0;w=0;h=0;} + node2d(double x,double y,double w=0,double h=0):x(x),y(y),w(w),h(h){} }; struct rect :virtual public node2d{ - rect(); - rect(double x,double y,double w,double h); + rect(){} + rect(double x,double y,double w,double h):node2d(x,y,w,h){} }; struct textured :virtual public rect{ Texture2D* texture; - textured(); - textured(Texture2D* texture,double x,double y,double w,double h); - void boot()override; - void tick()override; - void draw()override; - void exit()override; + textured(){texture=nullptr;} + textured(Texture2D* texture,double x,double y,double w,double h):texture(texture),rect(x,y,w,h){} + void boot() override{} + void tick() override{} + void draw()override{ + if(texture==nullptr)return; + float sw=GetScreenWidth(); + float sh=GetScreenHeight(); + float ax=x*sw; + float ay=y*sh; + float aw=w*sw; + float ah=h*sh; + tiny::echo("og: %f %f %f %f", x,y,w,h); + tiny::echo("transformed: %f %f %f %f", ax, ay, aw, ah); + DrawTexturePro(*texture,{0,0,(float)texture->width,(float)texture->height},{ax,ay,aw,ah},{0,0},0,rl::WHITE); + } + void exit()override { + if(texture){ + UnloadTexture(*texture); + delete texture; + texture=nullptr; + } + } }; struct animated :virtual public textured{ Image animimage; @@ -34,28 +50,87 @@ namespace enginend::nodes::twod::relative { int framecounter; int prevframe; unsigned int nextframeoffset; - animated(); - animated(const char* gifpath,double x,double y,double w,double h,int delay=6); - void tick()override; - void draw()override; - void exit()override; + animated():frames(0),currentframe(1),framedelay(6),framecounter(0),nextframeoffset(0){ + animimage.data=nullptr; + prevframe=currentframe; + } + animated(const char* gifpath,double x,double y,double w,double h,int delay=6): + textured(nullptr,x,y,w,h),framedelay(delay),currentframe(1),framecounter(0),frames(0),nextframeoffset(0) + { + prevframe=currentframe; + this->x=x; this->y=y; this->w=w; this->h=h; + animimage=LoadImageAnim(gifpath,&frames); + if(frames>0){ + texture=new Texture2D(LoadTextureFromImage(animimage)); + } + } + void tick()override{ + if(frames<=1)return; + framecounter++; + if(framecounter>=framedelay){ + framecounter=0; + currentframe++; + if(currentframe>=frames)currentframe=0; + nextframeoffset=animimage.width*animimage.height*4*currentframe; + tiny::echo("updating node\nframes: %i\n current frame: %i",frames,currentframe); + tiny::echo("%i",nextframeoffset); + } + } + void draw()override { + if (prevframe!=currentframe){ + prevframe=currentframe; + UpdateTexture(*this->texture,((unsigned char*)animimage.data)+nextframeoffset); + } + textured::draw(); + } + void exit()override{ + if(animimage.data)UnloadImage(animimage); + textured::exit(); + } }; struct colored :virtual public rect{ Color c; - colored(); - colored(Color color,double x,double y,double w,double h); - void boot()override; - void tick()override; - void draw()override; - void exit()override; + colored(){} + colored(Color color,double x,double y,double w,double h):c(color),rect(x,y,w,h){} + void boot()override{} + void tick()override{} + void draw()override{ + float sw=GetScreenWidth(); + float sh=GetScreenHeight(); + float ax=x*sw; + float ay=y*sh; + float aw=w*sw; + float ah=h*sh; + DrawRectangle(ax,ay,aw,ah,c); + } + void exit()override{} }; struct tinted :virtual public colored,virtual public textured{ - tinted(); - tinted(Texture2D* texture,Color color,double x,double y,double w,double h); - void boot()override; - void tick()override; - void draw()override; - void exit()override; + tinted(){} + tinted(Texture2D* texture,Color color,double x,double y,double w,double h): + node2d(x,y,w,h), + rect(x,y,w,h), + colored(color,x,y,w,h), + textured(texture,x,y,w,h) + {} + void boot()override{} + void tick()override{} + void draw()override{ + if(texture==nullptr) { + colored::draw(); + return; + } + float sw=GetScreenWidth(); + float sh=GetScreenHeight(); + float ax=x*sw; + float ay=y*sh; + float aw=w*sw; + float ah=h*sh; + DrawTexturePro(*texture,{0,0,(float)texture->width,(float)texture->height},{ax,ay,aw,ah},{0,0},0,c); + } + void exit()override{ + textured::exit(); + } }; struct text :public tinted { protected: @@ -63,12 +138,55 @@ namespace enginend::nodes::twod::relative { public: float fs; std::string content; - text(); - text(Texture2D* texture,enginend::theme* theme,double x,double y,double w,double h,float fsize,std::string txt); - void boot()override; - void tick()override; - void draw()override; - void exit()override; + text(){fs=20;} + text(Texture2D* texture,enginend::theme* theme,double x,double y,double w,double h,float fsize,std::string txt): + //tinted(texture,color,x,y,w,h), + fs(fsize),content(txt) + { + this->x=x;this->y=y;this->w=w;this->h=h; + this->texture=texture;this->theme=theme; + result=content; + size_t initp=0; + while((initp=result.find("\n",initp))!=std::string::npos){ + result.replace(initp,1,"\\n"); + initp+=2; + } + } + void boot()override{} + void tick()override { + if(result!=content){ + result=content; + size_t initp=0; + while((initp=result.find("\n",initp))!=std::string::npos){ + result.replace(initp,1,"\\n"); + initp+=2; + } + } + } + void draw()override { + float sw=GetScreenWidth(); + float sh=GetScreenHeight(); + float ax=x*sw; + float ay=y*sh; + + float aw=w*sw; + float ah=h*sh; + tiny::echo("og: %f %f %f %f", x,y,w,h); + tiny::echo("drawing text: %s", content.c_str()); + tiny::echo("transformed: %f %f %f %f", ax, ay, aw, ah); + Vector2 minsize=MeasureTextEx(this->theme->font,content.c_str(),fs,1); + Vector2 charsize=MeasureTextEx(this->theme->font," ",fs,1); + float p=charsize.x>charsize.y?charsize.x/minsize.x:charsize.y/minsize.y; + p=p*2; + int minh=(minsize.y>ah)?minsize.y:ah; + int minw=(minsize.x>aw)?minsize.x:aw; + DrawRectangle(ax-charsize.x,ay-charsize.y,minw+p,minh+p,this->theme->background); + DrawTextEx(this->theme->font,content.c_str(),{ax,ay},fs,1,this->theme->text); + DrawRectangleLines(ax, ay, aw, ah, this->theme->border); + } + void exit()override{ + tinted::exit(); + } }; struct button :virtual public tinted{ std::function func; @@ -76,64 +194,275 @@ namespace enginend::nodes::twod::relative { bool hover; const bool isboolean; bool boolean=false; - button(); - button(Texture2D* texture,enginend::theme* theme,double x,double y,double w,double h,std::function f); - button(Texture2D* texture,enginend::theme* theme,double x,double y,double w,double h,std::function f,bool isboolean); - void boot()override; - void tick()override; - void draw()override; - void exit()override; + button():func(nullptr),pressed(false),hover(false),isboolean(false){} + button(Texture2D* texture,enginend::theme* theme,double x,double y,double w,double h,std::function f):func(f),pressed(false),hover(false),isboolean(false) { + this->theme=theme;this->texture=texture;this->x=x;this->y=y;this->w=w;this->h=h; + }button(Texture2D* texture,enginend::theme* theme,double x,double y,double w,double h,std::function f,bool isboolean):func(f),pressed(false),hover(false),isboolean(isboolean) { + this->theme=theme;this->texture=texture;this->x=x;this->y=y;this->w=w;this->h=h; + } + void boot()override{} + void tick()override{ + } + void draw()override { + + Vector2 mouse=GetMousePosition(); + float sw=GetScreenWidth(); + float sh=GetScreenHeight(); + Rectangle r={float(x*sw),float(y*sh),float(w*sw),float(h*sh)}; + if(CheckCollisionPointRec(mouse,r)){hover=true; + if(IsMouseButtonPressed(MOUSE_LEFT_BUTTON)){ + pressed=true; + c=isboolean?boolean? + this->theme->booleanbutton[5]:this->theme->booleanbutton[2]: + this->theme->button[2]; + if(func)func(); + }else{ + pressed=false; + c=isboolean?boolean? + this->theme->booleanbutton[4]:this->theme->booleanbutton[1]: + this->theme->button[1]; + } + }else{ + hover=false; + pressed=false; + c=isboolean?boolean? + this->theme->booleanbutton[3]:this->theme->booleanbutton[0]: + this->theme->button[0]; + } + float ax=x*sw; + float ay=y*sh; + float aw=w*sw; + float ah=h*sh; + DrawRectangle(ax,ay,aw,ah,c); + DrawRectangleLines(ax, ay, aw, ah, this->theme->border); + } + void exit()override{ + tinted::exit(); + } }; struct labeledbutton :virtual public button { std::string label; int fs; Color txc; - labeledbutton(std::string name,Texture2D* texture,enginend::theme* theme, - double x,double y,double w,double h,std::function f,int size); - labeledbutton(std::string name,Texture2D* texture,enginend::theme* theme, - double x,double y,double w,double h,std::function f,int size,bool isboolean); - void boot()override; - void tick()override; - void draw()override; - void exit()override; + labeledbutton(std::string name,Texture2D* texture,enginend::theme*theme, + double x,double y,double w,double h,std::function f,int size):fs(size),label(name), + button(texture,theme,x,y,w,h,f) + {} + labeledbutton(std::string name,Texture2D* texture,enginend::theme*theme, + double x,double y,double w,double h,std::function f, + int size,bool isboolean):fs(size),label(name), + button(texture,theme,x,y,w,h,f,isboolean) + {} + void boot()override{} + void tick()override{ + button::tick(); + } + void draw()override{ + button::draw(); + float sw=GetScreenWidth(); + float sh=GetScreenHeight(); + float ax=x*sw; + float ay=y*sh; + float aw=w*sw; + float ah=h*sh; + tiny::echo("ax %f x %f sw %f",ax,x,sw); + tiny::echo("ay %f y %f sh %f",ay,y,sh); + tiny::echo("aw %f w %f sw %f",aw,w,sw); + tiny::echo("ah %f h %f sh %f",ah,h,sh); + Vector2 tsize=MeasureTextEx(this->theme->font,label.c_str(),fs,1); + Vector2 tpos={ + ax+(aw-tsize.x)/2, + ay+(ah-tsize.y)/2 + }; + tiny::echo("tsize\nw %f h %f",tsize.x,tsize.y); + tiny::echo("tpos\nx %f y %f",tpos.x,tpos.y); + if (hover) { + if (pressed) { + txc=isboolean?boolean? + this->theme->booleantext[5]:this->theme->booleantext[2]: + this->theme->buttontext[2]; + }else { + txc=isboolean?boolean? + this->theme->booleantext[4]:this->theme->booleantext[1]: + this->theme->buttontext[1]; + } + }else { + txc=isboolean?boolean? + this->theme->booleantext[3]:this->theme->booleantext[0]: + this->theme->buttontext[0]; + } + DrawTextEx(this->theme->font,label.c_str(),tpos,fs,1,txc); + DrawRectangleLinesEx({ax, ay, aw, ah},5., this->theme->border); + } + void exit()override{ + button::exit(); + } }; struct slider :virtual public tinted{ float val; float minv; float maxv; - slider(); - slider(Texture2D* texture,Color color,double x,double y,double w,double h,float min,float max,float v); - void boot()override; - void tick()override; - void draw()override; - void exit()override; + slider():val(0),minv(0),maxv(1){} + slider(Texture2D* texture,Color color,double x,double y,double w,double h,float min,float max,float v):val(v),minv(min),maxv(max),tinted(texture,color,x,y,w,h){} + void boot()override{} + void tick()override{ + Vector2 mouse=GetMousePosition(); + float sw=GetScreenWidth(); + float sh=GetScreenHeight(); + Rectangle r={float(x*sw),float(y*sh),float(w*sw),float(h*sh)}; + if(CheckCollisionPointRec(mouse,r)&&IsMouseButtonDown(MOUSE_LEFT_BUTTON)){ + float t=(mouse.x-(x*sw))/(w*sw); + val=minv+t*(maxv-minv); + if(valmaxv)val=maxv; + } + } + void draw()override{ + float sw=GetScreenWidth(); + float sh=GetScreenHeight(); + float ax=x*sw; + float ay=y*sh; + float aw=w*sw; + float ah=h*sh; + DrawRectangle(ax,ay,aw,ah,rl::DARKGRAY); + float t=(val-minv)/(maxv-minv); + DrawRectangle(ax,ay,aw*t,ah,c); + } + void exit()override{ + tinted::exit(); + } }; struct textfield :public text{ - textfield(); - textfield(Texture2D* texture,enginend::theme* theme,double x,double y,double w,double h,float fsize,std::string txt); - void boot()override; - void tick()override; - void draw()override; - void exit()override; + textfield(){} + textfield(Texture2D* texture,enginend::theme *theme,double x,double y,double w,double h,float fsize,std::string txt): + text(texture,theme,x,y,w,h,fsize,txt){} + void boot()override{} + void tick()override{ + text::tick(); + } + void draw()override{ + float sw=GetScreenWidth(); + float sh=GetScreenHeight(); + float ax=x*sw; + float ay=y*sh; + float aw=w*sw; + float ah=h*sh; + Vector2 charsize=MeasureTextEx(this->theme->font," ",fs,0); + Vector2 minsize=MeasureTextEx(this->theme->font,content.c_str(),fs,charsize.x/2); + float po=charsize.x>charsize.y?charsize.x/charsize.y:charsize.y/charsize.x;po=po*5; + int minh=(minsize.y>ah)?minsize.y:ah; + int minw=(minsize.x>aw)?minsize.x:aw; + DrawRectangle(ax-(po/2),ay-(po/2),minw+(po*1.1),minh+(po*1.1),this->theme->textfieldbg); + DrawTextEx(this->theme->font,content.c_str(),{ax,ay},fs,charsize.x/2,this->theme->text); + } + void exit()override{ + text::exit(); + } }; struct textinput :public text{ bool active; int cpos; - textinput(); - textinput(Texture2D* texture,enginend::theme* theme,double x,double y,double w,double h,float fsize); - void boot()override; - void tick()override; - void draw()override; - void exit()override; + textinput():active(false),cpos(0){} + textinput(Texture2D* texture,enginend::theme *theme,double x,double y,double w,double h,float fsize):active(false),cpos(0), + text(texture,theme,x,y,w,h,fsize,""){} + void boot()override{} + void tick()override{ + text::tick(); + Vector2 mouse=GetMousePosition(); + float sw=GetScreenWidth(); + float sh=GetScreenHeight(); + Rectangle r={float(x*sw),float(y*sh),float(w*sw),float(h*sh)}; + if(IsMouseButtonPressed(MOUSE_LEFT_BUTTON)){ + active=CheckCollisionPointRec(mouse,r); + } + if(active){ + int key=GetCharPressed(); + while(key>0){ + if(key>=32&&key<=125){ + content+=static_cast(key); + cpos++; + } + key=GetCharPressed(); + } + if(IsKeyPressed(KEY_BACKSPACE)&&content.length()>0){ + content.pop_back(); + cpos--; + } + } + } + void draw()override{ + text::draw(); + if(active){ + float sw=GetScreenWidth(); + float sh=GetScreenHeight(); + float ax=x*sw; + float ay=y*sh; + DrawRectangle(ax+MeasureTextEx(this->theme->font,content.c_str(),fs,1).x,ay,2,fs,{0,0,0,127}); + } + } + void exit()override{ + text::exit(); + } }; struct textinputfield :public textfield{ bool active; int cpos; - textinputfield(); - textinputfield(Texture2D* texture,enginend::theme* theme,double x,double y,double w,double h,float fsize); - void boot()override; - void tick()override; - void draw()override; - void exit()override; + textinputfield():active(false),cpos(0){} + textinputfield(Texture2D* texture,enginend::theme *theme,double x,double y,double w,double h,float fsize):active(false),cpos(0), + textfield(texture,theme,x,y,w,h,fsize,""){} + void boot()override{} + void tick()override{ + textfield::tick(); + Vector2 mouse=GetMousePosition(); + float sw=GetScreenWidth(); + float sh=GetScreenHeight(); + Rectangle r={float(x*sw),float(y*sh),float(w*sw),float(h*sh)}; + if(IsMouseButtonPressed(MOUSE_LEFT_BUTTON)){ + active=CheckCollisionPointRec(mouse,r); + } + if(active){ + int key=GetCharPressed(); + while(key>0){ + if(key>=32&&key<=125){ + content+=static_cast(key); + cpos++; + } + key=GetCharPressed(); + } + if(IsKeyPressed(KEY_BACKSPACE)&&content.length()>0){ + content.pop_back(); + cpos--; + } + if(IsKeyPressed(KEY_ENTER)){ + content+='\n'; + cpos++; + } + } + } + void draw()override{ + textfield::draw(); + if(active){ + float sw=GetScreenWidth(); + float sh=GetScreenHeight(); + float ax=x*sw; + float ay=y*sh; + float lh=fs+2; + Vector2 p={ax,ay}; + std::string line=""; + for(char ch:content){ + if(ch=='\n'){ + p.y+=lh; + line=""; + }else{ + line+=ch; + } + } + DrawRectangle(p.x+MeasureTextEx(this->theme->font,line.c_str(),fs,1).x,p.y,2,fs,rl::BLACK); + } + } + void exit()override{ + textfield::exit(); + } }; } + diff --git a/engine/src/scenes/node3d.h b/engine/src/scenes/node3d.h index a46f97f..cfab994 100644 --- a/engine/src/scenes/node3d.h +++ b/engine/src/scenes/node3d.h @@ -8,42 +8,50 @@ namespace enginend::nodes::trid { Shader* shader; Color tint; node3d(){} - node3d(Vector3 pos,Vector3 rot,Vector3 size,Vector3 scale); + node3d(Vector3 pos,Vector3 rot,Vector3 size,Vector3 scale): + pos(pos),rot(rot),scale(scale),size(size) { + tint={255,255,255,255}; + } }; struct physicsagent:virtual public node3d { bool hardbody,isphysics; std::vector* bboxes; - physicsagent(); - physicsagent(bool hardbody,bool isphysics); - physicsagent(bool hardbody,bool isphysics,std::vector* bboxes); - void boot() override; - void tick() override; - void draw() override; - void exit() override; + physicsagent():hardbody(false),isphysics(false) { + bboxes = new std::vector(); + } + physicsagent(bool hardbody,bool isphysics):hardbody(hardbody),isphysics(isphysics) { + bboxes = new std::vector(); + } + physicsagent(bool hardbody,bool isphysics,std::vector* bboxes): + hardbody(hardbody),isphysics(isphysics),bboxes(bboxes) { + + } }; - + struct billboard:virtual public physicsagent { - Texture2D texture; - char*texpath; - billboard(){} - billboard(Vector3 pos,Vector3 rot,Vector3 size,Vector3 scale,char* texture); - void boot() override; - void tick() override; - void draw() override; - void exit() override; + Texture2D* texture; + billboard(){texture=nullptr;} + billboard(Vector3 pos,Vector3 rot,Vector3 size,Vector3 scale,Texture2D* texture): + node3d(pos,rot,size,scale),texture(texture){} + void boot() override { + + } + void draw() override { + DrawBillboard(*watcher,*texture,pos,1.,tint); + } + void exit() override { + } }; - struct object3d:public physicsagent { Model* model; - const char *path; - object3d(const char* path); - void boot() override; - void tick() override; - void draw() override; - void exit() override; + void draw() override { + DrawModel(*model,pos,1.,tint); + } + void exit() override { + } }; - + struct animatedbillboard:virtual public physicsagent { Image animimage; int frames; @@ -53,22 +61,68 @@ namespace enginend::nodes::trid { unsigned int nextframeoffset; int prevframe; Texture2D* texture; - animatedbillboard(); - animatedbillboard(const char* gifpath, int delay = 6,Vector3 pos={},Vector3 rot={},Vector3 size={},Vector3 scale={}); - void tick() override; - void draw() override; - void exit() override; - }; + + animatedbillboard() : frames(0), currentframe(0), framedelay(6), framecounter(0), nextframeoffset(0) { + animimage.data = nullptr; + } + animatedbillboard(const char* gifpath, int delay = 6,Vector3 pos={},Vector3 rot={},Vector3 size={},Vector3 scale={}):node3d(pos,rot,size,scale), + framedelay(delay), currentframe(0), framecounter(0), frames(0), nextframeoffset(0) + { + animimage = LoadImageAnim(gifpath, &frames); + if (frames > 0) { + texture = new Texture2D(LoadTextureFromImage(animimage)); + } + } + void tick() override { + if (frames <= 1) return; + + framecounter++; + if (framecounter >= framedelay) { + framecounter = 0; + currentframe++; + if (currentframe >= frames) currentframe = 0; + nextframeoffset = animimage.width * animimage.height * 4 * currentframe; + } + } + + void draw() override { + + if (prevframe!=currentframe){ + prevframe=currentframe; + UpdateTexture(*this->texture,((unsigned char*)animimage.data)+nextframeoffset); + } + DrawBillboard(*watcher,*texture,pos,1.,tint); + } + void exit() override { + if (animimage.data) UnloadImage(animimage); + if (texture) { + UnloadTexture(*texture); + delete texture; + texture = nullptr; + } + } + }; struct animatedmodel:virtual public physicsagent { std::vector *animation; Model *model; int animcount; int curranimation=0; int currentframe=0; - animatedmodel(); - animatedmodel(Model *model,std::vector* animation,int animcount,Vector3 pos,Vector3 rot,Vector3 size,Vector3 scale); - void draw() override; - void exit() override; + animatedmodel() { + model = nullptr; + animation = nullptr; + } + animatedmodel(Model *model,std::vector* animation,int animcount,Vector3 pos,Vector3 rot,Vector3 size,Vector3 scale): + model(model), animation(animation),node3d(pos,rot,size,scale),animcount(animcount) + {} + void draw() override { + UpdateModelAnimationBones(*model,(*animation)[curranimation],currentframe++); + if (currentframe >= (*animation)[curranimation].frameCount) currentframe = 0; + DrawModel(*model,pos,1.,tint); + } + void exit() override { + } }; -} + +} \ No newline at end of file diff --git a/engine/src/scenes/nodes.h b/engine/src/scenes/nodes.h index 1e9f09b..af0b863 100644 --- a/engine/src/scenes/nodes.h +++ b/engine/src/scenes/nodes.h @@ -1,5 +1,4 @@ #pragma once -#include #include #include "../gr.h" @@ -12,26 +11,26 @@ namespace nodes { struct node{ - enginend::theme*theme{}; - - virtual void boot()=0; - virtual void tick()=0; - virtual void draw()=0; - virtual void exit()=0; + public: + enginend::theme* theme; + virtual void boot()=0; + virtual void tick()=0; + virtual void draw()=0; + virtual void exit()=0; }; } struct group : public virtual enginend::nodes::node { std::vector children; - explicit group(std::vector nodes):children(std::move(nodes)){}; + explicit group(std::vector nodes):children(nodes){}; - void boot() override {for (node* n: children){n->boot();}} - void tick() override {for (node* n: children){n->tick();}} - void draw() override {for (node* n: children){n->draw();}} - void exit() override {for (node* n: children){n->exit();}} + void boot(){for (node* n: children){n->boot();}} + void tick(){for (node* n: children){n->tick();}} + void draw(){for (node* n: children){n->draw();}} + void exit(){for (node* n: children){n->exit();}} }; - struct theme { + typedef struct theme { Color booleanbutton[6],button[3],booleantext[6],buttontext[3],text,buttonborder[3],booleanborder[6],border,background ,textfieldbg ; diff --git a/engine/src/scenes/scene.h b/engine/src/scenes/scene.h index 61265d2..95ad4a9 100644 --- a/engine/src/scenes/scene.h +++ b/engine/src/scenes/scene.h @@ -2,16 +2,14 @@ #include "nodes.h" #include "node2d.h" -#include "node3d.h" #include "node2drelative.h" #include namespace enginend { struct scene{ - std::vector nodes; - virtual void boot() { + virtual void boot() { int i=0; tiny::echo((char*)"initializing scene"); for (enginend::nodes::node* n : nodes) { diff --git a/engine/src/scenes/stuf.cpp b/engine/src/scenes/stuf.cpp deleted file mode 100644 index 3884630..0000000 --- a/engine/src/scenes/stuf.cpp +++ /dev/null @@ -1,2 +0,0 @@ -#include "scene.h" - diff --git a/engine/test.cpp b/engine/test.cpp index d5895af..fce4c43 100644 --- a/engine/test.cpp +++ b/engine/test.cpp @@ -13,10 +13,10 @@ public: InitWindow(500,500,"test"); SetTargetFPS(GetMonitorRefreshRate(GetCurrentMonitor())); this->tickrate=GetMonitorRefreshRate(GetCurrentMonitor()); - s.nodes=std::vector{ + s.nodes=std::list{ - new nodes::twod::colored(Color{255,255,255,255},0,0,500,500), - new nodes::twod::textfield(nullptr,enginend::DEFAULT + new nodes::colored(Color{255,255,255,255},0,0,500,500), + new nodes::textfield(nullptr,enginend::DEFAULT ,100,100,220,32,32, "welcome to enginend!\n" "hehe" diff --git a/engine/test/test b/engine/test/test deleted file mode 100755 index 9fe9d23..0000000 Binary files a/engine/test/test and /dev/null differ diff --git a/games/animatronical/q1/a1/CMakeLists.txt b/games/animatronical/q1/a1/CMakeLists.txt deleted file mode 100644 index e960d79..0000000 --- a/games/animatronical/q1/a1/CMakeLists.txt +++ /dev/null @@ -1,22 +0,0 @@ -cmake_minimum_required(VERSION 3.20) - -set(CMAKE_CXX_FLAGS "-std=c++26 -Wno-error -O0 -w -g -mavx2") -file(GLOB_RECURSE ANIMSOURCES CONFIGURE_DEPENDS "src/*.cpp") -add_executable(animatronical-1 ${ANIMSOURCES}) -if(NOT DEFINED ${ARCH}) - set(ARCH "linux-64") -endif(NOT DEFINED ${ARCH}) -set_target_properties(animatronical-1 PROPERTIES - RUNTIME_OUTPUT_DIRECTORY "${CMAKE_SOURCE_DIR}/built/ani/1/1/${PLATFORM_DIR}/bin" -) - -target_link_directories( - animatronical-1 PUBLIC - "${CMAKE_SOURCE_DIR}/link") -target_link_libraries(animatronical-1 PRIVATE - enginend - raylib -) -target_include_directories(animatronical-1 PUBLIC - ${CMAKE_SOURCE_DIR}/include -) \ No newline at end of file diff --git a/games/animatronical/q1/a1/res/cursor/down.png b/games/animatronical/q1/a1/res/cursor/down.png deleted file mode 100755 index 580913b..0000000 Binary files a/games/animatronical/q1/a1/res/cursor/down.png and /dev/null differ diff --git a/games/animatronical/q1/a1/res/cursor/empty.png b/games/animatronical/q1/a1/res/cursor/empty.png deleted file mode 100755 index a65561f..0000000 Binary files a/games/animatronical/q1/a1/res/cursor/empty.png and /dev/null differ diff --git a/games/animatronical/q1/a1/res/cursor/flashlight.png b/games/animatronical/q1/a1/res/cursor/flashlight.png deleted file mode 100755 index cd06f3c..0000000 Binary files a/games/animatronical/q1/a1/res/cursor/flashlight.png and /dev/null differ diff --git a/games/animatronical/q1/a1/res/cursor/interact.png b/games/animatronical/q1/a1/res/cursor/interact.png deleted file mode 100755 index 945483d..0000000 Binary files a/games/animatronical/q1/a1/res/cursor/interact.png and /dev/null differ diff --git a/games/animatronical/q1/a1/res/cursor/left.png b/games/animatronical/q1/a1/res/cursor/left.png deleted file mode 100755 index 60a5369..0000000 Binary files a/games/animatronical/q1/a1/res/cursor/left.png and /dev/null differ diff --git a/games/animatronical/q1/a1/res/cursor/right.png b/games/animatronical/q1/a1/res/cursor/right.png deleted file mode 100755 index 8c9f34d..0000000 Binary files a/games/animatronical/q1/a1/res/cursor/right.png and /dev/null differ diff --git a/games/animatronical/q1/a1/res/cursor/up.png b/games/animatronical/q1/a1/res/cursor/up.png deleted file mode 100755 index 77d86a7..0000000 Binary files a/games/animatronical/q1/a1/res/cursor/up.png and /dev/null differ diff --git a/games/animatronical/q1/a1/res/font/eagle.ttf b/games/animatronical/q1/a1/res/font/eagle.ttf deleted file mode 100755 index ad67d13..0000000 Binary files a/games/animatronical/q1/a1/res/font/eagle.ttf and /dev/null differ diff --git a/games/animatronical/q1/a1/res/font/eagle2.ttf b/games/animatronical/q1/a1/res/font/eagle2.ttf deleted file mode 100755 index bff0f5a..0000000 Binary files a/games/animatronical/q1/a1/res/font/eagle2.ttf and /dev/null differ diff --git a/games/animatronical/q1/a1/res/font/mga.ttf b/games/animatronical/q1/a1/res/font/mga.ttf deleted file mode 100755 index ff183da..0000000 Binary files a/games/animatronical/q1/a1/res/font/mga.ttf and /dev/null differ diff --git a/games/animatronical/q1/a1/res/gui/buttonf.png b/games/animatronical/q1/a1/res/gui/buttonf.png deleted file mode 100755 index fbceda1..0000000 Binary files a/games/animatronical/q1/a1/res/gui/buttonf.png and /dev/null differ diff --git a/games/animatronical/q1/a1/res/gui/buttonn.png b/games/animatronical/q1/a1/res/gui/buttonn.png deleted file mode 100755 index 580c5d1..0000000 Binary files a/games/animatronical/q1/a1/res/gui/buttonn.png and /dev/null differ diff --git a/games/animatronical/q1/a1/res/gui/run.png b/games/animatronical/q1/a1/res/gui/run.png deleted file mode 100755 index afdb8db..0000000 Binary files a/games/animatronical/q1/a1/res/gui/run.png and /dev/null differ diff --git a/games/animatronical/q1/a1/res/gui/skailevisor.png b/games/animatronical/q1/a1/res/gui/skailevisor.png deleted file mode 100755 index d3a1854..0000000 Binary files a/games/animatronical/q1/a1/res/gui/skailevisor.png and /dev/null differ diff --git a/games/animatronical/q1/a1/res/gui/tired.png b/games/animatronical/q1/a1/res/gui/tired.png deleted file mode 100755 index cc4621f..0000000 Binary files a/games/animatronical/q1/a1/res/gui/tired.png and /dev/null differ diff --git a/games/animatronical/q1/a1/res/gui/walk.png b/games/animatronical/q1/a1/res/gui/walk.png deleted file mode 100755 index d2abfb5..0000000 Binary files a/games/animatronical/q1/a1/res/gui/walk.png and /dev/null differ diff --git a/games/animatronical/q1/a1/res/icon.png b/games/animatronical/q1/a1/res/icon.png deleted file mode 100755 index 7648d33..0000000 Binary files a/games/animatronical/q1/a1/res/icon.png and /dev/null differ diff --git a/games/animatronical/q1/a1/res/loading/out2.gif b/games/animatronical/q1/a1/res/loading/out2.gif deleted file mode 100644 index 3a027c7..0000000 Binary files a/games/animatronical/q1/a1/res/loading/out2.gif and /dev/null differ diff --git a/games/animatronical/q1/a1/res/menu/000.png b/games/animatronical/q1/a1/res/menu/000.png deleted file mode 100644 index 3114d27..0000000 Binary files a/games/animatronical/q1/a1/res/menu/000.png and /dev/null differ diff --git a/games/animatronical/q1/a1/res/menu/001.png b/games/animatronical/q1/a1/res/menu/001.png deleted file mode 100644 index ec85e92..0000000 Binary files a/games/animatronical/q1/a1/res/menu/001.png and /dev/null differ diff --git a/games/animatronical/q1/a1/res/menu/010.png b/games/animatronical/q1/a1/res/menu/010.png deleted file mode 100644 index cd7262c..0000000 Binary files a/games/animatronical/q1/a1/res/menu/010.png and /dev/null differ diff --git a/games/animatronical/q1/a1/res/menu/011.png b/games/animatronical/q1/a1/res/menu/011.png deleted file mode 100644 index 2112e7b..0000000 Binary files a/games/animatronical/q1/a1/res/menu/011.png and /dev/null differ diff --git a/games/animatronical/q1/a1/res/menu/100.png b/games/animatronical/q1/a1/res/menu/100.png deleted file mode 100644 index 11e6917..0000000 Binary files a/games/animatronical/q1/a1/res/menu/100.png and /dev/null differ diff --git a/games/animatronical/q1/a1/res/menu/101.png b/games/animatronical/q1/a1/res/menu/101.png deleted file mode 100644 index d7c1c37..0000000 Binary files a/games/animatronical/q1/a1/res/menu/101.png and /dev/null differ diff --git a/games/animatronical/q1/a1/res/menu/110.png b/games/animatronical/q1/a1/res/menu/110.png deleted file mode 100644 index 22dfea5..0000000 Binary files a/games/animatronical/q1/a1/res/menu/110.png and /dev/null differ diff --git a/games/animatronical/q1/a1/res/menu/111.png b/games/animatronical/q1/a1/res/menu/111.png deleted file mode 100644 index 14df2a2..0000000 Binary files a/games/animatronical/q1/a1/res/menu/111.png and /dev/null differ diff --git a/games/animatronical/q1/a1/res/menu/title.png b/games/animatronical/q1/a1/res/menu/title.png deleted file mode 100644 index d1db3ed..0000000 Binary files a/games/animatronical/q1/a1/res/menu/title.png and /dev/null differ diff --git a/games/animatronical/q1/a1/res/snd/song.mp3 b/games/animatronical/q1/a1/res/snd/song.mp3 deleted file mode 100755 index 601bb94..0000000 Binary files a/games/animatronical/q1/a1/res/snd/song.mp3 and /dev/null differ diff --git a/games/animatronical/q1/a1/res/sprites/skaile/rest.png b/games/animatronical/q1/a1/res/sprites/skaile/rest.png deleted file mode 100755 index 60b9bd6..0000000 Binary files a/games/animatronical/q1/a1/res/sprites/skaile/rest.png and /dev/null differ diff --git a/games/animatronical/q1/a1/ressrc/NewCanvas1.png b/games/animatronical/q1/a1/ressrc/NewCanvas1.png deleted file mode 100755 index 680f0da..0000000 Binary files a/games/animatronical/q1/a1/ressrc/NewCanvas1.png and /dev/null differ diff --git a/games/animatronical/q1/a1/ressrc/closet.png b/games/animatronical/q1/a1/ressrc/closet.png deleted file mode 100755 index 680f0da..0000000 Binary files a/games/animatronical/q1/a1/ressrc/closet.png and /dev/null differ diff --git a/games/animatronical/q1/a1/ressrc/closeto.png b/games/animatronical/q1/a1/ressrc/closeto.png deleted file mode 100755 index cc4d757..0000000 Binary files a/games/animatronical/q1/a1/ressrc/closeto.png and /dev/null differ diff --git a/games/animatronical/q1/a1/ressrc/controls.png b/games/animatronical/q1/a1/ressrc/controls.png deleted file mode 100755 index 208cf7b..0000000 Binary files a/games/animatronical/q1/a1/ressrc/controls.png and /dev/null differ diff --git a/games/animatronical/q1/a1/ressrc/dither.png b/games/animatronical/q1/a1/ressrc/dither.png deleted file mode 100755 index 266ca7a..0000000 Binary files a/games/animatronical/q1/a1/ressrc/dither.png and /dev/null differ diff --git a/games/animatronical/q1/a1/ressrc/door.png b/games/animatronical/q1/a1/ressrc/door.png deleted file mode 100755 index d45517e..0000000 Binary files a/games/animatronical/q1/a1/ressrc/door.png and /dev/null differ diff --git a/games/animatronical/q1/a1/ressrc/fkitiles.png b/games/animatronical/q1/a1/ressrc/fkitiles.png deleted file mode 100755 index 644193e..0000000 Binary files a/games/animatronical/q1/a1/ressrc/fkitiles.png and /dev/null differ diff --git a/games/animatronical/q1/a1/ressrc/fridge.png b/games/animatronical/q1/a1/ressrc/fridge.png deleted file mode 100755 index 4dcf3a7..0000000 Binary files a/games/animatronical/q1/a1/ressrc/fridge.png and /dev/null differ diff --git a/games/animatronical/q1/a1/ressrc/house.blend b/games/animatronical/q1/a1/ressrc/house.blend deleted file mode 100644 index 9179fcc..0000000 Binary files a/games/animatronical/q1/a1/ressrc/house.blend and /dev/null differ diff --git a/games/animatronical/q1/a1/ressrc/house.blend1 b/games/animatronical/q1/a1/ressrc/house.blend1 deleted file mode 100644 index 8cd9249..0000000 Binary files a/games/animatronical/q1/a1/ressrc/house.blend1 and /dev/null differ diff --git a/games/animatronical/q1/a1/ressrc/kb1.png b/games/animatronical/q1/a1/ressrc/kb1.png deleted file mode 100755 index e6c818b..0000000 Binary files a/games/animatronical/q1/a1/ressrc/kb1.png and /dev/null differ diff --git a/games/animatronical/q1/a1/ressrc/kb2.png b/games/animatronical/q1/a1/ressrc/kb2.png deleted file mode 100755 index f9a3c35..0000000 Binary files a/games/animatronical/q1/a1/ressrc/kb2.png and /dev/null differ diff --git a/games/animatronical/q1/a1/ressrc/kb3.png b/games/animatronical/q1/a1/ressrc/kb3.png deleted file mode 100755 index 1b770bb..0000000 Binary files a/games/animatronical/q1/a1/ressrc/kb3.png and /dev/null differ diff --git a/games/animatronical/q1/a1/ressrc/out2.png b/games/animatronical/q1/a1/ressrc/out2.png deleted file mode 100755 index d833fe6..0000000 Binary files a/games/animatronical/q1/a1/ressrc/out2.png and /dev/null differ diff --git a/games/animatronical/q1/a1/ressrc/outside.png b/games/animatronical/q1/a1/ressrc/outside.png deleted file mode 100755 index 8e10d9a..0000000 Binary files a/games/animatronical/q1/a1/ressrc/outside.png and /dev/null differ diff --git a/games/animatronical/q1/a1/ressrc/poster.png b/games/animatronical/q1/a1/ressrc/poster.png deleted file mode 100755 index b757821..0000000 Binary files a/games/animatronical/q1/a1/ressrc/poster.png and /dev/null differ diff --git a/games/animatronical/q1/a1/ressrc/render.py b/games/animatronical/q1/a1/ressrc/render.py deleted file mode 100644 index a809c4b..0000000 --- a/games/animatronical/q1/a1/ressrc/render.py +++ /dev/null @@ -1,20 +0,0 @@ -import os -import bpy -modes=["on","off","urcooked"] -sides=['s','n','r','l'] -quality=99 -frame=0 -cmd=os.path.dirname(os.path.abspath(__file__)) -path=os.path.join(cmd,"../res/map") - -for mode in modes: - for side in sides: - for i in range(17): - out=os.path.abspath(f"{path}/{mode}/{side}/{i}.png") - bpy.context.scene.frame_set(frame) - os.makedirs(os.path.dirname(out),exist_ok=True) - bpy.context.scene.render.filepath=out - bpy.context.scene.render.image_settings.file_format='PNG' - bpy.context.scene.render.image_settings.quality=quality - bpy.ops.render.render(write_still=True) - frame+=1 \ No newline at end of file diff --git a/games/animatronical/q1/a1/ressrc/screen.png b/games/animatronical/q1/a1/ressrc/screen.png deleted file mode 100755 index a06b2d9..0000000 Binary files a/games/animatronical/q1/a1/ressrc/screen.png and /dev/null differ diff --git a/games/animatronical/q1/a1/ressrc/stairs.png b/games/animatronical/q1/a1/ressrc/stairs.png deleted file mode 100755 index 8206f6c..0000000 Binary files a/games/animatronical/q1/a1/ressrc/stairs.png and /dev/null differ diff --git a/games/animatronical/q1/a1/ressrc/stairset.png b/games/animatronical/q1/a1/ressrc/stairset.png deleted file mode 100755 index eff717f..0000000 Binary files a/games/animatronical/q1/a1/ressrc/stairset.png and /dev/null differ diff --git a/games/animatronical/q1/a1/ressrc/toilet.png b/games/animatronical/q1/a1/ressrc/toilet.png deleted file mode 100755 index 7e6c3ac..0000000 Binary files a/games/animatronical/q1/a1/ressrc/toilet.png and /dev/null differ diff --git a/games/animatronical/q1/a1/ressrc/vent.png b/games/animatronical/q1/a1/ressrc/vent.png deleted file mode 100755 index 85d4a64..0000000 Binary files a/games/animatronical/q1/a1/ressrc/vent.png and /dev/null differ diff --git a/games/animatronical/q1/a1/ressrc/vent1.png b/games/animatronical/q1/a1/ressrc/vent1.png deleted file mode 100755 index a534d6d..0000000 Binary files a/games/animatronical/q1/a1/ressrc/vent1.png and /dev/null differ diff --git a/games/animatronical/q1/a1/ressrc/wall.png b/games/animatronical/q1/a1/ressrc/wall.png deleted file mode 100755 index ee58b59..0000000 Binary files a/games/animatronical/q1/a1/ressrc/wall.png and /dev/null differ diff --git a/games/animatronical/q1/a1/ressrc/wkitiles.png b/games/animatronical/q1/a1/ressrc/wkitiles.png deleted file mode 100755 index 4efa002..0000000 Binary files a/games/animatronical/q1/a1/ressrc/wkitiles.png and /dev/null differ diff --git a/games/animatronical/q1/a1/ressrc/youwon.png b/games/animatronical/q1/a1/ressrc/youwon.png deleted file mode 100755 index 19a4397..0000000 Binary files a/games/animatronical/q1/a1/ressrc/youwon.png and /dev/null differ diff --git a/games/animatronical/q1/a1/src/cycletext.h b/games/animatronical/q1/a1/src/cycletext.h deleted file mode 100644 index feccba2..0000000 --- a/games/animatronical/q1/a1/src/cycletext.h +++ /dev/null @@ -1,40 +0,0 @@ -#pragma once -#include -extern Color*LOADINGCOLOR[3]; -struct logi: public virtual enginend::nodes::twod::textfield { - logi(Texture2D* texture,enginend::theme* theme,float x,float y,float w,float h,float fs,std::string txt) { - this->pos=Vector2{x,y};this->size=Vector2{w,h};this->content=txt;this->theme=theme; - this->texture=texture; - this->fs=fs; - } - int delay=0; - int wait=0,amount=10; - void draw() override { - float spacing=fs/2.0f; - if(++delay>=10){ - Color*tmp=LOADINGCOLOR[2]; - LOADINGCOLOR[2]=LOADINGCOLOR[1]; - LOADINGCOLOR[1]=LOADINGCOLOR[0]; - LOADINGCOLOR[0]=tmp; - delay=0; - } - if(++wait>20){ - wait=0; - int max=(content.size()/2)*2; - if(++amount>=max)amount=0; - } - int vispos=amount>>1; - int len=content.size(); - Vector2 charPos=pos; - for(int i=0;itheme->font,str,charPos,(float)fs,spacing,fc); - charPos.x+=MeasureTextEx(this->theme->font,str,(float)fs,spacing).x; - } else break; - } - } -}; diff --git a/games/animatronical/q1/a1/src/main.cpp b/games/animatronical/q1/a1/src/main.cpp deleted file mode 100644 index 698fa09..0000000 --- a/games/animatronical/q1/a1/src/main.cpp +++ /dev/null @@ -1,114 +0,0 @@ -#include "scenes/game.h" -#include "scenes/mainmenu.h" -#include "cycletext.h" -tiny::ErrorLevel tiny::level{9}; -PLATFORM platform=LINUX; -std::string androidpackage="kn.kinfuyuki.animatronical-q1a1"; -Font gamefont; -Font loadingfont; -char changeto=0; -Color*LOADINGCOLOR[3] { - new Color{255,255,0,255}, - new Color{255,0,255,255}, - new Color{0,255,255,255} -}; -class anim: public enginend::program { -public: - int loadscreensecs=0; - int loadingscreen=0; - RenderTexture2D buffer; - enginend::nodes::twod::animated* caramel; - logi* loadingtext; - const char *CONF() override{return "SAVEFILE.TDF";} - - bool changing=false; - Image aniicon; - void boot() override { - aniicon=LoadImage("res/icon.png"); - this->currentscene=new mainmenu; - - SetConfigFlags(FLAG_VSYNC_HINT|FLAG_WINDOW_RESIZABLE); - InitWindow(380,240,"ani1"); - - SetWindowIcon(aniicon); - InitAudioDevice(); - gamefont=LoadFont(AT("res/font/mga.ttf")); - caramel=new enginend::nodes::twod::animated( - AT("res/loading/out2.gif"),{0,0},{320,240},6 - ); - loadingtext=new logi( - nullptr,enginend::DEFAULT,0,220,200,16,16,"LOADING..." - ); - buffer=LoadRenderTexture(320,240); - enginend::DEFAULT->font=gamefont; - currentscene->boot(); - } - void tick() override { - if (IsKeyDown(KEY_LEFT_ALT)&&IsKeyDown(KEY_F4))shouldclose=true; - if(changing) { - loadingscreen++; - caramel->tick(); - loadingtext->tick(); - if (loadingscreen>loadscreensecs) { - changing=false; - loadingscreen=0; - currentscene->exit(); - delete currentscene; - currentscene= new game; - currentscene->boot(); - currentscene->tick(); - } - } - else currentscene->tick(); - } - void draw() override { - BeginTextureMode(buffer); - ClearBackground(rl::BLACK); - int currscene=changeto; - if (!changing)currentscene->draw(); - else { - caramel->draw(); - loadingtext->draw(); - } - EndTextureMode(); - - if (currscene!=changeto) { - tiny::success("yay"); - switch (changeto) { - case 0: - currentscene->exit(); - delete currentscene; - currentscene= new mainmenu; - currentscene->boot(); - break; - case 1: - changing=true; - loadscreensecs=GetRandomValue(2*60,10*60); - break; - default: - tiny::fatal("wtf"); - } - } - - BeginDrawing(); - ClearBackground(rl::BLACK); - DrawTexturePro(buffer.texture,{0,0,320,-240},{0,0,(float)GetScreenWidth(),(float)GetScreenHeight()},{0,0},0,rl::WHITE); - EndDrawing(); - } - void exit() override { - currentscene->exit(); - } -}; - -int main() { - anim dagame; - dagame.boot(); - tiny::startup("animatronical 1","0.1c"); - tiny::fatal("/home/komi/src/cpp/allgames/animatronical/q1/a1/res/map/on/s/0.jpg"); - while (!dagame.shouldclose) { - dagame.tick(); - dagame.draw(); - - } - dagame.exit(); -} \ No newline at end of file diff --git a/games/animatronical/q1/a1/src/scenes/benchmark.h b/games/animatronical/q1/a1/src/scenes/benchmark.h deleted file mode 100644 index d5ba7c9..0000000 --- a/games/animatronical/q1/a1/src/scenes/benchmark.h +++ /dev/null @@ -1,2 +0,0 @@ -#pragma once -#include "shared.h" \ No newline at end of file diff --git a/games/animatronical/q1/a1/src/scenes/cheats.h b/games/animatronical/q1/a1/src/scenes/cheats.h deleted file mode 100644 index 9b3a903..0000000 --- a/games/animatronical/q1/a1/src/scenes/cheats.h +++ /dev/null @@ -1,24 +0,0 @@ -#pragma once -#include -#include -inline std::vector codes{ -"imma lazy bitch", //disable skaile and crystally, no need to play like a diehard -"imscared", //disable all, ur too scared -"im gay for uycatroz", //uycatroz will follow you without attacking, he seems interested -"sneak 100", //uycatroz will never find you, you sneaky lil crap -"alpha male", //disable crystally, she aint givin you head and you disgust her -"carameldansen", //activates rainbow tint shader -"sigma ohio rizz", //disable all, ur so sigma nobody want to be around you -"L + ratio", //doubles difficulty until game restart, L + ratio for ya -"nah, jit trippin", //quadruples difficulty until restart, ya diehard -"we <3 fluffy!1!", //disables skaile, now only the fluffy ones will be a problem -"this is too hard", //automatically wins the game, confia -"discord moderator", //animatronics sprites gets stretched -"dementia", //uycatroz will not remember wether doors and vents are closed -"smegmung", //the notebook is so horrible not even uycatroz wanna touch it -"nightmare", //enable nightmare mode and go back to main menu -"alt plus f four", //kinda obvious -"panik", //let all lights on and make uycatroz be on alert, how tf did u scared him? -"#darkness", //disables flashlight -"muckbang", // ur fat now, cant run -}; \ No newline at end of file diff --git a/games/animatronical/q1/a1/src/scenes/game.h b/games/animatronical/q1/a1/src/scenes/game.h deleted file mode 100644 index bb00206..0000000 --- a/games/animatronical/q1/a1/src/scenes/game.h +++ /dev/null @@ -1,130 +0,0 @@ -#pragma once -#include "shared.h" -#include -#include "cheats.h" -enum CURSORMODES { - MAINMENU=0, - COMPUTER=1, - LEFT=2,RIGHT=3,UP=4,DOWN=5, - FLASHLIGHT=6,INTERACT=7 -}; -#define LOADMAP LoadTexture(newpath.c_str()); -struct entity { - char pos; - char dir; -}; - - - -extern std::vector> map; -extern std::vector opposites; -char moveentity(char pos,char dir,bool backwards); -char rotateentity(char pos,char dir, bool clockwise); -bool ifforward();bool ifbackward();bool ifleft();bool ifright(); -bool ifinteract();bool ifflashlight(); -bool cansee(char dest,char pos, char dir); -extern std::vector sides; -extern std::vector lightlevel; - -struct game:public enginend::scene { - // dir 1 - - int lightmode:2=1; // off, on, urcooked - std::string mappath; - // this is for quick loading but without weighting ram.. - // yea the assets are small but i like optimization - float stamina=0.0; - entity uycatroz{6,3}; - entity skaile{10,3}; - entity player{0,1}; - Texture2D current; - Texture2D skailemenu[3]; - bool iskailepressed=false; - bool iskailemenu=false; - - bool canseeuycatroz=false; - bool canseeskaile=false; - float crystallyprogress=1.; - void exit() override { - UnloadTexture(current); - for (Texture2D i: skailemenu) { - - UnloadTexture(i); - } - scene::exit(); - } - void boot() final { - mappath=AT("res/map"); - std::string newpath=AT((mappath+"/"+lightlevel[lightmode]+"/"+sides[player.dir]+"/"+std::to_string(player.pos)+".jpg")); - skailemenu[0]=LoadTexture(AT("res/gui/buttonf.png")); - skailemenu[1]=LoadTexture(AT("res/gui/buttonn.png")); - skailemenu[2]=LoadTexture(AT("res/gui/skailevisor.png")); - current=LOADMAP - } - void tick() final { - if (iskailemenu) { - if (IsMouseButtonDown(MOUSE_BUTTON_LEFT)) { - iskailepressed=true; - }else { - iskailepressed=false; - } - } - - } - void draw() final { - bool changed=false; - bool updateview=false; - if (stamina>=1.){ - if (ifforward()){player.pos=moveentity(player.pos,player.dir,false);changed=true;} - if (ifbackward()){player.pos=moveentity(player.pos,player.dir,true);changed=true;} - if (ifleft()){player.dir=rotateentity(player.pos,player.dir,false);changed=true;} - if (ifright()){player.dir=rotateentity(player.pos,player.dir,true);changed=true;} - if (ifflashlight()){lightmode=!lightmode;changed=true;} - if (ifinteract()) { - changed=true; - if (player.dir==0&&player.pos==0)changeto=0; - else if (moveentity(player.pos,player.dir,false)==skaile.pos) { - iskailemenu=!iskailemenu; - } - } - if (changed) { - UnloadTexture(current); - std::string newpath=AT((mappath+"/"+lightlevel[lightmode]+"/"+sides[player.dir]+"/"+std::to_string(player.pos)+".jpg")); - current=LOADMAP - //tiny::success((char*)newpath.c_str()); - updateview=true; - } - if (updateview) { - canseeuycatroz=cansee(uycatroz.pos,player.pos,player.dir); - canseeskaile=cansee(skaile.pos,player.pos,player.dir); - } - if (ifinteract()) { - if (player.pos==0&&player.dir==0)changeto=0; - - } - }else stamina+=.01; - float screenw=320;float screenh=240; - - if(!iskailemenu) { - DrawTexturePro(current,{0,0,480,280},{0,0,screenw,screenh},{0,0},0,rl::WHITE); - if (canseeuycatroz)DrawRectangle( - screenw/10.,screenh/10.,screenw/12,screenh/1.5,rl::BLUE); - if (canseeskaile)DrawRectangle( - screenw/2.,screenh/10.,screenw/12,screenh/1.5,rl::RED); - }else { - if (iskailemenu) { - DrawTexture(skailemenu[2],0,0,rl::WHITE); - tiny::success("%i",iskailepressed); - DrawTexture(skailemenu[iskailepressed],261,120,rl::WHITE); - - } - } - DrawText(("pos: "+std::to_string(player.pos)+" dir:"+std::to_string(player.dir)).c_str(),0,0,16,rl::WHITE); - DrawText(("uypos: "+std::to_string(uycatroz.pos)+" uydir:"+std::to_string(uycatroz.dir)).c_str(),0,32,16,rl::SKYBLUE); - DrawText(("skpos: "+std::to_string(skaile.pos)+" skdir:"+std::to_string(skaile.dir)).c_str(),0,48,16,rl::RED); - DrawText(("crystally: "+std::to_string(crystallyprogress)).c_str(),0,64,16,rl::LIME); - - - - } -}; \ No newline at end of file diff --git a/games/animatronical/q1/a1/src/scenes/mainmenu.h b/games/animatronical/q1/a1/src/scenes/mainmenu.h deleted file mode 100644 index f577160..0000000 --- a/games/animatronical/q1/a1/src/scenes/mainmenu.h +++ /dev/null @@ -1,99 +0,0 @@ -#pragma once -#include -#include -#include "shared.h" - - -class mainmenu:public enginend::scene { -public: - Texture2D bg; - Texture2D title; - Music bgm; - Shader bzzzz; - int wins:3=0b111; - mainmenu() { - - } - enginend::nodes::twod::labeledbutton* play; - enginend::nodes::twod::labeledbutton* version; - void boot() override { - std::string modifier=".png"; - bg=LoadTexture(AT("res/menu/"+ - std::to_string(wins>>2&1)+std::to_string(wins>>1&1)+std::to_string(wins&1) - +modifier)); - bgm=LoadMusicStream(AT("res/snd/song.mp3")); - title=LoadTexture(AT("res/menu/title.png")); - bgm.looping=true; - PlayMusicStream(bgm); - bzzzz=LoadShaderFromMemory( - "attribute vec2 vertexPosition;attribute vec2 vertexTexCoord;attribute vec4 vertexColor;" - "varying vec2 fragTexCoord;varying vec4 fragColor;varying float randf;" - "uniform mat4 mvp;uniform float t;" - "float rand(vec2 co){return fract(sin(dot(co,vec2(12.9898,78.233)))*43758.5453);}" - "void main(){fragTexCoord=vertexTexCoord;fragColor=vertexColor;" - "gl_Position=mvp*vec4(vertexPosition,0.,1.);" - "randf=rand(vec2(gl_Position.x+t,gl_Position.y+t));}", - "varying vec2 fragTexCoord;varying vec4 fragColor;varying float randf;" - "uniform sampler2D texture0;" - "void main(){" - "vec4 texel=texture2D(texture0,fragTexCoord)*fragColor;" - "float idx=(texel.r+texel.g+texel.b);" - "if(idx<0.7||idx>0.9){idx*=randf;}" - "gl_FragColor=vec4(texel.rgb,texel.a*idx);}" - ); - enginend::DEFAULT->tint={255,255,255,0}; - play=new enginend::nodes::twod::labeledbutton("PLAY", - nullptr,enginend::DEFAULT,0.65,0.75,0.5,0.05,std::function([]() { - changeto=1; - }),1 - ); - version=new enginend::nodes::twod::labeledbutton("0.1c", - nullptr,enginend::DEFAULT,0.65,0.75,0.5,0.05,std::function([]() { - changeto=2; - }),1 - ); - } - void tick() override { - play->tick(); - version->tick(); - } - void draw() override { - float screenw=320;float screenh=240; - UpdateMusicStream(bgm); - DrawTexturePro(bg,{0,0,320,240},{0,0,screenw,screenh},{0,0},0,rl::WHITE); - float t=GetTime()/200000; - SetShaderValue(bzzzz,GetShaderLocation(bzzzz,"t"),&t,SHADER_UNIFORM_FLOAT); - BeginShaderMode(bzzzz); - DrawTexturePro(title,{0,0,1065,194},{0,0,screenw,(screenh/4)},{0,0},0,rl::WHITE); - EndShaderMode(); - play->fs=std::sqrt(screenh+screenw); - play->pos={0.65f*screenw,0.75f*screenh}; - play->size={0.3f*screenw,0.2f*screenh}; - unsigned char hovering=play->hover?play->pressed?128:64:0; - enginend::DEFAULT->tint={255,255,255,hovering}; - enginend::DEFAULT->buttontext[0]=enginend::DEFAULT->buttontext[1]=enginend::DEFAULT->buttontext[2]= - {255,0,255,255}; - play->draw(); - hovering=version->hover?version->pressed?128:64:0; - enginend::DEFAULT->tint={255,255,255,hovering}; - - version->fs=std::sqrt(screenh+screenw); - version->pos={0.05f*screenw,0.75f*screenh}; - version->size={0.3f*screenw,0.2f*screenh}; - - enginend::DEFAULT->buttontext[0]=enginend::DEFAULT->buttontext[1]=enginend::DEFAULT->buttontext[2]= - {0,255,255,255}; - - version->draw(); - - } - void exit() override { - play->exit(); - version->exit(); - StopMusicStream(bgm); - UnloadTexture(bg); - UnloadTexture(title); - UnloadMusicStream(bgm); - UnloadShader(bzzzz); - } -}; \ No newline at end of file diff --git a/games/animatronical/q1/a1/src/scenes/scenes.cpp b/games/animatronical/q1/a1/src/scenes/scenes.cpp deleted file mode 100644 index a51ccbe..0000000 --- a/games/animatronical/q1/a1/src/scenes/scenes.cpp +++ /dev/null @@ -1,124 +0,0 @@ -#include "game.h" -// 0 1 2 3 4 5 6 -// 7 8 9 10 -// 11 12 13 -// 14 15 16 -// N S L R -std::vectoropposites{1,0,3,2}; -std::vector sides{ - 'n','s','r','l' -}; -std::vector lightlevel{ - "off","on","urcooked" -}; - -#define N (-1) -std::vector> map{ - // 0 1 2 3 4 5 6 - {N,7,N,1} ,{N,8,0,2} , {N,3,1,N} ,{2,4,N,N},{3,N,5,N}, {9,N,6,4},{10,N,N,5}, - // 7 8 9 10 - {0,11,N,8} ,{1,13,7,N}, {N,5,10,N},{N,6,N,9}, - // 11 12 13 - {7,14,N,12},{N,N,11,N}, {8,16,N,N}, - // 14 15 16 - {11,N,N,15},{N,N,14,16},{13,N,15,N} -}; -#undef N -std::vector>> visibilitychart{ - - {{},{7,8,11,14},{},{1,2,8}},//0 - {{},{7,8,11},{0,7},{2}}, - {{},{3,4},{0,7},{}},//2 - {{2},{4,5},{5,6,9,10},{}}, - {{2,3},{},{5,6,10},{}},//4 - {{3,9,10},{},{6},{4}}, - {{9,10},{},{},{5,4,3}},//6 - {{0,1},{11,14},{},{1,2,8}}, - {{0,1},{13},{7,1},{}},//8 - {{},{6,10},{3,4,5,6},{}}, - {{},{5,6},{},{3,5,9}},//10 - {{0,7},{14},{},{12}}, - {{},{},{11},{}},//12 - {{0,1,8},{},{16},{}}, - {{0,7,11},{},{},{15,16}},//14 - {{},{},{14},{16}}, - {{13},{},{14,15},{}}//16 - -}; - -bool cansee(char dest,char pos, char dir) { - std::vector check=visibilitychart[pos][dir]; - for (char i: check) { - if (dest==i)return true; - } - return false; -} - - -char moveentity(char pos,char dir,bool backwards) { - char tmpos=-1; - if (backwards)tmpos= map[pos][opposites[dir]]; - else tmpos=map[pos][dir]; - if (tmpos==-1) return pos; - return tmpos; -} -std::vector> look={ - {3,2,0,1}, - {2,3,1,0}, - {1,0} -}; -char rotateentity(char pos,char dir, bool clockwise) { - if (pos==13) { - return look[2][dir]; - } - return look[!clockwise][dir]; -} - - -bool ifforward() { - if (IsKeyPressed(KEY_W))return true; - if (IsKeyPressed(KEY_UP))return true; - if (IsKeyPressed(KEY_KP_8))return true; - return false; -} - -bool ifbackward() { - if (IsKeyPressed(KEY_S))return true; - if (IsKeyPressed(KEY_DOWN))return true; - if (IsKeyPressed(KEY_KP_5))return true; - return false; -} - -bool ifleft() { - if (IsKeyPressed(KEY_A))return true; - if (IsKeyPressed(KEY_LEFT))return true; - if (IsKeyPressed(KEY_KP_4))return true; - return false; -} - -bool ifright(){ - if (IsKeyPressed(KEY_D))return true; - if (IsKeyPressed(KEY_RIGHT))return true; - if (IsKeyPressed(KEY_KP_6))return true; - return false; -} - -bool ifinteract() { - if (IsKeyPressed(KEY_RIGHT_CONTROL))return true; - if (IsKeyPressed(KEY_KP_7))return true; - if (IsKeyPressed(KEY_E))return true; - if (IsKeyPressed(KEY_SPACE))return true; - return false; -} - -bool ifflashlight() { - if (IsKeyPressed(KEY_F))return true; - if (IsKeyPressed(KEY_KP_9))return true; - if (IsKeyPressed(KEY_RIGHT_SHIFT))return true; - return false; -} - - - - - diff --git a/games/animatronical/q1/a1/src/scenes/shared.h b/games/animatronical/q1/a1/src/scenes/shared.h deleted file mode 100644 index 81f32c0..0000000 --- a/games/animatronical/q1/a1/src/scenes/shared.h +++ /dev/null @@ -1,4 +0,0 @@ -#pragma once -#include -extern char changeto; -extern Font gamefont; \ No newline at end of file diff --git a/games/forespend/player/kinfuyuki/player.json b/games/forespend/player/kinfuyuki/player.json deleted file mode 100644 index 25e2dac..0000000 --- a/games/forespend/player/kinfuyuki/player.json +++ /dev/null @@ -1,15 +0,0 @@ -{ - "name": "kin fuyuki", - "description": - "me sprite yay im the creator of this game", - "spritew":16, - "spriteh":32, - "width": 1.0, - "height": 2.0, - "speed": 1.0, - "health": 1.0, - "radiores": 1.0, - "exhaustres": 1.0, - "singlesprite": true -} - diff --git a/games/forespend/player/kinfuyuki/player.png b/games/forespend/player/kinfuyuki/player.png deleted file mode 100644 index 99c3c8b..0000000 Binary files a/games/forespend/player/kinfuyuki/player.png and /dev/null differ diff --git a/games/forespend/player/kinfuyuki/player.tdf b/games/forespend/player/kinfuyuki/player.tdf deleted file mode 100644 index 2061f59..0000000 --- a/games/forespend/player/kinfuyuki/player.tdf +++ /dev/null @@ -1,22 +0,0 @@ -#BLOCKTYPE LIST -# - -" name kin fuyuki -S description -me sprite yay im the creator of this game -heya hoihoi -\ -i spritew 16 -i spriteh 32 -f width 8.0 -f height 2.0 -f speed 2.0 -f health 2.0 -f radiores 2.0 -f exhaustres 2.0 -B singlesprite T -B 3dprerendered F -# 0 = 1 side 1 = 4 sides 2 = 8 sides (diagonal axes) -# 3 = 10 sides (top and down) -i directions 0 -# defined \ No newline at end of file diff --git a/games/forespend/res/defaultplayer/player.png.1~ b/games/forespend/res/defaultplayer/player.png.1~ new file mode 100644 index 0000000..bc6b35f Binary files /dev/null and b/games/forespend/res/defaultplayer/player.png.1~ differ diff --git a/games/forespend/res/fonts/dos.fnt b/games/forespend/res/fonts/dos.fnt deleted file mode 100644 index 6aa2628..0000000 --- a/games/forespend/res/fonts/dos.fnt +++ /dev/null @@ -1,102 +0,0 @@ -info face="6x6 Font Monospaced Regular" size=32 bold=0 italic=0 charset="" unicode=0 stretchH=100 smooth=1 aa=1 padding=1,1,1,1 spacing=-2,-2 -common lineHeight=38 base=32 scaleW=512 scaleH=512 pages=1 packed=0 -page id=0 file="dos.png" -chars count=97 -char id=0 x=474 y=200 width=32 height=40 xoffset=-1 yoffset=-1 xadvance=30 page=0 chnl=0 -char id=10 x=0 y=0 width=0 height=0 xoffset=-1 yoffset=0 xadvance=0 page=0 chnl=0 -char id=32 x=0 y=0 width=0 height=0 xoffset=-1 yoffset=0 xadvance=37 page=0 chnl=0 -char id=33 x=390 y=160 width=40 height=40 xoffset=10 yoffset=-1 xadvance=38 page=0 chnl=0 -char id=34 x=351 y=160 width=39 height=40 xoffset=-1 yoffset=-1 xadvance=37 page=0 chnl=0 -char id=35 x=433 y=240 width=39 height=40 xoffset=-1 yoffset=-1 xadvance=37 page=0 chnl=0 -char id=36 x=237 y=240 width=39 height=40 xoffset=-1 yoffset=-1 xadvance=37 page=0 chnl=0 -char id=37 x=315 y=240 width=40 height=40 xoffset=-1 yoffset=-1 xadvance=38 page=0 chnl=0 -char id=38 x=472 y=240 width=39 height=40 xoffset=-1 yoffset=-1 xadvance=37 page=0 chnl=0 -char id=39 x=0 y=200 width=40 height=40 xoffset=10 yoffset=-1 xadvance=38 page=0 chnl=0 -char id=40 x=200 y=200 width=39 height=40 xoffset=4 yoffset=-1 xadvance=37 page=0 chnl=0 -char id=41 x=239 y=200 width=39 height=40 xoffset=4 yoffset=-1 xadvance=37 page=0 chnl=0 -char id=42 x=84 y=280 width=39 height=40 xoffset=-1 yoffset=-1 xadvance=37 page=0 chnl=0 -char id=43 x=355 y=240 width=39 height=40 xoffset=-1 yoffset=-1 xadvance=37 page=0 chnl=0 -char id=44 x=80 y=200 width=40 height=40 xoffset=10 yoffset=-1 xadvance=38 page=0 chnl=0 -char id=45 x=276 y=240 width=39 height=40 xoffset=-1 yoffset=-1 xadvance=37 page=0 chnl=0 -char id=46 x=40 y=200 width=40 height=40 xoffset=10 yoffset=-1 xadvance=38 page=0 chnl=0 -char id=47 x=79 y=240 width=40 height=40 xoffset=-1 yoffset=-1 xadvance=38 page=0 chnl=0 -char id=48 x=39 y=40 width=39 height=40 xoffset=-1 yoffset=-1 xadvance=37 page=0 chnl=0 -char id=49 x=0 y=160 width=39 height=40 xoffset=4 yoffset=-1 xadvance=37 page=0 chnl=0 -char id=50 x=39 y=160 width=39 height=40 xoffset=-1 yoffset=-1 xadvance=37 page=0 chnl=0 -char id=51 x=78 y=160 width=39 height=40 xoffset=-1 yoffset=-1 xadvance=37 page=0 chnl=0 -char id=52 x=117 y=160 width=39 height=40 xoffset=-1 yoffset=-1 xadvance=37 page=0 chnl=0 -char id=53 x=156 y=160 width=39 height=40 xoffset=-1 yoffset=-1 xadvance=37 page=0 chnl=0 -char id=54 x=195 y=160 width=39 height=40 xoffset=-1 yoffset=-1 xadvance=37 page=0 chnl=0 -char id=55 x=234 y=160 width=39 height=40 xoffset=-1 yoffset=-1 xadvance=37 page=0 chnl=0 -char id=56 x=273 y=160 width=39 height=40 xoffset=-1 yoffset=-1 xadvance=37 page=0 chnl=0 -char id=57 x=312 y=160 width=39 height=40 xoffset=-1 yoffset=-1 xadvance=37 page=0 chnl=0 -char id=58 x=160 y=200 width=40 height=40 xoffset=10 yoffset=-1 xadvance=38 page=0 chnl=0 -char id=59 x=120 y=200 width=40 height=40 xoffset=10 yoffset=-1 xadvance=38 page=0 chnl=0 -char id=60 x=434 y=200 width=40 height=40 xoffset=-1 yoffset=-1 xadvance=38 page=0 chnl=0 -char id=61 x=394 y=240 width=39 height=40 xoffset=-1 yoffset=-1 xadvance=37 page=0 chnl=0 -char id=62 x=0 y=240 width=39 height=40 xoffset=4 yoffset=-1 xadvance=37 page=0 chnl=0 -char id=63 x=469 y=160 width=39 height=40 xoffset=-1 yoffset=-1 xadvance=37 page=0 chnl=0 -char id=64 x=119 y=240 width=39 height=40 xoffset=-1 yoffset=-1 xadvance=37 page=0 chnl=0 -char id=65 x=0 y=0 width=39 height=40 xoffset=-1 yoffset=-1 xadvance=37 page=0 chnl=0 -char id=66 x=39 y=0 width=39 height=40 xoffset=-1 yoffset=-1 xadvance=37 page=0 chnl=0 -char id=67 x=78 y=0 width=39 height=40 xoffset=-1 yoffset=-1 xadvance=37 page=0 chnl=0 -char id=68 x=117 y=0 width=39 height=40 xoffset=-1 yoffset=-1 xadvance=37 page=0 chnl=0 -char id=69 x=156 y=0 width=39 height=40 xoffset=-1 yoffset=-1 xadvance=37 page=0 chnl=0 -char id=70 x=195 y=0 width=39 height=40 xoffset=-1 yoffset=-1 xadvance=37 page=0 chnl=0 -char id=71 x=234 y=0 width=39 height=40 xoffset=-1 yoffset=-1 xadvance=37 page=0 chnl=0 -char id=72 x=273 y=0 width=39 height=40 xoffset=-1 yoffset=-1 xadvance=37 page=0 chnl=0 -char id=73 x=312 y=0 width=39 height=40 xoffset=4 yoffset=-1 xadvance=37 page=0 chnl=0 -char id=74 x=351 y=0 width=39 height=40 xoffset=-1 yoffset=-1 xadvance=37 page=0 chnl=0 -char id=75 x=390 y=0 width=39 height=40 xoffset=-1 yoffset=-1 xadvance=37 page=0 chnl=0 -char id=76 x=429 y=0 width=39 height=40 xoffset=-1 yoffset=-1 xadvance=37 page=0 chnl=0 -char id=77 x=468 y=0 width=39 height=40 xoffset=-1 yoffset=-1 xadvance=37 page=0 chnl=0 -char id=78 x=0 y=40 width=39 height=40 xoffset=-1 yoffset=-1 xadvance=37 page=0 chnl=0 -char id=79 x=39 y=40 width=39 height=40 xoffset=-1 yoffset=-1 xadvance=37 page=0 chnl=0 -char id=80 x=78 y=40 width=39 height=40 xoffset=-1 yoffset=-1 xadvance=37 page=0 chnl=0 -char id=81 x=117 y=40 width=39 height=40 xoffset=-1 yoffset=-1 xadvance=37 page=0 chnl=0 -char id=82 x=156 y=40 width=39 height=40 xoffset=-1 yoffset=-1 xadvance=37 page=0 chnl=0 -char id=83 x=195 y=40 width=39 height=40 xoffset=-1 yoffset=-1 xadvance=37 page=0 chnl=0 -char id=84 x=234 y=40 width=39 height=40 xoffset=-1 yoffset=-1 xadvance=37 page=0 chnl=0 -char id=85 x=273 y=40 width=39 height=40 xoffset=-1 yoffset=-1 xadvance=37 page=0 chnl=0 -char id=86 x=312 y=40 width=39 height=40 xoffset=-1 yoffset=-1 xadvance=37 page=0 chnl=0 -char id=87 x=351 y=40 width=39 height=40 xoffset=-1 yoffset=-1 xadvance=37 page=0 chnl=0 -char id=88 x=390 y=40 width=39 height=40 xoffset=-1 yoffset=-1 xadvance=37 page=0 chnl=0 -char id=89 x=429 y=40 width=40 height=40 xoffset=-1 yoffset=-1 xadvance=38 page=0 chnl=0 -char id=90 x=469 y=40 width=39 height=40 xoffset=-1 yoffset=-1 xadvance=37 page=0 chnl=0 -char id=91 x=278 y=200 width=39 height=40 xoffset=4 yoffset=-1 xadvance=37 page=0 chnl=0 -char id=92 x=158 y=240 width=40 height=40 xoffset=-1 yoffset=-1 xadvance=38 page=0 chnl=0 -char id=93 x=317 y=200 width=39 height=40 xoffset=4 yoffset=-1 xadvance=37 page=0 chnl=0 -char id=94 x=198 y=240 width=39 height=40 xoffset=-1 yoffset=-1 xadvance=37 page=0 chnl=0 -char id=95 x=0 y=280 width=45 height=40 xoffset=-6 yoffset=-1 xadvance=38 page=0 chnl=0 -char id=96 x=430 y=160 width=39 height=40 xoffset=4 yoffset=-1 xadvance=37 page=0 chnl=0 -char id=97 x=0 y=80 width=39 height=40 xoffset=-1 yoffset=-1 xadvance=37 page=0 chnl=0 -char id=98 x=39 y=80 width=39 height=40 xoffset=-1 yoffset=-1 xadvance=37 page=0 chnl=0 -char id=99 x=78 y=80 width=39 height=40 xoffset=-1 yoffset=-1 xadvance=37 page=0 chnl=0 -char id=100 x=117 y=80 width=39 height=40 xoffset=-1 yoffset=-1 xadvance=37 page=0 chnl=0 -char id=101 x=156 y=80 width=39 height=40 xoffset=-1 yoffset=-1 xadvance=37 page=0 chnl=0 -char id=102 x=195 y=80 width=39 height=40 xoffset=-1 yoffset=-1 xadvance=37 page=0 chnl=0 -char id=103 x=234 y=80 width=39 height=40 xoffset=-1 yoffset=-1 xadvance=37 page=0 chnl=0 -char id=104 x=273 y=80 width=39 height=40 xoffset=-1 yoffset=-1 xadvance=37 page=0 chnl=0 -char id=105 x=312 y=80 width=39 height=40 xoffset=4 yoffset=-1 xadvance=37 page=0 chnl=0 -char id=106 x=351 y=80 width=39 height=40 xoffset=-1 yoffset=-1 xadvance=37 page=0 chnl=0 -char id=107 x=390 y=80 width=39 height=40 xoffset=-1 yoffset=-1 xadvance=37 page=0 chnl=0 -char id=108 x=429 y=80 width=39 height=40 xoffset=4 yoffset=-1 xadvance=37 page=0 chnl=0 -char id=109 x=468 y=80 width=39 height=40 xoffset=-1 yoffset=-1 xadvance=37 page=0 chnl=0 -char id=110 x=0 y=120 width=39 height=40 xoffset=-1 yoffset=-1 xadvance=37 page=0 chnl=0 -char id=111 x=39 y=120 width=39 height=40 xoffset=-1 yoffset=-1 xadvance=37 page=0 chnl=0 -char id=112 x=78 y=120 width=39 height=40 xoffset=-1 yoffset=-1 xadvance=37 page=0 chnl=0 -char id=113 x=117 y=120 width=39 height=40 xoffset=-1 yoffset=-1 xadvance=37 page=0 chnl=0 -char id=114 x=156 y=120 width=39 height=40 xoffset=-1 yoffset=-1 xadvance=37 page=0 chnl=0 -char id=115 x=195 y=120 width=39 height=40 xoffset=-1 yoffset=-1 xadvance=37 page=0 chnl=0 -char id=116 x=234 y=120 width=39 height=40 xoffset=-1 yoffset=-1 xadvance=37 page=0 chnl=0 -char id=117 x=273 y=120 width=39 height=40 xoffset=-1 yoffset=-1 xadvance=37 page=0 chnl=0 -char id=118 x=312 y=120 width=39 height=40 xoffset=-1 yoffset=-1 xadvance=37 page=0 chnl=0 -char id=119 x=351 y=120 width=39 height=40 xoffset=-1 yoffset=-1 xadvance=37 page=0 chnl=0 -char id=120 x=390 y=120 width=39 height=40 xoffset=-1 yoffset=-1 xadvance=37 page=0 chnl=0 -char id=121 x=429 y=120 width=39 height=40 xoffset=-1 yoffset=-1 xadvance=37 page=0 chnl=0 -char id=122 x=468 y=120 width=39 height=40 xoffset=-1 yoffset=-1 xadvance=37 page=0 chnl=0 -char id=123 x=356 y=200 width=39 height=40 xoffset=4 yoffset=-1 xadvance=37 page=0 chnl=0 -char id=124 x=39 y=240 width=40 height=40 xoffset=10 yoffset=-1 xadvance=38 page=0 chnl=0 -char id=125 x=395 y=200 width=39 height=40 xoffset=10 yoffset=-1 xadvance=37 page=0 chnl=0 -char id=126 x=45 y=280 width=39 height=40 xoffset=-1 yoffset=-1 xadvance=37 page=0 chnl=0 -kernings count=0 diff --git a/games/forespend/res/fonts/dos.png b/games/forespend/res/fonts/dos.png index 1f211eb..acc7db8 100644 Binary files a/games/forespend/res/fonts/dos.png and b/games/forespend/res/fonts/dos.png differ diff --git a/games/forespend/res/images/coolworld.png.1~ b/games/forespend/res/images/coolworld.png.1~ new file mode 100644 index 0000000..1c0c3cf Binary files /dev/null and b/games/forespend/res/images/coolworld.png.1~ differ diff --git a/games/forespend/res/npcs/canidmonster.tdf b/games/forespend/res/npcs/canidmonster.tdf index 415115d..d0173af 100644 --- a/games/forespend/res/npcs/canidmonster.tdf +++ b/games/forespend/res/npcs/canidmonster.tdf @@ -77,4 +77,4 @@ h ezra_0.0 ffffff } # end of range ffffff -} \ No newline at end of file +} diff --git a/games/forespend/res/shaders/screen.fs b/games/forespend/res/shaders/screen.fs index f40697b..2695147 100644 --- a/games/forespend/res/shaders/screen.fs +++ b/games/forespend/res/shaders/screen.fs @@ -7,7 +7,7 @@ uniform vec4 colDiffuse; const float BITS=8.0; uniform bool DITHER=false; uniform bool DEPTH=true; -uniform bool BLOOM=false; +uniform bool BLOOM=true; uniform bool BLUR=false; uniform float redbits=4.; uniform float greenbits=4.; diff --git a/games/forespend/src/client/client.cpp b/games/forespend/src/client/client.cpp index d855f27..9619739 100644 --- a/games/forespend/src/client/client.cpp +++ b/games/forespend/src/client/client.cpp @@ -8,37 +8,22 @@ client::client() { void client::boot() { this->framerate=60; this->tickrate=20; - SetConfigFlags(FLAG_VSYNC_HINT|FLAG_WINDOW_RESIZABLE); +// SetConfigFlags(); InitWindow(380,240,"forespend - 0.03h"); initthemes(); this->currentscene=new mainmenu(); this->currentscene->boot(); target=LoadRenderTexture(380,240); - display=LoadShader( - AT("res/shaders/screen.vs"), - AT("res/shaders/screen.fs") - ); - } void client::draw() { - BeginTextureMode(target); + BeginDrawing(); ClearBackground(rl::WHITE); this->currentscene->draw(); - EndTextureMode(); - BeginDrawing(); - BeginShaderMode(display); - DrawTexturePro( - target.texture,{0,0,380,-240},{0,0,(float)GetScreenWidth(),(float)GetScreenHeight()},{0,0},0,rl::WHITE - ); - EndShaderMode(); EndDrawing(); - } void client::exit() { this->currentscene->exit(); delete this->currentscene; - UnloadRenderTexture(target); - UnloadShader(display); } void client::tick() { this->currentscene->tick(); diff --git a/games/forespend/src/client/client.h b/games/forespend/src/client/client.h index f0c59d6..dd28d8f 100644 --- a/games/forespend/src/client/client.h +++ b/games/forespend/src/client/client.h @@ -6,7 +6,6 @@ class client :public enginend::program{ public: RenderTexture2D target; - Shader display; const char* CONF() final{return "client.tdf";} client(); void boot() override; diff --git a/games/forespend/src/client/scenes/configmenu.h b/games/forespend/src/client/scenes/configmenu.h index 4013163..ca5ebbd 100644 --- a/games/forespend/src/client/scenes/configmenu.h +++ b/games/forespend/src/client/scenes/configmenu.h @@ -2,7 +2,7 @@ #include #include -#include "../../common/themes.h" + extern enginend::group maincfgpage; extern enginend::group graphics; extern enginend::group sound; diff --git a/games/forespend/src/client/scenes/game.cpp b/games/forespend/src/client/scenes/game.cpp new file mode 100644 index 0000000..679fedf --- /dev/null +++ b/games/forespend/src/client/scenes/game.cpp @@ -0,0 +1 @@ +#include "game.h" \ No newline at end of file diff --git a/games/forespend/src/client/scenes/game.h b/games/forespend/src/client/scenes/game.h new file mode 100644 index 0000000..9360b8f --- /dev/null +++ b/games/forespend/src/client/scenes/game.h @@ -0,0 +1,7 @@ +#pragma once + +#include + +class game :public virtual enginend::scene { + +}; \ No newline at end of file diff --git a/games/forespend/src/client/scenes/mainmenu.cpp b/games/forespend/src/client/scenes/mainmenu.cpp index fda0c84..968b3da 100644 --- a/games/forespend/src/client/scenes/mainmenu.cpp +++ b/games/forespend/src/client/scenes/mainmenu.cpp @@ -1,71 +1 @@ -#include"mainmenu.h" - -void mainmenu::boot(){ - this->nodes=std::vector{ - new animated(AT("res/images/sky.gif"),0,0,1,1,2), - new text(nullptr,clienttheme,0.17,0.05,0.8,0.3,32,"FORESPEND"), - new labeledbutton("PLAY",nullptr,clienttheme,0.30,0.25,0.4,0.2, - std::function([]{ - - }),32), - new labeledbutton("OPTIONS",nullptr,clienttheme,0.02,0.75,0.56,0.2, - std::function([]{ - configmenupage=1; - }),32), - new labeledbutton("EXIT",nullptr,clienttheme,0.63,0.75,0.35,0.2, - std::function([](){ - std::exit(1); - }),32), - }; - enginend::scene::boot(); -} - - -void mainmenu::tick(){ - switch (configmenupage) { - case 0:{ - for (enginend::nodes::node* n : this->nodes) { - n->tick(); - } - break; - } - case 1: {this->nodes[0]->tick(); - for (enginend::nodes::node* n : maincfgpage.children) { - n->tick(); - } - break; - } - case 2: {this->nodes[0]->tick(); - for (enginend::nodes::node* n : graphics.children) { - n->tick(); - } - break; - } - } -} - -void mainmenu::draw(){ - switch (configmenupage) { - case 0:{ - for (enginend::nodes::node* n : this->nodes) { - n->draw(); - } - break; - } - case 1: {(this->nodes[0])->draw(); - for (enginend::nodes::node* n : maincfgpage.children) { - n->draw(); - } - break; - } - case 2: {this->nodes[0]->draw(); - for (enginend::nodes::node* n : graphics.children) { - n->draw(); - } - break; - } - } -} -void mainmenu::exit(){ - enginend::scene::exit(); -} +#include "mainmenu.h" diff --git a/games/forespend/src/client/scenes/mainmenu.h b/games/forespend/src/client/scenes/mainmenu.h index 566fce3..e61343a 100644 --- a/games/forespend/src/client/scenes/mainmenu.h +++ b/games/forespend/src/client/scenes/mainmenu.h @@ -6,10 +6,71 @@ using namespace enginend::nodes::twod::relative; class mainmenu :public virtual enginend::scene{ private: Texture2D bg= LoadTexture(AT("res/images/tilesheet.png")); - public: - void boot() override ; - void tick() override ; - void draw() override ; - void exit() override ; + void boot() override { + this->nodes=std::vector{ + new animated(AT("res/images/sky.gif"),0,0,1,1,2), + new text(nullptr,clienttheme,0.17,0.05,0.8,0.3,32,"FORESPEND"), + new labeledbutton("PLAY",nullptr,clienttheme,0.30,0.25,0.4,0.2, + std::function([]{ + + }),32), + new labeledbutton("OPTIONS",nullptr,clienttheme,0.02,0.75,0.56,0.2, + std::function([]{ + configmenupage=1; + }),32), + new labeledbutton("EXIT",nullptr,clienttheme,0.63,0.75,0.35,0.2, + std::function([](){ + std::exit(1); + }),32), + }; + enginend::scene::boot(); + } + void tick() override { + switch (configmenupage) { + case 0:{ + for (enginend::nodes::node* n : this->nodes) { + n->tick(); + } + break; + } + case 1: {this->nodes[0]->tick(); + for (enginend::nodes::node* n : maincfgpage.children) { + n->tick(); + } + break; + } + case 2: {this->nodes[0]->tick(); + for (enginend::nodes::node* n : graphics.children) { + n->tick(); + } + break; + } + } + } + void draw() override { + switch (configmenupage) { + case 0:{ + for (enginend::nodes::node* n : this->nodes) { + n->draw(); + } + break; + } + case 1: {(this->nodes[0])->draw(); + for (enginend::nodes::node* n : maincfgpage.children) { + n->draw(); + } + break; + } + case 2: {this->nodes[0]->draw(); + for (enginend::nodes::node* n : graphics.children) { + n->draw(); + } + break; + } + } + } + void exit() override { + enginend::scene::exit(); + } }; diff --git a/games/forespend/src/client/scenes/world/entity.cpp b/games/forespend/src/client/scenes/world/entity.cpp deleted file mode 100644 index c21ca3f..0000000 --- a/games/forespend/src/client/scenes/world/entity.cpp +++ /dev/null @@ -1 +0,0 @@ -#include "../../../common/world/entity.h" diff --git a/games/forespend/src/client/scenes/world/world.cpp b/games/forespend/src/client/scenes/world/world.cpp deleted file mode 100644 index 2de7181..0000000 --- a/games/forespend/src/client/scenes/world/world.cpp +++ /dev/null @@ -1,36 +0,0 @@ -#include "../../../common/world/world.h" - -#include -Camera3D* worldcam; -enginend::nodes::trid::billboard* itsame; -void world::boot() { - - itsame=new enginend::nodes::trid::billboard({0,0,0},{0,0,0},{1,1,1},{1,1,1},"player/kinfuyuki/player.png"); - players->boot(); - entities->boot(); - buildings->boot(); - terrain=new enginend::nodes::trid::object3d(AT("res/models/world.obj")); - worldrender=LoadShader( - AT("res/shaders/tile.vs"), - AT("res/shaders/tile.fs") - ); - players->children.push_back(itsame); - worldcam=new Camera3D; - itsame->watcher=worldcam; -} -void world::draw() { - BeginMode3D(*worldcam); - BeginShaderMode(worldrender); - terrain->draw(); - EndShaderMode(); - players->draw(); - entities->draw(); - buildings->draw(); - EndMode3D(); -} -void world::exit() { - players->exit(); - entities->exit(); - buildings->exit(); -} - diff --git a/games/forespend/src/common/world/entity.h b/games/forespend/src/common/world/entity.h deleted file mode 100644 index 0d20e99..0000000 --- a/games/forespend/src/common/world/entity.h +++ /dev/null @@ -1,18 +0,0 @@ -#pragma once -#include - - -struct ENTITYTYPE { - enginend::nodes::trid::node3d* node; - bool ISBILLBOARD; -}; - -struct entity: enginend::nodes::node{ - ENTITYTYPE self; - entity(); - void boot()override; - void tick()override; - void draw()override; - void exit()override; - ~entity(); -}; diff --git a/games/forespend/src/common/world/world.h b/games/forespend/src/common/world/world.h deleted file mode 100644 index 1280cdc..0000000 --- a/games/forespend/src/common/world/world.h +++ /dev/null @@ -1,24 +0,0 @@ -#pragma once -#include - -class world :public enginend::scene{ -public: - enginend::group *players; - enginend::group *entities; - enginend::group *buildings; - bool singleplayer; - // server side - world(); - void tick() override; - ~world(); - - // client side - void boot() override; - void draw() override; - void exit() override; - enginend::nodes::trid::object3d* terrain; - Shader worldrender; - unsigned char* tiles; - - -}; \ No newline at end of file diff --git a/games/forespend/src/main.cpp b/games/forespend/src/main.cpp index a02eaf7..50c80d0 100644 --- a/games/forespend/src/main.cpp +++ b/games/forespend/src/main.cpp @@ -10,14 +10,8 @@ std::string androidpackage="kn.kinfuyuki.forespend"; inline const char* COMMONCONFIG(){return "common.tdf";} tiny::ErrorLevel tiny::level{4}; int main(int argc, char** argv) { - { - system("echo $PWD"); - system("ls $PWD/res"); - system("ls $PWD/res/fonts"); - } enginend::program* game; tiny::startup("forespend","0.03g-rewrite.5"); - bool isserver = false; if (argc>1) { for (int i=1;itick(); -} -server::~server() { - delete w; -} +void server::boot() {} +void server::draw() {} +void server::exit() {} +void server::tick() {} \ No newline at end of file diff --git a/games/forespend/src/server/server.h b/games/forespend/src/server/server.h index 2d1a96c..40060f7 100644 --- a/games/forespend/src/server/server.h +++ b/games/forespend/src/server/server.h @@ -2,16 +2,13 @@ #include -#include "../common/world/world.h" - class server : public enginend::program{ public: - world* w; server(); const char* CONF() final{return "client.tdf";} + void boot() override; void tick() override; void draw() override; void exit() override; - ~server(); -}; +}; \ No newline at end of file diff --git a/games/forespend/src/server/world/world.cpp b/games/forespend/src/server/world/world.cpp deleted file mode 100644 index c2f2ab8..0000000 --- a/games/forespend/src/server/world/world.cpp +++ /dev/null @@ -1,19 +0,0 @@ -#include "../../common/world/world.h" - -world::world() { - players=new enginend::group({}); - entities=new enginend::group({}); - buildings=new enginend::group({}); - nodes.push_back(players); -} -void world::tick() { - players->tick(); - entities->tick(); - buildings->tick(); -} - -world::~world() { - for (enginend::nodes::node* n: players->children){delete n;} - for (enginend::nodes::node* n: entities->children){delete n;} - for (enginend::nodes::node* n: buildings->children){delete n;} -} diff --git a/games/pretend/CMakeLists.txt b/games/pretend/CMakeLists.txt deleted file mode 100644 index 89be7f2..0000000 --- a/games/pretend/CMakeLists.txt +++ /dev/null @@ -1,28 +0,0 @@ -cmake_minimum_required(VERSION 3.20) -# this game will be the hardest to make buuuut -# it will be a challenge to i be able to code around -# 8h/day and not burn out since im managing many different projects -# and i wont get bored, cuz if i do i switch between -# pretend, forespend and animatronical - -set(CMAKE_CXX_FLAGS "-std=c++26 -Wno-error -Oz -w -g -mavx2") -file(GLOB_RECURSE PRETEND_SOURCES CONFIGURE_DEPENDS "src/*.cpp") -add_executable(pretend ${PRETEND_SOURCES}) -if(NOT DEFINED ${ARCH}) - set(ARCH "linux-64") -endif(NOT DEFINED ${ARCH}) -set_target_properties(pretend PROPERTIES - RUNTIME_OUTPUT_DIRECTORY "${CMAKE_SOURCE_DIR}/built/pretend/${PLATFORM_DIR}/bin" -) - -target_link_directories( - pretend PUBLIC - "${CMAKE_SOURCE_DIR}/link") - -target_link_libraries(pretend PRIVATE - enginend - raylib -) -target_include_directories(pretend PUBLIC - ${CMAKE_SOURCE_DIR}/include -) \ No newline at end of file diff --git a/include/enginend/graph/noise.h b/include/enginend/graph/noise.h deleted file mode 120000 index 8299c7b..0000000 --- a/include/enginend/graph/noise.h +++ /dev/null @@ -1 +0,0 @@ -../../../engine/src/graph/noise.h \ No newline at end of file diff --git a/include/enginend/scenes/node3d.h b/include/enginend/scenes/node3d.h deleted file mode 120000 index 503c667..0000000 --- a/include/enginend/scenes/node3d.h +++ /dev/null @@ -1 +0,0 @@ -../../../engine/src/scenes/node3d.h \ No newline at end of file diff --git a/include/json.h b/include/json.h deleted file mode 100644 index 27986ed..0000000 --- a/include/json.h +++ /dev/null @@ -1,25712 +0,0 @@ -// __ _____ _____ _____ -// __| | __| | | | JSON for Modern C++ -// | | |__ | | | | | | version 3.12.0 -// |_____|_____|_____|_|___| https://github.com/nlohmann/json -// -// SPDX-FileCopyrightText: 2013-2025 Niels Lohmann -// SPDX-License-Identifier: MIT - -/****************************************************************************\ - * Note on documentation: The source files contain links to the online * - * documentation of the public API at https://json.nlohmann.me. This URL * - * contains the most recent documentation and should also be applicable to * - * previous versions; documentation for deprecated functions is not * - * removed, but marked deprecated. See "Generate documentation" section in * - * file docs/README.md. * -\****************************************************************************/ - -#ifndef INCLUDE_NLOHMANN_JSON_HPP_ -#define INCLUDE_NLOHMANN_JSON_HPP_ - -#include // all_of, find, for_each -#include // nullptr_t, ptrdiff_t, size_t -#include // hash, less -#include // initializer_list -#ifndef JSON_NO_IO - #include // istream, ostream -#endif // JSON_NO_IO -#include // random_access_iterator_tag -#include // unique_ptr -#include // string, stoi, to_string -#include // declval, forward, move, pair, swap -#include // vector - -// #include -// __ _____ _____ _____ -// __| | __| | | | JSON for Modern C++ -// | | |__ | | | | | | version 3.12.0 -// |_____|_____|_____|_|___| https://github.com/nlohmann/json -// -// SPDX-FileCopyrightText: 2013-2025 Niels Lohmann -// SPDX-License-Identifier: MIT - - - -#include - -// #include -// __ _____ _____ _____ -// __| | __| | | | JSON for Modern C++ -// | | |__ | | | | | | version 3.12.0 -// |_____|_____|_____|_|___| https://github.com/nlohmann/json -// -// SPDX-FileCopyrightText: 2013-2025 Niels Lohmann -// SPDX-License-Identifier: MIT - - - -// This file contains all macro definitions affecting or depending on the ABI - -#ifndef JSON_SKIP_LIBRARY_VERSION_CHECK - #if defined(NLOHMANN_JSON_VERSION_MAJOR) && defined(NLOHMANN_JSON_VERSION_MINOR) && defined(NLOHMANN_JSON_VERSION_PATCH) - #if NLOHMANN_JSON_VERSION_MAJOR != 3 || NLOHMANN_JSON_VERSION_MINOR != 12 || NLOHMANN_JSON_VERSION_PATCH != 0 - #warning "Already included a different version of the library!" - #endif - #endif -#endif - -#define NLOHMANN_JSON_VERSION_MAJOR 3 // NOLINT(modernize-macro-to-enum) -#define NLOHMANN_JSON_VERSION_MINOR 12 // NOLINT(modernize-macro-to-enum) -#define NLOHMANN_JSON_VERSION_PATCH 0 // NOLINT(modernize-macro-to-enum) - -#ifndef JSON_DIAGNOSTICS - #define JSON_DIAGNOSTICS 0 -#endif - -#ifndef JSON_DIAGNOSTIC_POSITIONS - #define JSON_DIAGNOSTIC_POSITIONS 0 -#endif - -#ifndef JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON - #define JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON 0 -#endif - -#if JSON_DIAGNOSTICS - #define NLOHMANN_JSON_ABI_TAG_DIAGNOSTICS _diag -#else - #define NLOHMANN_JSON_ABI_TAG_DIAGNOSTICS -#endif - -#if JSON_DIAGNOSTIC_POSITIONS - #define NLOHMANN_JSON_ABI_TAG_DIAGNOSTIC_POSITIONS _dp -#else - #define NLOHMANN_JSON_ABI_TAG_DIAGNOSTIC_POSITIONS -#endif - -#if JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON - #define NLOHMANN_JSON_ABI_TAG_LEGACY_DISCARDED_VALUE_COMPARISON _ldvcmp -#else - #define NLOHMANN_JSON_ABI_TAG_LEGACY_DISCARDED_VALUE_COMPARISON -#endif - -#ifndef NLOHMANN_JSON_NAMESPACE_NO_VERSION - #define NLOHMANN_JSON_NAMESPACE_NO_VERSION 0 -#endif - -// Construct the namespace ABI tags component -#define NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b, c) json_abi ## a ## b ## c -#define NLOHMANN_JSON_ABI_TAGS_CONCAT(a, b, c) \ - NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b, c) - -#define NLOHMANN_JSON_ABI_TAGS \ - NLOHMANN_JSON_ABI_TAGS_CONCAT( \ - NLOHMANN_JSON_ABI_TAG_DIAGNOSTICS, \ - NLOHMANN_JSON_ABI_TAG_LEGACY_DISCARDED_VALUE_COMPARISON, \ - NLOHMANN_JSON_ABI_TAG_DIAGNOSTIC_POSITIONS) - -// Construct the namespace version component -#define NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT_EX(major, minor, patch) \ - _v ## major ## _ ## minor ## _ ## patch -#define NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT(major, minor, patch) \ - NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT_EX(major, minor, patch) - -#if NLOHMANN_JSON_NAMESPACE_NO_VERSION -#define NLOHMANN_JSON_NAMESPACE_VERSION -#else -#define NLOHMANN_JSON_NAMESPACE_VERSION \ - NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT(NLOHMANN_JSON_VERSION_MAJOR, \ - NLOHMANN_JSON_VERSION_MINOR, \ - NLOHMANN_JSON_VERSION_PATCH) -#endif - -// Combine namespace components -#define NLOHMANN_JSON_NAMESPACE_CONCAT_EX(a, b) a ## b -#define NLOHMANN_JSON_NAMESPACE_CONCAT(a, b) \ - NLOHMANN_JSON_NAMESPACE_CONCAT_EX(a, b) - -#ifndef NLOHMANN_JSON_NAMESPACE -#define NLOHMANN_JSON_NAMESPACE \ - nlohmann::NLOHMANN_JSON_NAMESPACE_CONCAT( \ - NLOHMANN_JSON_ABI_TAGS, \ - NLOHMANN_JSON_NAMESPACE_VERSION) -#endif - -#ifndef NLOHMANN_JSON_NAMESPACE_BEGIN -#define NLOHMANN_JSON_NAMESPACE_BEGIN \ - namespace nlohmann \ - { \ - inline namespace NLOHMANN_JSON_NAMESPACE_CONCAT( \ - NLOHMANN_JSON_ABI_TAGS, \ - NLOHMANN_JSON_NAMESPACE_VERSION) \ - { -#endif - -#ifndef NLOHMANN_JSON_NAMESPACE_END -#define NLOHMANN_JSON_NAMESPACE_END \ - } /* namespace (inline namespace) NOLINT(readability/namespace) */ \ - } // namespace nlohmann -#endif - -// #include -// __ _____ _____ _____ -// __| | __| | | | JSON for Modern C++ -// | | |__ | | | | | | version 3.12.0 -// |_____|_____|_____|_|___| https://github.com/nlohmann/json -// -// SPDX-FileCopyrightText: 2013-2025 Niels Lohmann -// SPDX-License-Identifier: MIT - - - -#include // transform -#include // array -#include // forward_list -#include // inserter, front_inserter, end -#include // map -#include // string -#include // tuple, make_tuple -#include // is_arithmetic, is_same, is_enum, underlying_type, is_convertible -#include // unordered_map -#include // pair, declval -#include // valarray - -// #include -// __ _____ _____ _____ -// __| | __| | | | JSON for Modern C++ -// | | |__ | | | | | | version 3.12.0 -// |_____|_____|_____|_|___| https://github.com/nlohmann/json -// -// SPDX-FileCopyrightText: 2013-2025 Niels Lohmann -// SPDX-License-Identifier: MIT - - - -#include // nullptr_t -#include // exception -#if JSON_DIAGNOSTICS - #include // accumulate -#endif -#include // runtime_error -#include // to_string -#include // vector - -// #include -// __ _____ _____ _____ -// __| | __| | | | JSON for Modern C++ -// | | |__ | | | | | | version 3.12.0 -// |_____|_____|_____|_|___| https://github.com/nlohmann/json -// -// SPDX-FileCopyrightText: 2013-2025 Niels Lohmann -// SPDX-License-Identifier: MIT - - - -#include // array -#include // size_t -#include // uint8_t -#include // string - -// #include -// __ _____ _____ _____ -// __| | __| | | | JSON for Modern C++ -// | | |__ | | | | | | version 3.12.0 -// |_____|_____|_____|_|___| https://github.com/nlohmann/json -// -// SPDX-FileCopyrightText: 2013-2025 Niels Lohmann -// SPDX-License-Identifier: MIT - - - -#include // declval, pair -// #include -// __ _____ _____ _____ -// __| | __| | | | JSON for Modern C++ -// | | |__ | | | | | | version 3.12.0 -// |_____|_____|_____|_|___| https://github.com/nlohmann/json -// -// SPDX-FileCopyrightText: 2013-2025 Niels Lohmann -// SPDX-License-Identifier: MIT - - - -#include - -// #include -// __ _____ _____ _____ -// __| | __| | | | JSON for Modern C++ -// | | |__ | | | | | | version 3.12.0 -// |_____|_____|_____|_|___| https://github.com/nlohmann/json -// -// SPDX-FileCopyrightText: 2013-2025 Niels Lohmann -// SPDX-License-Identifier: MIT - - - -// #include - - -NLOHMANN_JSON_NAMESPACE_BEGIN -namespace detail -{ - -template struct make_void -{ - using type = void; -}; -template using void_t = typename make_void::type; - -} // namespace detail -NLOHMANN_JSON_NAMESPACE_END - - -NLOHMANN_JSON_NAMESPACE_BEGIN -namespace detail -{ - -// https://en.cppreference.com/w/cpp/experimental/is_detected -struct nonesuch -{ - nonesuch() = delete; - ~nonesuch() = delete; - nonesuch(nonesuch const&) = delete; - nonesuch(nonesuch const&&) = delete; - void operator=(nonesuch const&) = delete; - void operator=(nonesuch&&) = delete; -}; - -template class Op, - class... Args> -struct detector -{ - using value_t = std::false_type; - using type = Default; -}; - -template class Op, class... Args> -struct detector>, Op, Args...> -{ - using value_t = std::true_type; - using type = Op; -}; - -template class Op, class... Args> -using is_detected = typename detector::value_t; - -template class Op, class... Args> -struct is_detected_lazy : is_detected { }; - -template class Op, class... Args> -using detected_t = typename detector::type; - -template class Op, class... Args> -using detected_or = detector; - -template class Op, class... Args> -using detected_or_t = typename detected_or::type; - -template class Op, class... Args> -using is_detected_exact = std::is_same>; - -template class Op, class... Args> -using is_detected_convertible = - std::is_convertible, To>; - -} // namespace detail -NLOHMANN_JSON_NAMESPACE_END - -// #include - - -// __ _____ _____ _____ -// __| | __| | | | JSON for Modern C++ -// | | |__ | | | | | | version 3.12.0 -// |_____|_____|_____|_|___| https://github.com/nlohmann/json -// -// SPDX-FileCopyrightText: 2013-2025 Niels Lohmann -// SPDX-FileCopyrightText: 2016-2021 Evan Nemerson -// SPDX-License-Identifier: MIT - -/* Hedley - https://nemequ.github.io/hedley - * Created by Evan Nemerson - * SPDX-License-Identifier: CC0-1.0 - */ - -#if !defined(JSON_HEDLEY_VERSION) || (JSON_HEDLEY_VERSION < 15) -#if defined(JSON_HEDLEY_VERSION) - #undef JSON_HEDLEY_VERSION -#endif -#define JSON_HEDLEY_VERSION 15 - -#if defined(JSON_HEDLEY_STRINGIFY_EX) - #undef JSON_HEDLEY_STRINGIFY_EX -#endif -#define JSON_HEDLEY_STRINGIFY_EX(x) #x - -#if defined(JSON_HEDLEY_STRINGIFY) - #undef JSON_HEDLEY_STRINGIFY -#endif -#define JSON_HEDLEY_STRINGIFY(x) JSON_HEDLEY_STRINGIFY_EX(x) - -#if defined(JSON_HEDLEY_CONCAT_EX) - #undef JSON_HEDLEY_CONCAT_EX -#endif -#define JSON_HEDLEY_CONCAT_EX(a,b) a##b - -#if defined(JSON_HEDLEY_CONCAT) - #undef JSON_HEDLEY_CONCAT -#endif -#define JSON_HEDLEY_CONCAT(a,b) JSON_HEDLEY_CONCAT_EX(a,b) - -#if defined(JSON_HEDLEY_CONCAT3_EX) - #undef JSON_HEDLEY_CONCAT3_EX -#endif -#define JSON_HEDLEY_CONCAT3_EX(a,b,c) a##b##c - -#if defined(JSON_HEDLEY_CONCAT3) - #undef JSON_HEDLEY_CONCAT3 -#endif -#define JSON_HEDLEY_CONCAT3(a,b,c) JSON_HEDLEY_CONCAT3_EX(a,b,c) - -#if defined(JSON_HEDLEY_VERSION_ENCODE) - #undef JSON_HEDLEY_VERSION_ENCODE -#endif -#define JSON_HEDLEY_VERSION_ENCODE(major,minor,revision) (((major) * 1000000) + ((minor) * 1000) + (revision)) - -#if defined(JSON_HEDLEY_VERSION_DECODE_MAJOR) - #undef JSON_HEDLEY_VERSION_DECODE_MAJOR -#endif -#define JSON_HEDLEY_VERSION_DECODE_MAJOR(version) ((version) / 1000000) - -#if defined(JSON_HEDLEY_VERSION_DECODE_MINOR) - #undef JSON_HEDLEY_VERSION_DECODE_MINOR -#endif -#define JSON_HEDLEY_VERSION_DECODE_MINOR(version) (((version) % 1000000) / 1000) - -#if defined(JSON_HEDLEY_VERSION_DECODE_REVISION) - #undef JSON_HEDLEY_VERSION_DECODE_REVISION -#endif -#define JSON_HEDLEY_VERSION_DECODE_REVISION(version) ((version) % 1000) - -#if defined(JSON_HEDLEY_GNUC_VERSION) - #undef JSON_HEDLEY_GNUC_VERSION -#endif -#if defined(__GNUC__) && defined(__GNUC_PATCHLEVEL__) - #define JSON_HEDLEY_GNUC_VERSION JSON_HEDLEY_VERSION_ENCODE(__GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__) -#elif defined(__GNUC__) - #define JSON_HEDLEY_GNUC_VERSION JSON_HEDLEY_VERSION_ENCODE(__GNUC__, __GNUC_MINOR__, 0) -#endif - -#if defined(JSON_HEDLEY_GNUC_VERSION_CHECK) - #undef JSON_HEDLEY_GNUC_VERSION_CHECK -#endif -#if defined(JSON_HEDLEY_GNUC_VERSION) - #define JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_GNUC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) -#else - #define JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) (0) -#endif - -#if defined(JSON_HEDLEY_MSVC_VERSION) - #undef JSON_HEDLEY_MSVC_VERSION -#endif -#if defined(_MSC_FULL_VER) && (_MSC_FULL_VER >= 140000000) && !defined(__ICL) - #define JSON_HEDLEY_MSVC_VERSION JSON_HEDLEY_VERSION_ENCODE(_MSC_FULL_VER / 10000000, (_MSC_FULL_VER % 10000000) / 100000, (_MSC_FULL_VER % 100000) / 100) -#elif defined(_MSC_FULL_VER) && !defined(__ICL) - #define JSON_HEDLEY_MSVC_VERSION JSON_HEDLEY_VERSION_ENCODE(_MSC_FULL_VER / 1000000, (_MSC_FULL_VER % 1000000) / 10000, (_MSC_FULL_VER % 10000) / 10) -#elif defined(_MSC_VER) && !defined(__ICL) - #define JSON_HEDLEY_MSVC_VERSION JSON_HEDLEY_VERSION_ENCODE(_MSC_VER / 100, _MSC_VER % 100, 0) -#endif - -#if defined(JSON_HEDLEY_MSVC_VERSION_CHECK) - #undef JSON_HEDLEY_MSVC_VERSION_CHECK -#endif -#if !defined(JSON_HEDLEY_MSVC_VERSION) - #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (0) -#elif defined(_MSC_VER) && (_MSC_VER >= 1400) - #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_FULL_VER >= ((major * 10000000) + (minor * 100000) + (patch))) -#elif defined(_MSC_VER) && (_MSC_VER >= 1200) - #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_FULL_VER >= ((major * 1000000) + (minor * 10000) + (patch))) -#else - #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_VER >= ((major * 100) + (minor))) -#endif - -#if defined(JSON_HEDLEY_INTEL_VERSION) - #undef JSON_HEDLEY_INTEL_VERSION -#endif -#if defined(__INTEL_COMPILER) && defined(__INTEL_COMPILER_UPDATE) && !defined(__ICL) - #define JSON_HEDLEY_INTEL_VERSION JSON_HEDLEY_VERSION_ENCODE(__INTEL_COMPILER / 100, __INTEL_COMPILER % 100, __INTEL_COMPILER_UPDATE) -#elif defined(__INTEL_COMPILER) && !defined(__ICL) - #define JSON_HEDLEY_INTEL_VERSION JSON_HEDLEY_VERSION_ENCODE(__INTEL_COMPILER / 100, __INTEL_COMPILER % 100, 0) -#endif - -#if defined(JSON_HEDLEY_INTEL_VERSION_CHECK) - #undef JSON_HEDLEY_INTEL_VERSION_CHECK -#endif -#if defined(JSON_HEDLEY_INTEL_VERSION) - #define JSON_HEDLEY_INTEL_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_INTEL_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) -#else - #define JSON_HEDLEY_INTEL_VERSION_CHECK(major,minor,patch) (0) -#endif - -#if defined(JSON_HEDLEY_INTEL_CL_VERSION) - #undef JSON_HEDLEY_INTEL_CL_VERSION -#endif -#if defined(__INTEL_COMPILER) && defined(__INTEL_COMPILER_UPDATE) && defined(__ICL) - #define JSON_HEDLEY_INTEL_CL_VERSION JSON_HEDLEY_VERSION_ENCODE(__INTEL_COMPILER, __INTEL_COMPILER_UPDATE, 0) -#endif - -#if defined(JSON_HEDLEY_INTEL_CL_VERSION_CHECK) - #undef JSON_HEDLEY_INTEL_CL_VERSION_CHECK -#endif -#if defined(JSON_HEDLEY_INTEL_CL_VERSION) - #define JSON_HEDLEY_INTEL_CL_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_INTEL_CL_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) -#else - #define JSON_HEDLEY_INTEL_CL_VERSION_CHECK(major,minor,patch) (0) -#endif - -#if defined(JSON_HEDLEY_PGI_VERSION) - #undef JSON_HEDLEY_PGI_VERSION -#endif -#if defined(__PGI) && defined(__PGIC__) && defined(__PGIC_MINOR__) && defined(__PGIC_PATCHLEVEL__) - #define JSON_HEDLEY_PGI_VERSION JSON_HEDLEY_VERSION_ENCODE(__PGIC__, __PGIC_MINOR__, __PGIC_PATCHLEVEL__) -#endif - -#if defined(JSON_HEDLEY_PGI_VERSION_CHECK) - #undef JSON_HEDLEY_PGI_VERSION_CHECK -#endif -#if defined(JSON_HEDLEY_PGI_VERSION) - #define JSON_HEDLEY_PGI_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_PGI_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) -#else - #define JSON_HEDLEY_PGI_VERSION_CHECK(major,minor,patch) (0) -#endif - -#if defined(JSON_HEDLEY_SUNPRO_VERSION) - #undef JSON_HEDLEY_SUNPRO_VERSION -#endif -#if defined(__SUNPRO_C) && (__SUNPRO_C > 0x1000) - #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((((__SUNPRO_C >> 16) & 0xf) * 10) + ((__SUNPRO_C >> 12) & 0xf), (((__SUNPRO_C >> 8) & 0xf) * 10) + ((__SUNPRO_C >> 4) & 0xf), (__SUNPRO_C & 0xf) * 10) -#elif defined(__SUNPRO_C) - #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((__SUNPRO_C >> 8) & 0xf, (__SUNPRO_C >> 4) & 0xf, (__SUNPRO_C) & 0xf) -#elif defined(__SUNPRO_CC) && (__SUNPRO_CC > 0x1000) - #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((((__SUNPRO_CC >> 16) & 0xf) * 10) + ((__SUNPRO_CC >> 12) & 0xf), (((__SUNPRO_CC >> 8) & 0xf) * 10) + ((__SUNPRO_CC >> 4) & 0xf), (__SUNPRO_CC & 0xf) * 10) -#elif defined(__SUNPRO_CC) - #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((__SUNPRO_CC >> 8) & 0xf, (__SUNPRO_CC >> 4) & 0xf, (__SUNPRO_CC) & 0xf) -#endif - -#if defined(JSON_HEDLEY_SUNPRO_VERSION_CHECK) - #undef JSON_HEDLEY_SUNPRO_VERSION_CHECK -#endif -#if defined(JSON_HEDLEY_SUNPRO_VERSION) - #define JSON_HEDLEY_SUNPRO_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_SUNPRO_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) -#else - #define JSON_HEDLEY_SUNPRO_VERSION_CHECK(major,minor,patch) (0) -#endif - -#if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION) - #undef JSON_HEDLEY_EMSCRIPTEN_VERSION -#endif -#if defined(__EMSCRIPTEN__) - #define JSON_HEDLEY_EMSCRIPTEN_VERSION JSON_HEDLEY_VERSION_ENCODE(__EMSCRIPTEN_major__, __EMSCRIPTEN_minor__, __EMSCRIPTEN_tiny__) -#endif - -#if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK) - #undef JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK -#endif -#if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION) - #define JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_EMSCRIPTEN_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) -#else - #define JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK(major,minor,patch) (0) -#endif - -#if defined(JSON_HEDLEY_ARM_VERSION) - #undef JSON_HEDLEY_ARM_VERSION -#endif -#if defined(__CC_ARM) && defined(__ARMCOMPILER_VERSION) - #define JSON_HEDLEY_ARM_VERSION JSON_HEDLEY_VERSION_ENCODE(__ARMCOMPILER_VERSION / 1000000, (__ARMCOMPILER_VERSION % 1000000) / 10000, (__ARMCOMPILER_VERSION % 10000) / 100) -#elif defined(__CC_ARM) && defined(__ARMCC_VERSION) - #define JSON_HEDLEY_ARM_VERSION JSON_HEDLEY_VERSION_ENCODE(__ARMCC_VERSION / 1000000, (__ARMCC_VERSION % 1000000) / 10000, (__ARMCC_VERSION % 10000) / 100) -#endif - -#if defined(JSON_HEDLEY_ARM_VERSION_CHECK) - #undef JSON_HEDLEY_ARM_VERSION_CHECK -#endif -#if defined(JSON_HEDLEY_ARM_VERSION) - #define JSON_HEDLEY_ARM_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_ARM_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) -#else - #define JSON_HEDLEY_ARM_VERSION_CHECK(major,minor,patch) (0) -#endif - -#if defined(JSON_HEDLEY_IBM_VERSION) - #undef JSON_HEDLEY_IBM_VERSION -#endif -#if defined(__ibmxl__) - #define JSON_HEDLEY_IBM_VERSION JSON_HEDLEY_VERSION_ENCODE(__ibmxl_version__, __ibmxl_release__, __ibmxl_modification__) -#elif defined(__xlC__) && defined(__xlC_ver__) - #define JSON_HEDLEY_IBM_VERSION JSON_HEDLEY_VERSION_ENCODE(__xlC__ >> 8, __xlC__ & 0xff, (__xlC_ver__ >> 8) & 0xff) -#elif defined(__xlC__) - #define JSON_HEDLEY_IBM_VERSION JSON_HEDLEY_VERSION_ENCODE(__xlC__ >> 8, __xlC__ & 0xff, 0) -#endif - -#if defined(JSON_HEDLEY_IBM_VERSION_CHECK) - #undef JSON_HEDLEY_IBM_VERSION_CHECK -#endif -#if defined(JSON_HEDLEY_IBM_VERSION) - #define JSON_HEDLEY_IBM_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_IBM_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) -#else - #define JSON_HEDLEY_IBM_VERSION_CHECK(major,minor,patch) (0) -#endif - -#if defined(JSON_HEDLEY_TI_VERSION) - #undef JSON_HEDLEY_TI_VERSION -#endif -#if \ - defined(__TI_COMPILER_VERSION__) && \ - ( \ - defined(__TMS470__) || defined(__TI_ARM__) || \ - defined(__MSP430__) || \ - defined(__TMS320C2000__) \ - ) -#if (__TI_COMPILER_VERSION__ >= 16000000) - #define JSON_HEDLEY_TI_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000)) -#endif -#endif - -#if defined(JSON_HEDLEY_TI_VERSION_CHECK) - #undef JSON_HEDLEY_TI_VERSION_CHECK -#endif -#if defined(JSON_HEDLEY_TI_VERSION) - #define JSON_HEDLEY_TI_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) -#else - #define JSON_HEDLEY_TI_VERSION_CHECK(major,minor,patch) (0) -#endif - -#if defined(JSON_HEDLEY_TI_CL2000_VERSION) - #undef JSON_HEDLEY_TI_CL2000_VERSION -#endif -#if defined(__TI_COMPILER_VERSION__) && defined(__TMS320C2000__) - #define JSON_HEDLEY_TI_CL2000_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000)) -#endif - -#if defined(JSON_HEDLEY_TI_CL2000_VERSION_CHECK) - #undef JSON_HEDLEY_TI_CL2000_VERSION_CHECK -#endif -#if defined(JSON_HEDLEY_TI_CL2000_VERSION) - #define JSON_HEDLEY_TI_CL2000_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL2000_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) -#else - #define JSON_HEDLEY_TI_CL2000_VERSION_CHECK(major,minor,patch) (0) -#endif - -#if defined(JSON_HEDLEY_TI_CL430_VERSION) - #undef JSON_HEDLEY_TI_CL430_VERSION -#endif -#if defined(__TI_COMPILER_VERSION__) && defined(__MSP430__) - #define JSON_HEDLEY_TI_CL430_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000)) -#endif - -#if defined(JSON_HEDLEY_TI_CL430_VERSION_CHECK) - #undef JSON_HEDLEY_TI_CL430_VERSION_CHECK -#endif -#if defined(JSON_HEDLEY_TI_CL430_VERSION) - #define JSON_HEDLEY_TI_CL430_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL430_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) -#else - #define JSON_HEDLEY_TI_CL430_VERSION_CHECK(major,minor,patch) (0) -#endif - -#if defined(JSON_HEDLEY_TI_ARMCL_VERSION) - #undef JSON_HEDLEY_TI_ARMCL_VERSION -#endif -#if defined(__TI_COMPILER_VERSION__) && (defined(__TMS470__) || defined(__TI_ARM__)) - #define JSON_HEDLEY_TI_ARMCL_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000)) -#endif - -#if defined(JSON_HEDLEY_TI_ARMCL_VERSION_CHECK) - #undef JSON_HEDLEY_TI_ARMCL_VERSION_CHECK -#endif -#if defined(JSON_HEDLEY_TI_ARMCL_VERSION) - #define JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_ARMCL_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) -#else - #define JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(major,minor,patch) (0) -#endif - -#if defined(JSON_HEDLEY_TI_CL6X_VERSION) - #undef JSON_HEDLEY_TI_CL6X_VERSION -#endif -#if defined(__TI_COMPILER_VERSION__) && defined(__TMS320C6X__) - #define JSON_HEDLEY_TI_CL6X_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000)) -#endif - -#if defined(JSON_HEDLEY_TI_CL6X_VERSION_CHECK) - #undef JSON_HEDLEY_TI_CL6X_VERSION_CHECK -#endif -#if defined(JSON_HEDLEY_TI_CL6X_VERSION) - #define JSON_HEDLEY_TI_CL6X_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL6X_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) -#else - #define JSON_HEDLEY_TI_CL6X_VERSION_CHECK(major,minor,patch) (0) -#endif - -#if defined(JSON_HEDLEY_TI_CL7X_VERSION) - #undef JSON_HEDLEY_TI_CL7X_VERSION -#endif -#if defined(__TI_COMPILER_VERSION__) && defined(__C7000__) - #define JSON_HEDLEY_TI_CL7X_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000)) -#endif - -#if defined(JSON_HEDLEY_TI_CL7X_VERSION_CHECK) - #undef JSON_HEDLEY_TI_CL7X_VERSION_CHECK -#endif -#if defined(JSON_HEDLEY_TI_CL7X_VERSION) - #define JSON_HEDLEY_TI_CL7X_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL7X_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) -#else - #define JSON_HEDLEY_TI_CL7X_VERSION_CHECK(major,minor,patch) (0) -#endif - -#if defined(JSON_HEDLEY_TI_CLPRU_VERSION) - #undef JSON_HEDLEY_TI_CLPRU_VERSION -#endif -#if defined(__TI_COMPILER_VERSION__) && defined(__PRU__) - #define JSON_HEDLEY_TI_CLPRU_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000)) -#endif - -#if defined(JSON_HEDLEY_TI_CLPRU_VERSION_CHECK) - #undef JSON_HEDLEY_TI_CLPRU_VERSION_CHECK -#endif -#if defined(JSON_HEDLEY_TI_CLPRU_VERSION) - #define JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CLPRU_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) -#else - #define JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(major,minor,patch) (0) -#endif - -#if defined(JSON_HEDLEY_CRAY_VERSION) - #undef JSON_HEDLEY_CRAY_VERSION -#endif -#if defined(_CRAYC) - #if defined(_RELEASE_PATCHLEVEL) - #define JSON_HEDLEY_CRAY_VERSION JSON_HEDLEY_VERSION_ENCODE(_RELEASE_MAJOR, _RELEASE_MINOR, _RELEASE_PATCHLEVEL) - #else - #define JSON_HEDLEY_CRAY_VERSION JSON_HEDLEY_VERSION_ENCODE(_RELEASE_MAJOR, _RELEASE_MINOR, 0) - #endif -#endif - -#if defined(JSON_HEDLEY_CRAY_VERSION_CHECK) - #undef JSON_HEDLEY_CRAY_VERSION_CHECK -#endif -#if defined(JSON_HEDLEY_CRAY_VERSION) - #define JSON_HEDLEY_CRAY_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_CRAY_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) -#else - #define JSON_HEDLEY_CRAY_VERSION_CHECK(major,minor,patch) (0) -#endif - -#if defined(JSON_HEDLEY_IAR_VERSION) - #undef JSON_HEDLEY_IAR_VERSION -#endif -#if defined(__IAR_SYSTEMS_ICC__) - #if __VER__ > 1000 - #define JSON_HEDLEY_IAR_VERSION JSON_HEDLEY_VERSION_ENCODE((__VER__ / 1000000), ((__VER__ / 1000) % 1000), (__VER__ % 1000)) - #else - #define JSON_HEDLEY_IAR_VERSION JSON_HEDLEY_VERSION_ENCODE(__VER__ / 100, __VER__ % 100, 0) - #endif -#endif - -#if defined(JSON_HEDLEY_IAR_VERSION_CHECK) - #undef JSON_HEDLEY_IAR_VERSION_CHECK -#endif -#if defined(JSON_HEDLEY_IAR_VERSION) - #define JSON_HEDLEY_IAR_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_IAR_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) -#else - #define JSON_HEDLEY_IAR_VERSION_CHECK(major,minor,patch) (0) -#endif - -#if defined(JSON_HEDLEY_TINYC_VERSION) - #undef JSON_HEDLEY_TINYC_VERSION -#endif -#if defined(__TINYC__) - #define JSON_HEDLEY_TINYC_VERSION JSON_HEDLEY_VERSION_ENCODE(__TINYC__ / 1000, (__TINYC__ / 100) % 10, __TINYC__ % 100) -#endif - -#if defined(JSON_HEDLEY_TINYC_VERSION_CHECK) - #undef JSON_HEDLEY_TINYC_VERSION_CHECK -#endif -#if defined(JSON_HEDLEY_TINYC_VERSION) - #define JSON_HEDLEY_TINYC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TINYC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) -#else - #define JSON_HEDLEY_TINYC_VERSION_CHECK(major,minor,patch) (0) -#endif - -#if defined(JSON_HEDLEY_DMC_VERSION) - #undef JSON_HEDLEY_DMC_VERSION -#endif -#if defined(__DMC__) - #define JSON_HEDLEY_DMC_VERSION JSON_HEDLEY_VERSION_ENCODE(__DMC__ >> 8, (__DMC__ >> 4) & 0xf, __DMC__ & 0xf) -#endif - -#if defined(JSON_HEDLEY_DMC_VERSION_CHECK) - #undef JSON_HEDLEY_DMC_VERSION_CHECK -#endif -#if defined(JSON_HEDLEY_DMC_VERSION) - #define JSON_HEDLEY_DMC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_DMC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) -#else - #define JSON_HEDLEY_DMC_VERSION_CHECK(major,minor,patch) (0) -#endif - -#if defined(JSON_HEDLEY_COMPCERT_VERSION) - #undef JSON_HEDLEY_COMPCERT_VERSION -#endif -#if defined(__COMPCERT_VERSION__) - #define JSON_HEDLEY_COMPCERT_VERSION JSON_HEDLEY_VERSION_ENCODE(__COMPCERT_VERSION__ / 10000, (__COMPCERT_VERSION__ / 100) % 100, __COMPCERT_VERSION__ % 100) -#endif - -#if defined(JSON_HEDLEY_COMPCERT_VERSION_CHECK) - #undef JSON_HEDLEY_COMPCERT_VERSION_CHECK -#endif -#if defined(JSON_HEDLEY_COMPCERT_VERSION) - #define JSON_HEDLEY_COMPCERT_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_COMPCERT_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) -#else - #define JSON_HEDLEY_COMPCERT_VERSION_CHECK(major,minor,patch) (0) -#endif - -#if defined(JSON_HEDLEY_PELLES_VERSION) - #undef JSON_HEDLEY_PELLES_VERSION -#endif -#if defined(__POCC__) - #define JSON_HEDLEY_PELLES_VERSION JSON_HEDLEY_VERSION_ENCODE(__POCC__ / 100, __POCC__ % 100, 0) -#endif - -#if defined(JSON_HEDLEY_PELLES_VERSION_CHECK) - #undef JSON_HEDLEY_PELLES_VERSION_CHECK -#endif -#if defined(JSON_HEDLEY_PELLES_VERSION) - #define JSON_HEDLEY_PELLES_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_PELLES_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) -#else - #define JSON_HEDLEY_PELLES_VERSION_CHECK(major,minor,patch) (0) -#endif - -#if defined(JSON_HEDLEY_MCST_LCC_VERSION) - #undef JSON_HEDLEY_MCST_LCC_VERSION -#endif -#if defined(__LCC__) && defined(__LCC_MINOR__) - #define JSON_HEDLEY_MCST_LCC_VERSION JSON_HEDLEY_VERSION_ENCODE(__LCC__ / 100, __LCC__ % 100, __LCC_MINOR__) -#endif - -#if defined(JSON_HEDLEY_MCST_LCC_VERSION_CHECK) - #undef JSON_HEDLEY_MCST_LCC_VERSION_CHECK -#endif -#if defined(JSON_HEDLEY_MCST_LCC_VERSION) - #define JSON_HEDLEY_MCST_LCC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_MCST_LCC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) -#else - #define JSON_HEDLEY_MCST_LCC_VERSION_CHECK(major,minor,patch) (0) -#endif - -#if defined(JSON_HEDLEY_GCC_VERSION) - #undef JSON_HEDLEY_GCC_VERSION -#endif -#if \ - defined(JSON_HEDLEY_GNUC_VERSION) && \ - !defined(__clang__) && \ - !defined(JSON_HEDLEY_INTEL_VERSION) && \ - !defined(JSON_HEDLEY_PGI_VERSION) && \ - !defined(JSON_HEDLEY_ARM_VERSION) && \ - !defined(JSON_HEDLEY_CRAY_VERSION) && \ - !defined(JSON_HEDLEY_TI_VERSION) && \ - !defined(JSON_HEDLEY_TI_ARMCL_VERSION) && \ - !defined(JSON_HEDLEY_TI_CL430_VERSION) && \ - !defined(JSON_HEDLEY_TI_CL2000_VERSION) && \ - !defined(JSON_HEDLEY_TI_CL6X_VERSION) && \ - !defined(JSON_HEDLEY_TI_CL7X_VERSION) && \ - !defined(JSON_HEDLEY_TI_CLPRU_VERSION) && \ - !defined(__COMPCERT__) && \ - !defined(JSON_HEDLEY_MCST_LCC_VERSION) - #define JSON_HEDLEY_GCC_VERSION JSON_HEDLEY_GNUC_VERSION -#endif - -#if defined(JSON_HEDLEY_GCC_VERSION_CHECK) - #undef JSON_HEDLEY_GCC_VERSION_CHECK -#endif -#if defined(JSON_HEDLEY_GCC_VERSION) - #define JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_GCC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) -#else - #define JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) (0) -#endif - -#if defined(JSON_HEDLEY_HAS_ATTRIBUTE) - #undef JSON_HEDLEY_HAS_ATTRIBUTE -#endif -#if \ - defined(__has_attribute) && \ - ( \ - (!defined(JSON_HEDLEY_IAR_VERSION) || JSON_HEDLEY_IAR_VERSION_CHECK(8,5,9)) \ - ) -# define JSON_HEDLEY_HAS_ATTRIBUTE(attribute) __has_attribute(attribute) -#else -# define JSON_HEDLEY_HAS_ATTRIBUTE(attribute) (0) -#endif - -#if defined(JSON_HEDLEY_GNUC_HAS_ATTRIBUTE) - #undef JSON_HEDLEY_GNUC_HAS_ATTRIBUTE -#endif -#if defined(__has_attribute) - #define JSON_HEDLEY_GNUC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_HAS_ATTRIBUTE(attribute) -#else - #define JSON_HEDLEY_GNUC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) -#endif - -#if defined(JSON_HEDLEY_GCC_HAS_ATTRIBUTE) - #undef JSON_HEDLEY_GCC_HAS_ATTRIBUTE -#endif -#if defined(__has_attribute) - #define JSON_HEDLEY_GCC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_HAS_ATTRIBUTE(attribute) -#else - #define JSON_HEDLEY_GCC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) -#endif - -#if defined(JSON_HEDLEY_HAS_CPP_ATTRIBUTE) - #undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE -#endif -#if \ - defined(__has_cpp_attribute) && \ - defined(__cplusplus) && \ - (!defined(JSON_HEDLEY_SUNPRO_VERSION) || JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0)) - #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute) __has_cpp_attribute(attribute) -#else - #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute) (0) -#endif - -#if defined(JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS) - #undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS -#endif -#if !defined(__cplusplus) || !defined(__has_cpp_attribute) - #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) (0) -#elif \ - !defined(JSON_HEDLEY_PGI_VERSION) && \ - !defined(JSON_HEDLEY_IAR_VERSION) && \ - (!defined(JSON_HEDLEY_SUNPRO_VERSION) || JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0)) && \ - (!defined(JSON_HEDLEY_MSVC_VERSION) || JSON_HEDLEY_MSVC_VERSION_CHECK(19,20,0)) - #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) JSON_HEDLEY_HAS_CPP_ATTRIBUTE(ns::attribute) -#else - #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) (0) -#endif - -#if defined(JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE) - #undef JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE -#endif -#if defined(__has_cpp_attribute) && defined(__cplusplus) - #define JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) __has_cpp_attribute(attribute) -#else - #define JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) -#endif - -#if defined(JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE) - #undef JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE -#endif -#if defined(__has_cpp_attribute) && defined(__cplusplus) - #define JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) __has_cpp_attribute(attribute) -#else - #define JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) -#endif - -#if defined(JSON_HEDLEY_HAS_BUILTIN) - #undef JSON_HEDLEY_HAS_BUILTIN -#endif -#if defined(__has_builtin) - #define JSON_HEDLEY_HAS_BUILTIN(builtin) __has_builtin(builtin) -#else - #define JSON_HEDLEY_HAS_BUILTIN(builtin) (0) -#endif - -#if defined(JSON_HEDLEY_GNUC_HAS_BUILTIN) - #undef JSON_HEDLEY_GNUC_HAS_BUILTIN -#endif -#if defined(__has_builtin) - #define JSON_HEDLEY_GNUC_HAS_BUILTIN(builtin,major,minor,patch) __has_builtin(builtin) -#else - #define JSON_HEDLEY_GNUC_HAS_BUILTIN(builtin,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) -#endif - -#if defined(JSON_HEDLEY_GCC_HAS_BUILTIN) - #undef JSON_HEDLEY_GCC_HAS_BUILTIN -#endif -#if defined(__has_builtin) - #define JSON_HEDLEY_GCC_HAS_BUILTIN(builtin,major,minor,patch) __has_builtin(builtin) -#else - #define JSON_HEDLEY_GCC_HAS_BUILTIN(builtin,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) -#endif - -#if defined(JSON_HEDLEY_HAS_FEATURE) - #undef JSON_HEDLEY_HAS_FEATURE -#endif -#if defined(__has_feature) - #define JSON_HEDLEY_HAS_FEATURE(feature) __has_feature(feature) -#else - #define JSON_HEDLEY_HAS_FEATURE(feature) (0) -#endif - -#if defined(JSON_HEDLEY_GNUC_HAS_FEATURE) - #undef JSON_HEDLEY_GNUC_HAS_FEATURE -#endif -#if defined(__has_feature) - #define JSON_HEDLEY_GNUC_HAS_FEATURE(feature,major,minor,patch) __has_feature(feature) -#else - #define JSON_HEDLEY_GNUC_HAS_FEATURE(feature,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) -#endif - -#if defined(JSON_HEDLEY_GCC_HAS_FEATURE) - #undef JSON_HEDLEY_GCC_HAS_FEATURE -#endif -#if defined(__has_feature) - #define JSON_HEDLEY_GCC_HAS_FEATURE(feature,major,minor,patch) __has_feature(feature) -#else - #define JSON_HEDLEY_GCC_HAS_FEATURE(feature,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) -#endif - -#if defined(JSON_HEDLEY_HAS_EXTENSION) - #undef JSON_HEDLEY_HAS_EXTENSION -#endif -#if defined(__has_extension) - #define JSON_HEDLEY_HAS_EXTENSION(extension) __has_extension(extension) -#else - #define JSON_HEDLEY_HAS_EXTENSION(extension) (0) -#endif - -#if defined(JSON_HEDLEY_GNUC_HAS_EXTENSION) - #undef JSON_HEDLEY_GNUC_HAS_EXTENSION -#endif -#if defined(__has_extension) - #define JSON_HEDLEY_GNUC_HAS_EXTENSION(extension,major,minor,patch) __has_extension(extension) -#else - #define JSON_HEDLEY_GNUC_HAS_EXTENSION(extension,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) -#endif - -#if defined(JSON_HEDLEY_GCC_HAS_EXTENSION) - #undef JSON_HEDLEY_GCC_HAS_EXTENSION -#endif -#if defined(__has_extension) - #define JSON_HEDLEY_GCC_HAS_EXTENSION(extension,major,minor,patch) __has_extension(extension) -#else - #define JSON_HEDLEY_GCC_HAS_EXTENSION(extension,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) -#endif - -#if defined(JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE) - #undef JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE -#endif -#if defined(__has_declspec_attribute) - #define JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute) __has_declspec_attribute(attribute) -#else - #define JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute) (0) -#endif - -#if defined(JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE) - #undef JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE -#endif -#if defined(__has_declspec_attribute) - #define JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) __has_declspec_attribute(attribute) -#else - #define JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) -#endif - -#if defined(JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE) - #undef JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE -#endif -#if defined(__has_declspec_attribute) - #define JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) __has_declspec_attribute(attribute) -#else - #define JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) -#endif - -#if defined(JSON_HEDLEY_HAS_WARNING) - #undef JSON_HEDLEY_HAS_WARNING -#endif -#if defined(__has_warning) - #define JSON_HEDLEY_HAS_WARNING(warning) __has_warning(warning) -#else - #define JSON_HEDLEY_HAS_WARNING(warning) (0) -#endif - -#if defined(JSON_HEDLEY_GNUC_HAS_WARNING) - #undef JSON_HEDLEY_GNUC_HAS_WARNING -#endif -#if defined(__has_warning) - #define JSON_HEDLEY_GNUC_HAS_WARNING(warning,major,minor,patch) __has_warning(warning) -#else - #define JSON_HEDLEY_GNUC_HAS_WARNING(warning,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) -#endif - -#if defined(JSON_HEDLEY_GCC_HAS_WARNING) - #undef JSON_HEDLEY_GCC_HAS_WARNING -#endif -#if defined(__has_warning) - #define JSON_HEDLEY_GCC_HAS_WARNING(warning,major,minor,patch) __has_warning(warning) -#else - #define JSON_HEDLEY_GCC_HAS_WARNING(warning,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) -#endif - -#if \ - (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)) || \ - defined(__clang__) || \ - JSON_HEDLEY_GCC_VERSION_CHECK(3,0,0) || \ - JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ - JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) || \ - JSON_HEDLEY_PGI_VERSION_CHECK(18,4,0) || \ - JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ - JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ - JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,7,0) || \ - JSON_HEDLEY_TI_CL430_VERSION_CHECK(2,0,1) || \ - JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,1,0) || \ - JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,0,0) || \ - JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ - JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ - JSON_HEDLEY_CRAY_VERSION_CHECK(5,0,0) || \ - JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,17) || \ - JSON_HEDLEY_SUNPRO_VERSION_CHECK(8,0,0) || \ - (JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) && defined(__C99_PRAGMA_OPERATOR)) - #define JSON_HEDLEY_PRAGMA(value) _Pragma(#value) -#elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0) - #define JSON_HEDLEY_PRAGMA(value) __pragma(value) -#else - #define JSON_HEDLEY_PRAGMA(value) -#endif - -#if defined(JSON_HEDLEY_DIAGNOSTIC_PUSH) - #undef JSON_HEDLEY_DIAGNOSTIC_PUSH -#endif -#if defined(JSON_HEDLEY_DIAGNOSTIC_POP) - #undef JSON_HEDLEY_DIAGNOSTIC_POP -#endif -#if defined(__clang__) - #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("clang diagnostic push") - #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("clang diagnostic pop") -#elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) - #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("warning(push)") - #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("warning(pop)") -#elif JSON_HEDLEY_GCC_VERSION_CHECK(4,6,0) - #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("GCC diagnostic push") - #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("GCC diagnostic pop") -#elif \ - JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0) || \ - JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) - #define JSON_HEDLEY_DIAGNOSTIC_PUSH __pragma(warning(push)) - #define JSON_HEDLEY_DIAGNOSTIC_POP __pragma(warning(pop)) -#elif JSON_HEDLEY_ARM_VERSION_CHECK(5,6,0) - #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("push") - #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("pop") -#elif \ - JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ - JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ - JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,4,0) || \ - JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,1,0) || \ - JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ - JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) - #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("diag_push") - #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("diag_pop") -#elif JSON_HEDLEY_PELLES_VERSION_CHECK(2,90,0) - #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("warning(push)") - #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("warning(pop)") -#else - #define JSON_HEDLEY_DIAGNOSTIC_PUSH - #define JSON_HEDLEY_DIAGNOSTIC_POP -#endif - -/* JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_ is for - HEDLEY INTERNAL USE ONLY. API subject to change without notice. */ -#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_) - #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_ -#endif -#if defined(__cplusplus) -# if JSON_HEDLEY_HAS_WARNING("-Wc++98-compat") -# if JSON_HEDLEY_HAS_WARNING("-Wc++17-extensions") -# if JSON_HEDLEY_HAS_WARNING("-Wc++1z-extensions") -# define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr) \ - JSON_HEDLEY_DIAGNOSTIC_PUSH \ - _Pragma("clang diagnostic ignored \"-Wc++98-compat\"") \ - _Pragma("clang diagnostic ignored \"-Wc++17-extensions\"") \ - _Pragma("clang diagnostic ignored \"-Wc++1z-extensions\"") \ - xpr \ - JSON_HEDLEY_DIAGNOSTIC_POP -# else -# define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr) \ - JSON_HEDLEY_DIAGNOSTIC_PUSH \ - _Pragma("clang diagnostic ignored \"-Wc++98-compat\"") \ - _Pragma("clang diagnostic ignored \"-Wc++17-extensions\"") \ - xpr \ - JSON_HEDLEY_DIAGNOSTIC_POP -# endif -# else -# define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr) \ - JSON_HEDLEY_DIAGNOSTIC_PUSH \ - _Pragma("clang diagnostic ignored \"-Wc++98-compat\"") \ - xpr \ - JSON_HEDLEY_DIAGNOSTIC_POP -# endif -# endif -#endif -#if !defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_) - #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(x) x -#endif - -#if defined(JSON_HEDLEY_CONST_CAST) - #undef JSON_HEDLEY_CONST_CAST -#endif -#if defined(__cplusplus) -# define JSON_HEDLEY_CONST_CAST(T, expr) (const_cast(expr)) -#elif \ - JSON_HEDLEY_HAS_WARNING("-Wcast-qual") || \ - JSON_HEDLEY_GCC_VERSION_CHECK(4,6,0) || \ - JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) -# define JSON_HEDLEY_CONST_CAST(T, expr) (__extension__ ({ \ - JSON_HEDLEY_DIAGNOSTIC_PUSH \ - JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL \ - ((T) (expr)); \ - JSON_HEDLEY_DIAGNOSTIC_POP \ - })) -#else -# define JSON_HEDLEY_CONST_CAST(T, expr) ((T) (expr)) -#endif - -#if defined(JSON_HEDLEY_REINTERPRET_CAST) - #undef JSON_HEDLEY_REINTERPRET_CAST -#endif -#if defined(__cplusplus) - #define JSON_HEDLEY_REINTERPRET_CAST(T, expr) (reinterpret_cast(expr)) -#else - #define JSON_HEDLEY_REINTERPRET_CAST(T, expr) ((T) (expr)) -#endif - -#if defined(JSON_HEDLEY_STATIC_CAST) - #undef JSON_HEDLEY_STATIC_CAST -#endif -#if defined(__cplusplus) - #define JSON_HEDLEY_STATIC_CAST(T, expr) (static_cast(expr)) -#else - #define JSON_HEDLEY_STATIC_CAST(T, expr) ((T) (expr)) -#endif - -#if defined(JSON_HEDLEY_CPP_CAST) - #undef JSON_HEDLEY_CPP_CAST -#endif -#if defined(__cplusplus) -# if JSON_HEDLEY_HAS_WARNING("-Wold-style-cast") -# define JSON_HEDLEY_CPP_CAST(T, expr) \ - JSON_HEDLEY_DIAGNOSTIC_PUSH \ - _Pragma("clang diagnostic ignored \"-Wold-style-cast\"") \ - ((T) (expr)) \ - JSON_HEDLEY_DIAGNOSTIC_POP -# elif JSON_HEDLEY_IAR_VERSION_CHECK(8,3,0) -# define JSON_HEDLEY_CPP_CAST(T, expr) \ - JSON_HEDLEY_DIAGNOSTIC_PUSH \ - _Pragma("diag_suppress=Pe137") \ - JSON_HEDLEY_DIAGNOSTIC_POP -# else -# define JSON_HEDLEY_CPP_CAST(T, expr) ((T) (expr)) -# endif -#else -# define JSON_HEDLEY_CPP_CAST(T, expr) (expr) -#endif - -#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED) - #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED -#endif -#if JSON_HEDLEY_HAS_WARNING("-Wdeprecated-declarations") - #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("clang diagnostic ignored \"-Wdeprecated-declarations\"") -#elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) - #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("warning(disable:1478 1786)") -#elif JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) - #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED __pragma(warning(disable:1478 1786)) -#elif JSON_HEDLEY_PGI_VERSION_CHECK(20,7,0) - #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1215,1216,1444,1445") -#elif JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) - #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1215,1444") -#elif JSON_HEDLEY_GCC_VERSION_CHECK(4,3,0) - #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"") -#elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0) - #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED __pragma(warning(disable:4996)) -#elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) - #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1215,1444") -#elif \ - JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ - (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ - JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ - (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ - JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ - (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ - JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ - (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ - JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \ - JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ - JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) - #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1291,1718") -#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,13,0) && !defined(__cplusplus) - #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("error_messages(off,E_DEPRECATED_ATT,E_DEPRECATED_ATT_MESS)") -#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,13,0) && defined(__cplusplus) - #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("error_messages(off,symdeprecated,symdeprecated2)") -#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) - #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress=Pe1444,Pe1215") -#elif JSON_HEDLEY_PELLES_VERSION_CHECK(2,90,0) - #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("warn(disable:2241)") -#else - #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED -#endif - -#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS) - #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS -#endif -#if JSON_HEDLEY_HAS_WARNING("-Wunknown-pragmas") - #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("clang diagnostic ignored \"-Wunknown-pragmas\"") -#elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) - #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("warning(disable:161)") -#elif JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) - #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS __pragma(warning(disable:161)) -#elif JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) - #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 1675") -#elif JSON_HEDLEY_GCC_VERSION_CHECK(4,3,0) - #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("GCC diagnostic ignored \"-Wunknown-pragmas\"") -#elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0) - #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS __pragma(warning(disable:4068)) -#elif \ - JSON_HEDLEY_TI_VERSION_CHECK(16,9,0) || \ - JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,0,0) || \ - JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ - JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,3,0) - #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 163") -#elif JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,0,0) - #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 163") -#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) - #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress=Pe161") -#elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) - #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 161") -#else - #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS -#endif - -#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES) - #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES -#endif -#if JSON_HEDLEY_HAS_WARNING("-Wunknown-attributes") - #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("clang diagnostic ignored \"-Wunknown-attributes\"") -#elif JSON_HEDLEY_GCC_VERSION_CHECK(4,6,0) - #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"") -#elif JSON_HEDLEY_INTEL_VERSION_CHECK(17,0,0) - #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("warning(disable:1292)") -#elif JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) - #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES __pragma(warning(disable:1292)) -#elif JSON_HEDLEY_MSVC_VERSION_CHECK(19,0,0) - #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES __pragma(warning(disable:5030)) -#elif JSON_HEDLEY_PGI_VERSION_CHECK(20,7,0) - #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1097,1098") -#elif JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) - #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1097") -#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,14,0) && defined(__cplusplus) - #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("error_messages(off,attrskipunsup)") -#elif \ - JSON_HEDLEY_TI_VERSION_CHECK(18,1,0) || \ - JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,3,0) || \ - JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) - #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1173") -#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) - #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress=Pe1097") -#elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) - #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1097") -#else - #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES -#endif - -#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL) - #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL -#endif -#if JSON_HEDLEY_HAS_WARNING("-Wcast-qual") - #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL _Pragma("clang diagnostic ignored \"-Wcast-qual\"") -#elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) - #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL _Pragma("warning(disable:2203 2331)") -#elif JSON_HEDLEY_GCC_VERSION_CHECK(3,0,0) - #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL _Pragma("GCC diagnostic ignored \"-Wcast-qual\"") -#else - #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL -#endif - -#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION) - #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION -#endif -#if JSON_HEDLEY_HAS_WARNING("-Wunused-function") - #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION _Pragma("clang diagnostic ignored \"-Wunused-function\"") -#elif JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) - #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION _Pragma("GCC diagnostic ignored \"-Wunused-function\"") -#elif JSON_HEDLEY_MSVC_VERSION_CHECK(1,0,0) - #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION __pragma(warning(disable:4505)) -#elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) - #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION _Pragma("diag_suppress 3142") -#else - #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION -#endif - -#if defined(JSON_HEDLEY_DEPRECATED) - #undef JSON_HEDLEY_DEPRECATED -#endif -#if defined(JSON_HEDLEY_DEPRECATED_FOR) - #undef JSON_HEDLEY_DEPRECATED_FOR -#endif -#if \ - JSON_HEDLEY_MSVC_VERSION_CHECK(14,0,0) || \ - JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) - #define JSON_HEDLEY_DEPRECATED(since) __declspec(deprecated("Since " # since)) - #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __declspec(deprecated("Since " #since "; use " #replacement)) -#elif \ - (JSON_HEDLEY_HAS_EXTENSION(attribute_deprecated_with_message) && !defined(JSON_HEDLEY_IAR_VERSION)) || \ - JSON_HEDLEY_GCC_VERSION_CHECK(4,5,0) || \ - JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ - JSON_HEDLEY_ARM_VERSION_CHECK(5,6,0) || \ - JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,13,0) || \ - JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \ - JSON_HEDLEY_TI_VERSION_CHECK(18,1,0) || \ - JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(18,1,0) || \ - JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,3,0) || \ - JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ - JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,3,0) || \ - JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) - #define JSON_HEDLEY_DEPRECATED(since) __attribute__((__deprecated__("Since " #since))) - #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __attribute__((__deprecated__("Since " #since "; use " #replacement))) -#elif defined(__cplusplus) && (__cplusplus >= 201402L) - #define JSON_HEDLEY_DEPRECATED(since) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[deprecated("Since " #since)]]) - #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[deprecated("Since " #since "; use " #replacement)]]) -#elif \ - JSON_HEDLEY_HAS_ATTRIBUTE(deprecated) || \ - JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \ - JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ - JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ - (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ - JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ - (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ - JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ - (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ - JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ - (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ - JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \ - JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ - JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ - JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) || \ - JSON_HEDLEY_IAR_VERSION_CHECK(8,10,0) - #define JSON_HEDLEY_DEPRECATED(since) __attribute__((__deprecated__)) - #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __attribute__((__deprecated__)) -#elif \ - JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \ - JSON_HEDLEY_PELLES_VERSION_CHECK(6,50,0) || \ - JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) - #define JSON_HEDLEY_DEPRECATED(since) __declspec(deprecated) - #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __declspec(deprecated) -#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) - #define JSON_HEDLEY_DEPRECATED(since) _Pragma("deprecated") - #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) _Pragma("deprecated") -#else - #define JSON_HEDLEY_DEPRECATED(since) - #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) -#endif - -#if defined(JSON_HEDLEY_UNAVAILABLE) - #undef JSON_HEDLEY_UNAVAILABLE -#endif -#if \ - JSON_HEDLEY_HAS_ATTRIBUTE(warning) || \ - JSON_HEDLEY_GCC_VERSION_CHECK(4,3,0) || \ - JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ - JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) - #define JSON_HEDLEY_UNAVAILABLE(available_since) __attribute__((__warning__("Not available until " #available_since))) -#else - #define JSON_HEDLEY_UNAVAILABLE(available_since) -#endif - -#if defined(JSON_HEDLEY_WARN_UNUSED_RESULT) - #undef JSON_HEDLEY_WARN_UNUSED_RESULT -#endif -#if defined(JSON_HEDLEY_WARN_UNUSED_RESULT_MSG) - #undef JSON_HEDLEY_WARN_UNUSED_RESULT_MSG -#endif -#if \ - JSON_HEDLEY_HAS_ATTRIBUTE(warn_unused_result) || \ - JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) || \ - JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ - JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ - (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ - JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ - (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ - JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ - (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ - JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ - (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ - JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \ - JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ - JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ - (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0) && defined(__cplusplus)) || \ - JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \ - JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) - #define JSON_HEDLEY_WARN_UNUSED_RESULT __attribute__((__warn_unused_result__)) - #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) __attribute__((__warn_unused_result__)) -#elif (JSON_HEDLEY_HAS_CPP_ATTRIBUTE(nodiscard) >= 201907L) - #define JSON_HEDLEY_WARN_UNUSED_RESULT JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]]) - #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard(msg)]]) -#elif JSON_HEDLEY_HAS_CPP_ATTRIBUTE(nodiscard) - #define JSON_HEDLEY_WARN_UNUSED_RESULT JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]]) - #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]]) -#elif defined(_Check_return_) /* SAL */ - #define JSON_HEDLEY_WARN_UNUSED_RESULT _Check_return_ - #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) _Check_return_ -#else - #define JSON_HEDLEY_WARN_UNUSED_RESULT - #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) -#endif - -#if defined(JSON_HEDLEY_SENTINEL) - #undef JSON_HEDLEY_SENTINEL -#endif -#if \ - JSON_HEDLEY_HAS_ATTRIBUTE(sentinel) || \ - JSON_HEDLEY_GCC_VERSION_CHECK(4,0,0) || \ - JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ - JSON_HEDLEY_ARM_VERSION_CHECK(5,4,0) || \ - JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) - #define JSON_HEDLEY_SENTINEL(position) __attribute__((__sentinel__(position))) -#else - #define JSON_HEDLEY_SENTINEL(position) -#endif - -#if defined(JSON_HEDLEY_NO_RETURN) - #undef JSON_HEDLEY_NO_RETURN -#endif -#if JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) - #define JSON_HEDLEY_NO_RETURN __noreturn -#elif \ - JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ - JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) - #define JSON_HEDLEY_NO_RETURN __attribute__((__noreturn__)) -#elif defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L - #define JSON_HEDLEY_NO_RETURN _Noreturn -#elif defined(__cplusplus) && (__cplusplus >= 201103L) - #define JSON_HEDLEY_NO_RETURN JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[noreturn]]) -#elif \ - JSON_HEDLEY_HAS_ATTRIBUTE(noreturn) || \ - JSON_HEDLEY_GCC_VERSION_CHECK(3,2,0) || \ - JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \ - JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ - JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \ - JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ - (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ - JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ - (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ - JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ - (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ - JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ - (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ - JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \ - JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ - JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ - JSON_HEDLEY_IAR_VERSION_CHECK(8,10,0) - #define JSON_HEDLEY_NO_RETURN __attribute__((__noreturn__)) -#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0) - #define JSON_HEDLEY_NO_RETURN _Pragma("does_not_return") -#elif \ - JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \ - JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) - #define JSON_HEDLEY_NO_RETURN __declspec(noreturn) -#elif JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,0,0) && defined(__cplusplus) - #define JSON_HEDLEY_NO_RETURN _Pragma("FUNC_NEVER_RETURNS;") -#elif JSON_HEDLEY_COMPCERT_VERSION_CHECK(3,2,0) - #define JSON_HEDLEY_NO_RETURN __attribute((noreturn)) -#elif JSON_HEDLEY_PELLES_VERSION_CHECK(9,0,0) - #define JSON_HEDLEY_NO_RETURN __declspec(noreturn) -#else - #define JSON_HEDLEY_NO_RETURN -#endif - -#if defined(JSON_HEDLEY_NO_ESCAPE) - #undef JSON_HEDLEY_NO_ESCAPE -#endif -#if JSON_HEDLEY_HAS_ATTRIBUTE(noescape) - #define JSON_HEDLEY_NO_ESCAPE __attribute__((__noescape__)) -#else - #define JSON_HEDLEY_NO_ESCAPE -#endif - -#if defined(JSON_HEDLEY_UNREACHABLE) - #undef JSON_HEDLEY_UNREACHABLE -#endif -#if defined(JSON_HEDLEY_UNREACHABLE_RETURN) - #undef JSON_HEDLEY_UNREACHABLE_RETURN -#endif -#if defined(JSON_HEDLEY_ASSUME) - #undef JSON_HEDLEY_ASSUME -#endif -#if \ - JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \ - JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ - JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) - #define JSON_HEDLEY_ASSUME(expr) __assume(expr) -#elif JSON_HEDLEY_HAS_BUILTIN(__builtin_assume) - #define JSON_HEDLEY_ASSUME(expr) __builtin_assume(expr) -#elif \ - JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,0) || \ - JSON_HEDLEY_TI_CL6X_VERSION_CHECK(4,0,0) - #if defined(__cplusplus) - #define JSON_HEDLEY_ASSUME(expr) std::_nassert(expr) - #else - #define JSON_HEDLEY_ASSUME(expr) _nassert(expr) - #endif -#endif -#if \ - (JSON_HEDLEY_HAS_BUILTIN(__builtin_unreachable) && (!defined(JSON_HEDLEY_ARM_VERSION))) || \ - JSON_HEDLEY_GCC_VERSION_CHECK(4,5,0) || \ - JSON_HEDLEY_PGI_VERSION_CHECK(18,10,0) || \ - JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ - JSON_HEDLEY_IBM_VERSION_CHECK(13,1,5) || \ - JSON_HEDLEY_CRAY_VERSION_CHECK(10,0,0) || \ - JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) - #define JSON_HEDLEY_UNREACHABLE() __builtin_unreachable() -#elif defined(JSON_HEDLEY_ASSUME) - #define JSON_HEDLEY_UNREACHABLE() JSON_HEDLEY_ASSUME(0) -#endif -#if !defined(JSON_HEDLEY_ASSUME) - #if defined(JSON_HEDLEY_UNREACHABLE) - #define JSON_HEDLEY_ASSUME(expr) JSON_HEDLEY_STATIC_CAST(void, ((expr) ? 1 : (JSON_HEDLEY_UNREACHABLE(), 1))) - #else - #define JSON_HEDLEY_ASSUME(expr) JSON_HEDLEY_STATIC_CAST(void, expr) - #endif -#endif -#if defined(JSON_HEDLEY_UNREACHABLE) - #if \ - JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,0) || \ - JSON_HEDLEY_TI_CL6X_VERSION_CHECK(4,0,0) - #define JSON_HEDLEY_UNREACHABLE_RETURN(value) return (JSON_HEDLEY_STATIC_CAST(void, JSON_HEDLEY_ASSUME(0)), (value)) - #else - #define JSON_HEDLEY_UNREACHABLE_RETURN(value) JSON_HEDLEY_UNREACHABLE() - #endif -#else - #define JSON_HEDLEY_UNREACHABLE_RETURN(value) return (value) -#endif -#if !defined(JSON_HEDLEY_UNREACHABLE) - #define JSON_HEDLEY_UNREACHABLE() JSON_HEDLEY_ASSUME(0) -#endif - -JSON_HEDLEY_DIAGNOSTIC_PUSH -#if JSON_HEDLEY_HAS_WARNING("-Wpedantic") - #pragma clang diagnostic ignored "-Wpedantic" -#endif -#if JSON_HEDLEY_HAS_WARNING("-Wc++98-compat-pedantic") && defined(__cplusplus) - #pragma clang diagnostic ignored "-Wc++98-compat-pedantic" -#endif -#if JSON_HEDLEY_GCC_HAS_WARNING("-Wvariadic-macros",4,0,0) - #if defined(__clang__) - #pragma clang diagnostic ignored "-Wvariadic-macros" - #elif defined(JSON_HEDLEY_GCC_VERSION) - #pragma GCC diagnostic ignored "-Wvariadic-macros" - #endif -#endif -#if defined(JSON_HEDLEY_NON_NULL) - #undef JSON_HEDLEY_NON_NULL -#endif -#if \ - JSON_HEDLEY_HAS_ATTRIBUTE(nonnull) || \ - JSON_HEDLEY_GCC_VERSION_CHECK(3,3,0) || \ - JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ - JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) - #define JSON_HEDLEY_NON_NULL(...) __attribute__((__nonnull__(__VA_ARGS__))) -#else - #define JSON_HEDLEY_NON_NULL(...) -#endif -JSON_HEDLEY_DIAGNOSTIC_POP - -#if defined(JSON_HEDLEY_PRINTF_FORMAT) - #undef JSON_HEDLEY_PRINTF_FORMAT -#endif -#if defined(__MINGW32__) && JSON_HEDLEY_GCC_HAS_ATTRIBUTE(format,4,4,0) && !defined(__USE_MINGW_ANSI_STDIO) - #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __attribute__((__format__(ms_printf, string_idx, first_to_check))) -#elif defined(__MINGW32__) && JSON_HEDLEY_GCC_HAS_ATTRIBUTE(format,4,4,0) && defined(__USE_MINGW_ANSI_STDIO) - #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __attribute__((__format__(gnu_printf, string_idx, first_to_check))) -#elif \ - JSON_HEDLEY_HAS_ATTRIBUTE(format) || \ - JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \ - JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ - JSON_HEDLEY_ARM_VERSION_CHECK(5,6,0) || \ - JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \ - JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ - (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ - JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ - (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ - JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ - (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ - JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ - (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ - JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \ - JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ - JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ - JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) - #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __attribute__((__format__(__printf__, string_idx, first_to_check))) -#elif JSON_HEDLEY_PELLES_VERSION_CHECK(6,0,0) - #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __declspec(vaformat(printf,string_idx,first_to_check)) -#else - #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) -#endif - -#if defined(JSON_HEDLEY_CONSTEXPR) - #undef JSON_HEDLEY_CONSTEXPR -#endif -#if defined(__cplusplus) - #if __cplusplus >= 201103L - #define JSON_HEDLEY_CONSTEXPR JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(constexpr) - #endif -#endif -#if !defined(JSON_HEDLEY_CONSTEXPR) - #define JSON_HEDLEY_CONSTEXPR -#endif - -#if defined(JSON_HEDLEY_PREDICT) - #undef JSON_HEDLEY_PREDICT -#endif -#if defined(JSON_HEDLEY_LIKELY) - #undef JSON_HEDLEY_LIKELY -#endif -#if defined(JSON_HEDLEY_UNLIKELY) - #undef JSON_HEDLEY_UNLIKELY -#endif -#if defined(JSON_HEDLEY_UNPREDICTABLE) - #undef JSON_HEDLEY_UNPREDICTABLE -#endif -#if JSON_HEDLEY_HAS_BUILTIN(__builtin_unpredictable) - #define JSON_HEDLEY_UNPREDICTABLE(expr) __builtin_unpredictable((expr)) -#endif -#if \ - (JSON_HEDLEY_HAS_BUILTIN(__builtin_expect_with_probability) && !defined(JSON_HEDLEY_PGI_VERSION)) || \ - JSON_HEDLEY_GCC_VERSION_CHECK(9,0,0) || \ - JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) -# define JSON_HEDLEY_PREDICT(expr, value, probability) __builtin_expect_with_probability( (expr), (value), (probability)) -# define JSON_HEDLEY_PREDICT_TRUE(expr, probability) __builtin_expect_with_probability(!!(expr), 1 , (probability)) -# define JSON_HEDLEY_PREDICT_FALSE(expr, probability) __builtin_expect_with_probability(!!(expr), 0 , (probability)) -# define JSON_HEDLEY_LIKELY(expr) __builtin_expect (!!(expr), 1 ) -# define JSON_HEDLEY_UNLIKELY(expr) __builtin_expect (!!(expr), 0 ) -#elif \ - (JSON_HEDLEY_HAS_BUILTIN(__builtin_expect) && !defined(JSON_HEDLEY_INTEL_CL_VERSION)) || \ - JSON_HEDLEY_GCC_VERSION_CHECK(3,0,0) || \ - JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ - (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0) && defined(__cplusplus)) || \ - JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ - JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \ - JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ - JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,7,0) || \ - JSON_HEDLEY_TI_CL430_VERSION_CHECK(3,1,0) || \ - JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,1,0) || \ - JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,1,0) || \ - JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ - JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ - JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,27) || \ - JSON_HEDLEY_CRAY_VERSION_CHECK(8,1,0) || \ - JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) -# define JSON_HEDLEY_PREDICT(expr, expected, probability) \ - (((probability) >= 0.9) ? __builtin_expect((expr), (expected)) : (JSON_HEDLEY_STATIC_CAST(void, expected), (expr))) -# define JSON_HEDLEY_PREDICT_TRUE(expr, probability) \ - (__extension__ ({ \ - double hedley_probability_ = (probability); \ - ((hedley_probability_ >= 0.9) ? __builtin_expect(!!(expr), 1) : ((hedley_probability_ <= 0.1) ? __builtin_expect(!!(expr), 0) : !!(expr))); \ - })) -# define JSON_HEDLEY_PREDICT_FALSE(expr, probability) \ - (__extension__ ({ \ - double hedley_probability_ = (probability); \ - ((hedley_probability_ >= 0.9) ? __builtin_expect(!!(expr), 0) : ((hedley_probability_ <= 0.1) ? __builtin_expect(!!(expr), 1) : !!(expr))); \ - })) -# define JSON_HEDLEY_LIKELY(expr) __builtin_expect(!!(expr), 1) -# define JSON_HEDLEY_UNLIKELY(expr) __builtin_expect(!!(expr), 0) -#else -# define JSON_HEDLEY_PREDICT(expr, expected, probability) (JSON_HEDLEY_STATIC_CAST(void, expected), (expr)) -# define JSON_HEDLEY_PREDICT_TRUE(expr, probability) (!!(expr)) -# define JSON_HEDLEY_PREDICT_FALSE(expr, probability) (!!(expr)) -# define JSON_HEDLEY_LIKELY(expr) (!!(expr)) -# define JSON_HEDLEY_UNLIKELY(expr) (!!(expr)) -#endif -#if !defined(JSON_HEDLEY_UNPREDICTABLE) - #define JSON_HEDLEY_UNPREDICTABLE(expr) JSON_HEDLEY_PREDICT(expr, 1, 0.5) -#endif - -#if defined(JSON_HEDLEY_MALLOC) - #undef JSON_HEDLEY_MALLOC -#endif -#if \ - JSON_HEDLEY_HAS_ATTRIBUTE(malloc) || \ - JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \ - JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ - JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \ - JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ - JSON_HEDLEY_IBM_VERSION_CHECK(12,1,0) || \ - JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ - (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ - JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ - (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ - JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ - (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ - JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ - (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ - JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \ - JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ - JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ - JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) - #define JSON_HEDLEY_MALLOC __attribute__((__malloc__)) -#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0) - #define JSON_HEDLEY_MALLOC _Pragma("returns_new_memory") -#elif \ - JSON_HEDLEY_MSVC_VERSION_CHECK(14,0,0) || \ - JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) - #define JSON_HEDLEY_MALLOC __declspec(restrict) -#else - #define JSON_HEDLEY_MALLOC -#endif - -#if defined(JSON_HEDLEY_PURE) - #undef JSON_HEDLEY_PURE -#endif -#if \ - JSON_HEDLEY_HAS_ATTRIBUTE(pure) || \ - JSON_HEDLEY_GCC_VERSION_CHECK(2,96,0) || \ - JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ - JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \ - JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ - JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \ - JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ - (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ - JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ - (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ - JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ - (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ - JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ - (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ - JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \ - JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ - JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ - JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \ - JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) -# define JSON_HEDLEY_PURE __attribute__((__pure__)) -#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0) -# define JSON_HEDLEY_PURE _Pragma("does_not_write_global_data") -#elif defined(__cplusplus) && \ - ( \ - JSON_HEDLEY_TI_CL430_VERSION_CHECK(2,0,1) || \ - JSON_HEDLEY_TI_CL6X_VERSION_CHECK(4,0,0) || \ - JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) \ - ) -# define JSON_HEDLEY_PURE _Pragma("FUNC_IS_PURE;") -#else -# define JSON_HEDLEY_PURE -#endif - -#if defined(JSON_HEDLEY_CONST) - #undef JSON_HEDLEY_CONST -#endif -#if \ - JSON_HEDLEY_HAS_ATTRIBUTE(const) || \ - JSON_HEDLEY_GCC_VERSION_CHECK(2,5,0) || \ - JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ - JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \ - JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ - JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \ - JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ - (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ - JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ - (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ - JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ - (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ - JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ - (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ - JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \ - JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ - JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ - JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \ - JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) - #define JSON_HEDLEY_CONST __attribute__((__const__)) -#elif \ - JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0) - #define JSON_HEDLEY_CONST _Pragma("no_side_effect") -#else - #define JSON_HEDLEY_CONST JSON_HEDLEY_PURE -#endif - -#if defined(JSON_HEDLEY_RESTRICT) - #undef JSON_HEDLEY_RESTRICT -#endif -#if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) && !defined(__cplusplus) - #define JSON_HEDLEY_RESTRICT restrict -#elif \ - JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \ - JSON_HEDLEY_MSVC_VERSION_CHECK(14,0,0) || \ - JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ - JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) || \ - JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ - JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \ - JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \ - JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ - JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,4) || \ - JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,1,0) || \ - JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ - (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,14,0) && defined(__cplusplus)) || \ - JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) || \ - defined(__clang__) || \ - JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) - #define JSON_HEDLEY_RESTRICT __restrict -#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,3,0) && !defined(__cplusplus) - #define JSON_HEDLEY_RESTRICT _Restrict -#else - #define JSON_HEDLEY_RESTRICT -#endif - -#if defined(JSON_HEDLEY_INLINE) - #undef JSON_HEDLEY_INLINE -#endif -#if \ - (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)) || \ - (defined(__cplusplus) && (__cplusplus >= 199711L)) - #define JSON_HEDLEY_INLINE inline -#elif \ - defined(JSON_HEDLEY_GCC_VERSION) || \ - JSON_HEDLEY_ARM_VERSION_CHECK(6,2,0) - #define JSON_HEDLEY_INLINE __inline__ -#elif \ - JSON_HEDLEY_MSVC_VERSION_CHECK(12,0,0) || \ - JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) || \ - JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ - JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,1,0) || \ - JSON_HEDLEY_TI_CL430_VERSION_CHECK(3,1,0) || \ - JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,0) || \ - JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,0,0) || \ - JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ - JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ - JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) - #define JSON_HEDLEY_INLINE __inline -#else - #define JSON_HEDLEY_INLINE -#endif - -#if defined(JSON_HEDLEY_ALWAYS_INLINE) - #undef JSON_HEDLEY_ALWAYS_INLINE -#endif -#if \ - JSON_HEDLEY_HAS_ATTRIBUTE(always_inline) || \ - JSON_HEDLEY_GCC_VERSION_CHECK(4,0,0) || \ - JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ - JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \ - JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ - JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \ - JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ - (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ - JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ - (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ - JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ - (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ - JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ - (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ - JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \ - JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ - JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ - JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) || \ - JSON_HEDLEY_IAR_VERSION_CHECK(8,10,0) -# define JSON_HEDLEY_ALWAYS_INLINE __attribute__((__always_inline__)) JSON_HEDLEY_INLINE -#elif \ - JSON_HEDLEY_MSVC_VERSION_CHECK(12,0,0) || \ - JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) -# define JSON_HEDLEY_ALWAYS_INLINE __forceinline -#elif defined(__cplusplus) && \ - ( \ - JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ - JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ - JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ - JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,1,0) || \ - JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ - JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) \ - ) -# define JSON_HEDLEY_ALWAYS_INLINE _Pragma("FUNC_ALWAYS_INLINE;") -#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) -# define JSON_HEDLEY_ALWAYS_INLINE _Pragma("inline=forced") -#else -# define JSON_HEDLEY_ALWAYS_INLINE JSON_HEDLEY_INLINE -#endif - -#if defined(JSON_HEDLEY_NEVER_INLINE) - #undef JSON_HEDLEY_NEVER_INLINE -#endif -#if \ - JSON_HEDLEY_HAS_ATTRIBUTE(noinline) || \ - JSON_HEDLEY_GCC_VERSION_CHECK(4,0,0) || \ - JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ - JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \ - JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ - JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \ - JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ - (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ - JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ - (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ - JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ - (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ - JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ - (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ - JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \ - JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ - JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ - JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) || \ - JSON_HEDLEY_IAR_VERSION_CHECK(8,10,0) - #define JSON_HEDLEY_NEVER_INLINE __attribute__((__noinline__)) -#elif \ - JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \ - JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) - #define JSON_HEDLEY_NEVER_INLINE __declspec(noinline) -#elif JSON_HEDLEY_PGI_VERSION_CHECK(10,2,0) - #define JSON_HEDLEY_NEVER_INLINE _Pragma("noinline") -#elif JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,0,0) && defined(__cplusplus) - #define JSON_HEDLEY_NEVER_INLINE _Pragma("FUNC_CANNOT_INLINE;") -#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) - #define JSON_HEDLEY_NEVER_INLINE _Pragma("inline=never") -#elif JSON_HEDLEY_COMPCERT_VERSION_CHECK(3,2,0) - #define JSON_HEDLEY_NEVER_INLINE __attribute((noinline)) -#elif JSON_HEDLEY_PELLES_VERSION_CHECK(9,0,0) - #define JSON_HEDLEY_NEVER_INLINE __declspec(noinline) -#else - #define JSON_HEDLEY_NEVER_INLINE -#endif - -#if defined(JSON_HEDLEY_PRIVATE) - #undef JSON_HEDLEY_PRIVATE -#endif -#if defined(JSON_HEDLEY_PUBLIC) - #undef JSON_HEDLEY_PUBLIC -#endif -#if defined(JSON_HEDLEY_IMPORT) - #undef JSON_HEDLEY_IMPORT -#endif -#if defined(_WIN32) || defined(__CYGWIN__) -# define JSON_HEDLEY_PRIVATE -# define JSON_HEDLEY_PUBLIC __declspec(dllexport) -# define JSON_HEDLEY_IMPORT __declspec(dllimport) -#else -# if \ - JSON_HEDLEY_HAS_ATTRIBUTE(visibility) || \ - JSON_HEDLEY_GCC_VERSION_CHECK(3,3,0) || \ - JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \ - JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ - JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ - JSON_HEDLEY_IBM_VERSION_CHECK(13,1,0) || \ - ( \ - defined(__TI_EABI__) && \ - ( \ - (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ - JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) \ - ) \ - ) || \ - JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) -# define JSON_HEDLEY_PRIVATE __attribute__((__visibility__("hidden"))) -# define JSON_HEDLEY_PUBLIC __attribute__((__visibility__("default"))) -# else -# define JSON_HEDLEY_PRIVATE -# define JSON_HEDLEY_PUBLIC -# endif -# define JSON_HEDLEY_IMPORT extern -#endif - -#if defined(JSON_HEDLEY_NO_THROW) - #undef JSON_HEDLEY_NO_THROW -#endif -#if \ - JSON_HEDLEY_HAS_ATTRIBUTE(nothrow) || \ - JSON_HEDLEY_GCC_VERSION_CHECK(3,3,0) || \ - JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ - JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) - #define JSON_HEDLEY_NO_THROW __attribute__((__nothrow__)) -#elif \ - JSON_HEDLEY_MSVC_VERSION_CHECK(13,1,0) || \ - JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) || \ - JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) - #define JSON_HEDLEY_NO_THROW __declspec(nothrow) -#else - #define JSON_HEDLEY_NO_THROW -#endif - -#if defined(JSON_HEDLEY_FALL_THROUGH) - #undef JSON_HEDLEY_FALL_THROUGH -#endif -#if \ - JSON_HEDLEY_HAS_ATTRIBUTE(fallthrough) || \ - JSON_HEDLEY_GCC_VERSION_CHECK(7,0,0) || \ - JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) - #define JSON_HEDLEY_FALL_THROUGH __attribute__((__fallthrough__)) -#elif JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(clang,fallthrough) - #define JSON_HEDLEY_FALL_THROUGH JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[clang::fallthrough]]) -#elif JSON_HEDLEY_HAS_CPP_ATTRIBUTE(fallthrough) - #define JSON_HEDLEY_FALL_THROUGH JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[fallthrough]]) -#elif defined(__fallthrough) /* SAL */ - #define JSON_HEDLEY_FALL_THROUGH __fallthrough -#else - #define JSON_HEDLEY_FALL_THROUGH -#endif - -#if defined(JSON_HEDLEY_RETURNS_NON_NULL) - #undef JSON_HEDLEY_RETURNS_NON_NULL -#endif -#if \ - JSON_HEDLEY_HAS_ATTRIBUTE(returns_nonnull) || \ - JSON_HEDLEY_GCC_VERSION_CHECK(4,9,0) || \ - JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) - #define JSON_HEDLEY_RETURNS_NON_NULL __attribute__((__returns_nonnull__)) -#elif defined(_Ret_notnull_) /* SAL */ - #define JSON_HEDLEY_RETURNS_NON_NULL _Ret_notnull_ -#else - #define JSON_HEDLEY_RETURNS_NON_NULL -#endif - -#if defined(JSON_HEDLEY_ARRAY_PARAM) - #undef JSON_HEDLEY_ARRAY_PARAM -#endif -#if \ - defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) && \ - !defined(__STDC_NO_VLA__) && \ - !defined(__cplusplus) && \ - !defined(JSON_HEDLEY_PGI_VERSION) && \ - !defined(JSON_HEDLEY_TINYC_VERSION) - #define JSON_HEDLEY_ARRAY_PARAM(name) (name) -#else - #define JSON_HEDLEY_ARRAY_PARAM(name) -#endif - -#if defined(JSON_HEDLEY_IS_CONSTANT) - #undef JSON_HEDLEY_IS_CONSTANT -#endif -#if defined(JSON_HEDLEY_REQUIRE_CONSTEXPR) - #undef JSON_HEDLEY_REQUIRE_CONSTEXPR -#endif -/* JSON_HEDLEY_IS_CONSTEXPR_ is for - HEDLEY INTERNAL USE ONLY. API subject to change without notice. */ -#if defined(JSON_HEDLEY_IS_CONSTEXPR_) - #undef JSON_HEDLEY_IS_CONSTEXPR_ -#endif -#if \ - JSON_HEDLEY_HAS_BUILTIN(__builtin_constant_p) || \ - JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) || \ - JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ - JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,19) || \ - JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ - JSON_HEDLEY_IBM_VERSION_CHECK(13,1,0) || \ - JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,1,0) || \ - (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0) && !defined(__cplusplus)) || \ - JSON_HEDLEY_CRAY_VERSION_CHECK(8,1,0) || \ - JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) - #define JSON_HEDLEY_IS_CONSTANT(expr) __builtin_constant_p(expr) -#endif -#if !defined(__cplusplus) -# if \ - JSON_HEDLEY_HAS_BUILTIN(__builtin_types_compatible_p) || \ - JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) || \ - JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ - JSON_HEDLEY_IBM_VERSION_CHECK(13,1,0) || \ - JSON_HEDLEY_CRAY_VERSION_CHECK(8,1,0) || \ - JSON_HEDLEY_ARM_VERSION_CHECK(5,4,0) || \ - JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,24) -#if defined(__INTPTR_TYPE__) - #define JSON_HEDLEY_IS_CONSTEXPR_(expr) __builtin_types_compatible_p(__typeof__((1 ? (void*) ((__INTPTR_TYPE__) ((expr) * 0)) : (int*) 0)), int*) -#else - #include - #define JSON_HEDLEY_IS_CONSTEXPR_(expr) __builtin_types_compatible_p(__typeof__((1 ? (void*) ((intptr_t) ((expr) * 0)) : (int*) 0)), int*) -#endif -# elif \ - ( \ - defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L) && \ - !defined(JSON_HEDLEY_SUNPRO_VERSION) && \ - !defined(JSON_HEDLEY_PGI_VERSION) && \ - !defined(JSON_HEDLEY_IAR_VERSION)) || \ - (JSON_HEDLEY_HAS_EXTENSION(c_generic_selections) && !defined(JSON_HEDLEY_IAR_VERSION)) || \ - JSON_HEDLEY_GCC_VERSION_CHECK(4,9,0) || \ - JSON_HEDLEY_INTEL_VERSION_CHECK(17,0,0) || \ - JSON_HEDLEY_IBM_VERSION_CHECK(12,1,0) || \ - JSON_HEDLEY_ARM_VERSION_CHECK(5,3,0) -#if defined(__INTPTR_TYPE__) - #define JSON_HEDLEY_IS_CONSTEXPR_(expr) _Generic((1 ? (void*) ((__INTPTR_TYPE__) ((expr) * 0)) : (int*) 0), int*: 1, void*: 0) -#else - #include - #define JSON_HEDLEY_IS_CONSTEXPR_(expr) _Generic((1 ? (void*) ((intptr_t) * 0) : (int*) 0), int*: 1, void*: 0) -#endif -# elif \ - defined(JSON_HEDLEY_GCC_VERSION) || \ - defined(JSON_HEDLEY_INTEL_VERSION) || \ - defined(JSON_HEDLEY_TINYC_VERSION) || \ - defined(JSON_HEDLEY_TI_ARMCL_VERSION) || \ - JSON_HEDLEY_TI_CL430_VERSION_CHECK(18,12,0) || \ - defined(JSON_HEDLEY_TI_CL2000_VERSION) || \ - defined(JSON_HEDLEY_TI_CL6X_VERSION) || \ - defined(JSON_HEDLEY_TI_CL7X_VERSION) || \ - defined(JSON_HEDLEY_TI_CLPRU_VERSION) || \ - defined(__clang__) -# define JSON_HEDLEY_IS_CONSTEXPR_(expr) ( \ - sizeof(void) != \ - sizeof(*( \ - 1 ? \ - ((void*) ((expr) * 0L) ) : \ -((struct { char v[sizeof(void) * 2]; } *) 1) \ - ) \ - ) \ - ) -# endif -#endif -#if defined(JSON_HEDLEY_IS_CONSTEXPR_) - #if !defined(JSON_HEDLEY_IS_CONSTANT) - #define JSON_HEDLEY_IS_CONSTANT(expr) JSON_HEDLEY_IS_CONSTEXPR_(expr) - #endif - #define JSON_HEDLEY_REQUIRE_CONSTEXPR(expr) (JSON_HEDLEY_IS_CONSTEXPR_(expr) ? (expr) : (-1)) -#else - #if !defined(JSON_HEDLEY_IS_CONSTANT) - #define JSON_HEDLEY_IS_CONSTANT(expr) (0) - #endif - #define JSON_HEDLEY_REQUIRE_CONSTEXPR(expr) (expr) -#endif - -#if defined(JSON_HEDLEY_BEGIN_C_DECLS) - #undef JSON_HEDLEY_BEGIN_C_DECLS -#endif -#if defined(JSON_HEDLEY_END_C_DECLS) - #undef JSON_HEDLEY_END_C_DECLS -#endif -#if defined(JSON_HEDLEY_C_DECL) - #undef JSON_HEDLEY_C_DECL -#endif -#if defined(__cplusplus) - #define JSON_HEDLEY_BEGIN_C_DECLS extern "C" { - #define JSON_HEDLEY_END_C_DECLS } - #define JSON_HEDLEY_C_DECL extern "C" -#else - #define JSON_HEDLEY_BEGIN_C_DECLS - #define JSON_HEDLEY_END_C_DECLS - #define JSON_HEDLEY_C_DECL -#endif - -#if defined(JSON_HEDLEY_STATIC_ASSERT) - #undef JSON_HEDLEY_STATIC_ASSERT -#endif -#if \ - !defined(__cplusplus) && ( \ - (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L)) || \ - (JSON_HEDLEY_HAS_FEATURE(c_static_assert) && !defined(JSON_HEDLEY_INTEL_CL_VERSION)) || \ - JSON_HEDLEY_GCC_VERSION_CHECK(6,0,0) || \ - JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ - defined(_Static_assert) \ - ) -# define JSON_HEDLEY_STATIC_ASSERT(expr, message) _Static_assert(expr, message) -#elif \ - (defined(__cplusplus) && (__cplusplus >= 201103L)) || \ - JSON_HEDLEY_MSVC_VERSION_CHECK(16,0,0) || \ - JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) -# define JSON_HEDLEY_STATIC_ASSERT(expr, message) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(static_assert(expr, message)) -#else -# define JSON_HEDLEY_STATIC_ASSERT(expr, message) -#endif - -#if defined(JSON_HEDLEY_NULL) - #undef JSON_HEDLEY_NULL -#endif -#if defined(__cplusplus) - #if __cplusplus >= 201103L - #define JSON_HEDLEY_NULL JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(nullptr) - #elif defined(NULL) - #define JSON_HEDLEY_NULL NULL - #else - #define JSON_HEDLEY_NULL JSON_HEDLEY_STATIC_CAST(void*, 0) - #endif -#elif defined(NULL) - #define JSON_HEDLEY_NULL NULL -#else - #define JSON_HEDLEY_NULL ((void*) 0) -#endif - -#if defined(JSON_HEDLEY_MESSAGE) - #undef JSON_HEDLEY_MESSAGE -#endif -#if JSON_HEDLEY_HAS_WARNING("-Wunknown-pragmas") -# define JSON_HEDLEY_MESSAGE(msg) \ - JSON_HEDLEY_DIAGNOSTIC_PUSH \ - JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS \ - JSON_HEDLEY_PRAGMA(message msg) \ - JSON_HEDLEY_DIAGNOSTIC_POP -#elif \ - JSON_HEDLEY_GCC_VERSION_CHECK(4,4,0) || \ - JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) -# define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(message msg) -#elif JSON_HEDLEY_CRAY_VERSION_CHECK(5,0,0) -# define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(_CRI message msg) -#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) -# define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(message(msg)) -#elif JSON_HEDLEY_PELLES_VERSION_CHECK(2,0,0) -# define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(message(msg)) -#else -# define JSON_HEDLEY_MESSAGE(msg) -#endif - -#if defined(JSON_HEDLEY_WARNING) - #undef JSON_HEDLEY_WARNING -#endif -#if JSON_HEDLEY_HAS_WARNING("-Wunknown-pragmas") -# define JSON_HEDLEY_WARNING(msg) \ - JSON_HEDLEY_DIAGNOSTIC_PUSH \ - JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS \ - JSON_HEDLEY_PRAGMA(clang warning msg) \ - JSON_HEDLEY_DIAGNOSTIC_POP -#elif \ - JSON_HEDLEY_GCC_VERSION_CHECK(4,8,0) || \ - JSON_HEDLEY_PGI_VERSION_CHECK(18,4,0) || \ - JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) -# define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_PRAGMA(GCC warning msg) -#elif \ - JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0) || \ - JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) -# define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_PRAGMA(message(msg)) -#else -# define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_MESSAGE(msg) -#endif - -#if defined(JSON_HEDLEY_REQUIRE) - #undef JSON_HEDLEY_REQUIRE -#endif -#if defined(JSON_HEDLEY_REQUIRE_MSG) - #undef JSON_HEDLEY_REQUIRE_MSG -#endif -#if JSON_HEDLEY_HAS_ATTRIBUTE(diagnose_if) -# if JSON_HEDLEY_HAS_WARNING("-Wgcc-compat") -# define JSON_HEDLEY_REQUIRE(expr) \ - JSON_HEDLEY_DIAGNOSTIC_PUSH \ - _Pragma("clang diagnostic ignored \"-Wgcc-compat\"") \ - __attribute__((diagnose_if(!(expr), #expr, "error"))) \ - JSON_HEDLEY_DIAGNOSTIC_POP -# define JSON_HEDLEY_REQUIRE_MSG(expr,msg) \ - JSON_HEDLEY_DIAGNOSTIC_PUSH \ - _Pragma("clang diagnostic ignored \"-Wgcc-compat\"") \ - __attribute__((diagnose_if(!(expr), msg, "error"))) \ - JSON_HEDLEY_DIAGNOSTIC_POP -# else -# define JSON_HEDLEY_REQUIRE(expr) __attribute__((diagnose_if(!(expr), #expr, "error"))) -# define JSON_HEDLEY_REQUIRE_MSG(expr,msg) __attribute__((diagnose_if(!(expr), msg, "error"))) -# endif -#else -# define JSON_HEDLEY_REQUIRE(expr) -# define JSON_HEDLEY_REQUIRE_MSG(expr,msg) -#endif - -#if defined(JSON_HEDLEY_FLAGS) - #undef JSON_HEDLEY_FLAGS -#endif -#if JSON_HEDLEY_HAS_ATTRIBUTE(flag_enum) && (!defined(__cplusplus) || JSON_HEDLEY_HAS_WARNING("-Wbitfield-enum-conversion")) - #define JSON_HEDLEY_FLAGS __attribute__((__flag_enum__)) -#else - #define JSON_HEDLEY_FLAGS -#endif - -#if defined(JSON_HEDLEY_FLAGS_CAST) - #undef JSON_HEDLEY_FLAGS_CAST -#endif -#if JSON_HEDLEY_INTEL_VERSION_CHECK(19,0,0) -# define JSON_HEDLEY_FLAGS_CAST(T, expr) (__extension__ ({ \ - JSON_HEDLEY_DIAGNOSTIC_PUSH \ - _Pragma("warning(disable:188)") \ - ((T) (expr)); \ - JSON_HEDLEY_DIAGNOSTIC_POP \ - })) -#else -# define JSON_HEDLEY_FLAGS_CAST(T, expr) JSON_HEDLEY_STATIC_CAST(T, expr) -#endif - -#if defined(JSON_HEDLEY_EMPTY_BASES) - #undef JSON_HEDLEY_EMPTY_BASES -#endif -#if \ - (JSON_HEDLEY_MSVC_VERSION_CHECK(19,0,23918) && !JSON_HEDLEY_MSVC_VERSION_CHECK(20,0,0)) || \ - JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) - #define JSON_HEDLEY_EMPTY_BASES __declspec(empty_bases) -#else - #define JSON_HEDLEY_EMPTY_BASES -#endif - -/* Remaining macros are deprecated. */ - -#if defined(JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK) - #undef JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK -#endif -#if defined(__clang__) - #define JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK(major,minor,patch) (0) -#else - #define JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK(major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) -#endif - -#if defined(JSON_HEDLEY_CLANG_HAS_ATTRIBUTE) - #undef JSON_HEDLEY_CLANG_HAS_ATTRIBUTE -#endif -#define JSON_HEDLEY_CLANG_HAS_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_ATTRIBUTE(attribute) - -#if defined(JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE) - #undef JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE -#endif -#define JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute) - -#if defined(JSON_HEDLEY_CLANG_HAS_BUILTIN) - #undef JSON_HEDLEY_CLANG_HAS_BUILTIN -#endif -#define JSON_HEDLEY_CLANG_HAS_BUILTIN(builtin) JSON_HEDLEY_HAS_BUILTIN(builtin) - -#if defined(JSON_HEDLEY_CLANG_HAS_FEATURE) - #undef JSON_HEDLEY_CLANG_HAS_FEATURE -#endif -#define JSON_HEDLEY_CLANG_HAS_FEATURE(feature) JSON_HEDLEY_HAS_FEATURE(feature) - -#if defined(JSON_HEDLEY_CLANG_HAS_EXTENSION) - #undef JSON_HEDLEY_CLANG_HAS_EXTENSION -#endif -#define JSON_HEDLEY_CLANG_HAS_EXTENSION(extension) JSON_HEDLEY_HAS_EXTENSION(extension) - -#if defined(JSON_HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE) - #undef JSON_HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE -#endif -#define JSON_HEDLEY_CLANG_HAS_DECLSPEC_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute) - -#if defined(JSON_HEDLEY_CLANG_HAS_WARNING) - #undef JSON_HEDLEY_CLANG_HAS_WARNING -#endif -#define JSON_HEDLEY_CLANG_HAS_WARNING(warning) JSON_HEDLEY_HAS_WARNING(warning) - -#endif /* !defined(JSON_HEDLEY_VERSION) || (JSON_HEDLEY_VERSION < X) */ - - -// This file contains all internal macro definitions (except those affecting ABI) -// You MUST include macro_unscope.hpp at the end of json.hpp to undef all of them - -// #include - - -// exclude unsupported compilers -#if !defined(JSON_SKIP_UNSUPPORTED_COMPILER_CHECK) - #if defined(__clang__) - #if (__clang_major__ * 10000 + __clang_minor__ * 100 + __clang_patchlevel__) < 30400 - #error "unsupported Clang version - see https://github.com/nlohmann/json#supported-compilers" - #endif - #elif defined(__GNUC__) && !(defined(__ICC) || defined(__INTEL_COMPILER)) - #if (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__) < 40800 - #error "unsupported GCC version - see https://github.com/nlohmann/json#supported-compilers" - #endif - #endif -#endif - -// C++ language standard detection -// if the user manually specified the used C++ version, this is skipped -#if !defined(JSON_HAS_CPP_26) && !defined(JSON_HAS_CPP_23) && !defined(JSON_HAS_CPP_20) && !defined(JSON_HAS_CPP_17) && !defined(JSON_HAS_CPP_14) && !defined(JSON_HAS_CPP_11) - #if (defined(__cplusplus) && __cplusplus > 202302L) || (defined(_MSVC_LANG) && _MSVC_LANG > 202302L) - #define JSON_HAS_CPP_26 - #define JSON_HAS_CPP_23 - #define JSON_HAS_CPP_20 - #define JSON_HAS_CPP_17 - #define JSON_HAS_CPP_14 - #elif (defined(__cplusplus) && __cplusplus > 202002L) || (defined(_MSVC_LANG) && _MSVC_LANG > 202002L) - #define JSON_HAS_CPP_23 - #define JSON_HAS_CPP_20 - #define JSON_HAS_CPP_17 - #define JSON_HAS_CPP_14 - #elif (defined(__cplusplus) && __cplusplus > 201703L) || (defined(_MSVC_LANG) && _MSVC_LANG > 201703L) - #define JSON_HAS_CPP_20 - #define JSON_HAS_CPP_17 - #define JSON_HAS_CPP_14 - #elif (defined(__cplusplus) && __cplusplus > 201402L) || (defined(_HAS_CXX17) && _HAS_CXX17 == 1) // fix for issue #464 - #define JSON_HAS_CPP_17 - #define JSON_HAS_CPP_14 - #elif (defined(__cplusplus) && __cplusplus > 201103L) || (defined(_HAS_CXX14) && _HAS_CXX14 == 1) - #define JSON_HAS_CPP_14 - #endif - // the cpp 11 flag is always specified because it is the minimal required version - #define JSON_HAS_CPP_11 -#endif - -#ifdef __has_include - #if __has_include() - #include - #endif -#endif - -#if !defined(JSON_HAS_FILESYSTEM) && !defined(JSON_HAS_EXPERIMENTAL_FILESYSTEM) - #ifdef JSON_HAS_CPP_17 - #if defined(__cpp_lib_filesystem) - #define JSON_HAS_FILESYSTEM 1 - #elif defined(__cpp_lib_experimental_filesystem) - #define JSON_HAS_EXPERIMENTAL_FILESYSTEM 1 - #elif !defined(__has_include) - #define JSON_HAS_EXPERIMENTAL_FILESYSTEM 1 - #elif __has_include() - #define JSON_HAS_FILESYSTEM 1 - #elif __has_include() - #define JSON_HAS_EXPERIMENTAL_FILESYSTEM 1 - #endif - - // std::filesystem does not work on MinGW GCC 8: https://sourceforge.net/p/mingw-w64/bugs/737/ - #if defined(__MINGW32__) && defined(__GNUC__) && __GNUC__ == 8 - #undef JSON_HAS_FILESYSTEM - #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM - #endif - - // no filesystem support before GCC 8: https://en.cppreference.com/w/cpp/compiler_support - #if defined(__GNUC__) && !defined(__clang__) && __GNUC__ < 8 - #undef JSON_HAS_FILESYSTEM - #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM - #endif - - // no filesystem support before Clang 7: https://en.cppreference.com/w/cpp/compiler_support - #if defined(__clang_major__) && __clang_major__ < 7 - #undef JSON_HAS_FILESYSTEM - #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM - #endif - - // no filesystem support before MSVC 19.14: https://en.cppreference.com/w/cpp/compiler_support - #if defined(_MSC_VER) && _MSC_VER < 1914 - #undef JSON_HAS_FILESYSTEM - #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM - #endif - - // no filesystem support before iOS 13 - #if defined(__IPHONE_OS_VERSION_MIN_REQUIRED) && __IPHONE_OS_VERSION_MIN_REQUIRED < 130000 - #undef JSON_HAS_FILESYSTEM - #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM - #endif - - // no filesystem support before macOS Catalina - #if defined(__MAC_OS_X_VERSION_MIN_REQUIRED) && __MAC_OS_X_VERSION_MIN_REQUIRED < 101500 - #undef JSON_HAS_FILESYSTEM - #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM - #endif - #endif -#endif - -#ifndef JSON_HAS_EXPERIMENTAL_FILESYSTEM - #define JSON_HAS_EXPERIMENTAL_FILESYSTEM 0 -#endif - -#ifndef JSON_HAS_FILESYSTEM - #define JSON_HAS_FILESYSTEM 0 -#endif - -#ifndef JSON_HAS_THREE_WAY_COMPARISON - #if defined(__cpp_impl_three_way_comparison) && __cpp_impl_three_way_comparison >= 201907L \ - && defined(__cpp_lib_three_way_comparison) && __cpp_lib_three_way_comparison >= 201907L - #define JSON_HAS_THREE_WAY_COMPARISON 1 - #else - #define JSON_HAS_THREE_WAY_COMPARISON 0 - #endif -#endif - -#ifndef JSON_HAS_RANGES - // ranges header shipping in GCC 11.1.0 (released 2021-04-27) has a syntax error - #if defined(__GLIBCXX__) && __GLIBCXX__ == 20210427 - #define JSON_HAS_RANGES 0 - #elif defined(__cpp_lib_ranges) - #define JSON_HAS_RANGES 1 - #else - #define JSON_HAS_RANGES 0 - #endif -#endif - -#ifndef JSON_HAS_STATIC_RTTI - #if !defined(_HAS_STATIC_RTTI) || _HAS_STATIC_RTTI != 0 - #define JSON_HAS_STATIC_RTTI 1 - #else - #define JSON_HAS_STATIC_RTTI 0 - #endif -#endif - -#ifdef JSON_HAS_CPP_17 - #define JSON_INLINE_VARIABLE inline -#else - #define JSON_INLINE_VARIABLE -#endif - -#if JSON_HEDLEY_HAS_ATTRIBUTE(no_unique_address) - #define JSON_NO_UNIQUE_ADDRESS [[no_unique_address]] -#else - #define JSON_NO_UNIQUE_ADDRESS -#endif - -// disable documentation warnings on clang -#if defined(__clang__) - #pragma clang diagnostic push - #pragma clang diagnostic ignored "-Wdocumentation" - #pragma clang diagnostic ignored "-Wdocumentation-unknown-command" -#endif - -// allow disabling exceptions -#if (defined(__cpp_exceptions) || defined(__EXCEPTIONS) || defined(_CPPUNWIND)) && !defined(JSON_NOEXCEPTION) - #define JSON_THROW(exception) throw exception - #define JSON_TRY try - #define JSON_CATCH(exception) catch(exception) - #define JSON_INTERNAL_CATCH(exception) catch(exception) -#else - #include - #define JSON_THROW(exception) std::abort() - #define JSON_TRY if(true) - #define JSON_CATCH(exception) if(false) - #define JSON_INTERNAL_CATCH(exception) if(false) -#endif - -// override exception macros -#if defined(JSON_THROW_USER) - #undef JSON_THROW - #define JSON_THROW JSON_THROW_USER -#endif -#if defined(JSON_TRY_USER) - #undef JSON_TRY - #define JSON_TRY JSON_TRY_USER -#endif -#if defined(JSON_CATCH_USER) - #undef JSON_CATCH - #define JSON_CATCH JSON_CATCH_USER - #undef JSON_INTERNAL_CATCH - #define JSON_INTERNAL_CATCH JSON_CATCH_USER -#endif -#if defined(JSON_INTERNAL_CATCH_USER) - #undef JSON_INTERNAL_CATCH - #define JSON_INTERNAL_CATCH JSON_INTERNAL_CATCH_USER -#endif - -// allow overriding assert -#if !defined(JSON_ASSERT) - #include // assert - #define JSON_ASSERT(x) assert(x) -#endif - -// allow accessing some private functions (needed by the test suite) -#if defined(JSON_TESTS_PRIVATE) - #define JSON_PRIVATE_UNLESS_TESTED public -#else - #define JSON_PRIVATE_UNLESS_TESTED private -#endif - -/*! -@brief macro to briefly define a mapping between an enum and JSON -@def NLOHMANN_JSON_SERIALIZE_ENUM -@since version 3.4.0 -*/ -#define NLOHMANN_JSON_SERIALIZE_ENUM(ENUM_TYPE, ...) \ - template \ - inline void to_json(BasicJsonType& j, const ENUM_TYPE& e) \ - { \ - /* NOLINTNEXTLINE(modernize-type-traits) we use C++11 */ \ - static_assert(std::is_enum::value, #ENUM_TYPE " must be an enum!"); \ - /* NOLINTNEXTLINE(modernize-avoid-c-arrays) we don't want to depend on */ \ - static const std::pair m[] = __VA_ARGS__; \ - auto it = std::find_if(std::begin(m), std::end(m), \ - [e](const std::pair& ej_pair) -> bool \ - { \ - return ej_pair.first == e; \ - }); \ - j = ((it != std::end(m)) ? it : std::begin(m))->second; \ - } \ - template \ - inline void from_json(const BasicJsonType& j, ENUM_TYPE& e) \ - { \ - /* NOLINTNEXTLINE(modernize-type-traits) we use C++11 */ \ - static_assert(std::is_enum::value, #ENUM_TYPE " must be an enum!"); \ - /* NOLINTNEXTLINE(modernize-avoid-c-arrays) we don't want to depend on */ \ - static const std::pair m[] = __VA_ARGS__; \ - auto it = std::find_if(std::begin(m), std::end(m), \ - [&j](const std::pair& ej_pair) -> bool \ - { \ - return ej_pair.second == j; \ - }); \ - e = ((it != std::end(m)) ? it : std::begin(m))->first; \ - } - -// Ugly macros to avoid uglier copy-paste when specializing basic_json. They -// may be removed in the future once the class is split. - -#define NLOHMANN_BASIC_JSON_TPL_DECLARATION \ - template class ObjectType, \ - template class ArrayType, \ - class StringType, class BooleanType, class NumberIntegerType, \ - class NumberUnsignedType, class NumberFloatType, \ - template class AllocatorType, \ - template class JSONSerializer, \ - class BinaryType, \ - class CustomBaseClass> - -#define NLOHMANN_BASIC_JSON_TPL \ - basic_json - -// Macros to simplify conversion from/to types - -#define NLOHMANN_JSON_EXPAND( x ) x -#define NLOHMANN_JSON_GET_MACRO(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, _56, _57, _58, _59, _60, _61, _62, _63, _64, NAME,...) NAME -#define NLOHMANN_JSON_PASTE(...) NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_GET_MACRO(__VA_ARGS__, \ - NLOHMANN_JSON_PASTE64, \ - NLOHMANN_JSON_PASTE63, \ - NLOHMANN_JSON_PASTE62, \ - NLOHMANN_JSON_PASTE61, \ - NLOHMANN_JSON_PASTE60, \ - NLOHMANN_JSON_PASTE59, \ - NLOHMANN_JSON_PASTE58, \ - NLOHMANN_JSON_PASTE57, \ - NLOHMANN_JSON_PASTE56, \ - NLOHMANN_JSON_PASTE55, \ - NLOHMANN_JSON_PASTE54, \ - NLOHMANN_JSON_PASTE53, \ - NLOHMANN_JSON_PASTE52, \ - NLOHMANN_JSON_PASTE51, \ - NLOHMANN_JSON_PASTE50, \ - NLOHMANN_JSON_PASTE49, \ - NLOHMANN_JSON_PASTE48, \ - NLOHMANN_JSON_PASTE47, \ - NLOHMANN_JSON_PASTE46, \ - NLOHMANN_JSON_PASTE45, \ - NLOHMANN_JSON_PASTE44, \ - NLOHMANN_JSON_PASTE43, \ - NLOHMANN_JSON_PASTE42, \ - NLOHMANN_JSON_PASTE41, \ - NLOHMANN_JSON_PASTE40, \ - NLOHMANN_JSON_PASTE39, \ - NLOHMANN_JSON_PASTE38, \ - NLOHMANN_JSON_PASTE37, \ - NLOHMANN_JSON_PASTE36, \ - NLOHMANN_JSON_PASTE35, \ - NLOHMANN_JSON_PASTE34, \ - NLOHMANN_JSON_PASTE33, \ - NLOHMANN_JSON_PASTE32, \ - NLOHMANN_JSON_PASTE31, \ - NLOHMANN_JSON_PASTE30, \ - NLOHMANN_JSON_PASTE29, \ - NLOHMANN_JSON_PASTE28, \ - NLOHMANN_JSON_PASTE27, \ - NLOHMANN_JSON_PASTE26, \ - NLOHMANN_JSON_PASTE25, \ - NLOHMANN_JSON_PASTE24, \ - NLOHMANN_JSON_PASTE23, \ - NLOHMANN_JSON_PASTE22, \ - NLOHMANN_JSON_PASTE21, \ - NLOHMANN_JSON_PASTE20, \ - NLOHMANN_JSON_PASTE19, \ - NLOHMANN_JSON_PASTE18, \ - NLOHMANN_JSON_PASTE17, \ - NLOHMANN_JSON_PASTE16, \ - NLOHMANN_JSON_PASTE15, \ - NLOHMANN_JSON_PASTE14, \ - NLOHMANN_JSON_PASTE13, \ - NLOHMANN_JSON_PASTE12, \ - NLOHMANN_JSON_PASTE11, \ - NLOHMANN_JSON_PASTE10, \ - NLOHMANN_JSON_PASTE9, \ - NLOHMANN_JSON_PASTE8, \ - NLOHMANN_JSON_PASTE7, \ - NLOHMANN_JSON_PASTE6, \ - NLOHMANN_JSON_PASTE5, \ - NLOHMANN_JSON_PASTE4, \ - NLOHMANN_JSON_PASTE3, \ - NLOHMANN_JSON_PASTE2, \ - NLOHMANN_JSON_PASTE1)(__VA_ARGS__)) -#define NLOHMANN_JSON_PASTE2(func, v1) func(v1) -#define NLOHMANN_JSON_PASTE3(func, v1, v2) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE2(func, v2) -#define NLOHMANN_JSON_PASTE4(func, v1, v2, v3) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE3(func, v2, v3) -#define NLOHMANN_JSON_PASTE5(func, v1, v2, v3, v4) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE4(func, v2, v3, v4) -#define NLOHMANN_JSON_PASTE6(func, v1, v2, v3, v4, v5) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE5(func, v2, v3, v4, v5) -#define NLOHMANN_JSON_PASTE7(func, v1, v2, v3, v4, v5, v6) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE6(func, v2, v3, v4, v5, v6) -#define NLOHMANN_JSON_PASTE8(func, v1, v2, v3, v4, v5, v6, v7) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE7(func, v2, v3, v4, v5, v6, v7) -#define NLOHMANN_JSON_PASTE9(func, v1, v2, v3, v4, v5, v6, v7, v8) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE8(func, v2, v3, v4, v5, v6, v7, v8) -#define NLOHMANN_JSON_PASTE10(func, v1, v2, v3, v4, v5, v6, v7, v8, v9) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE9(func, v2, v3, v4, v5, v6, v7, v8, v9) -#define NLOHMANN_JSON_PASTE11(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE10(func, v2, v3, v4, v5, v6, v7, v8, v9, v10) -#define NLOHMANN_JSON_PASTE12(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE11(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11) -#define NLOHMANN_JSON_PASTE13(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE12(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12) -#define NLOHMANN_JSON_PASTE14(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE13(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13) -#define NLOHMANN_JSON_PASTE15(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE14(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14) -#define NLOHMANN_JSON_PASTE16(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE15(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15) -#define NLOHMANN_JSON_PASTE17(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE16(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16) -#define NLOHMANN_JSON_PASTE18(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE17(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17) -#define NLOHMANN_JSON_PASTE19(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE18(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18) -#define NLOHMANN_JSON_PASTE20(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE19(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19) -#define NLOHMANN_JSON_PASTE21(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE20(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20) -#define NLOHMANN_JSON_PASTE22(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE21(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21) -#define NLOHMANN_JSON_PASTE23(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE22(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22) -#define NLOHMANN_JSON_PASTE24(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE23(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23) -#define NLOHMANN_JSON_PASTE25(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE24(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24) -#define NLOHMANN_JSON_PASTE26(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE25(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25) -#define NLOHMANN_JSON_PASTE27(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE26(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26) -#define NLOHMANN_JSON_PASTE28(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE27(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27) -#define NLOHMANN_JSON_PASTE29(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE28(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28) -#define NLOHMANN_JSON_PASTE30(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE29(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29) -#define NLOHMANN_JSON_PASTE31(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE30(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30) -#define NLOHMANN_JSON_PASTE32(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE31(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31) -#define NLOHMANN_JSON_PASTE33(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE32(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32) -#define NLOHMANN_JSON_PASTE34(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE33(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33) -#define NLOHMANN_JSON_PASTE35(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE34(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34) -#define NLOHMANN_JSON_PASTE36(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE35(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35) -#define NLOHMANN_JSON_PASTE37(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE36(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36) -#define NLOHMANN_JSON_PASTE38(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE37(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37) -#define NLOHMANN_JSON_PASTE39(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE38(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38) -#define NLOHMANN_JSON_PASTE40(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE39(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39) -#define NLOHMANN_JSON_PASTE41(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE40(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40) -#define NLOHMANN_JSON_PASTE42(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE41(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41) -#define NLOHMANN_JSON_PASTE43(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE42(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42) -#define NLOHMANN_JSON_PASTE44(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE43(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43) -#define NLOHMANN_JSON_PASTE45(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE44(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44) -#define NLOHMANN_JSON_PASTE46(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE45(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45) -#define NLOHMANN_JSON_PASTE47(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE46(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46) -#define NLOHMANN_JSON_PASTE48(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE47(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47) -#define NLOHMANN_JSON_PASTE49(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE48(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48) -#define NLOHMANN_JSON_PASTE50(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE49(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49) -#define NLOHMANN_JSON_PASTE51(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE50(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50) -#define NLOHMANN_JSON_PASTE52(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE51(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51) -#define NLOHMANN_JSON_PASTE53(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE52(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52) -#define NLOHMANN_JSON_PASTE54(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE53(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53) -#define NLOHMANN_JSON_PASTE55(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE54(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54) -#define NLOHMANN_JSON_PASTE56(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE55(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55) -#define NLOHMANN_JSON_PASTE57(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE56(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56) -#define NLOHMANN_JSON_PASTE58(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE57(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57) -#define NLOHMANN_JSON_PASTE59(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE58(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58) -#define NLOHMANN_JSON_PASTE60(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE59(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59) -#define NLOHMANN_JSON_PASTE61(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE60(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60) -#define NLOHMANN_JSON_PASTE62(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE61(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61) -#define NLOHMANN_JSON_PASTE63(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE62(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62) -#define NLOHMANN_JSON_PASTE64(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62, v63) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE63(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62, v63) - -#define NLOHMANN_JSON_TO(v1) nlohmann_json_j[#v1] = nlohmann_json_t.v1; -#define NLOHMANN_JSON_FROM(v1) nlohmann_json_j.at(#v1).get_to(nlohmann_json_t.v1); -#define NLOHMANN_JSON_FROM_WITH_DEFAULT(v1) nlohmann_json_t.v1 = !nlohmann_json_j.is_null() ? nlohmann_json_j.value(#v1, nlohmann_json_default_obj.v1) : nlohmann_json_default_obj.v1; - -/*! -@brief macro -@def NLOHMANN_DEFINE_TYPE_INTRUSIVE -@since version 3.9.0 -@sa https://json.nlohmann.me/api/macros/nlohmann_define_type_intrusive/ -*/ -#define NLOHMANN_DEFINE_TYPE_INTRUSIVE(Type, ...) \ - template::value, int> = 0> \ - friend void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \ - template::value, int> = 0> \ - friend void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM, __VA_ARGS__)) } - -/*! -@brief macro -@def NLOHMANN_DEFINE_TYPE_INTRUSIVE_WITH_DEFAULT -@since version 3.11.0 -@sa https://json.nlohmann.me/api/macros/nlohmann_define_type_intrusive/ -*/ -#define NLOHMANN_DEFINE_TYPE_INTRUSIVE_WITH_DEFAULT(Type, ...) \ - template::value, int> = 0> \ - friend void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \ - template::value, int> = 0> \ - friend void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { const Type nlohmann_json_default_obj{}; NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM_WITH_DEFAULT, __VA_ARGS__)) } - -/*! -@brief macro -@def NLOHMANN_DEFINE_TYPE_INTRUSIVE_ONLY_SERIALIZE -@since version 3.11.3 -@sa https://json.nlohmann.me/api/macros/nlohmann_define_type_intrusive/ -*/ -#define NLOHMANN_DEFINE_TYPE_INTRUSIVE_ONLY_SERIALIZE(Type, ...) \ - template::value, int> = 0> \ - friend void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } - -/*! -@brief macro -@def NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE -@since version 3.9.0 -@sa https://json.nlohmann.me/api/macros/nlohmann_define_type_non_intrusive/ -*/ -#define NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(Type, ...) \ - template::value, int> = 0> \ - void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \ - template::value, int> = 0> \ - void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM, __VA_ARGS__)) } - -/*! -@brief macro -@def NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_WITH_DEFAULT -@since version 3.11.0 -@sa https://json.nlohmann.me/api/macros/nlohmann_define_type_non_intrusive/ -*/ -#define NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_WITH_DEFAULT(Type, ...) \ - template::value, int> = 0> \ - void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \ - template::value, int> = 0> \ - void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { const Type nlohmann_json_default_obj{}; NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM_WITH_DEFAULT, __VA_ARGS__)) } - -/*! -@brief macro -@def NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_ONLY_SERIALIZE -@since version 3.11.3 -@sa https://json.nlohmann.me/api/macros/nlohmann_define_type_non_intrusive/ -*/ -#define NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_ONLY_SERIALIZE(Type, ...) \ - template::value, int> = 0> \ - void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } - -/*! -@brief macro -@def NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE -@since version 3.12.0 -@sa https://json.nlohmann.me/api/macros/nlohmann_define_derived_type/ -*/ -#define NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE(Type, BaseType, ...) \ - template::value, int> = 0> \ - friend void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \ - template::value, int> = 0> \ - friend void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { nlohmann::from_json(nlohmann_json_j, static_cast(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM, __VA_ARGS__)) } - -/*! -@brief macro -@def NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE_WITH_DEFAULT -@since version 3.12.0 -@sa https://json.nlohmann.me/api/macros/nlohmann_define_derived_type/ -*/ -#define NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE_WITH_DEFAULT(Type, BaseType, ...) \ - template::value, int> = 0> \ - friend void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \ - template::value, int> = 0> \ - friend void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { nlohmann::from_json(nlohmann_json_j, static_cast(nlohmann_json_t)); const Type nlohmann_json_default_obj{}; NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM_WITH_DEFAULT, __VA_ARGS__)) } - -/*! -@brief macro -@def NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE_ONLY_SERIALIZE -@since version 3.12.0 -@sa https://json.nlohmann.me/api/macros/nlohmann_define_derived_type/ -*/ -#define NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE_ONLY_SERIALIZE(Type, BaseType, ...) \ - template::value, int> = 0> \ - friend void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } - -/*! -@brief macro -@def NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE -@since version 3.12.0 -@sa https://json.nlohmann.me/api/macros/nlohmann_define_derived_type/ -*/ -#define NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE(Type, BaseType, ...) \ - template::value, int> = 0> \ - void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \ - template::value, int> = 0> \ - void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { nlohmann::from_json(nlohmann_json_j, static_cast(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM, __VA_ARGS__)) } - -/*! -@brief macro -@def NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_WITH_DEFAULT -@since version 3.12.0 -@sa https://json.nlohmann.me/api/macros/nlohmann_define_derived_type/ -*/ -#define NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_WITH_DEFAULT(Type, BaseType, ...) \ - template::value, int> = 0> \ - void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \ - template::value, int> = 0> \ - void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { nlohmann::from_json(nlohmann_json_j, static_cast(nlohmann_json_t)); const Type nlohmann_json_default_obj{}; NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM_WITH_DEFAULT, __VA_ARGS__)) } - -/*! -@brief macro -@def NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_ONLY_SERIALIZE -@since version 3.12.0 -@sa https://json.nlohmann.me/api/macros/nlohmann_define_derived_type/ -*/ -#define NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_ONLY_SERIALIZE(Type, BaseType, ...) \ - template::value, int> = 0> \ - void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } - -// inspired from https://stackoverflow.com/a/26745591 -// allows calling any std function as if (e.g., with begin): -// using std::begin; begin(x); -// -// it allows using the detected idiom to retrieve the return type -// of such an expression -#define NLOHMANN_CAN_CALL_STD_FUNC_IMPL(std_name) \ - namespace detail { \ - using std::std_name; \ - \ - template \ - using result_of_##std_name = decltype(std_name(std::declval()...)); \ - } \ - \ - namespace detail2 { \ - struct std_name##_tag \ - { \ - }; \ - \ - template \ - std_name##_tag std_name(T&&...); \ - \ - template \ - using result_of_##std_name = decltype(std_name(std::declval()...)); \ - \ - template \ - struct would_call_std_##std_name \ - { \ - static constexpr auto const value = ::nlohmann::detail:: \ - is_detected_exact::value; \ - }; \ - } /* namespace detail2 */ \ - \ - template \ - struct would_call_std_##std_name : detail2::would_call_std_##std_name \ - { \ - } - -#ifndef JSON_USE_IMPLICIT_CONVERSIONS - #define JSON_USE_IMPLICIT_CONVERSIONS 1 -#endif - -#if JSON_USE_IMPLICIT_CONVERSIONS - #define JSON_EXPLICIT -#else - #define JSON_EXPLICIT explicit -#endif - -#ifndef JSON_DISABLE_ENUM_SERIALIZATION - #define JSON_DISABLE_ENUM_SERIALIZATION 0 -#endif - -#ifndef JSON_USE_GLOBAL_UDLS - #define JSON_USE_GLOBAL_UDLS 1 -#endif - -#if JSON_HAS_THREE_WAY_COMPARISON - #include // partial_ordering -#endif - -NLOHMANN_JSON_NAMESPACE_BEGIN -namespace detail -{ - -/////////////////////////// -// JSON type enumeration // -/////////////////////////// - -/*! -@brief the JSON type enumeration - -This enumeration collects the different JSON types. It is internally used to -distinguish the stored values, and the functions @ref basic_json::is_null(), -@ref basic_json::is_object(), @ref basic_json::is_array(), -@ref basic_json::is_string(), @ref basic_json::is_boolean(), -@ref basic_json::is_number() (with @ref basic_json::is_number_integer(), -@ref basic_json::is_number_unsigned(), and @ref basic_json::is_number_float()), -@ref basic_json::is_discarded(), @ref basic_json::is_primitive(), and -@ref basic_json::is_structured() rely on it. - -@note There are three enumeration entries (number_integer, number_unsigned, and -number_float), because the library distinguishes these three types for numbers: -@ref basic_json::number_unsigned_t is used for unsigned integers, -@ref basic_json::number_integer_t is used for signed integers, and -@ref basic_json::number_float_t is used for floating-point numbers or to -approximate integers which do not fit in the limits of their respective type. - -@sa see @ref basic_json::basic_json(const value_t value_type) -- create a JSON -value with the default value for a given type - -@since version 1.0.0 -*/ -enum class value_t : std::uint8_t -{ - null, ///< null value - object, ///< object (unordered set of name/value pairs) - array, ///< array (ordered collection of values) - string, ///< string value - boolean, ///< boolean value - number_integer, ///< number value (signed integer) - number_unsigned, ///< number value (unsigned integer) - number_float, ///< number value (floating-point) - binary, ///< binary array (ordered collection of bytes) - discarded ///< discarded by the parser callback function -}; - -/*! -@brief comparison operator for JSON types - -Returns an ordering that is similar to Python: -- order: null < boolean < number < object < array < string < binary -- furthermore, each type is not smaller than itself -- discarded values are not comparable -- binary is represented as a b"" string in python and directly comparable to a - string; however, making a binary array directly comparable with a string would - be surprising behavior in a JSON file. - -@since version 1.0.0 -*/ -#if JSON_HAS_THREE_WAY_COMPARISON - inline std::partial_ordering operator<=>(const value_t lhs, const value_t rhs) noexcept // *NOPAD* -#else - inline bool operator<(const value_t lhs, const value_t rhs) noexcept -#endif -{ - static constexpr std::array order = {{ - 0 /* null */, 3 /* object */, 4 /* array */, 5 /* string */, - 1 /* boolean */, 2 /* integer */, 2 /* unsigned */, 2 /* float */, - 6 /* binary */ - } - }; - - const auto l_index = static_cast(lhs); - const auto r_index = static_cast(rhs); -#if JSON_HAS_THREE_WAY_COMPARISON - if (l_index < order.size() && r_index < order.size()) - { - return order[l_index] <=> order[r_index]; // *NOPAD* - } - return std::partial_ordering::unordered; -#else - return l_index < order.size() && r_index < order.size() && order[l_index] < order[r_index]; -#endif -} - -// GCC selects the built-in operator< over an operator rewritten from -// a user-defined spaceship operator -// Clang, MSVC, and ICC select the rewritten candidate -// (see GCC bug https://gcc.gnu.org/bugzilla/show_bug.cgi?id=105200) -#if JSON_HAS_THREE_WAY_COMPARISON && defined(__GNUC__) -inline bool operator<(const value_t lhs, const value_t rhs) noexcept -{ - return std::is_lt(lhs <=> rhs); // *NOPAD* -} -#endif - -} // namespace detail -NLOHMANN_JSON_NAMESPACE_END - -// #include -// __ _____ _____ _____ -// __| | __| | | | JSON for Modern C++ -// | | |__ | | | | | | version 3.12.0 -// |_____|_____|_____|_|___| https://github.com/nlohmann/json -// -// SPDX-FileCopyrightText: 2013-2025 Niels Lohmann -// SPDX-License-Identifier: MIT - - - -// #include - - -NLOHMANN_JSON_NAMESPACE_BEGIN -namespace detail -{ - -/*! -@brief replace all occurrences of a substring by another string - -@param[in,out] s the string to manipulate; changed so that all - occurrences of @a f are replaced with @a t -@param[in] f the substring to replace with @a t -@param[in] t the string to replace @a f - -@pre The search string @a f must not be empty. **This precondition is -enforced with an assertion.** - -@since version 2.0.0 -*/ -template -inline void replace_substring(StringType& s, const StringType& f, - const StringType& t) -{ - JSON_ASSERT(!f.empty()); - for (auto pos = s.find(f); // find the first occurrence of f - pos != StringType::npos; // make sure f was found - s.replace(pos, f.size(), t), // replace with t, and - pos = s.find(f, pos + t.size())) // find the next occurrence of f - {} -} - -/*! - * @brief string escaping as described in RFC 6901 (Sect. 4) - * @param[in] s string to escape - * @return escaped string - * - * Note the order of escaping "~" to "~0" and "/" to "~1" is important. - */ -template -inline StringType escape(StringType s) -{ - replace_substring(s, StringType{"~"}, StringType{"~0"}); - replace_substring(s, StringType{"/"}, StringType{"~1"}); - return s; -} - -/*! - * @brief string unescaping as described in RFC 6901 (Sect. 4) - * @param[in] s string to unescape - * @return unescaped string - * - * Note the order of escaping "~1" to "/" and "~0" to "~" is important. - */ -template -inline void unescape(StringType& s) -{ - replace_substring(s, StringType{"~1"}, StringType{"/"}); - replace_substring(s, StringType{"~0"}, StringType{"~"}); -} - -} // namespace detail -NLOHMANN_JSON_NAMESPACE_END - -// #include -// __ _____ _____ _____ -// __| | __| | | | JSON for Modern C++ -// | | |__ | | | | | | version 3.12.0 -// |_____|_____|_____|_|___| https://github.com/nlohmann/json -// -// SPDX-FileCopyrightText: 2013-2025 Niels Lohmann -// SPDX-License-Identifier: MIT - - - -#include // size_t - -// #include - - -NLOHMANN_JSON_NAMESPACE_BEGIN -namespace detail -{ - -/// struct to capture the start position of the current token -struct position_t -{ - /// the total number of characters read - std::size_t chars_read_total = 0; - /// the number of characters read in the current line - std::size_t chars_read_current_line = 0; - /// the number of lines read - std::size_t lines_read = 0; - - /// conversion to size_t to preserve SAX interface - constexpr operator size_t() const - { - return chars_read_total; - } -}; - -} // namespace detail -NLOHMANN_JSON_NAMESPACE_END - -// #include - -// #include -// __ _____ _____ _____ -// __| | __| | | | JSON for Modern C++ -// | | |__ | | | | | | version 3.12.0 -// |_____|_____|_____|_|___| https://github.com/nlohmann/json -// -// SPDX-FileCopyrightText: 2013-2025 Niels Lohmann -// SPDX-FileCopyrightText: 2018 The Abseil Authors -// SPDX-License-Identifier: MIT - - - -#include // array -#include // size_t -#include // conditional, enable_if, false_type, integral_constant, is_constructible, is_integral, is_same, remove_cv, remove_reference, true_type -#include // index_sequence, make_index_sequence, index_sequence_for - -// #include - - -NLOHMANN_JSON_NAMESPACE_BEGIN -namespace detail -{ - -template -using uncvref_t = typename std::remove_cv::type>::type; - -#ifdef JSON_HAS_CPP_14 - -// the following utilities are natively available in C++14 -using std::enable_if_t; -using std::index_sequence; -using std::make_index_sequence; -using std::index_sequence_for; - -#else - -// alias templates to reduce boilerplate -template -using enable_if_t = typename std::enable_if::type; - -// The following code is taken from https://github.com/abseil/abseil-cpp/blob/10cb35e459f5ecca5b2ff107635da0bfa41011b4/absl/utility/utility.h -// which is part of Google Abseil (https://github.com/abseil/abseil-cpp), licensed under the Apache License 2.0. - -//// START OF CODE FROM GOOGLE ABSEIL - -// integer_sequence -// -// Class template representing a compile-time integer sequence. An instantiation -// of `integer_sequence` has a sequence of integers encoded in its -// type through its template arguments (which is a common need when -// working with C++11 variadic templates). `absl::integer_sequence` is designed -// to be a drop-in replacement for C++14's `std::integer_sequence`. -// -// Example: -// -// template< class T, T... Ints > -// void user_function(integer_sequence); -// -// int main() -// { -// // user_function's `T` will be deduced to `int` and `Ints...` -// // will be deduced to `0, 1, 2, 3, 4`. -// user_function(make_integer_sequence()); -// } -template -struct integer_sequence -{ - using value_type = T; - static constexpr std::size_t size() noexcept - { - return sizeof...(Ints); - } -}; - -// index_sequence -// -// A helper template for an `integer_sequence` of `size_t`, -// `absl::index_sequence` is designed to be a drop-in replacement for C++14's -// `std::index_sequence`. -template -using index_sequence = integer_sequence; - -namespace utility_internal -{ - -template -struct Extend; - -// Note that SeqSize == sizeof...(Ints). It's passed explicitly for efficiency. -template -struct Extend, SeqSize, 0> -{ - using type = integer_sequence < T, Ints..., (Ints + SeqSize)... >; -}; - -template -struct Extend, SeqSize, 1> -{ - using type = integer_sequence < T, Ints..., (Ints + SeqSize)..., 2 * SeqSize >; -}; - -// Recursion helper for 'make_integer_sequence'. -// 'Gen::type' is an alias for 'integer_sequence'. -template -struct Gen -{ - using type = - typename Extend < typename Gen < T, N / 2 >::type, N / 2, N % 2 >::type; -}; - -template -struct Gen -{ - using type = integer_sequence; -}; - -} // namespace utility_internal - -// Compile-time sequences of integers - -// make_integer_sequence -// -// This template alias is equivalent to -// `integer_sequence`, and is designed to be a drop-in -// replacement for C++14's `std::make_integer_sequence`. -template -using make_integer_sequence = typename utility_internal::Gen::type; - -// make_index_sequence -// -// This template alias is equivalent to `index_sequence<0, 1, ..., N-1>`, -// and is designed to be a drop-in replacement for C++14's -// `std::make_index_sequence`. -template -using make_index_sequence = make_integer_sequence; - -// index_sequence_for -// -// Converts a typename pack into an index sequence of the same length, and -// is designed to be a drop-in replacement for C++14's -// `std::index_sequence_for()` -template -using index_sequence_for = make_index_sequence; - -//// END OF CODE FROM GOOGLE ABSEIL - -#endif - -// dispatch utility (taken from ranges-v3) -template struct priority_tag : priority_tag < N - 1 > {}; -template<> struct priority_tag<0> {}; - -// taken from ranges-v3 -template -struct static_const -{ - static JSON_INLINE_VARIABLE constexpr T value{}; -}; - -#ifndef JSON_HAS_CPP_17 - template - constexpr T static_const::value; -#endif - -template -constexpr std::array make_array(Args&& ... args) -{ - return std::array {{static_cast(std::forward(args))...}}; -} - -} // namespace detail -NLOHMANN_JSON_NAMESPACE_END - -// #include -// __ _____ _____ _____ -// __| | __| | | | JSON for Modern C++ -// | | |__ | | | | | | version 3.12.0 -// |_____|_____|_____|_|___| https://github.com/nlohmann/json -// -// SPDX-FileCopyrightText: 2013-2025 Niels Lohmann -// SPDX-License-Identifier: MIT - - - -#include // numeric_limits -#include // char_traits -#include // tuple -#include // false_type, is_constructible, is_integral, is_same, true_type -#include // declval -#if defined(__cpp_lib_byte) && __cpp_lib_byte >= 201603L - #include // byte -#endif -// #include -// __ _____ _____ _____ -// __| | __| | | | JSON for Modern C++ -// | | |__ | | | | | | version 3.12.0 -// |_____|_____|_____|_|___| https://github.com/nlohmann/json -// -// SPDX-FileCopyrightText: 2013-2025 Niels Lohmann -// SPDX-License-Identifier: MIT - - - -#include // random_access_iterator_tag - -// #include - -// #include - -// #include - - -NLOHMANN_JSON_NAMESPACE_BEGIN -namespace detail -{ - -template -struct iterator_types {}; - -template -struct iterator_types < - It, - void_t> -{ - using difference_type = typename It::difference_type; - using value_type = typename It::value_type; - using pointer = typename It::pointer; - using reference = typename It::reference; - using iterator_category = typename It::iterator_category; -}; - -// This is required as some compilers implement std::iterator_traits in a way that -// doesn't work with SFINAE. See https://github.com/nlohmann/json/issues/1341. -template -struct iterator_traits -{ -}; - -template -struct iterator_traits < T, enable_if_t < !std::is_pointer::value >> - : iterator_types -{ -}; - -template -struct iterator_traits::value>> -{ - using iterator_category = std::random_access_iterator_tag; - using value_type = T; - using difference_type = ptrdiff_t; - using pointer = T*; - using reference = T&; -}; - -} // namespace detail -NLOHMANN_JSON_NAMESPACE_END - -// #include - -// #include -// __ _____ _____ _____ -// __| | __| | | | JSON for Modern C++ -// | | |__ | | | | | | version 3.12.0 -// |_____|_____|_____|_|___| https://github.com/nlohmann/json -// -// SPDX-FileCopyrightText: 2013-2025 Niels Lohmann -// SPDX-License-Identifier: MIT - - - -// #include - - -NLOHMANN_JSON_NAMESPACE_BEGIN - -NLOHMANN_CAN_CALL_STD_FUNC_IMPL(begin); - -NLOHMANN_JSON_NAMESPACE_END - -// #include -// __ _____ _____ _____ -// __| | __| | | | JSON for Modern C++ -// | | |__ | | | | | | version 3.12.0 -// |_____|_____|_____|_|___| https://github.com/nlohmann/json -// -// SPDX-FileCopyrightText: 2013-2025 Niels Lohmann -// SPDX-License-Identifier: MIT - - - -// #include - - -NLOHMANN_JSON_NAMESPACE_BEGIN - -NLOHMANN_CAN_CALL_STD_FUNC_IMPL(end); - -NLOHMANN_JSON_NAMESPACE_END - -// #include - -// #include - -// #include -// __ _____ _____ _____ -// __| | __| | | | JSON for Modern C++ -// | | |__ | | | | | | version 3.12.0 -// |_____|_____|_____|_|___| https://github.com/nlohmann/json -// -// SPDX-FileCopyrightText: 2013-2025 Niels Lohmann -// SPDX-License-Identifier: MIT - -#ifndef INCLUDE_NLOHMANN_JSON_FWD_HPP_ - #define INCLUDE_NLOHMANN_JSON_FWD_HPP_ - - #include // int64_t, uint64_t - #include // map - #include // allocator - #include // string - #include // vector - - // #include - - - /*! - @brief namespace for Niels Lohmann - @see https://github.com/nlohmann - @since version 1.0.0 - */ - NLOHMANN_JSON_NAMESPACE_BEGIN - - /*! - @brief default JSONSerializer template argument - - This serializer ignores the template arguments and uses ADL - ([argument-dependent lookup](https://en.cppreference.com/w/cpp/language/adl)) - for serialization. - */ - template - struct adl_serializer; - - /// a class to store JSON values - /// @sa https://json.nlohmann.me/api/basic_json/ - template class ObjectType = - std::map, - template class ArrayType = std::vector, - class StringType = std::string, class BooleanType = bool, - class NumberIntegerType = std::int64_t, - class NumberUnsignedType = std::uint64_t, - class NumberFloatType = double, - template class AllocatorType = std::allocator, - template class JSONSerializer = - adl_serializer, - class BinaryType = std::vector, // cppcheck-suppress syntaxError - class CustomBaseClass = void> - class basic_json; - - /// @brief JSON Pointer defines a string syntax for identifying a specific value within a JSON document - /// @sa https://json.nlohmann.me/api/json_pointer/ - template - class json_pointer; - - /*! - @brief default specialization - @sa https://json.nlohmann.me/api/json/ - */ - using json = basic_json<>; - - /// @brief a minimal map-like container that preserves insertion order - /// @sa https://json.nlohmann.me/api/ordered_map/ - template - struct ordered_map; - - /// @brief specialization that maintains the insertion order of object keys - /// @sa https://json.nlohmann.me/api/ordered_json/ - using ordered_json = basic_json; - - NLOHMANN_JSON_NAMESPACE_END - -#endif // INCLUDE_NLOHMANN_JSON_FWD_HPP_ - - -NLOHMANN_JSON_NAMESPACE_BEGIN -/*! -@brief detail namespace with internal helper functions - -This namespace collects functions that should not be exposed, -implementations of some @ref basic_json methods, and meta-programming helpers. - -@since version 2.1.0 -*/ -namespace detail -{ - -///////////// -// helpers // -///////////// - -// Note to maintainers: -// -// Every trait in this file expects a non-CV-qualified type. -// The only exceptions are in the 'aliases for detected' section -// (i.e., those of the form: decltype(T::member_function(std::declval()))) -// -// In this case, T has to be properly CV-qualified to constraint the function arguments -// (e.g., to_json(BasicJsonType&, const T&)) - -template struct is_basic_json : std::false_type {}; - -NLOHMANN_BASIC_JSON_TPL_DECLARATION -struct is_basic_json : std::true_type {}; - -// used by exceptions create() member functions -// true_type for the pointer to possibly cv-qualified basic_json or std::nullptr_t -// false_type otherwise -template -struct is_basic_json_context : - std::integral_constant < bool, - is_basic_json::type>::type>::value - || std::is_same::value > -{}; - -////////////////////// -// json_ref helpers // -////////////////////// - -template -class json_ref; - -template -struct is_json_ref : std::false_type {}; - -template -struct is_json_ref> : std::true_type {}; - -////////////////////////// -// aliases for detected // -////////////////////////// - -template -using mapped_type_t = typename T::mapped_type; - -template -using key_type_t = typename T::key_type; - -template -using value_type_t = typename T::value_type; - -template -using difference_type_t = typename T::difference_type; - -template -using pointer_t = typename T::pointer; - -template -using reference_t = typename T::reference; - -template -using iterator_category_t = typename T::iterator_category; - -template -using to_json_function = decltype(T::to_json(std::declval()...)); - -template -using from_json_function = decltype(T::from_json(std::declval()...)); - -template -using get_template_function = decltype(std::declval().template get()); - -// trait checking if JSONSerializer::from_json(json const&, udt&) exists -template -struct has_from_json : std::false_type {}; - -// trait checking if j.get is valid -// use this trait instead of std::is_constructible or std::is_convertible, -// both rely on, or make use of implicit conversions, and thus fail when T -// has several constructors/operator= (see https://github.com/nlohmann/json/issues/958) -template -struct is_getable -{ - static constexpr bool value = is_detected::value; -}; - -template -struct has_from_json < BasicJsonType, T, enable_if_t < !is_basic_json::value >> -{ - using serializer = typename BasicJsonType::template json_serializer; - - static constexpr bool value = - is_detected_exact::value; -}; - -// This trait checks if JSONSerializer::from_json(json const&) exists -// this overload is used for non-default-constructible user-defined-types -template -struct has_non_default_from_json : std::false_type {}; - -template -struct has_non_default_from_json < BasicJsonType, T, enable_if_t < !is_basic_json::value >> -{ - using serializer = typename BasicJsonType::template json_serializer; - - static constexpr bool value = - is_detected_exact::value; -}; - -// This trait checks if BasicJsonType::json_serializer::to_json exists -// Do not evaluate the trait when T is a basic_json type, to avoid template instantiation infinite recursion. -template -struct has_to_json : std::false_type {}; - -template -struct has_to_json < BasicJsonType, T, enable_if_t < !is_basic_json::value >> -{ - using serializer = typename BasicJsonType::template json_serializer; - - static constexpr bool value = - is_detected_exact::value; -}; - -template -using detect_key_compare = typename T::key_compare; - -template -struct has_key_compare : std::integral_constant::value> {}; - -// obtains the actual object key comparator -template -struct actual_object_comparator -{ - using object_t = typename BasicJsonType::object_t; - using object_comparator_t = typename BasicJsonType::default_object_comparator_t; - using type = typename std::conditional < has_key_compare::value, - typename object_t::key_compare, object_comparator_t>::type; -}; - -template -using actual_object_comparator_t = typename actual_object_comparator::type; - -///////////////// -// char_traits // -///////////////// - -// Primary template of char_traits calls std char_traits -template -struct char_traits : std::char_traits -{}; - -// Explicitly define char traits for unsigned char since it is not standard -template<> -struct char_traits : std::char_traits -{ - using char_type = unsigned char; - using int_type = uint64_t; - - // Redefine to_int_type function - static int_type to_int_type(char_type c) noexcept - { - return static_cast(c); - } - - static char_type to_char_type(int_type i) noexcept - { - return static_cast(i); - } - - static constexpr int_type eof() noexcept - { - return static_cast(std::char_traits::eof()); - } -}; - -// Explicitly define char traits for signed char since it is not standard -template<> -struct char_traits : std::char_traits -{ - using char_type = signed char; - using int_type = uint64_t; - - // Redefine to_int_type function - static int_type to_int_type(char_type c) noexcept - { - return static_cast(c); - } - - static char_type to_char_type(int_type i) noexcept - { - return static_cast(i); - } - - static constexpr int_type eof() noexcept - { - return static_cast(std::char_traits::eof()); - } -}; - -#if defined(__cpp_lib_byte) && __cpp_lib_byte >= 201603L -template<> -struct char_traits : std::char_traits -{ - using char_type = std::byte; - using int_type = uint64_t; - - static int_type to_int_type(char_type c) noexcept - { - return static_cast(std::to_integer(c)); - } - - static char_type to_char_type(int_type i) noexcept - { - return std::byte(static_cast(i)); - } - - static constexpr int_type eof() noexcept - { - return static_cast(std::char_traits::eof()); - } -}; -#endif - -/////////////////// -// is_ functions // -/////////////////// - -// https://en.cppreference.com/w/cpp/types/conjunction -template struct conjunction : std::true_type { }; -template struct conjunction : B { }; -template -struct conjunction -: std::conditional(B::value), conjunction, B>::type {}; - -// https://en.cppreference.com/w/cpp/types/negation -template struct negation : std::integral_constant < bool, !B::value > { }; - -// Reimplementation of is_constructible and is_default_constructible, due to them being broken for -// std::pair and std::tuple until LWG 2367 fix (see https://cplusplus.github.io/LWG/lwg-defects.html#2367). -// This causes compile errors in e.g., Clang 3.5 or GCC 4.9. -template -struct is_default_constructible : std::is_default_constructible {}; - -template -struct is_default_constructible> - : conjunction, is_default_constructible> {}; - -template -struct is_default_constructible> - : conjunction, is_default_constructible> {}; - -template -struct is_default_constructible> - : conjunction...> {}; - -template -struct is_default_constructible> - : conjunction...> {}; - -template -struct is_constructible : std::is_constructible {}; - -template -struct is_constructible> : is_default_constructible> {}; - -template -struct is_constructible> : is_default_constructible> {}; - -template -struct is_constructible> : is_default_constructible> {}; - -template -struct is_constructible> : is_default_constructible> {}; - -template -struct is_iterator_traits : std::false_type {}; - -template -struct is_iterator_traits> -{ - private: - using traits = iterator_traits; - - public: - static constexpr auto value = - is_detected::value && - is_detected::value && - is_detected::value && - is_detected::value && - is_detected::value; -}; - -template -struct is_range -{ - private: - using t_ref = typename std::add_lvalue_reference::type; - - using iterator = detected_t; - using sentinel = detected_t; - - // to be 100% correct, it should use https://en.cppreference.com/w/cpp/iterator/input_or_output_iterator - // and https://en.cppreference.com/w/cpp/iterator/sentinel_for - // but reimplementing these would be too much work, as a lot of other concepts are used underneath - static constexpr auto is_iterator_begin = - is_iterator_traits>::value; - - public: - static constexpr bool value = !std::is_same::value && !std::is_same::value && is_iterator_begin; -}; - -template -using iterator_t = enable_if_t::value, result_of_begin())>>; - -template -using range_value_t = value_type_t>>; - -// The following implementation of is_complete_type is taken from -// https://blogs.msdn.microsoft.com/vcblog/2015/12/02/partial-support-for-expression-sfinae-in-vs-2015-update-1/ -// and is written by Xiang Fan who agreed to use it in this library. - -template -struct is_complete_type : std::false_type {}; - -template -struct is_complete_type : std::true_type {}; - -template -struct is_compatible_object_type_impl : std::false_type {}; - -template -struct is_compatible_object_type_impl < - BasicJsonType, CompatibleObjectType, - enable_if_t < is_detected::value&& - is_detected::value >> -{ - using object_t = typename BasicJsonType::object_t; - - // macOS's is_constructible does not play well with nonesuch... - static constexpr bool value = - is_constructible::value && - is_constructible::value; -}; - -template -struct is_compatible_object_type - : is_compatible_object_type_impl {}; - -template -struct is_constructible_object_type_impl : std::false_type {}; - -template -struct is_constructible_object_type_impl < - BasicJsonType, ConstructibleObjectType, - enable_if_t < is_detected::value&& - is_detected::value >> -{ - using object_t = typename BasicJsonType::object_t; - - static constexpr bool value = - (is_default_constructible::value && - (std::is_move_assignable::value || - std::is_copy_assignable::value) && - (is_constructible::value && - std::is_same < - typename object_t::mapped_type, - typename ConstructibleObjectType::mapped_type >::value)) || - (has_from_json::value || - has_non_default_from_json < - BasicJsonType, - typename ConstructibleObjectType::mapped_type >::value); -}; - -template -struct is_constructible_object_type - : is_constructible_object_type_impl {}; - -template -struct is_compatible_string_type -{ - static constexpr auto value = - is_constructible::value; -}; - -template -struct is_constructible_string_type -{ - // launder type through decltype() to fix compilation failure on ICPC -#ifdef __INTEL_COMPILER - using laundered_type = decltype(std::declval()); -#else - using laundered_type = ConstructibleStringType; -#endif - - static constexpr auto value = - conjunction < - is_constructible, - is_detected_exact>::value; -}; - -template -struct is_compatible_array_type_impl : std::false_type {}; - -template -struct is_compatible_array_type_impl < - BasicJsonType, CompatibleArrayType, - enable_if_t < - is_detected::value&& - is_iterator_traits>>::value&& -// special case for types like std::filesystem::path whose iterator's value_type are themselves -// c.f. https://github.com/nlohmann/json/pull/3073 - !std::is_same>::value >> -{ - static constexpr bool value = - is_constructible>::value; -}; - -template -struct is_compatible_array_type - : is_compatible_array_type_impl {}; - -template -struct is_constructible_array_type_impl : std::false_type {}; - -template -struct is_constructible_array_type_impl < - BasicJsonType, ConstructibleArrayType, - enable_if_t::value >> - : std::true_type {}; - -template -struct is_constructible_array_type_impl < - BasicJsonType, ConstructibleArrayType, - enable_if_t < !std::is_same::value&& - !is_compatible_string_type::value&& - is_default_constructible::value&& -(std::is_move_assignable::value || - std::is_copy_assignable::value)&& -is_detected::value&& -is_iterator_traits>>::value&& -is_detected::value&& -// special case for types like std::filesystem::path whose iterator's value_type are themselves -// c.f. https://github.com/nlohmann/json/pull/3073 -!std::is_same>::value&& -is_complete_type < -detected_t>::value >> -{ - using value_type = range_value_t; - - static constexpr bool value = - std::is_same::value || - has_from_json::value || - has_non_default_from_json < - BasicJsonType, - value_type >::value; -}; - -template -struct is_constructible_array_type - : is_constructible_array_type_impl {}; - -template -struct is_compatible_integer_type_impl : std::false_type {}; - -template -struct is_compatible_integer_type_impl < - RealIntegerType, CompatibleNumberIntegerType, - enable_if_t < std::is_integral::value&& - std::is_integral::value&& - !std::is_same::value >> -{ - // is there an assert somewhere on overflows? - using RealLimits = std::numeric_limits; - using CompatibleLimits = std::numeric_limits; - - static constexpr auto value = - is_constructible::value && - CompatibleLimits::is_integer && - RealLimits::is_signed == CompatibleLimits::is_signed; -}; - -template -struct is_compatible_integer_type - : is_compatible_integer_type_impl {}; - -template -struct is_compatible_type_impl: std::false_type {}; - -template -struct is_compatible_type_impl < - BasicJsonType, CompatibleType, - enable_if_t::value >> -{ - static constexpr bool value = - has_to_json::value; -}; - -template -struct is_compatible_type - : is_compatible_type_impl {}; - -template -struct is_constructible_tuple : std::false_type {}; - -template -struct is_constructible_tuple> : conjunction...> {}; - -template -struct is_json_iterator_of : std::false_type {}; - -template -struct is_json_iterator_of : std::true_type {}; - -template -struct is_json_iterator_of : std::true_type -{}; - -// checks if a given type T is a template specialization of Primary -template