diff --git a/sfwl/sfwl.cpp b/sfwl/sfwl.cpp new file mode 100644 index 0000000..d2af85e --- /dev/null +++ b/sfwl/sfwl.cpp @@ -0,0 +1,19943 @@ + + +// SFW - Simple Framework - https://github.com/Relintai/sfw + +// Simple c++ app / game framework inspired by the single file c game engines +// and libraries, especially [FWK](https://github.com/r-lyeh/FWK). + +// MODULES: +// CORE + OBJECT + +// LICENSES: + +/* +SFW - (MIT) + +Copyright (c) 2023-present Péter Magyar. + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +*/ + +// This Library uses code from the following projects: + +// Pandemonium Engine (MIT) + +/*************************************************************************/ +/* PANDEMONIUM ENGINE LICENSE */ +/* https://github.com/Relintai/pandemonium_engine */ +/*************************************************************************/ +/* Copyright (c) 2022-present Péter Magyar. */ +/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md). */ +/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur. */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ + +// FWK + +//https://github.com/r-lyeh/FWK + +/* + +Unlicense + +This software is released into the [public domain](https://unlicense.org/). +Also dual-licensed as [0-BSD](https://opensource.org/licenses/0BSD) or [MIT (No Attribution)](https://github.com/aws/mit-0) +for those countries where public domain is a concern (sigh). +Any contribution to this repository is implicitly subjected to the same release conditions aforementioned. + +*/ + +// Trantor + +//inet_address.h, .cpp, socket.h and .cpp originates from trantor (they were heavily modified): + +// Trantor - A non-blocking I/O based TCP network library, using C++14/17, +// Copyright (c) 2016-2021, Tao An. All rights reserved. +// https://github.com/an-tao/trantor +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions +// are met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above copyright +// notice, this list of conditions and the following disclaimer in the +// documentation and/or other materials provided with the distribution. +// * Neither the name of Tao An nor the names of other contributors +// may be used to endorse or promote products derived from this software +// without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// Muduo - A reactor-based C++ network library for Linux +// Copyright (c) 2010, Shuo Chen. All rights reserved. +// http://code.google.com/p/muduo/ +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions +// are met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above copyright +// notice, this list of conditions and the following disclaimer in the +// documentation and/or other materials provided with the distribution. +// * Neither the name of Shuo Chen nor the names of other contributors +// may be used to endorse or promote products derived from this software +// without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// PCG + +// pcg.h's License: + +// *Really* minimal PCG32 code / (c) 2014 M.E. O'Neill / pcg-random.org +// Licensed under Apache License 2.0 (NO WARRANTY, etc. see website) + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#if !defined(_WIN64) && !defined(_WIN32) +#include +#include +#endif + +#ifndef SFWL_H +#include "sfwl.h" +#endif + +//=================== CORE SECTION =================== + +#line 1 "sfwl/core/ucaps.h" + +/*************************************************************************/ +/* ucaps.h */ +/* From https://github.com/Relintai/pandemonium_engine (MIT) */ +/*************************************************************************/ + +//satan invented unicode? +#define CAPS_LEN 666 + +static const int caps_table[CAPS_LEN][2] = { + { 0x0061, 0x0041 }, + { 0x0062, 0x0042 }, + { 0x0063, 0x0043 }, + { 0x0064, 0x0044 }, + { 0x0065, 0x0045 }, + { 0x0066, 0x0046 }, + { 0x0067, 0x0047 }, + { 0x0068, 0x0048 }, + { 0x0069, 0x0049 }, + { 0x006A, 0x004A }, + { 0x006B, 0x004B }, + { 0x006C, 0x004C }, + { 0x006D, 0x004D }, + { 0x006E, 0x004E }, + { 0x006F, 0x004F }, + { 0x0070, 0x0050 }, + { 0x0071, 0x0051 }, + { 0x0072, 0x0052 }, + { 0x0073, 0x0053 }, + { 0x0074, 0x0054 }, + { 0x0075, 0x0055 }, + { 0x0076, 0x0056 }, + { 0x0077, 0x0057 }, + { 0x0078, 0x0058 }, + { 0x0079, 0x0059 }, + { 0x007A, 0x005A }, + { 0x00E0, 0x00C0 }, + { 0x00E1, 0x00C1 }, + { 0x00E2, 0x00C2 }, + { 0x00E3, 0x00C3 }, + { 0x00E4, 0x00C4 }, + { 0x00E5, 0x00C5 }, + { 0x00E6, 0x00C6 }, + { 0x00E7, 0x00C7 }, + { 0x00E8, 0x00C8 }, + { 0x00E9, 0x00C9 }, + { 0x00EA, 0x00CA }, + { 0x00EB, 0x00CB }, + { 0x00EC, 0x00CC }, + { 0x00ED, 0x00CD }, + { 0x00EE, 0x00CE }, + { 0x00EF, 0x00CF }, + { 0x00F0, 0x00D0 }, + { 0x00F1, 0x00D1 }, + { 0x00F2, 0x00D2 }, + { 0x00F3, 0x00D3 }, + { 0x00F4, 0x00D4 }, + { 0x00F5, 0x00D5 }, + { 0x00F6, 0x00D6 }, + { 0x00F8, 0x00D8 }, + { 0x00F9, 0x00D9 }, + { 0x00FA, 0x00DA }, + { 0x00FB, 0x00DB }, + { 0x00FC, 0x00DC }, + { 0x00FD, 0x00DD }, + { 0x00FE, 0x00DE }, + { 0x00FF, 0x0178 }, + { 0x0101, 0x0100 }, + { 0x0103, 0x0102 }, + { 0x0105, 0x0104 }, + { 0x0107, 0x0106 }, + { 0x0109, 0x0108 }, + { 0x010B, 0x010A }, + { 0x010D, 0x010C }, + { 0x010F, 0x010E }, + { 0x0111, 0x0110 }, + { 0x0113, 0x0112 }, + { 0x0115, 0x0114 }, + { 0x0117, 0x0116 }, + { 0x0119, 0x0118 }, + { 0x011B, 0x011A }, + { 0x011D, 0x011C }, + { 0x011F, 0x011E }, + { 0x0121, 0x0120 }, + { 0x0123, 0x0122 }, + { 0x0125, 0x0124 }, + { 0x0127, 0x0126 }, + { 0x0129, 0x0128 }, + { 0x012B, 0x012A }, + { 0x012D, 0x012C }, + { 0x012F, 0x012E }, + { 0x0131, 0x0049 }, + { 0x0133, 0x0132 }, + { 0x0135, 0x0134 }, + { 0x0137, 0x0136 }, + { 0x013A, 0x0139 }, + { 0x013C, 0x013B }, + { 0x013E, 0x013D }, + { 0x0140, 0x013F }, + { 0x0142, 0x0141 }, + { 0x0144, 0x0143 }, + { 0x0146, 0x0145 }, + { 0x0148, 0x0147 }, + { 0x014B, 0x014A }, + { 0x014D, 0x014C }, + { 0x014F, 0x014E }, + { 0x0151, 0x0150 }, + { 0x0153, 0x0152 }, + { 0x0155, 0x0154 }, + { 0x0157, 0x0156 }, + { 0x0159, 0x0158 }, + { 0x015B, 0x015A }, + { 0x015D, 0x015C }, + { 0x015F, 0x015E }, + { 0x0161, 0x0160 }, + { 0x0163, 0x0162 }, + { 0x0165, 0x0164 }, + { 0x0167, 0x0166 }, + { 0x0169, 0x0168 }, + { 0x016B, 0x016A }, + { 0x016D, 0x016C }, + { 0x016F, 0x016E }, + { 0x0171, 0x0170 }, + { 0x0173, 0x0172 }, + { 0x0175, 0x0174 }, + { 0x0177, 0x0176 }, + { 0x017A, 0x0179 }, + { 0x017C, 0x017B }, + { 0x017E, 0x017D }, + { 0x0183, 0x0182 }, + { 0x0185, 0x0184 }, + { 0x0188, 0x0187 }, + { 0x018C, 0x018B }, + { 0x0192, 0x0191 }, + { 0x0199, 0x0198 }, + { 0x01A1, 0x01A0 }, + { 0x01A3, 0x01A2 }, + { 0x01A5, 0x01A4 }, + { 0x01A8, 0x01A7 }, + { 0x01AD, 0x01AC }, + { 0x01B0, 0x01AF }, + { 0x01B4, 0x01B3 }, + { 0x01B6, 0x01B5 }, + { 0x01B9, 0x01B8 }, + { 0x01BD, 0x01BC }, + { 0x01C6, 0x01C4 }, + { 0x01C9, 0x01C7 }, + { 0x01CC, 0x01CA }, + { 0x01CE, 0x01CD }, + { 0x01D0, 0x01CF }, + { 0x01D2, 0x01D1 }, + { 0x01D4, 0x01D3 }, + { 0x01D6, 0x01D5 }, + { 0x01D8, 0x01D7 }, + { 0x01DA, 0x01D9 }, + { 0x01DC, 0x01DB }, + { 0x01DF, 0x01DE }, + { 0x01E1, 0x01E0 }, + { 0x01E3, 0x01E2 }, + { 0x01E5, 0x01E4 }, + { 0x01E7, 0x01E6 }, + { 0x01E9, 0x01E8 }, + { 0x01EB, 0x01EA }, + { 0x01ED, 0x01EC }, + { 0x01EF, 0x01EE }, + { 0x01F3, 0x01F1 }, + { 0x01F5, 0x01F4 }, + { 0x01FB, 0x01FA }, + { 0x01FD, 0x01FC }, + { 0x01FF, 0x01FE }, + { 0x0201, 0x0200 }, + { 0x0203, 0x0202 }, + { 0x0205, 0x0204 }, + { 0x0207, 0x0206 }, + { 0x0209, 0x0208 }, + { 0x020B, 0x020A }, + { 0x020D, 0x020C }, + { 0x020F, 0x020E }, + { 0x0211, 0x0210 }, + { 0x0213, 0x0212 }, + { 0x0215, 0x0214 }, + { 0x0217, 0x0216 }, + { 0x0253, 0x0181 }, + { 0x0254, 0x0186 }, + { 0x0257, 0x018A }, + { 0x0258, 0x018E }, + { 0x0259, 0x018F }, + { 0x025B, 0x0190 }, + { 0x0260, 0x0193 }, + { 0x0263, 0x0194 }, + { 0x0268, 0x0197 }, + { 0x0269, 0x0196 }, + { 0x026F, 0x019C }, + { 0x0272, 0x019D }, + { 0x0275, 0x019F }, + { 0x0283, 0x01A9 }, + { 0x0288, 0x01AE }, + { 0x028A, 0x01B1 }, + { 0x028B, 0x01B2 }, + { 0x0292, 0x01B7 }, + { 0x03AC, 0x0386 }, + { 0x03AD, 0x0388 }, + { 0x03AE, 0x0389 }, + { 0x03AF, 0x038A }, + { 0x03B1, 0x0391 }, + { 0x03B2, 0x0392 }, + { 0x03B3, 0x0393 }, + { 0x03B4, 0x0394 }, + { 0x03B5, 0x0395 }, + { 0x03B6, 0x0396 }, + { 0x03B7, 0x0397 }, + { 0x03B8, 0x0398 }, + { 0x03B9, 0x0399 }, + { 0x03BA, 0x039A }, + { 0x03BB, 0x039B }, + { 0x03BC, 0x039C }, + { 0x03BD, 0x039D }, + { 0x03BE, 0x039E }, + { 0x03BF, 0x039F }, + { 0x03C0, 0x03A0 }, + { 0x03C1, 0x03A1 }, + { 0x03C3, 0x03A3 }, + { 0x03C4, 0x03A4 }, + { 0x03C5, 0x03A5 }, + { 0x03C6, 0x03A6 }, + { 0x03C7, 0x03A7 }, + { 0x03C8, 0x03A8 }, + { 0x03C9, 0x03A9 }, + { 0x03CA, 0x03AA }, + { 0x03CB, 0x03AB }, + { 0x03CC, 0x038C }, + { 0x03CD, 0x038E }, + { 0x03CE, 0x038F }, + { 0x03E3, 0x03E2 }, + { 0x03E5, 0x03E4 }, + { 0x03E7, 0x03E6 }, + { 0x03E9, 0x03E8 }, + { 0x03EB, 0x03EA }, + { 0x03ED, 0x03EC }, + { 0x03EF, 0x03EE }, + { 0x0430, 0x0410 }, + { 0x0431, 0x0411 }, + { 0x0432, 0x0412 }, + { 0x0433, 0x0413 }, + { 0x0434, 0x0414 }, + { 0x0435, 0x0415 }, + { 0x0436, 0x0416 }, + { 0x0437, 0x0417 }, + { 0x0438, 0x0418 }, + { 0x0439, 0x0419 }, + { 0x043A, 0x041A }, + { 0x043B, 0x041B }, + { 0x043C, 0x041C }, + { 0x043D, 0x041D }, + { 0x043E, 0x041E }, + { 0x043F, 0x041F }, + { 0x0440, 0x0420 }, + { 0x0441, 0x0421 }, + { 0x0442, 0x0422 }, + { 0x0443, 0x0423 }, + { 0x0444, 0x0424 }, + { 0x0445, 0x0425 }, + { 0x0446, 0x0426 }, + { 0x0447, 0x0427 }, + { 0x0448, 0x0428 }, + { 0x0449, 0x0429 }, + { 0x044A, 0x042A }, + { 0x044B, 0x042B }, + { 0x044C, 0x042C }, + { 0x044D, 0x042D }, + { 0x044E, 0x042E }, + { 0x044F, 0x042F }, + { 0x0451, 0x0401 }, + { 0x0452, 0x0402 }, + { 0x0453, 0x0403 }, + { 0x0454, 0x0404 }, + { 0x0455, 0x0405 }, + { 0x0456, 0x0406 }, + { 0x0457, 0x0407 }, + { 0x0458, 0x0408 }, + { 0x0459, 0x0409 }, + { 0x045A, 0x040A }, + { 0x045B, 0x040B }, + { 0x045C, 0x040C }, + { 0x045E, 0x040E }, + { 0x045F, 0x040F }, + { 0x0461, 0x0460 }, + { 0x0463, 0x0462 }, + { 0x0465, 0x0464 }, + { 0x0467, 0x0466 }, + { 0x0469, 0x0468 }, + { 0x046B, 0x046A }, + { 0x046D, 0x046C }, + { 0x046F, 0x046E }, + { 0x0471, 0x0470 }, + { 0x0473, 0x0472 }, + { 0x0475, 0x0474 }, + { 0x0477, 0x0476 }, + { 0x0479, 0x0478 }, + { 0x047B, 0x047A }, + { 0x047D, 0x047C }, + { 0x047F, 0x047E }, + { 0x0481, 0x0480 }, + { 0x0491, 0x0490 }, + { 0x0493, 0x0492 }, + { 0x0495, 0x0494 }, + { 0x0497, 0x0496 }, + { 0x0499, 0x0498 }, + { 0x049B, 0x049A }, + { 0x049D, 0x049C }, + { 0x049F, 0x049E }, + { 0x04A1, 0x04A0 }, + { 0x04A3, 0x04A2 }, + { 0x04A5, 0x04A4 }, + { 0x04A7, 0x04A6 }, + { 0x04A9, 0x04A8 }, + { 0x04AB, 0x04AA }, + { 0x04AD, 0x04AC }, + { 0x04AF, 0x04AE }, + { 0x04B1, 0x04B0 }, + { 0x04B3, 0x04B2 }, + { 0x04B5, 0x04B4 }, + { 0x04B7, 0x04B6 }, + { 0x04B9, 0x04B8 }, + { 0x04BB, 0x04BA }, + { 0x04BD, 0x04BC }, + { 0x04BF, 0x04BE }, + { 0x04C2, 0x04C1 }, + { 0x04C4, 0x04C3 }, + { 0x04C8, 0x04C7 }, + { 0x04CC, 0x04CB }, + { 0x04D1, 0x04D0 }, + { 0x04D3, 0x04D2 }, + { 0x04D5, 0x04D4 }, + { 0x04D7, 0x04D6 }, + { 0x04D9, 0x04D8 }, + { 0x04DB, 0x04DA }, + { 0x04DD, 0x04DC }, + { 0x04DF, 0x04DE }, + { 0x04E1, 0x04E0 }, + { 0x04E3, 0x04E2 }, + { 0x04E5, 0x04E4 }, + { 0x04E7, 0x04E6 }, + { 0x04E9, 0x04E8 }, + { 0x04EB, 0x04EA }, + { 0x04EF, 0x04EE }, + { 0x04F1, 0x04F0 }, + { 0x04F3, 0x04F2 }, + { 0x04F5, 0x04F4 }, + { 0x04F9, 0x04F8 }, + { 0x0561, 0x0531 }, + { 0x0562, 0x0532 }, + { 0x0563, 0x0533 }, + { 0x0564, 0x0534 }, + { 0x0565, 0x0535 }, + { 0x0566, 0x0536 }, + { 0x0567, 0x0537 }, + { 0x0568, 0x0538 }, + { 0x0569, 0x0539 }, + { 0x056A, 0x053A }, + { 0x056B, 0x053B }, + { 0x056C, 0x053C }, + { 0x056D, 0x053D }, + { 0x056E, 0x053E }, + { 0x056F, 0x053F }, + { 0x0570, 0x0540 }, + { 0x0571, 0x0541 }, + { 0x0572, 0x0542 }, + { 0x0573, 0x0543 }, + { 0x0574, 0x0544 }, + { 0x0575, 0x0545 }, + { 0x0576, 0x0546 }, + { 0x0577, 0x0547 }, + { 0x0578, 0x0548 }, + { 0x0579, 0x0549 }, + { 0x057A, 0x054A }, + { 0x057B, 0x054B }, + { 0x057C, 0x054C }, + { 0x057D, 0x054D }, + { 0x057E, 0x054E }, + { 0x057F, 0x054F }, + { 0x0580, 0x0550 }, + { 0x0581, 0x0551 }, + { 0x0582, 0x0552 }, + { 0x0583, 0x0553 }, + { 0x0584, 0x0554 }, + { 0x0585, 0x0555 }, + { 0x0586, 0x0556 }, + { 0x10D0, 0x10A0 }, + { 0x10D1, 0x10A1 }, + { 0x10D2, 0x10A2 }, + { 0x10D3, 0x10A3 }, + { 0x10D4, 0x10A4 }, + { 0x10D5, 0x10A5 }, + { 0x10D6, 0x10A6 }, + { 0x10D7, 0x10A7 }, + { 0x10D8, 0x10A8 }, + { 0x10D9, 0x10A9 }, + { 0x10DA, 0x10AA }, + { 0x10DB, 0x10AB }, + { 0x10DC, 0x10AC }, + { 0x10DD, 0x10AD }, + { 0x10DE, 0x10AE }, + { 0x10DF, 0x10AF }, + { 0x10E0, 0x10B0 }, + { 0x10E1, 0x10B1 }, + { 0x10E2, 0x10B2 }, + { 0x10E3, 0x10B3 }, + { 0x10E4, 0x10B4 }, + { 0x10E5, 0x10B5 }, + { 0x10E6, 0x10B6 }, + { 0x10E7, 0x10B7 }, + { 0x10E8, 0x10B8 }, + { 0x10E9, 0x10B9 }, + { 0x10EA, 0x10BA }, + { 0x10EB, 0x10BB }, + { 0x10EC, 0x10BC }, + { 0x10ED, 0x10BD }, + { 0x10EE, 0x10BE }, + { 0x10EF, 0x10BF }, + { 0x10F0, 0x10C0 }, + { 0x10F1, 0x10C1 }, + { 0x10F2, 0x10C2 }, + { 0x10F3, 0x10C3 }, + { 0x10F4, 0x10C4 }, + { 0x10F5, 0x10C5 }, + { 0x1E01, 0x1E00 }, + { 0x1E03, 0x1E02 }, + { 0x1E05, 0x1E04 }, + { 0x1E07, 0x1E06 }, + { 0x1E09, 0x1E08 }, + { 0x1E0B, 0x1E0A }, + { 0x1E0D, 0x1E0C }, + { 0x1E0F, 0x1E0E }, + { 0x1E11, 0x1E10 }, + { 0x1E13, 0x1E12 }, + { 0x1E15, 0x1E14 }, + { 0x1E17, 0x1E16 }, + { 0x1E19, 0x1E18 }, + { 0x1E1B, 0x1E1A }, + { 0x1E1D, 0x1E1C }, + { 0x1E1F, 0x1E1E }, + { 0x1E21, 0x1E20 }, + { 0x1E23, 0x1E22 }, + { 0x1E25, 0x1E24 }, + { 0x1E27, 0x1E26 }, + { 0x1E29, 0x1E28 }, + { 0x1E2B, 0x1E2A }, + { 0x1E2D, 0x1E2C }, + { 0x1E2F, 0x1E2E }, + { 0x1E31, 0x1E30 }, + { 0x1E33, 0x1E32 }, + { 0x1E35, 0x1E34 }, + { 0x1E37, 0x1E36 }, + { 0x1E39, 0x1E38 }, + { 0x1E3B, 0x1E3A }, + { 0x1E3D, 0x1E3C }, + { 0x1E3F, 0x1E3E }, + { 0x1E41, 0x1E40 }, + { 0x1E43, 0x1E42 }, + { 0x1E45, 0x1E44 }, + { 0x1E47, 0x1E46 }, + { 0x1E49, 0x1E48 }, + { 0x1E4B, 0x1E4A }, + { 0x1E4D, 0x1E4C }, + { 0x1E4F, 0x1E4E }, + { 0x1E51, 0x1E50 }, + { 0x1E53, 0x1E52 }, + { 0x1E55, 0x1E54 }, + { 0x1E57, 0x1E56 }, + { 0x1E59, 0x1E58 }, + { 0x1E5B, 0x1E5A }, + { 0x1E5D, 0x1E5C }, + { 0x1E5F, 0x1E5E }, + { 0x1E61, 0x1E60 }, + { 0x1E63, 0x1E62 }, + { 0x1E65, 0x1E64 }, + { 0x1E67, 0x1E66 }, + { 0x1E69, 0x1E68 }, + { 0x1E6B, 0x1E6A }, + { 0x1E6D, 0x1E6C }, + { 0x1E6F, 0x1E6E }, + { 0x1E71, 0x1E70 }, + { 0x1E73, 0x1E72 }, + { 0x1E75, 0x1E74 }, + { 0x1E77, 0x1E76 }, + { 0x1E79, 0x1E78 }, + { 0x1E7B, 0x1E7A }, + { 0x1E7D, 0x1E7C }, + { 0x1E7F, 0x1E7E }, + { 0x1E81, 0x1E80 }, + { 0x1E83, 0x1E82 }, + { 0x1E85, 0x1E84 }, + { 0x1E87, 0x1E86 }, + { 0x1E89, 0x1E88 }, + { 0x1E8B, 0x1E8A }, + { 0x1E8D, 0x1E8C }, + { 0x1E8F, 0x1E8E }, + { 0x1E91, 0x1E90 }, + { 0x1E93, 0x1E92 }, + { 0x1E95, 0x1E94 }, + { 0x1EA1, 0x1EA0 }, + { 0x1EA3, 0x1EA2 }, + { 0x1EA5, 0x1EA4 }, + { 0x1EA7, 0x1EA6 }, + { 0x1EA9, 0x1EA8 }, + { 0x1EAB, 0x1EAA }, + { 0x1EAD, 0x1EAC }, + { 0x1EAF, 0x1EAE }, + { 0x1EB1, 0x1EB0 }, + { 0x1EB3, 0x1EB2 }, + { 0x1EB5, 0x1EB4 }, + { 0x1EB7, 0x1EB6 }, + { 0x1EB9, 0x1EB8 }, + { 0x1EBB, 0x1EBA }, + { 0x1EBD, 0x1EBC }, + { 0x1EBF, 0x1EBE }, + { 0x1EC1, 0x1EC0 }, + { 0x1EC3, 0x1EC2 }, + { 0x1EC5, 0x1EC4 }, + { 0x1EC7, 0x1EC6 }, + { 0x1EC9, 0x1EC8 }, + { 0x1ECB, 0x1ECA }, + { 0x1ECD, 0x1ECC }, + { 0x1ECF, 0x1ECE }, + { 0x1ED1, 0x1ED0 }, + { 0x1ED3, 0x1ED2 }, + { 0x1ED5, 0x1ED4 }, + { 0x1ED7, 0x1ED6 }, + { 0x1ED9, 0x1ED8 }, + { 0x1EDB, 0x1EDA }, + { 0x1EDD, 0x1EDC }, + { 0x1EDF, 0x1EDE }, + { 0x1EE1, 0x1EE0 }, + { 0x1EE3, 0x1EE2 }, + { 0x1EE5, 0x1EE4 }, + { 0x1EE7, 0x1EE6 }, + { 0x1EE9, 0x1EE8 }, + { 0x1EEB, 0x1EEA }, + { 0x1EED, 0x1EEC }, + { 0x1EEF, 0x1EEE }, + { 0x1EF1, 0x1EF0 }, + { 0x1EF3, 0x1EF2 }, + { 0x1EF5, 0x1EF4 }, + { 0x1EF7, 0x1EF6 }, + { 0x1EF9, 0x1EF8 }, + { 0x1F00, 0x1F08 }, + { 0x1F01, 0x1F09 }, + { 0x1F02, 0x1F0A }, + { 0x1F03, 0x1F0B }, + { 0x1F04, 0x1F0C }, + { 0x1F05, 0x1F0D }, + { 0x1F06, 0x1F0E }, + { 0x1F07, 0x1F0F }, + { 0x1F10, 0x1F18 }, + { 0x1F11, 0x1F19 }, + { 0x1F12, 0x1F1A }, + { 0x1F13, 0x1F1B }, + { 0x1F14, 0x1F1C }, + { 0x1F15, 0x1F1D }, + { 0x1F20, 0x1F28 }, + { 0x1F21, 0x1F29 }, + { 0x1F22, 0x1F2A }, + { 0x1F23, 0x1F2B }, + { 0x1F24, 0x1F2C }, + { 0x1F25, 0x1F2D }, + { 0x1F26, 0x1F2E }, + { 0x1F27, 0x1F2F }, + { 0x1F30, 0x1F38 }, + { 0x1F31, 0x1F39 }, + { 0x1F32, 0x1F3A }, + { 0x1F33, 0x1F3B }, + { 0x1F34, 0x1F3C }, + { 0x1F35, 0x1F3D }, + { 0x1F36, 0x1F3E }, + { 0x1F37, 0x1F3F }, + { 0x1F40, 0x1F48 }, + { 0x1F41, 0x1F49 }, + { 0x1F42, 0x1F4A }, + { 0x1F43, 0x1F4B }, + { 0x1F44, 0x1F4C }, + { 0x1F45, 0x1F4D }, + { 0x1F51, 0x1F59 }, + { 0x1F53, 0x1F5B }, + { 0x1F55, 0x1F5D }, + { 0x1F57, 0x1F5F }, + { 0x1F60, 0x1F68 }, + { 0x1F61, 0x1F69 }, + { 0x1F62, 0x1F6A }, + { 0x1F63, 0x1F6B }, + { 0x1F64, 0x1F6C }, + { 0x1F65, 0x1F6D }, + { 0x1F66, 0x1F6E }, + { 0x1F67, 0x1F6F }, + { 0x1F80, 0x1F88 }, + { 0x1F81, 0x1F89 }, + { 0x1F82, 0x1F8A }, + { 0x1F83, 0x1F8B }, + { 0x1F84, 0x1F8C }, + { 0x1F85, 0x1F8D }, + { 0x1F86, 0x1F8E }, + { 0x1F87, 0x1F8F }, + { 0x1F90, 0x1F98 }, + { 0x1F91, 0x1F99 }, + { 0x1F92, 0x1F9A }, + { 0x1F93, 0x1F9B }, + { 0x1F94, 0x1F9C }, + { 0x1F95, 0x1F9D }, + { 0x1F96, 0x1F9E }, + { 0x1F97, 0x1F9F }, + { 0x1FA0, 0x1FA8 }, + { 0x1FA1, 0x1FA9 }, + { 0x1FA2, 0x1FAA }, + { 0x1FA3, 0x1FAB }, + { 0x1FA4, 0x1FAC }, + { 0x1FA5, 0x1FAD }, + { 0x1FA6, 0x1FAE }, + { 0x1FA7, 0x1FAF }, + { 0x1FB0, 0x1FB8 }, + { 0x1FB1, 0x1FB9 }, + { 0x1FD0, 0x1FD8 }, + { 0x1FD1, 0x1FD9 }, + { 0x1FE0, 0x1FE8 }, + { 0x1FE1, 0x1FE9 }, + { 0x24D0, 0x24B6 }, + { 0x24D1, 0x24B7 }, + { 0x24D2, 0x24B8 }, + { 0x24D3, 0x24B9 }, + { 0x24D4, 0x24BA }, + { 0x24D5, 0x24BB }, + { 0x24D6, 0x24BC }, + { 0x24D7, 0x24BD }, + { 0x24D8, 0x24BE }, + { 0x24D9, 0x24BF }, + { 0x24DA, 0x24C0 }, + { 0x24DB, 0x24C1 }, + { 0x24DC, 0x24C2 }, + { 0x24DD, 0x24C3 }, + { 0x24DE, 0x24C4 }, + { 0x24DF, 0x24C5 }, + { 0x24E0, 0x24C6 }, + { 0x24E1, 0x24C7 }, + { 0x24E2, 0x24C8 }, + { 0x24E3, 0x24C9 }, + { 0x24E4, 0x24CA }, + { 0x24E5, 0x24CB }, + { 0x24E6, 0x24CC }, + { 0x24E7, 0x24CD }, + { 0x24E8, 0x24CE }, + { 0x24E9, 0x24CF }, + { 0xFF41, 0xFF21 }, + { 0xFF42, 0xFF22 }, + { 0xFF43, 0xFF23 }, + { 0xFF44, 0xFF24 }, + { 0xFF45, 0xFF25 }, + { 0xFF46, 0xFF26 }, + { 0xFF47, 0xFF27 }, + { 0xFF48, 0xFF28 }, + { 0xFF49, 0xFF29 }, + { 0xFF4A, 0xFF2A }, + { 0xFF4B, 0xFF2B }, + { 0xFF4C, 0xFF2C }, + { 0xFF4D, 0xFF2D }, + { 0xFF4E, 0xFF2E }, + { 0xFF4F, 0xFF2F }, + { 0xFF50, 0xFF30 }, + { 0xFF51, 0xFF31 }, + { 0xFF52, 0xFF32 }, + { 0xFF53, 0xFF33 }, + { 0xFF54, 0xFF34 }, + { 0xFF55, 0xFF35 }, + { 0xFF56, 0xFF36 }, + { 0xFF57, 0xFF37 }, + { 0xFF58, 0xFF38 }, + { 0xFF59, 0xFF39 }, + { 0xFF5A, 0xFF3A }, +}; + +static const int reverse_caps_table[CAPS_LEN - 1][2] = { + { 0x0041, 0x0061 }, + { 0x0042, 0x0062 }, + { 0x0043, 0x0063 }, + { 0x0044, 0x0064 }, + { 0x0045, 0x0065 }, + { 0x0046, 0x0066 }, + { 0x0047, 0x0067 }, + { 0x0048, 0x0068 }, + { 0x0049, 0x0069 }, + // { 0x0049, 0x0131 }, // dotless I + { 0x004A, 0x006A }, + { 0x004B, 0x006B }, + { 0x004C, 0x006C }, + { 0x004D, 0x006D }, + { 0x004E, 0x006E }, + { 0x004F, 0x006F }, + { 0x0050, 0x0070 }, + { 0x0051, 0x0071 }, + { 0x0052, 0x0072 }, + { 0x0053, 0x0073 }, + { 0x0054, 0x0074 }, + { 0x0055, 0x0075 }, + { 0x0056, 0x0076 }, + { 0x0057, 0x0077 }, + { 0x0058, 0x0078 }, + { 0x0059, 0x0079 }, + { 0x005A, 0x007A }, + { 0x00C0, 0x00E0 }, + { 0x00C1, 0x00E1 }, + { 0x00C2, 0x00E2 }, + { 0x00C3, 0x00E3 }, + { 0x00C4, 0x00E4 }, + { 0x00C5, 0x00E5 }, + { 0x00C6, 0x00E6 }, + { 0x00C7, 0x00E7 }, + { 0x00C8, 0x00E8 }, + { 0x00C9, 0x00E9 }, + { 0x00CA, 0x00EA }, + { 0x00CB, 0x00EB }, + { 0x00CC, 0x00EC }, + { 0x00CD, 0x00ED }, + { 0x00CE, 0x00EE }, + { 0x00CF, 0x00EF }, + { 0x00D0, 0x00F0 }, + { 0x00D1, 0x00F1 }, + { 0x00D2, 0x00F2 }, + { 0x00D3, 0x00F3 }, + { 0x00D4, 0x00F4 }, + { 0x00D5, 0x00F5 }, + { 0x00D6, 0x00F6 }, + { 0x00D8, 0x00F8 }, + { 0x00D9, 0x00F9 }, + { 0x00DA, 0x00FA }, + { 0x00DB, 0x00FB }, + { 0x00DC, 0x00FC }, + { 0x00DD, 0x00FD }, + { 0x00DE, 0x00FE }, + { 0x0100, 0x0101 }, + { 0x0102, 0x0103 }, + { 0x0104, 0x0105 }, + { 0x0106, 0x0107 }, + { 0x0108, 0x0109 }, + { 0x010A, 0x010B }, + { 0x010C, 0x010D }, + { 0x010E, 0x010F }, + { 0x0110, 0x0111 }, + { 0x0112, 0x0113 }, + { 0x0114, 0x0115 }, + { 0x0116, 0x0117 }, + { 0x0118, 0x0119 }, + { 0x011A, 0x011B }, + { 0x011C, 0x011D }, + { 0x011E, 0x011F }, + { 0x0120, 0x0121 }, + { 0x0122, 0x0123 }, + { 0x0124, 0x0125 }, + { 0x0126, 0x0127 }, + { 0x0128, 0x0129 }, + { 0x012A, 0x012B }, + { 0x012C, 0x012D }, + { 0x012E, 0x012F }, + { 0x0132, 0x0133 }, + { 0x0134, 0x0135 }, + { 0x0136, 0x0137 }, + { 0x0139, 0x013A }, + { 0x013B, 0x013C }, + { 0x013D, 0x013E }, + { 0x013F, 0x0140 }, + { 0x0141, 0x0142 }, + { 0x0143, 0x0144 }, + { 0x0145, 0x0146 }, + { 0x0147, 0x0148 }, + { 0x014A, 0x014B }, + { 0x014C, 0x014D }, + { 0x014E, 0x014F }, + { 0x0150, 0x0151 }, + { 0x0152, 0x0153 }, + { 0x0154, 0x0155 }, + { 0x0156, 0x0157 }, + { 0x0158, 0x0159 }, + { 0x015A, 0x015B }, + { 0x015C, 0x015D }, + { 0x015E, 0x015F }, + { 0x0160, 0x0161 }, + { 0x0162, 0x0163 }, + { 0x0164, 0x0165 }, + { 0x0166, 0x0167 }, + { 0x0168, 0x0169 }, + { 0x016A, 0x016B }, + { 0x016C, 0x016D }, + { 0x016E, 0x016F }, + { 0x0170, 0x0171 }, + { 0x0172, 0x0173 }, + { 0x0174, 0x0175 }, + { 0x0176, 0x0177 }, + { 0x0178, 0x00FF }, + { 0x0179, 0x017A }, + { 0x017B, 0x017C }, + { 0x017D, 0x017E }, + { 0x0181, 0x0253 }, + { 0x0182, 0x0183 }, + { 0x0184, 0x0185 }, + { 0x0186, 0x0254 }, + { 0x0187, 0x0188 }, + { 0x018A, 0x0257 }, + { 0x018B, 0x018C }, + { 0x018E, 0x0258 }, + { 0x018F, 0x0259 }, + { 0x0190, 0x025B }, + { 0x0191, 0x0192 }, + { 0x0193, 0x0260 }, + { 0x0194, 0x0263 }, + { 0x0196, 0x0269 }, + { 0x0197, 0x0268 }, + { 0x0198, 0x0199 }, + { 0x019C, 0x026F }, + { 0x019D, 0x0272 }, + { 0x019F, 0x0275 }, + { 0x01A0, 0x01A1 }, + { 0x01A2, 0x01A3 }, + { 0x01A4, 0x01A5 }, + { 0x01A7, 0x01A8 }, + { 0x01A9, 0x0283 }, + { 0x01AC, 0x01AD }, + { 0x01AE, 0x0288 }, + { 0x01AF, 0x01B0 }, + { 0x01B1, 0x028A }, + { 0x01B2, 0x028B }, + { 0x01B3, 0x01B4 }, + { 0x01B5, 0x01B6 }, + { 0x01B7, 0x0292 }, + { 0x01B8, 0x01B9 }, + { 0x01BC, 0x01BD }, + { 0x01C4, 0x01C6 }, + { 0x01C7, 0x01C9 }, + { 0x01CA, 0x01CC }, + { 0x01CD, 0x01CE }, + { 0x01CF, 0x01D0 }, + { 0x01D1, 0x01D2 }, + { 0x01D3, 0x01D4 }, + { 0x01D5, 0x01D6 }, + { 0x01D7, 0x01D8 }, + { 0x01D9, 0x01DA }, + { 0x01DB, 0x01DC }, + { 0x01DE, 0x01DF }, + { 0x01E0, 0x01E1 }, + { 0x01E2, 0x01E3 }, + { 0x01E4, 0x01E5 }, + { 0x01E6, 0x01E7 }, + { 0x01E8, 0x01E9 }, + { 0x01EA, 0x01EB }, + { 0x01EC, 0x01ED }, + { 0x01EE, 0x01EF }, + { 0x01F1, 0x01F3 }, + { 0x01F4, 0x01F5 }, + { 0x01FA, 0x01FB }, + { 0x01FC, 0x01FD }, + { 0x01FE, 0x01FF }, + { 0x0200, 0x0201 }, + { 0x0202, 0x0203 }, + { 0x0204, 0x0205 }, + { 0x0206, 0x0207 }, + { 0x0208, 0x0209 }, + { 0x020A, 0x020B }, + { 0x020C, 0x020D }, + { 0x020E, 0x020F }, + { 0x0210, 0x0211 }, + { 0x0212, 0x0213 }, + { 0x0214, 0x0215 }, + { 0x0216, 0x0217 }, + { 0x0386, 0x03AC }, + { 0x0388, 0x03AD }, + { 0x0389, 0x03AE }, + { 0x038A, 0x03AF }, + { 0x038C, 0x03CC }, + { 0x038E, 0x03CD }, + { 0x038F, 0x03CE }, + { 0x0391, 0x03B1 }, + { 0x0392, 0x03B2 }, + { 0x0393, 0x03B3 }, + { 0x0394, 0x03B4 }, + { 0x0395, 0x03B5 }, + { 0x0396, 0x03B6 }, + { 0x0397, 0x03B7 }, + { 0x0398, 0x03B8 }, + { 0x0399, 0x03B9 }, + { 0x039A, 0x03BA }, + { 0x039B, 0x03BB }, + { 0x039C, 0x03BC }, + { 0x039D, 0x03BD }, + { 0x039E, 0x03BE }, + { 0x039F, 0x03BF }, + { 0x03A0, 0x03C0 }, + { 0x03A1, 0x03C1 }, + { 0x03A3, 0x03C3 }, + { 0x03A4, 0x03C4 }, + { 0x03A5, 0x03C5 }, + { 0x03A6, 0x03C6 }, + { 0x03A7, 0x03C7 }, + { 0x03A8, 0x03C8 }, + { 0x03A9, 0x03C9 }, + { 0x03AA, 0x03CA }, + { 0x03AB, 0x03CB }, + { 0x03E2, 0x03E3 }, + { 0x03E4, 0x03E5 }, + { 0x03E6, 0x03E7 }, + { 0x03E8, 0x03E9 }, + { 0x03EA, 0x03EB }, + { 0x03EC, 0x03ED }, + { 0x03EE, 0x03EF }, + { 0x0401, 0x0451 }, + { 0x0402, 0x0452 }, + { 0x0403, 0x0453 }, + { 0x0404, 0x0454 }, + { 0x0405, 0x0455 }, + { 0x0406, 0x0456 }, + { 0x0407, 0x0457 }, + { 0x0408, 0x0458 }, + { 0x0409, 0x0459 }, + { 0x040A, 0x045A }, + { 0x040B, 0x045B }, + { 0x040C, 0x045C }, + { 0x040E, 0x045E }, + { 0x040F, 0x045F }, + { 0x0410, 0x0430 }, + { 0x0411, 0x0431 }, + { 0x0412, 0x0432 }, + { 0x0413, 0x0433 }, + { 0x0414, 0x0434 }, + { 0x0415, 0x0435 }, + { 0x0416, 0x0436 }, + { 0x0417, 0x0437 }, + { 0x0418, 0x0438 }, + { 0x0419, 0x0439 }, + { 0x041A, 0x043A }, + { 0x041B, 0x043B }, + { 0x041C, 0x043C }, + { 0x041D, 0x043D }, + { 0x041E, 0x043E }, + { 0x041F, 0x043F }, + { 0x0420, 0x0440 }, + { 0x0421, 0x0441 }, + { 0x0422, 0x0442 }, + { 0x0423, 0x0443 }, + { 0x0424, 0x0444 }, + { 0x0425, 0x0445 }, + { 0x0426, 0x0446 }, + { 0x0427, 0x0447 }, + { 0x0428, 0x0448 }, + { 0x0429, 0x0449 }, + { 0x042A, 0x044A }, + { 0x042B, 0x044B }, + { 0x042C, 0x044C }, + { 0x042D, 0x044D }, + { 0x042E, 0x044E }, + { 0x042F, 0x044F }, + { 0x0460, 0x0461 }, + { 0x0462, 0x0463 }, + { 0x0464, 0x0465 }, + { 0x0466, 0x0467 }, + { 0x0468, 0x0469 }, + { 0x046A, 0x046B }, + { 0x046C, 0x046D }, + { 0x046E, 0x046F }, + { 0x0470, 0x0471 }, + { 0x0472, 0x0473 }, + { 0x0474, 0x0475 }, + { 0x0476, 0x0477 }, + { 0x0478, 0x0479 }, + { 0x047A, 0x047B }, + { 0x047C, 0x047D }, + { 0x047E, 0x047F }, + { 0x0480, 0x0481 }, + { 0x0490, 0x0491 }, + { 0x0492, 0x0493 }, + { 0x0494, 0x0495 }, + { 0x0496, 0x0497 }, + { 0x0498, 0x0499 }, + { 0x049A, 0x049B }, + { 0x049C, 0x049D }, + { 0x049E, 0x049F }, + { 0x04A0, 0x04A1 }, + { 0x04A2, 0x04A3 }, + { 0x04A4, 0x04A5 }, + { 0x04A6, 0x04A7 }, + { 0x04A8, 0x04A9 }, + { 0x04AA, 0x04AB }, + { 0x04AC, 0x04AD }, + { 0x04AE, 0x04AF }, + { 0x04B0, 0x04B1 }, + { 0x04B2, 0x04B3 }, + { 0x04B4, 0x04B5 }, + { 0x04B6, 0x04B7 }, + { 0x04B8, 0x04B9 }, + { 0x04BA, 0x04BB }, + { 0x04BC, 0x04BD }, + { 0x04BE, 0x04BF }, + { 0x04C1, 0x04C2 }, + { 0x04C3, 0x04C4 }, + { 0x04C7, 0x04C8 }, + { 0x04CB, 0x04CC }, + { 0x04D0, 0x04D1 }, + { 0x04D2, 0x04D3 }, + { 0x04D4, 0x04D5 }, + { 0x04D6, 0x04D7 }, + { 0x04D8, 0x04D9 }, + { 0x04DA, 0x04DB }, + { 0x04DC, 0x04DD }, + { 0x04DE, 0x04DF }, + { 0x04E0, 0x04E1 }, + { 0x04E2, 0x04E3 }, + { 0x04E4, 0x04E5 }, + { 0x04E6, 0x04E7 }, + { 0x04E8, 0x04E9 }, + { 0x04EA, 0x04EB }, + { 0x04EE, 0x04EF }, + { 0x04F0, 0x04F1 }, + { 0x04F2, 0x04F3 }, + { 0x04F4, 0x04F5 }, + { 0x04F8, 0x04F9 }, + { 0x0531, 0x0561 }, + { 0x0532, 0x0562 }, + { 0x0533, 0x0563 }, + { 0x0534, 0x0564 }, + { 0x0535, 0x0565 }, + { 0x0536, 0x0566 }, + { 0x0537, 0x0567 }, + { 0x0538, 0x0568 }, + { 0x0539, 0x0569 }, + { 0x053A, 0x056A }, + { 0x053B, 0x056B }, + { 0x053C, 0x056C }, + { 0x053D, 0x056D }, + { 0x053E, 0x056E }, + { 0x053F, 0x056F }, + { 0x0540, 0x0570 }, + { 0x0541, 0x0571 }, + { 0x0542, 0x0572 }, + { 0x0543, 0x0573 }, + { 0x0544, 0x0574 }, + { 0x0545, 0x0575 }, + { 0x0546, 0x0576 }, + { 0x0547, 0x0577 }, + { 0x0548, 0x0578 }, + { 0x0549, 0x0579 }, + { 0x054A, 0x057A }, + { 0x054B, 0x057B }, + { 0x054C, 0x057C }, + { 0x054D, 0x057D }, + { 0x054E, 0x057E }, + { 0x054F, 0x057F }, + { 0x0550, 0x0580 }, + { 0x0551, 0x0581 }, + { 0x0552, 0x0582 }, + { 0x0553, 0x0583 }, + { 0x0554, 0x0584 }, + { 0x0555, 0x0585 }, + { 0x0556, 0x0586 }, + { 0x10A0, 0x10D0 }, + { 0x10A1, 0x10D1 }, + { 0x10A2, 0x10D2 }, + { 0x10A3, 0x10D3 }, + { 0x10A4, 0x10D4 }, + { 0x10A5, 0x10D5 }, + { 0x10A6, 0x10D6 }, + { 0x10A7, 0x10D7 }, + { 0x10A8, 0x10D8 }, + { 0x10A9, 0x10D9 }, + { 0x10AA, 0x10DA }, + { 0x10AB, 0x10DB }, + { 0x10AC, 0x10DC }, + { 0x10AD, 0x10DD }, + { 0x10AE, 0x10DE }, + { 0x10AF, 0x10DF }, + { 0x10B0, 0x10E0 }, + { 0x10B1, 0x10E1 }, + { 0x10B2, 0x10E2 }, + { 0x10B3, 0x10E3 }, + { 0x10B4, 0x10E4 }, + { 0x10B5, 0x10E5 }, + { 0x10B6, 0x10E6 }, + { 0x10B7, 0x10E7 }, + { 0x10B8, 0x10E8 }, + { 0x10B9, 0x10E9 }, + { 0x10BA, 0x10EA }, + { 0x10BB, 0x10EB }, + { 0x10BC, 0x10EC }, + { 0x10BD, 0x10ED }, + { 0x10BE, 0x10EE }, + { 0x10BF, 0x10EF }, + { 0x10C0, 0x10F0 }, + { 0x10C1, 0x10F1 }, + { 0x10C2, 0x10F2 }, + { 0x10C3, 0x10F3 }, + { 0x10C4, 0x10F4 }, + { 0x10C5, 0x10F5 }, + { 0x1E00, 0x1E01 }, + { 0x1E02, 0x1E03 }, + { 0x1E04, 0x1E05 }, + { 0x1E06, 0x1E07 }, + { 0x1E08, 0x1E09 }, + { 0x1E0A, 0x1E0B }, + { 0x1E0C, 0x1E0D }, + { 0x1E0E, 0x1E0F }, + { 0x1E10, 0x1E11 }, + { 0x1E12, 0x1E13 }, + { 0x1E14, 0x1E15 }, + { 0x1E16, 0x1E17 }, + { 0x1E18, 0x1E19 }, + { 0x1E1A, 0x1E1B }, + { 0x1E1C, 0x1E1D }, + { 0x1E1E, 0x1E1F }, + { 0x1E20, 0x1E21 }, + { 0x1E22, 0x1E23 }, + { 0x1E24, 0x1E25 }, + { 0x1E26, 0x1E27 }, + { 0x1E28, 0x1E29 }, + { 0x1E2A, 0x1E2B }, + { 0x1E2C, 0x1E2D }, + { 0x1E2E, 0x1E2F }, + { 0x1E30, 0x1E31 }, + { 0x1E32, 0x1E33 }, + { 0x1E34, 0x1E35 }, + { 0x1E36, 0x1E37 }, + { 0x1E38, 0x1E39 }, + { 0x1E3A, 0x1E3B }, + { 0x1E3C, 0x1E3D }, + { 0x1E3E, 0x1E3F }, + { 0x1E40, 0x1E41 }, + { 0x1E42, 0x1E43 }, + { 0x1E44, 0x1E45 }, + { 0x1E46, 0x1E47 }, + { 0x1E48, 0x1E49 }, + { 0x1E4A, 0x1E4B }, + { 0x1E4C, 0x1E4D }, + { 0x1E4E, 0x1E4F }, + { 0x1E50, 0x1E51 }, + { 0x1E52, 0x1E53 }, + { 0x1E54, 0x1E55 }, + { 0x1E56, 0x1E57 }, + { 0x1E58, 0x1E59 }, + { 0x1E5A, 0x1E5B }, + { 0x1E5C, 0x1E5D }, + { 0x1E5E, 0x1E5F }, + { 0x1E60, 0x1E61 }, + { 0x1E62, 0x1E63 }, + { 0x1E64, 0x1E65 }, + { 0x1E66, 0x1E67 }, + { 0x1E68, 0x1E69 }, + { 0x1E6A, 0x1E6B }, + { 0x1E6C, 0x1E6D }, + { 0x1E6E, 0x1E6F }, + { 0x1E70, 0x1E71 }, + { 0x1E72, 0x1E73 }, + { 0x1E74, 0x1E75 }, + { 0x1E76, 0x1E77 }, + { 0x1E78, 0x1E79 }, + { 0x1E7A, 0x1E7B }, + { 0x1E7C, 0x1E7D }, + { 0x1E7E, 0x1E7F }, + { 0x1E80, 0x1E81 }, + { 0x1E82, 0x1E83 }, + { 0x1E84, 0x1E85 }, + { 0x1E86, 0x1E87 }, + { 0x1E88, 0x1E89 }, + { 0x1E8A, 0x1E8B }, + { 0x1E8C, 0x1E8D }, + { 0x1E8E, 0x1E8F }, + { 0x1E90, 0x1E91 }, + { 0x1E92, 0x1E93 }, + { 0x1E94, 0x1E95 }, + { 0x1EA0, 0x1EA1 }, + { 0x1EA2, 0x1EA3 }, + { 0x1EA4, 0x1EA5 }, + { 0x1EA6, 0x1EA7 }, + { 0x1EA8, 0x1EA9 }, + { 0x1EAA, 0x1EAB }, + { 0x1EAC, 0x1EAD }, + { 0x1EAE, 0x1EAF }, + { 0x1EB0, 0x1EB1 }, + { 0x1EB2, 0x1EB3 }, + { 0x1EB4, 0x1EB5 }, + { 0x1EB6, 0x1EB7 }, + { 0x1EB8, 0x1EB9 }, + { 0x1EBA, 0x1EBB }, + { 0x1EBC, 0x1EBD }, + { 0x1EBE, 0x1EBF }, + { 0x1EC0, 0x1EC1 }, + { 0x1EC2, 0x1EC3 }, + { 0x1EC4, 0x1EC5 }, + { 0x1EC6, 0x1EC7 }, + { 0x1EC8, 0x1EC9 }, + { 0x1ECA, 0x1ECB }, + { 0x1ECC, 0x1ECD }, + { 0x1ECE, 0x1ECF }, + { 0x1ED0, 0x1ED1 }, + { 0x1ED2, 0x1ED3 }, + { 0x1ED4, 0x1ED5 }, + { 0x1ED6, 0x1ED7 }, + { 0x1ED8, 0x1ED9 }, + { 0x1EDA, 0x1EDB }, + { 0x1EDC, 0x1EDD }, + { 0x1EDE, 0x1EDF }, + { 0x1EE0, 0x1EE1 }, + { 0x1EE2, 0x1EE3 }, + { 0x1EE4, 0x1EE5 }, + { 0x1EE6, 0x1EE7 }, + { 0x1EE8, 0x1EE9 }, + { 0x1EEA, 0x1EEB }, + { 0x1EEC, 0x1EED }, + { 0x1EEE, 0x1EEF }, + { 0x1EF0, 0x1EF1 }, + { 0x1EF2, 0x1EF3 }, + { 0x1EF4, 0x1EF5 }, + { 0x1EF6, 0x1EF7 }, + { 0x1EF8, 0x1EF9 }, + { 0x1F08, 0x1F00 }, + { 0x1F09, 0x1F01 }, + { 0x1F0A, 0x1F02 }, + { 0x1F0B, 0x1F03 }, + { 0x1F0C, 0x1F04 }, + { 0x1F0D, 0x1F05 }, + { 0x1F0E, 0x1F06 }, + { 0x1F0F, 0x1F07 }, + { 0x1F18, 0x1F10 }, + { 0x1F19, 0x1F11 }, + { 0x1F1A, 0x1F12 }, + { 0x1F1B, 0x1F13 }, + { 0x1F1C, 0x1F14 }, + { 0x1F1D, 0x1F15 }, + { 0x1F28, 0x1F20 }, + { 0x1F29, 0x1F21 }, + { 0x1F2A, 0x1F22 }, + { 0x1F2B, 0x1F23 }, + { 0x1F2C, 0x1F24 }, + { 0x1F2D, 0x1F25 }, + { 0x1F2E, 0x1F26 }, + { 0x1F2F, 0x1F27 }, + { 0x1F38, 0x1F30 }, + { 0x1F39, 0x1F31 }, + { 0x1F3A, 0x1F32 }, + { 0x1F3B, 0x1F33 }, + { 0x1F3C, 0x1F34 }, + { 0x1F3D, 0x1F35 }, + { 0x1F3E, 0x1F36 }, + { 0x1F3F, 0x1F37 }, + { 0x1F48, 0x1F40 }, + { 0x1F49, 0x1F41 }, + { 0x1F4A, 0x1F42 }, + { 0x1F4B, 0x1F43 }, + { 0x1F4C, 0x1F44 }, + { 0x1F4D, 0x1F45 }, + { 0x1F59, 0x1F51 }, + { 0x1F5B, 0x1F53 }, + { 0x1F5D, 0x1F55 }, + { 0x1F5F, 0x1F57 }, + { 0x1F68, 0x1F60 }, + { 0x1F69, 0x1F61 }, + { 0x1F6A, 0x1F62 }, + { 0x1F6B, 0x1F63 }, + { 0x1F6C, 0x1F64 }, + { 0x1F6D, 0x1F65 }, + { 0x1F6E, 0x1F66 }, + { 0x1F6F, 0x1F67 }, + { 0x1F88, 0x1F80 }, + { 0x1F89, 0x1F81 }, + { 0x1F8A, 0x1F82 }, + { 0x1F8B, 0x1F83 }, + { 0x1F8C, 0x1F84 }, + { 0x1F8D, 0x1F85 }, + { 0x1F8E, 0x1F86 }, + { 0x1F8F, 0x1F87 }, + { 0x1F98, 0x1F90 }, + { 0x1F99, 0x1F91 }, + { 0x1F9A, 0x1F92 }, + { 0x1F9B, 0x1F93 }, + { 0x1F9C, 0x1F94 }, + { 0x1F9D, 0x1F95 }, + { 0x1F9E, 0x1F96 }, + { 0x1F9F, 0x1F97 }, + { 0x1FA8, 0x1FA0 }, + { 0x1FA9, 0x1FA1 }, + { 0x1FAA, 0x1FA2 }, + { 0x1FAB, 0x1FA3 }, + { 0x1FAC, 0x1FA4 }, + { 0x1FAD, 0x1FA5 }, + { 0x1FAE, 0x1FA6 }, + { 0x1FAF, 0x1FA7 }, + { 0x1FB8, 0x1FB0 }, + { 0x1FB9, 0x1FB1 }, + { 0x1FD8, 0x1FD0 }, + { 0x1FD9, 0x1FD1 }, + { 0x1FE8, 0x1FE0 }, + { 0x1FE9, 0x1FE1 }, + { 0x24B6, 0x24D0 }, + { 0x24B7, 0x24D1 }, + { 0x24B8, 0x24D2 }, + { 0x24B9, 0x24D3 }, + { 0x24BA, 0x24D4 }, + { 0x24BB, 0x24D5 }, + { 0x24BC, 0x24D6 }, + { 0x24BD, 0x24D7 }, + { 0x24BE, 0x24D8 }, + { 0x24BF, 0x24D9 }, + { 0x24C0, 0x24DA }, + { 0x24C1, 0x24DB }, + { 0x24C2, 0x24DC }, + { 0x24C3, 0x24DD }, + { 0x24C4, 0x24DE }, + { 0x24C5, 0x24DF }, + { 0x24C6, 0x24E0 }, + { 0x24C7, 0x24E1 }, + { 0x24C8, 0x24E2 }, + { 0x24C9, 0x24E3 }, + { 0x24CA, 0x24E4 }, + { 0x24CB, 0x24E5 }, + { 0x24CC, 0x24E6 }, + { 0x24CD, 0x24E7 }, + { 0x24CE, 0x24E8 }, + { 0x24CF, 0x24E9 }, + { 0xFF21, 0xFF41 }, + { 0xFF22, 0xFF42 }, + { 0xFF23, 0xFF43 }, + { 0xFF24, 0xFF44 }, + { 0xFF25, 0xFF45 }, + { 0xFF26, 0xFF46 }, + { 0xFF27, 0xFF47 }, + { 0xFF28, 0xFF48 }, + { 0xFF29, 0xFF49 }, + { 0xFF2A, 0xFF4A }, + { 0xFF2B, 0xFF4B }, + { 0xFF2C, 0xFF4C }, + { 0xFF2D, 0xFF4D }, + { 0xFF2E, 0xFF4E }, + { 0xFF2F, 0xFF4F }, + { 0xFF30, 0xFF50 }, + { 0xFF31, 0xFF51 }, + { 0xFF32, 0xFF52 }, + { 0xFF33, 0xFF53 }, + { 0xFF34, 0xFF54 }, + { 0xFF35, 0xFF55 }, + { 0xFF36, 0xFF56 }, + { 0xFF37, 0xFF57 }, + { 0xFF38, 0xFF58 }, + { 0xFF39, 0xFF59 }, + { 0xFF3A, 0xFF5A }, +}; + +static int _find_upper(int ch) { + int low = 0; + int high = CAPS_LEN - 1; + int middle; + + while (low <= high) { + middle = (low + high) / 2; + + if (ch < caps_table[middle][0]) { + high = middle - 1; //search low end of array + } else if (caps_table[middle][0] < ch) { + low = middle + 1; //search high end of array + } else { + return caps_table[middle][1]; + } + } + + return ch; +} + +static int _find_lower(int ch) { + int low = 0; + int high = CAPS_LEN - 2; + int middle; + + while (low <= high) { + middle = (low + high) / 2; + + if (ch < reverse_caps_table[middle][0]) { + high = middle - 1; //search low end of array + } else if (reverse_caps_table[middle][0] < ch) { + low = middle + 1; //search high end of array + } else { + return reverse_caps_table[middle][1]; + } + } + + return ch; +} + +#line 0 + +#line 1 "sfwl/core/mutex.cpp" +/*************************************************************************/ +/* mutex.cpp */ +/* From https://github.com/Relintai/pandemonium_engine (MIT) */ +/*************************************************************************/ + +static Mutex _global_mutex; + +void _global_lock() { + _global_mutex.lock(); +} + +void _global_unlock() { + _global_mutex.unlock(); +} + +#ifndef NO_THREADS + +template class MutexImpl; +template class MutexImpl; + +#endif +#line 0 + +#line 1 "sfwl/core/safe_refcount.cpp" +/*************************************************************************/ +/* safe_refcount.cpp */ +/* From https://github.com/Relintai/pandemonium_engine (MIT) */ +/*************************************************************************/ + +#if defined(DEBUG_ENABLED) && !defined(NO_THREADS) + +// On C++14 we don't have std::atomic::is_always_lockfree, so this is the best we can do +void check_lockless_atomics() { + // Doing the check for the types we actually care about + if (!std::atomic{}.is_lock_free() || !std::atomic{}.is_lock_free() || !std::atomic_bool{}.is_lock_free()) { + WARN_PRINT("Your compiler doesn't seem to support lockless atomics. Performance will be degraded. Please consider upgrading to a different or newer compiler."); + } +} + +#endif +#line 0 + +#line 1 "sfwl/core/sfw_time.cpp" +// ---------------------------------------------------------------------------- +// time + +#if defined(_WIN64) || defined(_WIN32) +#define WIN32_LEAN_AND_MEAN +#include +#include +#else +#include +#include +#endif + +#if 0 +uint64_t SFWTime::time_gpu() { + GLint64 t = 123456789; + glGetInteger64v(GL_TIMESTAMP, &t); + return (uint64_t)t; +} +#endif +uint64_t SFWTime::date() { + //time_t epoch = time(0); + //struct tm *ti = localtime(&epoch); + //return atoi64(va("%04d%02d%02d%02d%02d%02d", ti->tm_year + 1900, ti->tm_mon + 1, ti->tm_mday, ti->tm_hour, ti->tm_min, ti->tm_sec)); + return 0; +} +char *SFWTime::date_string() { + //time_t epoch = time(0); + //struct tm *ti = localtime(&epoch); + //return va("%04d-%02d-%02d %02d:%02d:%02d", ti->tm_year + 1900, ti->tm_mon + 1, ti->tm_mday, ti->tm_hour, ti->tm_min, ti->tm_sec); + return 0; +} +uint64_t SFWTime::date_epoch() { + time_t epoch = time(0); + return epoch; +} +#if 0 +double SFWTime::time_ss() { + return glfwGetTime(); +} +double SFWTime::time_ms() { + return glfwGetTime() * 1000.0; +} +uint64_t SFWTime::time_us() { + return (uint64_t)(glfwGetTime() * 1000000.0); // @fixme: use a high resolution timer instead, or time_gpu below +} +uint64_t SFWTime::sleep_us(uint64_t us) { // @fixme: use a high resolution sleeper instead + return sleep_ms( us / 1000.0 ); +} +double SFWTime::sleep_ms(double ms) { + double now = time_ms(); + if( ms <= 0 ) { +#if defined(_WIN64) || defined(_WIN32) + Sleep(0); // yield +#else + usleep(0); +#endif + } else { +#if defined(_WIN64) || defined(_WIN32) + Sleep(ms); +#else + usleep(ms * 1000); +#endif + } + return time_ms() - now; +} +double sleep_ss(double ss) { + return sleep_ms( ss * 1000 ) / 1000.0; +} +#endif + +// high-perf functions + +#define TIMER_E3 1000ULL +#define TIMER_E6 1000000ULL +#define TIMER_E9 1000000000ULL + +#ifdef CLOCK_MONOTONIC_RAW +#define TIME_MONOTONIC CLOCK_MONOTONIC_RAW +#elif defined CLOCK_MONOTONIC +#define TIME_MONOTONIC CLOCK_MONOTONIC +#else +// #define TIME_MONOTONIC CLOCK_REALTIME // untested +#endif + +static uint64_t nanotimer(uint64_t *out_freq) { + if (out_freq) { +#if defined(_WIN64) || defined(_WIN32) + LARGE_INTEGER li; + QueryPerformanceFrequency(&li); + *out_freq = li.QuadPart; +//#elif is(ANDROID) +// *out_freq = CLOCKS_PER_SEC; +#elif defined TIME_MONOTONIC + *out_freq = TIMER_E9; +#else + *out_freq = TIMER_E6; +#endif + } +#if defined(_WIN64) || defined(_WIN32) + LARGE_INTEGER li; + QueryPerformanceCounter(&li); + return (uint64_t)li.QuadPart; +//#elif is(ANDROID) +// return (uint64_t)clock(); +#elif defined TIME_MONOTONIC + struct timespec ts; + clock_gettime(TIME_MONOTONIC, &ts); + return (TIMER_E9 * (uint64_t)ts.tv_sec) + ts.tv_nsec; +#else + struct timeval tv; + gettimeofday(&tv, NULL); + return (TIMER_E6 * (uint64_t)tv.tv_sec) + tv.tv_usec; +#endif +} + +uint64_t SFWTime::time_ns() { + static thread_local uint64_t epoch = 0; + static thread_local uint64_t freq = 0; + if (!freq) { + epoch = nanotimer(&freq); + } + + uint64_t a = nanotimer(NULL) - epoch; + uint64_t b = TIMER_E9; + uint64_t c = freq; + + // Computes (a*b)/c without overflow, as long as both (a*b) and the overall result fit into 64-bits. + // [ref] https://github.com/rust-lang/rust/blob/3809bbf47c8557bd149b3e52ceb47434ca8378d5/src/libstd/sys_common/mod.rs#L124 + uint64_t q = a / c; + uint64_t r = a % c; + return q * b + r * b / c; +} +uint64_t SFWTime::time_us() { + return time_ns() / TIMER_E3; +} +uint64_t SFWTime::time_ms() { + return time_ns() / TIMER_E6; +} +double SFWTime::time_ss() { + return time_ns() / 1e9; // TIMER_E9; +} +double SFWTime::time_mm() { + return time_ss() / 60; +} +double SFWTime::time_hh() { + return time_mm() / 60; +} + +void SFWTime::sleep_ns(double ns) { +#if defined(_WIN64) || defined(_WIN32) + if (ns >= 100) { + LARGE_INTEGER li; // Windows sleep in 100ns units + HANDLE timer = CreateWaitableTimer(NULL, TRUE, NULL); + li.QuadPart = (LONGLONG)(__int64)(-ns / 100); // Negative for relative time + SetWaitableTimer(timer, &li, 0, NULL, NULL, FALSE); + WaitForSingleObject(timer, INFINITE); + CloseHandle(timer); +#else + if (ns > 0) { + struct timespec wait = { 0 }; + wait.tv_sec = ns / 1e9; + wait.tv_nsec = ns - wait.tv_sec * 1e9; + nanosleep(&wait, NULL); +#endif + } else { +#if defined(_WIN64) || defined(_WIN32) + Sleep(0); // yield, Sleep(0), SwitchToThread +#else + usleep(0); +#endif + } +} +void SFWTime::sleep_us(double us) { + sleep_ns(us * 1e3); +} +void SFWTime::sleep_ms(double ms) { + sleep_ns(ms * 1e6); +} +void SFWTime::sleep_ss(double ss) { + sleep_ns(ss * 1e9); +} +#line 0 + +#line 1 "sfwl/core/memory.cpp" +/*************************************************************************/ +/* memory.cpp */ +/* From https://github.com/Relintai/pandemonium_engine (MIT) */ +/*************************************************************************/ + +void *operator new(size_t p_size, const char *p_description) { + return Memory::alloc_static(p_size, false); +} + +void *operator new(size_t p_size, void *(*p_allocfunc)(size_t p_size)) { + return p_allocfunc(p_size); +} + +#ifdef _MSC_VER +void operator delete(void *p_mem, const char *p_description) { + CRASH_MSG("Call to placement delete should not happen."); +} + +void operator delete(void *p_mem, void *(*p_allocfunc)(size_t p_size)) { + CRASH_MSG("Call to placement delete should not happen."); +} + +void operator delete(void *p_mem, void *p_pointer, size_t check, const char *p_description) { + CRASH_MSG("Call to placement delete should not happen."); +} +#endif + +#ifdef DEBUG_ENABLED +SafeNumeric Memory::mem_usage; +SafeNumeric Memory::max_usage; +#endif + +SafeNumeric Memory::alloc_count; + +void *Memory::alloc_static(size_t p_bytes, bool p_pad_align) { +#ifdef DEBUG_ENABLED + bool prepad = true; +#else + bool prepad = p_pad_align; +#endif + + void *mem = malloc(p_bytes + (prepad ? PAD_ALIGN : 0)); + + ERR_FAIL_COND_V(!mem, nullptr); + + alloc_count.increment(); + + if (prepad) { + uint64_t *s = (uint64_t *)mem; + *s = p_bytes; + + uint8_t *s8 = (uint8_t *)mem; + +#ifdef DEBUG_ENABLED + uint64_t new_mem_usage = mem_usage.add(p_bytes); + max_usage.exchange_if_greater(new_mem_usage); +#endif + return s8 + PAD_ALIGN; + } else { + return mem; + } +} + +void *Memory::realloc_static(void *p_memory, size_t p_bytes, bool p_pad_align) { + if (p_memory == nullptr) { + return alloc_static(p_bytes, p_pad_align); + } + + uint8_t *mem = (uint8_t *)p_memory; + +#ifdef DEBUG_ENABLED + bool prepad = true; +#else + bool prepad = p_pad_align; +#endif + + if (prepad) { + mem -= PAD_ALIGN; + uint64_t *s = (uint64_t *)mem; + +#ifdef DEBUG_ENABLED + if (p_bytes > *s) { + uint64_t new_mem_usage = mem_usage.add(p_bytes - *s); + max_usage.exchange_if_greater(new_mem_usage); + } else { + mem_usage.sub(*s - p_bytes); + } +#endif + + if (p_bytes == 0) { + free(mem); + return nullptr; + } else { + *s = p_bytes; + + mem = (uint8_t *)realloc(mem, p_bytes + PAD_ALIGN); + ERR_FAIL_COND_V(!mem, nullptr); + + s = (uint64_t *)mem; + + *s = p_bytes; + + return mem + PAD_ALIGN; + } + } else { + mem = (uint8_t *)realloc(mem, p_bytes); + + ERR_FAIL_COND_V(mem == nullptr && p_bytes > 0, nullptr); + + return mem; + } +} + +void Memory::free_static(void *p_ptr, bool p_pad_align) { + ERR_FAIL_COND(p_ptr == nullptr); + + uint8_t *mem = (uint8_t *)p_ptr; + +#ifdef DEBUG_ENABLED + bool prepad = true; +#else + bool prepad = p_pad_align; +#endif + + alloc_count.decrement(); + + if (prepad) { + mem -= PAD_ALIGN; + +#ifdef DEBUG_ENABLED + uint64_t *s = (uint64_t *)mem; + mem_usage.sub(*s); +#endif + + free(mem); + } else { + free(mem); + } +} + +uint64_t Memory::get_mem_available() { + return -1; // 0xFFFF... +} + +uint64_t Memory::get_mem_usage() { +#ifdef DEBUG_ENABLED + return mem_usage.get(); +#else + return 0; +#endif +} + +uint64_t Memory::get_mem_max_usage() { +#ifdef DEBUG_ENABLED + return max_usage.get(); +#else + return 0; +#endif +} + +_GlobalNil::_GlobalNil() { + color = 1; + left = this; + right = this; + parent = this; +} + +_GlobalNil _GlobalNilClass::_nil; +#line 0 + +#line 1 "sfwl/core/pool_vector.cpp" +/*************************************************************************/ +/* pool_vector.cpp */ +/* From https://github.com/Relintai/pandemonium_engine (MIT) */ +/*************************************************************************/ + +Mutex pool_vector_lock; + +PoolAllocator *MemoryPool::memory_pool = nullptr; +uint8_t *MemoryPool::pool_memory = nullptr; +size_t *MemoryPool::pool_size = nullptr; + +MemoryPool::Alloc *MemoryPool::allocs = nullptr; +MemoryPool::Alloc *MemoryPool::free_list = nullptr; +uint32_t MemoryPool::alloc_count = 0; +uint32_t MemoryPool::allocs_used = 0; +Mutex MemoryPool::alloc_mutex; + +size_t MemoryPool::total_memory = 0; +size_t MemoryPool::max_memory = 0; + +void MemoryPool::setup(uint32_t p_max_allocs) { + allocs = memnew_arr(Alloc, p_max_allocs); + alloc_count = p_max_allocs; + allocs_used = 0; + + for (uint32_t i = 0; i < alloc_count - 1; i++) { + allocs[i].free_list = &allocs[i + 1]; + } + + free_list = &allocs[0]; +} + +void MemoryPool::cleanup() { + memdelete_arr(allocs); + + ERR_FAIL_COND_MSG(allocs_used > 0, "There are still MemoryPool allocs in use at exit!"); +} +#line 0 + +#line 1 "sfwl/core/pool_allocator.cpp" +/*************************************************************************/ +/* pool_allocator.cpp */ +/* From https://github.com/Relintai/pandemonium_engine (MIT) */ +/*************************************************************************/ + +#define COMPACT_CHUNK(m_entry, m_to_pos) \ + do { \ + void *_dst = &((unsigned char *)pool)[m_to_pos]; \ + void *_src = &((unsigned char *)pool)[(m_entry).pos]; \ + memmove(_dst, _src, aligned((m_entry).len)); \ + (m_entry).pos = m_to_pos; \ + } while (0); + +void PoolAllocator::mt_lock() const { +} + +void PoolAllocator::mt_unlock() const { +} + +bool PoolAllocator::get_free_entry(EntryArrayPos *p_pos) { + if (entry_count == entry_max) { + return false; + } + + for (int i = 0; i < entry_max; i++) { + if (entry_array[i].len == 0) { + *p_pos = i; + return true; + } + } + + ERR_PRINT("Out of memory Chunks!"); + + return false; // +} + +/** + * Find a hole + * @param p_pos The hole is behind the block pointed by this variable upon return. if pos==entry_count, then allocate at end + * @param p_for_size hole size + * @return false if hole found, true if no hole found + */ +bool PoolAllocator::find_hole(EntryArrayPos *p_pos, int p_for_size) { + /* position where previous entry ends. Defaults to zero (begin of pool) */ + + int prev_entry_end_pos = 0; + + for (int i = 0; i < entry_count; i++) { + Entry &entry = entry_array[entry_indices[i]]; + + /* determine hole size to previous entry */ + + int hole_size = entry.pos - prev_entry_end_pos; + + /* determine if what we want fits in that hole */ + if (hole_size >= p_for_size) { + *p_pos = i; + return true; + } + + /* prepare for next one */ + prev_entry_end_pos = entry_end(entry); + } + + /* No holes between entries, check at the end..*/ + + if ((pool_size - prev_entry_end_pos) >= p_for_size) { + *p_pos = entry_count; + return true; + } + + return false; +} + +void PoolAllocator::compact(int p_up_to) { + uint32_t prev_entry_end_pos = 0; + + if (p_up_to < 0) { + p_up_to = entry_count; + } + for (int i = 0; i < p_up_to; i++) { + Entry &entry = entry_array[entry_indices[i]]; + + /* determine hole size to previous entry */ + + int hole_size = entry.pos - prev_entry_end_pos; + + /* if we can compact, do it */ + if (hole_size > 0 && !entry.lock) { + COMPACT_CHUNK(entry, prev_entry_end_pos); + } + + /* prepare for next one */ + prev_entry_end_pos = entry_end(entry); + } +} + +void PoolAllocator::compact_up(int p_from) { + uint32_t next_entry_end_pos = pool_size; // - static_area_size; + + for (int i = entry_count - 1; i >= p_from; i--) { + Entry &entry = entry_array[entry_indices[i]]; + + /* determine hole size to nextious entry */ + + int hole_size = next_entry_end_pos - (entry.pos + aligned(entry.len)); + + /* if we can compact, do it */ + if (hole_size > 0 && !entry.lock) { + COMPACT_CHUNK(entry, (next_entry_end_pos - aligned(entry.len))); + } + + /* prepare for next one */ + next_entry_end_pos = entry.pos; + } +} + +bool PoolAllocator::find_entry_index(EntryIndicesPos *p_map_pos, Entry *p_entry) { + EntryArrayPos entry_pos = entry_max; + + for (int i = 0; i < entry_count; i++) { + if (&entry_array[entry_indices[i]] == p_entry) { + entry_pos = i; + break; + } + } + + if (entry_pos == entry_max) { + return false; + } + + *p_map_pos = entry_pos; + return true; +} + +PoolAllocator::ID PoolAllocator::alloc(int p_size) { + ERR_FAIL_COND_V(p_size < 1, POOL_ALLOCATOR_INVALID_ID); + ERR_FAIL_COND_V(p_size > free_mem, POOL_ALLOCATOR_INVALID_ID); + + mt_lock(); + + if (entry_count == entry_max) { + mt_unlock(); + ERR_PRINT("entry_count==entry_max"); + return POOL_ALLOCATOR_INVALID_ID; + } + + int size_to_alloc = aligned(p_size); + + EntryIndicesPos new_entry_indices_pos; + + if (!find_hole(&new_entry_indices_pos, size_to_alloc)) { + /* No hole could be found, try compacting mem */ + compact(); + /* Then search again */ + + if (!find_hole(&new_entry_indices_pos, size_to_alloc)) { + mt_unlock(); + ERR_FAIL_V_MSG(POOL_ALLOCATOR_INVALID_ID, "Memory can't be compacted further."); + } + } + + EntryArrayPos new_entry_array_pos; + + bool found_free_entry = get_free_entry(&new_entry_array_pos); + + if (!found_free_entry) { + mt_unlock(); + ERR_FAIL_V_MSG(POOL_ALLOCATOR_INVALID_ID, "No free entry found in PoolAllocator."); + } + + /* move all entry indices up, make room for this one */ + for (int i = entry_count; i > new_entry_indices_pos; i--) { + entry_indices[i] = entry_indices[i - 1]; + } + + entry_indices[new_entry_indices_pos] = new_entry_array_pos; + + entry_count++; + + Entry &entry = entry_array[entry_indices[new_entry_indices_pos]]; + + entry.len = p_size; + entry.pos = (new_entry_indices_pos == 0) ? 0 : entry_end(entry_array[entry_indices[new_entry_indices_pos - 1]]); //alloc either at beginning or end of previous + entry.lock = 0; + entry.check = (check_count++) & CHECK_MASK; + free_mem -= size_to_alloc; + if (free_mem < free_mem_peak) { + free_mem_peak = free_mem; + } + + ID retval = (entry_indices[new_entry_indices_pos] << CHECK_BITS) | entry.check; + mt_unlock(); + + //ERR_FAIL_COND_V( (uintptr_t)get(retval)%align != 0, retval ); + + return retval; +} + +PoolAllocator::Entry *PoolAllocator::get_entry(ID p_mem) { + unsigned int check = p_mem & CHECK_MASK; + int entry = p_mem >> CHECK_BITS; + ERR_FAIL_INDEX_V(entry, entry_max, nullptr); + ERR_FAIL_COND_V(entry_array[entry].check != check, nullptr); + ERR_FAIL_COND_V(entry_array[entry].len == 0, nullptr); + + return &entry_array[entry]; +} + +const PoolAllocator::Entry *PoolAllocator::get_entry(ID p_mem) const { + unsigned int check = p_mem & CHECK_MASK; + int entry = p_mem >> CHECK_BITS; + ERR_FAIL_INDEX_V(entry, entry_max, nullptr); + ERR_FAIL_COND_V(entry_array[entry].check != check, nullptr); + ERR_FAIL_COND_V(entry_array[entry].len == 0, nullptr); + + return &entry_array[entry]; +} + +void PoolAllocator::free(ID p_mem) { + mt_lock(); + Entry *e = get_entry(p_mem); + if (!e) { + mt_unlock(); + ERR_PRINT("!e"); + return; + } + if (e->lock) { + mt_unlock(); + ERR_PRINT("e->lock"); + return; + } + + EntryIndicesPos entry_indices_pos; + + bool index_found = find_entry_index(&entry_indices_pos, e); + if (!index_found) { + mt_unlock(); + ERR_FAIL_COND(!index_found); + } + + for (int i = entry_indices_pos; i < (entry_count - 1); i++) { + entry_indices[i] = entry_indices[i + 1]; + } + + entry_count--; + free_mem += aligned(e->len); + e->clear(); + mt_unlock(); +} + +int PoolAllocator::get_size(ID p_mem) const { + int size; + mt_lock(); + + const Entry *e = get_entry(p_mem); + if (!e) { + mt_unlock(); + ERR_PRINT("!e"); + return 0; + } + + size = e->len; + + mt_unlock(); + + return size; +} + +Error PoolAllocator::resize(ID p_mem, int p_new_size) { + mt_lock(); + Entry *e = get_entry(p_mem); + + if (!e) { + mt_unlock(); + ERR_FAIL_COND_V(!e, ERR_INVALID_PARAMETER); + } + + if (needs_locking && e->lock) { + mt_unlock(); + ERR_FAIL_COND_V(e->lock, ERR_ALREADY_IN_USE); + } + + uint32_t alloc_size = aligned(p_new_size); + + if ((uint32_t)aligned(e->len) == alloc_size) { + e->len = p_new_size; + mt_unlock(); + return OK; + } else if (e->len > (uint32_t)p_new_size) { + free_mem += aligned(e->len); + free_mem -= alloc_size; + e->len = p_new_size; + mt_unlock(); + return OK; + } + + //p_new_size = align(p_new_size) + int _free = free_mem; // - static_area_size; + + if (uint32_t(_free + aligned(e->len)) < alloc_size) { + mt_unlock(); + ERR_FAIL_V(ERR_OUT_OF_MEMORY); + }; + + EntryIndicesPos entry_indices_pos; + + bool index_found = find_entry_index(&entry_indices_pos, e); + + if (!index_found) { + mt_unlock(); + ERR_FAIL_COND_V(!index_found, ERR_BUG); + } + + //no need to move stuff around, it fits before the next block + uint32_t next_pos; + if (entry_indices_pos + 1 == entry_count) { + next_pos = pool_size; // - static_area_size; + } else { + next_pos = entry_array[entry_indices[entry_indices_pos + 1]].pos; + }; + + if ((next_pos - e->pos) > alloc_size) { + free_mem += aligned(e->len); + e->len = p_new_size; + free_mem -= alloc_size; + mt_unlock(); + return OK; + } + //it doesn't fit, compact around BEFORE current index (make room behind) + + compact(entry_indices_pos + 1); + + if ((next_pos - e->pos) > alloc_size) { + //now fits! hooray! + free_mem += aligned(e->len); + e->len = p_new_size; + free_mem -= alloc_size; + mt_unlock(); + if (free_mem < free_mem_peak) { + free_mem_peak = free_mem; + } + return OK; + } + + //STILL doesn't fit, compact around AFTER current index (make room after) + + compact_up(entry_indices_pos + 1); + + if ((entry_array[entry_indices[entry_indices_pos + 1]].pos - e->pos) > alloc_size) { + //now fits! hooray! + free_mem += aligned(e->len); + e->len = p_new_size; + free_mem -= alloc_size; + mt_unlock(); + if (free_mem < free_mem_peak) { + free_mem_peak = free_mem; + } + return OK; + } + + mt_unlock(); + ERR_FAIL_V(ERR_OUT_OF_MEMORY); +} + +Error PoolAllocator::lock(ID p_mem) { + if (!needs_locking) { + return OK; + } + mt_lock(); + Entry *e = get_entry(p_mem); + if (!e) { + mt_unlock(); + ERR_PRINT("!e"); + return ERR_INVALID_PARAMETER; + } + e->lock++; + mt_unlock(); + return OK; +} + +bool PoolAllocator::is_locked(ID p_mem) const { + if (!needs_locking) { + return false; + } + + mt_lock(); + const Entry *e = ((PoolAllocator *)(this))->get_entry(p_mem); + if (!e) { + mt_unlock(); + ERR_PRINT("!e"); + return false; + } + bool locked = e->lock; + mt_unlock(); + return locked; +} + +const void *PoolAllocator::get(ID p_mem) const { + if (!needs_locking) { + const Entry *e = get_entry(p_mem); + ERR_FAIL_COND_V(!e, nullptr); + return &pool[e->pos]; + } + + mt_lock(); + const Entry *e = get_entry(p_mem); + + if (!e) { + mt_unlock(); + ERR_FAIL_COND_V(!e, nullptr); + } + if (e->lock == 0) { + mt_unlock(); + ERR_PRINT("e->lock == 0"); + return nullptr; + } + + if ((int)e->pos >= pool_size) { + mt_unlock(); + ERR_PRINT("e->pos<0 || e->pos>=pool_size"); + return nullptr; + } + const void *ptr = &pool[e->pos]; + + mt_unlock(); + + return ptr; +} + +void *PoolAllocator::get(ID p_mem) { + if (!needs_locking) { + Entry *e = get_entry(p_mem); + ERR_FAIL_COND_V(!e, nullptr); + return &pool[e->pos]; + } + + mt_lock(); + Entry *e = get_entry(p_mem); + + if (!e) { + mt_unlock(); + ERR_FAIL_COND_V(!e, nullptr); + } + if (e->lock == 0) { + mt_unlock(); + ERR_PRINT("e->lock == 0"); + return nullptr; + } + + if ((int)e->pos >= pool_size) { + mt_unlock(); + ERR_PRINT("e->pos<0 || e->pos>=pool_size"); + return nullptr; + } + void *ptr = &pool[e->pos]; + + mt_unlock(); + + return ptr; +} +void PoolAllocator::unlock(ID p_mem) { + if (!needs_locking) { + return; + } + mt_lock(); + Entry *e = get_entry(p_mem); + if (!e) { + mt_unlock(); + ERR_FAIL_COND(!e); + } + if (e->lock == 0) { + mt_unlock(); + ERR_PRINT("e->lock == 0"); + return; + } + e->lock--; + mt_unlock(); +} + +int PoolAllocator::get_used_mem() const { + return pool_size - free_mem; +} + +int PoolAllocator::get_free_peak() { + return free_mem_peak; +} + +int PoolAllocator::get_free_mem() { + return free_mem; +} + +void PoolAllocator::create_pool(void *p_mem, int p_size, int p_max_entries) { + pool = (uint8_t *)p_mem; + pool_size = p_size; + + entry_array = memnew_arr(Entry, p_max_entries); + entry_indices = memnew_arr(int, p_max_entries); + entry_max = p_max_entries; + entry_count = 0; + + free_mem = p_size; + free_mem_peak = p_size; + + check_count = 0; +} + +PoolAllocator::PoolAllocator(int p_size, bool p_needs_locking, int p_max_entries) { + mem_ptr = memalloc(p_size); + ERR_FAIL_COND(!mem_ptr); + align = 1; + create_pool(mem_ptr, p_size, p_max_entries); + needs_locking = p_needs_locking; +} + +PoolAllocator::PoolAllocator(void *p_mem, int p_size, int p_align, bool p_needs_locking, int p_max_entries) { + if (p_align > 1) { + uint8_t *mem8 = (uint8_t *)p_mem; + uint64_t ofs = (uint64_t)mem8; + if (ofs % p_align) { + int dif = p_align - (ofs % p_align); + mem8 += p_align - (ofs % p_align); + p_size -= dif; + p_mem = (void *)mem8; + }; + }; + + create_pool(p_mem, p_size, p_max_entries); + needs_locking = p_needs_locking; + align = p_align; + mem_ptr = nullptr; +} + +PoolAllocator::PoolAllocator(int p_align, int p_size, bool p_needs_locking, int p_max_entries) { + ERR_FAIL_COND(p_align < 1); + mem_ptr = Memory::alloc_static(p_size + p_align, true); + uint8_t *mem8 = (uint8_t *)mem_ptr; + uint64_t ofs = (uint64_t)mem8; + if (ofs % p_align) { + mem8 += p_align - (ofs % p_align); + } + create_pool(mem8, p_size, p_max_entries); + needs_locking = p_needs_locking; + align = p_align; +} + +PoolAllocator::~PoolAllocator() { + if (mem_ptr) { + memfree(mem_ptr); + } + + memdelete_arr(entry_array); + memdelete_arr(entry_indices); +} + +#undef COMPACT_CHUNK +#line 0 + +#line 1 "sfwl/core/random_pcg.cpp" +/*************************************************************************/ +/* random_pcg.cpp */ +/* From https://github.com/Relintai/pandemonium_engine (MIT) */ +/*************************************************************************/ + +RandomPCG::RandomPCG(uint64_t p_seed, uint64_t p_inc) : + pcg(), + current_inc(p_inc) { + seed(p_seed); +} + +void RandomPCG::randomize() { + seed((SFWTime::date() + SFWTime::time_us()) * pcg.state + PCG_DEFAULT_INC_64); +} + +double RandomPCG::random(double p_from, double p_to) { + return randd() * (p_to - p_from) + p_from; +} + +float RandomPCG::random(float p_from, float p_to) { + return randf() * (p_to - p_from) + p_from; +} + +int RandomPCG::random(int p_from, int p_to) { + if (p_from == p_to) { + return p_from; + } + return rand(abs(p_from - p_to) + 1) + MIN(p_from, p_to); +} +#line 0 + +#line 1 "sfwl/core/math_funcs.cpp" +/*************************************************************************/ +/* math_funcs.cpp */ +/* From https://github.com/Relintai/pandemonium_engine (MIT) */ +/*************************************************************************/ + +RandomPCG Math::default_rand(RandomPCG::DEFAULT_SEED, RandomPCG::DEFAULT_INC); + +#define PHI 0x9e3779b9 + +uint32_t Math::rand_from_seed(uint64_t *seed) { + RandomPCG rng = RandomPCG(*seed, RandomPCG::DEFAULT_INC); + uint32_t r = rng.rand(); + *seed = rng.get_seed(); + return r; +} + +void Math::seed(uint64_t x) { + default_rand.seed(x); +} + +void Math::randomize() { + default_rand.randomize(); +} + +uint32_t Math::rand() { + return default_rand.rand(); +} + +double Math::randfn(double mean, double deviation) { + return default_rand.randfn(mean, deviation); +} + +int Math::step_decimals(double p_step) { + static const int maxn = 10; + static const double sd[maxn] = { + 0.9999, // somehow compensate for floating point error + 0.09999, + 0.009999, + 0.0009999, + 0.00009999, + 0.000009999, + 0.0000009999, + 0.00000009999, + 0.000000009999, + 0.0000000009999 + }; + + double abs = Math::abs(p_step); + double decs = abs - (int)abs; // Strip away integer part + for (int i = 0; i < maxn; i++) { + if (decs >= sd[i]) { + return i; + } + } + + return 0; +} + +// Only meant for editor usage in float ranges, where a step of 0 +// means that decimal digits should not be limited in String::num. +int Math::range_step_decimals(double p_step) { + if (p_step < 0.0000000000001) { + return 16; // Max value hardcoded in String::num + } + return step_decimals(p_step); +} + +double Math::dectime(double p_value, double p_amount, double p_step) { + double sgn = p_value < 0 ? -1.0 : 1.0; + double val = Math::abs(p_value); + val -= p_amount * p_step; + if (val < 0.0) { + val = 0.0; + } + return val * sgn; +} + +double Math::ease(double p_x, double p_c) { + if (p_x < 0) { + p_x = 0; + } else if (p_x > 1.0) { + p_x = 1.0; + } + if (p_c > 0) { + if (p_c < 1.0) { + return 1.0 - Math::pow(1.0 - p_x, 1.0 / p_c); + } else { + return Math::pow(p_x, p_c); + } + } else if (p_c < 0) { + //inout ease + + if (p_x < 0.5) { + return Math::pow(p_x * 2.0, -p_c) * 0.5; + } else { + return (1.0 - Math::pow(1.0 - (p_x - 0.5) * 2.0, -p_c)) * 0.5 + 0.5; + } + } else { + return 0; // no ease (raw) + } +} + +double Math::stepify(double p_value, double p_step) { + if (p_step != 0) { + p_value = Math::floor(p_value / p_step + 0.5) * p_step; + } + return p_value; +} + +uint32_t Math::larger_prime(uint32_t p_val) { + static const uint32_t primes[] = { + 5, + 13, + 23, + 47, + 97, + 193, + 389, + 769, + 1543, + 3079, + 6151, + 12289, + 24593, + 49157, + 98317, + 196613, + 393241, + 786433, + 1572869, + 3145739, + 6291469, + 12582917, + 25165843, + 50331653, + 100663319, + 201326611, + 402653189, + 805306457, + 1610612741, + 0, + }; + + int idx = 0; + while (true) { + ERR_FAIL_COND_V(primes[idx] == 0, 0); + if (primes[idx] > p_val) { + return primes[idx]; + } + idx++; + } +} + +double Math::random(double from, double to) { + return default_rand.random(from, to); +} + +float Math::random(float from, float to) { + return default_rand.random(from, to); +} + +real_t Math::randomr(real_t from, real_t to) { + return default_rand.randomr(from, to); +} + +int Math::random(int from, int to) { + return default_rand.random(from, to); +} +#line 0 + +#line 1 "sfwl/core/ustring.cpp" +/*************************************************************************/ +/* ustring.cpp */ +/* From https://github.com/Relintai/pandemonium_engine (MIT) */ +/*************************************************************************/ + +#ifdef _MSC_VER +#define _CRT_SECURE_NO_WARNINGS // to disable build-time warning which suggested to use strcpy_s instead strcpy +#endif + +#if defined(MINGW_ENABLED) || defined(_MSC_VER) +#define snprintf _snprintf_s +#endif + +#define MAX_DIGITS 6 +#define UPPERCASE(m_c) (((m_c) >= 'a' && (m_c) <= 'z') ? ((m_c) - ('a' - 'A')) : (m_c)) +#define LOWERCASE(m_c) (((m_c) >= 'A' && (m_c) <= 'Z') ? ((m_c) + ('a' - 'A')) : (m_c)) +#define IS_DIGIT(m_d) ((m_d) >= '0' && (m_d) <= '9') +#define IS_HEX_DIGIT(m_d) (((m_d) >= '0' && (m_d) <= '9') || ((m_d) >= 'a' && (m_d) <= 'f') || ((m_d) >= 'A' && (m_d) <= 'F')) + +#define READING_SIGN 0 +#define READING_INT 1 +#define READING_DEC 2 +#define READING_EXP 3 +#define READING_DONE 4 + +const char CharString::_null = 0; +const char16_t Char16String::_null = 0; +const CharType String::_null = 0; + +static bool _wildcard_match(const CharType *p_pattern, const CharType *p_string, bool p_case_sensitive) { + switch (*p_pattern) { + case '\0': + return !*p_string; + case '*': + return _wildcard_match(p_pattern + 1, p_string, p_case_sensitive) || (*p_string && _wildcard_match(p_pattern, p_string + 1, p_case_sensitive)); + case '?': + return *p_string && (*p_string != '.') && _wildcard_match(p_pattern + 1, p_string + 1, p_case_sensitive); + default: + + return (p_case_sensitive ? (*p_string == *p_pattern) : (_find_upper(*p_string) == _find_upper(*p_pattern))) && _wildcard_match(p_pattern + 1, p_string + 1, p_case_sensitive); + } +} + +static int _humanize_digits(int p_num) { + if (p_num < 100) { + return 2; + } else if (p_num < 1024) { + return 1; + } else { + return 0; + } +} + +bool select_word(const String &p_s, int p_col, int &r_beg, int &r_end) { + const String &s = p_s; + int beg = CLAMP(p_col, 0, s.length()); + int end = beg; + + if (s[beg] > 32 || beg == s.length()) { + bool symbol = beg < s.length() && is_symbol(s[beg]); + + while (beg > 0 && s[beg - 1] > 32 && (symbol == is_symbol(s[beg - 1]))) { + beg--; + } + while (end < s.length() && s[end + 1] > 32 && (symbol == is_symbol(s[end + 1]))) { + end++; + } + + if (end < s.length()) { + end += 1; + } + + r_beg = beg; + r_end = end; + + return true; + } else { + return false; + } +} + +/*************************************************************************/ +/* Char16String */ +/*************************************************************************/ + +bool Char16String::operator<(const Char16String &p_right) const { + if (length() == 0) { + return p_right.length() != 0; + } + + return is_str_less(get_data(), p_right.get_data()); +} + +Char16String &Char16String::operator+=(char16_t p_char) { + const int lhs_len = length(); + resize(lhs_len + 2); + + char16_t *dst = ptrw(); + dst[lhs_len] = p_char; + dst[lhs_len + 1] = 0; + + return *this; +} + +void Char16String::operator=(const char16_t *p_cstr) { + copy_from(p_cstr); +} + +const char16_t *Char16String::get_data() const { + if (size()) { + return &operator[](0); + } else { + return u""; + } +} + +void Char16String::copy_from(const char16_t *p_cstr) { + if (!p_cstr) { + resize(0); + return; + } + + const char16_t *s = p_cstr; + for (; *s; s++) { + } + size_t len = s - p_cstr; + + if (len == 0) { + resize(0); + return; + } + + Error err = resize(++len); // include terminating null char + + ERR_FAIL_COND_MSG(err != OK, "Failed to copy char16_t string."); + + memcpy(ptrw(), p_cstr, len * sizeof(char16_t)); +} + +/*************************************************************************/ +/* CharString */ +/*************************************************************************/ + +bool CharString::operator<(const CharString &p_right) const { + if (length() == 0) { + return p_right.length() != 0; + } + + return is_str_less(get_data(), p_right.get_data()); +} + +CharString &CharString::operator+=(char p_char) { + const int lhs_len = length(); + resize(lhs_len + 2); + + char *dst = ptrw(); + dst[lhs_len] = p_char; + dst[lhs_len + 1] = 0; + + return *this; +} + +void CharString::operator=(const char *p_cstr) { + copy_from(p_cstr); +} + +const char *CharString::get_data() const { + if (size()) { + return &operator[](0); + } else { + return ""; + } +} + +void CharString::copy_from(const char *p_cstr) { + if (!p_cstr) { + resize(0); + return; + } + + size_t len = strlen(p_cstr); + + if (len == 0) { + resize(0); + return; + } + + Error err = resize(++len); // include terminating null char + + ERR_FAIL_COND_MSG(err != OK, "Failed to copy C-string."); + + memcpy(ptrw(), p_cstr, len); +} + +/*************************************************************************/ +/* String */ +/*************************************************************************/ + +void String::copy_from(const char *p_cstr) { + // copy Latin-1 encoded c-string directly + if (!p_cstr) { + resize(0); + return; + } + + const size_t len = strlen(p_cstr); + + if (len == 0) { + resize(0); + return; + } + + resize(len + 1); // include 0 + + CharType *dst = this->ptrw(); + + for (size_t i = 0; i <= len; i++) { + uint8_t c = p_cstr[i] >= 0 ? p_cstr[i] : uint8_t(256 + p_cstr[i]); + if (c == 0 && i < len) { + print_unicode_error("NUL character", true); + dst[i] = 0x20; + } else { + dst[i] = c; + } + } +} + +void String::copy_from(const char *p_cstr, const int p_clip_to) { + // copy Latin-1 encoded c-string directly + if (!p_cstr) { + resize(0); + return; + } + + int len = 0; + const char *ptr = p_cstr; + while ((p_clip_to < 0 || len < p_clip_to) && *(ptr++) != 0) { + len++; + } + + if (len == 0) { + resize(0); + return; + } + + resize(len + 1); // include 0 + + CharType *dst = this->ptrw(); + + for (int i = 0; i < len; i++) { + uint8_t c = p_cstr[i] >= 0 ? p_cstr[i] : uint8_t(256 + p_cstr[i]); + if (c == 0) { + print_unicode_error("NUL character", true); + dst[i] = 0x20; + } else { + dst[i] = c; + } + } + dst[len] = 0; +} + +void String::copy_from(const wchar_t *p_cstr) { +#ifdef WINDOWS_ENABLED + // wchar_t is 16-bit, parse as UTF-16 + parse_utf16((const char16_t *)p_cstr); +#else + // wchar_t is 32-bit, copy directly + copy_from((const CharType *)p_cstr); +#endif +} + +void String::copy_from(const wchar_t *p_cstr, const int p_clip_to) { +#ifdef WINDOWS_ENABLED + // wchar_t is 16-bit, parse as UTF-16 + parse_utf16((const char16_t *)p_cstr, p_clip_to); +#else + // wchar_t is 32-bit, copy directly + copy_from((const CharType *)p_cstr, p_clip_to); +#endif +} + +void String::copy_from(const CharType &p_char) { + if (p_char == 0) { + print_unicode_error("NUL character", true); + return; + } + /* + if ((p_char & 0xfffff800) == 0xd800) { + print_unicode_error(vformat("Unpaired surrogate (%x)", (uint32_t)p_char)); + } + if (p_char > 0x10ffff) { + print_unicode_error(vformat("Invalid unicode codepoint (%x)", (uint32_t)p_char)); + } + */ + + resize(2); + + CharType *dst = ptrw(); + dst[0] = p_char; + dst[1] = 0; +} + +void String::copy_from(const CharType *p_cstr) { + if (!p_cstr) { + resize(0); + return; + } + + int len = 0; + const CharType *ptr = p_cstr; + while (*(ptr++) != 0) { + len++; + } + + if (len == 0) { + resize(0); + return; + } + + copy_from_unchecked(p_cstr, len); +} + +void String::copy_from(const CharType *p_cstr, const int p_clip_to) { + if (!p_cstr) { + resize(0); + return; + } + + int len = 0; + const CharType *ptr = p_cstr; + while ((p_clip_to < 0 || len < p_clip_to) && *(ptr++) != 0) { + len++; + } + + if (len == 0) { + resize(0); + return; + } + + copy_from_unchecked(p_cstr, len); +} + +// assumes the following have already been validated: +// p_char != nullptr +// p_length > 0 +// p_length <= p_char strlen +void String::copy_from_unchecked(const CharType *p_char, const int p_length) { + resize(p_length + 1); + CharType *dst = ptrw(); + dst[p_length] = 0; + + for (int i = 0; i < p_length; i++) { + if (p_char[i] == 0) { + print_unicode_error("NUL character", true); + dst[i] = 0x20; + continue; + } + /* + if ((p_char[i] & 0xfffff800) == 0xd800) { + print_unicode_error(vformat("Unpaired surrogate (%x)", (uint32_t)p_char[i])); + } + if (p_char[i] > 0x10ffff) { + print_unicode_error(vformat("Invalid unicode codepoint (%x)", (uint32_t)p_char[i])); + } + */ + dst[i] = p_char[i]; + } +} + +bool String::operator==(const String &p_str) const { + if (length() != p_str.length()) { + return false; + } + if (empty()) { + return true; + } + + int l = length(); + + const CharType *src = get_data(); + const CharType *dst = p_str.get_data(); + + /* Compare char by char */ + for (int i = 0; i < l; i++) { + if (src[i] != dst[i]) { + return false; + } + } + + return true; +} + +bool String::operator!=(const String &p_str) const { + return !((*this == p_str)); +} + +String String::operator+(const String &p_str) const { + String res = *this; + res += p_str; + return res; +} + +/* +String String::operator+(CharType p_char) const { + String res = *this; + res += p_char; + return res; +} +*/ + +String &String::operator+=(const String &p_str) { + const int lhs_len = length(); + if (lhs_len == 0) { + *this = p_str; + return *this; + } + + const int rhs_len = p_str.length(); + if (rhs_len == 0) { + return *this; + } + + set_length(lhs_len + rhs_len); + + const CharType *src = p_str.get_data(); + CharType *dst = ptrw() + lhs_len; + + memcpy(dst, src, rhs_len * sizeof(CharType)); + + return *this; +} + +String &String::operator+=(CharType p_char) { + if (p_char == 0) { + print_unicode_error("NUL character", true); + return *this; + } + /* + if ((p_char & 0xfffff800) == 0xd800) { + print_unicode_error(vformat("Unpaired surrogate (%x)", (uint32_t)p_char)); + } + if (p_char > 0x10ffff) { + print_unicode_error(vformat("Invalid unicode codepoint (%x)", (uint32_t)p_char)); + } + */ + + const int lhs_len = length(); + set_length(lhs_len + 1); + CharType *dst = ptrw(); + dst[lhs_len] = p_char; + + return *this; +} + +String &String::operator+=(const char *p_str) { + if (!p_str || p_str[0] == 0) { + return *this; + } + + const int lhs_len = length(); + const size_t rhs_len = strlen(p_str); + + set_length(lhs_len + rhs_len); + + CharType *dst = ptrw() + lhs_len; + + for (size_t i = 0; i <= rhs_len; i++) { + uint8_t c = p_str[i] >= 0 ? p_str[i] : uint8_t(256 + p_str[i]); + if (c == 0 && i < rhs_len) { + print_unicode_error("NUL character", true); + dst[i] = 0x20; + } else { + dst[i] = c; + } + } + + return *this; +} + +String &String::operator+=(const wchar_t *p_str) { +#ifdef WINDOWS_ENABLED + // wchar_t is 16-bit + *this += String::utf16((const char16_t *)p_str); +#else + // wchar_t is 32-bit + *this += String((const CharType *)p_str); +#endif + return *this; +} + +String &String::operator+=(const CharType *p_str) { + *this += String(p_str); + return *this; +} + +void String::operator=(const char *p_str) { + copy_from(p_str); +} + +void String::operator=(const CharType *p_str) { + copy_from(p_str); +} + +void String::operator=(const wchar_t *p_str) { + copy_from(p_str); +} + +bool String::operator==(const char *p_str) const { + // compare Latin-1 encoded c-string + int len = 0; + const char *aux = p_str; + + while (*(aux++) != 0) { + len++; + } + + if (length() != len) { + return false; + } + if (empty()) { + return true; + } + + int l = length(); + + const CharType *dst = get_data(); + + // Compare char by char + for (int i = 0; i < l; i++) { + if ((CharType)p_str[i] != dst[i]) { + return false; + } + } + + return true; +} + +bool String::operator==(const wchar_t *p_str) const { +#ifdef WINDOWS_ENABLED + // wchar_t is 16-bit, parse as UTF-16 + return *this == String::utf16((const char16_t *)p_str); +#else + // wchar_t is 32-bit, compare char by char + return *this == (const CharType *)p_str; +#endif +} + +bool String::operator==(const CharType *p_str) const { + int len = 0; + const CharType *aux = p_str; + + while (*(aux++) != 0) { + len++; + } + + if (length() != len) { + return false; + } + if (empty()) { + return true; + } + + int l = length(); + + const CharType *dst = get_data(); + + /* Compare char by char */ + for (int i = 0; i < l; i++) { + if (p_str[i] != dst[i]) { + return false; + } + } + + return true; +} + +bool String::operator==(const StrRange &p_str_range) const { + int len = p_str_range.len; + + if (length() != len) { + return false; + } + if (empty()) { + return true; + } + + const CharType *c_str = p_str_range.c_str; + const CharType *dst = &operator[](0); + + /* Compare char by char */ + for (int i = 0; i < len; i++) { + if (c_str[i] != dst[i]) { + return false; + } + } + + return true; +} + +bool String::operator!=(const char *p_str) const { + return (!(*this == p_str)); +} + +bool String::operator!=(const wchar_t *p_str) const { + return (!(*this == p_str)); +} + +bool String::operator!=(const CharType *p_str) const { + return (!(*this == p_str)); +} + +bool String::operator<(const char *p_str) const { + if (empty() && p_str[0] == 0) { + return false; + } + if (empty()) { + return true; + } + return is_str_less(get_data(), p_str); +} + +bool String::operator<(const wchar_t *p_str) const { + if (empty() && p_str[0] == 0) { + return false; + } + if (empty()) { + return true; + } + +#ifdef WINDOWS_ENABLED + // wchar_t is 16-bit + return is_str_less(get_data(), String::utf16((const char16_t *)p_str).get_data()); +#else + // wchar_t is 32-bit + return is_str_less(get_data(), (const CharType *)p_str); +#endif +} + +bool String::operator<(const CharType *p_str) const { + if (empty() && p_str[0] == 0) { + return false; + } + if (empty()) { + return true; + } + + return is_str_less(get_data(), p_str); +} + +bool String::operator<(const String &p_str) const { + return operator<(p_str.get_data()); +} + +bool String::operator<=(const String &p_str) const { + return !(p_str < *this); +} + +bool String::operator>(const String &p_str) const { + return p_str < *this; +} + +bool String::operator>=(const String &p_str) const { + return !(*this < p_str); +} + +signed char String::nocasecmp_to(const String &p_str) const { + if (empty() && p_str.empty()) { + return 0; + } + if (empty()) { + return -1; + } + if (p_str.empty()) { + return 1; + } + + const CharType *that_str = p_str.get_data(); + const CharType *this_str = get_data(); + + while (true) { + if (*that_str == 0 && *this_str == 0) { + return 0; //we're equal + } else if (*this_str == 0) { + return -1; //if this is empty, and the other one is not, then we're less.. I think? + } else if (*that_str == 0) { + return 1; //otherwise the other one is smaller.. + } else if (_find_upper(*this_str) < _find_upper(*that_str)) { //more than + return -1; + } else if (_find_upper(*this_str) > _find_upper(*that_str)) { //less than + return 1; + } + + this_str++; + that_str++; + } +} + +signed char String::casecmp_to(const String &p_str) const { + if (empty() && p_str.empty()) { + return 0; + } + if (empty()) { + return -1; + } + if (p_str.empty()) { + return 1; + } + + const CharType *that_str = p_str.get_data(); + const CharType *this_str = get_data(); + + while (true) { + if (*that_str == 0 && *this_str == 0) { + return 0; //we're equal + } else if (*this_str == 0) { + return -1; //if this is empty, and the other one is not, then we're less.. I think? + } else if (*that_str == 0) { + return 1; //otherwise the other one is smaller.. + } else if (*this_str < *that_str) { //more than + return -1; + } else if (*this_str > *that_str) { //less than + return 1; + } + + this_str++; + that_str++; + } +} + +signed char String::naturalnocasecmp_to(const String &p_str) const { + const CharType *this_str = get_data(); + const CharType *that_str = p_str.get_data(); + + if (this_str && that_str) { + while (*this_str == '.' || *that_str == '.') { + if (*this_str++ != '.') { + return 1; + } + if (*that_str++ != '.') { + return -1; + } + if (!*that_str) { + return 1; + } + if (!*this_str) { + return -1; + } + } + + while (*this_str) { + if (!*that_str) { + return 1; + } else if (is_digit(*this_str)) { + if (!is_digit(*that_str)) { + return -1; + } + + // Keep ptrs to start of numerical sequences + const CharType *this_substr = this_str; + const CharType *that_substr = that_str; + + // Compare lengths of both numerical sequences, ignoring leading zeros + while (is_digit(*this_str)) { + this_str++; + } + while (is_digit(*that_str)) { + that_str++; + } + while (*this_substr == '0') { + this_substr++; + } + while (*that_substr == '0') { + that_substr++; + } + int this_len = this_str - this_substr; + int that_len = that_str - that_substr; + + if (this_len < that_len) { + return -1; + } else if (this_len > that_len) { + return 1; + } + + // If lengths equal, compare lexicographically + while (this_substr != this_str && that_substr != that_str) { + if (*this_substr < *that_substr) { + return -1; + } else if (*this_substr > *that_substr) { + return 1; + } + this_substr++; + that_substr++; + } + } else if (is_digit(*that_str)) { + return 1; + } else { + if (_find_upper(*this_str) < _find_upper(*that_str)) { //more than + return -1; + } else if (_find_upper(*this_str) > _find_upper(*that_str)) { //less than + return 1; + } + + this_str++; + that_str++; + } + } + if (*that_str) { + return -1; + } + } + + return 0; +} + +const CharType *String::get_data() const { + static const CharType zero = 0; + return size() ? &operator[](0) : &zero; +} + +bool String::is_valid_string() const { + int l = length(); + const CharType *src = get_data(); + bool valid = true; + for (int i = 0; i < l; i++) { + valid = valid && (src[i] < 0xd800 || (src[i] > 0xdfff && src[i] <= 0x10ffff)); + } + return valid; +} + +void String::print_unicode_error(const String &p_message, bool p_critical) const { + /* + if (p_critical) { + print_error(vformat("Unicode parsing error, some characters were replaced with spaces: %s", p_message)); + } else { + print_error(vformat("Unicode parsing error: %s", p_message)); + } + */ +} + +/* complex helpers */ + +String String::substr(int p_from, int p_chars) const { + if (p_chars == -1) { + p_chars = length() - p_from; + } + + if (empty() || p_from < 0 || p_from >= length() || p_chars <= 0) { + return ""; + } + + if ((p_from + p_chars) > length()) { + p_chars = length() - p_from; + } + + if (p_from == 0 && p_chars >= length()) { + return String(*this); + } + + String s = String(); + s.copy_from_unchecked(&get_data()[p_from], p_chars); + return s; +} + +String String::substr_index(const int start_index, const int end_index) const { + int s = length(); + + if (start_index < 0 || start_index >= s || end_index < 0) { + return ""; + } + + if (start_index > end_index) { + return ""; + } + + if (end_index >= s) { + return substr(start_index, (s - 1) - start_index); + } + + return substr(start_index, end_index - start_index); +} + +int String::find(const String &p_str, int p_from) const { + if (p_from < 0) { + return -1; + } + + const int src_len = p_str.length(); + + const int len = length(); + + if (src_len == 0 || len == 0) { + return -1; // won't find anything! + } + + const CharType *src = get_data(); + const CharType *str = p_str.get_data(); + + for (int i = p_from; i <= (len - src_len); i++) { + bool found = true; + for (int j = 0; j < src_len; j++) { + int read_pos = i + j; + + if (read_pos >= len) { + ERR_PRINT("read_pos>=len"); + return -1; + }; + + if (src[read_pos] != str[j]) { + found = false; + break; + } + } + + if (found) { + return i; + } + } + + return -1; +} + +int String::find(const char *p_str, int p_from) const { + if (p_from < 0) { + return -1; + } + + const int len = length(); + + if (len == 0) { + return -1; // won't find anything! + } + + const CharType *src = get_data(); + + int src_len = 0; + while (p_str[src_len] != '\0') { + src_len++; + } + + if (src_len == 1) { + const CharType needle = p_str[0]; + + for (int i = p_from; i < len; i++) { + if (src[i] == needle) { + return i; + } + } + + } else { + for (int i = p_from; i <= (len - src_len); i++) { + bool found = true; + for (int j = 0; j < src_len; j++) { + int read_pos = i + j; + + if (read_pos >= len) { + ERR_PRINT("read_pos>=len"); + return -1; + }; + + if (src[read_pos] != (CharType)p_str[j]) { + found = false; + break; + } + } + + if (found) { + return i; + } + } + } + + return -1; +} + +int String::find_char(const CharType &p_char, int p_from) const { + return _cowdata.find(p_char, p_from); +} + +int String::find_last(const String &p_str) const { + return rfind(p_str); +} + +int String::findn(const String &p_str, int p_from) const { + if (p_from < 0) { + return -1; + } + + int src_len = p_str.length(); + + if (src_len == 0 || length() == 0) { + return -1; // won't find anything! + } + + const CharType *srcd = get_data(); + + for (int i = p_from; i <= (length() - src_len); i++) { + bool found = true; + for (int j = 0; j < src_len; j++) { + int read_pos = i + j; + + if (read_pos >= length()) { + ERR_PRINT("read_pos>=length()"); + return -1; + }; + + CharType src = _find_lower(srcd[read_pos]); + CharType dst = _find_lower(p_str[j]); + + if (src != dst) { + found = false; + break; + } + } + + if (found) { + return i; + } + } + + return -1; +} + +int String::rfind(const String &p_str, int p_from) const { + // establish a limit + int limit = length() - p_str.length(); + if (limit < 0) { + return -1; + } + + // establish a starting point + if (p_from < 0) { + p_from = limit; + } else if (p_from > limit) { + p_from = limit; + } + + int src_len = p_str.length(); + int len = length(); + + if (src_len == 0 || len == 0) { + return -1; // won't find anything! + } + + const CharType *src = get_data(); + + for (int i = p_from; i >= 0; i--) { + bool found = true; + for (int j = 0; j < src_len; j++) { + int read_pos = i + j; + + if (read_pos >= len) { + ERR_PRINT("read_pos>=len"); + return -1; + }; + + if (src[read_pos] != p_str[j]) { + found = false; + break; + } + } + + if (found) { + return i; + } + } + + return -1; +} + +int String::rfindn(const String &p_str, int p_from) const { + // establish a limit + int limit = length() - p_str.length(); + if (limit < 0) { + return -1; + } + + // establish a starting point + if (p_from < 0) { + p_from = limit; + } else if (p_from > limit) { + p_from = limit; + } + + int src_len = p_str.length(); + int len = length(); + + if (src_len == 0 || len == 0) { + return -1; // won't find anything! + } + + const CharType *src = get_data(); + + for (int i = p_from; i >= 0; i--) { + bool found = true; + for (int j = 0; j < src_len; j++) { + int read_pos = i + j; + + if (read_pos >= len) { + ERR_PRINT("read_pos>=len"); + return -1; + }; + + CharType srcc = _find_lower(src[read_pos]); + CharType dstc = _find_lower(p_str[j]); + + if (srcc != dstc) { + found = false; + break; + } + } + + if (found) { + return i; + } + } + + return -1; +} + +int String::findmk(const Vector &p_keys, int p_from, int *r_key) const { + if (p_from < 0) { + return -1; + } + if (p_keys.size() == 0) { + return -1; + } + + //int src_len=p_str.length(); + const String *keys = &p_keys[0]; + int key_count = p_keys.size(); + int len = length(); + + if (len == 0) { + return -1; // won't find anything! + } + + const CharType *src = get_data(); + + for (int i = p_from; i < len; i++) { + bool found = true; + for (int k = 0; k < key_count; k++) { + found = true; + if (r_key) { + *r_key = k; + } + const CharType *cmp = keys[k].get_data(); + int l = keys[k].length(); + + for (int j = 0; j < l; j++) { + int read_pos = i + j; + + if (read_pos >= len) { + found = false; + break; + }; + + if (src[read_pos] != cmp[j]) { + found = false; + break; + } + } + if (found) { + break; + } + } + + if (found) { + return i; + } + } + + return -1; +} + +int String::find_first_difference_index(const String &p_str) const { + const int olen = p_str.length(); + const int len = length(); + const int c = len < olen ? len : olen; + + const CharType *p = get_data(); + const CharType *op = p_str.get_data(); + + for (int i = 0; i < c; ++i) { + if (p[i] != op[i]) { + return i; + } + } + + return c; +} + +bool String::is_word_at(const int index, const char *p_str) const { + int size = length(); + + ERR_FAIL_INDEX_V(index, size, false); + + int i = 0; + + while (p_str[i] != '\0') { + int iind = index + i; + + if (iind >= size) { + return false; + } + + if (operator[](iind) != (CharType)p_str[i]) { + return false; + } + + ++i; + } + + return true; +} +bool String::is_word_at(const int index, const String &p_str) const { + int size = length(); + + ERR_FAIL_INDEX_V(index, size, false); + + if (index + p_str.length() >= size) { + return false; + } + + for (int i = 0; i < p_str.length(); ++i) { + int iind = index + i; + + if (operator[](iind) != p_str[i]) { + return false; + } + } + + return true; +} + +bool String::match(const String &p_wildcard) const { + if (!p_wildcard.length() || !length()) { + return false; + } + + return _wildcard_match(p_wildcard.get_data(), get_data(), true); +} + +bool String::matchn(const String &p_wildcard) const { + if (!p_wildcard.length() || !length()) { + return false; + } + return _wildcard_match(p_wildcard.get_data(), get_data(), false); +} + +bool String::begins_with(const String &p_string) const { + int l = p_string.length(); + if (l > length()) { + return false; + } + + if (l == 0) { + return true; + } + + const CharType *p = &p_string[0]; + const CharType *s = &operator[](0); + + for (int i = 0; i < l; i++) { + if (p[i] != s[i]) { + return false; + } + } + + return true; +} + +bool String::begins_with(const char *p_string) const { + int l = length(); + if (l == 0 || !p_string) { + return false; + } + + const CharType *str = &operator[](0); + int i = 0; + + while (*p_string && i < l) { + if ((CharType)(*p_string) != str[i]) { + return false; + } + i++; + p_string++; + } + + return *p_string == 0; +} + +bool String::ends_with(const String &p_string) const { + int l = p_string.length(); + if (l > length()) { + return false; + } + + if (l == 0) { + return true; + } + + const CharType *p = &p_string[0]; + const CharType *s = &operator[](length() - l); + + for (int i = 0; i < l; i++) { + if (p[i] != s[i]) { + return false; + } + } + + return true; +} + +bool String::is_enclosed_in(const String &p_string) const { + return begins_with(p_string) && ends_with(p_string); +} + +bool String::is_subsequence_of(const String &p_string) const { + return _base_is_subsequence_of(p_string, false); +} + +bool String::is_subsequence_ofi(const String &p_string) const { + return _base_is_subsequence_of(p_string, true); +} + +bool String::is_quoted() const { + return is_enclosed_in("\"") || is_enclosed_in("'"); +} + +Vector String::bigrams() const { + int n_pairs = length() - 1; + Vector b; + if (n_pairs <= 0) { + return b; + } + b.resize(n_pairs); + for (int i = 0; i < n_pairs; i++) { + b.write[i] = substr(i, 2); + } + return b; +} + +// Similarity according to Sorensen-Dice coefficient +float String::similarity(const String &p_string) const { + if (operator==(p_string)) { + // Equal strings are totally similar + return 1.0f; + } + if (length() < 2 || p_string.length() < 2) { + // No way to calculate similarity without a single bigram + return 0.0f; + } + + Vector src_bigrams = bigrams(); + Vector tgt_bigrams = p_string.bigrams(); + + int src_size = src_bigrams.size(); + int tgt_size = tgt_bigrams.size(); + + float sum = src_size + tgt_size; + float inter = 0; + for (int i = 0; i < src_size; i++) { + for (int j = 0; j < tgt_size; j++) { + if (src_bigrams[i] == tgt_bigrams[j]) { + inter++; + break; + } + } + } + + return (2.0f * inter) / sum; +} + +/* +String String::format(const Variant &values, String placeholder) const { + String new_string = String(this->ptr()); + + if (values.get_type() == Variant::ARRAY) { + Array values_arr = values; + + for (int i = 0; i < values_arr.size(); i++) { + String i_as_str = String::num_int64(i); + + if (values_arr[i].get_type() == Variant::ARRAY) { //Array in Array structure [["name","RobotGuy"],[0,"pandemonium"],["strength",9000.91]] + Array value_arr = values_arr[i]; + + if (value_arr.size() == 2) { + Variant v_key = value_arr[0]; + String key = v_key; + + Variant v_val = value_arr[1]; + String val = v_val; + + new_string = new_string.replace(placeholder.replace("_", key), val); + } else { + ERR_PRINT(String("STRING.format Inner Array size != 2 ").ascii().get_data()); + } + } else { //Array structure ["RobotGuy","Logis","rookie"] + Variant v_val = values_arr[i]; + String val = v_val; + + if (placeholder.find("_") > -1) { + new_string = new_string.replace(placeholder.replace("_", i_as_str), val); + } else { + new_string = new_string.replace_first(placeholder, val); + } + } + } + } else if (values.get_type() == Variant::DICTIONARY) { + Dictionary d = values; + List keys; + d.get_key_list(&keys); + + for (List::Element *E = keys.front(); E; E = E->next()) { + String key = E->get(); + String val = d[E->get()]; + + new_string = new_string.replace(placeholder.replace("_", key), val); + } + } else { + ERR_PRINT(String("Invalid type: use Array or Dictionary.").ascii().get_data()); + } + + return new_string; +} +*/ + +String String::replace_first(const String &p_key, const String &p_with) const { + int pos = find(p_key); + if (pos >= 0) { + return substr(0, pos) + p_with + substr(pos + p_key.length(), length()); + } + + return *this; +} + +String String::replace(const String &p_key, const String &p_with) const { + String new_string; + int search_from = 0; + int result = 0; + + while ((result = find(p_key, search_from)) >= 0) { + new_string += substr(search_from, result - search_from); + new_string += p_with; + search_from = result + p_key.length(); + } + + if (search_from == 0) { + return *this; + } + + new_string += substr(search_from, length() - search_from); + + return new_string; +} + +String String::replace(const char *p_key, const char *p_with) const { + String new_string; + int search_from = 0; + int result = 0; + + while ((result = find(p_key, search_from)) >= 0) { + new_string += substr(search_from, result - search_from); + new_string += p_with; + int k = 0; + while (p_key[k] != '\0') { + k++; + } + search_from = result + k; + } + + if (search_from == 0) { + return *this; + } + + new_string += substr(search_from, length() - search_from); + + return new_string; +} + +String String::replacen(const String &p_key, const String &p_with) const { + String new_string; + int search_from = 0; + int result = 0; + + while ((result = findn(p_key, search_from)) >= 0) { + new_string += substr(search_from, result - search_from); + new_string += p_with; + search_from = result + p_key.length(); + } + + if (search_from == 0) { + return *this; + } + + new_string += substr(search_from, length() - search_from); + return new_string; +} + +String String::newline_to_br() const { + String r = replace("\r\n", "
"); + return r.replace("\n", "
"); +} + +String String::repeat(int p_count) const { + ERR_FAIL_COND_V_MSG(p_count < 0, "", "Parameter count should be a positive number."); + + int len = length(); + String new_string = *this; + new_string.resize(p_count * len + 1); + + CharType *dst = new_string.ptrw(); + int offset = 1; + int stride = 1; + while (offset < p_count) { + memcpy(dst + offset * len, dst, stride * len * sizeof(CharType)); + offset += stride; + stride = MIN(stride * 2, p_count - offset); + } + dst[p_count * len] = _null; + + return new_string; +} + +String String::insert(int p_at_pos, const String &p_string) const { + if (p_at_pos < 0) { + return *this; + } + + if (p_at_pos > length()) { + p_at_pos = length(); + } + + String pre; + if (p_at_pos > 0) { + pre = substr(0, p_at_pos); + } + + String post; + if (p_at_pos < length()) { + post = substr(p_at_pos, length() - p_at_pos); + } + + return pre + p_string + post; +} + +String String::pad_decimals(int p_digits) const { + String s = *this; + int c = s.find("."); + + if (c == -1) { + if (p_digits <= 0) { + return s; + } + s += "."; + c = s.length() - 1; + } else { + if (p_digits <= 0) { + return s.substr(0, c); + } + } + + if (s.length() - (c + 1) > p_digits) { + s = s.substr(0, c + p_digits + 1); + } else { + while (s.length() - (c + 1) < p_digits) { + s += "0"; + } + } + return s; +} + +String String::pad_zeros(int p_digits) const { + String s = *this; + int end = s.find("."); + + if (end == -1) { + end = s.length(); + } + + if (end == 0) { + return s; + } + + int begin = 0; + + while (begin < end && (s[begin] < '0' || s[begin] > '9')) { + begin++; + } + + if (begin >= end) { + return s; + } + + while (end - begin < p_digits) { + s = s.insert(begin, "0"); + end++; + } + + return s; +} + +String String::trim_prefix(const String &p_prefix) const { + String s = *this; + if (s.begins_with(p_prefix)) { + return s.substr(p_prefix.length(), s.length() - p_prefix.length()); + } + return s; +} + +String String::trim_suffix(const String &p_suffix) const { + String s = *this; + if (s.ends_with(p_suffix)) { + return s.substr(0, s.length() - p_suffix.length()); + } + return s; +} + +// Left-pad with a character. +String String::lpad(int min_length, const String &character) const { + String s = *this; + int padding = min_length - s.length(); + if (padding > 0) { + for (int i = 0; i < padding; i++) { + s = character + s; + } + } + + return s; +} + +// Right-pad with a character. +String String::rpad(int min_length, const String &character) const { + String s = *this; + int padding = min_length - s.length(); + if (padding > 0) { + for (int i = 0; i < padding; i++) { + s = s + character; + } + } + + return s; +} + +String String::quote(String quotechar) const { + return quotechar + *this + quotechar; +} + +String String::unquote() const { + if (!is_quoted()) { + return *this; + } + + return substr(1, length() - 2); +} + +String String::num(double p_num, int p_decimals) { + if (Math::is_nan(p_num)) { + return "nan"; + } + + if (Math::is_inf(p_num)) { + if (signbit(p_num)) { + return "-inf"; + } else { + return "inf"; + } + } + +#ifndef NO_USE_STDLIB + + if (p_decimals > 16) { + p_decimals = 16; + } + + char fmt[7]; + fmt[0] = '%'; + fmt[1] = '.'; + + if (p_decimals < 0) { + fmt[1] = 'l'; + fmt[2] = 'f'; + fmt[3] = 0; + + } else if (p_decimals < 10) { + fmt[2] = '0' + p_decimals; + fmt[3] = 'l'; + fmt[4] = 'f'; + fmt[5] = 0; + } else { + fmt[2] = '0' + (p_decimals / 10); + fmt[3] = '0' + (p_decimals % 10); + fmt[4] = 'l'; + fmt[5] = 'f'; + fmt[6] = 0; + } + char buf[256]; + +#if defined(__GNUC__) || defined(_MSC_VER) + snprintf(buf, 256, fmt, p_num); +#else + sprintf(buf, fmt, p_num); +#endif + + buf[255] = 0; + //destroy trailing zeroes + { + bool period = false; + int z = 0; + while (buf[z]) { + if (buf[z] == '.') { + period = true; + } + z++; + } + + if (period) { + z--; + while (z > 0) { + if (buf[z] == '0') { + buf[z] = 0; + } else if (buf[z] == '.') { + buf[z] = 0; + break; + } else { + break; + } + + z--; + } + } + } + + return buf; +#else + + String s; + String sd; + /* integer part */ + + bool neg = p_num < 0; + p_num = ABS(p_num); + int intn = (int)p_num; + + /* decimal part */ + + if (p_decimals > 0 || (p_decimals == -1 && (int)p_num != p_num)) { + double dec = p_num - (double)((int)p_num); + + int digit = 0; + if (p_decimals > MAX_DIGITS) + p_decimals = MAX_DIGITS; + + int dec_int = 0; + int dec_max = 0; + + while (true) { + dec *= 10.0; + dec_int = dec_int * 10 + (int)dec % 10; + dec_max = dec_max * 10 + 9; + digit++; + + if (p_decimals == -1) { + if (digit == MAX_DIGITS) //no point in going to infinite + break; + + if ((dec - (double)((int)dec)) < 1e-6) + break; + } + + if (digit == p_decimals) + break; + } + dec *= 10; + int last = (int)dec % 10; + + if (last > 5) { + if (dec_int == dec_max) { + dec_int = 0; + intn++; + } else { + dec_int++; + } + } + + String decimal; + for (int i = 0; i < digit; i++) { + char num[2] = { 0, 0 }; + num[0] = '0' + dec_int % 10; + decimal = num + decimal; + dec_int /= 10; + } + sd = '.' + decimal; + } + + if (intn == 0) + + s = "0"; + else { + while (intn) { + CharType num = '0' + (intn % 10); + intn /= 10; + s = num + s; + } + } + + s = s + sd; + if (neg) + s = "-" + s; + return s; +#endif +} + +String String::num_scientific(double p_num) { + if (Math::is_nan(p_num)) { + return "nan"; + } + + if (Math::is_inf(p_num)) { + if (signbit(p_num)) { + return "-inf"; + } else { + return "inf"; + } + } + +#ifndef NO_USE_STDLIB + + char buf[256]; + +#if defined(__GNUC__) || defined(_MSC_VER) + +#if defined(__MINGW32__) && defined(_TWO_DIGIT_EXPONENT) && !defined(_UCRT) + // MinGW requires _set_output_format() to conform to C99 output for printf + unsigned int old_exponent_format = _set_output_format(_TWO_DIGIT_EXPONENT); +#endif + snprintf(buf, 256, "%lg", p_num); + +#if defined(__MINGW32__) && defined(_TWO_DIGIT_EXPONENT) && !defined(_UCRT) + _set_output_format(old_exponent_format); +#endif + +#else + sprintf(buf, "%.16lg", p_num); +#endif + + buf[255] = 0; + + return buf; +#else + + return String::num(p_num); +#endif +} + +String String::num_real(double p_num) { + if (Math::is_nan(p_num)) { + return "nan"; + } + + if (Math::is_inf(p_num)) { + if (signbit(p_num)) { + return "-inf"; + } else { + return "inf"; + } + } + + String s; + String sd; + /* integer part */ + + bool neg = p_num < 0; + p_num = ABS(p_num); + int intn = (int)p_num; + + /* decimal part */ + + if ((int)p_num != p_num) { + double dec = p_num - (double)((int)p_num); + + int digit = 0; + int decimals = MAX_DIGITS; + + int dec_int = 0; + int dec_max = 0; + + while (true) { + dec *= 10.0; + dec_int = dec_int * 10 + (int)dec % 10; + dec_max = dec_max * 10 + 9; + digit++; + + if ((dec - (double)((int)dec)) < 1e-6) { + break; + } + + if (digit == decimals) { + break; + } + } + + dec *= 10; + int last = (int)dec % 10; + + if (last > 5) { + if (dec_int == dec_max) { + dec_int = 0; + intn++; + } else { + dec_int++; + } + } + + String decimal; + for (int i = 0; i < digit; i++) { + char num[2] = { 0, 0 }; + num[0] = '0' + dec_int % 10; + decimal = num + decimal; + dec_int /= 10; + } + sd = '.' + decimal; + } else { + sd = ".0"; + } + + if (intn == 0) { + s = "0"; + } else { + while (intn) { + CharType num = '0' + (intn % 10); + intn /= 10; + s = num + s; + } + } + + s = s + sd; + if (neg) { + s = "-" + s; + } + return s; +} + +String String::num_int64(int64_t p_num, int base, bool capitalize_hex) { + bool sign = p_num < 0; + + int64_t n = p_num; + + int chars = 0; + do { + n /= base; + chars++; + } while (n); + + if (sign) { + chars++; + } + String s; + s.resize(chars + 1); + CharType *c = s.ptrw(); + c[chars] = 0; + n = p_num; + do { + int mod = ABS(n % base); + if (mod >= 10) { + char a = (capitalize_hex ? 'A' : 'a'); + c[--chars] = a + (mod - 10); + } else { + c[--chars] = '0' + mod; + } + + n /= base; + } while (n); + + if (sign) { + c[0] = '-'; + } + + return s; +} + +String String::num_uint64(uint64_t p_num, int base, bool capitalize_hex) { + uint64_t n = p_num; + + int chars = 0; + do { + n /= base; + chars++; + } while (n); + + String s; + s.resize(chars + 1); + CharType *c = s.ptrw(); + c[chars] = 0; + n = p_num; + do { + int mod = n % base; + if (mod >= 10) { + char a = (capitalize_hex ? 'A' : 'a'); + c[--chars] = a + (mod - 10); + } else { + c[--chars] = '0' + mod; + } + + n /= base; + } while (n); + + return s; +} + +String String::chr(CharType p_char) { + CharType c[2] = { p_char, 0 }; + return String(c); +} + +String String::md5(const uint8_t *p_md5) { + return String::hex_encode_buffer(p_md5, 16); +} + +String String::hex_encode_buffer(const uint8_t *p_buffer, int p_len) { + static const char hex[16] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' }; + + String ret; + char v[2] = { 0, 0 }; + + for (int i = 0; i < p_len; i++) { + v[0] = hex[p_buffer[i] >> 4]; + ret += v; + v[0] = hex[p_buffer[i] & 0xF]; + ret += v; + } + + return ret; +} + +String String::bool_num(bool p_val) { + if (p_val) { + return "1"; + } else { + return "0"; + } +} + +String String::bool_str(bool p_val) { + if (p_val) { + return "true"; + } else { + return "false"; + } +} + +bool String::is_numeric() const { + if (length() == 0) { + return false; + }; + + int s = 0; + if (operator[](0) == '-') { + ++s; + } + bool dot = false; + for (int i = s; i < length(); i++) { + CharType c = operator[](i); + if (c == '.') { + if (dot) { + return false; + }; + dot = true; + continue; + } + if (c < '0' || c > '9') { + return false; + }; + }; + + return true; // TODO: Use the parser below for this instead +}; + +bool String::is_zero() const { + int size = length(); + + if (size == 0) { + return false; + } + + int starti = 0; + + if (operator[](0) == '-') { + starti += 1; + } + + bool had_dot = false; + for (int i = starti; i < size; ++i) { + CharType c = operator[](i); + + if (c == '.') { + if (!had_dot) { + had_dot = true; + continue; + } else { + return false; + } + } + + if (c != '0') { + return false; + } + } + + return true; +} + +String String::capitalize() const { + String aux = this->camelcase_to_underscore(true).replace("_", " ").strip_edges(); + String cap; + for (int i = 0; i < aux.get_slice_count(" "); i++) { + String slice = aux.get_slicec(' ', i); + if (slice.length() > 0) { + slice[0] = _find_upper(slice[0]); + if (i > 0) { + cap += " "; + } + cap += slice; + } + } + + return cap; +} + +String String::camelcase_to_underscore(bool lowercase) const { + const CharType *cstr = get_data(); + String new_string; + const char A = 'A', Z = 'Z'; + const char a = 'a', z = 'z'; + int start_index = 0; + + for (int i = 1; i < this->size(); i++) { + bool is_upper = cstr[i] >= A && cstr[i] <= Z; + bool is_number = cstr[i] >= '0' && cstr[i] <= '9'; + bool are_next_2_lower = false; + bool is_next_lower = false; + bool is_next_number = false; + bool was_precedent_upper = cstr[i - 1] >= A && cstr[i - 1] <= Z; + bool was_precedent_number = cstr[i - 1] >= '0' && cstr[i - 1] <= '9'; + + if (i + 2 < this->size()) { + are_next_2_lower = cstr[i + 1] >= a && cstr[i + 1] <= z && cstr[i + 2] >= a && cstr[i + 2] <= z; + } + + if (i + 1 < this->size()) { + is_next_lower = cstr[i + 1] >= a && cstr[i + 1] <= z; + is_next_number = cstr[i + 1] >= '0' && cstr[i + 1] <= '9'; + } + + const bool cond_a = is_upper && !was_precedent_upper && !was_precedent_number; + const bool cond_b = was_precedent_upper && is_upper && are_next_2_lower; + const bool cond_c = is_number && !was_precedent_number; + const bool can_break_number_letter = is_number && !was_precedent_number && is_next_lower; + const bool can_break_letter_number = !is_number && was_precedent_number && (is_next_lower || is_next_number); + + bool should_split = cond_a || cond_b || cond_c || can_break_number_letter || can_break_letter_number; + if (should_split) { + new_string += this->substr(start_index, i - start_index) + "_"; + start_index = i; + } + } + + new_string += this->substr(start_index, this->size() - start_index); + return lowercase ? new_string.to_lower() : new_string; +} + +int String::get_slice_count(String p_splitter) const { + if (empty()) { + return 0; + } + if (p_splitter.empty()) { + return 0; + } + + int pos = 0; + int slices = 1; + + while ((pos = find(p_splitter, pos)) >= 0) { + slices++; + pos += p_splitter.length(); + } + + return slices; +} + +String String::get_slice(String p_splitter, int p_slice) const { + if (empty() || p_splitter.empty()) { + return ""; + } + + int pos = 0; + int prev_pos = 0; + //int slices=1; + if (p_slice < 0) { + return ""; + } + if (find(p_splitter) == -1) { + return *this; + } + + int i = 0; + while (true) { + pos = find(p_splitter, pos); + if (pos == -1) { + pos = length(); //reached end + } + + int from = prev_pos; + //int to=pos; + + if (p_slice == i) { + return substr(from, pos - from); + } + + if (pos == length()) { //reached end and no find + break; + } + pos += p_splitter.length(); + prev_pos = pos; + i++; + } + + return ""; //no find! +} + +String String::get_slicec(CharType p_splitter, int p_slice) const { + if (empty()) { + return String(); + } + + if (p_slice < 0) { + return String(); + } + + const CharType *c = this->ptr(); + int i = 0; + int prev = 0; + int count = 0; + while (true) { + if (c[i] == 0 || c[i] == p_splitter) { + if (p_slice == count) { + return substr(prev, i - prev); + } else if (c[i] == 0) { + return String(); + } else { + count++; + prev = i + 1; + } + } + + i++; + } +} + +Vector String::split(const String &p_splitter, bool p_allow_empty, int p_maxsplit) const { + Vector ret; + int from = 0; + int len = length(); + + while (true) { + int end = find(p_splitter, from); + if (end < 0) { + end = len; + } + if (p_allow_empty || (end > from)) { + if (p_maxsplit <= 0) { + ret.push_back(substr(from, end - from)); + } else { + // Put rest of the string and leave cycle. + if (p_maxsplit == ret.size()) { + ret.push_back(substr(from, len)); + break; + } + + // Otherwise, push items until positive limit is reached. + ret.push_back(substr(from, end - from)); + } + } + + if (end == len) { + break; + } + + from = end + p_splitter.length(); + } + + return ret; +} + +Vector String::rsplit(const String &p_splitter, bool p_allow_empty, int p_maxsplit) const { + Vector ret; + const int len = length(); + int remaining_len = len; + + while (true) { + if (remaining_len < p_splitter.length() || (p_maxsplit > 0 && p_maxsplit == ret.size())) { + // no room for another splitter or hit max splits, push what's left and we're done + if (p_allow_empty || remaining_len > 0) { + ret.push_back(substr(0, remaining_len)); + } + break; + } + + int left_edge = rfind(p_splitter, remaining_len - p_splitter.length()); + + if (left_edge < 0) { + // no more splitters, we're done + ret.push_back(substr(0, remaining_len)); + break; + } + + int substr_start = left_edge + p_splitter.length(); + if (p_allow_empty || substr_start < remaining_len) { + ret.push_back(substr(substr_start, remaining_len - substr_start)); + } + + remaining_len = left_edge; + } + + ret.invert(); + return ret; +} + +Vector String::split_spaces() const { + Vector ret; + int from = 0; + int i = 0; + int len = length(); + if (len == 0) { + return ret; + } + + bool inside = false; + + while (true) { + bool empty = operator[](i) < 33; + + if (i == 0) { + inside = !empty; + } + + if (!empty && !inside) { + inside = true; + from = i; + } + + if (empty && inside) { + ret.push_back(substr(from, i - from)); + inside = false; + } + + if (i == len) { + break; + } + i++; + } + + return ret; +} + +Vector String::split_floats(const String &p_splitter, bool p_allow_empty) const { + Vector ret; + int from = 0; + int len = length(); + + while (true) { + int end = find(p_splitter, from); + if (end < 0) { + end = len; + } + if (p_allow_empty || (end > from)) { + ret.push_back(String::to_double(&get_data()[from])); + } + + if (end == len) { + break; + } + + from = end + p_splitter.length(); + } + + return ret; +} + +Vector String::split_floats_mk(const Vector &p_splitters, bool p_allow_empty) const { + Vector ret; + int from = 0; + int len = length(); + + while (true) { + int idx; + int end = findmk(p_splitters, from, &idx); + int spl_len = 1; + if (end < 0) { + end = len; + } else { + spl_len = p_splitters[idx].length(); + } + + if (p_allow_empty || (end > from)) { + ret.push_back(String::to_double(&get_data()[from])); + } + + if (end == len) { + break; + } + + from = end + spl_len; + } + + return ret; +} + +Vector String::split_ints(const String &p_splitter, bool p_allow_empty) const { + Vector ret; + int from = 0; + int len = length(); + + while (true) { + int end = find(p_splitter, from); + if (end < 0) { + end = len; + } + if (p_allow_empty || (end > from)) { + ret.push_back(String::to_int(&get_data()[from], end - from)); + } + + if (end == len) { + break; + } + + from = end + p_splitter.length(); + } + + return ret; +} + +Vector String::split_ints_mk(const Vector &p_splitters, bool p_allow_empty) const { + Vector ret; + int from = 0; + int len = length(); + + while (true) { + int idx; + int end = findmk(p_splitters, from, &idx); + int spl_len = 1; + if (end < 0) { + end = len; + } else { + spl_len = p_splitters[idx].length(); + } + + if (p_allow_empty || (end > from)) { + ret.push_back(String::to_int(&get_data()[from], end - from)); + } + + if (end == len) { + break; + } + + from = end + spl_len; + } + + return ret; +} + +String String::join(const Vector &parts) const { + String ret; + for (int i = 0; i < parts.size(); ++i) { + if (i > 0) { + ret += *this; + } + ret += parts[i]; + } + return ret; +} + +CharType String::char_uppercase(CharType p_char) { + return _find_upper(p_char); +} + +CharType String::char_lowercase(CharType p_char) { + return _find_lower(p_char); +} + +String String::to_lower() const { + String lower = *this; + + for (int i = 0; i < lower.size(); i++) { + const CharType s = lower[i]; + const CharType t = _find_lower(s); + if (s != t) { // avoid copy on write + lower[i] = t; + } + } + + return lower; +} + +String String::to_upper() const { + String upper = *this; + + for (int i = 0; i < upper.size(); i++) { + const CharType s = upper[i]; + const CharType t = _find_upper(s); + if (s != t) { // avoid copy on write + upper[i] = t; + } + } + + return upper; +} + +int String::_count(const String &p_string, int p_from, int p_to, bool p_case_insensitive) const { + if (p_string.empty()) { + return 0; + } + int len = length(); + int slen = p_string.length(); + if (len < slen) { + return 0; + } + String str; + if (p_from >= 0 && p_to >= 0) { + if (p_to == 0) { + p_to = len; + } else if (p_from >= p_to) { + return 0; + } + if (p_from == 0 && p_to == len) { + str = String(); + str.copy_from_unchecked(&get_data()[0], len); + } else { + str = substr(p_from, p_to - p_from); + } + } else { + return 0; + } + int c = 0; + int idx = -1; + do { + idx = p_case_insensitive ? str.findn(p_string) : str.find(p_string); + if (idx != -1) { + str = str.substr(idx + slen, str.length() - slen); + ++c; + } + } while (idx != -1); + return c; +} + +int String::count(const String &p_string, int p_from, int p_to) const { + return _count(p_string, p_from, p_to, false); +} + +int String::countn(const String &p_string, int p_from, int p_to) const { + return _count(p_string, p_from, p_to, true); +} + +String String::left(int p_pos) const { + if (p_pos <= 0) { + return ""; + } + + if (p_pos >= length()) { + return *this; + } + + return substr(0, p_pos); +} + +String String::right(int p_pos) const { + if (p_pos >= length()) { + return ""; + } + + if (p_pos <= 0) { + return *this; + } + + return substr(p_pos, (length() - p_pos)); +} + +String String::indent(const String &p_prefix) const { + String new_string; + int line_start = 0; + + for (int i = 0; i < length(); i++) { + const CharType c = operator[](i); + if (c == '\n') { + if (i == line_start) { + new_string += c; // Leave empty lines empty. + } else { + new_string += p_prefix + substr(line_start, i - line_start + 1); + } + line_start = i + 1; + } + } + if (line_start != length()) { + new_string += p_prefix + substr(line_start); + } + return new_string; +} + +String String::dedent() const { + String new_string; + String indent; + bool has_indent = false; + bool has_text = false; + int line_start = 0; + int indent_stop = -1; + + for (int i = 0; i < length(); i++) { + CharType c = operator[](i); + if (c == '\n') { + if (has_text) { + new_string += substr(indent_stop, i - indent_stop); + } + new_string += "\n"; + has_text = false; + line_start = i + 1; + indent_stop = -1; + } else if (!has_text) { + if (c > 32) { + has_text = true; + if (!has_indent) { + has_indent = true; + indent = substr(line_start, i - line_start); + indent_stop = i; + } + } + if (has_indent && indent_stop < 0) { + int j = i - line_start; + if (j >= indent.length() || c != indent[j]) { + indent_stop = i; + } + } + } + } + + if (has_text) { + new_string += substr(indent_stop, length() - indent_stop); + } + + return new_string; +} + +String String::strip_edges(bool left, bool right) const { + int len = length(); + int beg = 0, end = len; + + if (left) { + for (int i = 0; i < len; i++) { + if (operator[](i) <= 32) { + beg++; + } else { + break; + } + } + } + + if (right) { + for (int i = (int)(len - 1); i >= 0; i--) { + if (operator[](i) <= 32) { + end--; + } else { + break; + } + } + } + + if (beg == 0 && end == len) { + return *this; + } + + return substr(beg, end - beg); +} + +String String::strip_escapes() const { + String new_string; + for (int i = 0; i < length(); i++) { + // Escape characters on first page of the ASCII table, before 32 (Space). + if (operator[](i) < 32) { + continue; + } + new_string += operator[](i); + } + + return new_string; +} + +String String::lstrip(const String &p_chars) const { + int len = length(); + int beg; + + for (beg = 0; beg < len; beg++) { + if (p_chars.find_char(get(beg)) == -1) { + break; + } + } + + if (beg == 0) { + return *this; + } + + return substr(beg, len - beg); +} + +String String::rstrip(const String &p_chars) const { + int len = length(); + int end; + + for (end = len - 1; end >= 0; end--) { + if (p_chars.find_char(get(end)) == -1) { + break; + } + } + + if (end == len - 1) { + return *this; + } + + return substr(0, end + 1); +} + +String String::get_extension() const { + int pos = rfind("."); + if (pos < 0 || pos < MAX(rfind("/"), rfind("\\"))) { + return ""; + } + + return substr(pos + 1, length()); +} + +String String::get_basename() const { + int pos = rfind("."); + if (pos < 0 || pos < MAX(rfind("/"), rfind("\\"))) { + return *this; + } + + return substr(0, pos); +} + +String String::plus_file(const String &p_file) const { + if (empty()) { + return p_file; + } + if (operator[](length() - 1) == '/' || (p_file.size() > 0 && p_file.operator[](0) == '/')) { + return *this + p_file; + } + return *this + "/" + p_file; +} + +CharType String::unicode_at(int p_idx) const { + ERR_FAIL_INDEX_V(p_idx, length(), 0); + return operator[](p_idx); +} + +CharType String::ord_at(int p_idx) const { + ERR_FAIL_INDEX_V(p_idx, length(), 0); + return operator[](p_idx); +} + +void String::erase(int p_pos, int p_chars) { + *this = left(p_pos) + substr(p_pos + p_chars, length() - ((p_pos + p_chars))); +} +CharString String::ascii(bool p_allow_extended) const { + if (!length()) { + return CharString(); + } + + CharString cs; + cs.resize(size()); + + for (int i = 0; i < size(); i++) { + CharType c = operator[](i); + if ((c <= 0x7f) || (c <= 0xff && p_allow_extended)) { + cs[i] = c; + } else { + //print_unicode_error(vformat("Invalid unicode codepoint (%x), cannot represent as ASCII/Latin-1", (uint32_t)c)); + cs[i] = 0x20; + } + } + + return cs; +} + +String String::utf8(const char *p_utf8, int p_len) { + String ret; + ret.parse_utf8(p_utf8, p_len); + + return ret; +} + +Error String::parse_utf8(const char *p_utf8, int p_len, bool p_skip_cr) { + if (!p_utf8) { + return ERR_INVALID_DATA; + } + + String aux; + + int cstr_size = 0; + int str_size = 0; + + /* HANDLE BOM (Byte Order Mark) */ + if (p_len < 0 || p_len >= 3) { + bool has_bom = uint8_t(p_utf8[0]) == 0xef && uint8_t(p_utf8[1]) == 0xbb && uint8_t(p_utf8[2]) == 0xbf; + if (has_bom) { + //8-bit encoding, byte order has no meaning in UTF-8, just skip it + if (p_len >= 0) { + p_len -= 3; + } + p_utf8 += 3; + } + } + + bool decode_error = false; + bool decode_failed = false; + { + const char *ptrtmp = p_utf8; + const char *ptrtmp_limit = &p_utf8[p_len]; + int skip = 0; + uint8_t c_start = 0; + while (ptrtmp != ptrtmp_limit && *ptrtmp) { + uint8_t c = *ptrtmp >= 0 ? *ptrtmp : uint8_t(256 + *ptrtmp); + + if (skip == 0) { + if (p_skip_cr && c == '\r') { + ptrtmp++; + continue; + } + /* Determine the number of characters in sequence */ + if ((c & 0x80) == 0) { + skip = 0; + } else if ((c & 0xe0) == 0xc0) { + skip = 1; + } else if ((c & 0xf0) == 0xe0) { + skip = 2; + } else if ((c & 0xf8) == 0xf0) { + skip = 3; + } else if ((c & 0xfc) == 0xf8) { + skip = 4; + } else if ((c & 0xfe) == 0xfc) { + skip = 5; + } else { + skip = 0; + //print_unicode_error(vformat("Invalid UTF-8 leading byte (%x)", c), true); + decode_failed = true; + } + c_start = c; + + if (skip == 1 && (c & 0x1e) == 0) { + //print_unicode_error(vformat("Overlong encoding (%x ...)", c)); + decode_error = true; + } + str_size++; + } else { + if ((c_start == 0xe0 && skip == 2 && c < 0xa0) || (c_start == 0xf0 && skip == 3 && c < 0x90) || (c_start == 0xf8 && skip == 4 && c < 0x88) || (c_start == 0xfc && skip == 5 && c < 0x84)) { + //print_unicode_error(vformat("Overlong encoding (%x %x ...)", c_start, c)); + decode_error = true; + } + if (c < 0x80 || c > 0xbf) { + //print_unicode_error(vformat("Invalid UTF-8 continuation byte (%x ... %x ...)", c_start, c), true); + decode_failed = true; + skip = 0; + } else { + --skip; + } + } + + cstr_size++; + ptrtmp++; + } + + if (skip) { + //rrprint_unicode_error(vformat("Missing %d UTF-8 continuation byte(s)", skip), true); + decode_failed = true; + } + } + + if (str_size == 0) { + clear(); + return OK; // empty string + } + + resize(str_size + 1); + CharType *dst = ptrw(); + dst[str_size] = 0; + + int skip = 0; + uint32_t unichar = 0; + while (cstr_size) { + uint8_t c = *p_utf8 >= 0 ? *p_utf8 : uint8_t(256 + *p_utf8); + + if (skip == 0) { + if (p_skip_cr && c == '\r') { + p_utf8++; + continue; + } + /* Determine the number of characters in sequence */ + if ((c & 0x80) == 0) { + *(dst++) = c; + unichar = 0; + skip = 0; + } else if ((c & 0xe0) == 0xc0) { + unichar = (0xff >> 3) & c; + skip = 1; + } else if ((c & 0xf0) == 0xe0) { + unichar = (0xff >> 4) & c; + skip = 2; + } else if ((c & 0xf8) == 0xf0) { + unichar = (0xff >> 5) & c; + skip = 3; + } else if ((c & 0xfc) == 0xf8) { + unichar = (0xff >> 6) & c; + skip = 4; + } else if ((c & 0xfe) == 0xfc) { + unichar = (0xff >> 7) & c; + skip = 5; + } else { + *(dst++) = 0x20; + unichar = 0; + skip = 0; + } + } else { + if (c < 0x80 || c > 0xbf) { + *(dst++) = 0x20; + skip = 0; + } else { + unichar = (unichar << 6) | (c & 0x3f); + --skip; + if (skip == 0) { + if (unichar == 0) { + //print_unicode_error("NUL character", true); + decode_failed = true; + unichar = 0x20; + } + if ((unichar & 0xfffff800) == 0xd800) { + //print_unicode_error(vformat("Unpaired surrogate (%x)", unichar)); + decode_error = true; + } + if (unichar > 0x10ffff) { + //print_unicode_error(vformat("Invalid unicode codepoint (%x)", unichar)); + decode_error = true; + } + *(dst++) = unichar; + } + } + } + + cstr_size--; + p_utf8++; + } + if (skip) { + *(dst++) = 0x20; + } + + if (decode_failed) { + return ERR_INVALID_DATA; + } else if (decode_error) { + return ERR_PARSE_ERROR; + } else { + return OK; + } +} + +CharString String::utf8() const { + int l = length(); + if (!l) { + return CharString(); + } + + const CharType *d = &operator[](0); + int fl = 0; + for (int i = 0; i < l; i++) { + uint32_t c = d[i]; + if (c <= 0x7f) { // 7 bits. + fl += 1; + } else if (c <= 0x7ff) { // 11 bits + fl += 2; + } else if (c <= 0xffff) { // 16 bits + fl += 3; + } else if (c <= 0x001fffff) { // 21 bits + fl += 4; + } else if (c <= 0x03ffffff) { // 26 bits + fl += 5; + //print_unicode_error(vformat("Invalid unicode codepoint (%x)", c)); + } else if (c <= 0x7fffffff) { // 31 bits + fl += 6; + //print_unicode_error(vformat("Invalid unicode codepoint (%x)", c)); + } else { + fl += 1; + //print_unicode_error(vformat("Invalid unicode codepoint (%x), cannot represent as UTF-8", c), true); + } + } + + CharString utf8s; + if (fl == 0) { + return utf8s; + } + + utf8s.resize(fl + 1); + uint8_t *cdst = (uint8_t *)utf8s.get_data(); + +#define APPEND_CHAR(m_c) *(cdst++) = m_c + + for (int i = 0; i < l; i++) { + uint32_t c = d[i]; + + if (c <= 0x7f) { // 7 bits. + APPEND_CHAR(c); + } else if (c <= 0x7ff) { // 11 bits + APPEND_CHAR(uint32_t(0xc0 | ((c >> 6) & 0x1f))); // Top 5 bits. + APPEND_CHAR(uint32_t(0x80 | (c & 0x3f))); // Bottom 6 bits. + } else if (c <= 0xffff) { // 16 bits + APPEND_CHAR(uint32_t(0xe0 | ((c >> 12) & 0x0f))); // Top 4 bits. + APPEND_CHAR(uint32_t(0x80 | ((c >> 6) & 0x3f))); // Middle 6 bits. + APPEND_CHAR(uint32_t(0x80 | (c & 0x3f))); // Bottom 6 bits. + } else if (c <= 0x001fffff) { // 21 bits + APPEND_CHAR(uint32_t(0xf0 | ((c >> 18) & 0x07))); // Top 3 bits. + APPEND_CHAR(uint32_t(0x80 | ((c >> 12) & 0x3f))); // Upper middle 6 bits. + APPEND_CHAR(uint32_t(0x80 | ((c >> 6) & 0x3f))); // Lower middle 6 bits. + APPEND_CHAR(uint32_t(0x80 | (c & 0x3f))); // Bottom 6 bits. + } else if (c <= 0x03ffffff) { // 26 bits + APPEND_CHAR(uint32_t(0xf8 | ((c >> 24) & 0x03))); // Top 2 bits. + APPEND_CHAR(uint32_t(0x80 | ((c >> 18) & 0x3f))); // Upper middle 6 bits. + APPEND_CHAR(uint32_t(0x80 | ((c >> 12) & 0x3f))); // middle 6 bits. + APPEND_CHAR(uint32_t(0x80 | ((c >> 6) & 0x3f))); // Lower middle 6 bits. + APPEND_CHAR(uint32_t(0x80 | (c & 0x3f))); // Bottom 6 bits. + } else if (c <= 0x7fffffff) { // 31 bits + APPEND_CHAR(uint32_t(0xfc | ((c >> 30) & 0x01))); // Top 1 bit. + APPEND_CHAR(uint32_t(0x80 | ((c >> 24) & 0x3f))); // Upper upper middle 6 bits. + APPEND_CHAR(uint32_t(0x80 | ((c >> 18) & 0x3f))); // Lower upper middle 6 bits. + APPEND_CHAR(uint32_t(0x80 | ((c >> 12) & 0x3f))); // Upper lower middle 6 bits. + APPEND_CHAR(uint32_t(0x80 | ((c >> 6) & 0x3f))); // Lower lower middle 6 bits. + APPEND_CHAR(uint32_t(0x80 | (c & 0x3f))); // Bottom 6 bits. + } else { + APPEND_CHAR(0x20); + } + } +#undef APPEND_CHAR + *cdst = 0; //trailing zero + + return utf8s; +} + +int String::utf8_byte_length() const { + int l = length(); + if (!l) { + return 0; + } + + const CharType *d = &operator[](0); + int fl = 0; + for (int i = 0; i < l; i++) { + uint32_t c = d[i]; + if (c <= 0x7f) { // 7 bits. + fl += 1; + } else if (c <= 0x7ff) { // 11 bits + fl += 2; + } else if (c <= 0xffff) { // 16 bits + fl += 3; + } else if (c <= 0x001fffff) { // 21 bits + fl += 4; + } else if (c <= 0x03ffffff) { // 26 bits + fl += 5; + //print_unicode_error(vformat("Invalid unicode codepoint (%x)", c)); + } else if (c <= 0x7fffffff) { // 31 bits + fl += 6; + //print_unicode_error(vformat("Invalid unicode codepoint (%x)", c)); + } else { + fl += 1; + //print_unicode_error(vformat("Invalid unicode codepoint (%x), cannot represent as UTF-8", c), true); + } + } + + return fl; +} + +String String::utf16(const char16_t *p_utf16, int p_len) { + String ret; + ret.parse_utf16(p_utf16, p_len); + + return ret; +} + +Error String::parse_utf16(const char16_t *p_utf16, int p_len) { + if (!p_utf16) { + return ERR_INVALID_DATA; + } + + String aux; + + int cstr_size = 0; + int str_size = 0; + + /* HANDLE BOM (Byte Order Mark) */ + bool byteswap = false; // assume correct endianness if no BOM found + if (p_len < 0 || p_len >= 1) { + bool has_bom = false; + if (uint16_t(p_utf16[0]) == 0xfeff) { // correct BOM, read as is + has_bom = true; + byteswap = false; + } else if (uint16_t(p_utf16[0]) == 0xfffe) { // backwards BOM, swap bytes + has_bom = true; + byteswap = true; + } + if (has_bom) { + if (p_len >= 0) { + p_len -= 1; + } + p_utf16 += 1; + } + } + + bool decode_error = false; + { + const char16_t *ptrtmp = p_utf16; + const char16_t *ptrtmp_limit = &p_utf16[p_len]; + //uint32_t c_prev = 0; + bool skip = false; + while (ptrtmp != ptrtmp_limit && *ptrtmp) { + uint32_t c = (byteswap) ? BSWAP16(*ptrtmp) : *ptrtmp; + + if ((c & 0xfffffc00) == 0xd800) { // lead surrogate + if (skip) { + //print_unicode_error(vformat("Unpaired lead surrogate (%x [trail?] %x)", c_prev, c)); + decode_error = true; + } + skip = true; + } else if ((c & 0xfffffc00) == 0xdc00) { // trail surrogate + if (skip) { + str_size--; + } else { + //print_unicode_error(vformat("Unpaired trail surrogate (%x [lead?] %x)", c_prev, c)); + decode_error = true; + } + skip = false; + } else { + skip = false; + } + + //c_prev = c; + str_size++; + cstr_size++; + ptrtmp++; + } + + if (skip) { + //print_unicode_error(vformat("Unpaired lead surrogate (%x [eol])", c_prev)); + decode_error = true; + } + } + + if (str_size == 0) { + clear(); + return OK; // empty string + } + + resize(str_size + 1); + CharType *dst = ptrw(); + dst[str_size] = 0; + + bool skip = false; + uint32_t c_prev = 0; + while (cstr_size) { + uint32_t c = (byteswap) ? BSWAP16(*p_utf16) : *p_utf16; + + if ((c & 0xfffffc00) == 0xd800) { // lead surrogate + if (skip) { + *(dst++) = c_prev; // unpaired, store as is + } + skip = true; + } else if ((c & 0xfffffc00) == 0xdc00) { // trail surrogate + if (skip) { + *(dst++) = (c_prev << 10UL) + c - ((0xd800 << 10UL) + 0xdc00 - 0x10000); // decode pair + } else { + *(dst++) = c; // unpaired, store as is + } + skip = false; + } else { + *(dst++) = c; + skip = false; + } + + cstr_size--; + p_utf16++; + c_prev = c; + } + + if (skip) { + *(dst++) = c_prev; + } + + if (decode_error) { + return ERR_PARSE_ERROR; + } else { + return OK; + } +} + +Char16String String::utf16() const { + int l = length(); + if (!l) { + return Char16String(); + } + + const CharType *d = &operator[](0); + int fl = 0; + for (int i = 0; i < l; i++) { + uint32_t c = d[i]; + if (c <= 0xffff) { // 16 bits. + fl += 1; + if ((c & 0xfffff800) == 0xd800) { + //print_unicode_error(vformat("Unpaired surrogate (%x)", c)); + } + } else if (c <= 0x10ffff) { // 32 bits. + fl += 2; + } else { + //print_unicode_error(vformat("Invalid unicode codepoint (%x), cannot represent as UTF-16", c), true); + fl += 1; + } + } + + Char16String utf16s; + if (fl == 0) { + return utf16s; + } + + utf16s.resize(fl + 1); + uint16_t *cdst = (uint16_t *)utf16s.get_data(); + +#define APPEND_CHAR(m_c) *(cdst++) = m_c + + for (int i = 0; i < l; i++) { + uint32_t c = d[i]; + + if (c <= 0xffff) { // 16 bits. + APPEND_CHAR(c); + } else if (c <= 0x10ffff) { // 32 bits. + APPEND_CHAR(uint32_t((c >> 10) + 0xd7c0)); // lead surrogate. + APPEND_CHAR(uint32_t((c & 0x3ff) | 0xdc00)); // trail surrogate. + } else { + APPEND_CHAR(0x20); + } + } +#undef APPEND_CHAR + *cdst = 0; //trailing zero + + return utf16s; +} + +int String::utf16_byte_length() const { + int l = length(); + if (!l) { + return 0; + } + + const CharType *d = &operator[](0); + int fl = 0; + for (int i = 0; i < l; i++) { + uint32_t c = d[i]; + if (c <= 0xffff) { // 16 bits. + fl += 1; + if ((c & 0xfffff800) == 0xd800) { + //print_unicode_error(vformat("Unpaired surrogate (%x)", c)); + } + } else if (c <= 0x10ffff) { // 32 bits. + fl += 2; + } else { + //print_unicode_error(vformat("Invalid unicode codepoint (%x), cannot represent as UTF-16", c), true); + fl += 1; + } + } + + return fl; +} + +uint32_t String::hash(const char *p_cstr) { + uint32_t hashv = 5381; + uint32_t c; + + while ((c = *p_cstr++)) { + hashv = ((hashv << 5) + hashv) + c; /* hash * 33 + c */ + } + + return hashv; +} + +uint32_t String::hash(const char *p_cstr, int p_len) { + uint32_t hashv = 5381; + for (int i = 0; i < p_len; i++) { + hashv = ((hashv << 5) + hashv) + p_cstr[i]; /* hash * 33 + c */ + } + + return hashv; +} + +uint32_t String::hash(const wchar_t *p_cstr) { + uint32_t hashv = 5381; + uint32_t c; + + while ((c = *p_cstr++)) { + hashv = ((hashv << 5) + hashv) + c; /* hash * 33 + c */ + } + + return hashv; +} + +uint32_t String::hash(const wchar_t *p_cstr, int p_len) { + uint32_t hashv = 5381; + for (int i = 0; i < p_len; i++) { + hashv = ((hashv << 5) + hashv) + p_cstr[i]; /* hash * 33 + c */ + } + + return hashv; +} + +uint32_t String::hash(const CharType *p_cstr) { + uint32_t hashv = 5381; + uint32_t c; + + while ((c = *p_cstr++)) { + hashv = ((hashv << 5) + hashv) + c; /* hash * 33 + c */ + } + + return hashv; +} + +uint32_t String::hash(const CharType *p_cstr, int p_len) { + uint32_t hashv = 5381; + for (int i = 0; i < p_len; i++) { + hashv = ((hashv << 5) + hashv) + p_cstr[i]; /* hash * 33 + c */ + } + + return hashv; +} + +uint32_t String::hash() const { + /* simple djb2 hashing */ + + const CharType *chr = get_data(); + uint32_t hashv = 5381; + uint32_t c; + + while ((c = *chr++)) { + hashv = ((hashv << 5) + hashv) + c; /* hash * 33 + c */ + } + + return hashv; +} + +uint64_t String::hash64() const { + /* simple djb2 hashing */ + + const CharType *chr = get_data(); + uint64_t hashv = 5381; + uint64_t c; + + while ((c = *chr++)) { + hashv = ((hashv << 5) + hashv) + c; /* hash * 33 + c */ + } + + return hashv; +} + +bool String::is_abs_path() const { + if (length() > 1) { + return (operator[](0) == '/' || operator[](0) == '\\' || find(":/") != -1 || find(":\\") != -1); + } else if ((length()) == 1) { + return (operator[](0) == '/' || operator[](0) == '\\'); + } else { + return false; + } +} + +bool String::is_rel_path() const { + return !is_abs_path(); +} + +bool String::is_resource_file() const { + return begins_with("res://") && find("::") == -1; +} + +String String::path_to(const String &p_path) const { + String src = this->replace("\\", "/"); + String dst = p_path.replace("\\", "/"); + if (!src.ends_with("/")) { + src += "/"; + } + if (!dst.ends_with("/")) { + dst += "/"; + } + + String base; + + if (src.begins_with("res://") && dst.begins_with("res://")) { + base = "res:/"; + src = src.replace("res://", "/"); + dst = dst.replace("res://", "/"); + + } else if (src.begins_with("user://") && dst.begins_with("user://")) { + base = "user:/"; + src = src.replace("user://", "/"); + dst = dst.replace("user://", "/"); + + } else if (src.begins_with("/") && dst.begins_with("/")) { + //nothing + } else { + //dos style + String src_begin = src.get_slicec('/', 0); + String dst_begin = dst.get_slicec('/', 0); + + if (src_begin != dst_begin) { + return p_path; //impossible to do this + } + + base = src_begin; + src = src.substr(src_begin.length(), src.length()); + dst = dst.substr(dst_begin.length(), dst.length()); + } + + //remove leading and trailing slash and split + Vector src_dirs = src.substr(1, src.length() - 2).split("/"); + Vector dst_dirs = dst.substr(1, dst.length() - 2).split("/"); + + //find common parent + int common_parent = 0; + + while (true) { + if (src_dirs.size() == common_parent) { + break; + } + if (dst_dirs.size() == common_parent) { + break; + } + if (src_dirs[common_parent] != dst_dirs[common_parent]) { + break; + } + common_parent++; + } + + common_parent--; + + String dir; + + for (int i = src_dirs.size() - 1; i > common_parent; i--) { + dir += "../"; + } + + for (int i = common_parent + 1; i < dst_dirs.size(); i++) { + dir += dst_dirs[i] + "/"; + } + + if (dir.length() == 0) { + dir = "./"; + } + return dir; +} + +String String::path_to_file(const String &p_path) const { + // Don't get base dir for src, this is expected to be a dir already. + String src = this->replace("\\", "/"); + String dst = p_path.replace("\\", "/").get_base_dir(); + String rel = src.path_to(dst); + if (rel == dst) { // failed + return p_path; + } else { + return rel + p_path.get_file(); + } +} + +String String::get_base_dir() const { + int end = 0; + + // url scheme style base + int basepos = find("://"); + if (basepos != -1) { + end = basepos + 3; + } + + // windows top level directory base + if (end == 0) { + basepos = find(":/"); + if (basepos == -1) { + basepos = find(":\\"); + } + if (basepos != -1) { + end = basepos + 2; + } + } + + // Windows UNC network share path. + if (end == 0) { + if (is_network_share_path()) { + basepos = find("/", 2); + if (basepos == -1) { + basepos = find("\\", 2); + } + int servpos = find("/", basepos + 1); + if (servpos == -1) { + servpos = find("\\", basepos + 1); + } + if (servpos != -1) { + end = servpos + 1; + } + } + } + + // unix root directory base + if (end == 0) { + if (begins_with("/")) { + end = 1; + } + } + + String rs; + String base; + if (end != 0) { + rs = substr(end, length()); + base = substr(0, end); + } else { + rs = *this; + } + + int sep = MAX(rs.rfind("/"), rs.rfind("\\")); + if (sep == -1) { + return base; + } + + return base + rs.substr(0, sep); +} + +String String::get_file() const { + int sep = MAX(rfind("/"), rfind("\\")); + if (sep == -1) { + return *this; + } + + return substr(sep + 1, length()); +} + +String String::humanize_size(uint64_t p_size) { + uint64_t _div = 1; + Vector prefixes; + prefixes.push_back(RTR("B")); + prefixes.push_back(RTR("KiB")); + prefixes.push_back(RTR("MiB")); + prefixes.push_back(RTR("GiB")); + prefixes.push_back(RTR("TiB")); + prefixes.push_back(RTR("PiB")); + prefixes.push_back(RTR("EiB")); + + int prefix_idx = 0; + + while (prefix_idx < prefixes.size() - 1 && p_size > (_div * 1024)) { + _div *= 1024; + prefix_idx++; + } + + const int digits = prefix_idx > 0 ? _humanize_digits(p_size / _div) : 0; + const double divisor = prefix_idx > 0 ? _div : 1; + + return String::num(p_size / divisor).pad_decimals(digits) + " " + prefixes[prefix_idx]; +} + +String String::simplify_path() const { + String s = *this; + String drive; + if (s.begins_with("local://")) { + drive = "local://"; + s = s.substr(8, s.length()); + } else if (s.begins_with("res://")) { + drive = "res://"; + s = s.substr(6, s.length()); + } else if (s.begins_with("user://")) { + drive = "user://"; + s = s.substr(7, s.length()); + } else if (is_network_share_path()) { + drive = s.substr(0, 2); + s = s.substr(2, s.length() - 2); + } else if (s.begins_with("/") || s.begins_with("\\")) { + drive = s.substr(0, 1); + s = s.substr(1, s.length() - 1); + } else { + int p = s.find(":/"); + if (p == -1) { + p = s.find(":\\"); + } + if (p != -1 && p < s.find("/")) { + drive = s.substr(0, p + 2); + s = s.substr(p + 2, s.length()); + } + } + + s = s.replace("\\", "/"); + while (true) { // in case of using 2 or more slash + String compare = s.replace("//", "/"); + if (s == compare) { + break; + } else { + s = compare; + } + } + Vector dirs = s.split("/", false); + + for (int i = 0; i < dirs.size(); i++) { + String d = dirs[i]; + if (d == ".") { + dirs.remove(i); + i--; + } else if (d == "..") { + if (i == 0) { + dirs.remove(i); + i--; + } else { + dirs.remove(i); + dirs.remove(i - 1); + i -= 2; + } + } + } + + s = ""; + + for (int i = 0; i < dirs.size(); i++) { + if (i > 0) { + s += "/"; + } + s += dirs[i]; + } + + return drive + s; +} + +bool String::is_network_share_path() const { + return begins_with("//") || begins_with("\\\\"); +} + +String String::append_path(const char *path) const { + if (path[0] == '\0') { + return *this; + } + + String ret = *this; + int size = length(); + + if (size == 0) { + ret += path; + return ret; + } + + int sindex = 0; + char ch = path[sindex]; + while (ch == '/' || ch == '\\') { + if (ch == '\0') { + return ret; + } + + ch = path[++sindex]; + } + + // /////folder + // ^ (sindex) + + if (ret.ends_with("/") || ret.ends_with("\\")) { + ret += &path[sindex]; + } else { + if (sindex > 0) { + ret += '/'; + ret += &path[sindex - 1]; + } else { + ret += '/'; + ret += &path[sindex]; + } + } + + return ret; +} + +String String::append_path(const String &path) const { + if (path.length() == 0) { + return *this; + } + + int size = length(); + + if (size == 0) { + return path; + } + + int sindex = 0; + int ts = path.size() - 1; + char ch = path[sindex]; + while (ch == '/' || ch == '\\') { + if (sindex == ts) { + return *this; + } + + ch = path[++sindex]; + } + + String ret = *this; + + // /////folder + // ^ (sindex) + + if (ret.ends_with("/") || ret.ends_with("\\")) { + ret += &path[sindex]; + } else { + if (sindex > 0) { + ret += '/'; + ret += &path[sindex - 1]; + } else { + ret += '/'; + ret += &path[sindex]; + } + } + + return ret; +} + +String String::path_clean_end_slash() const { + // _size > 1, so if root is given ("/"), it will not be removed + + String ret = *this; + + int strip_to = ret.length() - 1; + + CharType c = ret[strip_to]; + + while (strip_to > 1 && (c == '/' || c == '\\')) { + --strip_to; + c = ret[strip_to]; + } + + if (ret.length() != strip_to + 1) { + ret.set_length(strip_to + 1); + } + + return ret; +} +String String::path_ensure_end_slash() const { + // Don't add if empty string, as it would make it root on linux, which can easily become a serious bug + + String ret = *this; + + if (ret.length() == 0) { + return ret; + } + + if (!(ret.ends_with("/") || ret.ends_with("\\"))) { + ret += "/"; + } + + return ret; +} + +String String::path_get_prev_dir() const { + int size = length(); + + if (size == 0) { + return "/"; + } + + int seind = size - 1; + while (seind > 0 && (operator[](seind) == '/' || operator[](seind) == '\\')) { + --seind; + } + + if (seind == 0) { + // ///////// + // or + // a/////// + // no prev dir + + return "/"; + } + + // fol/fol2/fol3// + // ^ (seind) + + while (seind > 0 && (operator[](seind) != '/' && operator[](seind) != '\\')) { + --seind; + } + + // fol/fol2/fol3// + // ^ (seind) + + //--seind; + + if (seind <= 0) { + return "/"; + } + + return substr_index(0, seind); +} + +String String::xml_escape(bool p_escape_quotes) const { + String str = *this; + str = str.replace("&", "&"); + str = str.replace("<", "<"); + str = str.replace(">", ">"); + if (p_escape_quotes) { + str = str.replace("'", "'"); + str = str.replace("\"", """); + } + /* + for (int i=1;i<32;i++) { + + char chr[2]={i,0}; + str=str.replace(chr,"&#"+String::num(i)+";"); + }*/ + return str; +} + +static _FORCE_INLINE_ int _xml_unescape(const CharType *p_src, int p_src_len, CharType *p_dst) { + int len = 0; + while (p_src_len) { + if (*p_src == '&') { + int eat = 0; + + if (p_src_len >= 4 && p_src[1] == '#') { + CharType c = 0; + bool overflow = false; + if (p_src[2] == 'x') { + // Hex entity &#x; + for (int i = 3; i < p_src_len; i++) { + eat = i + 1; + CharType ct = p_src[i]; + if (ct == ';') { + break; + } else if (ct >= '0' && ct <= '9') { + ct = ct - '0'; + } else if (ct >= 'a' && ct <= 'f') { + ct = (ct - 'a') + 10; + } else if (ct >= 'A' && ct <= 'F') { + ct = (ct - 'A') + 10; + } else { + break; + } + if (c > (WCHAR_MAX >> 4)) { + overflow = true; + break; + } + c <<= 4; + c |= ct; + } + } else { + // Decimal entity &#; + for (int i = 2; i < p_src_len; i++) { + eat = i + 1; + CharType ct = p_src[i]; + if (ct == ';' || ct < '0' || ct > '9') { + break; + } + } + if (p_src[eat - 1] == ';') { + int64_t val = String::to_int(p_src + 2, eat - 3); + if (val > 0 && val <= WCHAR_MAX) { + c = (CharType)val; + } else { + overflow = true; + } + } + } + + // Value must be non-zero, in the range of CharType, + // actually end with ';'. If invalid, leave the entity as-is + if (c == '\0' || overflow || p_src[eat - 1] != ';') { + eat = 1; + c = *p_src; + } + if (p_dst) { + *p_dst = c; + } + } else if (p_src_len >= 4 && p_src[1] == 'g' && p_src[2] == 't' && p_src[3] == ';') { + if (p_dst) { + *p_dst = '>'; + } + eat = 4; + } else if (p_src_len >= 4 && p_src[1] == 'l' && p_src[2] == 't' && p_src[3] == ';') { + if (p_dst) { + *p_dst = '<'; + } + eat = 4; + } else if (p_src_len >= 5 && p_src[1] == 'a' && p_src[2] == 'm' && p_src[3] == 'p' && p_src[4] == ';') { + if (p_dst) { + *p_dst = '&'; + } + eat = 5; + } else if (p_src_len >= 6 && p_src[1] == 'q' && p_src[2] == 'u' && p_src[3] == 'o' && p_src[4] == 't' && p_src[5] == ';') { + if (p_dst) { + *p_dst = '"'; + } + eat = 6; + } else if (p_src_len >= 6 && p_src[1] == 'a' && p_src[2] == 'p' && p_src[3] == 'o' && p_src[4] == 's' && p_src[5] == ';') { + if (p_dst) { + *p_dst = '\''; + } + eat = 6; + } else { + if (p_dst) { + *p_dst = *p_src; + } + eat = 1; + } + + if (p_dst) { + p_dst++; + } + + len++; + p_src += eat; + p_src_len -= eat; + } else { + if (p_dst) { + *p_dst = *p_src; + p_dst++; + } + len++; + p_src++; + p_src_len--; + } + } + + return len; +} + +String String::xml_unescape() const { + String str; + int l = length(); + int len = _xml_unescape(get_data(), l, nullptr); + if (len == 0) { + return String(); + } + str.resize(len + 1); + _xml_unescape(get_data(), l, str.ptrw()); + str[len] = 0; + return str; +} + +String String::http_escape() const { + const CharString temp = utf8(); + String res; + for (int i = 0; i < temp.length(); ++i) { + uint8_t ord = temp[i]; + if (ord == '.' || ord == '-' || ord == '_' || ord == '~' || + (ord >= 'a' && ord <= 'z') || + (ord >= 'A' && ord <= 'Z') || + (ord >= '0' && ord <= '9')) { + res += ord; + } else { + char p[4] = { '%', 0, 0, 0 }; + static const char hex[16] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' }; + + p[1] = hex[ord >> 4]; + p[2] = hex[ord & 0xF]; + res += p; + } + } + return res; +} + +String String::http_unescape() const { + String res; + for (int i = 0; i < length(); ++i) { + if (ord_at(i) == '%' && i + 2 < length()) { + CharType ord1 = ord_at(i + 1); + if ((ord1 >= '0' && ord1 <= '9') || (ord1 >= 'A' && ord1 <= 'Z')) { + CharType ord2 = ord_at(i + 2); + if ((ord2 >= '0' && ord2 <= '9') || (ord2 >= 'A' && ord2 <= 'Z')) { + char bytes[3] = { (char)ord1, (char)ord2, 0 }; + res += (char)strtol(bytes, nullptr, 16); + i += 2; + } + } else { + res += ord_at(i); + } + } else { + res += ord_at(i); + } + } + return String::utf8(res.ascii()); +} + +String String::uri_encode() const { + const CharString temp = utf8(); + String res; + for (int i = 0; i < temp.length(); ++i) { + uint8_t ord = temp[i]; + if (ord == '.' || ord == '-' || ord == '~' || is_ascii_identifier_char(ord)) { + res += ord; + } else { + char p[4] = { '%', 0, 0, 0 }; + static const char hex[16] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' }; + p[1] = hex[ord >> 4]; + p[2] = hex[ord & 0xF]; + res += p; + } + } + return res; +} + +String String::uri_decode() const { + CharString src = utf8(); + CharString res; + for (int i = 0; i < src.length(); ++i) { + if (src[i] == '%' && i + 2 < src.length()) { + char ord1 = src[i + 1]; + if (is_digit(ord1) || is_ascii_upper_case(ord1)) { + char ord2 = src[i + 2]; + if (is_digit(ord2) || is_ascii_upper_case(ord2)) { + char bytes[3] = { (char)ord1, (char)ord2, 0 }; + res += (char)strtol(bytes, nullptr, 16); + i += 2; + } + } else { + res += src[i]; + } + } else if (src[i] == '+') { + res += ' '; + } else { + res += src[i]; + } + } + return String::utf8(res); +} + +String String::c_escape() const { + String escaped = *this; + escaped = escaped.replace("\\", "\\\\"); + escaped = escaped.replace("\a", "\\a"); + escaped = escaped.replace("\b", "\\b"); + escaped = escaped.replace("\f", "\\f"); + escaped = escaped.replace("\n", "\\n"); + escaped = escaped.replace("\r", "\\r"); + escaped = escaped.replace("\t", "\\t"); + escaped = escaped.replace("\v", "\\v"); + escaped = escaped.replace("\'", "\\'"); + escaped = escaped.replace("\?", "\\?"); + escaped = escaped.replace("\"", "\\\""); + + return escaped; +} + +String String::c_escape_multiline() const { + String escaped = *this; + escaped = escaped.replace("\\", "\\\\"); + escaped = escaped.replace("\"", "\\\""); + + return escaped; +} + +String String::c_unescape() const { + String escaped = *this; + escaped = escaped.replace("\\a", "\a"); + escaped = escaped.replace("\\b", "\b"); + escaped = escaped.replace("\\f", "\f"); + escaped = escaped.replace("\\n", "\n"); + escaped = escaped.replace("\\r", "\r"); + escaped = escaped.replace("\\t", "\t"); + escaped = escaped.replace("\\v", "\v"); + escaped = escaped.replace("\\'", "\'"); + escaped = escaped.replace("\\\"", "\""); + escaped = escaped.replace("\\?", "\?"); + escaped = escaped.replace("\\\\", "\\"); + + return escaped; +} + +String String::json_escape() const { + String escaped = *this; + escaped = escaped.replace("\\", "\\\\"); + escaped = escaped.replace("\b", "\\b"); + escaped = escaped.replace("\f", "\\f"); + escaped = escaped.replace("\n", "\\n"); + escaped = escaped.replace("\r", "\\r"); + escaped = escaped.replace("\t", "\\t"); + escaped = escaped.replace("\v", "\\v"); + escaped = escaped.replace("\"", "\\\""); + + return escaped; +} + +String String::word_wrap(int p_chars_per_line) const { + String ret; + + int line_start = 0; + int line_end = 0; // End of last word on current line. + int word_start = 0; // -1 if no word encountered. Leading spaces are part of a word. + int word_length = 0; + + for (int i = 0; i < length(); i++) { + const CharType c = operator[](i); + + switch (c) { + case '\n': { + // Force newline. + ret += substr(line_start, i - line_start + 1); + line_start = i + 1; + line_end = line_start; + word_start = line_start; + word_length = 0; + } break; + + case ' ': + case '\t': { + // A whitespace ends current word. + if (word_length > 0) { + line_end = i - 1; + word_start = -1; + word_length = 0; + } + } break; + + default: { + if (word_start == -1) { + word_start = i; + } + word_length += 1; + + if (word_length > p_chars_per_line) { + // Word too long: wrap before current character. + ret += substr(line_start, i - line_start) + "\n"; + line_start = i; + line_end = i; + word_start = i; + word_length = 1; + } else if (i - line_start + 1 > p_chars_per_line) { + // Line too long: wrap after the last word. + ret += substr(line_start, line_end - line_start + 1) + "\n"; + line_start = word_start; + line_end = line_start; + } + } break; + } + } + + const int remaining = length() - line_start; + if (remaining) { + ret += substr(line_start, remaining); + } + + return ret; +} + +Error String::parse_url(String &r_scheme, String &r_host, int &r_port, String &r_path) const { + // Splits the URL into scheme, host, port, path. Strip credentials when present. + String base = *this; + r_scheme = ""; + r_host = ""; + r_port = 0; + r_path = ""; + int pos = base.find("://"); + // Scheme + if (pos != -1) { + r_scheme = base.substr(0, pos + 3).to_lower(); + base = base.substr(pos + 3, base.length() - pos - 3); + } + pos = base.find("/"); + // Path + if (pos != -1) { + r_path = base.substr(pos, base.length() - pos); + base = base.substr(0, pos); + } + // Host + pos = base.find("@"); + if (pos != -1) { + // Strip credentials + base = base.substr(pos + 1, base.length() - pos - 1); + } + if (base.begins_with("[")) { + // Literal IPv6 + pos = base.rfind("]"); + if (pos == -1) { + return ERR_INVALID_PARAMETER; + } + r_host = base.substr(1, pos - 1); + base = base.substr(pos + 1, base.length() - pos - 1); + } else { + // Anything else + if (base.get_slice_count(":") > 2) { + return ERR_INVALID_PARAMETER; + } + pos = base.rfind(":"); + if (pos == -1) { + r_host = base; + base = ""; + } else { + r_host = base.substr(0, pos); + base = base.substr(pos, base.length() - pos); + } + } + if (r_host.empty()) { + return ERR_INVALID_PARAMETER; + } + r_host = r_host.to_lower(); + // Port + if (base.begins_with(":")) { + base = base.substr(1, base.length() - 1); + if (!base.is_valid_integer()) { + return ERR_INVALID_PARAMETER; + } + r_port = base.to_int(); + if (r_port < 1 || r_port > 65535) { + return ERR_INVALID_PARAMETER; + } + } + return OK; +} + +String String::percent_encode() const { + CharString cs = utf8(); + String encoded; + for (int i = 0; i < cs.length(); i++) { + uint8_t c = cs[i]; + if ((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') || (c >= '0' && c <= '9') || c == '-' || c == '_' || c == '~' || c == '.') { + char p[2] = { (char)c, 0 }; + encoded += p; + } else { + char p[4] = { '%', 0, 0, 0 }; + static const char hex[16] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' }; + + p[1] = hex[c >> 4]; + p[2] = hex[c & 0xF]; + encoded += p; + } + } + + return encoded; +} +String String::percent_decode() const { + CharString pe; + + CharString cs = utf8(); + for (int i = 0; i < cs.length(); i++) { + uint8_t c = cs[i]; + if (c == '%' && i < length() - 2) { + uint8_t a = LOWERCASE(cs[i + 1]); + uint8_t b = LOWERCASE(cs[i + 2]); + + if (a >= '0' && a <= '9') { + c = (a - '0') << 4; + } else if (a >= 'a' && a <= 'f') { + c = (a - 'a' + 10) << 4; + } else { + continue; + } + + uint8_t d = 0; + + if (b >= '0' && b <= '9') { + d = (b - '0'); + } else if (b >= 'a' && b <= 'f') { + d = (b - 'a' + 10); + } else { + continue; + } + c += d; + i += 2; + } + pe += c; + } + + return String::utf8(pe.ptr()); +} + +String String::property_name_encode() const { + // Escape and quote strings with extended ASCII or further Unicode characters + // as well as '"', '=' or ' ' (32) + const CharType *cstr = get_data(); + for (int i = 0; cstr[i]; i++) { + if (cstr[i] == '=' || cstr[i] == '"' || cstr[i] == ';' || cstr[i] == '[' || cstr[i] == ']' || cstr[i] < 33 || cstr[i] > 126) { + return "\"" + c_escape_multiline() + "\""; + } + } + // Keep as is + return *this; +} + +// Changes made to the set of invalid characters must also be reflected in the String documentation. + +static const char32_t invalid_node_name_characters[] = { '.', ':', '@', '/', '\"', '%', 0 }; + +String String::get_invalid_node_name_characters() { + // Do not use this function for critical validation. + String r; + const char32_t *c = invalid_node_name_characters; + while (*c) { + if (c != invalid_node_name_characters) { + r += " "; + } + r += String::chr(*c); + c++; + } + return r; +} + +String String::validate_node_name() const { + // This is a critical validation in node addition, so it must be optimized. + const char32_t *cn = ptr(); + if (cn == nullptr) { + return String(); + } + + bool valid = true; + uint32_t idx = 0; + while (cn[idx]) { + const char32_t *c = invalid_node_name_characters; + while (*c) { + if (cn[idx] == *c) { + valid = false; + break; + } + c++; + } + if (!valid) { + break; + } + idx++; + } + + if (valid) { + return *this; + } + + String validated = *this; + char32_t *nn = validated.ptrw(); + while (nn[idx]) { + const char32_t *c = invalid_node_name_characters; + while (*c) { + if (nn[idx] == *c) { + nn[idx] = '_'; + break; + } + c++; + } + idx++; + } + + return validated; +} + +static _FORCE_INLINE_ bool _is_valid_identifier_bit(int p_index, char32_t p_char) { + if (p_index == 0 && is_digit(p_char)) { + return false; // No start with number plz. + } + return is_ascii_identifier_char(p_char); +} + +String String::validate_identifier() const { + if (empty()) { + return "_"; // Empty string is not a valid identifier; + } + + String result = *this; + int len = result.length(); + char32_t *buffer = result.ptrw(); + + for (int i = 0; i < len; i++) { + if (!_is_valid_identifier_bit(i, buffer[i])) { + buffer[i] = '_'; + } + } + + return result; +} + +bool String::is_valid_identifier() const { + int len = length(); + + if (len == 0) { + return false; + } + + const CharType *str = &operator[](0); + + for (int i = 0; i < len; i++) { + if (i == 0) { + if (str[0] >= '0' && str[0] <= '9') { + return false; // no start with number plz + } + } + + bool valid_char = (str[i] >= '0' && str[i] <= '9') || (str[i] >= 'a' && str[i] <= 'z') || (str[i] >= 'A' && str[i] <= 'Z') || str[i] == '_'; + + if (!valid_char) { + return false; + } + } + + return true; +} + +bool String::is_valid_integer() const { + int len = length(); + + if (len == 0) { + return false; + } + + int from = 0; + if (len != 1 && (operator[](0) == '+' || operator[](0) == '-')) { + from++; + } + + for (int i = from; i < len; i++) { + if (operator[](i) < '0' || operator[](i) > '9') { + return false; // no start with number plz + } + } + + return true; +} + +bool String::is_valid_hex_number(bool p_with_prefix) const { + int len = length(); + + if (len == 0) { + return false; + } + + int from = 0; + if (len != 1 && (operator[](0) == '+' || operator[](0) == '-')) { + from++; + } + + if (p_with_prefix) { + if (len < 3) { + return false; + } + if (operator[](from) != '0' || operator[](from + 1) != 'x') { + return false; + } + from += 2; + } + + for (int i = from; i < len; i++) { + CharType c = operator[](i); + if ((c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F')) { + continue; + } + return false; + } + + return true; +}; + +bool String::is_valid_float() const { + int len = length(); + + if (len == 0) { + return false; + } + + int from = 0; + if (operator[](0) == '+' || operator[](0) == '-') { + from++; + } + + bool exponent_found = false; + bool period_found = false; + bool sign_found = false; + bool exponent_values_found = false; + bool numbers_found = false; + + for (int i = from; i < len; i++) { + if (operator[](i) >= '0' && operator[](i) <= '9') { + if (exponent_found) { + exponent_values_found = true; + } else { + numbers_found = true; + } + } else if (numbers_found && !exponent_found && operator[](i) == 'e') { + exponent_found = true; + } else if (!period_found && !exponent_found && operator[](i) == '.') { + period_found = true; + } else if ((operator[](i) == '-' || operator[](i) == '+') && exponent_found && !exponent_values_found && !sign_found) { + sign_found = true; + } else { + return false; // no start with number plz + } + } + + return numbers_found; +} + +bool String::is_valid_bool() const { + int size = length(); + + if (size == 1) { + CharType c = ptr()[0]; + + if (c == '0') { + return true; + } else if (c == '1') { + return true; + } + + return false; + } else if (size == 4) { + String l = to_lower(); + const CharType *p = l.ptr(); + + if (p[0] == 't' && p[1] == 'r' && p[2] == 'u' && p[3] == 'e') { + return true; + } else { + return false; + } + } else if (size == 5) { + String l = to_lower(); + const CharType *p = l.ptr(); + + if (p[0] == 'f' && p[1] == 'a' && p[2] == 'l' && p[3] == 's' && p[3] == 'e') { + return true; + } else { + return false; + } + } + + return false; +} + +bool String::is_valid_unsigned_integer() const { + int len = length(); + + if (len == 0) { + return false; + } + + int from = 0; + if (len != 1 && (operator[](0) == '+')) { + from++; + } + + for (int i = from; i < len; i++) { + if (operator[](i) < '0' || operator[](i) > '9') { + return false; // no start with number plz + } + } + + return true; +} + +bool String::is_valid_html_color() const { + return Color::html_is_valid(*this); +} + +bool String::is_valid_filename() const { + String stripped = strip_edges(); + if (*this != stripped) { + return false; + } + + if (stripped == String()) { + return false; + } + + return !(find(":") != -1 || find("/") != -1 || find("\\") != -1 || find("?") != -1 || find("*") != -1 || find("\"") != -1 || find("|") != -1 || find("%") != -1 || find("<") != -1 || find(">") != -1); +} + +bool String::is_valid_ip_address() const { + if (find(":") >= 0) { + Vector ip = split(":"); + for (int i = 0; i < ip.size(); i++) { + String n = ip[i]; + if (n.empty()) { + continue; + } + if (n.is_valid_hex_number(false)) { + int nint = n.hex_to_int(false); + if (nint < 0 || nint > 0xffff) { + return false; + } + continue; + }; + if (!n.is_valid_ip_address()) { + return false; + } + }; + + } else { + Vector ip = split("."); + if (ip.size() != 4) { + return false; + } + for (int i = 0; i < ip.size(); i++) { + String n = ip[i]; + if (!n.is_valid_integer()) { + return false; + } + int val = n.to_int(); + if (val < 0 || val > 255) { + return false; + } + } + }; + + return true; +} + +Vector String::to_ascii_buffer() const { + const String *s = this; + if (s->empty()) { + return Vector(); + } + CharString charstr = s->ascii(); + + Vector retval; + size_t len = charstr.length(); + retval.resize(len); + uint8_t *w = retval.ptrw(); + memcpy(w, charstr.ptr(), len); + + return retval; +} + +Vector String::to_utf8_buffer() const { + const String *s = this; + if (s->empty()) { + return Vector(); + } + CharString charstr = s->utf8(); + + Vector retval; + size_t len = charstr.length(); + retval.resize(len); + uint8_t *w = retval.ptrw(); + memcpy(w, charstr.ptr(), len); + + return retval; +} + +Vector String::to_utf16_buffer() const { + const String *s = this; + if (s->empty()) { + return Vector(); + } + Char16String charstr = s->utf16(); + + Vector retval; + size_t len = charstr.length() * sizeof(char16_t); + retval.resize(len); + uint8_t *w = retval.ptrw(); + memcpy(w, (const void *)charstr.ptr(), len); + + return retval; +} + +Vector String::to_utf32_buffer() const { + const String *s = this; + if (s->empty()) { + return Vector(); + } + + Vector retval; + size_t len = s->length() * sizeof(CharType); + retval.resize(len); + uint8_t *w = retval.ptrw(); + memcpy(w, (const void *)s->ptr(), len); + + return retval; +} + +String::String(const char *p_str) { + copy_from(p_str); +} + +String::String(const wchar_t *p_str) { + copy_from(p_str); +} + +String::String(const CharType *p_str) { + copy_from(p_str); +} + +String::String(const char *p_str, int p_clip_to_len) { + copy_from(p_str, p_clip_to_len); +} + +String::String(const wchar_t *p_str, int p_clip_to_len) { + copy_from(p_str, p_clip_to_len); +} + +String::String(const CharType *p_str, int p_clip_to_len) { + copy_from(p_str, p_clip_to_len); +} + +String::String(const StrRange &p_range) { + if (!p_range.c_str) { + return; + } + copy_from(p_range.c_str, p_range.len); +} + +// Other conversions + +int String::hex_to_int(bool p_with_prefix) const { + int len = length(); + ERR_FAIL_COND_V_MSG(p_with_prefix ? len < 3 : len == 0, 0, String("Invalid hexadecimal notation length in string ") + (p_with_prefix ? "with" : "without") + " prefix \"" + *this + "\"."); + + const CharType *s = ptr(); + + int sign = s[0] == '-' ? -1 : 1; + + if (sign < 0) { + s++; + } + + if (p_with_prefix) { + ERR_FAIL_COND_V_MSG(s[0] != '0' || LOWERCASE(s[1]) != 'x', 0, "Invalid hexadecimal notation prefix in string \"" + *this + "\"."); + s += 2; + } + + int hex = 0; + + while (*s) { + CharType c = LOWERCASE(*s); + int n; + if (c >= '0' && c <= '9') { + n = c - '0'; + } else if (c >= 'a' && c <= 'f') { + n = (c - 'a') + 10; + } else { + ERR_FAIL_V_MSG(0, "Invalid hexadecimal notation character \"" + chr(*s) + "\" in string \"" + *this + "\"."); + } + // Check for overflow/underflow, with special case to ensure INT32_MIN does not result in error + bool overflow = ((hex > INT32_MAX / 16) && (sign == 1 || (sign == -1 && hex != (INT32_MAX >> 4) + 1))) || (sign == -1 && hex == (INT32_MAX >> 4) + 1 && c > '0'); + ERR_FAIL_COND_V_MSG(overflow, sign == 1 ? INT32_MAX : INT32_MIN, "Cannot represent " + *this + " as a 32-bit signed integer, since the value is " + (sign == 1 ? "too large." : "too small.")); + hex *= 16; + hex += n; + s++; + } + + return hex * sign; +} + +int64_t String::hex_to_int64(bool p_with_prefix) const { + int len = length(); + ERR_FAIL_COND_V_MSG(p_with_prefix ? len < 3 : len == 0, 0, String("Invalid hexadecimal notation length in string ") + (p_with_prefix ? "with" : "without") + " prefix \"" + *this + "\"."); + + const CharType *s = ptr(); + + int64_t sign = s[0] == '-' ? -1 : 1; + + if (sign < 0) { + s++; + } + + if (p_with_prefix) { + ERR_FAIL_COND_V_MSG(s[0] != '0' || LOWERCASE(s[1]) != 'x', 0, "Invalid hexadecimal notation prefix in string \"" + *this + "\"."); + s += 2; + } + + int64_t hex = 0; + + while (*s) { + CharType c = LOWERCASE(*s); + int64_t n; + if (c >= '0' && c <= '9') { + n = c - '0'; + } else if (c >= 'a' && c <= 'f') { + n = (c - 'a') + 10; + } else { + ERR_FAIL_V_MSG(0, "Invalid hexadecimal notation character \"" + chr(*s) + "\" in string \"" + *this + "\"."); + } + bool overflow = ((hex > INT64_MAX / 16) && (sign == 1 || (sign == -1 && hex != (INT64_MAX >> 4) + 1))) || (sign == -1 && hex == (INT64_MAX >> 4) + 1 && c > '0'); + ERR_FAIL_COND_V_MSG(overflow, sign == 1 ? INT64_MAX : INT64_MIN, "Cannot represent " + *this + " as a 64-bit signed integer, since the value is " + (sign == 1 ? "too large." : "too small.")); + hex *= 16; + hex += n; + s++; + } + + return hex * sign; +} + +int64_t String::bin_to_int64(bool p_with_prefix) const { + int len = length(); + ERR_FAIL_COND_V_MSG(p_with_prefix ? len < 3 : len == 0, 0, String("Invalid binary notation length in string ") + (p_with_prefix ? "with" : "without") + " prefix \"" + *this + "\"."); + + const CharType *s = ptr(); + + int64_t sign = s[0] == '-' ? -1 : 1; + + if (sign < 0) { + s++; + } + + if (p_with_prefix) { + ERR_FAIL_COND_V_MSG(s[0] != '0' || LOWERCASE(s[1]) != 'b', 0, "Invalid binary notation prefix in string \"" + *this + "\"."); + s += 2; + } + + int64_t binary = 0; + + while (*s) { + CharType c = LOWERCASE(*s); + int64_t n; + if (c == '0' || c == '1') { + n = c - '0'; + } else { + ERR_FAIL_V_MSG(0, "Invalid binary notation character \"" + chr(*s) + "\" in string \"" + *this + "\"."); + } + // Check for overflow/underflow, with special case to ensure INT64_MIN does not result in error + bool overflow = ((binary > INT64_MAX / 2) && (sign == 1 || (sign == -1 && binary != (INT64_MAX >> 1) + 1))) || (sign == -1 && binary == (INT64_MAX >> 1) + 1 && c > '0'); + ERR_FAIL_COND_V_MSG(overflow, sign == 1 ? INT64_MAX : INT64_MIN, "Cannot represent " + *this + " as a 64-bit signed integer, since the value is " + (sign == 1 ? "too large." : "too small.")); + binary *= 2; + binary += n; + s++; + } + + return binary * sign; +} + +template +static double built_in_strtod( + /* A decimal ASCII floating-point number, + * optionally preceded by white space. Must + * have form "-I.FE-X", where I is the integer + * part of the mantissa, F is the fractional + * part of the mantissa, and X is the + * exponent. Either of the signs may be "+", + * "-", or omitted. Either I or F may be + * omitted, or both. The decimal point isn't + * necessary unless F is present. The "E" may + * actually be an "e". E and X may both be + * omitted (but not just one). */ + const C *string, + /* If non-nullptr, store terminating Cacter's + * address here. */ + C **endPtr = nullptr) { + /* Largest possible base 10 exponent. Any + * exponent larger than this will already + * produce underflow or overflow, so there's + * no need to worry about additional digits. */ + static const int maxExponent = 511; + /* Table giving binary powers of 10. Entry + * is 10^2^i. Used to convert decimal + * exponents into floating-point numbers. */ + static const double powersOf10[] = { + 10., + 100., + 1.0e4, + 1.0e8, + 1.0e16, + 1.0e32, + 1.0e64, + 1.0e128, + 1.0e256 + }; + + bool sign, expSign = false; + double fraction, dblExp; + const double *d; + const C *p; + int c; + /* Exponent read from "EX" field. */ + int exp = 0; + /* Exponent that derives from the fractional + * part. Under normal circumstances, it is + * the negative of the number of digits in F. + * However, if I is very long, the last digits + * of I get dropped (otherwise a long I with a + * large negative exponent could cause an + * unnecessary overflow on I alone). In this + * case, fracExp is incremented one for each + * dropped digit. */ + int fracExp = 0; + /* Number of digits in mantissa. */ + int mantSize; + /* Number of mantissa digits BEFORE decimal point. */ + int decPt; + /* Temporarily holds location of exponent in string. */ + const C *pExp; + + /* + * Strip off leading blanks and check for a sign. + */ + + p = string; + while (*p == ' ' || *p == '\t' || *p == '\n') { + p += 1; + } + if (*p == '-') { + sign = true; + p += 1; + } else { + if (*p == '+') { + p += 1; + } + sign = false; + } + + /* + * Count the number of digits in the mantissa (including the decimal + * point), and also locate the decimal point. + */ + + decPt = -1; + for (mantSize = 0;; mantSize += 1) { + c = *p; + if (!IS_DIGIT(c)) { + if ((c != '.') || (decPt >= 0)) { + break; + } + decPt = mantSize; + } + p += 1; + } + + /* + * Now suck up the digits in the mantissa. Use two integers to collect 9 + * digits each (this is faster than using floating-point). If the mantissa + * has more than 18 digits, ignore the extras, since they can't affect the + * value anyway. + */ + + pExp = p; + p -= mantSize; + if (decPt < 0) { + decPt = mantSize; + } else { + mantSize -= 1; /* One of the digits was the point. */ + } + if (mantSize > 18) { + fracExp = decPt - 18; + mantSize = 18; + } else { + fracExp = decPt - mantSize; + } + if (mantSize == 0) { + fraction = 0.0; + p = string; + goto done; + } else { + int frac1, frac2; + + frac1 = 0; + for (; mantSize > 9; mantSize -= 1) { + c = *p; + p += 1; + if (c == '.') { + c = *p; + p += 1; + } + frac1 = 10 * frac1 + (c - '0'); + } + frac2 = 0; + for (; mantSize > 0; mantSize -= 1) { + c = *p; + p += 1; + if (c == '.') { + c = *p; + p += 1; + } + frac2 = 10 * frac2 + (c - '0'); + } + fraction = (1.0e9 * frac1) + frac2; + } + + /* + * Skim off the exponent. + */ + + p = pExp; + if ((*p == 'E') || (*p == 'e')) { + p += 1; + if (*p == '-') { + expSign = true; + p += 1; + } else { + if (*p == '+') { + p += 1; + } + expSign = false; + } + if (!IS_DIGIT(CharType(*p))) { + p = pExp; + goto done; + } + while (IS_DIGIT(CharType(*p))) { + exp = exp * 10 + (*p - '0'); + p += 1; + } + } + if (expSign) { + exp = fracExp - exp; + } else { + exp = fracExp + exp; + } + + /* + * Generate a floating-point number that represents the exponent. Do this + * by processing the exponent one bit at a time to combine many powers of + * 2 of 10. Then combine the exponent with the fraction. + */ + + if (exp < 0) { + expSign = true; + exp = -exp; + } else { + expSign = false; + } + + if (exp > maxExponent) { + exp = maxExponent; + //WARN_PRINT("Exponent too high"); + } + dblExp = 1.0; + for (d = powersOf10; exp != 0; exp >>= 1, ++d) { + if (exp & 01) { + dblExp *= *d; + } + } + if (expSign) { + fraction /= dblExp; + } else { + fraction *= dblExp; + } + +done: + if (endPtr != nullptr) { + *endPtr = (C *)p; + } + + if (sign) { + return -fraction; + } + return fraction; +} + +double String::to_double() const { + if (empty()) { + return 0; + } + + return built_in_strtod(get_data()); +} + +float String::to_float() const { + if (empty()) { + return 0; + } + + return built_in_strtod(get_data()); +} + +int String::to_int() const { + if (length() == 0) { + return 0; + } + + int to = (find(".") >= 0) ? find(".") : length(); + + int integer = 0; + int sign = 1; + + for (int i = 0; i < to; i++) { + CharType c = operator[](i); + if (c >= '0' && c <= '9') { + bool overflow = (integer > INT32_MAX / 10) || (integer == INT32_MAX / 10 && ((sign == 1 && c > '7') || (sign == -1 && c > '8'))); + ERR_FAIL_COND_V_MSG(overflow, sign == 1 ? INT32_MAX : INT32_MIN, "Cannot represent " + *this + " as a 32-bit signed integer, since the value is " + (sign == 1 ? "too large." : "too small.")); + integer *= 10; + integer += c - '0'; + + } else if (integer == 0 && c == '-') { + sign = -sign; + } + } + + return integer * sign; +} + +bool String::to_bool() const { + if (length() == 0) { + return false; + } + + if (is_numeric()) { + return to_int() != 0; + } + + return to_lower() == "true"; +} + +uint32_t String::to_uint() const { + if (is_numeric()) { + return static_cast(to_int()); + } + + return 0; +} + +int64_t String::to_int64() const { + if (length() == 0) { + return 0; + } + + int to = (find(".") >= 0) ? find(".") : length(); + + int64_t integer = 0; + int64_t sign = 1; + + for (int i = 0; i < to; i++) { + CharType c = operator[](i); + if (c >= '0' && c <= '9') { + bool overflow = (integer > INT64_MAX / 10) || (integer == INT64_MAX / 10 && ((sign == 1 && c > '7') || (sign == -1 && c > '8'))); + ERR_FAIL_COND_V_MSG(overflow, sign == 1 ? INT64_MAX : INT64_MIN, "Cannot represent " + *this + " as a 64-bit signed integer, since the value is " + (sign == 1 ? "too large." : "too small.")); + integer *= 10; + integer += c - '0'; + + } else if (integer == 0 && c == '-') { + sign = -sign; + } + } + + return integer * sign; +} + +int64_t String::to_int(const char *p_str, int p_len) { + int to = 0; + if (p_len >= 0) { + to = p_len; + } else { + while (p_str[to] != 0 && p_str[to] != '.') { + to++; + } + } + + int64_t integer = 0; + int64_t sign = 1; + + for (int i = 0; i < to; i++) { + char c = p_str[i]; + if (is_digit(c)) { + bool overflow = (integer > INT64_MAX / 10) || (integer == INT64_MAX / 10 && ((sign == 1 && c > '7') || (sign == -1 && c > '8'))); + ERR_FAIL_COND_V_MSG(overflow, sign == 1 ? INT64_MAX : INT64_MIN, "Cannot represent " + String(p_str).substr(0, to) + " as a 64-bit signed integer, since the value is " + (sign == 1 ? "too large." : "too small.")); + integer *= 10; + integer += c - '0'; + + } else if (c == '-' && integer == 0) { + sign = -sign; + } else if (c != ' ') { + break; + } + } + + return integer * sign; +} + +int64_t String::to_int(const wchar_t *p_str, int p_len) { + int to = 0; + if (p_len >= 0) { + to = p_len; + } else { + while (p_str[to] != 0 && p_str[to] != '.') { + to++; + } + } + + int64_t integer = 0; + int64_t sign = 1; + + for (int i = 0; i < to; i++) { + wchar_t c = p_str[i]; + if (is_digit(c)) { + bool overflow = (integer > INT64_MAX / 10) || (integer == INT64_MAX / 10 && ((sign == 1 && c > '7') || (sign == -1 && c > '8'))); + ERR_FAIL_COND_V_MSG(overflow, sign == 1 ? INT64_MAX : INT64_MIN, "Cannot represent " + String(p_str).substr(0, to) + " as a 64-bit signed integer, since the value is " + (sign == 1 ? "too large." : "too small.")); + integer *= 10; + integer += c - '0'; + + } else if (c == '-' && integer == 0) { + sign = -sign; + } else if (c != ' ') { + break; + } + } + + return integer * sign; +} + +int64_t String::to_int(const CharType *p_str, int p_len, bool p_clamp) { + if (p_len == 0 || !p_str[0]) { + return 0; + } + ///@todo make more exact so saving and loading does not lose precision + + int64_t integer = 0; + int64_t sign = 1; + int reading = READING_SIGN; + + const CharType *str = p_str; + const CharType *limit = &p_str[p_len]; + + while (*str && reading != READING_DONE && str != limit) { + CharType c = *(str++); + switch (reading) { + case READING_SIGN: { + if (is_digit(c)) { + reading = READING_INT; + // let it fallthrough + } else if (c == '-') { + sign = -1; + reading = READING_INT; + break; + } else if (c == '+') { + sign = 1; + reading = READING_INT; + break; + } else { + break; + } + FALLTHROUGH; + } + case READING_INT: { + if (is_digit(c)) { + if (integer > INT64_MAX / 10) { + String number(""); + str = p_str; + while (*str && str != limit) { + number += *(str++); + } + if (p_clamp) { + if (sign == 1) { + return INT64_MAX; + } else { + return INT64_MIN; + } + } else { + ERR_FAIL_V_MSG(sign == 1 ? INT64_MAX : INT64_MIN, "Cannot represent " + number + " as a 64-bit signed integer, since the value is " + (sign == 1 ? "too large." : "too small.")); + } + } + integer *= 10; + integer += c - '0'; + } else { + reading = READING_DONE; + } + + } break; + } + } + + return sign * integer; +} + +double String::to_float(const char *p_str) { + return built_in_strtod(p_str); +} + +double String::to_float(const wchar_t *p_str, const wchar_t **r_end) { + return built_in_strtod(p_str, (wchar_t **)r_end); +} +double String::to_float(const CharType *p_str, const CharType **r_end) { + return built_in_strtod(p_str, (CharType **)r_end); +} + +double String::to_double(const char *p_str) { + return built_in_strtod(p_str); +} + +double String::to_double(const wchar_t *p_str, const wchar_t **r_end) { + return built_in_strtod(p_str, (wchar_t **)r_end); +} +double String::to_double(const CharType *p_str, const CharType **r_end) { + return built_in_strtod(p_str, (CharType **)r_end); +} + +uint32_t String::num_characters(int64_t p_int) { + int r = 1; + if (p_int < 0) { + r += 1; + if (p_int == INT64_MIN) { + p_int = INT64_MAX; + } else { + p_int = -p_int; + } + } + while (p_int >= 10) { + p_int /= 10; + r++; + } + return r; +} + +bool String::_base_is_subsequence_of(const String &p_string, bool case_insensitive) const { + int len = length(); + if (len == 0) { + // Technically an empty string is subsequence of any string + return true; + } + + if (len > p_string.length()) { + return false; + } + + const CharType *src = &operator[](0); + const CharType *tgt = &p_string[0]; + + for (; *src && *tgt; tgt++) { + bool match = false; + if (case_insensitive) { + CharType srcc = _find_lower(*src); + CharType tgtc = _find_lower(*tgt); + match = srcc == tgtc; + } else { + match = *src == *tgt; + } + if (match) { + src++; + if (!*src) { + return true; + } + } + } + + return false; +} + +bool operator==(const char *p_chr, const String &p_str) { + return p_str == p_chr; +} + +bool operator==(const wchar_t *p_chr, const String &p_str) { +#ifdef WINDOWS_ENABLED + // wchar_t is 16-bit + return p_str == String::utf16((const char16_t *)p_chr); +#else + // wchar_t is 32-bi + return p_str == String((const CharType *)p_chr); +#endif +} + +bool operator!=(const char *p_chr, const String &p_str) { + return !(p_str == p_chr); +} + +bool operator!=(const wchar_t *p_chr, const String &p_str) { +#ifdef WINDOWS_ENABLED + // wchar_t is 16-bit + return !(p_str == String::utf16((const char16_t *)p_chr)); +#else + // wchar_t is 32-bi + return !(p_str == String((const CharType *)p_chr)); +#endif +} + +String operator+(const char *p_chr, const String &p_str) { + String tmp = p_chr; + tmp += p_str; + return tmp; +} + +String operator+(const wchar_t *p_chr, const String &p_str) { +#ifdef WINDOWS_ENABLED + // wchar_t is 16-bit + String tmp = String::utf16((const char16_t *)p_chr); +#else + // wchar_t is 32-bit + String tmp = (const CharType *)p_chr; +#endif + tmp += p_str; + return tmp; +} + +String operator+(CharType p_chr, const String &p_str) { + return (String::chr(p_chr) + p_str); +} + +String itos(int64_t p_val) { + return String::num_int64(p_val); +} + +String uitos(uint64_t p_val) { + return String::num_uint64(p_val); +} + +String rtos(double p_val) { + return String::num(p_val); +} + +String rtoss(double p_val) { + return String::num_scientific(p_val); +} + +#ifdef TOOLS_ENABLED +String TTR(const String &p_text, const String &p_context) { + return p_text; +} + +/* DTR is used for the documentation, handling descriptions extracted from the XML. + * It also replaces `$DOCS_URL` with the actual URL to the documentation's branch, + * to allow dehardcoding it in the XML and doing proper substitutions everywhere. + */ +String DTR(const String &p_text) { + // Comes straight from the XML, so remove indentation and any trailing whitespace. + const String text = p_text.dedent().strip_edges(); + + return text.replace("$DOCS_URL", VERSION_DOCS_URL); +} +#endif + +String RTR(const String &p_text) { + return p_text; +} +#line 0 + +#line 1 "sfwl/core/logger.cpp" + +void RLogger::print_trace(const String &str) { + print_trace(str.utf8().get_data()); +} +void RLogger::print_trace(const char *str) { + printf("T %s\n", str); +} +void RLogger::print_trace(const char *p_function, const char *p_file, int p_line, const char *str) { + printf("T | %s::%s:%d | %s\n", p_file, p_function, p_line, str); +} +void RLogger::print_trace(const char *p_function, const char *p_file, int p_line, const String &str) { + printf("T | %s::%s:%d | %s\n", p_file, p_function, p_line, str.utf8().get_data()); +} + +void RLogger::print_message(const String &str) { + print_message(str.utf8().get_data()); +} +void RLogger::print_message(const char *str) { + printf("M %s\n", str); +} +void RLogger::print_message(const char *p_function, const char *p_file, int p_line, const char *str) { + printf("M | %s::%s:%d | %s\n", p_file, p_function, p_line, str); +} +void RLogger::print_message(const char *p_function, const char *p_file, int p_line, const String &str) { + printf("M | %s::%s:%d | %s\n", p_file, p_function, p_line, str.utf8().get_data()); +} + +void RLogger::print_warning(const String &str) { + print_warning(str.utf8().get_data()); +} +void RLogger::print_warning(const char *str) { + printf("W %s\n", str); +} +void RLogger::print_warning(const char *p_function, const char *p_file, int p_line, const char *str) { + printf("W | %s::%s:%d | %s\n", p_file, p_function, p_line, str); +} +void RLogger::print_warning(const char *p_function, const char *p_file, int p_line, const String &str) { + printf("W | %s::%s:%d | %s\n", p_file, p_function, p_line, str.utf8().get_data()); +} + +void RLogger::print_error(const String &str) { + print_error(str.utf8().get_data()); +} +void RLogger::print_error(const char *str) { + printf("E %s\n", str); +} + +void RLogger::print_error(const char *p_function, const char *p_file, int p_line, const char *str) { + printf("E | %s::%s:%d | %s\n", p_file, p_function, p_line, str); +} +void RLogger::print_error(const char *p_function, const char *p_file, int p_line, const String &str) { + printf("E | %s::%s:%d | %s\n", p_file, p_function, p_line, str.utf8().get_data()); +} +void RLogger::print_msg_error(const char *p_function, const char *p_file, int p_line, const char *p_msg, const char *str) { + printf("E | %s::%s:%d | :: %s. %s\n", p_file, p_function, p_line, str, p_msg); +} +void RLogger::print_index_error(const char *p_function, const char *p_file, int p_line, const int index, const int size, const char *str) { + printf("E (INDEX) | %s::%s:%d | :: index: %d/%d. %s\n", p_file, p_function, p_line, index, size, str); +} + +void RLogger::log_trace(const String &str) { + log_trace(str.utf8().get_data()); +} +void RLogger::log_trace(const char *str) { + printf("T %s\n", str); +} +void RLogger::log_trace(const char *p_function, const char *p_file, int p_line, const char *str) { + printf("T | %s::%s:%d | %s\n", p_file, p_function, p_line, str); +} +void RLogger::log_trace(const char *p_function, const char *p_file, int p_line, const String &str) { + printf("T | %s::%s:%d | %s\n", p_file, p_function, p_line, str.utf8().get_data()); +} + +void RLogger::log_message(const String &str) { + log_message(str.utf8().get_data()); +} +void RLogger::log_message(const char *str) { + printf("M %s\n", str); +} +void RLogger::log_message(const char *p_function, const char *p_file, int p_line, const char *str) { + printf("M | %s::%s:%d | %s\n", p_file, p_function, p_line, str); +} +void RLogger::log_message(const char *p_function, const char *p_file, int p_line, const String &str) { + printf("M | %s::%s:%d | %s\n", p_file, p_function, p_line, str.utf8().get_data()); +} + +void RLogger::log_warning(const String &str) { + log_warning(str.utf8().get_data()); +} +void RLogger::log_warning(const char *str) { + printf("W %s\n", str); +} +void RLogger::log_warning(const char *p_function, const char *p_file, int p_line, const char *str) { + printf("W | %s::%s:%d | %s\n", p_file, p_function, p_line, str); +} +void RLogger::log_warning(const char *p_function, const char *p_file, int p_line, const String &str) { + printf("W | %s::%s:%d | %s\n", p_file, p_function, p_line, str.utf8().get_data()); +} + +void RLogger::log_error(const String &str) { + log_error(str.utf8().get_data()); +} +void RLogger::log_error(const char *str) { + printf("E %s\n", str); +} + +void RLogger::log_error(const char *p_function, const char *p_file, int p_line, const char *str) { + printf("E | %s::%s:%d | %s\n", p_file, p_function, p_line, str); +} +void RLogger::log_error(const char *p_function, const char *p_file, int p_line, const String &str) { + printf("E | %s::%s:%d | %s\n", p_file, p_function, p_line, str.utf8().get_data()); +} +void RLogger::log_msg_error(const char *p_function, const char *p_file, int p_line, const char *p_msg, const char *str) { + printf("E | %s::%s:%d | :: %s. %s\n", p_file, p_function, p_line, str, p_msg); +} +void RLogger::log_index_error(const char *p_function, const char *p_file, int p_line, const int index, const int size, const char *str) { + printf("E (INDEX) | %s::%s:%d | :: index: %d/%d. %s\n", p_file, p_function, p_line, index, size, str); +} +void RLogger::log_index_error(const char *p_function, const char *p_file, int p_line, const int index, const int size, const String &str) { + printf("E (INDEX) | %s::%s:%d | :: index: %d/%d. %s\n", p_file, p_function, p_line, index, size, str.utf8().get_data()); +} + +String *RLogger::get_string_ptr(const int p_default_size) { + return memnew(String()); +} +String *RLogger::get_string_ptr(const char *p_function, const char *p_file, int p_line, const int p_default_size) { + String *s = memnew(String()); + + s->operator+=(p_function); + s->operator+=("::"); + s->operator+=(p_file); + s->operator+=(":"); + s->operator+=(String::num(p_line)); + s->operator+=(" | "); + + return s; +} +String *RLogger::get_string_ptr(const char *p_prefix, const char *p_function, const char *p_file, int p_line, const int p_default_size) { + String *s = memnew(String()); + + s->operator+=(p_prefix); + s->operator+=(" | "); + s->operator+=(p_function); + s->operator+=("::"); + s->operator+=(p_file); + s->operator+=(":"); + s->operator+=(String::num(p_line)); + s->operator+=(" | "); + + return s; +} +void RLogger::return_string_ptr(String *str) { + delete str; +} + +String *RLogger::get_trace_string_ptr(const int p_default_size) { + String *str = get_string_ptr(p_default_size); + str->operator+=("T "); + return str; +} +String *RLogger::get_message_string_ptr(const int p_default_size) { + String *str = get_string_ptr(p_default_size); + str->operator+=("M "); + return str; +} +String *RLogger::get_warning_string_ptr(const int p_default_size) { + String *str = get_string_ptr(p_default_size); + str->operator+=("W "); + return str; +} +String *RLogger::get_error_string_ptr(const int p_default_size) { + String *str = get_string_ptr(p_default_size); + str->operator+=("E "); + return str; +} + +String *RLogger::get_trace_string_ptr(const char *p_function, const char *p_file, int p_line, const int p_default_size) { + return get_string_ptr("T", p_function, p_file, p_line, p_default_size); +} +String *RLogger::get_message_string_ptr(const char *p_function, const char *p_file, int p_line, const int p_default_size) { + return get_string_ptr("M", p_function, p_file, p_line, p_default_size); +} +String *RLogger::get_warning_string_ptr(const char *p_function, const char *p_file, int p_line, const int p_default_size) { + return get_string_ptr("W", p_function, p_file, p_line, p_default_size); +} +String *RLogger::get_error_string_ptr(const char *p_function, const char *p_file, int p_line, const int p_default_size) { + return get_string_ptr("E", p_function, p_file, p_line, p_default_size); +} + +void RLogger::log_ptr(String *str) { + printf("%s\n", str->utf8().get_data()); +} + +void RLogger::log_ret_ptr(String *str) { + log_ptr(str); + + return_string_ptr(str); +} +#line 0 + +#line 1 "sfwl/core/string_name.cpp" +/*************************************************************************/ +/* string_name.cpp */ +/* From https://github.com/Relintai/pandemonium_engine (MIT) */ +/*************************************************************************/ + +StaticCString StaticCString::create(const char *p_ptr) { + StaticCString scs; + scs.ptr = p_ptr; + return scs; +} + +StringName::_Data *StringName::_table[STRING_TABLE_LEN]; + +StringName _scs_create(const char *p_chr, bool p_static) { + return (p_chr[0] ? StringName(StaticCString::create(p_chr), p_static) : StringName()); +} + +bool StringName::configured = false; +Mutex StringName::lock; + +#ifdef DEBUG_ENABLED +bool StringName::debug_stringname = false; +#endif + +void StringName::setup() { + ERR_FAIL_COND(configured); + for (int i = 0; i < STRING_TABLE_LEN; i++) { + _table[i] = nullptr; + } + configured = true; +} + +void StringName::cleanup() { + lock.lock(); + +#ifdef DEBUG_ENABLED + if (unlikely(debug_stringname)) { + Vector<_Data *> data; + for (int i = 0; i < STRING_TABLE_LEN; i++) { + _Data *d = _table[i]; + while (d) { + data.push_back(d); + d = d->next; + } + } + + print_line("\nStringName reference ranking (from most to least referenced):\n"); + + data.sort_custom(); + int unreferenced_stringnames = 0; + int rarely_referenced_stringnames = 0; + for (int i = 0; i < data.size(); i++) { + print_line(itos(i + 1) + ": " + data[i]->get_name() + " - " + itos(data[i]->debug_references)); + if (data[i]->debug_references == 0) { + unreferenced_stringnames += 1; + } else if (data[i]->debug_references < 5) { + rarely_referenced_stringnames += 1; + } + } + + print_line(vformat("\nOut of %d StringNames, %d StringNames were never referenced during this run (0 times) (%.2f%%).", data.size(), unreferenced_stringnames, unreferenced_stringnames / float(data.size()) * 100)); + print_line(vformat("Out of %d StringNames, %d StringNames were rarely referenced during this run (1-4 times) (%.2f%%).", data.size(), rarely_referenced_stringnames, rarely_referenced_stringnames / float(data.size()) * 100)); + } +#endif + + //int lost_strings = 0; + for (int i = 0; i < STRING_TABLE_LEN; i++) { + while (_table[i]) { + _Data *d = _table[i]; + + /* + if (d->static_count.get() != d->refcount.get()) { + lost_strings++; + if (OS::get_singleton()->is_stdout_verbose()) { + if (d->cname) { + print_line("Orphan StringName: " + String(d->cname)); + } else { + print_line("Orphan StringName: " + String(d->name)); + } + } + } + */ + + _table[i] = _table[i]->next; + memdelete(d); + } + } + + /* + if (lost_strings) { + print_verbose("StringName: " + itos(lost_strings) + " unclaimed string names at exit."); + } + */ + + configured = false; + + lock.unlock(); +} + +void StringName::unref() { + ERR_FAIL_COND(!configured); + + if (_data && _data->refcount.unref()) { + lock.lock(); + + if (_data->static_count.get() > 0) { + if (_data->cname) { + ERR_PRINT("BUG: Unreferenced static string to 0: " + String(_data->cname)); + } else { + ERR_PRINT("BUG: Unreferenced static string to 0: " + String(_data->name)); + } + } + + if (_data->prev) { + _data->prev->next = _data->next; + } else { + if (_table[_data->idx] != _data) { + ERR_PRINT("BUG!"); + } + + _table[_data->idx] = _data->next; + } + + if (_data->next) { + _data->next->prev = _data->prev; + } + + memdelete(_data); + lock.unlock(); + } + + _data = nullptr; +} + +bool StringName::operator==(const String &p_name) const { + if (!_data) { + return (p_name.length() == 0); + } + + return (_data->get_name() == p_name); +} + +bool StringName::operator==(const char *p_name) const { + if (!_data) { + return (p_name[0] == 0); + } + + return (_data->get_name() == p_name); +} + +bool StringName::operator!=(const String &p_name) const { + return !(operator==(p_name)); +} + +bool StringName::operator!=(const StringName &p_name) const { + // the real magic of all this mess happens here. + // this is why path comparisons are very fast + return _data != p_name._data; +} + +void StringName::operator=(const StringName &p_name) { + if (this == &p_name) { + return; + } + + unref(); + + if (p_name._data && p_name._data->refcount.ref()) { + _data = p_name._data; + } +} + +StringName::StringName(const StringName &p_name) { + _data = nullptr; + + ERR_FAIL_COND(!configured); + + if (p_name._data && p_name._data->refcount.ref()) { + _data = p_name._data; + } +} + +StringName::StringName(const char *p_name, bool p_static) { + _data = nullptr; + + ERR_FAIL_COND(!configured); + + if (!p_name || p_name[0] == 0) { + return; //empty, ignore + } + + lock.lock(); + + uint32_t hash = String::hash(p_name); + + uint32_t idx = hash & STRING_TABLE_MASK; + + _data = _table[idx]; + + while (_data) { + // compare hash first + if (_data->hash == hash && _data->get_name() == p_name) { + break; + } + _data = _data->next; + } + + if (_data) { + if (_data->refcount.ref()) { + // exists + if (p_static) { + _data->static_count.increment(); + } + +#ifdef DEBUG_ENABLED + if (unlikely(debug_stringname)) { + _data->debug_references++; + } +#endif + + lock.unlock(); + return; + } + } + + _data = memnew(_Data); + _data->name = p_name; + _data->refcount.init(); + _data->static_count.set(p_static ? 1 : 0); + _data->hash = hash; + _data->idx = idx; + _data->cname = NULL; + _data->next = _table[idx]; + _data->prev = NULL; + +#ifdef DEBUG_ENABLED + if (unlikely(debug_stringname)) { + // Keep in memory, force static. + _data->refcount.ref(); + _data->static_count.increment(); + } +#endif + + if (_table[idx]) { + _table[idx]->prev = _data; + } + + _table[idx] = _data; + + lock.unlock(); +} + +StringName::StringName(const StaticCString &p_static_string, bool p_static) { + _data = NULL; + + ERR_FAIL_COND(!configured); + + ERR_FAIL_COND(!p_static_string.ptr || !p_static_string.ptr[0]); + + lock.lock(); + + uint32_t hash = String::hash(p_static_string.ptr); + + uint32_t idx = hash & STRING_TABLE_MASK; + + _data = _table[idx]; + + while (_data) { + // compare hash first + if (_data->hash == hash && _data->get_name() == p_static_string.ptr) { + break; + } + _data = _data->next; + } + + if (_data) { + if (_data->refcount.ref()) { + // exists + if (p_static) { + _data->static_count.increment(); + } + +#ifdef DEBUG_ENABLED + if (unlikely(debug_stringname)) { + _data->debug_references++; + } +#endif + + lock.unlock(); + return; + } + } + + _data = memnew(_Data); + + _data->refcount.init(); + _data->static_count.set(p_static ? 1 : 0); + _data->hash = hash; + _data->idx = idx; + _data->cname = p_static_string.ptr; + _data->next = _table[idx]; + _data->prev = NULL; + +#ifdef DEBUG_ENABLED + if (unlikely(debug_stringname)) { + // Keep in memory, force static. + _data->refcount.ref(); + _data->static_count.increment(); + } +#endif + + if (_table[idx]) { + _table[idx]->prev = _data; + } + + _table[idx] = _data; + + lock.unlock(); +} + +StringName::StringName(const String &p_name, bool p_static) { + _data = nullptr; + + ERR_FAIL_COND(!configured); + + if (p_name.empty()) { + return; + } + + lock.lock(); + + uint32_t hash = p_name.hash(); + + uint32_t idx = hash & STRING_TABLE_MASK; + + _data = _table[idx]; + + while (_data) { + if (_data->hash == hash && _data->get_name() == p_name) { + break; + } + + _data = _data->next; + } + + if (_data) { + if (_data->refcount.ref()) { + // exists + if (p_static) { + _data->static_count.increment(); + } + +#ifdef DEBUG_ENABLED + if (unlikely(debug_stringname)) { + _data->debug_references++; + } +#endif + + lock.unlock(); + return; + } + } + + _data = memnew(_Data); + _data->name = p_name; + _data->refcount.init(); + _data->static_count.set(p_static ? 1 : 0); + _data->hash = hash; + _data->idx = idx; + _data->cname = NULL; + _data->next = _table[idx]; + _data->prev = NULL; + +#ifdef DEBUG_ENABLED + if (unlikely(debug_stringname)) { + // Keep in memory, force static. + _data->refcount.ref(); + _data->static_count.increment(); + } +#endif + + if (_table[idx]) { + _table[idx]->prev = _data; + } + + _table[idx] = _data; + + lock.unlock(); +} + +StringName StringName::search(const char *p_name) { + ERR_FAIL_COND_V(!configured, StringName()); + + ERR_FAIL_COND_V(!p_name, StringName()); + if (!p_name[0]) { + return StringName(); + } + + lock.lock(); + + uint32_t hash = String::hash(p_name); + + uint32_t idx = hash & STRING_TABLE_MASK; + + _Data *_data = _table[idx]; + + while (_data) { + // compare hash first + if (_data->hash == hash && _data->get_name() == p_name) { + break; + } + _data = _data->next; + } + + if (_data && _data->refcount.ref()) { +#ifdef DEBUG_ENABLED + if (unlikely(debug_stringname)) { + _data->debug_references++; + } +#endif + + lock.unlock(); + + return StringName(_data); + } + + lock.unlock(); + return StringName(); //does not exist +} + +StringName StringName::search(const CharType *p_name) { + ERR_FAIL_COND_V(!configured, StringName()); + + ERR_FAIL_COND_V(!p_name, StringName()); + if (!p_name[0]) { + return StringName(); + } + + lock.lock(); + + uint32_t hash = String::hash(p_name); + + uint32_t idx = hash & STRING_TABLE_MASK; + + _Data *_data = _table[idx]; + + while (_data) { + // compare hash first + if (_data->hash == hash && _data->get_name() == p_name) { + break; + } + + _data = _data->next; + } + + if (_data && _data->refcount.ref()) { + lock.unlock(); + return StringName(_data); + } + + lock.unlock(); + return StringName(); //does not exist +} +StringName StringName::search(const String &p_name) { + ERR_FAIL_COND_V(p_name == "", StringName()); + + lock.lock(); + + uint32_t hash = p_name.hash(); + + uint32_t idx = hash & STRING_TABLE_MASK; + + _Data *_data = _table[idx]; + + while (_data) { + // compare hash first + if (_data->hash == hash && p_name == _data->get_name()) { + break; + } + + _data = _data->next; + } + + if (_data && _data->refcount.ref()) { +#ifdef DEBUG_ENABLED + if (unlikely(debug_stringname)) { + _data->debug_references++; + } +#endif + lock.unlock(); + return StringName(_data); + } + + lock.unlock(); + return StringName(); //does not exist +} + +StringName::StringName() { + _data = nullptr; +} + +/* +bool operator==(const String &p_name, const StringName &p_string_name) { + return p_name == p_string_name.operator String(); +} +bool operator!=(const String &p_name, const StringName &p_string_name) { + return p_name != p_string_name.operator String(); +} + +bool operator==(const char *p_name, const StringName &p_string_name) { + return p_name == p_string_name.operator String(); +} +bool operator!=(const char *p_name, const StringName &p_string_name) { + return p_name != p_string_name.operator String(); +} +*/ +#line 0 + +#line 1 "sfwl/core/color.cpp" +/*************************************************************************/ +/* color.cpp */ +/* From https://github.com/Relintai/pandemonium_engine (MIT) */ +/*************************************************************************/ + +uint32_t Color::to_argb32() const { + uint32_t c = (uint8_t)Math::round(a * 255); + c <<= 8; + c |= (uint8_t)Math::round(r * 255); + c <<= 8; + c |= (uint8_t)Math::round(g * 255); + c <<= 8; + c |= (uint8_t)Math::round(b * 255); + + return c; +} + +uint32_t Color::to_abgr32() const { + uint32_t c = (uint8_t)Math::round(a * 255); + c <<= 8; + c |= (uint8_t)Math::round(b * 255); + c <<= 8; + c |= (uint8_t)Math::round(g * 255); + c <<= 8; + c |= (uint8_t)Math::round(r * 255); + + return c; +} + +uint32_t Color::to_rgba32() const { + uint32_t c = (uint8_t)Math::round(r * 255); + c <<= 8; + c |= (uint8_t)Math::round(g * 255); + c <<= 8; + c |= (uint8_t)Math::round(b * 255); + c <<= 8; + c |= (uint8_t)Math::round(a * 255); + + return c; +} + +uint64_t Color::to_abgr64() const { + uint64_t c = (uint16_t)Math::round(a * 65535); + c <<= 16; + c |= (uint16_t)Math::round(b * 65535); + c <<= 16; + c |= (uint16_t)Math::round(g * 65535); + c <<= 16; + c |= (uint16_t)Math::round(r * 65535); + + return c; +} + +uint64_t Color::to_argb64() const { + uint64_t c = (uint16_t)Math::round(a * 65535); + c <<= 16; + c |= (uint16_t)Math::round(r * 65535); + c <<= 16; + c |= (uint16_t)Math::round(g * 65535); + c <<= 16; + c |= (uint16_t)Math::round(b * 65535); + + return c; +} + +uint64_t Color::to_rgba64() const { + uint64_t c = (uint16_t)Math::round(r * 65535); + c <<= 16; + c |= (uint16_t)Math::round(g * 65535); + c <<= 16; + c |= (uint16_t)Math::round(b * 65535); + c <<= 16; + c |= (uint16_t)Math::round(a * 65535); + + return c; +} + +float Color::get_h() const { + float min = MIN(r, g); + min = MIN(min, b); + float max = MAX(r, g); + max = MAX(max, b); + + float delta = max - min; + + if (delta == 0) { + return 0; + } + + float h; + if (r == max) { + h = (g - b) / delta; // between yellow & magenta + } else if (g == max) { + h = 2 + (b - r) / delta; // between cyan & yellow + } else { + h = 4 + (r - g) / delta; // between magenta & cyan + } + + h /= 6.0; + if (h < 0) { + h += 1.0; + } + + return h; +} + +float Color::get_s() const { + float min = MIN(r, g); + min = MIN(min, b); + float max = MAX(r, g); + max = MAX(max, b); + + float delta = max - min; + + return (max != 0) ? (delta / max) : 0; +} + +float Color::get_v() const { + float max = MAX(r, g); + max = MAX(max, b); + return max; +} + +void Color::set_hsv(float p_h, float p_s, float p_v, float p_alpha) { + int i; + float f, p, q, t; + a = p_alpha; + + if (p_s == 0) { + // acp_hromatic (grey) + r = g = b = p_v; + return; + } + + p_h *= 6.0; + p_h = Math::fmod(p_h, 6); + i = Math::floor(p_h); + + f = p_h - i; + p = p_v * (1 - p_s); + q = p_v * (1 - p_s * f); + t = p_v * (1 - p_s * (1 - f)); + + switch (i) { + case 0: // Red is the dominant color + r = p_v; + g = t; + b = p; + break; + case 1: // Green is the dominant color + r = q; + g = p_v; + b = p; + break; + case 2: + r = p; + g = p_v; + b = t; + break; + case 3: // Blue is the dominant color + r = p; + g = q; + b = p_v; + break; + case 4: + r = t; + g = p; + b = p_v; + break; + default: // (5) Red is the dominant color + r = p_v; + g = p; + b = q; + break; + } +} + +bool Color::is_equal_approx(const Color &p_color) const { + return Math::is_equal_approx(r, p_color.r) && Math::is_equal_approx(g, p_color.g) && Math::is_equal_approx(b, p_color.b) && Math::is_equal_approx(a, p_color.a); +} + +Color Color::clamp(const Color &p_min, const Color &p_max) const { + return Color( + CLAMP(r, p_min.r, p_max.r), + CLAMP(g, p_min.g, p_max.g), + CLAMP(b, p_min.b, p_max.b), + CLAMP(a, p_min.a, p_max.a)); +} + +void Color::invert() { + r = 1.0 - r; + g = 1.0 - g; + b = 1.0 - b; +} +void Color::contrast() { + r = Math::fmod(r + 0.5, 1.0); + g = Math::fmod(g + 0.5, 1.0); + b = Math::fmod(b + 0.5, 1.0); +} + +Color Color::hex(uint32_t p_hex) { + float a = (p_hex & 0xFF) / 255.0; + p_hex >>= 8; + float b = (p_hex & 0xFF) / 255.0; + p_hex >>= 8; + float g = (p_hex & 0xFF) / 255.0; + p_hex >>= 8; + float r = (p_hex & 0xFF) / 255.0; + + return Color(r, g, b, a); +} + +Color Color::hex64(uint64_t p_hex) { + float a = (p_hex & 0xFFFF) / 65535.0; + p_hex >>= 16; + float b = (p_hex & 0xFFFF) / 65535.0; + p_hex >>= 16; + float g = (p_hex & 0xFFFF) / 65535.0; + p_hex >>= 16; + float r = (p_hex & 0xFFFF) / 65535.0; + + return Color(r, g, b, a); +} + +Color Color::from_rgbe9995(uint32_t p_rgbe) { + float r = p_rgbe & 0x1ff; + float g = (p_rgbe >> 9) & 0x1ff; + float b = (p_rgbe >> 18) & 0x1ff; + float e = (p_rgbe >> 27); + float m = Math::pow(2, e - 15.0 - 9.0); + + float rd = r * m; + float gd = g * m; + float bd = b * m; + + return Color(rd, gd, bd, 1.0f); +} + +static float _parse_col(const String &p_str, int p_ofs) { + int ig = 0; + + for (int i = 0; i < 2; i++) { + int c = p_str[i + p_ofs]; + int v = 0; + + if (c >= '0' && c <= '9') { + v = c - '0'; + } else if (c >= 'a' && c <= 'f') { + v = c - 'a'; + v += 10; + } else if (c >= 'A' && c <= 'F') { + v = c - 'A'; + v += 10; + } else { + return -1; + } + + if (i == 0) { + ig += v * 16; + } else { + ig += v; + } + } + + return ig; +} + +Color Color::inverted() const { + Color c = *this; + c.invert(); + return c; +} + +Color Color::contrasted() const { + Color c = *this; + c.contrast(); + return c; +} + +Color Color::html(const String &p_color) { + String color = p_color; + if (color.length() == 0) { + return Color(); + } + if (color[0] == '#') { + color = color.substr(1, color.length() - 1); + } + if (color.length() == 3 || color.length() == 4) { + String exp_color; + for (int i = 0; i < color.length(); i++) { + exp_color += color[i]; + exp_color += color[i]; + } + color = exp_color; + } + + bool alpha = false; + + if (color.length() == 8) { + alpha = true; + } else if (color.length() == 6) { + alpha = false; + } else { + ERR_FAIL_V_MSG(Color(), "Invalid color code: " + p_color + "."); + } + + int a = 255; + if (alpha) { + a = _parse_col(color, 0); + ERR_FAIL_COND_V_MSG(a < 0, Color(), "Invalid color code: " + p_color + "."); + } + + int from = alpha ? 2 : 0; + + int r = _parse_col(color, from + 0); + ERR_FAIL_COND_V_MSG(r < 0, Color(), "Invalid color code: " + p_color + "."); + int g = _parse_col(color, from + 2); + ERR_FAIL_COND_V_MSG(g < 0, Color(), "Invalid color code: " + p_color + "."); + int b = _parse_col(color, from + 4); + ERR_FAIL_COND_V_MSG(b < 0, Color(), "Invalid color code: " + p_color + "."); + + return Color(r / 255.0, g / 255.0, b / 255.0, a / 255.0); +} + +bool Color::html_is_valid(const String &p_color) { + String color = p_color; + + if (color.length() == 0) { + return false; + } + if (color[0] == '#') { + color = color.substr(1, color.length() - 1); + } + + bool alpha = false; + + if (color.length() == 8) { + alpha = true; + } else if (color.length() == 6) { + alpha = false; + } else { + return false; + } + + if (alpha) { + int a = _parse_col(color, 0); + if (a < 0) { + return false; + } + } + + int from = alpha ? 2 : 0; + + int r = _parse_col(color, from + 0); + if (r < 0) { + return false; + } + int g = _parse_col(color, from + 2); + if (g < 0) { + return false; + } + int b = _parse_col(color, from + 4); + if (b < 0) { + return false; + } + + return true; +} + +String _to_hex(float p_val) { + int v = Math::round(p_val * 255); + v = CLAMP(v, 0, 255); + String ret; + + for (int i = 0; i < 2; i++) { + CharType c[2] = { 0, 0 }; + int lv = v & 0xF; + if (lv < 10) { + c[0] = '0' + lv; + } else { + c[0] = 'a' + lv - 10; + } + + v >>= 4; + String cs = (const CharType *)c; + ret = cs + ret; + } + + return ret; +} + +String Color::to_html(bool p_alpha) const { + String txt; + txt += _to_hex(r); + txt += _to_hex(g); + txt += _to_hex(b); + if (p_alpha) { + txt = _to_hex(a) + txt; + } + return txt; +} + +Color Color::from_hsv(float p_h, float p_s, float p_v, float p_a) const { + Color c; + c.set_hsv(p_h, p_s, p_v, p_a); + return c; +} + +Color::operator String() const { + return "(" + String::num(r, 4) + ", " + String::num(g, 4) + ", " + String::num(b, 4) + ", " + String::num(a, 4) + ")"; +} + +Color Color::operator+(const Color &p_color) const { + return Color( + r + p_color.r, + g + p_color.g, + b + p_color.b, + a + p_color.a); +} + +void Color::operator+=(const Color &p_color) { + r = r + p_color.r; + g = g + p_color.g; + b = b + p_color.b; + a = a + p_color.a; +} + +Color Color::operator-(const Color &p_color) const { + return Color( + r - p_color.r, + g - p_color.g, + b - p_color.b, + a - p_color.a); +} + +void Color::operator-=(const Color &p_color) { + r = r - p_color.r; + g = g - p_color.g; + b = b - p_color.b; + a = a - p_color.a; +} + +Color Color::operator*(const Color &p_color) const { + return Color( + r * p_color.r, + g * p_color.g, + b * p_color.b, + a * p_color.a); +} + +Color Color::operator*(const real_t &rvalue) const { + return Color( + r * rvalue, + g * rvalue, + b * rvalue, + a * rvalue); +} + +void Color::operator*=(const Color &p_color) { + r = r * p_color.r; + g = g * p_color.g; + b = b * p_color.b; + a = a * p_color.a; +} + +void Color::operator*=(const real_t &rvalue) { + r = r * rvalue; + g = g * rvalue; + b = b * rvalue; + a = a * rvalue; +} + +Color Color::operator/(const Color &p_color) const { + return Color( + r / p_color.r, + g / p_color.g, + b / p_color.b, + a / p_color.a); +} + +Color Color::operator/(const real_t &rvalue) const { + return Color( + r / rvalue, + g / rvalue, + b / rvalue, + a / rvalue); +} + +void Color::operator/=(const Color &p_color) { + r = r / p_color.r; + g = g / p_color.g; + b = b / p_color.b; + a = a / p_color.a; +} + +void Color::operator/=(const real_t &rvalue) { + if (rvalue == 0) { + r = 1.0; + g = 1.0; + b = 1.0; + a = 1.0; + } else { + r = r / rvalue; + g = g / rvalue; + b = b / rvalue; + a = a / rvalue; + } +}; + +Color Color::operator-() const { + return Color( + 1.0 - r, + 1.0 - g, + 1.0 - b, + 1.0 - a); +} +#line 0 + +#line 1 "sfwl/core/vector2i.cpp" +/*************************************************************************/ +/* vector2i.cpp */ +/* From https://github.com/Relintai/pandemonium_engine (MIT) */ +/*************************************************************************/ + +Vector2i Vector2i::clamp(const Vector2i &p_min, const Vector2i &p_max) const { + return Vector2i( + CLAMP(x, p_min.x, p_max.x), + CLAMP(y, p_min.y, p_max.y)); +} + +int64_t Vector2i::length_squared() const { + return x * (int64_t)x + y * (int64_t)y; +} + +double Vector2i::length() const { + return Math::sqrt((double)length_squared()); +} + +Vector2i Vector2i::operator+(const Vector2i &p_v) const { + return Vector2i(x + p_v.x, y + p_v.y); +} +void Vector2i::operator+=(const Vector2i &p_v) { + x += p_v.x; + y += p_v.y; +} +Vector2i Vector2i::operator-(const Vector2i &p_v) const { + return Vector2i(x - p_v.x, y - p_v.y); +} +void Vector2i::operator-=(const Vector2i &p_v) { + x -= p_v.x; + y -= p_v.y; +} + +Vector2i Vector2i::operator*(const Vector2i &p_v1) const { + return Vector2i(x * p_v1.x, y * p_v1.y); +}; + +Vector2i Vector2i::operator*(const int &rvalue) const { + return Vector2i(x * rvalue, y * rvalue); +}; +void Vector2i::operator*=(const int &rvalue) { + x *= rvalue; + y *= rvalue; +}; + +Vector2i Vector2i::operator/(const Vector2i &p_v1) const { + return Vector2i(x / p_v1.x, y / p_v1.y); +}; + +Vector2i Vector2i::operator/(const int &rvalue) const { + return Vector2i(x / rvalue, y / rvalue); +}; + +void Vector2i::operator/=(const int &rvalue) { + x /= rvalue; + y /= rvalue; +}; + +Vector2i Vector2i::operator-() const { + return Vector2i(-x, -y); +} + +bool Vector2i::operator==(const Vector2i &p_vec2) const { + return x == p_vec2.x && y == p_vec2.y; +} +bool Vector2i::operator!=(const Vector2i &p_vec2) const { + return x != p_vec2.x || y != p_vec2.y; +} + +Vector2i::operator String() const { + return "(" + itos(x) + ", " + itos(y) + ")"; +} +#line 0 + +#line 1 "sfwl/core/rect2i.cpp" +/*************************************************************************/ +/* rect2i.cpp */ +/* From https://github.com/Relintai/pandemonium_engine (MIT) */ +/*************************************************************************/ + +Rect2i::operator String() const { + return "[P: " + position.operator String() + ", S: " + size + "]"; +} +#line 0 + +#line 1 "sfwl/core/pcg.cpp" +// *Really* minimal PCG32 code / (c) 2014 M.E. O'Neill / pcg-random.org +// Licensed under Apache License 2.0 (NO WARRANTY, etc. see website) + +uint32_t pcg32_random_r(pcg32_random_t *rng) { + uint64_t oldstate = rng->state; + // Advance internal state + rng->state = oldstate * 6364136223846793005ULL + (rng->inc | 1); + // Calculate output function (XSH RR), uses old state for max ILP + uint32_t xorshifted = ((oldstate >> 18u) ^ oldstate) >> 27u; + uint32_t rot = oldstate >> 59u; + return (xorshifted >> rot) | (xorshifted << ((-rot) & 31)); +} + +// Source from http://www.pcg-random.org/downloads/pcg-c-basic-0.9.zip +void pcg32_srandom_r(pcg32_random_t *rng, uint64_t initstate, uint64_t initseq) { + rng->state = 0U; + rng->inc = (initseq << 1u) | 1u; + pcg32_random_r(rng); + rng->state += initstate; + pcg32_random_r(rng); +} + +// Source from https://github.com/imneme/pcg-c-basic/blob/master/pcg_basic.c +// pcg32_boundedrand_r(rng, bound): +// Generate a uniformly distributed number, r, where 0 <= r < bound +uint32_t pcg32_boundedrand_r(pcg32_random_t *rng, uint32_t bound) { + // To avoid bias, we need to make the range of the RNG a multiple of + // bound, which we do by dropping output less than a threshold. + // A naive scheme to calculate the threshold would be to do + // + // uint32_t threshold = 0x100000000ull % bound; + // + // but 64-bit div/mod is slower than 32-bit div/mod (especially on + // 32-bit platforms). In essence, we do + // + // uint32_t threshold = (0x100000000ull-bound) % bound; + // + // because this version will calculate the same modulus, but the LHS + // value is less than 2^32. + uint32_t threshold = -bound % bound; + + // Uniformity guarantees that this loop will terminate. In practice, it + // should usually terminate quickly; on average (assuming all bounds are + // equally likely), 82.25% of the time, we can expect it to require just + // one iteration. In the worst case, someone passes a bound of 2^31 + 1 + // (i.e., 2147483649), which invalidates almost 50% of the range. In + // practice, bounds are typically small and only a tiny amount of the range + // is eliminated. + for (;;) { + uint32_t r = pcg32_random_r(rng); + if (r >= threshold) + return r % bound; + } +} +#line 0 + +#line 1 "sfwl/core/file_access.cpp" + +/*************************************************************************/ +/* file_access.cpp */ +/* From https://github.com/Relintai/pandemonium_engine (MIT) */ +/*************************************************************************/ + +#if defined(_WIN64) || defined(_WIN32) + +#include // _SH_DENYNO +#include +#define WIN32_LEAN_AND_MEAN +#include + +#include +#include +#include +#include +#include + +#ifdef _MSC_VER +#define S_ISREG(m) ((m)&_S_IFREG) +#endif + +#else + +#include +#include +#include + +#include + +#include + +#ifdef MSVC +#define S_ISREG(m) ((m)&_S_IFREG) +#include +#endif +#ifndef S_ISREG +#define S_ISREG(m) ((m)&S_IFREG) +#endif + +#ifndef NO_FCNTL +#include +#else +#include +#endif + +#endif + +#if defined(_WIN64) || defined(_WIN32) + +void FileAccess::check_errors() const { + ERR_FAIL_COND(!f); + + if (feof(f)) { + last_error = ERR_FILE_EOF; + } +} + +Error FileAccess::_open(const String &p_path, int p_mode_flags) { + path_src = p_path; + path = fix_path(p_path); + + if (f) { + close(); + } + + const WCHAR *mode_string; + + if (p_mode_flags == READ) { + mode_string = L"rb"; + } else if (p_mode_flags == WRITE) { + mode_string = L"wb"; + } else if (p_mode_flags == READ_WRITE) { + mode_string = L"rb+"; + } else if (p_mode_flags == WRITE_READ) { + mode_string = L"wb+"; + } else { + return ERR_INVALID_PARAMETER; + } + + /* pretty much every implementation that uses fopen as primary + backend supports utf8 encoding */ + + struct _stat st; + if (_wstat((LPCWSTR)(path.utf16().get_data()), &st) == 0) { + if (!S_ISREG(st.st_mode)) { + return ERR_FILE_CANT_OPEN; + } + }; + +#ifdef TOOLS_ENABLED + // Windows is case insensitive, but all other platforms are sensitive to it + // To ease cross-platform development, we issue a warning if users try to access + // a file using the wrong case (which *works* on Windows, but won't on other + // platforms). + if (p_mode_flags == READ) { + WIN32_FIND_DATAW d; + HANDLE f = FindFirstFileW((LPCWSTR)(path.utf16().get_data()), &d); + + if (f != INVALID_HANDLE_VALUE) { + String fname = String::utf16((const char16_t *)(d.cFileName)); + + if (fname != String()) { + String base_file = path.get_file(); + if (base_file != fname && base_file.findn(fname) == 0) { + WARN_PRINT("Case mismatch opening requested file '" + base_file + "', stored as '" + fname + "' in the filesystem. This file will not open when exported to other case-sensitive platforms."); + } + } + + FindClose(f); + } + } +#endif + + if (is_backup_save_enabled() && p_mode_flags & WRITE && !(p_mode_flags & READ)) { + save_path = path; + path = path + ".tmp"; + } + + f = _wfsopen((LPCWSTR)(path.utf16().get_data()), mode_string, _SH_DENYNO); + + if (f == nullptr) { + switch (errno) { + case ENOENT: { + last_error = ERR_FILE_NOT_FOUND; + } break; + default: { + last_error = ERR_FILE_CANT_OPEN; + } break; + } + return last_error; + } else { + last_error = OK; + flags = p_mode_flags; + return OK; + } +} + +void FileAccess::close() { + if (!f) { + return; + } + + fclose(f); + f = NULL; + + if (save_path != "") { + bool rename_error = true; + int attempts = 4; + while (rename_error && attempts) { + // This workaround of trying multiple times is added to deal with paranoid Windows + // antiviruses that love reading just written files even if they are not executable, thus + // locking the file and preventing renaming from happening. + +#ifdef UWP_ENABLED + // UWP has no PathFileExists, so we check attributes instead + DWORD fileAttr; + + fileAttr = GetFileAttributesW((LPCWSTR)(save_path.utf16().get_data())); + if (INVALID_FILE_ATTRIBUTES == fileAttr) { +#else + if (!PathFileExistsW((LPCWSTR)(save_path.utf16().get_data()))) { +#endif + //creating new file + rename_error = _wrename((LPCWSTR)((save_path + ".tmp").utf16().get_data()), (LPCWSTR)(save_path.utf16().get_data())) != 0; + } else { + //atomic replace for existing file + rename_error = !ReplaceFileW((LPCWSTR)(save_path.utf16().get_data()), (LPCWSTR)((save_path + ".tmp").utf16().get_data()), NULL, 2 | 4, NULL, NULL); + } + if (rename_error) { + attempts--; + SFWTime::sleep_us(100000); // wait 100msec and try again + } + } + + if (rename_error) { + if (close_fail_notify) { + close_fail_notify(save_path); + } + } + + save_path = ""; + + ERR_FAIL_COND_MSG(rename_error, "Safe save failed. This may be a permissions problem, but also may happen because you are running a paranoid antivirus. If this is the case, please switch to Windows Defender or disable the 'safe save' option in editor settings. This makes it work, but increases the risk of file corruption in a crash."); + } +} + +String FileAccess::get_path() const { + return path_src; +} + +String FileAccess::get_path_absolute() const { + return path; +} + +bool FileAccess::is_open() const { + return (f != NULL); +} + +void FileAccess::seek(uint64_t p_position) { + ERR_FAIL_COND(!f); + + last_error = OK; + + if (_fseeki64(f, p_position, SEEK_SET)) { + check_errors(); + } + + prev_op = 0; +} + +void FileAccess::seek_end(int64_t p_position) { + ERR_FAIL_COND(!f); + + if (_fseeki64(f, p_position, SEEK_END)) { + check_errors(); + } + + prev_op = 0; +} + +uint64_t FileAccess::get_position() const { + int64_t aux_position = _ftelli64(f); + + if (aux_position < 0) { + check_errors(); + } + + return aux_position; +} + +uint64_t FileAccess::get_len() const { + ERR_FAIL_COND_V(!f, 0); + + uint64_t pos = get_position(); + _fseeki64(f, 0, SEEK_END); + uint64_t size = get_position(); + _fseeki64(f, pos, SEEK_SET); + + return size; +} + +bool FileAccess::eof_reached() const { + check_errors(); + return last_error == ERR_FILE_EOF; +} + +uint8_t FileAccess::get_8() const { + ERR_FAIL_COND_V(!f, 0); + if (flags == READ_WRITE || flags == WRITE_READ) { + if (prev_op == WRITE) { + fflush(f); + } + prev_op = READ; + } + uint8_t b; + if (fread(&b, 1, 1, f) == 0) { + check_errors(); + b = '\0'; + }; + + return b; +} + +uint64_t FileAccess::get_buffer(uint8_t *p_dst, uint64_t p_length) const { + ERR_FAIL_COND_V(!p_dst && p_length > 0, -1); + ERR_FAIL_COND_V(!f, -1); + + if (flags == READ_WRITE || flags == WRITE_READ) { + if (prev_op == WRITE) { + fflush(f); + } + prev_op = READ; + } + uint64_t read = fread(p_dst, 1, p_length, f); + check_errors(); + return read; +}; + +Error FileAccess::get_error() const { + return last_error; +} + +void FileAccess::flush() { + ERR_FAIL_COND(!f); + fflush(f); + + if (prev_op == WRITE) { + prev_op = 0; + } +} + +void FileAccess::store_8(uint8_t p_dest) { + ERR_FAIL_COND(!f); + if (flags == READ_WRITE || flags == WRITE_READ) { + if (prev_op == READ) { + if (last_error != ERR_FILE_EOF) { + fseek(f, 0, SEEK_CUR); + } + } + prev_op = WRITE; + } + fwrite(&p_dest, 1, 1, f); +} + +void FileAccess::store_buffer(const uint8_t *p_src, uint64_t p_length) { + ERR_FAIL_COND(!f); + ERR_FAIL_COND(!p_src && p_length > 0); + + if (flags == READ_WRITE || flags == WRITE_READ) { + if (prev_op == READ) { + if (last_error != ERR_FILE_EOF) { + fseek(f, 0, SEEK_CUR); + } + } + prev_op = WRITE; + } + ERR_FAIL_COND(fwrite(p_src, 1, p_length, f) != (size_t)p_length); +} + +bool FileAccess::file_exists(const String &p_name) { + String filename = fix_path(p_name); + + FILE *g = _wfsopen((LPCWSTR)(filename.utf16().get_data()), L"rb", _SH_DENYNO); + + if (g == nullptr) { + return false; + } else { + fclose(g); + return true; + } +} + +uint64_t FileAccess::_get_modified_time(const String &p_file) { + String file = fix_path(p_file); + if (file.ends_with("/") && file != "/") + file = file.substr(0, file.length() - 1); + + struct _stat st; + int rv = _wstat((LPCWSTR)(file.utf16().get_data()), &st); + + if (rv == 0) { + return st.st_mtime; + } else { + LOG_TRACE("Failed to get modified time for: " + p_file + ""); + return 0; + } +} + +uint32_t FileAccess::_get_unix_permissions(const String &p_file) { + return 0; +} + +Error FileAccess::_set_unix_permissions(const String &p_file, uint32_t p_permissions) { + return ERR_UNAVAILABLE; +} + +FileAccess::FileAccess() : + f(NULL), + flags(0), + prev_op(0), + last_error(OK) { +} +FileAccess::~FileAccess() { + close(); +} + +#else + +void FileAccess::check_errors() const { + ERR_FAIL_COND_MSG(!f, "File must be opened before use."); + + if (feof(f)) { + last_error = ERR_FILE_EOF; + } +} + +Error FileAccess::_open(const String &p_path, int p_mode_flags) { + if (f) { + fclose(f); + } + f = nullptr; + + path_src = p_path; + path = fix_path(p_path); + //printf("opening %s, %i\n", path.utf8().get_data(), Memory::get_static_mem_usage()); + + ERR_FAIL_COND_V_MSG(f, ERR_ALREADY_IN_USE, "File is already in use."); + const char *mode_string; + + if (p_mode_flags == READ) { + mode_string = "rb"; + } else if (p_mode_flags == WRITE) { + mode_string = "wb"; + } else if (p_mode_flags == READ_WRITE) { + mode_string = "rb+"; + } else if (p_mode_flags == WRITE_READ) { + mode_string = "wb+"; + } else { + return ERR_INVALID_PARAMETER; + } + + /* pretty much every implementation that uses fopen as primary + backend (unix-compatible mostly) supports utf8 encoding */ + + //printf("opening %s as %s\n", p_path.utf8().get_data(), path.utf8().get_data()); + struct stat st; + int err = stat(path.utf8().get_data(), &st); + if (!err) { + switch (st.st_mode & S_IFMT) { + case S_IFLNK: + case S_IFREG: + break; + default: + return ERR_FILE_CANT_OPEN; + } + } + + if (is_backup_save_enabled() && (p_mode_flags & WRITE) && !(p_mode_flags & READ)) { + save_path = path; + path = path + ".tmp"; + } + + f = fopen(path.utf8().get_data(), mode_string); + + if (f == nullptr) { + switch (errno) { + case ENOENT: { + last_error = ERR_FILE_NOT_FOUND; + } break; + default: { + last_error = ERR_FILE_CANT_OPEN; + } break; + } + return last_error; + } + + // Set close on exec to avoid leaking it to subprocesses. + int fd = fileno(f); + + if (fd != -1) { +#if defined(NO_FCNTL) + unsigned long par = 0; + ioctl(fd, FIOCLEX, &par); +#else + int opts = fcntl(fd, F_GETFD); + fcntl(fd, F_SETFD, opts | FD_CLOEXEC); +#endif + } + + last_error = OK; + flags = p_mode_flags; + return OK; +} + +void FileAccess::close() { + if (!f) { + return; + } + + fclose(f); + f = nullptr; + + if (close_notification_func) { + close_notification_func(path, flags); + } + + if (save_path != "") { + int rename_error = rename((save_path + ".tmp").utf8().get_data(), save_path.utf8().get_data()); + + if (rename_error && close_fail_notify) { + close_fail_notify(save_path); + } + + save_path = ""; + ERR_FAIL_COND(rename_error != 0); + } +} + +bool FileAccess::is_open() const { + return (f != nullptr); +} + +String FileAccess::get_path() const { + return path_src; +} + +String FileAccess::get_path_absolute() const { + return path; +} + +void FileAccess::seek(uint64_t p_position) { + ERR_FAIL_COND_MSG(!f, "File must be opened before use."); + + last_error = OK; + if (fseeko(f, p_position, SEEK_SET)) { + check_errors(); + } +} + +void FileAccess::seek_end(int64_t p_position) { + ERR_FAIL_COND_MSG(!f, "File must be opened before use."); + + if (fseeko(f, p_position, SEEK_END)) { + check_errors(); + } +} + +uint64_t FileAccess::get_position() const { + ERR_FAIL_COND_V_MSG(!f, 0, "File must be opened before use."); + + int64_t pos = ftello(f); + if (pos < 0) { + check_errors(); + ERR_FAIL_V(0); + } + return pos; +} + +uint64_t FileAccess::get_len() const { + ERR_FAIL_COND_V_MSG(!f, 0, "File must be opened before use."); + + int64_t pos = ftello(f); + ERR_FAIL_COND_V(pos < 0, 0); + ERR_FAIL_COND_V(fseeko(f, 0, SEEK_END), 0); + int64_t size = ftello(f); + ERR_FAIL_COND_V(size < 0, 0); + ERR_FAIL_COND_V(fseeko(f, pos, SEEK_SET), 0); + + return size; +} + +bool FileAccess::eof_reached() const { + return last_error == ERR_FILE_EOF; +} + +uint8_t FileAccess::get_8() const { + ERR_FAIL_COND_V_MSG(!f, 0, "File must be opened before use."); + uint8_t b; + if (fread(&b, 1, 1, f) == 0) { + check_errors(); + b = '\0'; + } + return b; +} + +uint64_t FileAccess::get_buffer(uint8_t *p_dst, uint64_t p_length) const { + ERR_FAIL_COND_V(!p_dst && p_length > 0, -1); + ERR_FAIL_COND_V_MSG(!f, -1, "File must be opened before use."); + + uint64_t read = fread(p_dst, 1, p_length, f); + check_errors(); + return read; +}; + +Error FileAccess::get_error() const { + return last_error; +} + +void FileAccess::flush() { + ERR_FAIL_COND_MSG(!f, "File must be opened before use."); + fflush(f); +} + +void FileAccess::store_8(uint8_t p_dest) { + ERR_FAIL_COND_MSG(!f, "File must be opened before use."); + ERR_FAIL_COND(fwrite(&p_dest, 1, 1, f) != 1); +} + +void FileAccess::store_buffer(const uint8_t *p_src, uint64_t p_length) { + ERR_FAIL_COND_MSG(!f, "File must be opened before use."); + ERR_FAIL_COND(!p_src && p_length > 0); + ERR_FAIL_COND(fwrite(p_src, 1, p_length, f) != p_length); +} + +bool FileAccess::file_exists(const String &p_path) { + int err; + struct stat st; + String filename = fix_path(p_path); + + // Does the name exist at all? + err = stat(filename.utf8().get_data(), &st); + if (err) { + return false; + } + +#if defined(_WIN64) || defined(_WIN32) + if (_access(filename.utf8().get_data(), 4) == -1) { + return false; + } +#else + // See if we have access to the file + if (access(filename.utf8().get_data(), F_OK)) { + return false; + } +#endif + + // See if this is a regular file + switch (st.st_mode & S_IFMT) { + case S_IFLNK: + case S_IFREG: + return true; + default: + return false; + } +} + +uint64_t FileAccess::_get_modified_time(const String &p_file) { + String file = fix_path(p_file); + struct stat flags; + int err = stat(file.utf8().get_data(), &flags); + + if (!err) { + return flags.st_mtime; + } else { + LOG_TRACE("Failed to get modified time for: " + p_file + ""); + return 0; + }; +} + +uint32_t FileAccess::_get_unix_permissions(const String &p_file) { + String file = fix_path(p_file); + struct stat flags; + int err = stat(file.utf8().get_data(), &flags); + + if (!err) { + return flags.st_mode & 0x7FF; //only permissions + } else { + ERR_FAIL_V_MSG(0, "Failed to get unix permissions for: " + p_file + "."); + }; +} + +Error FileAccess::_set_unix_permissions(const String &p_file, uint32_t p_permissions) { + String file = fix_path(p_file); + + int err = chmod(file.utf8().get_data(), p_permissions); + if (!err) { + return OK; + } + + return FAILED; +} + +FileCloseNotificationFunc FileAccess::close_notification_func = nullptr; + +FileAccess::FileAccess() : + f(nullptr), + flags(0), + last_error(OK) { + endian_swap = false; + real_is_double = false; +} + +FileAccess::~FileAccess() { + close(); +} + +#endif + +FileAccess::FileCloseFailNotify FileAccess::close_fail_notify = nullptr; + +bool FileAccess::backup_save = false; + +FileAccess *FileAccess::create() { + return memnew(FileAccess()); +} + +bool FileAccess::exists(const String &p_name) { + FileAccess *f = create_and_open(p_name, READ); + if (!f) { + return false; + } + memdelete(f); + return true; +} + +Error FileAccess::reopen(const String &p_path, int p_mode_flags) { + return _open(p_path, p_mode_flags); +}; + +Error FileAccess::open(const String &p_path, int p_mode_flags) { + return _open(p_path, p_mode_flags); +} + +FileAccess *FileAccess::create_and_open(const String &p_path, int p_mode_flags, Error *r_error) { + //try packed data first + + FileAccess *ret = nullptr; + + ret = create(); + Error err = ret->_open(p_path, p_mode_flags); + + if (r_error) { + *r_error = err; + } + if (err != OK) { + memdelete(ret); + ret = nullptr; + } + + return ret; +} + +String FileAccess::fix_path(const String &p_path) const { + //helper used by file accesses that use a single filesystem + + String r_path = p_path.replace("\\", "/"); + + return r_path; +} + +/* these are all implemented for ease of porting, then can later be optimized */ + +uint16_t FileAccess::get_16() const { + uint16_t res; + uint8_t a, b; + + a = get_8(); + b = get_8(); + + if (endian_swap) { + SWAP(a, b); + } + + res = b; + res <<= 8; + res |= a; + + return res; +} +uint32_t FileAccess::get_32() const { + uint32_t res; + uint16_t a, b; + + a = get_16(); + b = get_16(); + + if (endian_swap) { + SWAP(a, b); + } + + res = b; + res <<= 16; + res |= a; + + return res; +} +uint64_t FileAccess::get_64() const { + uint64_t res; + uint32_t a, b; + + a = get_32(); + b = get_32(); + + if (endian_swap) { + SWAP(a, b); + } + + res = b; + res <<= 32; + res |= a; + + return res; +} + +float FileAccess::get_float() const { + MarshallFloat m; + m.i = get_32(); + return m.f; +}; + +real_t FileAccess::get_real() const { + if (real_is_double) { + return get_double(); + } else { + return get_float(); + } +} + +double FileAccess::get_double() const { + MarshallDouble m; + m.l = get_64(); + return m.d; +}; + +String FileAccess::get_token() const { + CharString token; + + CharType c = get_8(); + + while (!eof_reached()) { + if (c <= ' ') { + if (token.length()) { + break; + } + } else { + token += c; + } + c = get_8(); + } + + return String::utf8(token.get_data()); +} + +class CharBuffer { + Vector vector; + char stack_buffer[256]; + + char *buffer; + int capacity; + int written; + + bool grow() { + if (vector.resize(next_power_of_2(1 + written)) != OK) { + return false; + } + + if (buffer == stack_buffer) { // first chunk? + + for (int i = 0; i < written; i++) { + vector.write[i] = stack_buffer[i]; + } + } + + buffer = vector.ptrw(); + capacity = vector.size(); + ERR_FAIL_COND_V(written >= capacity, false); + + return true; + } + +public: + _FORCE_INLINE_ CharBuffer() : + buffer(stack_buffer), + capacity(sizeof(stack_buffer) / sizeof(char)), + written(0) { + } + + _FORCE_INLINE_ void push_back(char c) { + if (written >= capacity) { + ERR_FAIL_COND(!grow()); + } + + buffer[written++] = c; + } + + _FORCE_INLINE_ const char *get_data() const { + return buffer; + } +}; + +String FileAccess::get_line() const { + CharBuffer line; + + CharType c = get_8(); + + while (!eof_reached()) { + if (c == '\n' || c == '\0') { + line.push_back(0); + return String::utf8(line.get_data()); + } else if (c != '\r') { + line.push_back(c); + } + + c = get_8(); + } + line.push_back(0); + return String::utf8(line.get_data()); +} + +Vector FileAccess::get_csv_line(const String &p_delim) const { + ERR_FAIL_COND_V_MSG(p_delim.length() != 1, Vector(), "Only single character delimiters are supported to parse CSV lines."); + ERR_FAIL_COND_V_MSG(p_delim[0] == '"', Vector(), "The double quotation mark character (\") is not supported as a delimiter for CSV lines."); + + String line; + + // CSV can support entries with line breaks as long as they are enclosed + // in double quotes. So our "line" might be more than a single line in the + // text file. + int qc = 0; + do { + if (eof_reached()) { + break; + } + line += get_line() + "\n"; + qc = 0; + for (int i = 0; i < line.length(); i++) { + if (line[i] == '"') { + qc++; + } + } + } while (qc % 2); + + // Remove the extraneous newline we've added above. + line = line.substr(0, line.length() - 1); + + Vector strings; + + bool in_quote = false; + String current; + for (int i = 0; i < line.length(); i++) { + CharType c = line[i]; + // A delimiter ends the current entry, unless it's in a quoted string. + if (!in_quote && c == p_delim[0]) { + strings.push_back(current); + current = String(); + } else if (c == '"') { + // Doubled quotes are escapes for intentional quotes in the string. + if (line[i + 1] == '"' && in_quote) { + current += '"'; + i++; + } else { + in_quote = !in_quote; + } + } else { + current += c; + } + } + strings.push_back(current); + + return strings; +} + +/* +uint64_t FileAccess::get_buffer(uint8_t *p_dst, uint64_t p_length) const { + ERR_FAIL_COND_V(!p_dst && p_length > 0, -1); + + uint64_t i = 0; + for (i = 0; i < p_length && !eof_reached(); i++) { + p_dst[i] = get_8(); + } + + return i; +} +*/ + +String FileAccess::get_as_utf8_string(bool p_skip_cr) const { + Vector sourcef; + uint64_t len = get_len(); + sourcef.resize(len + 1); + + uint8_t *w = sourcef.ptrw(); + uint64_t r = get_buffer(w, len); + ERR_FAIL_COND_V(r != len, String()); + w[len] = 0; + + String s; + if (s.parse_utf8((const char *)w, -1, p_skip_cr)) { + return String(); + } + + return s; +} + +void FileAccess::store_16(uint16_t p_dest) { + uint8_t a, b; + + a = p_dest & 0xFF; + b = p_dest >> 8; + + if (endian_swap) { + SWAP(a, b); + } + + store_8(a); + store_8(b); +} +void FileAccess::store_32(uint32_t p_dest) { + uint16_t a, b; + + a = p_dest & 0xFFFF; + b = p_dest >> 16; + + if (endian_swap) { + SWAP(a, b); + } + + store_16(a); + store_16(b); +} +void FileAccess::store_64(uint64_t p_dest) { + uint32_t a, b; + + a = p_dest & 0xFFFFFFFF; + b = p_dest >> 32; + + if (endian_swap) { + SWAP(a, b); + } + + store_32(a); + store_32(b); +} + +void FileAccess::store_real(real_t p_real) { + if (sizeof(real_t) == 4) { + store_float(p_real); + } else { + store_double(p_real); + } +} + +void FileAccess::store_float(float p_dest) { + MarshallFloat m; + m.f = p_dest; + store_32(m.i); +}; + +void FileAccess::store_double(double p_dest) { + MarshallDouble m; + m.d = p_dest; + store_64(m.l); +}; + +uint64_t FileAccess::get_modified_time(const String &p_file) { + FileAccess *fa = create(); + ERR_FAIL_COND_V_MSG(!fa, 0, "Cannot create FileAccess for path '" + p_file + "'."); + + uint64_t mt = fa->_get_modified_time(p_file); + memdelete(fa); + return mt; +} + +uint32_t FileAccess::get_unix_permissions(const String &p_file) { + FileAccess *fa = create(); + ERR_FAIL_COND_V_MSG(!fa, 0, "Cannot create FileAccess for path '" + p_file + "'."); + + uint32_t mt = fa->_get_unix_permissions(p_file); + memdelete(fa); + return mt; +} + +Error FileAccess::set_unix_permissions(const String &p_file, uint32_t p_permissions) { + FileAccess *fa = create(); + ERR_FAIL_COND_V_MSG(!fa, ERR_CANT_CREATE, "Cannot create FileAccess for path '" + p_file + "'."); + + Error err = fa->_set_unix_permissions(p_file, p_permissions); + memdelete(fa); + return err; +} + +void FileAccess::store_string(const String &p_string) { + if (p_string.length() == 0) { + return; + } + + CharString cs = p_string.utf8(); + store_buffer((uint8_t *)&cs[0], cs.length()); +} + +void FileAccess::store_pascal_string(const String &p_string) { + CharString cs = p_string.utf8(); + store_32(cs.length()); + store_buffer((uint8_t *)&cs[0], cs.length()); +}; + +String FileAccess::get_pascal_string() { + uint32_t sl = get_32(); + CharString cs; + cs.resize(sl + 1); + get_buffer((uint8_t *)cs.ptr(), sl); + cs[sl] = 0; + + String ret; + ret.parse_utf8(cs.ptr()); + + return ret; +}; + +void FileAccess::store_line(const String &p_line) { + store_string(p_line); + store_8('\n'); +} + +void FileAccess::store_csv_line(const Vector &p_values, const String &p_delim) { + ERR_FAIL_COND(p_delim.length() != 1); + + String line = ""; + int size = p_values.size(); + for (int i = 0; i < size; ++i) { + String value = p_values[i]; + + if (value.find("\"") != -1 || value.find(p_delim) != -1 || value.find("\n") != -1) { + value = "\"" + value.replace("\"", "\"\"") + "\""; + } + if (i < size - 1) { + value += p_delim; + } + + line += value; + } + + store_line(line); +} + +void FileAccess::store_buffer_vec(const Vector &data) { + store_buffer(data.ptr(), data.size()); +} + +/* +void FileAccess::store_buffer(const uint8_t *p_src, uint64_t p_length) { + ERR_FAIL_COND(!p_src && p_length > 0); + for (uint64_t i = 0; i < p_length; i++) { + store_8(p_src[i]); + } +} +*/ + +Vector FileAccess::get_file_as_array(const String &p_path, Error *r_error) { + FileAccess *f = FileAccess::create_and_open(p_path, READ, r_error); + if (!f) { + if (r_error) { // if error requested, do not throw error + return Vector(); + } + ERR_FAIL_V_MSG(Vector(), "Can't open file from path '" + String(p_path) + "'."); + } + Vector data; + data.resize(f->get_len()); + f->get_buffer(data.ptrw(), data.size()); + memdelete(f); + return data; +} + +String FileAccess::get_file_as_string(const String &p_path, Error *r_error) { + Error err; + Vector array = get_file_as_array(p_path, &err); + if (r_error) { + *r_error = err; + } + if (err != OK) { + if (r_error) { + return String(); + } + ERR_FAIL_V_MSG(String(), "Can't get file as string from path '" + String(p_path) + "'."); + } + + String ret; + ret.parse_utf8((const char *)array.ptr(), array.size()); + return ret; +} + +void FileAccess::write_file(const String &p_path, const String &data, Error *r_error) { + FileAccess *f = FileAccess::create_and_open(p_path, WRITE, r_error); + if (!f) { + if (r_error) { // if error requested, do not throw error + return; + } + + ERR_FAIL_MSG("Can't open file from path '" + String(p_path) + "'."); + } + + f->store_string(data); + f->close(); + memdelete(f); +} +void FileAccess::write_file_buffer(const String &p_path, const Vector &data, Error *r_error) { + FileAccess *f = FileAccess::create_and_open(p_path, WRITE, r_error); + if (!f) { + if (r_error) { // if error requested, do not throw error + return; + } + + ERR_FAIL_MSG("Can't open file from path '" + String(p_path) + "'."); + } + + f->store_buffer_vec(data); + f->close(); + memdelete(f); +} + +/* +FileAccess::FileAccess() { + endian_swap = false; + real_is_double = false; +}; +*/ +#line 0 + +#line 1 "sfwl/core/dir_access.cpp" + +/*************************************************************************/ +/* dir_access.cpp */ +/* From https://github.com/Relintai/pandemonium_engine (MIT) */ +/*************************************************************************/ + +#if defined(_WIN64) || defined(_WIN32) + +#include +#include +#define WIN32_LEAN_AND_MEAN +#include + +#else + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#ifdef HAVE_MNTENT +#include +#endif + +#endif + +#ifdef _MSC_VER +#pragma comment(lib, "Shlwapi") +#endif + +#if defined(_WIN64) || defined(_WIN32) + +bool DirAccess::is_link(String p_file) { + return false; +}; +String DirAccess::read_link(String p_file) { + return p_file; +}; +Error DirAccess::create_link(String p_source, String p_target) { + return FAILED; +}; + +/* + +[03:57] yessopie, so i don't havemak to rely on unicows +[03:58] reduz- yeah, all of the functions fail, and then you can call GetLastError () which will return 120 +[03:58] CategoryApl, hehe, what? :) +[03:59] didn't Verona lead to some trouble +[03:59] 120 = ERROR_CALL_NOT_IMPLEMENTED +[03:59] (you can use that constant if you include winerr.h) +[03:59] well answer with winning a compo + +[04:02] if ( SetCurrentDirectoryW ( L"." ) == FALSE && GetLastError () == ERROR_CALL_NOT_IMPLEMENTED ) { use ANSI } +*/ + +struct DirAccessWindowsPrivate { + HANDLE h; //handle for findfirstfile + WIN32_FIND_DATA f; + WIN32_FIND_DATAW fu; //unicode version +}; + +// CreateFolderAsync + +Error DirAccess::list_dir_begin(bool skip_specials) { + _cisdir = false; + _cishidden = false; + _skip_specials = skip_specials; + + list_dir_end(); + p->h = FindFirstFileExW((LPCWSTR)(String(current_dir + "\\*").utf16().get_data()), FindExInfoStandard, &p->fu, FindExSearchNameMatch, NULL, 0); + + return (p->h == INVALID_HANDLE_VALUE) ? ERR_CANT_OPEN : OK; +} + +String DirAccess::get_next() { + if (p->h == INVALID_HANDLE_VALUE) { + return ""; + } + + _cisdir = (p->fu.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY); + _cishidden = (p->fu.dwFileAttributes & FILE_ATTRIBUTE_HIDDEN); + + String name = String::utf16((const char16_t *)(p->fu.cFileName)); + + if (FindNextFileW(p->h, &p->fu) == 0) { + FindClose(p->h); + p->h = INVALID_HANDLE_VALUE; + } + + return name; +} + +bool DirAccess::current_is_dir() const { + return _cisdir; +} + +bool DirAccess::current_is_hidden() const { + return _cishidden; +} + +bool DirAccess::current_is_file() const { + return !_cisdir; +} + +bool DirAccess::current_is_special_dir() const { + return _cisspecial; +} + +void DirAccess::list_dir_end() { + if (p->h != INVALID_HANDLE_VALUE) { + FindClose(p->h); + p->h = INVALID_HANDLE_VALUE; + } +} +int DirAccess::get_drive_count() { + return drive_count; +} +String DirAccess::get_drive(int p_drive) { + if (p_drive < 0 || p_drive >= drive_count) { + return ""; + } + + return String::chr(drives[p_drive]) + ":"; +} + +Error DirAccess::change_dir(String p_dir) { + GLOBAL_LOCK_FUNCTION + + WCHAR real_current_dir_name[2048]; + GetCurrentDirectoryW(2048, real_current_dir_name); + String prev_dir = String::utf16((const char16_t *)real_current_dir_name); + + SetCurrentDirectoryW((LPCWSTR)(current_dir.utf16().get_data())); + bool worked = (SetCurrentDirectoryW((LPCWSTR)(p_dir.utf16().get_data())) != 0); + + String base; + if (base != "") { + GetCurrentDirectoryW(2048, real_current_dir_name); + String new_dir = String::utf16((const char16_t *)real_current_dir_name).replace("\\", "/"); + if (!new_dir.begins_with(base)) { + worked = false; + } + } + + if (worked) { + GetCurrentDirectoryW(2048, real_current_dir_name); + current_dir = String::utf16((const char16_t *)real_current_dir_name); + current_dir = current_dir.replace("\\", "/"); + } + + SetCurrentDirectoryW((LPCWSTR)(prev_dir.utf16().get_data())); + + return worked ? OK : ERR_INVALID_PARAMETER; +} + +Error DirAccess::make_dir(String p_dir) { + GLOBAL_LOCK_FUNCTION + + if (p_dir.is_rel_path()) { + p_dir = current_dir.plus_file(p_dir); + } + + p_dir = p_dir.simplify_path().replace("/", "\\"); + + bool success; + int err; + + if (!p_dir.is_network_share_path()) { + p_dir = "\\\\?\\" + p_dir; + // Add "\\?\" to the path to extend max. path length past 248, if it's not a network share UNC path. + // See https://msdn.microsoft.com/en-us/library/windows/desktop/aa363855(v=vs.85).aspx + } + + success = CreateDirectoryW((LPCWSTR)(p_dir.utf16().get_data()), NULL); + err = GetLastError(); + + if (success) { + return OK; + } + + if (err == ERROR_ALREADY_EXISTS || err == ERROR_ACCESS_DENIED) { + return ERR_ALREADY_EXISTS; + } + + return ERR_CANT_CREATE; +} + +String DirAccess::get_current_dir() { + String base; + if (base != "") { + String bd = current_dir.replace("\\", "/").replace_first(base, ""); + if (bd.begins_with("/")) { + return bd.substr(1, bd.length()); + } else { + return bd; + } + } + + return current_dir; +} + +String DirAccess::get_current_dir_without_drive() { + String dir = get_current_dir(); + + int p = current_dir.find(":"); + if (p != -1) { + dir = dir.right(p + 1); + } + + return dir; +} + +bool DirAccess::file_exists(String p_file) { + GLOBAL_LOCK_FUNCTION + + if (!p_file.is_abs_path()) { + p_file = get_current_dir().plus_file(p_file); + } + + DWORD fileAttr; + + fileAttr = GetFileAttributesW((LPCWSTR)(p_file.utf16().get_data())); + if (INVALID_FILE_ATTRIBUTES == fileAttr) { + return false; + } + + return !(fileAttr & FILE_ATTRIBUTE_DIRECTORY); +} + +bool DirAccess::dir_exists(String p_dir) { + GLOBAL_LOCK_FUNCTION + + if (p_dir.is_rel_path()) { + p_dir = get_current_dir().plus_file(p_dir); + } + + DWORD fileAttr; + + fileAttr = GetFileAttributesW((LPCWSTR)(p_dir.utf16().get_data())); + if (INVALID_FILE_ATTRIBUTES == fileAttr) { + return false; + } + + return (fileAttr & FILE_ATTRIBUTE_DIRECTORY); +} + +Error DirAccess::rename(String p_path, String p_new_path) { + if (p_path.is_rel_path()) { + p_path = get_current_dir().plus_file(p_path); + } + + if (p_new_path.is_rel_path()) { + p_new_path = get_current_dir().plus_file(p_new_path); + } + + // If we're only changing file name case we need to do a little juggling + if (p_path.to_lower() == p_new_path.to_lower()) { + if (dir_exists(p_path)) { + // The path is a dir; just rename + return ::_wrename((LPCWSTR)(p_path.utf16().get_data()), (LPCWSTR)(p_new_path.utf16().get_data())) == 0 ? OK : FAILED; + } + + // The path is a file; juggle + WCHAR tmpfile[MAX_PATH]; + + if (!GetTempFileNameW((LPCWSTR)(get_current_dir().utf16().get_data()), NULL, 0, tmpfile)) { + return FAILED; + } + + if (!::ReplaceFileW(tmpfile, (LPCWSTR)(p_path.utf16().get_data()), NULL, 0, NULL, NULL)) { + DeleteFileW(tmpfile); + return FAILED; + } + + return ::_wrename(tmpfile, (LPCWSTR)(p_new_path.utf16().get_data())) == 0 ? OK : FAILED; + + } else { + if (file_exists(p_new_path)) { + if (remove(p_new_path) != OK) { + return FAILED; + } + } + + return ::_wrename((LPCWSTR)(p_path.utf16().get_data()), (LPCWSTR)(p_new_path.utf16().get_data())) == 0 ? OK : FAILED; + } +} + +Error DirAccess::remove(String p_path) { + if (p_path.is_rel_path()) { + p_path = get_current_dir().plus_file(p_path); + } + + DWORD fileAttr; + + fileAttr = GetFileAttributesW((LPCWSTR)(p_path.utf16().get_data())); + if (INVALID_FILE_ATTRIBUTES == fileAttr) { + return FAILED; + } + + if ((fileAttr & FILE_ATTRIBUTE_DIRECTORY)) { + return ::_wrmdir((LPCWSTR)(p_path.utf16().get_data())) == 0 ? OK : FAILED; + } else { + return ::_wunlink((LPCWSTR)(p_path.utf16().get_data())) == 0 ? OK : FAILED; + } +} +/* + +FileType DirAccess::get_file_type(const String& p_file) const { + WCHAR real_current_dir_name[2048]; + GetCurrentDirectoryW(2048, real_current_dir_name); + String prev_dir = Strong::utf16((const char16_t *)real_current_dir_name); + + bool worked = SetCurrentDirectoryW((LPCWSTR)(current_dir.utf16().get_data())); + + DWORD attr; + if (worked) { + WIN32_FILE_ATTRIBUTE_DATA fileInfo; + attr = GetFileAttributesExW((LPCWSTR)(p_file.utf16().get_data()), GetFileExInfoStandard, &fileInfo); + } + + SetCurrentDirectoryW((LPCWSTR)(prev_dir.utf16().get_data())); + + if (!worked) { + return FILE_TYPE_NONE; + } + + return (attr & FILE_ATTRIBUTE_DIRECTORY) ? FILE_TYPE_ +} +*/ + +uint64_t DirAccess::get_space_left() { + uint64_t bytes = 0; + + if (!GetDiskFreeSpaceEx(NULL, (PULARGE_INTEGER)&bytes, NULL, NULL)) { + return 0; + } + + //this is either 0 or a value in bytes. + return bytes; +} + +String DirAccess::get_filesystem_type() const { + String path = const_cast(this)->get_current_dir(); + + if (path.is_network_share_path()) { + return "Network Share"; + } + + int unit_end = path.find(":"); + ERR_FAIL_COND_V(unit_end == -1, String()); + String unit = path.substr(0, unit_end + 1) + "\\"; + + WCHAR szVolumeName[100]; + WCHAR szFileSystemName[10]; + DWORD dwSerialNumber = 0; + DWORD dwMaxFileNameLength = 0; + DWORD dwFileSystemFlags = 0; + + if (::GetVolumeInformationW((LPCWSTR)(unit.utf16().get_data()), + szVolumeName, + sizeof(szVolumeName), + &dwSerialNumber, + &dwMaxFileNameLength, + &dwFileSystemFlags, + szFileSystemName, + sizeof(szFileSystemName)) == TRUE) { + return String::utf16((const char16_t *)szFileSystemName); + } + + ERR_FAIL_V(""); +} + +int DirAccess::get_current_drive() { + String path = get_current_dir().to_lower(); + for (int i = 0; i < get_drive_count(); i++) { + String d = get_drive(i).to_lower(); + if (path.begins_with(d)) { + return i; + } + } + + return 0; +} + +bool DirAccess::drives_are_shortcuts() { + return false; +} + +uint64_t DirAccess::get_modified_time(String p_file) { + return 0; +}; + +DirAccess::DirAccess() { + p = memnew(DirAccessWindowsPrivate); + p->h = INVALID_HANDLE_VALUE; + current_dir = "."; + + drive_count = 0; + +#ifdef UWP_ENABLED + Windows::Storage::StorageFolder ^ install_folder = Windows::ApplicationModel::Package::Current->InstalledLocation; + change_dir(install_folder->Path->Data()); + +#else + + DWORD mask = GetLogicalDrives(); + + for (int i = 0; i < MAX_DRIVES; i++) { + if (mask & (1 << i)) { //DRIVE EXISTS + + drives[drive_count] = 'A' + i; + drive_count++; + } + } + + change_dir("."); +#endif +} + +DirAccess::~DirAccess() { + list_dir_end(); + + memdelete(p); +} + +#else + +Error DirAccess::list_dir_begin(bool skip_specials) { + list_dir_end(); //close any previous dir opening! + + _skip_specials = skip_specials; + + //char real_current_dir_name[2048]; //is this enough?! + //getcwd(real_current_dir_name,2048); + //chdir(current_path.utf8().get_data()); + dir_stream = opendir(current_dir.utf8().get_data()); + //chdir(real_current_dir_name); + if (!dir_stream) { + return ERR_CANT_OPEN; //error! + } + + return OK; +} + +bool DirAccess::file_exists(String p_file) { + GLOBAL_LOCK_FUNCTION + + if (p_file.is_rel_path()) { + p_file = current_dir.plus_file(p_file); + } + + struct stat flags; + bool success = (stat(p_file.utf8().get_data(), &flags) == 0); + + if (success && S_ISDIR(flags.st_mode)) { + success = false; + } + + return success; +} + +bool DirAccess::dir_exists(String p_dir) { + GLOBAL_LOCK_FUNCTION + + if (p_dir.is_rel_path()) { + p_dir = get_current_dir().plus_file(p_dir); + } + + struct stat flags; + bool success = (stat(p_dir.utf8().get_data(), &flags) == 0); + + return (success && S_ISDIR(flags.st_mode)); +} + +uint64_t DirAccess::get_modified_time(String p_file) { + if (p_file.is_rel_path()) { + p_file = current_dir.plus_file(p_file); + } + + struct stat flags; + bool success = (stat(p_file.utf8().get_data(), &flags) == 0); + + if (success) { + return flags.st_mtime; + } else { + ERR_FAIL_V(0); + }; + return 0; +}; + +String DirAccess::get_next() { + if (!dir_stream) { + return ""; + } + + dirent *entry = readdir(dir_stream); + + if (entry == nullptr) { + list_dir_end(); + return ""; + } + + String fname = fix_unicode_name(entry->d_name); + + // Look at d_type to determine if the entry is a directory, unless + // its type is unknown (the file system does not support it) or if + // the type is a link, in that case we want to resolve the link to + // known if it points to a directory. stat() will resolve the link + // for us. + if (entry->d_type == DT_UNKNOWN || entry->d_type == DT_LNK) { + String f = current_dir.plus_file(fname); + + struct stat flags; + if (stat(f.utf8().get_data(), &flags) == 0) { + _cisdir = S_ISDIR(flags.st_mode); + } else { + _cisdir = false; + } + } else { + _cisdir = (entry->d_type == DT_DIR); + } + + _cishidden = is_hidden(fname); + + _cisspecial = is_special(fname); + + if (_skip_specials && _cisspecial) { + // Should only happen 2 times max + return get_next(); + } + + return fname; +} + +bool DirAccess::current_is_dir() const { + return _cisdir; +} + +bool DirAccess::current_is_file() const { + return !_cisdir; +} + +bool DirAccess::current_is_special_dir() const { + return _cisspecial; +} + +bool DirAccess::current_is_hidden() const { + return _cishidden; +} + +void DirAccess::list_dir_end() { + if (dir_stream) { + closedir(dir_stream); + } + dir_stream = nullptr; + _cisdir = false; +} + +#if defined(HAVE_MNTENT) && defined(X11_ENABLED) +static bool _filter_drive(struct mntent *mnt) { + // Ignore devices that don't point to /dev + if (strncmp(mnt->mnt_fsname, "/dev", 4) != 0) { + return false; + } + + // Accept devices mounted at common locations + if (strncmp(mnt->mnt_dir, "/media", 6) == 0 || + strncmp(mnt->mnt_dir, "/mnt", 4) == 0 || + strncmp(mnt->mnt_dir, "/home", 5) == 0 || + strncmp(mnt->mnt_dir, "/run/media", 10) == 0) { + return true; + } + + // Ignore everything else + return false; +} +#endif + +static void _get_drives(List *list) { + list->push_back("/"); + +#if defined(HAVE_MNTENT) && defined(X11_ENABLED) + // Check /etc/mtab for the list of mounted partitions + FILE *mtab = setmntent("/etc/mtab", "r"); + if (mtab) { + struct mntent mnt; + char strings[4096]; + + while (getmntent_r(mtab, &mnt, strings, sizeof(strings))) { + if (mnt.mnt_dir != nullptr && _filter_drive(&mnt)) { + // Avoid duplicates + if (!list->find(mnt.mnt_dir)) { + list->push_back(mnt.mnt_dir); + } + } + } + + endmntent(mtab); + } +#endif + + // Add $HOME + const char *home = getenv("HOME"); + if (home) { + // Only add if it's not a duplicate + if (!list->find(home)) { + list->push_back(home); + } + + // Check $HOME/.config/gtk-3.0/bookmarks + char path[1024]; + snprintf(path, 1024, "%s/.config/gtk-3.0/bookmarks", home); + FILE *fd = fopen(path, "r"); + if (fd) { + char string[1024]; + while (fgets(string, 1024, fd)) { + // Parse only file:// links + if (strncmp(string, "file://", 7) == 0) { + // Strip any unwanted edges on the strings and push_back if it's not a duplicate + String fpath = String(string + 7).strip_edges().split_spaces()[0].percent_decode(); + if (!list->find(fpath)) { + list->push_back(fpath); + } + } + } + + fclose(fd); + } + } + + list->sort(); +} + +int DirAccess::get_drive_count() { + List list; + _get_drives(&list); + + return list.size(); +} + +String DirAccess::get_drive(int p_drive) { + List list; + _get_drives(&list); + + ERR_FAIL_INDEX_V(p_drive, list.size(), ""); + + return list[p_drive]; +} + +int DirAccess::get_current_drive() { + int drive = 0; + int max_length = -1; + const String path = get_current_dir().to_lower(); + for (int i = 0; i < get_drive_count(); i++) { + const String d = get_drive(i).to_lower(); + if (max_length < d.length() && path.begins_with(d)) { + max_length = d.length(); + drive = i; + } + } + return drive; +} + +bool DirAccess::drives_are_shortcuts() { + return true; +} + +Error DirAccess::make_dir(String p_dir) { + GLOBAL_LOCK_FUNCTION + + if (p_dir.is_rel_path()) { + p_dir = get_current_dir().plus_file(p_dir); + } + + bool success = (mkdir(p_dir.utf8().get_data(), S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH) == 0); + int err = errno; + + if (success) { + return OK; + }; + + if (err == EEXIST) { + return ERR_ALREADY_EXISTS; + }; + + return ERR_CANT_CREATE; +} + +Error DirAccess::change_dir(String p_dir) { + GLOBAL_LOCK_FUNCTION + + // prev_dir is the directory we are changing out of + String prev_dir; + char real_current_dir_name[2048]; + ERR_FAIL_COND_V(getcwd(real_current_dir_name, 2048) == nullptr, ERR_BUG); + if (prev_dir.parse_utf8(real_current_dir_name)) { + prev_dir = real_current_dir_name; //no utf8, maybe latin? + } + + // try_dir is the directory we are trying to change into + String try_dir = ""; + if (p_dir.is_rel_path()) { + String next_dir = current_dir.plus_file(p_dir); + next_dir = next_dir.simplify_path(); + try_dir = next_dir; + } else { + try_dir = p_dir; + } + + bool worked = (chdir(try_dir.utf8().get_data()) == 0); // we can only give this utf8 + if (!worked) { + return ERR_INVALID_PARAMETER; + } + + String base; + if (base != String() && !try_dir.begins_with(base)) { + ERR_FAIL_COND_V(getcwd(real_current_dir_name, 2048) == nullptr, ERR_BUG); + String new_dir; + new_dir.parse_utf8(real_current_dir_name); + + if (!new_dir.begins_with(base)) { + try_dir = current_dir; //revert + } + } + + // the directory exists, so set current_dir to try_dir + current_dir = try_dir; + ERR_FAIL_COND_V(chdir(prev_dir.utf8().get_data()) != 0, ERR_BUG); + return OK; +} + +String DirAccess::get_current_dir() { + String base; + if (base != "") { + String bd = current_dir.replace_first(base, ""); + if (bd.begins_with("/")) { + return bd.substr(1, bd.length()); + } else { + return bd; + } + } + return current_dir; +} + +Error DirAccess::rename(String p_path, String p_new_path) { + if (p_path.is_rel_path()) { + p_path = get_current_dir().plus_file(p_path); + } + + if (p_new_path.is_rel_path()) { + p_new_path = get_current_dir().plus_file(p_new_path); + } + + return ::rename(p_path.utf8().get_data(), p_new_path.utf8().get_data()) == 0 ? OK : FAILED; +} + +Error DirAccess::remove(String p_path) { + if (p_path.is_rel_path()) { + p_path = get_current_dir().plus_file(p_path); + } + + struct stat flags; + if ((stat(p_path.utf8().get_data(), &flags) != 0)) { + return FAILED; + } + + if (S_ISDIR(flags.st_mode)) { + return ::rmdir(p_path.utf8().get_data()) == 0 ? OK : FAILED; + } else { + return ::unlink(p_path.utf8().get_data()) == 0 ? OK : FAILED; + } +} + +bool DirAccess::is_link(String p_file) { + if (p_file.is_rel_path()) { + p_file = get_current_dir().plus_file(p_file); + } + + struct stat flags; + if ((lstat(p_file.utf8().get_data(), &flags) != 0)) { + return FAILED; + } + + return S_ISLNK(flags.st_mode); +} + +String DirAccess::read_link(String p_file) { + if (p_file.is_rel_path()) { + p_file = get_current_dir().plus_file(p_file); + } + + char buf[256]; + memset(buf, 0, 256); + ssize_t len = readlink(p_file.utf8().get_data(), buf, sizeof(buf)); + String link; + if (len > 0) { + link.parse_utf8(buf, len); + } + return link; +} + +Error DirAccess::create_link(String p_source, String p_target) { + if (p_target.is_rel_path()) { + p_target = get_current_dir().plus_file(p_target); + } + + if (symlink(p_source.utf8().get_data(), p_target.utf8().get_data()) == 0) { + return OK; + } else { + return FAILED; + } +} + +uint64_t DirAccess::get_space_left() { +#ifndef NO_STATVFS + struct statvfs vfs; + if (statvfs(current_dir.utf8().get_data(), &vfs) != 0) { + return 0; + }; + + return (uint64_t)vfs.f_bavail * (uint64_t)vfs.f_frsize; +#else + // FIXME: Implement this. + return 0; +#endif +}; + +String DirAccess::get_filesystem_type() const { + return ""; //TODO this should be implemented +} + +bool DirAccess::is_hidden(const String &p_name) { + return p_name != "." && p_name != ".." && p_name.begins_with("."); +} + +String DirAccess::get_current_dir_without_drive() { + return get_current_dir(); +} + +DirAccess::DirAccess() { + dir_stream = NULL; + _cisdir = false; + + next_is_dir = false; + _skip_specials = false; + + _cishidden = false; + _cisspecial = false; + + /* determine drive count */ + + // set current directory to an absolute path of the current directory + char real_current_dir_name[2048]; + ERR_FAIL_COND(getcwd(real_current_dir_name, 2048) == nullptr); + if (current_dir.parse_utf8(real_current_dir_name)) { + current_dir = real_current_dir_name; + } + + change_dir(current_dir); +} + +DirAccess::~DirAccess() { + list_dir_end(); +} + +#endif + +static Error _erase_recursive(DirAccess *da) { + List dirs; + List files; + + da->list_dir_begin(); + String n = da->get_next(); + while (n != String()) { + if (n != "." && n != "..") { + if (da->current_is_dir()) { + dirs.push_back(n); + } else { + files.push_back(n); + } + } + + n = da->get_next(); + } + + da->list_dir_end(); + + for (List::Element *E = dirs.front(); E; E = E->next()) { + Error err = da->change_dir(E->get()); + if (err == OK) { + err = _erase_recursive(da); + if (err) { + da->change_dir(".."); + return err; + } + err = da->change_dir(".."); + if (err) { + return err; + } + err = da->remove(da->get_current_dir().plus_file(E->get())); + if (err) { + return err; + } + } else { + return err; + } + } + + for (List::Element *E = files.front(); E; E = E->next()) { + Error err = da->remove(da->get_current_dir().plus_file(E->get())); + if (err) { + return err; + } + } + + return OK; +} + +Error DirAccess::erase_contents_recursive() { + return _erase_recursive(this); +} + +Error DirAccess::make_dir_recursive(String p_dir) { + if (p_dir.length() < 1) { + return OK; + }; + + String full_dir; + + if (p_dir.is_rel_path()) { + //append current + full_dir = get_current_dir().plus_file(p_dir); + + } else { + full_dir = p_dir; + } + + full_dir = full_dir.replace("\\", "/"); + + String base; + + if (full_dir.is_network_share_path()) { + int pos = full_dir.find("/", 2); + ERR_FAIL_COND_V(pos < 0, ERR_INVALID_PARAMETER); + pos = full_dir.find("/", pos + 1); + ERR_FAIL_COND_V(pos < 0, ERR_INVALID_PARAMETER); + base = full_dir.substr(0, pos + 1); + } else if (full_dir.begins_with("/")) { + base = "/"; + } else if (full_dir.find(":/") != -1) { + base = full_dir.substr(0, full_dir.find(":/") + 2); + } else { + ERR_FAIL_V(ERR_INVALID_PARAMETER); + } + + full_dir = full_dir.replace_first(base, "").simplify_path(); + + Vector subdirs = full_dir.split("/"); + + String curpath = base; + for (int i = 0; i < subdirs.size(); i++) { + curpath = curpath.plus_file(subdirs[i]); + Error err = make_dir(curpath); + if (err != OK && err != ERR_ALREADY_EXISTS) { + ERR_FAIL_V_MSG(err, "Could not create directory: " + curpath); + } + } + + return OK; +} + +DirAccess *DirAccess::create_for_path(const String &p_path) { + DirAccess *d = memnew(DirAccess()); + d->open(p_path); + return d; +} +DirAccess *DirAccess::create() { + return memnew(DirAccess()); +} + +Error DirAccess::open(const String &p_path) { + return change_dir(p_path); +} + +String DirAccess::get_full_path(const String &p_path) { + DirAccess d; + + d.change_dir(p_path); + String full = d.get_current_dir(); + + return full; +} + +Error DirAccess::copy(String p_from, String p_to, int p_chmod_flags) { + //printf("copy %s -> %s\n",p_from.ascii().get_data(),p_to.ascii().get_data()); + Error err; + FileAccess *fsrc = FileAccess::create_and_open(p_from, FileAccess::READ, &err); + + if (err) { + ERR_PRINT("Failed to open " + p_from); + return err; + } + + FileAccess *fdst = FileAccess::create_and_open(p_to, FileAccess::WRITE, &err); + if (err) { + fsrc->close(); + memdelete(fsrc); + ERR_PRINT("Failed to open " + p_to); + return err; + } + + const size_t copy_buffer_limit = 65536; // 64 KB + + fsrc->seek_end(0); + uint64_t size = fsrc->get_position(); + fsrc->seek(0); + err = OK; + size_t buffer_size = MIN(size * sizeof(uint8_t), copy_buffer_limit); + LocalVector buffer; + buffer.resize(buffer_size); + while (size > 0) { + if (fsrc->get_error() != OK) { + err = fsrc->get_error(); + break; + } + if (fdst->get_error() != OK) { + err = fdst->get_error(); + break; + } + + int bytes_read = fsrc->get_buffer(buffer.ptr(), buffer_size); + if (bytes_read <= 0) { + err = FAILED; + break; + } + fdst->store_buffer(buffer.ptr(), bytes_read); + + size -= bytes_read; + } + + if (err == OK && p_chmod_flags != -1) { + fdst->close(); + err = FileAccess::set_unix_permissions(p_to, p_chmod_flags); + // If running on a platform with no chmod support (i.e., Windows), don't fail + if (err == ERR_UNAVAILABLE) { + err = OK; + } + } + + memdelete(fsrc); + memdelete(fdst); + + return err; +} + +// Changes dir for the current scope, returning back to the original dir +// when scope exits +class DirChanger { + DirAccess *da; + String original_dir; + +public: + DirChanger(DirAccess *p_da, String p_dir) : + da(p_da), + original_dir(p_da->get_current_dir()) { + p_da->change_dir(p_dir); + } + + ~DirChanger() { + da->change_dir(original_dir); + } +}; + +Error DirAccess::_copy_dir(DirAccess *p_target_da, String p_to, int p_chmod_flags, bool p_copy_links) { + List dirs; + + String curdir = get_current_dir(); + list_dir_begin(); + String n = get_next(); + while (n != String()) { + if (n != "." && n != "..") { + if (p_copy_links && is_link(get_current_dir().plus_file(n))) { + create_link(read_link(get_current_dir().plus_file(n)), p_to + n); + } else if (current_is_dir()) { + dirs.push_back(n); + } else { + const String &rel_path = n; + if (!n.is_rel_path()) { + list_dir_end(); + return ERR_BUG; + } + Error err = copy(get_current_dir().plus_file(n), p_to + rel_path, p_chmod_flags); + if (err) { + list_dir_end(); + return err; + } + } + } + + n = get_next(); + } + + list_dir_end(); + + for (List::Element *E = dirs.front(); E; E = E->next()) { + String rel_path = E->get(); + String target_dir = p_to + rel_path; + if (!p_target_da->dir_exists(target_dir)) { + Error err = p_target_da->make_dir(target_dir); + ERR_FAIL_COND_V_MSG(err != OK, err, "Cannot create directory '" + target_dir + "'."); + } + + Error err = change_dir(E->get()); + ERR_FAIL_COND_V_MSG(err != OK, err, "Cannot change current directory to '" + E->get() + "'."); + + err = _copy_dir(p_target_da, p_to + rel_path + "/", p_chmod_flags, p_copy_links); + if (err) { + change_dir(".."); + ERR_FAIL_V_MSG(err, "Failed to copy recursively."); + } + err = change_dir(".."); + ERR_FAIL_COND_V_MSG(err != OK, err, "Failed to go back."); + } + + return OK; +} + +Error DirAccess::copy_dir(String p_from, String p_to, int p_chmod_flags, bool p_copy_links) { + ERR_FAIL_COND_V_MSG(!dir_exists(p_from), ERR_FILE_NOT_FOUND, "Source directory doesn't exist."); + + DirAccess *target_da = DirAccess::create_for_path(p_to); + ERR_FAIL_COND_V_MSG(!target_da, ERR_CANT_CREATE, "Cannot create DirAccess for path '" + p_to + "'."); + + if (!target_da->dir_exists(p_to)) { + Error err = target_da->make_dir_recursive(p_to); + if (err) { + memdelete(target_da); + } + ERR_FAIL_COND_V_MSG(err != OK, err, "Cannot create directory '" + p_to + "'."); + } + + if (!p_to.ends_with("/")) { + p_to = p_to + "/"; + } + + DirChanger dir_changer(this, p_from); + Error err = _copy_dir(target_da, p_to, p_chmod_flags, p_copy_links); + memdelete(target_da); + + return err; +} + +bool DirAccess::exists(String p_dir) { + DirAccess *da = DirAccess::create_for_path(p_dir); + bool valid = da->change_dir(p_dir) == OK; + memdelete(da); + return valid; +} + +String DirAccess::get_filesystem_abspath_for(String p_path) { + DirAccess d; + + d.change_dir(p_path); + String full = d.get_current_dir(); + + return full; +} + +bool DirAccess::is_special(const String &p_path) { + if (p_path.size() > 2) { + return false; + } + + return p_path == "." || p_path == ".."; +} +#line 0 + +#line 1 "sfwl/core/inet_address.cpp" +//Based on: + +// Copyright 2010, Shuo Chen. All rights reserved. +// http://code.google.com/p/muduo/ +// +// Use of this source code is governed by a BSD-style license +// that can be found in the License file. + +// Author: Shuo Chen (chenshuo at chenshuo dot com) + +#include +#include + +#if defined(_WIN64) || defined(_WIN32) + +#ifdef __GNUC__ +#define GCCWIN +// Mingw / gcc on windows +// #define _WIN32_WINNT 0x0501 +#include +#include + +extern "C" { +WINSOCK_API_LINKAGE INT WSAAPI inet_pton(INT Family, PCSTR pszAddrString, PVOID pAddrBuf); + +#ifdef __MINGW64_VERSION_MAJOR +#if __MINGW64_VERSION_MAJOR >= 7 +WINSOCK_API_LINKAGE PCSTR WSAAPI inet_ntop(INT Family, const VOID *pAddr, PSTR pStringBuf, size_t StringBufSize); +#else +WINSOCK_API_LINKAGE PCSTR WSAAPI inet_ntop(INT Family, VOID *pAddr, PSTR pStringBuf, size_t StringBufSize); +#endif + +#else +WINSOCK_API_LINKAGE PCSTR WSAAPI inet_ntop(INT Family, VOID *pAddr, PSTR pStringBuf, size_t StringBufSize); +#endif +} +#else +// Windows... + +#define WIN32_LEAN_AND_MEAN +#include + +#include +#include +#include + +extern "C" { + +PCSTR WSAAPI inet_ntop(_In_ INT Family, _In_ const VOID *pAddr, _Out_writes_(StringBufSize) PSTR pStringBuf, _In_ size_t StringBufSize); + +WINSOCK_API_LINKAGE INT WSAAPI inet_pton(_In_ INT Family, _In_ PCSTR pszAddrString, _When_(Family == AF_INET, _Out_writes_bytes_(sizeof(IN_ADDR))) _When_(Family == AF_INET6, _Out_writes_bytes_(sizeof(IN6_ADDR))) PVOID pAddrBuf); +} + +#endif + +struct in6__addruint { + union { + u_char Byte[16]; + u_short Word[8]; + uint32_t __s6_addr32[4]; + } uext; +}; +#else +#include +#include +#include // memset +#endif + +#ifdef _MSC_VER +#pragma comment(lib, "ws2_32") +#endif + +// INADDR_ANY use (type)value casting. +static const in_addr_t kInaddrAny = INADDR_ANY; +static const in_addr_t kInaddrLoopback = INADDR_ANY; + +// /* Structure describing an Internet socket address. */ +// struct sock_addrin { +// sa_family_t sin_family; /* address family: AF_INET */ +// uint16_t sin_port; /* port in network byte order */ +// struct in_addr sin_addr; /* internet address */ +// }; + +// /* Internet address. */ +// typedef uint32_t in_addr_t; +// struct in_addr { +// in_addr_t s_addr; /* address in network byte order */ +// }; + +// struct sockaddr_in6 { +// sa_family_t sin6_family; /* address family: AF_INET6 */ +// uint16_t sin6_port; /* port in network byte order */ +// uint32_t sin6_flowinfo; /* IPv6 flow information */ +// struct in6_addr sin6_addr; /* IPv6 address */ +// uint32_t sin6_scope_id; /* IPv6 scope-id */ +// }; + +/* +#ifdef __linux__ +#if !(__GNUC_PREREQ(4, 6)) +#pragma GCC diagnostic ignored "-Winvalid-offsetof" +#endif +#endif +*/ + +// Defined here so we don't need to include in the header +struct InetAddress::InetAddressData { + union { + struct sockaddr_in _addr; + struct sockaddr_in6 _addr6; + }; +}; + +String InetAddress::to_ip_port() const { + char buf[64] = ""; + uint16_t port = ntohs(_data->_addr.sin_port); + snprintf(buf, sizeof(buf), ":%u", port); + + return to_ip() + String(buf); +} + +bool InetAddress::is_intranet_ip() const { + if (_data->_addr.sin_family == AF_INET) { + uint32_t ip_addr = ntohl(_data->_addr.sin_addr.s_addr); + if ((ip_addr >= 0x0A000000 && ip_addr <= 0x0AFFFFFF) || + (ip_addr >= 0xAC100000 && ip_addr <= 0xAC1FFFFF) || + (ip_addr >= 0xC0A80000 && ip_addr <= 0xC0A8FFFF) || + ip_addr == 0x7f000001) + + { + return true; + } + } else { + auto addrP = ip6_net_endian(); + // Loopback ip + if (*addrP == 0 && *(addrP + 1) == 0 && *(addrP + 2) == 0 && + ntohl(*(addrP + 3)) == 1) { + return true; + } + + // Privated ip is prefixed by FEC0::/10 or FE80::/10, need testing + auto i32 = (ntohl(*addrP) & 0xffc00000); + if (i32 == 0xfec00000 || i32 == 0xfe800000) { + return true; + } + + if (*addrP == 0 && *(addrP + 1) == 0 && ntohl(*(addrP + 2)) == 0xffff) { + // the IPv6 version of an IPv4 IP address + uint32_t ip_addr = ntohl(*(addrP + 3)); + if ((ip_addr >= 0x0A000000 && ip_addr <= 0x0AFFFFFF) || + (ip_addr >= 0xAC100000 && ip_addr <= 0xAC1FFFFF) || + (ip_addr >= 0xC0A80000 && ip_addr <= 0xC0A8FFFF) || + ip_addr == 0x7f000001) + + { + return true; + } + } + } + return false; +} + +bool InetAddress::is_loopback_ip() const { + if (!is_ip_v6()) { + uint32_t ip_addr = ntohl(_data->_addr.sin_addr.s_addr); + if (ip_addr == 0x7f000001) { + return true; + } + } else { + auto addrP = ip6_net_endian(); + if (*addrP == 0 && *(addrP + 1) == 0 && *(addrP + 2) == 0 && + ntohl(*(addrP + 3)) == 1) { + return true; + } + // the IPv6 version of an IPv4 loopback address + if (*addrP == 0 && *(addrP + 1) == 0 && ntohl(*(addrP + 2)) == 0xffff && + ntohl(*(addrP + 3)) == 0x7f000001) { + return true; + } + } + return false; +} + +const struct sockaddr *InetAddress::get_sock_addr() const { + return static_cast((void *)(&_data->_addr6)); +} + +void InetAddress::set_sock_addr_inet6(const struct sockaddr_in6 &addr6) { + _data->_addr6 = addr6; + _is_ip_v6 = (_data->_addr6.sin6_family == AF_INET6); + _is_unspecified = false; +} + +sa_family_t InetAddress::family() const { + return _data->_addr.sin_family; +} + +String InetAddress::to_ip() const { + char buf[64]; + if (_data->_addr.sin_family == AF_INET) { +#if defined GCCWIN || (_MSC_VER && _MSC_VER >= 1900) + ::inet_ntop(AF_INET, (PVOID)&_data->_addr.sin_addr, buf, sizeof(buf)); +#else + ::inet_ntop(AF_INET, &_data->_addr.sin_addr, buf, sizeof(buf)); +#endif + } else if (_data->_addr.sin_family == AF_INET6) { +#if defined GCCWIN || (_MSC_VER && _MSC_VER >= 1900) + ::inet_ntop(AF_INET6, (PVOID)&_data->_addr6.sin6_addr, buf, sizeof(buf)); +#else + ::inet_ntop(AF_INET6, &_data->_addr6.sin6_addr, buf, sizeof(buf)); +#endif + } + + return buf; +} + +uint32_t InetAddress::ip_net_endian() const { + // assert(family() == AF_INET); + return _data->_addr.sin_addr.s_addr; +} + +const uint32_t *InetAddress::ip6_net_endian() const { +// assert(family() == AF_INET6); +#if defined __linux__ || defined __HAIKU__ + return _data->_addr6.sin6_addr.s6_addr32; +#elif defined(_WIN64) || defined(_WIN32) + // TODO is this OK ? + const struct in6__addruint *_addrtemp = + reinterpret_cast(&_data->_addr6.sin6_addr); + return (*_addrtemp).uext.__s6_addr32; +#else + return _data->_addr6.sin6_addr.__u6_addr.__u6_addr32; +#endif +} + +uint16_t InetAddress::port_net_endian() const { + return _data->_addr.sin_port; +} + +void InetAddress::set_port_net_endian(uint16_t port) { + _data->_addr.sin_port = port; +} + +inline bool InetAddress::is_unspecified() const { + return _is_unspecified; +} + +uint16_t InetAddress::to_port() const { + return ntohs(port_net_endian()); +} + +bool InetAddress::is_ip_v6() const { + return _is_ip_v6; +} + +InetAddress::InetAddress(uint16_t port, bool loopbackOnly, bool ipv6) { + _data = memnew(InetAddressData); + + _is_ip_v6 = ipv6; + + if (ipv6) { + memset(&_data->_addr6, 0, sizeof(_data->_addr6)); + _data->_addr6.sin6_family = AF_INET6; + + in6_addr ip = loopbackOnly ? in6addr_loopback : in6addr_any; + + _data->_addr6.sin6_addr = ip; + _data->_addr6.sin6_port = htons(port); + } else { + memset(&_data->_addr, 0, sizeof(_data->_addr)); + _data->_addr.sin_family = AF_INET; + + in_addr_t ip = loopbackOnly ? kInaddrLoopback : kInaddrAny; + + _data->_addr.sin_addr.s_addr = htonl(ip); + _data->_addr.sin_port = htons(port); + } + + _is_unspecified = false; +} + +InetAddress::InetAddress(const String &ip, uint16_t port, bool ipv6) { + _data = memnew(InetAddressData); + + _is_ip_v6 = ipv6; + + if (ipv6) { + memset(&_data->_addr6, 0, sizeof(_data->_addr6)); + _data->_addr6.sin6_family = AF_INET6; + _data->_addr6.sin6_port = htons(port); + + if (::inet_pton(AF_INET6, ip.utf8().get_data(), &_data->_addr6.sin6_addr) <= 0) { + return; + } + } else { + memset(&_data->_addr, 0, sizeof(_data->_addr)); + _data->_addr.sin_family = AF_INET; + _data->_addr.sin_port = htons(port); + + if (::inet_pton(AF_INET, ip.utf8().get_data(), &_data->_addr.sin_addr) <= 0) { + return; + } + } + + _is_unspecified = false; +} + +InetAddress::InetAddress(const struct sockaddr_in &addr) { + _data = memnew(InetAddressData); + + _data->_addr = addr; + _is_unspecified = false; +} + +InetAddress::InetAddress(const struct sockaddr_in6 &addr) { + _data = memnew(InetAddressData); + + _data->_addr6 = addr; + _is_ip_v6 = true; + _is_unspecified = false; +} + +InetAddress::~InetAddress() { + memdelete(_data); +} +#line 0 + +#line 1 "sfwl/core/socket.cpp" + +//Based on: + +/** + * + * Socket.cc + * An Tao + * + * Public header file in trantor lib. + * + * Copyright 2018, An Tao. All rights reserved. + * Use of this source code is governed by a BSD-style license + * that can be found in the License file. + * + * + */ + +#if !defined(_WIN64) && !defined(_WIN32) +#include +#endif +#include + +///usr/include/asm-generic/errno-base.h +//http://www.virtsync.com/c-error-codes-include-errno +#include + +#if defined(_WIN64) || defined(_WIN32) +#include +#else +#include +#include +#endif + +void Socket::create_net_socket() { + create(AF_INET); +} + +void Socket::create(int family) { +#ifdef __linux__ + _socket = ::socket(family, SOCK_STREAM | SOCK_NONBLOCK | SOCK_CLOEXEC, IPPROTO_TCP); +#else + _socket = static_cast(::socket(family, SOCK_STREAM, IPPROTO_TCP)); +#endif +} + +void Socket::close_socket() { + if (!_socket) { + return; + } + +#if !defined(_WIN64) && !defined(_WIN32) + close(_socket); +#else + closesocket(_socket); +#endif + + _socket = 0; +} + +// taken from muduo +int Socket::set_non_block() { + ERR_FAIL_COND_V(_socket == 0, -1); + +#if defined(_WIN64) || defined(_WIN32) + // TODO how to set FD_CLOEXEC on windows? is it necessary? + u_long arg = 1; + auto ret = ioctlsocket(_socket, (long)FIONBIO, &arg); + + if (ret) { + //LOG_ERR("ioctlsocket error"); + return -1; + } + + return 0; +#else + // non-block + int flags = ::fcntl(_socket, F_GETFL, 0); + flags |= O_NONBLOCK; + int ret = ::fcntl(_socket, F_SETFL, flags); + // TODO check + + return ret; +#endif +} + +// taken from muduo +int Socket::set_close_on_exit() { + ERR_FAIL_COND_V(_socket == 0, -1); + +#if defined(_WIN64) || defined(_WIN32) + // TODO how to set FD_CLOEXEC on windows? is it necessary? + return 0; +#else + // close-on-exec + int flags = ::fcntl(_socket, F_GETFD, 0); + flags |= FD_CLOEXEC; + int ret = ::fcntl(_socket, F_SETFD, flags); + // TODO check + + return ret; +#endif +} + +int Socket::get_error() { + ERR_FAIL_COND_V(_socket == 0, -1); + + int optval; + + socklen_t optlen = static_cast(sizeof optval); + +#if defined(_WIN64) || defined(_WIN32) + if (::getsockopt(_socket, SOL_SOCKET, SO_ERROR, (char *)&optval, &optlen) < 0) +#else + if (::getsockopt(_socket, SOL_SOCKET, SO_ERROR, &optval, &optlen) < 0) +#endif + { + return errno; + } else { + return optval; + } +} + +int Socket::connect(const InetAddress &addr) { + ERR_FAIL_COND_V(_socket == 0, -1); + + if (addr.is_ip_v6()) { + return ::connect(_socket, addr.get_sock_addr(), static_cast(sizeof(struct sockaddr_in6))); + } else { + return ::connect(_socket, addr.get_sock_addr(), static_cast(sizeof(struct sockaddr_in))); + } +} + +bool Socket::is_self_connect() { + ERR_FAIL_COND_V(_socket == 0, false); + + struct sockaddr_in6 localaddr = get_local_addr(); + struct sockaddr_in6 peeraddr = get_peer_addr(); + + if (localaddr.sin6_family == AF_INET) { + const struct sockaddr_in *laddr4 = reinterpret_cast(&localaddr); + const struct sockaddr_in *raddr4 = reinterpret_cast(&peeraddr); + return laddr4->sin_port == raddr4->sin_port && laddr4->sin_addr.s_addr == raddr4->sin_addr.s_addr; + } else if (localaddr.sin6_family == AF_INET6) { + return localaddr.sin6_port == peeraddr.sin6_port && memcmp(&localaddr.sin6_addr, &peeraddr.sin6_addr, sizeof localaddr.sin6_addr) == 0; + } else { + return false; + } +} + +int Socket::bind_address(const InetAddress &address) { + ERR_FAIL_COND_V(_socket == 0, -1); + + int ret; + if (address.is_ip_v6()) { + ret = ::bind(_socket, address.get_sock_addr(), sizeof(sockaddr_in6)); + } else { + ret = ::bind(_socket, address.get_sock_addr(), sizeof(sockaddr_in)); + } + + if (ret != 0) { +#if defined(_WIN64) || defined(_WIN32) + return WSAGetLastError(); +#else + return errno; +#endif + } + + return ret; +} + +int Socket::listen() { + ERR_FAIL_COND_V(_socket == 0, -1); + + return ::listen(_socket, SOMAXCONN); +} + +int Socket::accept(Socket *sock) { + ERR_FAIL_COND_V(!sock, -1); + + struct sockaddr_in6 addr6; + memset(&addr6, 0, sizeof(addr6)); + socklen_t size = sizeof(addr6); + +#ifdef __linux__ + int connfd = ::accept4(_socket, (struct sockaddr *)&addr6, &size, SOCK_NONBLOCK | SOCK_CLOEXEC); +#else + int connfd = static_cast(::accept(_socket, (struct sockaddr *)&addr6, &size)); +#endif + + if (connfd >= 0) { + sock->_socket = connfd; + sock->_address.set_sock_addr_inet6(addr6); +#ifndef __linux__ + sock->set_non_block(); + sock->set_close_on_exit(); +#endif + } + + return connfd; +} + +int Socket::close_write() { + ERR_FAIL_COND_V(_socket == 0, -1); + +#if !defined(_WIN64) && !defined(_WIN32) + return ::shutdown(_socket, SHUT_WR); +#else + return ::shutdown(_socket, SD_SEND); +#endif +} + +int Socket::read(char *buffer, uint64_t len) { + //ERR_FAIL_COND_V(_socket == 0, -1); + +#if !defined(_WIN64) && !defined(_WIN32) + return ::read(_socket, buffer, len); +#else + return recv(_socket, buffer, static_cast(len), 0); +#endif +} + +int Socket::send(const char *buffer, uint64_t len) { + //ERR_FAIL_COND_V(_socket == 0, -1); + +#if !defined(_WIN64) && !defined(_WIN32) + return write(_socket, buffer, len); +#else + errno = 0; + return ::send(_socket, buffer, static_cast(len), 0); +#endif +} + +void Socket::set_tcp_nodelay(bool on) { + ERR_FAIL_COND(_socket == 0); + +#if defined(_WIN64) || defined(_WIN32) + char optval = on ? 1 : 0; +#else + int optval = on ? 1 : 0; +#endif + ::setsockopt(_socket, IPPROTO_TCP, TCP_NODELAY, &optval, static_cast(sizeof optval)); +} + +void Socket::set_reuse_addr(bool on) { + ERR_FAIL_COND(_socket == 0); + +#if defined(_WIN64) || defined(_WIN32) + char optval = on ? 1 : 0; +#else + int optval = on ? 1 : 0; +#endif + ::setsockopt(_socket, SOL_SOCKET, SO_REUSEADDR, &optval, static_cast(sizeof optval)); +} + +int Socket::set_reuse_port(bool on) { + ERR_FAIL_COND_V(_socket == 0, -1); + +#ifdef SO_REUSEPORT +#if defined(_WIN64) || defined(_WIN32) + char optval = on ? 1 : 0; +#else + int optval = on ? 1 : 0; +#endif + int ret = ::setsockopt(_socket, SOL_SOCKET, SO_REUSEPORT, &optval, static_cast(sizeof optval)); + + return ret; +#else + if (on) { + //LOG_ERR("SO_REUSEPORT is not supported."); + return -1; + } + + return 0; +#endif +} + +void Socket::set_keep_alive(bool on) { + ERR_FAIL_COND(_socket == 0); + +#if defined(_WIN64) || defined(_WIN32) + char optval = on ? 1 : 0; +#else + int optval = on ? 1 : 0; +#endif + ::setsockopt(_socket, SOL_SOCKET, SO_KEEPALIVE, &optval, static_cast(sizeof optval)); +} + +struct sockaddr_in6 Socket::get_local_addr(int *r_err) { + struct sockaddr_in6 localaddr = { 0 }; + + ERR_FAIL_COND_V(_socket == 0, localaddr); + + memset(&localaddr, 0, sizeof(localaddr)); + socklen_t addrlen = static_cast(sizeof localaddr); + + int err = ::getsockname(_socket, static_cast((void *)(&localaddr)), &addrlen); + + if (r_err) { + *r_err = err; + } + + return localaddr; +} + +struct sockaddr_in6 Socket::get_peer_addr(int *r_err) { + struct sockaddr_in6 peeraddr = { 0 }; + + ERR_FAIL_COND_V(_socket == 0, peeraddr); + + memset(&peeraddr, 0, sizeof(peeraddr)); + socklen_t addrlen = static_cast(sizeof peeraddr); + + int err = ::getpeername(_socket, static_cast((void *)(&peeraddr)), &addrlen); + + if (r_err) { + *r_err = err; + } + + return peeraddr; +} + +int Socket::global_init() { +#if defined(_WIN64) || defined(_WIN32) + int r; + WSADATA wsa_data; + + r = WSAStartup(MAKEWORD(2, 2), &wsa_data); + + return r; +#else + return 0; +#endif +} + +Socket::Socket() { + _socket = 0; +} + +Socket::Socket(int socketFD, const InetAddress &address) { + _socket = socketFD; + _address = address; +} + +Socket::~Socket() { + if (_socket >= 0) { + close_socket(); + } +} +#line 0 + +#line 1 "sfwl/core/sub_process.cpp" +/*************************************************************************/ +/* sub_process.cpp */ +/* From https://github.com/Relintai/pandemonium_engine (MIT) */ +/*************************************************************************/ + +#if defined(_WIN64) || defined(_WIN32) + +#define WIN32_LEAN_AND_MEAN +#include + +typedef struct tagLOGCONTEXTW { + WCHAR lcName[40]; + UINT lcOptions; + UINT lcStatus; + UINT lcLocks; + UINT lcMsgBase; + UINT lcDevice; + UINT lcPktRate; + DWORD lcPktData; + DWORD lcPktMode; + DWORD lcMoveMask; + DWORD lcBtnDnMask; + DWORD lcBtnUpMask; + LONG lcInOrgX; + LONG lcInOrgY; + LONG lcInOrgZ; + LONG lcInExtX; + LONG lcInExtY; + LONG lcInExtZ; + LONG lcOutOrgX; + LONG lcOutOrgY; + LONG lcOutOrgZ; + LONG lcOutExtX; + LONG lcOutExtY; + LONG lcOutExtZ; + DWORD lcSensX; + DWORD lcSensY; + DWORD lcSensZ; + BOOL lcSysMode; + int lcSysOrgX; + int lcSysOrgY; + int lcSysExtX; + int lcSysExtY; + DWORD lcSysSensX; + DWORD lcSysSensY; +} LOGCONTEXTW; + +typedef HANDLE(WINAPI *WTOpenPtr)(HWND p_window, LOGCONTEXTW *p_ctx, BOOL p_enable); + +// TODO clean these up +#include +#include +#include +#include +#include +#include +#include + +struct SubProcess::SubProcessWindowsData { + struct ProcessInfo { + STARTUPINFO si; + PROCESS_INFORMATION pi; + }; + + HANDLE _pipe_handles[2]; + ProcessInfo _process_info; +}; + +Error SubProcess::start() { + if (_executable_path.empty()) { + return ERR_FILE_BAD_PATH; + } + + if (is_process_running()) { + return ERR_BUSY; + } + + String path = _executable_path.replace("/", "\\"); + + String cmdline = _quote_command_line_argument(path); + for (int i = 0; i < _arguments.size(); ++i) { + cmdline += " " + _quote_command_line_argument(_arguments[i]); + } + + ZeroMemory(&_data->_process_info.si, sizeof(_data->_process_info.si)); + _data->_process_info.si.cb = sizeof(_data->_process_info.si); + ZeroMemory(&_data->_process_info.pi, sizeof(_data->_process_info.pi)); + LPSTARTUPINFOW si_w = (LPSTARTUPINFOW)&_data->_process_info.si; + + Char16String modstr = cmdline.utf16(); // Windows wants to change this no idea why. + + bool inherit_handles = false; + + if (_read_output) { + // Create pipe for StdOut and StdErr. + SECURITY_ATTRIBUTES sa; + sa.nLength = sizeof(SECURITY_ATTRIBUTES); + sa.bInheritHandle = true; + sa.lpSecurityDescriptor = NULL; + + ERR_FAIL_COND_V(!CreatePipe(&_data->_pipe_handles[0], &_data->_pipe_handles[1], &sa, 0), ERR_CANT_FORK); + ERR_FAIL_COND_V(!SetHandleInformation(_data->_pipe_handles[0], HANDLE_FLAG_INHERIT, 0), ERR_CANT_FORK); // Read handle is for host process only and should not be inherited. + + _data->_process_info.si.dwFlags |= STARTF_USESTDHANDLES; + _data->_process_info.si.hStdOutput = _data->_pipe_handles[1]; + if (_read_std_err) { + _data->_process_info.si.hStdError = _data->_pipe_handles[1]; + } + inherit_handles = true; + } + + DWORD creaton_flags = NORMAL_PRIORITY_CLASS; + if (_open_console) { + creaton_flags |= CREATE_NEW_CONSOLE; + } else { + creaton_flags |= CREATE_NO_WINDOW; + } + + int ret = CreateProcessW(nullptr, (LPWSTR)(modstr.ptrw()), nullptr, nullptr, inherit_handles, creaton_flags, nullptr, nullptr, si_w, &_data->_process_info.pi); + if (!ret && _read_output) { + CloseHandle(_data->_pipe_handles[0]); // Cleanup pipe handles. + CloseHandle(_data->_pipe_handles[1]); + + _data->_pipe_handles[0] = NULL; + _data->_pipe_handles[1] = NULL; + } + + ERR_FAIL_COND_V(ret == 0, ERR_CANT_FORK); + + if (_blocking) { + if (_read_output) { + CloseHandle(_data->_pipe_handles[1]); // Close pipe write handle (only child process is writing). + + int bytes_in_buffer = 0; + + const int CHUNK_SIZE = 4096; + DWORD read = 0; + for (;;) { // Read StdOut and StdErr from pipe. + _bytes.resize(bytes_in_buffer + CHUNK_SIZE); + const bool success = ReadFile(_data->_pipe_handles[0], _bytes.ptr() + bytes_in_buffer, CHUNK_SIZE, &read, NULL); + if (!success || read == 0) { + break; + } + // Assume that all possible encodings are ASCII-compatible. + // Break at newline to allow receiving long output in portions. + int newline_index = -1; + for (int i = read - 1; i >= 0; i--) { + if (_bytes[bytes_in_buffer + i] == '\n') { + newline_index = i; + break; + } + } + + if (newline_index == -1) { + bytes_in_buffer += read; + continue; + } + + const int bytes_to_convert = bytes_in_buffer + (newline_index + 1); + _append_to_pipe(_bytes.ptr(), bytes_to_convert); + + bytes_in_buffer = read - (newline_index + 1); + memmove(_bytes.ptr(), _bytes.ptr() + bytes_to_convert, bytes_in_buffer); + } + + if (bytes_in_buffer > 0) { + _append_to_pipe(_bytes.ptr(), bytes_in_buffer); + } + + CloseHandle(_data->_pipe_handles[0]); // Close pipe read handle. + } + + WaitForSingleObject(_data->_process_info.pi.hProcess, INFINITE); + + DWORD ret2; + GetExitCodeProcess(_data->_process_info.pi.hProcess, &ret2); + _exitcode = ret2; + + CloseHandle(_data->_process_info.pi.hProcess); + CloseHandle(_data->_process_info.pi.hThread); + } else { + if (_read_output) { + //eventually we will need to keep this + CloseHandle(_data->_pipe_handles[1]); // Close pipe write handle (only child process is writing). + _data->_pipe_handles[1] = NULL; + } + + _process_started = true; + + ProcessID pid = _data->_process_info.pi.dwProcessId; + _process_id = pid; + } + + return OK; +} + +Error SubProcess::stop() { + if (!_process_started) { + return OK; + } + + if (_data->_pipe_handles[0]) { + CloseHandle(_data->_pipe_handles[0]); // Cleanup pipe handles. + _data->_pipe_handles[0] = NULL; + } + + if (_data->_pipe_handles[1]) { + CloseHandle(_data->_pipe_handles[1]); + _data->_pipe_handles[1] = NULL; + } + + const int ret = TerminateProcess(_data->_process_info.pi.hProcess, 0); + + CloseHandle(_data->_process_info.pi.hProcess); + CloseHandle(_data->_process_info.pi.hThread); + + ZeroMemory(&_data->_process_info.si, sizeof(_data->_process_info.si)); + _data->_process_info.si.cb = sizeof(_data->_process_info.si); + ZeroMemory(&_data->_process_info.pi, sizeof(_data->_process_info.pi)); + + _process_started = false; + + return ret != 0 ? OK : FAILED; +} + +Error SubProcess::poll() { + if (!_process_started) { + return FAILED; + } + + if (!_data->_pipe_handles[0]) { + return FAILED; + } + + _pipe.clear(); + + int bytes_in_buffer = 0; + + const int CHUNK_SIZE = 4096; + DWORD read = 0; + + _bytes.resize(bytes_in_buffer + CHUNK_SIZE); + const bool success = ReadFile(_data->_pipe_handles[0], _bytes.ptr() + bytes_in_buffer, CHUNK_SIZE, &read, NULL); + + if (!success) { + stop(); + return ERR_FILE_EOF; + } + + if (read == 0) { + return OK; + } + + // Assume that all possible encodings are ASCII-compatible. + // Break at newline to allow receiving long output in portions. + int newline_index = -1; + for (int i = read - 1; i >= 0; i--) { + if (_bytes[bytes_in_buffer + i] == '\n') { + newline_index = i; + break; + } + } + + if (newline_index == -1) { + bytes_in_buffer += read; + return OK; + } + + const int bytes_to_convert = bytes_in_buffer + (newline_index + 1); + _append_to_pipe(_bytes.ptr(), bytes_to_convert); + + bytes_in_buffer = read - (newline_index + 1); + memmove(_bytes.ptr(), _bytes.ptr() + bytes_to_convert, bytes_in_buffer); + + if (bytes_in_buffer > 0) { + _append_to_pipe(_bytes.ptr(), bytes_in_buffer); + } + + return OK; +} + +Error SubProcess::send_signal(const int p_signal) { + //Not Yet Impl + ERR_FAIL_V(ERR_BUG); +} + +Error SubProcess::send_data(const String &p_data) { + //Not Yet Impl + ERR_FAIL_V(ERR_BUG); +} + +bool SubProcess::is_process_running() const { + if (_process_id == 0) { + return false; + } + + if (!_process_started) { + return false; + } + + DWORD dw_exit_code = 0; + if (!GetExitCodeProcess(_data->_process_info.pi.hProcess, &dw_exit_code)) { + return false; + } + + if (dw_exit_code != STILL_ACTIVE) { + return false; + } + + return true; +} + +String SubProcess::_quote_command_line_argument(const String &p_text) const { + for (int i = 0; i < p_text.size(); i++) { + CharType c = p_text[i]; + if (c == ' ' || c == '&' || c == '(' || c == ')' || c == '[' || c == ']' || c == '{' || c == '}' || c == '^' || c == '=' || c == ';' || c == '!' || c == '\'' || c == '+' || c == ',' || c == '`' || c == '~') { + return "\"" + p_text + "\""; + } + } + return p_text; +} + +void SubProcess::_append_to_pipe(char *p_bytes, int p_size) { + // Try to convert from default ANSI code page to Unicode. + LocalVector wchars; + int total_wchars = MultiByteToWideChar(CP_ACP, 0, p_bytes, p_size, nullptr, 0); + if (total_wchars > 0) { + wchars.resize(total_wchars); + if (MultiByteToWideChar(CP_ACP, 0, p_bytes, p_size, wchars.ptr(), total_wchars) == 0) { + wchars.clear(); + } + } + + if (_pipe_mutex) { + _pipe_mutex->lock(); + } + if (wchars.empty()) { + // Let's hope it's compatible with UTF-8. + _pipe += String::utf8(p_bytes, p_size); + } else { + _pipe += String(wchars.ptr(), total_wchars); + } + if (_pipe_mutex) { + _pipe_mutex->unlock(); + } +} + +SubProcess::SubProcess() { + _data = memnew(SubProcessWindowsData); + + _blocking = false; + + _read_output = true; + + _read_std = true; + _read_std_err = false; + + _use_pipe_mutex = false; + + _pipe_mutex = NULL; + + _open_console = false; + + _process_id = ProcessID(); + _exitcode = 0; + + _data->_pipe_handles[0] = NULL; + _data->_pipe_handles[1] = NULL; + + _process_started = false; + + ZeroMemory(&_data->_process_info.si, sizeof(_data->_process_info.si)); + _data->_process_info.si.cb = sizeof(_data->_process_info.si); + ZeroMemory(&_data->_process_info.pi, sizeof(_data->_process_info.pi)); +} +SubProcess::~SubProcess() { + stop(); + + memdelete(_data); +} + +#else + +#include +#include +#include +#include +#include +#include +#include + +Error SubProcess::start() { +#ifdef __EMSCRIPTEN__ + // Don't compile this code at all to avoid undefined references. + // Actual virtual call goes to OS_JavaScript. + ERR_FAIL_V(ERR_BUG); +#else + if (_executable_path.empty()) { + return ERR_FILE_BAD_PATH; + } + + if (is_process_running()) { + return ERR_BUSY; + } + + if (_blocking && _read_output) { + String argss; + argss = "\"" + _executable_path + "\""; + + for (int i = 0; i < _arguments.size(); i++) { + argss += String(" \"") + _arguments[i] + "\""; + } + + if (_read_std_err) { + argss += " 2>&1"; // Read stderr too + } else { + argss += " 2>/dev/null"; //silence stderr + } + FILE *f = popen(argss.utf8().get_data(), "r"); + + ERR_FAIL_COND_V_MSG(!f, ERR_CANT_OPEN, "Cannot pipe stream from process running with following arguments '" + argss + "'."); + + char buf[65535]; + + while (fgets(buf, 65535, f)) { + if (_pipe_mutex) { + _pipe_mutex->lock(); + } + _pipe += String::utf8(buf); + if (_pipe_mutex) { + _pipe_mutex->unlock(); + } + } + int rv = pclose(f); + + _exitcode = WEXITSTATUS(rv); + + return OK; + } + + if (!_blocking && _read_output) { + String argss; + argss = "\"" + _executable_path + "\""; + + for (int i = 0; i < _arguments.size(); i++) { + argss += String(" \"") + _arguments[i] + "\""; + } + + if (_read_std_err) { + argss += " 2>&1"; // Read stderr too + } else { + argss += " 2>/dev/null"; //silence stderr + } + + _process_fp = popen(argss.utf8().get_data(), "r"); + + ERR_FAIL_COND_V_MSG(!_process_fp, ERR_CANT_OPEN, "Cannot pipe stream from process running with following arguments '" + argss + "'."); + + return OK; + } + + // We just run it, no need to worry about output + + pid_t pid = fork(); + ERR_FAIL_COND_V(pid < 0, ERR_CANT_FORK); + + if (pid == 0) { + // is child + + if (!_blocking) { + // For non blocking calls, create a new session-ID so parent won't wait for it. + // This ensures the process won't go zombie at end. + setsid(); + } + + Vector cs; + cs.push_back(_executable_path.utf8()); + for (int i = 0; i < _arguments.size(); i++) { + cs.push_back(_arguments[i].utf8()); + } + + Vector args; + for (int i = 0; i < cs.size(); i++) { + args.push_back((char *)cs[i].get_data()); + } + args.push_back(0); + + execvp(_executable_path.utf8().get_data(), &args[0]); + // still alive? something failed.. + fprintf(stderr, "**ERROR** SubProcess::execute - Could not create child process while executing: %s\n", _executable_path.utf8().get_data()); + raise(SIGKILL); + } + + if (_blocking) { + int status; + waitpid(pid, &status, 0); + + _exitcode = WIFEXITED(status) ? WEXITSTATUS(status) : status; + } else { + _process_id = pid; + } + + return OK; +#endif +} + +Error SubProcess::stop() { +#ifdef __EMSCRIPTEN__ + // Don't compile this code at all to avoid undefined references. + // Actual virtual call goes to OS_JavaScript. + ERR_FAIL_V(ERR_BUG); +#else + if (_process_fp) { + int rv = pclose(_process_fp); + _process_fp = NULL; + _exitcode = WEXITSTATUS(rv); + _process_id = 0; + return OK; + } + + if (_process_id) { + int ret = ::kill(_process_id, SIGKILL); + + if (!ret) { + //avoid zombie process + int st; + ::waitpid(_process_id, &st, 0); + } + + _process_id = 0; + + return ret ? ERR_INVALID_PARAMETER : OK; + } + + return OK; +#endif +} + +Error SubProcess::poll() { +#ifdef __EMSCRIPTEN__ + // Don't compile this code at all to avoid undefined references. + // Actual virtual call goes to OS_JavaScript. + ERR_FAIL_V(ERR_BUG); +#else + + if (_process_fp) { + if (fgets(_process_buf, 65535, _process_fp)) { + if (_pipe_mutex) { + _pipe_mutex->lock(); + } + _pipe = String::utf8(_process_buf); + if (_pipe_mutex) { + _pipe_mutex->unlock(); + } + } else { + // The process finished + // Cleanup: + stop(); + return ERR_FILE_EOF; + } + } + + return OK; +#endif +} + +Error SubProcess::send_signal(const int p_signal) { + //Not Yet Impl + ERR_FAIL_V(ERR_BUG); +} + +Error SubProcess::send_data(const String &p_data) { + //Not Yet Impl + ERR_FAIL_V(ERR_BUG); +} + +bool SubProcess::is_process_running() const { +#ifdef __EMSCRIPTEN__ + // Don't compile this code at all to avoid undefined references. + // Actual virtual call goes to OS_JavaScript. + ERR_FAIL_V(false); +#else + + if (_process_fp) { + return !feof(_process_fp); + } + + if (_process_id == 0) { + return false; + } + + int status = 0; + if (waitpid(_process_id, &status, WNOHANG) != 0) { + return false; + } + + return true; +#endif +} + +SubProcess::SubProcess() { + _blocking = false; + + _read_output = true; + + _read_std = true; + _read_std_err = false; + + _use_pipe_mutex = false; + + _pipe_mutex = NULL; + + _open_console = false; + + _process_id = ProcessID(); + _exitcode = 0; + + _process_fp = NULL; +} +SubProcess::~SubProcess() { + stop(); +} + +#endif + +SubProcess *SubProcess::create() { + return memnew(SubProcess()); +} + +String SubProcess::get_executable_path() const { + return _executable_path; +} +void SubProcess::set_executable_path(const String &p_executable_path) { + ERR_FAIL_COND(is_process_running()); + + _executable_path = p_executable_path; +} + +Vector SubProcess::get_arguments() const { + return _arguments; +} +void SubProcess::set_arguments(const Vector &p_arguments) { + ERR_FAIL_COND(is_process_running()); + + _arguments = p_arguments; +} + +bool SubProcess::get_blocking() const { + return _blocking; +} +void SubProcess::set_blocking(const bool p_value) { + ERR_FAIL_COND(is_process_running()); + + _blocking = p_value; +} + +bool SubProcess::get_read_output() const { + return _read_output; +} +void SubProcess::set_read_output(const bool p_value) { + ERR_FAIL_COND(is_process_running()); + + _read_output = p_value; +} + +bool SubProcess::get_read_std() const { + return _read_std; +} +void SubProcess::set_read_std(const bool p_value) { + ERR_FAIL_COND(is_process_running()); + + _read_std = p_value; +} + +bool SubProcess::get_read_std_err() const { + return _read_std_err; +} +void SubProcess::set_read_std_err(const bool p_value) { + ERR_FAIL_COND(is_process_running()); + + _read_std_err = p_value; +} + +bool SubProcess::get_use_pipe_mutex() const { + return _use_pipe_mutex; +} +void SubProcess::set_use_pipe_mutex(const bool p_value) { + ERR_FAIL_COND(is_process_running()); + + _use_pipe_mutex = p_value; +} + +bool SubProcess::get_open_console() const { + return _open_console; +} +void SubProcess::set_open_console(const bool p_value) { + ERR_FAIL_COND(is_process_running()); + + _open_console = p_value; +} + +Error SubProcess::run(const String &p_executable_path, const Vector &p_arguments, bool p_output, bool p_blocking, bool p_read_std_err, bool p_use_pipe_mutex, bool p_open_console) { + if (is_process_running()) { + return ERR_ALREADY_IN_USE; + } + + _executable_path = p_executable_path; + _arguments = p_arguments; + + _blocking = p_blocking; + + _read_output = p_output; + + _read_std = true; + _read_std_err = p_read_std_err; + + _use_pipe_mutex = p_use_pipe_mutex; + + _open_console = p_open_console; + + _setup_pipe_mutex(); + + return start(); +} + +/* +SubProcess::SubProcess() { + _blocking = false; + + _read_output = true; + + _read_std = true; + _read_std_err = false; + + _use_pipe_mutex = false; + + _pipe_mutex = NULL; + + _open_console = false; + + _process_id = ProcessID(); + _exitcode = 0; +}; +*/ + +void SubProcess::_setup_pipe_mutex() { + if (_use_pipe_mutex) { + if (!_pipe_mutex) { + _pipe_mutex = memnew(Mutex); + } + } else { + if (_pipe_mutex) { + memdelete(_pipe_mutex); + _pipe_mutex = NULL; + } + } +} +#line 0 + +#line 1 "sfwl/core/sfw_core.cpp" + +void SFWCore::setup() { + if (_initialized) { + return; + } + + _initialized = true; + + StringName::setup(); + MemoryPool::setup(); +} + +void SFWCore::cleanup() { + if (!_initialized) { + return; + } + + _initialized = false; + + StringName::cleanup(); + MemoryPool::cleanup(); +} + +bool SFWCore::_initialized = false; +#line 0 + +//=================== OBJECT SECTION =================== + +#line 1 "sfwl/object/resource.cpp" + +void Resource::emit_changed() { + changed.emit(this); +} + +Error Resource::load(const String &path) { + return ERR_UNAVAILABLE; +} +Error Resource::save(const String &path) { + return ERR_UNAVAILABLE; +} + +Resource::Resource() : + Reference() { +} + +Resource::~Resource() { +} +#line 0 + +#line 1 "sfwl/object/reference.cpp" + +/*************************************************************************/ +/* reference.cpp */ +/* From https://github.com/Relintai/pandemonium_engine (MIT) */ +/*************************************************************************/ + +bool Reference::init_ref() { + if (reference()) { + if (!is_referenced() && refcount_init.unref()) { + unreference(); // first referencing is already 1, so compensate for the ref above + } + + return true; + } else { + return false; + } +} + +int Reference::reference_get_count() const { + return refcount.get(); +} + +bool Reference::reference() { + uint32_t rc_val = refcount.refval(); + bool success = rc_val != 0; + + return success; +} + +bool Reference::unreference() { + uint32_t rc_val = refcount.unrefval(); + bool die = rc_val == 0; + + return die; +} + +Reference::Reference() : + Object() { + refcount.init(); + refcount_init.init(); +} + +Reference::~Reference() { +} + +/* \ +void WeakRef::set_obj(Object *p_object) { \ + //ref = p_object ? p_object->get_instance_id() : 0; \ +} \ + \ +void WeakRef::set_ref(const REF &p_ref) { \ + //ref = p_ref.is_valid() ? p_ref->get_instance_id() : 0; \ +} \ + \ +WeakRef::WeakRef() : \ + ref(0) { \ +} \ +*/ \ +#line 0 + +#line 1 "sfwl/object/object.cpp" + +void Object::set(const StringName &p_name, const Variant &p_value, bool *r_valid) { + if (p_name == CoreStringNames::get_singleton()->_meta) { + //set_meta(p_name,p_value); + metadata = p_value.duplicate(); + if (r_valid) { + *r_valid = true; + } + return; + } + + //something inside the object... :| + bool success = _setv(p_name, p_value); + if (success) { + if (r_valid) { + *r_valid = true; + } + return; + } + + if (r_valid) { + *r_valid = false; + } +} + +Variant Object::get(const StringName &p_name, bool *r_valid) const { + Variant ret; + + if (p_name == CoreStringNames::get_singleton()->_meta) { + ret = metadata; + if (r_valid) { + *r_valid = true; + } + return ret; + + } else { + //something inside the object... :| + bool success = _getv(p_name, ret); + if (success) { + if (r_valid) { + *r_valid = true; + } + return ret; + } + + if (r_valid) { + *r_valid = false; + } + + return Variant(); + } +} + +bool Object::lt(const Variant &p_value_l, const Variant &p_value_r) { + return p_value_l < p_value_r; +} + +void Object::notification(int p_notification, bool p_reversed) { + _notificationv(p_notification, p_reversed); +} + +String Object::to_string() { + return "[" + get_class() + ":" + itos(get_instance_id()) + "]"; +} + +bool Object::_predelete() { + _predelete_ok = 1; + notification(NOTIFICATION_PREDELETE, true); + if (_predelete_ok) { + _class_ptr = nullptr; //must restore so destructors can access class ptr correctly + } + return _predelete_ok; +} + +void Object::_postinitialize() { + _class_ptr = _get_class_namev(); + notification(NOTIFICATION_POSTINITIALIZE); +} + +bool Object::has_meta(const String &p_name) const { + return metadata.has(p_name); +} + +void Object::set_meta(const String &p_name, const Variant &p_value) { + if (p_value.get_type() == Variant::NIL) { + metadata.erase(p_name); + return; + }; + + metadata[p_name] = p_value; +} + +Variant Object::get_meta(const String &p_name, const Variant &p_default) const { + if (!metadata.has(p_name)) { + return p_default; + } + return metadata[p_name]; +} + +void Object::remove_meta(const String &p_name) { + metadata.erase(p_name); +} + +void Object::cancel_free() { + _predelete_ok = 0; +} + +Object::Object() { + _is_queued_for_deletion = false; + _predelete_ok = 0; + _instance_id = 0; + _instance_id = ObjectDB::add_instance(this); +} + +Object::~Object() { +} + +ObjectRC *Object::_use_rc() { + // The RC object is lazily created the first time it's requested; + // that way, there's no need to allocate and release it at all if this Object + // is not being referred by any Variant at all. + + // Although when dealing with Objects from multiple threads some locking + // mechanism should be used, this at least makes safe the case of first + // assignment. + + ObjectRC *rc = nullptr; + ObjectRC *const creating = reinterpret_cast(1); + if (unlikely(_rc.compare_exchange_strong(rc, creating, std::memory_order_acq_rel))) { + // Not created yet + rc = memnew(ObjectRC(this)); + _rc.store(rc, std::memory_order_release); + return rc; + } + + // Spin-wait until we know it's created (or just return if it's already created) + for (;;) { + if (likely(rc != creating)) { + rc->increment(); + return rc; + } + rc = _rc.load(std::memory_order_acquire); + } +} + +bool predelete_handler(Object *p_object) { + return p_object->_predelete(); +} + +void postinitialize_handler(Object *p_object) { + p_object->_postinitialize(); +} + +HashMap ObjectDB::instances; +ObjectID ObjectDB::instance_counter = 1; +HashMap ObjectDB::instance_checks; +ObjectID ObjectDB::add_instance(Object *p_object) { + ERR_FAIL_COND_V(p_object->get_instance_id() != 0, 0); + + rw_lock.write_lock(); + ObjectID instance_id = ++instance_counter; + instances[instance_id] = p_object; + instance_checks[p_object] = instance_id; + + rw_lock.write_unlock(); + + return instance_id; +} + +void ObjectDB::remove_instance(Object *p_object) { + rw_lock.write_lock(); + + instances.erase(p_object->get_instance_id()); + instance_checks.erase(p_object); + + rw_lock.write_unlock(); +} +Object *ObjectDB::get_instance(ObjectID p_instance_id) { + rw_lock.read_lock(); + Object **obj = instances.getptr(p_instance_id); + rw_lock.read_unlock(); + + if (!obj) { + return nullptr; + } + return *obj; +} + +void ObjectDB::debug_objects(DebugFunc p_func) { + rw_lock.read_lock(); + + const ObjectID *K = nullptr; + while ((K = instances.next(K))) { + p_func(instances[*K]); + } + + rw_lock.read_unlock(); +} + +int ObjectDB::get_object_count() { + rw_lock.read_lock(); + int count = instances.size(); + rw_lock.read_unlock(); + + return count; +} + +RWLock ObjectDB::rw_lock; + +void ObjectDB::cleanup() { + rw_lock.write_lock(); + if (instances.size()) { + LOG_WARN("ObjectDB instances leaked at exit!"); + } + instances.clear(); + instance_checks.clear(); + rw_lock.write_unlock(); +} +#line 0 + +#line 1 "sfwl/object/ref_ptr.cpp" +/*************************************************************************/ +/* ref_ptr.cpp */ +/* From https://github.com/Relintai/pandemonium_engine (MIT) */ +/*************************************************************************/ + +void RefPtr::operator=(const RefPtr &p_other) { + Ref *ref = reinterpret_cast *>(&data[0]); + Ref *ref_other = reinterpret_cast *>(const_cast(&p_other.data[0])); + + *ref = *ref_other; +} + +bool RefPtr::operator==(const RefPtr &p_other) const { + Ref *ref = reinterpret_cast *>(&data[0]); + Ref *ref_other = reinterpret_cast *>(const_cast(&p_other.data[0])); + + return *ref == *ref_other; +} + +bool RefPtr::operator!=(const RefPtr &p_other) const { + Ref *ref = reinterpret_cast *>(&data[0]); + Ref *ref_other = reinterpret_cast *>(const_cast(&p_other.data[0])); + + return *ref != *ref_other; +} + +RefPtr::RefPtr(const RefPtr &p_other) { + memnew_placement(&data[0], Ref); + + Ref *ref = reinterpret_cast *>(&data[0]); + Ref *ref_other = reinterpret_cast *>(const_cast(&p_other.data[0])); + + *ref = *ref_other; +} + +bool RefPtr::is_null() const { + Ref *ref = reinterpret_cast *>(&data[0]); + return ref->is_null(); +} + +void RefPtr::unref() { + Ref *ref = reinterpret_cast *>(&data[0]); + ref->unref(); +} + +RefPtr::RefPtr() { + ERR_FAIL_COND(sizeof(Ref) > DATASIZE); + memnew_placement(&data[0], Ref); +} + +RefPtr::~RefPtr() { + Ref *ref = reinterpret_cast *>(&data[0]); + ref->~Ref(); +} +#line 0 + +#line 1 "sfwl/object/core_string_names.cpp" +/*************************************************************************/ +/* core_string_names.cpp */ +/* From https://github.com/Relintai/pandemonium_engine (MIT) */ +/*************************************************************************/ + +CoreStringNames *CoreStringNames::singleton = nullptr; + +CoreStringNames::CoreStringNames() : + _free(StaticCString::create("free")), + changed(StaticCString::create("changed")), + _meta(StaticCString::create("__meta__")), + _script(StaticCString::create("script")), + script_changed(StaticCString::create("script_changed")), + ___pdcdata(StaticCString::create("___pdcdata")), + __getvar(StaticCString::create("__getvar")), + _iter_init(StaticCString::create("_iter_init")), + _iter_next(StaticCString::create("_iter_next")), + _iter_get(StaticCString::create("_iter_get")), + get_rid(StaticCString::create("get_rid")), + _to_string(StaticCString::create("_to_string")), +#ifdef TOOLS_ENABLED + _sections_unfolded(StaticCString::create("_sections_unfolded")), +#endif + _custom_features(StaticCString::create("_custom_features")), + x(StaticCString::create("x")), + y(StaticCString::create("y")), + z(StaticCString::create("z")), + w(StaticCString::create("w")), + r(StaticCString::create("r")), + g(StaticCString::create("g")), + b(StaticCString::create("b")), + a(StaticCString::create("a")), + position(StaticCString::create("position")), + size(StaticCString::create("size")), + end(StaticCString::create("end")), + basis(StaticCString::create("basis")), + origin(StaticCString::create("origin")), + normal(StaticCString::create("normal")), + d(StaticCString::create("d")), + h(StaticCString::create("h")), + s(StaticCString::create("s")), + v(StaticCString::create("v")), + r8(StaticCString::create("r8")), + g8(StaticCString::create("g8")), + b8(StaticCString::create("b8")), + a8(StaticCString::create("a8")) { +} +#line 0 + +#line 1 "sfwl/object/dictionary.cpp" +/*************************************************************************/ +/* dictionary.cpp */ +/* From https://github.com/Relintai/pandemonium_engine (MIT) */ +/*************************************************************************/ + +struct DictionaryPrivate { + SafeRefCount refcount; + OrderedHashMap variant_map; +}; + +void Dictionary::get_key_list(List *p_keys) const { + if (_p->variant_map.empty()) { + return; + } + + for (OrderedHashMap::Element E = _p->variant_map.front(); E; E = E.next()) { + p_keys->push_back(E.key()); + } +} + +Variant Dictionary::get_key_at_index(int p_index) const { + int index = 0; + for (OrderedHashMap::Element E = _p->variant_map.front(); E; E = E.next()) { + if (index == p_index) { + return E.key(); + } + index++; + } + + return Variant(); +} + +Variant Dictionary::get_value_at_index(int p_index) const { + int index = 0; + for (OrderedHashMap::Element E = _p->variant_map.front(); E; E = E.next()) { + if (index == p_index) { + return E.value(); + } + index++; + } + + return Variant(); +} + +Variant &Dictionary::operator[](const Variant &p_key) { + return _p->variant_map[p_key]; +} + +const Variant &Dictionary::operator[](const Variant &p_key) const { + return _p->variant_map[p_key]; +} +const Variant *Dictionary::getptr(const Variant &p_key) const { + OrderedHashMap::ConstElement E = ((const OrderedHashMap *)&_p->variant_map)->find(p_key); + + if (!E) { + return nullptr; + } + return &E.get(); +} + +Variant *Dictionary::getptr(const Variant &p_key) { + OrderedHashMap::Element E = _p->variant_map.find(p_key); + + if (!E) { + return nullptr; + } + return &E.get(); +} + +Variant Dictionary::get_valid(const Variant &p_key) const { + OrderedHashMap::ConstElement E = ((const OrderedHashMap *)&_p->variant_map)->find(p_key); + + if (!E) { + return Variant(); + } + return E.get(); +} + +Variant Dictionary::get(const Variant &p_key, const Variant &p_default) const { + const Variant *result = getptr(p_key); + if (!result) { + return p_default; + } + + return *result; +} + +int Dictionary::size() const { + return _p->variant_map.size(); +} +bool Dictionary::empty() const { + return !_p->variant_map.size(); +} + +bool Dictionary::has(const Variant &p_key) const { + return _p->variant_map.has(p_key); +} + +bool Dictionary::has_all(const Array &p_keys) const { + for (int i = 0; i < p_keys.size(); i++) { + if (!has(p_keys[i])) { + return false; + } + } + return true; +} + +Variant Dictionary::find_key(const Variant &p_value) const { + for (OrderedHashMap::Element E = _p->variant_map.front(); E; E = E.next()) { + if (E.value() == p_value) { + return E.key(); + } + } + return Variant(); +} + +bool Dictionary::erase(const Variant &p_key) { + return _p->variant_map.erase(p_key); +} + +bool Dictionary::deep_equal(const Dictionary &p_dictionary, int p_recursion_count) const { + // Cheap checks + ERR_FAIL_COND_V_MSG(p_recursion_count > MAX_RECURSION, 0, "Max recursion reached"); + if (_p == p_dictionary._p) { + return true; + } + if (_p->variant_map.size() != p_dictionary._p->variant_map.size()) { + return false; + } + + // Heavy O(n) check + OrderedHashMap::Element this_E = _p->variant_map.front(); + OrderedHashMap::Element other_E = p_dictionary._p->variant_map.front(); + p_recursion_count++; + while (this_E && other_E) { + if ( + !this_E.key().deep_equal(other_E.key(), p_recursion_count) || + !this_E.value().deep_equal(other_E.value(), p_recursion_count)) { + return false; + } + + this_E = this_E.next(); + other_E = other_E.next(); + } + + return !this_E && !other_E; +} + +bool Dictionary::operator==(const Dictionary &p_dictionary) const { + return _p == p_dictionary._p; +} + +bool Dictionary::operator!=(const Dictionary &p_dictionary) const { + return _p != p_dictionary._p; +} + +void Dictionary::_ref(const Dictionary &p_from) const { + //make a copy first (thread safe) + if (!p_from._p->refcount.ref()) { + return; // couldn't copy + } + + //if this is the same, unreference the other one + if (p_from._p == _p) { + _p->refcount.unref(); + return; + } + if (_p) { + _unref(); + } + _p = p_from._p; +} + +void Dictionary::clear() { + _p->variant_map.clear(); +} + +void Dictionary::merge(const Dictionary &p_dictionary, bool p_overwrite) { + for (OrderedHashMap::Element E = p_dictionary._p->variant_map.front(); E; E = E.next()) { + if (p_overwrite || !has(E.key())) { + this->operator[](E.key()) = E.value(); + } + } +} + +void Dictionary::_unref() const { + ERR_FAIL_COND(!_p); + if (_p->refcount.unref()) { + memdelete(_p); + } + _p = nullptr; +} + +uint32_t Dictionary::hash() const { + return recursive_hash(0); +} + +uint32_t Dictionary::recursive_hash(int p_recursion_count) const { + ERR_FAIL_COND_V_MSG(p_recursion_count > MAX_RECURSION, 0, "Max recursion reached"); + p_recursion_count++; + + uint32_t h = hash_murmur3_one_32(Variant::DICTIONARY); + + for (OrderedHashMap::Element E = _p->variant_map.front(); E; E = E.next()) { + h = hash_murmur3_one_32(E.key().recursive_hash(p_recursion_count), h); + h = hash_murmur3_one_32(E.value().recursive_hash(p_recursion_count), h); + } + + return hash_fmix32(h); +} + +Array Dictionary::keys() const { + Array varr; + if (_p->variant_map.empty()) { + return varr; + } + + varr.resize(size()); + + int i = 0; + for (OrderedHashMap::Element E = _p->variant_map.front(); E; E = E.next()) { + varr[i] = E.key(); + i++; + } + + return varr; +} + +Array Dictionary::values() const { + Array varr; + if (_p->variant_map.empty()) { + return varr; + } + + varr.resize(size()); + + int i = 0; + for (OrderedHashMap::Element E = _p->variant_map.front(); E; E = E.next()) { + varr[i] = E.get(); + i++; + } + + return varr; +} + +const Variant *Dictionary::next(const Variant *p_key) const { + if (p_key == nullptr) { + // caller wants to get the first element + if (_p->variant_map.front()) { + return &_p->variant_map.front().key(); + } + return nullptr; + } + OrderedHashMap::Element E = _p->variant_map.find(*p_key); + + if (E && E.next()) { + return &E.next().key(); + } + return nullptr; +} + +Dictionary Dictionary::duplicate(bool p_deep) const { + Dictionary n; + + for (OrderedHashMap::Element E = _p->variant_map.front(); E; E = E.next()) { + n[E.key()] = p_deep ? E.value().duplicate(true) : E.value(); + } + + return n; +} + +void Dictionary::operator=(const Dictionary &p_dictionary) { + _ref(p_dictionary); +} + +const void *Dictionary::id() const { + return _p; +} + +Dictionary::Dictionary(const Dictionary &p_from) { + _p = nullptr; + _ref(p_from); +} + +Dictionary::Dictionary() { + _p = memnew(DictionaryPrivate); + _p->refcount.init(); +} +Dictionary::~Dictionary() { + _unref(); +} +#line 0 + +#line 1 "sfwl/object/array.cpp" +/*************************************************************************/ +/* array.cpp */ +/* From https://github.com/Relintai/pandemonium_engine (MIT) */ +/*************************************************************************/ + +class ArrayPrivate { +public: + SafeRefCount refcount; + Vector array; +}; + +void Array::_ref(const Array &p_from) const { + ArrayPrivate *_fp = p_from._p; + + ERR_FAIL_COND(!_fp); // should NOT happen. + + if (_fp == _p) { + return; // whatever it is, nothing to do here move along + } + + bool success = _fp->refcount.ref(); + + ERR_FAIL_COND(!success); // should really not happen either + + _unref(); + + _p = p_from._p; +} + +void Array::_unref() const { + if (!_p) { + return; + } + + if (_p->refcount.unref()) { + memdelete(_p); + } + _p = nullptr; +} + +Variant &Array::operator[](int p_idx) { + return _p->array.write[p_idx]; +} + +const Variant &Array::operator[](int p_idx) const { + return _p->array[p_idx]; +} + +int Array::size() const { + return _p->array.size(); +} +bool Array::empty() const { + return _p->array.empty(); +} +void Array::clear() { + _p->array.clear(); +} + +bool Array::deep_equal(const Array &p_array, int p_recursion_count) const { + // Cheap checks + ERR_FAIL_COND_V_MSG(p_recursion_count > MAX_RECURSION, true, "Max recursion reached"); + if (_p == p_array._p) { + return true; + } + const Vector &a1 = _p->array; + const Vector &a2 = p_array._p->array; + const int size = a1.size(); + if (size != a2.size()) { + return false; + } + + // Heavy O(n) check + p_recursion_count++; + for (int i = 0; i < size; i++) { + if (!a1[i].deep_equal(a2[i], p_recursion_count)) { + return false; + } + } + + return true; +} + +bool Array::operator==(const Array &p_array) const { + return _p == p_array._p; +} + +uint32_t Array::hash() const { + return recursive_hash(0); +} + +uint32_t Array::recursive_hash(int p_recursion_count) const { + ERR_FAIL_COND_V_MSG(p_recursion_count > MAX_RECURSION, 0, "Max recursion reached"); + p_recursion_count++; + + uint32_t h = hash_murmur3_one_32(0); + + for (int i = 0; i < _p->array.size(); i++) { + h = hash_murmur3_one_32(_p->array[i].recursive_hash(p_recursion_count), h); + } + return hash_fmix32(h); +} + +void Array::operator=(const Array &p_array) { + _ref(p_array); +} + +void Array::push_back(const Variant &p_value) { + _p->array.push_back(p_value); +} + +void Array::append_array(const Array &p_array) { + _p->array.append_array(p_array._p->array); +} + +Error Array::resize(int p_new_size) { + return _p->array.resize(p_new_size); +} + +void Array::insert(int p_pos, const Variant &p_value) { + _p->array.insert(p_pos, p_value); +} + +void Array::fill(const Variant &p_value) { + _p->array.fill(p_value); +} + +void Array::erase(const Variant &p_value) { + _p->array.erase(p_value); +} + +Variant Array::front() const { + ERR_FAIL_COND_V_MSG(_p->array.size() == 0, Variant(), "Can't take value from empty array."); + return operator[](0); +} + +Variant Array::back() const { + ERR_FAIL_COND_V_MSG(_p->array.size() == 0, Variant(), "Can't take value from empty array."); + return operator[](_p->array.size() - 1); +} + +int Array::find(const Variant &p_value, int p_from) const { + return _p->array.find(p_value, p_from); +} + +int Array::rfind(const Variant &p_value, int p_from) const { + if (_p->array.size() == 0) { + return -1; + } + + if (p_from < 0) { + // Relative offset from the end + p_from = _p->array.size() + p_from; + } + if (p_from < 0 || p_from >= _p->array.size()) { + // Limit to array boundaries + p_from = _p->array.size() - 1; + } + + for (int i = p_from; i >= 0; i--) { + if (_p->array[i] == p_value) { + return i; + } + } + + return -1; +} + +int Array::find_last(const Variant &p_value) const { + return rfind(p_value); +} + +int Array::count(const Variant &p_value) const { + if (_p->array.size() == 0) { + return 0; + } + + int amount = 0; + for (int i = 0; i < _p->array.size(); i++) { + if (_p->array[i] == p_value) { + amount++; + } + } + + return amount; +} + +bool Array::has(const Variant &p_value) const { + return _p->array.find(p_value, 0) != -1; +} + +void Array::remove(int p_pos) { + _p->array.remove(p_pos); +} + +void Array::set(int p_idx, const Variant &p_value) { + operator[](p_idx) = p_value; +} + +const Variant &Array::get(int p_idx) const { + return operator[](p_idx); +} + +Array Array::duplicate(bool p_deep) const { + Array new_arr; + int element_count = size(); + new_arr.resize(element_count); + for (int i = 0; i < element_count; i++) { + new_arr[i] = p_deep ? get(i).duplicate(p_deep) : get(i); + } + + return new_arr; +} + +int Array::_clamp_slice_index(int p_index) const { + int arr_size = size(); + int fixed_index = CLAMP(p_index, -arr_size, arr_size - 1); + if (fixed_index < 0) { + fixed_index = arr_size + fixed_index; + } + return fixed_index; +} + +Array Array::slice(int p_begin, int p_end, int p_step, bool p_deep) const { // like python, but inclusive on upper bound + + Array new_arr; + + ERR_FAIL_COND_V_MSG(p_step == 0, new_arr, "Array slice step size cannot be zero."); + + if (empty()) { // Don't try to slice empty arrays. + return new_arr; + } + if (p_step > 0) { + if (p_begin >= size() || p_end < -size()) { + return new_arr; + } + } else { // p_step < 0 + if (p_begin < -size() || p_end >= size()) { + return new_arr; + } + } + + int begin = _clamp_slice_index(p_begin); + int end = _clamp_slice_index(p_end); + + int new_arr_size = MAX(((end - begin + p_step) / p_step), 0); + new_arr.resize(new_arr_size); + + if (p_step > 0) { + int dest_idx = 0; + for (int idx = begin; idx <= end; idx += p_step) { + ERR_FAIL_COND_V_MSG(dest_idx < 0 || dest_idx >= new_arr_size, Array(), "Bug in Array slice()"); + new_arr[dest_idx++] = p_deep ? get(idx).duplicate(p_deep) : get(idx); + } + } else { // p_step < 0 + int dest_idx = 0; + for (int idx = begin; idx >= end; idx += p_step) { + ERR_FAIL_COND_V_MSG(dest_idx < 0 || dest_idx >= new_arr_size, Array(), "Bug in Array slice()"); + new_arr[dest_idx++] = p_deep ? get(idx).duplicate(p_deep) : get(idx); + } + } + + return new_arr; +} + +struct _ArrayVariantSort { + _FORCE_INLINE_ bool operator()(const Variant &p_l, const Variant &p_r) const { + bool valid = false; + Variant res; + Variant::evaluate(Variant::OP_LESS, p_l, p_r, res, valid); + if (!valid) { + res = false; + } + return res; + } +}; + +Array &Array::sort() { + _p->array.sort_custom<_ArrayVariantSort>(); + return *this; +} + +struct _ArrayVariantSortCustom { + Object *obj; + + _FORCE_INLINE_ bool operator()(const Variant &p_l, const Variant &p_r) const { + return obj->lt(p_l, p_r); + } +}; +Array &Array::sort_custom(Object *p_obj) { + ERR_FAIL_COND_V(!p_obj, *this); + + SortArray avs; + avs.compare.obj = p_obj; + avs.sort(_p->array.ptrw(), _p->array.size()); + return *this; +} + +void Array::shuffle() { + const int n = _p->array.size(); + if (n < 2) { + return; + } + Variant *data = _p->array.ptrw(); + for (int i = n - 1; i >= 1; i--) { + const int j = Math::rand() % (i + 1); + const Variant tmp = data[j]; + data[j] = data[i]; + data[i] = tmp; + } +} + +template +_FORCE_INLINE_ int bisect(const Vector &p_array, const Variant &p_value, bool p_before, const Less &p_less) { + int lo = 0; + int hi = p_array.size(); + if (p_before) { + while (lo < hi) { + const int mid = (lo + hi) / 2; + if (p_less(p_array.get(mid), p_value)) { + lo = mid + 1; + } else { + hi = mid; + } + } + } else { + while (lo < hi) { + const int mid = (lo + hi) / 2; + if (p_less(p_value, p_array.get(mid))) { + hi = mid; + } else { + lo = mid + 1; + } + } + } + return lo; +} + +int Array::bsearch(const Variant &p_value, bool p_before) { + return bisect(_p->array, p_value, p_before, _ArrayVariantSort()); +} + +int Array::bsearch_custom(const Variant &p_value, Object *p_obj, const StringName &p_function, bool p_before) { + ERR_FAIL_COND_V(!p_obj, 0); + + _ArrayVariantSortCustom less; + less.obj = p_obj; + + return bisect(_p->array, p_value, p_before, less); +} + +Array &Array::invert() { + _p->array.invert(); + return *this; +} + +void Array::push_front(const Variant &p_value) { + _p->array.insert(0, p_value); +} + +Variant Array::pop_back() { + if (!_p->array.empty()) { + const int n = _p->array.size() - 1; + const Variant ret = _p->array.get(n); + _p->array.resize(n); + return ret; + } + return Variant(); +} + +Variant Array::pop_front() { + if (!_p->array.empty()) { + const Variant ret = _p->array.get(0); + _p->array.remove(0); + return ret; + } + return Variant(); +} + +Variant Array::pop_at(int p_pos) { + if (_p->array.empty()) { + // Return `null` without printing an error to mimic `pop_back()` and `pop_front()` behavior. + return Variant(); + } + + if (p_pos < 0) { + // Relative offset from the end + p_pos = _p->array.size() + p_pos; + } + + ERR_FAIL_INDEX_V_MSG( + p_pos, + _p->array.size(), + Variant(), + vformat( + "The calculated index %s is out of bounds (the array has %s elements). Leaving the array untouched and returning `null`.", + p_pos, + _p->array.size())); + + const Variant ret = _p->array.get(p_pos); + _p->array.remove(p_pos); + return ret; +} + +#if defined(_WIN64) || defined(_WIN32) +// Windows... +#undef min +#undef max +#endif + +Variant Array::min() const { + Variant minval; + for (int i = 0; i < size(); i++) { + if (i == 0) { + minval = get(i); + } else { + bool valid; + Variant ret; + Variant test = get(i); + Variant::evaluate(Variant::OP_LESS, test, minval, ret, valid); + if (!valid) { + return Variant(); //not a valid comparison + } + if (bool(ret)) { + //is less + minval = test; + } + } + } + return minval; +} + +Variant Array::max() const { + Variant maxval; + for (int i = 0; i < size(); i++) { + if (i == 0) { + maxval = get(i); + } else { + bool valid; + Variant ret; + Variant test = get(i); + Variant::evaluate(Variant::OP_GREATER, test, maxval, ret, valid); + if (!valid) { + return Variant(); //not a valid comparison + } + if (bool(ret)) { + //is less + maxval = test; + } + } + } + return maxval; +} + +const void *Array::id() const { + return _p; +} + +String Array::sprintf(const String &p_format, bool *error) const { + String formatted; + CharType *self = (CharType *)p_format.get_data(); + bool in_format = false; + int value_index = 0; + int min_chars = 0; + int min_decimals = 0; + bool in_decimals = false; + bool pad_with_zeros = false; + bool left_justified = false; + bool show_sign = false; + + const Array &values = *this; + + if (error) { + *error = true; + } + + for (; *self; self++) { + const CharType c = *self; + + if (in_format) { // We have % - let's see what else we get. + switch (c) { + case '%': { // Replace %% with % + formatted += p_format.chr(c); + in_format = false; + break; + } + case 'd': // Integer (signed) + case 'o': // Octal + case 'x': // Hexadecimal (lowercase) + case 'X': { // Hexadecimal (uppercase) + if (value_index >= values.size()) { + return "not enough arguments for format string"; + } + + if (!values[value_index].is_num()) { + return "a number is required"; + } + + int64_t value = values[value_index]; + int base = 16; + bool capitalize = false; + switch (c) { + case 'd': + base = 10; + break; + case 'o': + base = 8; + break; + case 'x': + break; + case 'X': + base = 16; + capitalize = true; + break; + } + // Get basic number. + String str = String::num_int64(ABS(value), base, capitalize); + int number_len = str.length(); + + // Padding. + int pad_chars_count = (value < 0 || show_sign) ? min_chars - 1 : min_chars; + String pad_char = pad_with_zeros ? String("0") : String(" "); + if (left_justified) { + str = str.rpad(pad_chars_count, pad_char); + } else { + str = str.lpad(pad_chars_count, pad_char); + } + + // Sign. + if (show_sign || value < 0) { + String sign_char = value < 0 ? "-" : "+"; + if (left_justified) { + str = str.insert(0, sign_char); + } else { + str = str.insert(pad_with_zeros ? 0 : str.length() - number_len, sign_char); + } + } + + formatted += str; + ++value_index; + in_format = false; + + break; + } + case 'f': { // Float + if (value_index >= values.size()) { + return "not enough arguments for format string"; + } + + if (!values[value_index].is_num()) { + return "a number is required"; + } + + double value = values[value_index]; + bool is_negative = (value < 0); + String str = String::num(ABS(value), min_decimals); + bool not_numeric = isinf(value) || isnan(value); + + // Pad decimals out. + if (!not_numeric) { + str = str.pad_decimals(min_decimals); + } + + int initial_len = str.length(); + + // Padding. Leave room for sign later if required. + int pad_chars_count = (is_negative || show_sign) ? min_chars - 1 : min_chars; + String pad_char = (pad_with_zeros && !not_numeric) ? String("0") : String(" "); // Never pad NaN or inf with zeros + if (left_justified) { + str = str.rpad(pad_chars_count, pad_char); + } else { + str = str.lpad(pad_chars_count, pad_char); + } + + // Add sign if needed. + if (show_sign || is_negative) { + String sign_char = is_negative ? "-" : "+"; + if (left_justified) { + str = str.insert(0, sign_char); + } else { + str = str.insert(pad_with_zeros ? 0 : str.length() - initial_len, sign_char); + } + } + + formatted += str; + ++value_index; + in_format = false; + break; + } + case 's': { // String + if (value_index >= values.size()) { + return "not enough arguments for format string"; + } + + String str = values[value_index]; + // Padding. + if (left_justified) { + str = str.rpad(min_chars); + } else { + str = str.lpad(min_chars); + } + + formatted += str; + ++value_index; + in_format = false; + break; + } + case 'c': { + if (value_index >= values.size()) { + return "not enough arguments for format string"; + } + + // Convert to character. + String str; + if (values[value_index].is_num()) { + int value = values[value_index]; + if (value < 0) { + return "unsigned integer is lower than minimum"; + } else if (value >= 0xd800 && value <= 0xdfff) { + return "unsigned integer is invalid Unicode character"; + } else if (value > 0x10ffff) { + return "unsigned integer is greater than maximum"; + } + str = p_format.chr(values[value_index]); + } else if (values[value_index].get_type() == Variant::STRING) { + str = values[value_index]; + if (str.length() != 1) { + return "%c requires number or single-character string"; + } + } else { + return "%c requires number or single-character string"; + } + + // Padding. + if (left_justified) { + str = str.rpad(min_chars); + } else { + str = str.lpad(min_chars); + } + + formatted += str; + ++value_index; + in_format = false; + break; + } + case '-': { // Left justify + left_justified = true; + break; + } + case '+': { // Show + if positive. + show_sign = true; + break; + } + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': { + int n = c - '0'; + if (in_decimals) { + min_decimals *= 10; + min_decimals += n; + } else { + if (c == '0' && min_chars == 0) { + if (left_justified) { + LOG_WARN("'0' flag ignored with '-' flag in string format"); + } else { + pad_with_zeros = true; + } + } else { + min_chars *= 10; + min_chars += n; + } + } + break; + } + case '.': { // Float separator. + if (in_decimals) { + return "too many decimal points in format"; + } + in_decimals = true; + min_decimals = 0; // We want to add the value manually. + break; + } + + case '*': { // Dynamic width, based on value. + if (value_index >= values.size()) { + return "not enough arguments for format string"; + } + + if (!values[value_index].is_num()) { + return "* wants number"; + } + + int size = values[value_index]; + + if (in_decimals) { + min_decimals = size; + } else { + min_chars = size; + } + + ++value_index; + break; + } + + default: { + return "unsupported format character"; + } + } + } else { // Not in format string. + switch (c) { + case '%': + in_format = true; + // Back to defaults: + min_chars = 0; + min_decimals = 6; + pad_with_zeros = false; + left_justified = false; + show_sign = false; + in_decimals = false; + break; + default: + formatted += p_format.chr(c); + } + } + } + + if (in_format) { + return "incomplete format"; + } + + if (value_index != values.size()) { + return "not all arguments converted during string formatting"; + } + + if (error) { + *error = false; + } + return formatted; +} + +Array::Array(const Array &p_from) { + _p = nullptr; + _ref(p_from); +} + +Array::Array() { + _p = memnew(ArrayPrivate); + _p->refcount.init(); +} +Array::~Array() { + _unref(); +} +#line 0 + +#line 1 "sfwl/object/psignal.cpp" + +void Signal::connect_static(void (*func)(Signal *)) { + StaticSignalEntry *se = new StaticSignalEntry(); + se->func = func; + + entries.push_back(se); +} +void Signal::disconnect_static(void (*func)(Signal *)) { + for (int i = 0; i < entries.size(); ++i) { + SignalEntry *e = entries[i]; + + if (e->type == SIGNAL_ENTRY_TYPE_STATIC) { + StaticSignalEntry *se = static_cast(e); + + if (se->func == func) { + entries.remove(i); + return; + } + } + } +} +bool Signal::is_connected_static(void (*func)(Signal *)) { + for (int i = 0; i < entries.size(); ++i) { + SignalEntry *e = entries[i]; + + if (e->type == SIGNAL_ENTRY_TYPE_STATIC) { + StaticSignalEntry *se = static_cast(e); + + if (se->func == func) { + return true; + } + } + } + + return false; +} + +void Signal::emit(Object *p_emitter) { + emitter = p_emitter; + + for (int i = 0; i < entries.size(); ++i) { + entries[i]->call(this); + } +} + +void Signal::emit(Object *p_emitter, const Variant &p1) { + emitter = p_emitter; + + params.push_back(p1); + + for (int i = 0; i < entries.size(); ++i) { + entries[i]->call(this); + } + + params.clear(); +} +void Signal::emit(Object *p_emitter, const Variant &p1, const Variant &p2) { + emitter = p_emitter; + + params.push_back(p1); + params.push_back(p2); + + for (int i = 0; i < entries.size(); ++i) { + entries[i]->call(this); + } + + params.clear(); +} +void Signal::emit(Object *p_emitter, const Variant &p1, const Variant &p2, const Variant &p3) { + emitter = p_emitter; + + params.push_back(p1); + params.push_back(p2); + params.push_back(p3); + + for (int i = 0; i < entries.size(); ++i) { + entries[i]->call(this); + } + + params.clear(); +} + +void Signal::emit(Object *p_emitter, const Variant &p1, const Variant &p2, const Variant &p3, const Variant &p4) { + emitter = p_emitter; + + params.push_back(p1); + params.push_back(p2); + params.push_back(p3); + params.push_back(p4); + + for (int i = 0; i < entries.size(); ++i) { + entries[i]->call(this); + } + + params.clear(); +} + +void Signal::emit(Object *p_emitter, const Variant &p1, const Variant &p2, const Variant &p3, const Variant &p4, const Variant &p5) { + emitter = p_emitter; + + params.push_back(p1); + params.push_back(p2); + params.push_back(p3); + params.push_back(p4); + params.push_back(p5); + + for (int i = 0; i < entries.size(); ++i) { + entries[i]->call(this); + } + + params.clear(); +} + +Signal::Signal() { +} +Signal::~Signal() { +} +#line 0 + +#line 1 "sfwl/object/variant.cpp" +/*************************************************************************/ +/* variant.cpp */ +/* From https://github.com/Relintai/pandemonium_engine (MIT) */ +/*************************************************************************/ + +String Variant::get_type_name(Variant::Type p_type) { + switch (p_type) { + case NIL: { + return "Nil"; + } break; + + // atomic types + case BOOL: { + return "bool"; + } break; + case INT: { + return "int"; + + } break; + case REAL: { + return "float"; + + } break; + case STRING: { + return "String"; + } break; + + // math types + case RECT2I: { + return "Rect2i"; + } break; + case VECTOR2I: { + return "Vector2i"; + } break; + + // misc types + case COLOR: { + return "Color"; + } break; + case OBJECT: { + return "Object"; + } break; + case STRING_NAME: { + return "StringName"; + } break; + case DICTIONARY: { + return "Dictionary"; + } break; + case ARRAY: { + return "Array"; + } break; + + // arrays + case POOL_BYTE_ARRAY: { + return "PoolByteArray"; + } break; + case POOL_INT_ARRAY: { + return "PoolIntArray"; + } break; + case POOL_REAL_ARRAY: { + return "PoolRealArray"; + } break; + case POOL_STRING_ARRAY: { + return "PoolStringArray"; + } break; + case POOL_VECTOR2I_ARRAY: { + return "PoolVector2iArray"; + } break; + case POOL_COLOR_ARRAY: { + return "PoolColorArray"; + } break; + default: { + } + } + + return ""; +} + +bool Variant::can_convert(Variant::Type p_type_from, Variant::Type p_type_to) { + if (p_type_from == p_type_to) { + return true; + } + if (p_type_to == NIL && p_type_from != NIL) { //nil can convert to anything + return true; + } + + if (p_type_from == NIL) { + return (p_type_to == OBJECT); + }; + + const Type *valid_types = nullptr; + const Type *invalid_types = nullptr; + + switch (p_type_to) { + case NIL: { + //can't + } break; + case BOOL: { + static const Type valid[] = { + INT, + REAL, + STRING, + NIL, + }; + + valid_types = valid; + } break; + case INT: { + static const Type valid[] = { + BOOL, + REAL, + STRING, + NIL, + }; + + valid_types = valid; + } break; + case REAL: { + static const Type valid[] = { + BOOL, + INT, + STRING, + NIL, + }; + + valid_types = valid; + } break; + case STRING: { + static const Type invalid[] = { + OBJECT, + NIL + }; + + invalid_types = invalid; + } break; + case RECT2I: { + static const Type valid[] = { + NIL + }; + + valid_types = valid; + } break; + case VECTOR2I: { + static const Type valid[] = { + NIL + }; + + valid_types = valid; + } break; + // misc types + case COLOR: { + static const Type valid[] = { + STRING, + INT, + NIL, + }; + + valid_types = valid; + } break; + case OBJECT: { + static const Type valid[] = { + NIL + }; + + valid_types = valid; + } break; + case STRING_NAME: { + static const Type valid[] = { + STRING, + NIL + }; + + valid_types = valid; + } break; + case DICTIONARY: { + //can't + } break; + case ARRAY: { + static const Type valid[] = { + POOL_BYTE_ARRAY, + POOL_INT_ARRAY, + POOL_STRING_ARRAY, + POOL_REAL_ARRAY, + POOL_COLOR_ARRAY, + POOL_VECTOR2I_ARRAY, + NIL + }; + + valid_types = valid; + } break; + // arrays + case POOL_BYTE_ARRAY: { + static const Type valid[] = { + ARRAY, + NIL + }; + + valid_types = valid; + } break; + case POOL_INT_ARRAY: { + static const Type valid[] = { + ARRAY, + NIL + }; + valid_types = valid; + } break; + case POOL_REAL_ARRAY: { + static const Type valid[] = { + ARRAY, + NIL + }; + + valid_types = valid; + } break; + case POOL_STRING_ARRAY: { + static const Type valid[] = { + ARRAY, + NIL + }; + valid_types = valid; + } break; + case POOL_VECTOR2I_ARRAY: { + static const Type valid[] = { + ARRAY, + NIL + }; + valid_types = valid; + } break; + case POOL_COLOR_ARRAY: { + static const Type valid[] = { + ARRAY, + NIL + }; + + valid_types = valid; + } break; + default: { + } + } + + if (valid_types) { + int i = 0; + while (valid_types[i] != NIL) { + if (p_type_from == valid_types[i]) { + return true; + } + i++; + } + + } else if (invalid_types) { + int i = 0; + while (invalid_types[i] != NIL) { + if (p_type_from == invalid_types[i]) { + return false; + } + i++; + } + + return true; + } + + return false; +} + +bool Variant::can_convert_strict(Variant::Type p_type_from, Variant::Type p_type_to) { + if (p_type_from == p_type_to) { + return true; + } + if (p_type_to == NIL && p_type_from != NIL) { //nil can convert to anything + return true; + } + + if (p_type_from == NIL) { + return (p_type_to == OBJECT); + }; + + const Type *valid_types = nullptr; + + switch (p_type_to) { + case NIL: { + //can't, also already handled + } break; + case BOOL: { + static const Type valid[] = { + INT, + REAL, + //STRING, + NIL, + }; + + valid_types = valid; + } break; + case INT: { + static const Type valid[] = { + BOOL, + REAL, + //STRING, + NIL, + }; + + valid_types = valid; + + } break; + case REAL: { + static const Type valid[] = { + BOOL, + INT, + //STRING, + NIL, + }; + + valid_types = valid; + + } break; + case STRING: { + static const Type valid[] = { + STRING_NAME, + NIL + }; + + valid_types = valid; + } break; + case RECT2I: { + static const Type valid[] = { + NIL + }; + + valid_types = valid; + } break; + case VECTOR2I: { + static const Type valid[] = { + NIL + }; + + valid_types = valid; + } break; + case COLOR: { + static const Type valid[] = { + STRING, + INT, + NIL, + }; + + valid_types = valid; + } break; + case OBJECT: { + static const Type valid[] = { + NIL + }; + + valid_types = valid; + } break; + case STRING_NAME: { + static const Type valid[] = { + STRING, + NIL + }; + + valid_types = valid; + } break; + case DICTIONARY: { + //Can't + } break; + case ARRAY: { + static const Type valid[] = { + POOL_BYTE_ARRAY, + POOL_INT_ARRAY, + POOL_STRING_ARRAY, + POOL_REAL_ARRAY, + POOL_COLOR_ARRAY, + POOL_VECTOR2I_ARRAY, + NIL + }; + + valid_types = valid; + } break; + // arrays + case POOL_BYTE_ARRAY: { + static const Type valid[] = { + ARRAY, + NIL + }; + + valid_types = valid; + } break; + case POOL_INT_ARRAY: { + static const Type valid[] = { + ARRAY, + NIL + }; + valid_types = valid; + } break; + case POOL_REAL_ARRAY: { + static const Type valid[] = { + ARRAY, + NIL + }; + + valid_types = valid; + } break; + case POOL_STRING_ARRAY: { + static const Type valid[] = { + ARRAY, + NIL + }; + + valid_types = valid; + } break; + case POOL_VECTOR2I_ARRAY: { + static const Type valid[] = { + ARRAY, + NIL + }; + + valid_types = valid; + } break; + case POOL_COLOR_ARRAY: { + static const Type valid[] = { + ARRAY, + NIL + }; + + valid_types = valid; + } break; + default: { + } + } + + if (valid_types) { + int i = 0; + while (valid_types[i] != NIL) { + if (p_type_from == valid_types[i]) { + return true; + } + i++; + } + } + + return false; +} + +bool Variant::deep_equal(const Variant &p_variant, int p_recursion_count) const { + ERR_FAIL_COND_V_MSG(p_recursion_count > MAX_RECURSION, true, "Max recursion reached"); + + // Containers must be handled with recursivity checks + switch (type) { + case Variant::Type::DICTIONARY: { + if (p_variant.type != Variant::Type::DICTIONARY) { + return false; + } + + const Dictionary v1_as_d = Dictionary(*this); + const Dictionary v2_as_d = Dictionary(p_variant); + + return v1_as_d.deep_equal(v2_as_d, p_recursion_count + 1); + } break; + case Variant::Type::ARRAY: { + if (p_variant.type != Variant::Type::ARRAY) { + return false; + } + + const Array v1_as_a = Array(*this); + const Array v2_as_a = Array(p_variant); + + return v1_as_a.deep_equal(v2_as_a, p_recursion_count + 1); + } break; + default: { + return *this == p_variant; + } break; + } +} + +bool Variant::operator==(const Variant &p_variant) const { + if (type != p_variant.type) { //evaluation of operator== needs to be more strict + return false; + } + bool v; + Variant r; + evaluate(OP_EQUAL, *this, p_variant, r, v); + return r; +} + +bool Variant::operator!=(const Variant &p_variant) const { + if (type != p_variant.type) { //evaluation of operator== needs to be more strict + return true; + } + bool v; + Variant r; + evaluate(OP_NOT_EQUAL, *this, p_variant, r, v); + return r; +} + +bool Variant::operator<(const Variant &p_variant) const { + if (type != p_variant.type) { //if types differ, then order by type first + return type < p_variant.type; + } + bool v; + Variant r; + evaluate(OP_LESS, *this, p_variant, r, v); + return r; +} + +bool Variant::is_zero() const { + switch (type) { + case NIL: { + return true; + } break; + + // atomic types + case BOOL: { + return !(_data._bool); + } break; + case INT: { + return _data._int == 0; + } break; + case REAL: { + return _data._real == 0; + } break; + case STRING: { + return *reinterpret_cast(_data._mem) == String(); + } break; + + // math types + case RECT2I: { + return *reinterpret_cast(_data._mem) == Rect2i(); + } break; + case VECTOR2I: { + return *reinterpret_cast(_data._mem) == Vector2i(); + } break; + + // misc types + case COLOR: { + return *reinterpret_cast(_data._mem) == Color(); + } break; + case OBJECT: { + return _UNSAFE_OBJ_PROXY_PTR(*this) == nullptr; + } break; + case STRING_NAME: { + return *reinterpret_cast(_data._mem) != StringName(); + } break; + case DICTIONARY: { + return reinterpret_cast(_data._mem)->empty(); + } break; + case ARRAY: { + return reinterpret_cast(_data._mem)->empty(); + } break; + + // arrays + case POOL_BYTE_ARRAY: { + return reinterpret_cast *>(_data._mem)->size() == 0; + } break; + case POOL_INT_ARRAY: { + return reinterpret_cast *>(_data._mem)->size() == 0; + } break; + case POOL_REAL_ARRAY: { + return reinterpret_cast *>(_data._mem)->size() == 0; + } break; + case POOL_STRING_ARRAY: { + return reinterpret_cast *>(_data._mem)->size() == 0; + } break; + case POOL_VECTOR2I_ARRAY: { + return reinterpret_cast *>(_data._mem)->size() == 0; + } break; + case POOL_COLOR_ARRAY: { + return reinterpret_cast *>(_data._mem)->size() == 0; + } break; + default: { + } + } + + return false; +} + +bool Variant::is_one() const { + switch (type) { + case NIL: { + return true; + } break; + + // atomic types + case BOOL: { + return _data._bool; + } break; + case INT: { + return _data._int == 1; + } break; + case REAL: { + return _data._real == 1; + } break; + case RECT2I: { + return *reinterpret_cast(_data._mem) == Rect2i(1, 1, 1, 1); + } break; + case VECTOR2I: { + return *reinterpret_cast(_data._mem) == Vector2i(1, 1); + } break; + case COLOR: { + return *reinterpret_cast(_data._mem) == Color(1, 1, 1, 1); + } break; + + default: { + return !is_zero(); + } + } + + return false; +} + +ObjectID Variant::get_object_instance_id() const { + if (unlikely(type != OBJECT)) { + return 0; + } else if (likely(_get_obj().rc)) { + return _get_obj().rc->instance_id; + } else if (likely(!_get_obj().ref.is_null())) { + return _REF_OBJ_PTR(*this)->get_instance_id(); + } else { + return 0; + } +} + +bool Variant::is_invalid_object() const { + return type == OBJECT && _get_obj().rc && !_get_obj().rc->get_ptr(); +} + +void Variant::reference(const Variant &p_variant) { + switch (type) { + case NIL: + case BOOL: + case INT: + case REAL: + break; + default: + clear(); + } + + type = p_variant.type; + + switch (p_variant.type) { + case NIL: { + // none + } break; + + // atomic types + case BOOL: { + _data._bool = p_variant._data._bool; + } break; + case INT: { + _data._int = p_variant._data._int; + } break; + case REAL: { + _data._real = p_variant._data._real; + } break; + case STRING: { + memnew_placement(_data._mem, String(*reinterpret_cast(p_variant._data._mem))); + } break; + + // math types + case RECT2I: { + memnew_placement(_data._mem, Rect2i(*reinterpret_cast(p_variant._data._mem))); + } break; + case VECTOR2I: { + memnew_placement(_data._mem, Vector2i(*reinterpret_cast(p_variant._data._mem))); + } break; + + // misc types + case COLOR: { + memnew_placement(_data._mem, Color(*reinterpret_cast(p_variant._data._mem))); + } break; + case OBJECT: { + memnew_placement(_data._mem, ObjData(p_variant._get_obj())); + if (likely(_get_obj().rc)) { + _get_obj().rc->increment(); + } + } break; + case STRING_NAME: { + memnew_placement(_data._mem, StringName(*reinterpret_cast(p_variant._data._mem))); + } break; + case DICTIONARY: { + memnew_placement(_data._mem, Dictionary(*reinterpret_cast(p_variant._data._mem))); + } break; + case ARRAY: { + memnew_placement(_data._mem, Array(*reinterpret_cast(p_variant._data._mem))); + } break; + + // arrays + case POOL_BYTE_ARRAY: { + memnew_placement(_data._mem, PoolVector(*reinterpret_cast *>(p_variant._data._mem))); + } break; + case POOL_INT_ARRAY: { + memnew_placement(_data._mem, PoolVector(*reinterpret_cast *>(p_variant._data._mem))); + } break; + case POOL_REAL_ARRAY: { + memnew_placement(_data._mem, PoolVector(*reinterpret_cast *>(p_variant._data._mem))); + } break; + case POOL_STRING_ARRAY: { + memnew_placement(_data._mem, PoolVector(*reinterpret_cast *>(p_variant._data._mem))); + } break; + case POOL_VECTOR2I_ARRAY: { + memnew_placement(_data._mem, PoolVector(*reinterpret_cast *>(p_variant._data._mem))); + } break; + case POOL_COLOR_ARRAY: { + memnew_placement(_data._mem, PoolVector(*reinterpret_cast *>(p_variant._data._mem))); + } break; + default: { + } + } +} + +void Variant::zero() { + switch (type) { + case NIL: + break; + case BOOL: + this->_data._bool = false; + break; + case INT: + this->_data._int = 0; + break; + case REAL: + this->_data._real = 0; + break; + case RECT2I: + *reinterpret_cast(this->_data._mem) = Rect2i(); + break; + case VECTOR2I: + *reinterpret_cast(this->_data._mem) = Vector2i(); + break; + case COLOR: + *reinterpret_cast(this->_data._mem) = Color(); + break; + default: + this->clear(); + break; + } +} + +void Variant::clear() { + switch (type) { + /* + // no point, they don't allocate memory + BOOL, + INT, + REAL, + */ + case STRING: { + reinterpret_cast(_data._mem)->~String(); + } break; + /* + RECT2, + RECT2I + VECTOR2, + VECTOR2I, + VECTOR3, + VECTOR3i, + VECTOR4, + VECTOR4i, + + PLANE, + QUATERNION, + */ + //COLOR + + // misc types + case OBJECT: { + if (likely(_get_obj().rc)) { + if (unlikely(_get_obj().rc->decrement())) { + memdelete(_get_obj().rc); + } + } else { + _get_obj().ref.unref(); + } + } break; + case STRING_NAME: { + reinterpret_cast(_data._mem)->~StringName(); + } break; + case DICTIONARY: { + reinterpret_cast(_data._mem)->~Dictionary(); + } break; + case ARRAY: { + reinterpret_cast(_data._mem)->~Array(); + } break; + + // arrays + case POOL_BYTE_ARRAY: { + reinterpret_cast *>(_data._mem)->~PoolVector(); + } break; + case POOL_INT_ARRAY: { + reinterpret_cast *>(_data._mem)->~PoolVector(); + } break; + case POOL_REAL_ARRAY: { + reinterpret_cast *>(_data._mem)->~PoolVector(); + } break; + case POOL_STRING_ARRAY: { + reinterpret_cast *>(_data._mem)->~PoolVector(); + } break; + case POOL_VECTOR2I_ARRAY: { + reinterpret_cast *>(_data._mem)->~PoolVector(); + } break; + case POOL_COLOR_ARRAY: { + reinterpret_cast *>(_data._mem)->~PoolVector(); + } break; + default: { + } /* not needed */ + } + + type = NIL; +} + +Variant::operator signed int() const { + switch (type) { + case NIL: + return 0; + case BOOL: + return _data._bool ? 1 : 0; + case INT: + return _data._int; + case REAL: + return _data._real; + case STRING: + return operator String().to_int(); + default: { + return 0; + } + } +} +Variant::operator unsigned int() const { + switch (type) { + case NIL: + return 0; + case BOOL: + return _data._bool ? 1 : 0; + case INT: + return _data._int; + case REAL: + return _data._real; + case STRING: + return operator String().to_int(); + default: { + return 0; + } + } +} + +Variant::operator int64_t() const { + switch (type) { + case NIL: + return 0; + case BOOL: + return _data._bool ? 1 : 0; + case INT: + return _data._int; + case REAL: + return _data._real; + case STRING: + return operator String().to_int64(); + default: { + return 0; + } + } +} + +/* +Variant::operator long unsigned int() const { + + switch( type ) { + + case NIL: return 0; + case BOOL: return _data._bool ? 1 : 0; + case INT: return _data._int; + case REAL: return _data._real; + case STRING: return operator String().to_int(); + default: { + + return 0; + } + } + + return 0; +}; +*/ + +Variant::operator uint64_t() const { + switch (type) { + case NIL: + return 0; + case BOOL: + return _data._bool ? 1 : 0; + case INT: + return _data._int; + case REAL: + return _data._real; + case STRING: + return operator String().to_int(); + default: { + return 0; + } + } +} + +#ifdef NEED_LONG_INT +Variant::operator signed long() const { + switch (type) { + case NIL: + return 0; + case BOOL: + return _data._bool ? 1 : 0; + case INT: + return _data._int; + case REAL: + return _data._real; + case STRING: + return operator String().to_int(); + default: { + return 0; + } + } + + return 0; +}; + +Variant::operator unsigned long() const { + switch (type) { + case NIL: + return 0; + case BOOL: + return _data._bool ? 1 : 0; + case INT: + return _data._int; + case REAL: + return _data._real; + case STRING: + return operator String().to_int(); + default: { + return 0; + } + } + + return 0; +}; +#endif + +Variant::operator signed short() const { + switch (type) { + case NIL: + return 0; + case BOOL: + return _data._bool ? 1 : 0; + case INT: + return _data._int; + case REAL: + return _data._real; + case STRING: + return operator String().to_int(); + default: { + return 0; + } + } +} +Variant::operator unsigned short() const { + switch (type) { + case NIL: + return 0; + case BOOL: + return _data._bool ? 1 : 0; + case INT: + return _data._int; + case REAL: + return _data._real; + case STRING: + return operator String().to_int(); + default: { + return 0; + } + } +} +Variant::operator signed char() const { + switch (type) { + case NIL: + return 0; + case BOOL: + return _data._bool ? 1 : 0; + case INT: + return _data._int; + case REAL: + return _data._real; + case STRING: + return operator String().to_int(); + default: { + return 0; + } + } +} +Variant::operator unsigned char() const { + switch (type) { + case NIL: + return 0; + case BOOL: + return _data._bool ? 1 : 0; + case INT: + return _data._int; + case REAL: + return _data._real; + case STRING: + return operator String().to_int(); + default: { + return 0; + } + } +} + +Variant::operator CharType() const { + return operator unsigned int(); +} + +Variant::operator float() const { + switch (type) { + case NIL: + return 0; + case BOOL: + return _data._bool ? 1.0 : 0.0; + case INT: + return (float)_data._int; + case REAL: + return _data._real; + case STRING: + return operator String().to_double(); + default: { + return 0; + } + } +} +Variant::operator double() const { + switch (type) { + case NIL: + return 0; + case BOOL: + return _data._bool ? 1.0 : 0.0; + case INT: + return (double)_data._int; + case REAL: + return _data._real; + case STRING: + return operator String().to_double(); + default: { + return 0; + } + } +} + +Variant::operator StringName() const { + if (type == STRING_NAME) { + return *reinterpret_cast(_data._mem); + } + + return StringName(operator String()); +} + +struct _VariantStrPair { + String key; + String value; + + bool operator<(const _VariantStrPair &p) const { + return key < p.key; + } +}; + +Variant::operator String() const { + List stack; + + return stringify(stack); +} + +template +String stringify_vector(const T &vec, List &stack) { + String str("["); + for (int i = 0; i < vec.size(); i++) { + if (i > 0) { + str += ", "; + } + str = str + Variant(vec[i]).stringify(stack); + } + str += "]"; + return str; +} + +String Variant::stringify(List &stack) const { + switch (type) { + case NIL: + return "Null"; + case BOOL: + return _data._bool ? "True" : "False"; + case INT: + return itos(_data._int); + case REAL: + return rtos(_data._real); + case STRING: + return *reinterpret_cast(_data._mem); + case RECT2I: + return operator Rect2i(); + case VECTOR2I: + return operator Vector2i(); + case COLOR: + return operator Color(); + case OBJECT: { + Object *obj = _OBJ_PTR(*this); + if (likely(obj)) { + return obj->to_string(); + } else { + if (_get_obj().rc) { + return "[Deleted Object]"; + } + return "[Object:null]"; + } + } break; + case STRING_NAME: + return operator StringName(); + case DICTIONARY: { + const Dictionary &d = *reinterpret_cast(_data._mem); + if (stack.find(d.id())) { + return "{...}"; + } + + stack.push_back(d.id()); + + //const String *K=NULL; + String str("{"); + List keys; + d.get_key_list(&keys); + + Vector<_VariantStrPair> pairs; + + for (List::Element *E = keys.front(); E; E = E->next()) { + _VariantStrPair sp; + sp.key = E->get().stringify(stack); + sp.value = d[E->get()].stringify(stack); + + pairs.push_back(sp); + } + + pairs.sort(); + + for (int i = 0; i < pairs.size(); i++) { + if (i > 0) { + str += ", "; + } + str += pairs[i].key + ":" + pairs[i].value; + } + str += "}"; + + stack.erase(d.id()); + return str; + } break; + case ARRAY: { + Array arr = operator Array(); + if (stack.find(arr.id())) { + return "[...]"; + } + stack.push_back(arr.id()); + String str = stringify_vector(arr, stack); + stack.erase(arr.id()); + return str; + + } break; + + case POOL_BYTE_ARRAY: { + return stringify_vector(operator PoolVector(), stack); + } break; + case POOL_INT_ARRAY: { + return stringify_vector(operator PoolVector(), stack); + } break; + case POOL_REAL_ARRAY: { + return stringify_vector(operator PoolVector(), stack); + } break; + case POOL_STRING_ARRAY: { + return stringify_vector(operator PoolVector(), stack); + } break; + case POOL_VECTOR2I_ARRAY: { + return stringify_vector(operator PoolVector(), stack); + } break; + case POOL_COLOR_ARRAY: { + return stringify_vector(operator PoolVector(), stack); + } break; + + default: { + return "[" + get_type_name(type) + "]"; + } + } + + return ""; +} + +Variant::operator Rect2i() const { + if (type == RECT2I) { + return *reinterpret_cast(_data._mem); + } else { + return Rect2i(); + } +} + +Variant::operator Vector2i() const { + if (type == VECTOR2I) { + return *reinterpret_cast(_data._mem); + } else { + return Vector2i(); + } +} + +Variant::operator Color() const { + if (type == COLOR) { + return *reinterpret_cast(_data._mem); + } else if (type == STRING) { + return Color::html(operator String()); + } else if (type == INT) { + return Color::hex(operator int()); + } else { + return Color(); + } +} + +Variant::operator RefPtr() const { + if (type == OBJECT) { + return _get_obj().ref; + } else { + return RefPtr(); + } +} + +Variant::operator Object *() const { + if (type == OBJECT) { + return _OBJ_PTR(*this); + } else { + return nullptr; + } +} + +template +inline DA _convert_array(const SA &p_array) { + DA da; + da.resize(p_array.size()); + + for (int i = 0; i < p_array.size(); i++) { + da.set(i, Variant(p_array.get(i))); + } + + return da; +} + +template +inline DA _convert_array_from_variant(const Variant &p_variant) { + switch (p_variant.get_type()) { + case Variant::ARRAY: { + return _convert_array(p_variant.operator Array()); + } + case Variant::POOL_BYTE_ARRAY: { + return _convert_array>(p_variant.operator PoolVector()); + } + case Variant::POOL_INT_ARRAY: { + return _convert_array>(p_variant.operator PoolVector()); + } + case Variant::POOL_REAL_ARRAY: { + return _convert_array>(p_variant.operator PoolVector()); + } + case Variant::POOL_STRING_ARRAY: { + return _convert_array>(p_variant.operator PoolVector()); + } + case Variant::POOL_VECTOR2I_ARRAY: { + return _convert_array>(p_variant.operator PoolVector()); + } + case Variant::POOL_COLOR_ARRAY: { + return _convert_array>(p_variant.operator PoolVector()); + } + default: { + return DA(); + } + } +} + +Variant::operator Dictionary() const { + if (type == DICTIONARY) { + return *reinterpret_cast(_data._mem); + } else { + return Dictionary(); + } +} + +Variant::operator Array() const { + if (type == ARRAY) { + return *reinterpret_cast(_data._mem); + } else { + return _convert_array_from_variant(*this); + } +} + +Variant::operator PoolVector() const { + if (type == POOL_BYTE_ARRAY) { + return *reinterpret_cast *>(_data._mem); + } else { + return _convert_array_from_variant>(*this); + } +} +Variant::operator PoolVector() const { + if (type == POOL_INT_ARRAY) { + return *reinterpret_cast *>(_data._mem); + } else { + return _convert_array_from_variant>(*this); + } +} +Variant::operator PoolVector() const { + if (type == POOL_REAL_ARRAY) { + return *reinterpret_cast *>(_data._mem); + } else { + return _convert_array_from_variant>(*this); + } +} + +Variant::operator PoolVector() const { + if (type == POOL_STRING_ARRAY) { + return *reinterpret_cast *>(_data._mem); + } else { + return _convert_array_from_variant>(*this); + } +} +Variant::operator PoolVector() const { + if (type == POOL_VECTOR2I_ARRAY) { + return *reinterpret_cast *>(_data._mem); + } else { + return _convert_array_from_variant>(*this); + } +} +Variant::operator PoolVector() const { + if (type == POOL_COLOR_ARRAY) { + return *reinterpret_cast *>(_data._mem); + } else { + return _convert_array_from_variant>(*this); + } +} + +/* helpers */ + +Variant::operator Vector() const { + Array from = operator Array(); + Vector to; + int len = from.size(); + to.resize(len); + for (int i = 0; i < len; i++) { + to.write[i] = from[i]; + } + return to; +} + +Variant::operator Vector() const { + PoolVector from = operator PoolVector(); + Vector to; + int len = from.size(); + to.resize(len); + for (int i = 0; i < len; i++) { + to.write[i] = from[i]; + } + return to; +} +Variant::operator Vector() const { + PoolVector from = operator PoolVector(); + Vector to; + int len = from.size(); + to.resize(len); + for (int i = 0; i < len; i++) { + to.write[i] = from[i]; + } + return to; +} +Variant::operator Vector() const { + PoolVector from = operator PoolVector(); + Vector to; + int len = from.size(); + to.resize(len); + for (int i = 0; i < len; i++) { + to.write[i] = from[i]; + } + return to; +} + +Variant::operator Vector() const { + PoolVector from = operator PoolVector(); + Vector to; + int len = from.size(); + to.resize(len); + for (int i = 0; i < len; i++) { + to.write[i] = from[i]; + } + return to; +} +Variant::operator Vector() const { + PoolVector from = operator PoolVector(); + Vector to; + int len = from.size(); + to.resize(len); + for (int i = 0; i < len; i++) { + to.write[i] = from[i]; + } + return to; +} + +Variant::operator Vector() const { + PoolVector from = operator PoolVector(); + Vector to; + int len = from.size(); + if (len == 0) { + return Vector(); + } + to.resize(len); + PoolVector::Read r = from.read(); + Vector2i *w = to.ptrw(); + for (int i = 0; i < len; i++) { + w[i] = r[i]; + } + return to; +} + +Variant::operator Vector() const { + PoolVector from = operator PoolVector(); + Vector to; + int len = from.size(); + if (len == 0) { + return Vector(); + } + to.resize(len); + PoolVector::Read r = from.read(); + Color *w = to.ptrw(); + for (int i = 0; i < len; i++) { + w[i] = r[i]; + } + return to; +} + +Variant::operator Margin() const { + return (Margin) operator int(); +} +Variant::operator Side() const { + return (Side) operator int(); +} +Variant::operator Orientation() const { + return (Orientation) operator int(); +} + +Variant::Variant(bool p_bool) { + type = BOOL; + _data._bool = p_bool; +} + +/* +Variant::Variant(long unsigned int p_long) { + + type=INT; + _data._int=p_long; +}; +*/ + +Variant::Variant(signed int p_int) { + type = INT; + _data._int = p_int; +} +Variant::Variant(unsigned int p_int) { + type = INT; + _data._int = p_int; +} + +#ifdef NEED_LONG_INT + +Variant::Variant(signed long p_int) { + type = INT; + _data._int = p_int; +} +Variant::Variant(unsigned long p_int) { + type = INT; + _data._int = p_int; +} +#endif + +Variant::Variant(int64_t p_int) { + type = INT; + _data._int = p_int; +} + +Variant::Variant(uint64_t p_int) { + type = INT; + _data._int = p_int; +} + +Variant::Variant(signed short p_short) { + type = INT; + _data._int = p_short; +} +Variant::Variant(unsigned short p_short) { + type = INT; + _data._int = p_short; +} +Variant::Variant(signed char p_char) { + type = INT; + _data._int = p_char; +} +Variant::Variant(unsigned char p_char) { + type = INT; + _data._int = p_char; +} +Variant::Variant(float p_float) { + type = REAL; + _data._real = p_float; +} +Variant::Variant(double p_double) { + type = REAL; + _data._real = p_double; +} + +Variant::Variant(const StringName &p_string) { + type = STRING_NAME; + memnew_placement(_data._mem, StringName(p_string)); +} +Variant::Variant(const String &p_string) { + type = STRING; + memnew_placement(_data._mem, String(p_string)); +} + +Variant::Variant(const char *const p_cstring) { + type = STRING; + memnew_placement(_data._mem, String((const char *)p_cstring)); +} + +Variant::Variant(const CharType *p_wstring) { + type = STRING; + memnew_placement(_data._mem, String(p_wstring)); +} + +Variant::Variant(const Rect2i &p_rect2) { + type = RECT2I; + memnew_placement(_data._mem, Rect2i(p_rect2)); +} + +Variant::Variant(const Vector2i &p_vector2) { + type = VECTOR2I; + memnew_placement(_data._mem, Vector2i(p_vector2)); +} + +Variant::Variant(const Color &p_color) { + type = COLOR; + memnew_placement(_data._mem, Color(p_color)); +} + +Variant::Variant(const RefPtr &p_resource) { + type = OBJECT; + memnew_placement(_data._mem, ObjData); + _get_obj().rc = nullptr; + _get_obj().ref = p_resource; +} + +Variant::Variant(const Object *p_object) { + type = OBJECT; + Object *obj = const_cast(p_object); + + memnew_placement(_data._mem, ObjData); + Reference *ref = Object::cast_to(obj); + if (unlikely(ref)) { + *reinterpret_cast *>(_get_obj().ref.get_data()) = Ref(ref); + _get_obj().rc = nullptr; + } else { + _get_obj().rc = likely(obj) ? obj->_use_rc() : nullptr; + } +} + +Variant::Variant(const Dictionary &p_dictionary) { + type = DICTIONARY; + memnew_placement(_data._mem, Dictionary(p_dictionary)); +} + +Variant::Variant(const Array &p_array) { + type = ARRAY; + memnew_placement(_data._mem, Array(p_array)); +} + +Variant::Variant(const PoolVector &p_raw_array) { + type = POOL_BYTE_ARRAY; + memnew_placement(_data._mem, PoolVector(p_raw_array)); +} +Variant::Variant(const PoolVector &p_int_array) { + type = POOL_INT_ARRAY; + memnew_placement(_data._mem, PoolVector(p_int_array)); +} +Variant::Variant(const PoolVector &p_real_array) { + type = POOL_REAL_ARRAY; + memnew_placement(_data._mem, PoolVector(p_real_array)); +} +Variant::Variant(const PoolVector &p_string_array) { + type = POOL_STRING_ARRAY; + memnew_placement(_data._mem, PoolVector(p_string_array)); +} +Variant::Variant(const PoolVector &p_vector2_array) { + type = POOL_VECTOR2I_ARRAY; + memnew_placement(_data._mem, PoolVector(p_vector2_array)); +} + +Variant::Variant(const PoolVector &p_color_array) { + type = POOL_COLOR_ARRAY; + memnew_placement(_data._mem, PoolVector(p_color_array)); +} + +/* helpers */ + +Variant::Variant(const Vector &p_array) { + type = NIL; + Array v; + int len = p_array.size(); + v.resize(len); + for (int i = 0; i < len; i++) { + v.set(i, p_array[i]); + } + *this = v; +} + +Variant::Variant(const Vector &p_array) { + type = NIL; + PoolVector v; + int len = p_array.size(); + v.resize(len); + for (int i = 0; i < len; i++) { + v.set(i, p_array[i]); + } + *this = v; +} + +Variant::Variant(const Vector &p_array) { + type = NIL; + PoolVector v; + int len = p_array.size(); + v.resize(len); + for (int i = 0; i < len; i++) { + v.set(i, p_array[i]); + } + *this = v; +} + +Variant::Variant(const Vector &p_array) { + type = NIL; + PoolVector v; + int len = p_array.size(); + v.resize(len); + for (int i = 0; i < len; i++) { + v.set(i, p_array[i]); + } + *this = v; +} + +Variant::Variant(const Vector &p_array) { + type = NIL; + PoolVector v; + int len = p_array.size(); + v.resize(len); + for (int i = 0; i < len; i++) { + v.set(i, p_array[i]); + } + *this = v; +} + +Variant::Variant(const Vector &p_array) { + type = NIL; + PoolVector v; + int len = p_array.size(); + v.resize(len); + for (int i = 0; i < len; i++) { + v.set(i, p_array[i]); + } + *this = v; +} + +Variant::Variant(const Vector &p_array) { + type = NIL; + PoolVector v; + int len = p_array.size(); + if (len > 0) { + v.resize(len); + PoolVector::Write w = v.write(); + const Vector2i *r = p_array.ptr(); + + for (int i = 0; i < len; i++) { + w[i] = r[i]; + } + } + *this = v; +} + +Variant::Variant(const Vector &p_array) { + type = NIL; + PoolVector v; + int len = p_array.size(); + v.resize(len); + for (int i = 0; i < len; i++) { + v.set(i, p_array[i]); + } + *this = v; +} + +void Variant::operator=(const Variant &p_variant) { + if (unlikely(this == &p_variant)) { + return; + } + + if (unlikely(type != p_variant.type)) { + reference(p_variant); + return; + } + + switch (p_variant.type) { + case NIL: { + // none + } break; + + // atomic types + case BOOL: { + _data._bool = p_variant._data._bool; + } break; + case INT: { + _data._int = p_variant._data._int; + } break; + case REAL: { + _data._real = p_variant._data._real; + } break; + case STRING: { + *reinterpret_cast(_data._mem) = *reinterpret_cast(p_variant._data._mem); + } break; + + // math types + case RECT2I: { + *reinterpret_cast(_data._mem) = *reinterpret_cast(p_variant._data._mem); + } break; + case VECTOR2I: { + *reinterpret_cast(_data._mem) = *reinterpret_cast(p_variant._data._mem); + } break; + + // misc types + case COLOR: { + *reinterpret_cast(_data._mem) = *reinterpret_cast(p_variant._data._mem); + } break; + case OBJECT: { + if (likely(_get_obj().rc)) { + if (unlikely(_get_obj().rc->decrement())) { + memdelete(_get_obj().rc); + } + } + *reinterpret_cast(_data._mem) = p_variant._get_obj(); + if (likely(_get_obj().rc)) { + _get_obj().rc->increment(); + } + } break; + case STRING_NAME: { + *reinterpret_cast(_data._mem) = *reinterpret_cast(p_variant._data._mem); + } break; + case DICTIONARY: { + *reinterpret_cast(_data._mem) = *reinterpret_cast(p_variant._data._mem); + } break; + case ARRAY: { + *reinterpret_cast(_data._mem) = *reinterpret_cast(p_variant._data._mem); + } break; + + // arrays + case POOL_BYTE_ARRAY: { + *reinterpret_cast *>(_data._mem) = *reinterpret_cast *>(p_variant._data._mem); + } break; + case POOL_INT_ARRAY: { + *reinterpret_cast *>(_data._mem) = *reinterpret_cast *>(p_variant._data._mem); + } break; + case POOL_REAL_ARRAY: { + *reinterpret_cast *>(_data._mem) = *reinterpret_cast *>(p_variant._data._mem); + } break; + case POOL_STRING_ARRAY: { + *reinterpret_cast *>(_data._mem) = *reinterpret_cast *>(p_variant._data._mem); + } break; + case POOL_VECTOR2I_ARRAY: { + *reinterpret_cast *>(_data._mem) = *reinterpret_cast *>(p_variant._data._mem); + } break; + case POOL_COLOR_ARRAY: { + *reinterpret_cast *>(_data._mem) = *reinterpret_cast *>(p_variant._data._mem); + } break; + default: { + } + } +} + +Variant::Variant(const Variant &p_variant) { + type = NIL; + reference(p_variant); +} + +/* +Variant::~Variant() { + + clear(); +}*/ + +uint32_t Variant::hash() const { + return recursive_hash(0); +} + +uint32_t Variant::recursive_hash(int p_recursion_count) const { + switch (type) { + case NIL: { + return 0; + } break; + + case BOOL: { + return _data._bool ? 1 : 0; + } break; + case INT: { + return hash_one_uint64((uint64_t)_data._int); + } break; + case REAL: { + return hash_murmur3_one_float(_data._real); + } break; + case STRING: { + return reinterpret_cast(_data._mem)->hash(); + } break; + + // math types + case RECT2I: { + return HashMapHasherDefault::hash(*reinterpret_cast(_data._mem)); + } break; + case VECTOR2I: { + return HashMapHasherDefault::hash(*reinterpret_cast(_data._mem)); + } break; + + // misc types + case COLOR: { + uint32_t h = HASH_MURMUR3_SEED; + const Color &c = *reinterpret_cast(_data._mem); + h = hash_murmur3_one_float(c.r, h); + h = hash_murmur3_one_float(c.g, h); + h = hash_murmur3_one_float(c.b, h); + h = hash_murmur3_one_float(c.a, h); + return hash_fmix32(h); + } break; + case OBJECT: { + return hash_one_uint64(hash_make_uint64_t(_UNSAFE_OBJ_PROXY_PTR(*this))); + } break; + case STRING_NAME: { + return reinterpret_cast(_data._mem)->hash(); + } break; + case DICTIONARY: { + return reinterpret_cast(_data._mem)->recursive_hash(p_recursion_count); + } break; + case ARRAY: { + const Array &arr = *reinterpret_cast(_data._mem); + return arr.recursive_hash(p_recursion_count); + } break; + + case POOL_BYTE_ARRAY: { + const PoolVector &arr = *reinterpret_cast *>(_data._mem); + int len = arr.size(); + if (likely(len)) { + PoolVector::Read r = arr.read(); + return hash_murmur3_buffer((uint8_t *)&r[0], len); + } else { + return hash_murmur3_one_64(0); + } + + } break; + case POOL_INT_ARRAY: { + const PoolVector &arr = *reinterpret_cast *>(_data._mem); + int len = arr.size(); + if (likely(len)) { + PoolVector::Read r = arr.read(); + return hash_murmur3_buffer((uint8_t *)&r[0], len * sizeof(int)); + } else { + return hash_murmur3_one_64(0); + } + + } break; + case POOL_REAL_ARRAY: { + const PoolVector &arr = *reinterpret_cast *>(_data._mem); + int len = arr.size(); + + if (likely(len)) { + PoolVector::Read r = arr.read(); + uint32_t h = HASH_MURMUR3_SEED; + + for (int i = 0; i < len; i++) { + h = hash_murmur3_one_real(r[i], h); + } + + return hash_fmix32(h); + } else { + return hash_murmur3_one_real(0.0); + } + + } break; + case POOL_STRING_ARRAY: { + uint32_t hash = HASH_MURMUR3_SEED; + const PoolVector &arr = *reinterpret_cast *>(_data._mem); + int len = arr.size(); + + if (likely(len)) { + PoolVector::Read r = arr.read(); + + for (int i = 0; i < len; i++) { + hash = hash_murmur3_one_32(r[i].hash(), hash); + } + + hash = hash_fmix32(hash); + } + + return hash; + } break; + case POOL_VECTOR2I_ARRAY: { + uint32_t hash = HASH_MURMUR3_SEED; + const PoolVector &arr = *reinterpret_cast *>(_data._mem); + int len = arr.size(); + + if (likely(len)) { + PoolVector::Read r = arr.read(); + + for (int i = 0; i < len; i++) { + hash = hash_murmur3_one_32(r[i].x, hash); + hash = hash_murmur3_one_32(r[i].y, hash); + } + + hash = hash_fmix32(hash); + } + + return hash; + } break; + + case POOL_COLOR_ARRAY: { + uint32_t hash = HASH_MURMUR3_SEED; + const PoolVector &arr = *reinterpret_cast *>(_data._mem); + int len = arr.size(); + + if (likely(len)) { + PoolVector::Read r = arr.read(); + + for (int i = 0; i < len; i++) { + hash = hash_murmur3_one_real(r[i].r, hash); + hash = hash_murmur3_one_real(r[i].g, hash); + hash = hash_murmur3_one_real(r[i].b, hash); + hash = hash_murmur3_one_real(r[i].a, hash); + } + + hash = hash_fmix32(hash); + } + + return hash; + } break; + default: { + } + } + + return 0; +} + +#define hash_compare_scalar(p_lhs, p_rhs) \ + (((p_lhs) == (p_rhs)) || (Math::is_nan(p_lhs) && Math::is_nan(p_rhs))) + +#define hash_compare_vector2(p_lhs, p_rhs) \ + (hash_compare_scalar((p_lhs).x, (p_rhs).x) && \ + hash_compare_scalar((p_lhs).y, (p_rhs).y)) + +#define hash_compare_vector2i(p_lhs, p_rhs) \ + (((p_lhs).x == (p_rhs).x) && \ + ((p_lhs).y == (p_rhs).y)) + +#define hash_compare_vector3(p_lhs, p_rhs) \ + (hash_compare_scalar((p_lhs).x, (p_rhs).x) && \ + hash_compare_scalar((p_lhs).y, (p_rhs).y) && \ + hash_compare_scalar((p_lhs).z, (p_rhs).z)) + +#define hash_compare_vector3i(p_lhs, p_rhs) \ + (((p_lhs).x == (p_rhs).x) && \ + ((p_lhs).y == (p_rhs).y) && \ + ((p_lhs).z == (p_rhs).z)) + +#define hash_compare_vector4(p_lhs, p_rhs) \ + (hash_compare_scalar((p_lhs).x, (p_rhs).x) && \ + hash_compare_scalar((p_lhs).y, (p_rhs).y) && \ + hash_compare_scalar((p_lhs).z, (p_rhs).z) && \ + hash_compare_scalar((p_lhs).w, (p_rhs).w)) + +#define hash_compare_vector4i(p_lhs, p_rhs) \ + (((p_lhs).x == (p_rhs).x) && \ + ((p_lhs).y == (p_rhs).y) && \ + ((p_lhs).z == (p_rhs).z) && \ + ((p_lhs).w == (p_rhs).w)) + +#define hash_compare_quat(p_lhs, p_rhs) \ + (hash_compare_scalar((p_lhs).x, (p_rhs).x) && \ + hash_compare_scalar((p_lhs).y, (p_rhs).y) && \ + hash_compare_scalar((p_lhs).z, (p_rhs).z) && \ + hash_compare_scalar((p_lhs).w, (p_rhs).w)) + +#define hash_compare_color(p_lhs, p_rhs) \ + (hash_compare_scalar((p_lhs).r, (p_rhs).r) && \ + hash_compare_scalar((p_lhs).g, (p_rhs).g) && \ + hash_compare_scalar((p_lhs).b, (p_rhs).b) && \ + hash_compare_scalar((p_lhs).a, (p_rhs).a)) + +#define hash_compare_pool_array(p_lhs, p_rhs, p_type, p_compare_func) \ + const PoolVector &l = *reinterpret_cast *>(p_lhs); \ + const PoolVector &r = *reinterpret_cast *>(p_rhs); \ + \ + if (l.size() != r.size()) \ + return false; \ + \ + PoolVector::Read lr = l.read(); \ + PoolVector::Read rr = r.read(); \ + \ + for (int i = 0; i < l.size(); ++i) { \ + if (!p_compare_func((lr[i]), (rr[i]))) \ + return false; \ + } \ + \ + return true + +bool Variant::hash_compare(const Variant &p_variant) const { + if (type != p_variant.type) { + return false; + } + + switch (type) { + //BOOL + case INT: { + return _data._int == p_variant._data._int; + } break; + case REAL: { + return hash_compare_scalar(_data._real, p_variant._data._real); + } break; + case STRING: { + return *reinterpret_cast(_data._mem) == *reinterpret_cast(p_variant._data._mem); + } break; + + case RECT2I: { + const Rect2i *l = reinterpret_cast(_data._mem); + const Rect2i *r = reinterpret_cast(p_variant._data._mem); + + return hash_compare_vector2i(l->position, r->position) && + hash_compare_vector2i(l->size, r->size); + } break; + case VECTOR2I: { + const Vector2i *l = reinterpret_cast(_data._mem); + const Vector2i *r = reinterpret_cast(p_variant._data._mem); + + return hash_compare_vector2i(*l, *r); + } break; + + case COLOR: { + const Color *l = reinterpret_cast(_data._mem); + const Color *r = reinterpret_cast(p_variant._data._mem); + + return hash_compare_color(*l, *r); + } break; + case ARRAY: { + const Array &l = *(reinterpret_cast(_data._mem)); + const Array &r = *(reinterpret_cast(p_variant._data._mem)); + + if (l.size() != r.size()) { + return false; + } + + for (int i = 0; i < l.size(); ++i) { + if (!l[i].hash_compare(r[i])) { + return false; + } + } + + return true; + } break; + + case POOL_REAL_ARRAY: { + hash_compare_pool_array(_data._mem, p_variant._data._mem, real_t, hash_compare_scalar); + } break; + case POOL_VECTOR2I_ARRAY: { + hash_compare_pool_array(_data._mem, p_variant._data._mem, Vector2i, hash_compare_vector2i); + } break; + case POOL_COLOR_ARRAY: { + hash_compare_pool_array(_data._mem, p_variant._data._mem, Color, hash_compare_color); + } break; + + default: + bool v; + Variant r; + evaluate(OP_EQUAL, *this, p_variant, r, v); + return r; + } + + return false; +} + +bool Variant::is_ref() const { + return type == OBJECT && !_get_obj().ref.is_null(); +} + +Vector varray() { + return Vector(); +} + +Vector varray(const Variant &p_arg1) { + Vector v; + v.push_back(p_arg1); + return v; +} +Vector varray(const Variant &p_arg1, const Variant &p_arg2) { + Vector v; + v.push_back(p_arg1); + v.push_back(p_arg2); + return v; +} +Vector varray(const Variant &p_arg1, const Variant &p_arg2, const Variant &p_arg3) { + Vector v; + v.push_back(p_arg1); + v.push_back(p_arg2); + v.push_back(p_arg3); + return v; +} +Vector varray(const Variant &p_arg1, const Variant &p_arg2, const Variant &p_arg3, const Variant &p_arg4) { + Vector v; + v.push_back(p_arg1); + v.push_back(p_arg2); + v.push_back(p_arg3); + v.push_back(p_arg4); + return v; +} + +Vector varray(const Variant &p_arg1, const Variant &p_arg2, const Variant &p_arg3, const Variant &p_arg4, const Variant &p_arg5) { + Vector v; + v.push_back(p_arg1); + v.push_back(p_arg2); + v.push_back(p_arg3); + v.push_back(p_arg4); + v.push_back(p_arg5); + return v; +} + +bool Variant::is_shared() const { + switch (type) { + case OBJECT: + return true; + case ARRAY: + return true; + case DICTIONARY: + return true; + default: { + } + } + + return false; +} + +String vformat(const String &p_text, const Variant &p1, const Variant &p2, const Variant &p3, const Variant &p4, const Variant &p5) { + Array args; + if (p1.get_type() != Variant::NIL) { + args.push_back(p1); + + if (p2.get_type() != Variant::NIL) { + args.push_back(p2); + + if (p3.get_type() != Variant::NIL) { + args.push_back(p3); + + if (p4.get_type() != Variant::NIL) { + args.push_back(p4); + + if (p5.get_type() != Variant::NIL) { + args.push_back(p5); + } + } + } + } + } + + bool error = false; + String fmt = args.sprintf(p_text, &error); + + ERR_FAIL_COND_V_MSG(error, String(), fmt); + + return fmt; +} +#line 0 + +#line 1 "sfwl/object/variant_op.cpp" +/*************************************************************************/ +/* variant_op.cpp */ +/* From https://github.com/Relintai/pandemonium_engine (MIT) */ +/*************************************************************************/ + +#define CASE_TYPE_ALL(PREFIX, OP) \ + CASE_TYPE(PREFIX, OP, INT) \ + CASE_TYPE_ALL_BUT_INT(PREFIX, OP) + +#define CASE_TYPE_ALL_BUT_INT(PREFIX, OP) \ + CASE_TYPE(PREFIX, OP, NIL) \ + CASE_TYPE(PREFIX, OP, BOOL) \ + CASE_TYPE(PREFIX, OP, REAL) \ + CASE_TYPE(PREFIX, OP, STRING) \ + CASE_TYPE(PREFIX, OP, RECT2I) \ + CASE_TYPE(PREFIX, OP, VECTOR2I) \ + CASE_TYPE(PREFIX, OP, COLOR) \ + CASE_TYPE(PREFIX, OP, OBJECT) \ + CASE_TYPE(PREFIX, OP, STRING_NAME) \ + CASE_TYPE(PREFIX, OP, DICTIONARY) \ + CASE_TYPE(PREFIX, OP, ARRAY) \ + CASE_TYPE(PREFIX, OP, POOL_BYTE_ARRAY) \ + CASE_TYPE(PREFIX, OP, POOL_INT_ARRAY) \ + CASE_TYPE(PREFIX, OP, POOL_REAL_ARRAY) \ + CASE_TYPE(PREFIX, OP, POOL_STRING_ARRAY) \ + CASE_TYPE(PREFIX, OP, POOL_VECTOR2I_ARRAY) \ + CASE_TYPE(PREFIX, OP, POOL_COLOR_ARRAY) + +#ifdef __GNUC__ +#define TYPE(PREFIX, OP, TYPE) &&PREFIX##_##OP##_##TYPE + +/* clang-format off */ + +#define TYPES(PREFIX, OP) { \ + TYPE(PREFIX, OP, NIL), \ + TYPE(PREFIX, OP, BOOL), \ + TYPE(PREFIX, OP, INT), \ + TYPE(PREFIX, OP, REAL), \ + TYPE(PREFIX, OP, STRING), \ + TYPE(PREFIX, OP, RECT2I), \ + TYPE(PREFIX, OP, VECTOR2I), \ + TYPE(PREFIX, OP, COLOR), \ + TYPE(PREFIX, OP, OBJECT), \ + TYPE(PREFIX, OP, STRING_NAME), \ + TYPE(PREFIX, OP, DICTIONARY), \ + TYPE(PREFIX, OP, ARRAY), \ + TYPE(PREFIX, OP, POOL_BYTE_ARRAY), \ + TYPE(PREFIX, OP, POOL_INT_ARRAY), \ + TYPE(PREFIX, OP, POOL_REAL_ARRAY), \ + TYPE(PREFIX, OP, POOL_STRING_ARRAY), \ + TYPE(PREFIX, OP, POOL_VECTOR2I_ARRAY), \ + TYPE(PREFIX, OP, POOL_COLOR_ARRAY), \ +} + +/* clang-format on */ + +#define CASES(PREFIX) static const void *switch_table_##PREFIX[25][18] = { \ + TYPES(PREFIX, OP_EQUAL), \ + TYPES(PREFIX, OP_NOT_EQUAL), \ + TYPES(PREFIX, OP_LESS), \ + TYPES(PREFIX, OP_LESS_EQUAL), \ + TYPES(PREFIX, OP_GREATER), \ + TYPES(PREFIX, OP_GREATER_EQUAL), \ + TYPES(PREFIX, OP_ADD), \ + TYPES(PREFIX, OP_SUBTRACT), \ + TYPES(PREFIX, OP_MULTIPLY), \ + TYPES(PREFIX, OP_DIVIDE), \ + TYPES(PREFIX, OP_NEGATE), \ + TYPES(PREFIX, OP_POSITIVE), \ + TYPES(PREFIX, OP_MODULE), \ + TYPES(PREFIX, OP_STRING_CONCAT), \ + TYPES(PREFIX, OP_SHIFT_LEFT), \ + TYPES(PREFIX, OP_SHIFT_RIGHT), \ + TYPES(PREFIX, OP_BIT_AND), \ + TYPES(PREFIX, OP_BIT_OR), \ + TYPES(PREFIX, OP_BIT_XOR), \ + TYPES(PREFIX, OP_BIT_NEGATE), \ + TYPES(PREFIX, OP_AND), \ + TYPES(PREFIX, OP_OR), \ + TYPES(PREFIX, OP_XOR), \ + TYPES(PREFIX, OP_NOT), \ + TYPES(PREFIX, OP_IN), \ +} + +#define SWITCH(PREFIX, op, val) goto *switch_table_##PREFIX[op][val]; +#define SWITCH_OP(PREFIX, OP, val) +#define CASE_TYPE(PREFIX, OP, TYPE) PREFIX##_##OP##_##TYPE: + +#else +#define CASES(PREFIX) +#define SWITCH(PREFIX, op, val) switch (op) +#define SWITCH_OP(PREFIX, OP, val) \ + case OP: \ + switch (val) +#define CASE_TYPE(PREFIX, OP, TYPE) case TYPE: +#endif + +Variant::operator bool() const { + return booleanize(); +} + +// We consider all uninitialized or empty types to be false based on the type's +// zeroiness. +bool Variant::booleanize() const { + return !is_zero(); +} + +#define _RETURN(m_what) \ + { \ + r_ret = m_what; \ + return; \ + } + +#define _RETURN_FAIL \ + { \ + r_valid = false; \ + return; \ + } + +#define DEFAULT_OP_NUM(m_prefix, m_op_name, m_name, m_op, m_type) \ + CASE_TYPE(m_prefix, m_op_name, m_name) { \ + if (p_b.type == INT) \ + _RETURN(p_a._data.m_type m_op p_b._data._int); \ + if (p_b.type == REAL) \ + _RETURN(p_a._data.m_type m_op p_b._data._real); \ + \ + _RETURN_FAIL \ + }; + +#define DEFAULT_OP_NUM_NULL(m_prefix, m_op_name, m_name, m_op, m_type) \ + CASE_TYPE(m_prefix, m_op_name, m_name) { \ + if (p_b.type == INT) \ + _RETURN(p_a._data.m_type m_op p_b._data._int); \ + if (p_b.type == REAL) \ + _RETURN(p_a._data.m_type m_op p_b._data._real); \ + if (p_b.type == NIL) \ + _RETURN(!(p_b.type m_op NIL)); \ + \ + _RETURN_FAIL \ + }; + +#ifdef DEBUG_ENABLED +#define DEFAULT_OP_NUM_DIV(m_prefix, m_op_name, m_name, m_type) \ + CASE_TYPE(m_prefix, m_op_name, m_name) { \ + if (p_b.type == INT) { \ + if (p_b._data._int == 0) { \ + r_valid = false; \ + _RETURN("Division By Zero"); \ + } \ + _RETURN(p_a._data.m_type / p_b._data._int); \ + } \ + if (p_b.type == REAL) { \ + if (p_b._data._real == 0) { \ + r_valid = false; \ + _RETURN("Division By Zero"); \ + } \ + _RETURN(p_a._data.m_type / p_b._data._real); \ + } \ + \ + _RETURN_FAIL \ + }; +#else +#define DEFAULT_OP_NUM_DIV(m_prefix, m_op_name, m_name, m_type) \ + CASE_TYPE(m_prefix, m_op_name, m_name) { \ + if (p_b.type == INT) \ + _RETURN(p_a._data.m_type / p_b._data._int); \ + if (p_b.type == REAL) \ + _RETURN(p_a._data.m_type / p_b._data._real); \ + \ + _RETURN_FAIL \ + }; +#endif + +#define DEFAULT_OP_NUM_NEG(m_prefix, m_op_name, m_name, m_type) \ + CASE_TYPE(m_prefix, m_op_name, m_name) { \ + _RETURN(-p_a._data.m_type); \ + }; + +#define DEFAULT_OP_NUM_POS(m_prefix, m_op_name, m_name, m_type) \ + CASE_TYPE(m_prefix, m_op_name, m_name) { \ + _RETURN(p_a._data.m_type); \ + }; + +#define DEFAULT_OP_NUM_VEC(m_prefix, m_op_name, m_name, m_op, m_type) \ + CASE_TYPE(m_prefix, m_op_name, m_name) { \ + if (p_b.type == INT) \ + _RETURN(p_a._data.m_type m_op p_b._data._int); \ + if (p_b.type == REAL) \ + _RETURN(p_a._data.m_type m_op p_b._data._real); \ + \ + _RETURN_FAIL \ + }; + +#define DEFAULT_OP_STR_REV(m_prefix, m_op_name, m_name, m_op, m_type) \ + CASE_TYPE(m_prefix, m_op_name, m_name) { \ + if (p_b.type == STRING) \ + _RETURN(*reinterpret_cast(p_b._data._mem) m_op *reinterpret_cast(p_a._data._mem)); \ + if (p_b.type == STRING_NAME) \ + _RETURN(*reinterpret_cast(p_b._data._mem) m_op *reinterpret_cast(p_a._data._mem)); \ + \ + _RETURN_FAIL \ + }; + +#define DEFAULT_OP_STR(m_prefix, m_op_name, m_name, m_op, m_type) \ + CASE_TYPE(m_prefix, m_op_name, m_name) { \ + if (p_b.type == STRING) \ + _RETURN(*reinterpret_cast(p_a._data._mem) m_op *reinterpret_cast(p_b._data._mem)); \ + if (p_b.type == STRING_NAME) \ + _RETURN(*reinterpret_cast(p_a._data._mem) m_op *reinterpret_cast(p_b._data._mem)); \ + \ + _RETURN_FAIL \ + }; + +#define DEFAULT_OP_STR_NULL(m_prefix, m_op_name, m_name, m_op, m_type) \ + CASE_TYPE(m_prefix, m_op_name, m_name) { \ + if (p_b.type == STRING) \ + _RETURN(*reinterpret_cast(p_a._data._mem) m_op *reinterpret_cast(p_b._data._mem)); \ + if (p_b.type == STRING_NAME) \ + _RETURN(*reinterpret_cast(p_a._data._mem) m_op *reinterpret_cast(p_b._data._mem)); \ + if (p_b.type == NIL) \ + _RETURN(!(p_b.type m_op NIL)); \ + \ + _RETURN_FAIL \ + }; + +#define DEFAULT_OP_STR_NULL_NP(m_prefix, m_op_name, m_name, m_op, m_type) \ + CASE_TYPE(m_prefix, m_op_name, m_name) { \ + if (p_b.type == STRING) \ + _RETURN(*reinterpret_cast(p_a._data._mem) m_op *reinterpret_cast(p_b._data._mem)); \ + if (p_b.type == NIL) \ + _RETURN(!(p_b.type m_op NIL)); \ + \ + _RETURN_FAIL \ + }; + +#define DEFAULT_OP_STR_NULL_SN(m_prefix, m_op_name, m_name, m_op, m_type) \ + CASE_TYPE(m_prefix, m_op_name, m_name) { \ + if (p_b.type == STRING) \ + _RETURN(*reinterpret_cast(p_a._data._mem) m_op *reinterpret_cast(p_b._data._mem)); \ + if (p_b.type == STRING_NAME) \ + _RETURN(*reinterpret_cast(p_a._data._mem) m_op *reinterpret_cast(p_b._data._mem)); \ + if (p_b.type == NIL) \ + _RETURN(!(p_b.type m_op NIL)); \ + \ + _RETURN_FAIL \ + }; + +#define DEFAULT_OP_LOCALMEM_REV(m_prefix, m_op_name, m_name, m_op, m_type) \ + CASE_TYPE(m_prefix, m_op_name, m_name) { \ + if (p_b.type == m_name) \ + _RETURN(*reinterpret_cast(p_b._data._mem) m_op *reinterpret_cast(p_a._data._mem)); \ + \ + _RETURN_FAIL \ + }; + +#define DEFAULT_OP_LOCALMEM(m_prefix, m_op_name, m_name, m_op, m_type) \ + CASE_TYPE(m_prefix, m_op_name, m_name) { \ + if (p_b.type == m_name) \ + _RETURN(*reinterpret_cast(p_a._data._mem) m_op *reinterpret_cast(p_b._data._mem)); \ + \ + _RETURN_FAIL \ + }; + +#define DEFAULT_OP_LOCALMEM_NULL(m_prefix, m_op_name, m_name, m_op, m_type) \ + CASE_TYPE(m_prefix, m_op_name, m_name) { \ + if (p_b.type == m_name) \ + _RETURN(*reinterpret_cast(p_a._data._mem) m_op *reinterpret_cast(p_b._data._mem)); \ + if (p_b.type == NIL) \ + _RETURN(!(p_b.type m_op NIL)); \ + \ + _RETURN_FAIL \ + }; + +#define DEFAULT_OP_LOCALMEM_NEG(m_prefix, m_op_name, m_name, m_type) \ + CASE_TYPE(m_prefix, m_op_name, m_name) { \ + _RETURN(-*reinterpret_cast(p_a._data._mem)); \ + } + +#define DEFAULT_OP_LOCALMEM_POS(m_prefix, m_op_name, m_name, m_type) \ + CASE_TYPE(m_prefix, m_op_name, m_name) { \ + _RETURN(*reinterpret_cast(p_a._data._mem)); \ + } + +#define DEFAULT_OP_LOCALMEM_NUM(m_prefix, m_op_name, m_name, m_op, m_type) \ + CASE_TYPE(m_prefix, m_op_name, m_name) { \ + if (p_b.type == m_name) \ + _RETURN(*reinterpret_cast(p_a._data._mem) m_op *reinterpret_cast(p_b._data._mem)); \ + if (p_b.type == INT) \ + _RETURN(*reinterpret_cast(p_a._data._mem) m_op p_b._data._int); \ + if (p_b.type == REAL) \ + _RETURN(*reinterpret_cast(p_a._data._mem) m_op p_b._data._real); \ + \ + _RETURN_FAIL \ + } + +#define DEFAULT_OP_PTR(m_op, m_name, m_sub) \ + CASE_TYPE(m_prefix, m_op_name, m_name) { \ + if (p_b.type == m_name) \ + _RETURN(p_a._data.m_sub m_op p_b._data.m_sub); \ + \ + _RETURN_FAIL \ + } + +#define DEFAULT_OP_PTRREF(m_prefix, m_op_name, m_name, m_op, m_sub) \ + CASE_TYPE(m_prefix, m_op_name, m_name) { \ + if (p_b.type == m_name) \ + _RETURN(*p_a._data.m_sub m_op *p_b._data.m_sub); \ + \ + _RETURN_FAIL \ + } + +#define DEFAULT_OP_PTRREF_NULL(m_prefix, m_op_name, m_name, m_op, m_sub) \ + CASE_TYPE(m_prefix, m_op_name, m_name) { \ + if (p_b.type == m_name) \ + _RETURN(*p_a._data.m_sub m_op *p_b._data.m_sub); \ + if (p_b.type == NIL) \ + _RETURN(!(p_b.type m_op NIL)); \ + \ + _RETURN_FAIL \ + } + +#define DEFAULT_OP_ARRAY_EQ(m_prefix, m_op_name, m_name, m_type) \ + CASE_TYPE(m_prefix, m_op_name, m_name) { \ + if (p_b.type == NIL) \ + _RETURN(false) \ + DEFAULT_OP_ARRAY_OP_BODY(m_prefix, m_op_name, m_name, m_type, !=, !=, true, false, false) \ + } + +#define DEFAULT_OP_ARRAY_NEQ(m_prefix, m_op_name, m_name, m_type) \ + CASE_TYPE(m_prefix, m_op_name, m_name) { \ + if (p_b.type == NIL) \ + _RETURN(true) \ + DEFAULT_OP_ARRAY_OP_BODY(m_prefix, m_op_name, m_name, m_type, !=, !=, false, true, true) \ + } + +#define DEFAULT_OP_ARRAY_LT(m_prefix, m_op_name, m_name, m_type) \ + DEFAULT_OP_ARRAY_OP(m_prefix, m_op_name, m_name, m_type, <, !=, false, a_len < array_b.size(), true) + +#define DEFAULT_OP_ARRAY_GT(m_prefix, m_op_name, m_name, m_type) \ + DEFAULT_OP_ARRAY_OP(m_prefix, m_op_name, m_name, m_type, >, !=, false, a_len < array_b.size(), true) + +#define DEFAULT_OP_ARRAY_OP(m_prefix, m_op_name, m_name, m_type, m_opa, m_opb, m_ret_def, m_ret_s, m_ret_f) \ + CASE_TYPE(m_prefix, m_op_name, m_name) { \ + DEFAULT_OP_ARRAY_OP_BODY(m_prefix, m_op_name, m_name, m_type, m_opa, m_opb, m_ret_def, m_ret_s, m_ret_f) \ + } + +#define DEFAULT_OP_ARRAY_OP_BODY(m_prefix, m_op_name, m_name, m_type, m_opa, m_opb, m_ret_def, m_ret_s, m_ret_f) \ + if (p_a.type != p_b.type) \ + _RETURN_FAIL \ + \ + const PoolVector &array_a = *reinterpret_cast *>(p_a._data._mem); \ + const PoolVector &array_b = *reinterpret_cast *>(p_b._data._mem); \ + \ + int a_len = array_a.size(); \ + if (a_len m_opa array_b.size()) { \ + _RETURN(m_ret_s); \ + } else { \ + PoolVector::Read ra = array_a.read(); \ + PoolVector::Read rb = array_b.read(); \ + \ + for (int i = 0; i < a_len; i++) { \ + if (ra[i] m_opb rb[i]) \ + _RETURN(m_ret_f); \ + } \ + \ + _RETURN(m_ret_def); \ + } + +#define DEFAULT_OP_ARRAY_ADD(m_prefix, m_op_name, m_name, m_type) \ + CASE_TYPE(m_prefix, m_op_name, m_name) { \ + if (p_a.type != p_b.type) \ + _RETURN_FAIL; \ + \ + const PoolVector &array_a = *reinterpret_cast *>(p_a._data._mem); \ + const PoolVector &array_b = *reinterpret_cast *>(p_b._data._mem); \ + PoolVector sum = array_a; \ + sum.append_array(array_b); \ + _RETURN(sum); \ + } + +void Variant::evaluate(const Operator &p_op, const Variant &p_a, + const Variant &p_b, Variant &r_ret, bool &r_valid) { + CASES(math); + r_valid = true; + + SWITCH(math, p_op, p_a.type) { + SWITCH_OP(math, OP_EQUAL, p_a.type) { + CASE_TYPE(math, OP_EQUAL, NIL) { + if (p_b.type == NIL) + _RETURN(true); + if (p_b.type == OBJECT) + _RETURN(_UNSAFE_OBJ_PROXY_PTR(p_b) == nullptr); + + _RETURN(false); + } + + CASE_TYPE(math, OP_EQUAL, BOOL) { + if (p_b.type != BOOL) { + if (p_b.type == NIL) + _RETURN(false); + _RETURN_FAIL; + } + + _RETURN(p_a._data._bool == p_b._data._bool); + } + + CASE_TYPE(math, OP_EQUAL, OBJECT) { + if (p_b.type == OBJECT) + _RETURN(_UNSAFE_OBJ_PROXY_PTR(p_a) == _UNSAFE_OBJ_PROXY_PTR(p_b)); + if (p_b.type == NIL) + _RETURN(_UNSAFE_OBJ_PROXY_PTR(p_a) == nullptr); + + _RETURN_FAIL; + } + + CASE_TYPE(math, OP_EQUAL, DICTIONARY) { + if (p_b.type != DICTIONARY) { + if (p_b.type == NIL) + _RETURN(false); + _RETURN_FAIL; + } + + const Dictionary *arr_a = reinterpret_cast(p_a._data._mem); + const Dictionary *arr_b = reinterpret_cast(p_b._data._mem); + + _RETURN(*arr_a == *arr_b); + } + + CASE_TYPE(math, OP_EQUAL, ARRAY) { + if (p_b.type != ARRAY) { + if (p_b.type == NIL) + _RETURN(false); + _RETURN_FAIL; + } + const Array *arr_a = reinterpret_cast(p_a._data._mem); + const Array *arr_b = reinterpret_cast(p_b._data._mem); + + int l = arr_a->size(); + if (arr_b->size() != l) + _RETURN(false); + for (int i = 0; i < l; i++) { + if (!((*arr_a)[i] == (*arr_b)[i])) { + _RETURN(false); + } + } + + _RETURN(true); + } + + DEFAULT_OP_NUM_NULL(math, OP_EQUAL, INT, ==, _int); + DEFAULT_OP_NUM_NULL(math, OP_EQUAL, REAL, ==, _real); + DEFAULT_OP_STR_NULL(math, OP_EQUAL, STRING, ==, String); + DEFAULT_OP_LOCALMEM_NULL(math, OP_EQUAL, RECT2I, ==, Rect2i); + DEFAULT_OP_LOCALMEM_NULL(math, OP_EQUAL, VECTOR2I, ==, Vector2i); + DEFAULT_OP_LOCALMEM_NULL(math, OP_EQUAL, COLOR, ==, Color); + DEFAULT_OP_STR_NULL_SN(math, OP_EQUAL, STRING_NAME, ==, StringName); + + DEFAULT_OP_ARRAY_EQ(math, OP_EQUAL, POOL_BYTE_ARRAY, uint8_t); + DEFAULT_OP_ARRAY_EQ(math, OP_EQUAL, POOL_INT_ARRAY, int); + DEFAULT_OP_ARRAY_EQ(math, OP_EQUAL, POOL_REAL_ARRAY, real_t); + DEFAULT_OP_ARRAY_EQ(math, OP_EQUAL, POOL_STRING_ARRAY, String); + DEFAULT_OP_ARRAY_EQ(math, OP_EQUAL, POOL_VECTOR2I_ARRAY, Vector2i); + DEFAULT_OP_ARRAY_EQ(math, OP_EQUAL, POOL_COLOR_ARRAY, Color); + } + + SWITCH_OP(math, OP_NOT_EQUAL, p_a.type) { + CASE_TYPE(math, OP_NOT_EQUAL, NIL) { + if (p_b.type == NIL) + _RETURN(false); + if (p_b.type == OBJECT) + _RETURN(_UNSAFE_OBJ_PROXY_PTR(p_b) != nullptr); + + _RETURN(true); + } + + CASE_TYPE(math, OP_NOT_EQUAL, BOOL) { + if (p_b.type != BOOL) { + if (p_b.type == NIL) + _RETURN(true); + + _RETURN_FAIL; + } + + _RETURN(p_a._data._bool != p_b._data._bool); + } + + CASE_TYPE(math, OP_NOT_EQUAL, OBJECT) { + if (p_b.type == OBJECT) + _RETURN((_UNSAFE_OBJ_PROXY_PTR(p_a) != _UNSAFE_OBJ_PROXY_PTR(p_b))); + if (p_b.type == NIL) + _RETURN(_UNSAFE_OBJ_PROXY_PTR(p_a) != nullptr); + + _RETURN_FAIL; + } + + CASE_TYPE(math, OP_NOT_EQUAL, DICTIONARY) { + if (p_b.type != DICTIONARY) { + if (p_b.type == NIL) + _RETURN(true); + _RETURN_FAIL; + } + + const Dictionary *arr_a = reinterpret_cast(p_a._data._mem); + const Dictionary *arr_b = reinterpret_cast(p_b._data._mem); + + _RETURN(*arr_a != *arr_b); + } + + CASE_TYPE(math, OP_NOT_EQUAL, ARRAY) { + if (p_b.type != ARRAY) { + if (p_b.type == NIL) + _RETURN(true); + + _RETURN_FAIL; + } + + const Array *arr_a = reinterpret_cast(p_a._data._mem); + const Array *arr_b = reinterpret_cast(p_b._data._mem); + + int l = arr_a->size(); + if (arr_b->size() != l) + _RETURN(true); + for (int i = 0; i < l; i++) { + if (((*arr_a)[i] != (*arr_b)[i])) { + _RETURN(true); + } + } + + _RETURN(false); + } + + DEFAULT_OP_NUM_NULL(math, OP_NOT_EQUAL, INT, !=, _int); + DEFAULT_OP_NUM_NULL(math, OP_NOT_EQUAL, REAL, !=, _real); + DEFAULT_OP_STR_NULL(math, OP_NOT_EQUAL, STRING, !=, String); + DEFAULT_OP_LOCALMEM_NULL(math, OP_NOT_EQUAL, RECT2I, !=, Rect2i); + DEFAULT_OP_LOCALMEM_NULL(math, OP_NOT_EQUAL, VECTOR2I, !=, Vector2i); + DEFAULT_OP_LOCALMEM_NULL(math, OP_NOT_EQUAL, COLOR, !=, Color); + DEFAULT_OP_STR_NULL_SN(math, OP_NOT_EQUAL, STRING_NAME, !=, StringName); + + DEFAULT_OP_ARRAY_NEQ(math, OP_NOT_EQUAL, POOL_BYTE_ARRAY, uint8_t); + DEFAULT_OP_ARRAY_NEQ(math, OP_NOT_EQUAL, POOL_INT_ARRAY, int); + DEFAULT_OP_ARRAY_NEQ(math, OP_NOT_EQUAL, POOL_REAL_ARRAY, real_t); + DEFAULT_OP_ARRAY_NEQ(math, OP_NOT_EQUAL, POOL_STRING_ARRAY, String); + DEFAULT_OP_ARRAY_NEQ(math, OP_NOT_EQUAL, POOL_VECTOR2I_ARRAY, Vector2i); + DEFAULT_OP_ARRAY_NEQ(math, OP_NOT_EQUAL, POOL_COLOR_ARRAY, Color); + } + + SWITCH_OP(math, OP_LESS, p_a.type) { + CASE_TYPE(math, OP_LESS, BOOL) { + if (p_b.type != BOOL) + _RETURN_FAIL; + + if (p_a._data._bool == p_b._data._bool) + _RETURN(false); + + if (p_a._data._bool && !p_b._data._bool) + _RETURN(false); + + _RETURN(true); + } + + CASE_TYPE(math, OP_LESS, OBJECT) { + if (p_b.type != OBJECT) + _RETURN_FAIL; + _RETURN(_UNSAFE_OBJ_PROXY_PTR(p_a) < _UNSAFE_OBJ_PROXY_PTR(p_b)); + } + + CASE_TYPE(math, OP_LESS, ARRAY) { + if (p_b.type != ARRAY) + _RETURN_FAIL; + + const Array *arr_a = reinterpret_cast(p_a._data._mem); + const Array *arr_b = reinterpret_cast(p_b._data._mem); + + int l = arr_a->size(); + if (arr_b->size() < l) + _RETURN(false); + for (int i = 0; i < l; i++) { + if (!((*arr_a)[i] < (*arr_b)[i])) { + _RETURN(true); + } + } + + _RETURN(false); + } + + DEFAULT_OP_NUM(math, OP_LESS, INT, <, _int); + DEFAULT_OP_NUM(math, OP_LESS, REAL, <, _real); + DEFAULT_OP_STR(math, OP_LESS, STRING, <, String); + DEFAULT_OP_LOCALMEM(math, OP_LESS, VECTOR2I, <, Vector2i); + + DEFAULT_OP_ARRAY_LT(math, OP_LESS, POOL_BYTE_ARRAY, uint8_t); + DEFAULT_OP_ARRAY_LT(math, OP_LESS, POOL_INT_ARRAY, int); + DEFAULT_OP_ARRAY_LT(math, OP_LESS, POOL_REAL_ARRAY, real_t); + DEFAULT_OP_ARRAY_LT(math, OP_LESS, POOL_STRING_ARRAY, String); + DEFAULT_OP_ARRAY_LT(math, OP_LESS, POOL_VECTOR2I_ARRAY, Vector2i); + DEFAULT_OP_ARRAY_LT(math, OP_LESS, POOL_COLOR_ARRAY, Color); + + CASE_TYPE(math, OP_LESS, NIL) + CASE_TYPE(math, OP_LESS, RECT2I) + CASE_TYPE(math, OP_LESS, STRING_NAME) + CASE_TYPE(math, OP_LESS, COLOR) + CASE_TYPE(math, OP_LESS, DICTIONARY) + _RETURN_FAIL; + } + + SWITCH_OP(math, OP_LESS_EQUAL, p_a.type) { + CASE_TYPE(math, OP_LESS_EQUAL, OBJECT) { + if (p_b.type != OBJECT) + _RETURN_FAIL; + _RETURN(_UNSAFE_OBJ_PROXY_PTR(p_a) <= _UNSAFE_OBJ_PROXY_PTR(p_b)); + } + + DEFAULT_OP_NUM(math, OP_LESS_EQUAL, INT, <=, _int); + DEFAULT_OP_NUM(math, OP_LESS_EQUAL, REAL, <=, _real); + DEFAULT_OP_STR(math, OP_LESS_EQUAL, STRING, <=, String); + DEFAULT_OP_LOCALMEM(math, OP_LESS_EQUAL, VECTOR2I, <=, Vector2i); + + CASE_TYPE(math, OP_LESS_EQUAL, NIL) + CASE_TYPE(math, OP_LESS_EQUAL, BOOL) + CASE_TYPE(math, OP_LESS_EQUAL, RECT2I) + CASE_TYPE(math, OP_LESS_EQUAL, COLOR) + CASE_TYPE(math, OP_LESS_EQUAL, STRING_NAME) + CASE_TYPE(math, OP_LESS_EQUAL, DICTIONARY) + CASE_TYPE(math, OP_LESS_EQUAL, ARRAY) + CASE_TYPE(math, OP_LESS_EQUAL, POOL_BYTE_ARRAY); + CASE_TYPE(math, OP_LESS_EQUAL, POOL_INT_ARRAY); + CASE_TYPE(math, OP_LESS_EQUAL, POOL_REAL_ARRAY); + CASE_TYPE(math, OP_LESS_EQUAL, POOL_STRING_ARRAY); + CASE_TYPE(math, OP_LESS_EQUAL, POOL_VECTOR2I_ARRAY); + CASE_TYPE(math, OP_LESS_EQUAL, POOL_COLOR_ARRAY); + _RETURN_FAIL; + } + + SWITCH_OP(math, OP_GREATER, p_a.type) { + CASE_TYPE(math, OP_GREATER, BOOL) { + if (p_b.type != BOOL) + _RETURN_FAIL; + + if (p_a._data._bool == p_b._data._bool) + _RETURN(false); + + if (!p_a._data._bool && p_b._data._bool) + _RETURN(false); + + _RETURN(true); + } + + CASE_TYPE(math, OP_GREATER, OBJECT) { + if (p_b.type != OBJECT) + _RETURN_FAIL; + _RETURN(_UNSAFE_OBJ_PROXY_PTR(p_a) > _UNSAFE_OBJ_PROXY_PTR(p_b)); + } + + CASE_TYPE(math, OP_GREATER, ARRAY) { + if (p_b.type != ARRAY) + _RETURN_FAIL; + + const Array *arr_a = reinterpret_cast(p_a._data._mem); + const Array *arr_b = reinterpret_cast(p_b._data._mem); + + int l = arr_a->size(); + if (arr_b->size() > l) + _RETURN(false); + for (int i = 0; i < l; i++) { + if (((*arr_a)[i] < (*arr_b)[i])) { + _RETURN(false); + } + } + + _RETURN(true); + } + + DEFAULT_OP_NUM(math, OP_GREATER, INT, >, _int); + DEFAULT_OP_NUM(math, OP_GREATER, REAL, >, _real); + DEFAULT_OP_STR_REV(math, OP_GREATER, STRING, <, String); + DEFAULT_OP_LOCALMEM_REV(math, OP_GREATER, VECTOR2I, <, Vector2i); + DEFAULT_OP_ARRAY_GT(math, OP_GREATER, POOL_BYTE_ARRAY, uint8_t); + DEFAULT_OP_ARRAY_GT(math, OP_GREATER, POOL_INT_ARRAY, int); + DEFAULT_OP_ARRAY_GT(math, OP_GREATER, POOL_REAL_ARRAY, real_t); + DEFAULT_OP_ARRAY_GT(math, OP_GREATER, POOL_STRING_ARRAY, String); + DEFAULT_OP_ARRAY_GT(math, OP_GREATER, POOL_VECTOR2I_ARRAY, Vector2i); + DEFAULT_OP_ARRAY_GT(math, OP_GREATER, POOL_COLOR_ARRAY, Color); + + CASE_TYPE(math, OP_GREATER, NIL) + CASE_TYPE(math, OP_GREATER, RECT2I) + CASE_TYPE(math, OP_GREATER, STRING_NAME) + CASE_TYPE(math, OP_GREATER, COLOR) + CASE_TYPE(math, OP_GREATER, DICTIONARY) + _RETURN_FAIL; + } + + SWITCH_OP(math, OP_GREATER_EQUAL, p_a.type) { + CASE_TYPE(math, OP_GREATER_EQUAL, OBJECT) { + if (p_b.type != OBJECT) + _RETURN_FAIL; + _RETURN(_UNSAFE_OBJ_PROXY_PTR(p_a) >= _UNSAFE_OBJ_PROXY_PTR(p_b)); + } + + DEFAULT_OP_NUM(math, OP_GREATER_EQUAL, INT, >=, _int); + DEFAULT_OP_NUM(math, OP_GREATER_EQUAL, REAL, >=, _real); + DEFAULT_OP_STR_REV(math, OP_GREATER_EQUAL, STRING, <=, String); + DEFAULT_OP_LOCALMEM_REV(math, OP_GREATER_EQUAL, VECTOR2I, <=, Vector2i); + + CASE_TYPE(math, OP_GREATER_EQUAL, NIL) + CASE_TYPE(math, OP_GREATER_EQUAL, BOOL) + CASE_TYPE(math, OP_GREATER_EQUAL, RECT2I) + CASE_TYPE(math, OP_GREATER_EQUAL, COLOR) + CASE_TYPE(math, OP_GREATER_EQUAL, DICTIONARY) + CASE_TYPE(math, OP_GREATER_EQUAL, STRING_NAME) + CASE_TYPE(math, OP_GREATER_EQUAL, ARRAY) + CASE_TYPE(math, OP_GREATER_EQUAL, POOL_BYTE_ARRAY); + CASE_TYPE(math, OP_GREATER_EQUAL, POOL_INT_ARRAY); + CASE_TYPE(math, OP_GREATER_EQUAL, POOL_REAL_ARRAY); + CASE_TYPE(math, OP_GREATER_EQUAL, POOL_STRING_ARRAY); + CASE_TYPE(math, OP_GREATER_EQUAL, POOL_VECTOR2I_ARRAY); + CASE_TYPE(math, OP_GREATER_EQUAL, POOL_COLOR_ARRAY); + _RETURN_FAIL; + } + + SWITCH_OP(math, OP_ADD, p_a.type) { + CASE_TYPE(math, OP_ADD, ARRAY) { + if (p_a.type != p_b.type) + _RETURN_FAIL; + + const Array &array_a = *reinterpret_cast(p_a._data._mem); + const Array &array_b = *reinterpret_cast(p_b._data._mem); + Array sum; + int asize = array_a.size(); + int bsize = array_b.size(); + sum.resize(asize + bsize); + for (int i = 0; i < asize; i++) { + sum[i] = array_a[i]; + } + for (int i = 0; i < bsize; i++) { + sum[i + asize] = array_b[i]; + } + _RETURN(sum); + } + + DEFAULT_OP_NUM(math, OP_ADD, INT, +, _int); + DEFAULT_OP_NUM(math, OP_ADD, REAL, +, _real); + DEFAULT_OP_STR(math, OP_ADD, STRING, +, String); + DEFAULT_OP_LOCALMEM(math, OP_ADD, VECTOR2I, +, Vector2i); + DEFAULT_OP_LOCALMEM(math, OP_ADD, COLOR, +, Color); + + DEFAULT_OP_ARRAY_ADD(math, OP_ADD, POOL_BYTE_ARRAY, uint8_t); + DEFAULT_OP_ARRAY_ADD(math, OP_ADD, POOL_INT_ARRAY, int); + DEFAULT_OP_ARRAY_ADD(math, OP_ADD, POOL_REAL_ARRAY, real_t); + DEFAULT_OP_ARRAY_ADD(math, OP_ADD, POOL_STRING_ARRAY, String); + DEFAULT_OP_ARRAY_ADD(math, OP_ADD, POOL_VECTOR2I_ARRAY, Vector2i); + DEFAULT_OP_ARRAY_ADD(math, OP_ADD, POOL_COLOR_ARRAY, Color); + + CASE_TYPE(math, OP_ADD, NIL) + CASE_TYPE(math, OP_ADD, BOOL) + CASE_TYPE(math, OP_ADD, RECT2I) + CASE_TYPE(math, OP_ADD, OBJECT) + CASE_TYPE(math, OP_ADD, DICTIONARY) + CASE_TYPE(math, OP_ADD, STRING_NAME) + _RETURN_FAIL; + } + + SWITCH_OP(math, OP_SUBTRACT, p_a.type) { + DEFAULT_OP_NUM(math, OP_SUBTRACT, INT, -, _int); + DEFAULT_OP_NUM(math, OP_SUBTRACT, REAL, -, _real); + DEFAULT_OP_LOCALMEM(math, OP_SUBTRACT, VECTOR2I, -, Vector2i); + DEFAULT_OP_LOCALMEM(math, OP_SUBTRACT, COLOR, -, Color); + + CASE_TYPE(math, OP_SUBTRACT, NIL) + CASE_TYPE(math, OP_SUBTRACT, BOOL) + CASE_TYPE(math, OP_SUBTRACT, STRING) + CASE_TYPE(math, OP_SUBTRACT, RECT2I) + CASE_TYPE(math, OP_SUBTRACT, OBJECT) + CASE_TYPE(math, OP_SUBTRACT, STRING_NAME) + CASE_TYPE(math, OP_SUBTRACT, DICTIONARY) + CASE_TYPE(math, OP_SUBTRACT, ARRAY) + CASE_TYPE(math, OP_SUBTRACT, POOL_BYTE_ARRAY); + CASE_TYPE(math, OP_SUBTRACT, POOL_INT_ARRAY); + CASE_TYPE(math, OP_SUBTRACT, POOL_REAL_ARRAY); + CASE_TYPE(math, OP_SUBTRACT, POOL_STRING_ARRAY); + CASE_TYPE(math, OP_SUBTRACT, POOL_VECTOR2I_ARRAY); + CASE_TYPE(math, OP_SUBTRACT, POOL_COLOR_ARRAY); + _RETURN_FAIL; + } + + SWITCH_OP(math, OP_MULTIPLY, p_a.type) { + DEFAULT_OP_NUM_VEC(math, OP_MULTIPLY, INT, *, _int); + DEFAULT_OP_NUM_VEC(math, OP_MULTIPLY, REAL, *, _real); + DEFAULT_OP_LOCALMEM_NUM(math, OP_MULTIPLY, VECTOR2I, *, Vector2i); + DEFAULT_OP_LOCALMEM_NUM(math, OP_MULTIPLY, COLOR, *, Color); + + CASE_TYPE(math, OP_MULTIPLY, NIL) + CASE_TYPE(math, OP_MULTIPLY, BOOL) + CASE_TYPE(math, OP_MULTIPLY, STRING) + CASE_TYPE(math, OP_MULTIPLY, RECT2I) + CASE_TYPE(math, OP_MULTIPLY, OBJECT) + CASE_TYPE(math, OP_MULTIPLY, STRING_NAME) + CASE_TYPE(math, OP_MULTIPLY, DICTIONARY) + CASE_TYPE(math, OP_MULTIPLY, ARRAY) + CASE_TYPE(math, OP_MULTIPLY, POOL_BYTE_ARRAY); + CASE_TYPE(math, OP_MULTIPLY, POOL_INT_ARRAY); + CASE_TYPE(math, OP_MULTIPLY, POOL_REAL_ARRAY); + CASE_TYPE(math, OP_MULTIPLY, POOL_STRING_ARRAY); + CASE_TYPE(math, OP_MULTIPLY, POOL_VECTOR2I_ARRAY); + CASE_TYPE(math, OP_MULTIPLY, POOL_COLOR_ARRAY); + _RETURN_FAIL; + } + + SWITCH_OP(math, OP_DIVIDE, p_a.type) { + DEFAULT_OP_NUM_DIV(math, OP_DIVIDE, INT, _int); + DEFAULT_OP_NUM_DIV(math, OP_DIVIDE, REAL, _real); + DEFAULT_OP_LOCALMEM_NUM(math, OP_DIVIDE, VECTOR2I, /, Vector2i); + DEFAULT_OP_LOCALMEM_NUM(math, OP_DIVIDE, COLOR, /, Color); + + CASE_TYPE(math, OP_DIVIDE, NIL) + CASE_TYPE(math, OP_DIVIDE, BOOL) + CASE_TYPE(math, OP_DIVIDE, STRING) + CASE_TYPE(math, OP_DIVIDE, RECT2I) + CASE_TYPE(math, OP_DIVIDE, OBJECT) + CASE_TYPE(math, OP_DIVIDE, STRING_NAME) + CASE_TYPE(math, OP_DIVIDE, DICTIONARY) + CASE_TYPE(math, OP_DIVIDE, ARRAY) + CASE_TYPE(math, OP_DIVIDE, POOL_BYTE_ARRAY); + CASE_TYPE(math, OP_DIVIDE, POOL_INT_ARRAY); + CASE_TYPE(math, OP_DIVIDE, POOL_REAL_ARRAY); + CASE_TYPE(math, OP_DIVIDE, POOL_STRING_ARRAY); + CASE_TYPE(math, OP_DIVIDE, POOL_VECTOR2I_ARRAY); + CASE_TYPE(math, OP_DIVIDE, POOL_COLOR_ARRAY); + _RETURN_FAIL; + } + + SWITCH_OP(math, OP_POSITIVE, p_a.type) { + DEFAULT_OP_NUM_POS(math, OP_POSITIVE, INT, _int); + DEFAULT_OP_NUM_POS(math, OP_POSITIVE, REAL, _real); + DEFAULT_OP_LOCALMEM_POS(math, OP_POSITIVE, VECTOR2I, Vector2i); + + CASE_TYPE(math, OP_POSITIVE, NIL) + CASE_TYPE(math, OP_POSITIVE, BOOL) + CASE_TYPE(math, OP_POSITIVE, STRING) + CASE_TYPE(math, OP_POSITIVE, RECT2I) + CASE_TYPE(math, OP_POSITIVE, COLOR) + CASE_TYPE(math, OP_POSITIVE, OBJECT) + CASE_TYPE(math, OP_POSITIVE, STRING_NAME) + CASE_TYPE(math, OP_POSITIVE, DICTIONARY) + CASE_TYPE(math, OP_POSITIVE, ARRAY) + CASE_TYPE(math, OP_POSITIVE, POOL_BYTE_ARRAY) + CASE_TYPE(math, OP_POSITIVE, POOL_INT_ARRAY) + CASE_TYPE(math, OP_POSITIVE, POOL_REAL_ARRAY) + CASE_TYPE(math, OP_POSITIVE, POOL_STRING_ARRAY) + CASE_TYPE(math, OP_POSITIVE, POOL_VECTOR2I_ARRAY) + CASE_TYPE(math, OP_POSITIVE, POOL_COLOR_ARRAY) + _RETURN_FAIL; + } + + SWITCH_OP(math, OP_NEGATE, p_a.type) { + DEFAULT_OP_NUM_NEG(math, OP_NEGATE, INT, _int); + DEFAULT_OP_NUM_NEG(math, OP_NEGATE, REAL, _real); + + DEFAULT_OP_LOCALMEM_NEG(math, OP_NEGATE, VECTOR2I, Vector2i); + DEFAULT_OP_LOCALMEM_NEG(math, OP_NEGATE, COLOR, Color); + + CASE_TYPE(math, OP_NEGATE, NIL) + CASE_TYPE(math, OP_NEGATE, BOOL) + CASE_TYPE(math, OP_NEGATE, STRING) + CASE_TYPE(math, OP_NEGATE, RECT2I) + CASE_TYPE(math, OP_NEGATE, OBJECT) + CASE_TYPE(math, OP_NEGATE, STRING_NAME) + CASE_TYPE(math, OP_NEGATE, DICTIONARY) + CASE_TYPE(math, OP_NEGATE, ARRAY) + CASE_TYPE(math, OP_NEGATE, POOL_BYTE_ARRAY) + CASE_TYPE(math, OP_NEGATE, POOL_INT_ARRAY) + CASE_TYPE(math, OP_NEGATE, POOL_REAL_ARRAY) + CASE_TYPE(math, OP_NEGATE, POOL_STRING_ARRAY) + CASE_TYPE(math, OP_NEGATE, POOL_VECTOR2I_ARRAY) + CASE_TYPE(math, OP_NEGATE, POOL_COLOR_ARRAY) + _RETURN_FAIL; + } + + SWITCH_OP(math, OP_MODULE, p_a.type) { + CASE_TYPE(math, OP_MODULE, INT) { + if (p_b.type != INT) + _RETURN_FAIL; +#ifdef DEBUG_ENABLED + if (p_b._data._int == 0) { + r_valid = false; + _RETURN("Division By Zero"); + } +#endif + _RETURN(p_a._data._int % p_b._data._int); + } + + CASE_TYPE(math, OP_MODULE, STRING) { + const String *format = reinterpret_cast(p_a._data._mem); + + String result; + bool error; + if (p_b.type == ARRAY) { + // e.g. "frog %s %d" % ["fish", 12] + const Array *args = reinterpret_cast(p_b._data._mem); + result = args->sprintf(*format, &error); + } else { + // e.g. "frog %d" % 12 + Array args; + args.push_back(p_b); + result = args.sprintf(*format, &error); + } + r_valid = !error; + _RETURN(result); + } + + CASE_TYPE(math, OP_MODULE, NIL) + CASE_TYPE(math, OP_MODULE, BOOL) + CASE_TYPE(math, OP_MODULE, REAL) + CASE_TYPE(math, OP_MODULE, RECT2I) + CASE_TYPE(math, OP_MODULE, VECTOR2I) + CASE_TYPE(math, OP_MODULE, COLOR) + CASE_TYPE(math, OP_MODULE, OBJECT) + CASE_TYPE(math, OP_MODULE, STRING_NAME) + CASE_TYPE(math, OP_MODULE, DICTIONARY) + CASE_TYPE(math, OP_MODULE, ARRAY) + CASE_TYPE(math, OP_MODULE, POOL_BYTE_ARRAY) + CASE_TYPE(math, OP_MODULE, POOL_INT_ARRAY) + CASE_TYPE(math, OP_MODULE, POOL_REAL_ARRAY) + CASE_TYPE(math, OP_MODULE, POOL_STRING_ARRAY) + CASE_TYPE(math, OP_MODULE, POOL_VECTOR2I_ARRAY) + CASE_TYPE(math, OP_MODULE, POOL_COLOR_ARRAY) + _RETURN_FAIL; + } + + SWITCH_OP(math, OP_STRING_CONCAT, p_a.type) { + CASE_TYPE_ALL(math, OP_STRING_CONCAT) + + _RETURN(p_a.operator String() + p_b.operator String()); + } + + SWITCH_OP(math, OP_SHIFT_LEFT, p_a.type) { + CASE_TYPE(math, OP_SHIFT_LEFT, INT) { + if (p_b.type != INT) + _RETURN_FAIL; + if (p_b._data._int < 0 || p_b._data._int >= 64) + _RETURN_FAIL; + _RETURN(p_a._data._int << p_b._data._int); + } + + CASE_TYPE_ALL_BUT_INT(math, OP_SHIFT_LEFT) + _RETURN_FAIL; + } + + SWITCH_OP(math, OP_SHIFT_RIGHT, p_a.type) { + CASE_TYPE(math, OP_SHIFT_RIGHT, INT) { + if (p_b.type != INT) + _RETURN_FAIL; + if (p_b._data._int < 0 || p_b._data._int >= 64) + _RETURN_FAIL; + _RETURN(p_a._data._int >> p_b._data._int); + } + + CASE_TYPE_ALL_BUT_INT(math, OP_SHIFT_RIGHT) + _RETURN_FAIL; + } + + SWITCH_OP(math, OP_BIT_AND, p_a.type) { + CASE_TYPE(math, OP_BIT_AND, INT) { + if (p_b.type != INT) + _RETURN_FAIL; + _RETURN(p_a._data._int & p_b._data._int); + } + + CASE_TYPE_ALL_BUT_INT(math, OP_BIT_AND) + _RETURN_FAIL; + } + + SWITCH_OP(math, OP_BIT_OR, p_a.type) { + CASE_TYPE(math, OP_BIT_OR, INT) { + if (p_b.type != INT) + _RETURN_FAIL; + _RETURN(p_a._data._int | p_b._data._int); + } + + CASE_TYPE_ALL_BUT_INT(math, OP_BIT_OR) + _RETURN_FAIL; + } + + SWITCH_OP(math, OP_BIT_XOR, p_a.type) { + CASE_TYPE(math, OP_BIT_XOR, INT) { + if (p_b.type != INT) + _RETURN_FAIL; + _RETURN(p_a._data._int ^ p_b._data._int); + } + + CASE_TYPE_ALL_BUT_INT(math, OP_BIT_XOR) + _RETURN_FAIL; + } + + SWITCH_OP(math, OP_BIT_NEGATE, p_a.type) { + CASE_TYPE(math, OP_BIT_NEGATE, INT) { + _RETURN(~p_a._data._int); + } + + CASE_TYPE_ALL_BUT_INT(math, OP_BIT_NEGATE) + _RETURN_FAIL; + } + + SWITCH_OP(math, OP_AND, p_a.type) { + CASE_TYPE_ALL(math, OP_AND) { + bool l = p_a.booleanize(); + bool r = p_b.booleanize(); + + _RETURN(l && r); + } + } + + SWITCH_OP(math, OP_OR, p_a.type) { + CASE_TYPE_ALL(math, OP_OR) { + bool l = p_a.booleanize(); + bool r = p_b.booleanize(); + + _RETURN(l || r); + } + } + + SWITCH_OP(math, OP_XOR, p_a.type) { + CASE_TYPE_ALL(math, OP_XOR) { + bool l = p_a.booleanize(); + bool r = p_b.booleanize(); + + _RETURN((l || r) && !(l && r)); + } + } + + SWITCH_OP(math, OP_NOT, p_a.type) { + CASE_TYPE_ALL(math, OP_NOT) { + bool l = p_a.booleanize(); + _RETURN(!l); + } + } + + SWITCH_OP(math, OP_IN, p_a.type) { + CASE_TYPE_ALL(math, OP_IN) + _RETURN(p_b.in(p_a, &r_valid)); + } + } +} + +void Variant::set_named(const StringName &p_index, const Variant &p_value, bool *r_valid) { + bool valid = false; + switch (type) { + case RECT2I: { + if (p_value.type == Variant::VECTOR2I) { + Rect2i *v = reinterpret_cast(_data._mem); + //scalar name + if (p_index == CoreStringNames::singleton->position) { + v->position = *reinterpret_cast(p_value._data._mem); + valid = true; + } else if (p_index == CoreStringNames::singleton->size) { + v->size = *reinterpret_cast(p_value._data._mem); + valid = true; + } else if (p_index == CoreStringNames::singleton->end) { + v->size = *reinterpret_cast(p_value._data._mem) - v->position; + valid = true; + } + } + } break; + case VECTOR2I: { + if (p_value.type == Variant::INT) { + Vector2i *v = reinterpret_cast(_data._mem); + if (p_index == CoreStringNames::singleton->x) { + v->x = p_value._data._int; + valid = true; + } else if (p_index == CoreStringNames::singleton->y) { + v->y = p_value._data._int; + valid = true; + } + } else if (p_value.type == Variant::REAL) { + Vector2i *v = reinterpret_cast(_data._mem); + if (p_index == CoreStringNames::singleton->x) { + v->x = static_cast(p_value._data._real); + valid = true; + } else if (p_index == CoreStringNames::singleton->y) { + v->y = static_cast(p_value._data._real); + valid = true; + } + } + + } break; + case COLOR: { + if (p_value.type == Variant::INT) { + Color *v = reinterpret_cast(_data._mem); + if (p_index == CoreStringNames::singleton->r) { + v->r = p_value._data._int; + valid = true; + } else if (p_index == CoreStringNames::singleton->g) { + v->g = p_value._data._int; + valid = true; + } else if (p_index == CoreStringNames::singleton->b) { + v->b = p_value._data._int; + valid = true; + } else if (p_index == CoreStringNames::singleton->a) { + v->a = p_value._data._int; + valid = true; + } else if (p_index == CoreStringNames::singleton->r8) { + v->r = p_value._data._int / 255.0; + valid = true; + } else if (p_index == CoreStringNames::singleton->g8) { + v->g = p_value._data._int / 255.0; + valid = true; + } else if (p_index == CoreStringNames::singleton->b8) { + v->b = p_value._data._int / 255.0; + valid = true; + } else if (p_index == CoreStringNames::singleton->a8) { + v->a = p_value._data._int / 255.0; + valid = true; + } else if (p_index == CoreStringNames::singleton->h) { + v->set_hsv(p_value._data._int, v->get_s(), v->get_v(), v->a); + valid = true; + } else if (p_index == CoreStringNames::singleton->s) { + v->set_hsv(v->get_h(), p_value._data._int, v->get_v(), v->a); + valid = true; + } else if (p_index == CoreStringNames::singleton->v) { + v->set_hsv(v->get_h(), v->get_s(), p_value._data._int, v->a); + valid = true; + } + } else if (p_value.type == Variant::REAL) { + Color *v = reinterpret_cast(_data._mem); + if (p_index == CoreStringNames::singleton->r) { + v->r = p_value._data._real; + valid = true; + } else if (p_index == CoreStringNames::singleton->g) { + v->g = p_value._data._real; + valid = true; + } else if (p_index == CoreStringNames::singleton->b) { + v->b = p_value._data._real; + valid = true; + } else if (p_index == CoreStringNames::singleton->a) { + v->a = p_value._data._real; + valid = true; + } else if (p_index == CoreStringNames::singleton->r8) { + v->r = p_value._data._real / 255.0; + valid = true; + } else if (p_index == CoreStringNames::singleton->g8) { + v->g = p_value._data._real / 255.0; + valid = true; + } else if (p_index == CoreStringNames::singleton->b8) { + v->b = p_value._data._real / 255.0; + valid = true; + } else if (p_index == CoreStringNames::singleton->a8) { + v->a = p_value._data._real / 255.0; + valid = true; + } else if (p_index == CoreStringNames::singleton->h) { + v->set_hsv(p_value._data._real, v->get_s(), v->get_v(), v->a); + valid = true; + } else if (p_index == CoreStringNames::singleton->s) { + v->set_hsv(v->get_h(), p_value._data._real, v->get_v(), v->a); + valid = true; + } else if (p_index == CoreStringNames::singleton->v) { + v->set_hsv(v->get_h(), v->get_s(), p_value._data._real, v->a); + valid = true; + } + } + } break; + case OBJECT: { + Object *obj = _OBJ_PTR(*this); + if (unlikely(!obj)) { +#ifdef DEBUG_ENABLED + if (_get_obj().rc) { + ERR_PRINT("Attempted set on a deleted object."); + } +#endif + break; + } + obj->set(p_index, p_value, &valid); + + } break; + default: { + set(p_index.operator String(), p_value, &valid); + } break; + } + + if (r_valid) { + *r_valid = valid; + } +} + +Variant Variant::get_named(const StringName &p_index, bool *r_valid) const { + if (r_valid) { + *r_valid = true; + } + switch (type) { + case RECT2I: { + const Rect2i *v = reinterpret_cast(_data._mem); + //scalar name + if (p_index == CoreStringNames::singleton->position) { + return v->position; + } else if (p_index == CoreStringNames::singleton->size) { + return v->size; + } else if (p_index == CoreStringNames::singleton->end) { + return v->size + v->position; + } + } break; + case VECTOR2I: { + const Vector2i *v = reinterpret_cast(_data._mem); + if (p_index == CoreStringNames::singleton->x) { + return v->x; + } else if (p_index == CoreStringNames::singleton->y) { + return v->y; + } + + } break; + case COLOR: { + const Color *v = reinterpret_cast(_data._mem); + if (p_index == CoreStringNames::singleton->r) { + return v->r; + } else if (p_index == CoreStringNames::singleton->g) { + return v->g; + } else if (p_index == CoreStringNames::singleton->b) { + return v->b; + } else if (p_index == CoreStringNames::singleton->a) { + return v->a; + } else if (p_index == CoreStringNames::singleton->r8) { + return int(Math::round(v->r * 255.0)); + } else if (p_index == CoreStringNames::singleton->g8) { + return int(Math::round(v->g * 255.0)); + } else if (p_index == CoreStringNames::singleton->b8) { + return int(Math::round(v->b * 255.0)); + } else if (p_index == CoreStringNames::singleton->a8) { + return int(Math::round(v->a * 255.0)); + } else if (p_index == CoreStringNames::singleton->h) { + return v->get_h(); + } else if (p_index == CoreStringNames::singleton->s) { + return v->get_s(); + } else if (p_index == CoreStringNames::singleton->v) { + return v->get_v(); + } + } break; + case OBJECT: { + Object *obj = _OBJ_PTR(*this); + if (unlikely(!obj)) { + if (r_valid) { + *r_valid = false; + } +#ifdef DEBUG_ENABLED + if (_get_obj().rc) { + ERR_PRINT("Attempted get on a deleted object."); + } +#endif + return Variant(); + } + + return obj->get(p_index, r_valid); + + } break; + case DICTIONARY: { + const Dictionary *dic = reinterpret_cast(_data._mem); + const Variant *res = dic->getptr(p_index); + if (!res) { + // Backwards compatibility for before variants supported stringnames. + const Variant *res2 = dic->getptr(p_index.operator String()); + + if (res2) { + if (r_valid) { + *r_valid = true; + } + return *res2; + } + } else { + if (r_valid) { + *r_valid = true; + } + return *res; + } + } break; + default: { + return get(p_index.operator String(), r_valid); + } + } + + if (r_valid) { + *r_valid = false; + } + return Variant(); +} + +#define DEFAULT_OP_ARRAY_CMD(m_name, m_type, skip_test, cmd) \ + case m_name: { \ + skip_test; \ + \ + if (p_index.get_type() == Variant::INT || p_index.get_type() == Variant::REAL) { \ + int index = p_index; \ + m_type *arr = reinterpret_cast(_data._mem); \ + \ + if (index < 0) \ + index += arr->size(); \ + if (index >= 0 && index < arr->size()) { \ + valid = true; \ + cmd; \ + } \ + } \ + } break; + +// clang-format 14 wants to add a space after the last return, +// and clang-format 15 removes it... +/* clang-format off */ +#define DEFAULT_OP_DVECTOR_SET(m_name, dv_type, skip_cond) \ + DEFAULT_OP_ARRAY_CMD(m_name, PoolVector, if (skip_cond) return;, arr->set(index, p_value); return) +/* clang-format on */ + +#define DEFAULT_OP_DVECTOR_GET(m_name, dv_type) \ + DEFAULT_OP_ARRAY_CMD(m_name, const PoolVector, ;, return arr->get(index)) + +void Variant::set(const Variant &p_index, const Variant &p_value, bool *r_valid) { + static bool _dummy = false; + + bool &valid = r_valid ? *r_valid : _dummy; + valid = false; + + switch (type) { + case NIL: { + return; + } break; + case BOOL: { + return; + } break; + case INT: { + return; + } break; + case REAL: { + return; + } break; + case STRING: { + if (p_index.type != Variant::INT && p_index.type != Variant::REAL) { + return; + } + + int idx = p_index; + String *str = reinterpret_cast(_data._mem); + int len = str->length(); + if (idx < 0) { + idx += len; + } + if (idx < 0 || idx >= len) { + return; + } + + String chr; + if (p_value.type == Variant::INT || p_value.type == Variant::REAL) { + chr = String::chr(p_value); + } else if (p_value.type == Variant::STRING) { + chr = p_value; + } else { + return; + } + + *str = str->substr(0, idx) + chr + str->substr(idx + 1, len); + valid = true; + return; + + } break; + case RECT2I: { + if (p_value.type == Variant::VECTOR2I) { + if (p_index.get_type() == Variant::STRING) { + //scalar name + + const String *str = reinterpret_cast(p_index._data._mem); + Rect2i *v = reinterpret_cast(_data._mem); + if (*str == "position") { + valid = true; + v->position = p_value; + return; + } else if (*str == "size") { + valid = true; + v->size = p_value; + return; + } else if (*str == "end") { + valid = true; + //TODO fix + v->size = Vector2i(p_value) - v->position; + return; + } + } else if (p_index.get_type() == Variant::STRING_NAME) { + //scalar name + + Rect2i *v = reinterpret_cast(_data._mem); + if (p_index == CoreStringNames::singleton->position) { + valid = true; + v->position = p_value; + return; + } else if (p_index == CoreStringNames::singleton->size) { + valid = true; + v->size = p_value; + return; + } else if (p_index == CoreStringNames::singleton->end) { + valid = true; + v->size = Vector2i(p_value) - v->position; + return; + } + } + } else { + return; + } + } break; + case VECTOR2I: { + if (p_value.type != Variant::INT && p_value.type != Variant::REAL) { + return; + } + + if (p_index.get_type() == Variant::INT || p_index.get_type() == Variant::REAL) { + // scalar index + int idx = p_index; + + if (idx < 0) { + idx += 2; + } + if (idx >= 0 && idx < 2) { + Vector2i *v = reinterpret_cast(_data._mem); + valid = true; + (*v)[idx] = p_value; + return; + } + } else if (p_index.get_type() == Variant::STRING) { + //scalar name + + const String *str = reinterpret_cast(p_index._data._mem); + Vector2i *v = reinterpret_cast(_data._mem); + if (*str == "x") { + valid = true; + v->x = p_value; + return; + } else if (*str == "y") { + valid = true; + v->y = p_value; + return; + } + } else if (p_index.get_type() == Variant::STRING_NAME) { + //scalar name + + Vector2i *v = reinterpret_cast(_data._mem); + if (p_index == CoreStringNames::singleton->x) { + valid = true; + v->x = p_value; + return; + } else if (p_index == CoreStringNames::singleton->y) { + valid = true; + v->y = p_value; + return; + } + } + + } break; //6 + case COLOR: { + if (p_value.type != Variant::INT && p_value.type != Variant::REAL) { + return; + } + + if (p_index.get_type() == Variant::STRING) { + const String *str = reinterpret_cast(p_index._data._mem); + Color *v = reinterpret_cast(_data._mem); + if (*str == "r") { + valid = true; + v->r = p_value; + return; + } else if (*str == "g") { + valid = true; + v->g = p_value; + return; + } else if (*str == "b") { + valid = true; + v->b = p_value; + return; + } else if (*str == "a") { + valid = true; + v->a = p_value; + return; + } else if (*str == "h") { + valid = true; + v->set_hsv(p_value, v->get_s(), v->get_v(), v->a); + return; + } else if (*str == "s") { + valid = true; + v->set_hsv(v->get_h(), p_value, v->get_v(), v->a); + return; + } else if (*str == "v") { + valid = true; + v->set_hsv(v->get_h(), v->get_s(), p_value, v->a); + return; + } else if (*str == "r8") { + valid = true; + v->r = float(p_value) / 255.0; + return; + } else if (*str == "g8") { + valid = true; + v->g = float(p_value) / 255.0; + return; + } else if (*str == "b8") { + valid = true; + v->b = float(p_value) / 255.0; + return; + } else if (*str == "a8") { + valid = true; + v->a = float(p_value) / 255.0; + return; + } + } else if (p_index.get_type() == Variant::INT) { + int idx = p_index; + if (idx < 0) { + idx += 4; + } + if (idx >= 0 && idx < 4) { + Color *v = reinterpret_cast(_data._mem); + (*v)[idx] = p_value; + valid = true; + } + } else if (p_index.get_type() == Variant::STRING_NAME) { + Color *v = reinterpret_cast(_data._mem); + if (p_index == CoreStringNames::singleton->r) { + valid = true; + v->r = p_value; + return; + } else if (p_index == CoreStringNames::singleton->g) { + valid = true; + v->g = p_value; + return; + } else if (p_index == CoreStringNames::singleton->b) { + valid = true; + v->b = p_value; + return; + } else if (p_index == CoreStringNames::singleton->a) { + valid = true; + v->a = p_value; + return; + } else if (p_index == CoreStringNames::singleton->h) { + valid = true; + v->set_hsv(p_value, v->get_s(), v->get_v(), v->a); + return; + } else if (p_index == CoreStringNames::singleton->s) { + valid = true; + v->set_hsv(v->get_h(), p_value, v->get_v(), v->a); + return; + } else if (p_index == CoreStringNames::singleton->v) { + valid = true; + v->set_hsv(v->get_h(), v->get_s(), p_value, v->a); + return; + } else if (p_index == CoreStringNames::singleton->r8) { + valid = true; + v->r = float(p_value) / 255.0; + return; + } else if (p_index == CoreStringNames::singleton->g8) { + valid = true; + v->g = float(p_value) / 255.0; + return; + } else if (p_index == CoreStringNames::singleton->b8) { + valid = true; + v->b = float(p_value) / 255.0; + return; + } else if (p_index == CoreStringNames::singleton->a8) { + valid = true; + v->a = float(p_value) / 255.0; + return; + } + } + + } break; + case OBJECT: { + Object *obj = _OBJ_PTR(*this); + if (unlikely(!obj)) { + valid = false; +#ifdef DEBUG_ENABLED + if (_get_obj().rc) { + ERR_PRINT("Attempted set on a deleted object."); + } +#endif + return; + } + + obj->set(p_index, p_value, r_valid); + return; + } break; + case STRING_NAME: { + } break; + case DICTIONARY: { + Dictionary *dic = reinterpret_cast(_data._mem); + dic->operator[](p_index) = p_value; + valid = true; //always valid, i guess? should this really be ok? + return; + } break; + // clang-format 14 wants to add a space after the last return, + // and clang-format 15 removes it... + /* clang-format off */ + DEFAULT_OP_ARRAY_CMD(ARRAY, Array, ;, (*arr)[index] = p_value; return) // 20 + /* clang-format on */ + DEFAULT_OP_DVECTOR_SET(POOL_BYTE_ARRAY, uint8_t, p_value.type != Variant::REAL && p_value.type != Variant::INT) + DEFAULT_OP_DVECTOR_SET(POOL_INT_ARRAY, int, p_value.type != Variant::REAL && p_value.type != Variant::INT) + DEFAULT_OP_DVECTOR_SET(POOL_REAL_ARRAY, real_t, p_value.type != Variant::REAL && p_value.type != Variant::INT) + DEFAULT_OP_DVECTOR_SET(POOL_STRING_ARRAY, String, p_value.type != Variant::STRING) + DEFAULT_OP_DVECTOR_SET(POOL_VECTOR2I_ARRAY, Vector2i, p_value.type != Variant::VECTOR2I) // 25 + DEFAULT_OP_DVECTOR_SET(POOL_COLOR_ARRAY, Color, p_value.type != Variant::COLOR) + default: + return; + } +} + +Variant Variant::get(const Variant &p_index, bool *r_valid) const { + static bool _dummy = false; + + bool &valid = r_valid ? *r_valid : _dummy; + + valid = false; + + switch (type) { + case NIL: { + return Variant(); + } break; + case BOOL: { + return Variant(); + } break; + case INT: { + return Variant(); + } break; + case REAL: { + return Variant(); + } break; + case STRING: { + if (p_index.get_type() == Variant::INT || p_index.get_type() == Variant::REAL) { + //string index + + int idx = p_index; + const String *str = reinterpret_cast(_data._mem); + if (idx < 0) { + idx += str->length(); + } + if (idx >= 0 && idx < str->length()) { + valid = true; + return str->substr(idx, 1); + } + } + + } break; + case RECT2I: { + if (p_index.get_type() == Variant::STRING) { + //scalar name + + const String *str = reinterpret_cast(p_index._data._mem); + const Rect2i *v = reinterpret_cast(_data._mem); + if (*str == "position") { + valid = true; + return v->position; + } else if (*str == "size") { + valid = true; + return v->size; + } else if (*str == "end") { + valid = true; + return v->size + v->position; + } + } else if (p_index.get_type() == Variant::STRING_NAME) { + //scalar name + + const Rect2i *v = reinterpret_cast(_data._mem); + if (p_index == CoreStringNames::singleton->position) { + valid = true; + return v->position; + } else if (p_index == CoreStringNames::singleton->size) { + valid = true; + return v->size; + } else if (p_index == CoreStringNames::singleton->end) { + valid = true; + return v->size + v->position; + } + } + } break; + case VECTOR2I: { + if (p_index.get_type() == Variant::INT || p_index.get_type() == Variant::REAL) { + // scalar index + int idx = p_index; + if (idx < 0) { + idx += 2; + } + if (idx >= 0 && idx < 2) { + const Vector2i *v = reinterpret_cast(_data._mem); + valid = true; + return (*v)[idx]; + } + } else if (p_index.get_type() == Variant::STRING) { + //scalar name + + const String *str = reinterpret_cast(p_index._data._mem); + const Vector2i *v = reinterpret_cast(_data._mem); + if (*str == "x") { + valid = true; + return v->x; + } else if (*str == "y") { + valid = true; + return v->y; + } + } else if (p_index.get_type() == Variant::STRING_NAME) { + //scalar name + + const Vector2i *v = reinterpret_cast(_data._mem); + if (p_index == CoreStringNames::singleton->x) { + valid = true; + return v->x; + } else if (p_index == CoreStringNames::singleton->y) { + valid = true; + return v->y; + } + } + + } break; // 6 + case COLOR: { + if (p_index.get_type() == Variant::STRING) { + const String *str = reinterpret_cast(p_index._data._mem); + const Color *v = reinterpret_cast(_data._mem); + if (*str == "r") { + valid = true; + return v->r; + } else if (*str == "g") { + valid = true; + return v->g; + } else if (*str == "b") { + valid = true; + return v->b; + } else if (*str == "a") { + valid = true; + return v->a; + } else if (*str == "h") { + valid = true; + return v->get_h(); + } else if (*str == "s") { + valid = true; + return v->get_s(); + } else if (*str == "v") { + valid = true; + return v->get_v(); + } else if (*str == "r8") { + valid = true; + return (int)Math::round(v->r * 255.0); + } else if (*str == "g8") { + valid = true; + return (int)Math::round(v->g * 255.0); + } else if (*str == "b8") { + valid = true; + return (int)Math::round(v->b * 255.0); + } else if (*str == "a8") { + valid = true; + return (int)Math::round(v->a * 255.0); + } + } else if (p_index.get_type() == Variant::INT) { + int idx = p_index; + if (idx < 0) { + idx += 4; + } + if (idx >= 0 && idx < 4) { + const Color *v = reinterpret_cast(_data._mem); + valid = true; + return (*v)[idx]; + } + } else if (p_index.get_type() == Variant::STRING) { + const Color *v = reinterpret_cast(_data._mem); + if (p_index == CoreStringNames::singleton->r) { + valid = true; + return v->r; + } else if (p_index == CoreStringNames::singleton->g) { + valid = true; + return v->g; + } else if (p_index == CoreStringNames::singleton->b) { + valid = true; + return v->b; + } else if (p_index == CoreStringNames::singleton->a) { + valid = true; + return v->a; + } else if (p_index == CoreStringNames::singleton->h) { + valid = true; + return v->get_h(); + } else if (p_index == CoreStringNames::singleton->s) { + valid = true; + return v->get_s(); + } else if (p_index == CoreStringNames::singleton->v) { + valid = true; + return v->get_v(); + } else if (p_index == CoreStringNames::singleton->r8) { + valid = true; + return (int)Math::round(v->r * 255.0); + } else if (p_index == CoreStringNames::singleton->g8) { + valid = true; + return (int)Math::round(v->g * 255.0); + } else if (p_index == CoreStringNames::singleton->b8) { + valid = true; + return (int)Math::round(v->b * 255.0); + } else if (p_index == CoreStringNames::singleton->a8) { + valid = true; + return (int)Math::round(v->a * 255.0); + } + } + + } break; + case OBJECT: { + Object *obj = _OBJ_PTR(*this); + if (unlikely(!obj)) { + valid = false; +#ifdef DEBUG_ENABLED + if (_get_obj().rc) { + ERR_PRINT("Attempted get on a deleted object."); + } +#endif + return Variant(); + } + + return obj->get(p_index, r_valid); + + } break; + case STRING_NAME: { + } break; + case DICTIONARY: { + const Dictionary *dic = reinterpret_cast(_data._mem); + const Variant *res = dic->getptr(p_index); + if (res) { + valid = true; + return *res; + } + } break; + DEFAULT_OP_ARRAY_CMD(ARRAY, const Array, ;, return (*arr)[index]) // 20 + DEFAULT_OP_DVECTOR_GET(POOL_BYTE_ARRAY, uint8_t) + DEFAULT_OP_DVECTOR_GET(POOL_INT_ARRAY, int) + DEFAULT_OP_DVECTOR_GET(POOL_REAL_ARRAY, real_t) + DEFAULT_OP_DVECTOR_GET(POOL_STRING_ARRAY, String) + DEFAULT_OP_DVECTOR_GET(POOL_VECTOR2I_ARRAY, Vector2i) + DEFAULT_OP_DVECTOR_GET(POOL_COLOR_ARRAY, Color) + default: + return Variant(); + } + + return Variant(); +} + +bool Variant::in(const Variant &p_index, bool *r_valid) const { + if (r_valid) { + *r_valid = true; + } + + switch (type) { + case STRING: { + if (p_index.get_type() == Variant::STRING) { + //string index + String idx = p_index; + const String *str = reinterpret_cast(_data._mem); + + return str->find(idx) != -1; + } + + } break; + case OBJECT: { + Object *obj = _OBJ_PTR(*this); + if (unlikely(!obj)) { + if (r_valid) { + *r_valid = false; + } +#ifdef DEBUG_ENABLED + if (_get_obj().rc) { + ERR_PRINT("Attempted 'in' on a deleted object."); + } +#endif + return false; + } + + bool result; + obj->get(p_index, &result); + return result; + } break; + case DICTIONARY: { + const Dictionary *dic = reinterpret_cast(_data._mem); + return dic->has(p_index); + + } break; // 20 + case ARRAY: { + const Array *arr = reinterpret_cast(_data._mem); + int l = arr->size(); + if (l) { + for (int i = 0; i < l; i++) { + if (evaluate(OP_EQUAL, (*arr)[i], p_index)) { + return true; + } + } + } + + return false; + + } break; + case POOL_BYTE_ARRAY: { + if (p_index.get_type() == Variant::INT || p_index.get_type() == Variant::REAL) { + int index = p_index; + const PoolVector *arr = reinterpret_cast *>(_data._mem); + int l = arr->size(); + if (l) { + PoolVector::Read r = arr->read(); + for (int i = 0; i < l; i++) { + if (r[i] == index) { + return true; + } + } + } + + return false; + } + + } break; + case POOL_INT_ARRAY: { + if (p_index.get_type() == Variant::INT || p_index.get_type() == Variant::REAL) { + int index = p_index; + const PoolVector *arr = reinterpret_cast *>(_data._mem); + int l = arr->size(); + if (l) { + PoolVector::Read r = arr->read(); + for (int i = 0; i < l; i++) { + if (r[i] == index) { + return true; + } + } + } + + return false; + } + } break; + case POOL_REAL_ARRAY: { + if (p_index.get_type() == Variant::INT || p_index.get_type() == Variant::REAL) { + real_t index = p_index; + const PoolVector *arr = reinterpret_cast *>(_data._mem); + int l = arr->size(); + if (l) { + PoolVector::Read r = arr->read(); + for (int i = 0; i < l; i++) { + if (r[i] == index) { + return true; + } + } + } + + return false; + } + + } break; + case POOL_STRING_ARRAY: { + if (p_index.get_type() == Variant::STRING) { + String index = p_index; + const PoolVector *arr = reinterpret_cast *>(_data._mem); + + int l = arr->size(); + if (l) { + PoolVector::Read r = arr->read(); + for (int i = 0; i < l; i++) { + if (r[i] == index) { + return true; + } + } + } + + return false; + } + + } break; //25 + case POOL_VECTOR2I_ARRAY: { + if (p_index.get_type() == Variant::VECTOR2I) { + Vector2i index = p_index; + const PoolVector *arr = reinterpret_cast *>(_data._mem); + + int l = arr->size(); + if (l) { + PoolVector::Read r = arr->read(); + for (int i = 0; i < l; i++) { + if (r[i] == index) { + return true; + } + } + } + + return false; + } + + } break; + case POOL_COLOR_ARRAY: { + if (p_index.get_type() == Variant::COLOR) { + Color index = p_index; + const PoolVector *arr = reinterpret_cast *>(_data._mem); + + int l = arr->size(); + if (l) { + PoolVector::Read r = arr->read(); + for (int i = 0; i < l; i++) { + if (r[i] == index) { + return true; + } + } + } + + return false; + } + } break; + default: { + } + } + + if (r_valid) { + *r_valid = false; + } + return false; +} + +bool Variant::iter_init(Variant &r_iter, bool &valid) const { + valid = true; + switch (type) { + case INT: { + r_iter = 0; + return _data._int > 0; + } break; + case REAL: { + r_iter = 0; + return _data._real > 0.0; + } break; + case VECTOR2I: { + int64_t from = reinterpret_cast(_data._mem)->x; + int64_t to = reinterpret_cast(_data._mem)->y; + + r_iter = from; + + return from < to; + } break; + case STRING: { + const String *str = reinterpret_cast(_data._mem); + if (str->empty()) { + return false; + } + r_iter = 0; + return true; + } break; + case DICTIONARY: { + const Dictionary *dic = reinterpret_cast(_data._mem); + if (dic->empty()) { + return false; + } + + const Variant *next = dic->next(nullptr); + r_iter = *next; + return true; + + } break; + case ARRAY: { + const Array *arr = reinterpret_cast(_data._mem); + if (arr->empty()) { + return false; + } + r_iter = 0; + return true; + } break; + case POOL_BYTE_ARRAY: { + const PoolVector *arr = reinterpret_cast *>(_data._mem); + if (arr->size() == 0) { + return false; + } + r_iter = 0; + return true; + + } break; + case POOL_INT_ARRAY: { + const PoolVector *arr = reinterpret_cast *>(_data._mem); + if (arr->size() == 0) { + return false; + } + r_iter = 0; + return true; + + } break; + case POOL_REAL_ARRAY: { + const PoolVector *arr = reinterpret_cast *>(_data._mem); + if (arr->size() == 0) { + return false; + } + r_iter = 0; + return true; + + } break; + case POOL_STRING_ARRAY: { + const PoolVector *arr = reinterpret_cast *>(_data._mem); + if (arr->size() == 0) { + return false; + } + r_iter = 0; + return true; + } break; + case POOL_VECTOR2I_ARRAY: { + const PoolVector *arr = reinterpret_cast *>(_data._mem); + if (arr->size() == 0) { + return false; + } + r_iter = 0; + return true; + } break; + case POOL_COLOR_ARRAY: { + const PoolVector *arr = reinterpret_cast *>(_data._mem); + if (arr->size() == 0) { + return false; + } + r_iter = 0; + return true; + + } break; + default: { + } + } + + valid = false; + return false; +} +bool Variant::iter_next(Variant &r_iter, bool &valid) const { + valid = true; + switch (type) { + case INT: { + int64_t idx = r_iter; + idx++; + if (idx >= _data._int) { + return false; + } + r_iter = idx; + return true; + } break; + case REAL: { + int64_t idx = r_iter; + idx++; + if (idx >= _data._real) { + return false; + } + r_iter = idx; + return true; + } break; + case VECTOR2I: { + int64_t to = reinterpret_cast(_data._mem)->y; + + int64_t idx = r_iter; + idx++; + + if (idx >= to) { + return false; + } + + r_iter = idx; + return true; + } break; + case STRING: { + const String *str = reinterpret_cast(_data._mem); + int idx = r_iter; + idx++; + if (idx >= str->length()) { + return false; + } + r_iter = idx; + return true; + } break; + case DICTIONARY: { + const Dictionary *dic = reinterpret_cast(_data._mem); + const Variant *next = dic->next(&r_iter); + if (!next) { + return false; + } + + r_iter = *next; + return true; + + } break; + case ARRAY: { + const Array *arr = reinterpret_cast(_data._mem); + int idx = r_iter; + idx++; + if (idx >= arr->size()) { + return false; + } + r_iter = idx; + return true; + } break; + case POOL_BYTE_ARRAY: { + const PoolVector *arr = reinterpret_cast *>(_data._mem); + int idx = r_iter; + idx++; + if (idx >= arr->size()) { + return false; + } + r_iter = idx; + return true; + + } break; + case POOL_INT_ARRAY: { + const PoolVector *arr = reinterpret_cast *>(_data._mem); + int idx = r_iter; + idx++; + if (idx >= arr->size()) { + return false; + } + r_iter = idx; + return true; + + } break; + case POOL_REAL_ARRAY: { + const PoolVector *arr = reinterpret_cast *>(_data._mem); + int idx = r_iter; + idx++; + if (idx >= arr->size()) { + return false; + } + r_iter = idx; + return true; + + } break; + case POOL_STRING_ARRAY: { + const PoolVector *arr = reinterpret_cast *>(_data._mem); + int idx = r_iter; + idx++; + if (idx >= arr->size()) { + return false; + } + r_iter = idx; + return true; + } break; + case POOL_VECTOR2I_ARRAY: { + const PoolVector *arr = reinterpret_cast *>(_data._mem); + int idx = r_iter; + idx++; + if (idx >= arr->size()) { + return false; + } + r_iter = idx; + return true; + } break; + case POOL_COLOR_ARRAY: { + const PoolVector *arr = reinterpret_cast *>(_data._mem); + int idx = r_iter; + idx++; + if (idx >= arr->size()) { + return false; + } + r_iter = idx; + return true; + } break; + default: { + } + } + + valid = false; + return false; +} + +Variant Variant::iter_get(const Variant &r_iter, bool &r_valid) const { + r_valid = true; + switch (type) { + case INT: { + return r_iter; + } break; + case REAL: { + return r_iter; + } break; + case VECTOR2I: { + return r_iter; + } break; + case STRING: { + const String *str = reinterpret_cast(_data._mem); + return str->substr(r_iter, 1); + } break; + case DICTIONARY: { + return r_iter; //iterator is the same as the key + + } break; + case ARRAY: { + const Array *arr = reinterpret_cast(_data._mem); + int idx = r_iter; +#ifdef DEBUG_ENABLED + if (idx < 0 || idx >= arr->size()) { + r_valid = false; + return Variant(); + } +#endif + return arr->get(idx); + } break; + case POOL_BYTE_ARRAY: { + const PoolVector *arr = reinterpret_cast *>(_data._mem); + int idx = r_iter; +#ifdef DEBUG_ENABLED + if (idx < 0 || idx >= arr->size()) { + r_valid = false; + return Variant(); + } +#endif + return arr->get(idx); + } break; + case POOL_INT_ARRAY: { + const PoolVector *arr = reinterpret_cast *>(_data._mem); + int idx = r_iter; +#ifdef DEBUG_ENABLED + if (idx < 0 || idx >= arr->size()) { + r_valid = false; + return Variant(); + } +#endif + return arr->get(idx); + } break; + case POOL_REAL_ARRAY: { + const PoolVector *arr = reinterpret_cast *>(_data._mem); + int idx = r_iter; +#ifdef DEBUG_ENABLED + if (idx < 0 || idx >= arr->size()) { + r_valid = false; + return Variant(); + } +#endif + return arr->get(idx); + } break; + case POOL_STRING_ARRAY: { + const PoolVector *arr = reinterpret_cast *>(_data._mem); + int idx = r_iter; +#ifdef DEBUG_ENABLED + if (idx < 0 || idx >= arr->size()) { + r_valid = false; + return Variant(); + } +#endif + return arr->get(idx); + } break; + case POOL_VECTOR2I_ARRAY: { + const PoolVector *arr = reinterpret_cast *>(_data._mem); + int idx = r_iter; +#ifdef DEBUG_ENABLED + if (idx < 0 || idx >= arr->size()) { + r_valid = false; + return Variant(); + } +#endif + return arr->get(idx); + } break; + case POOL_COLOR_ARRAY: { + const PoolVector *arr = reinterpret_cast *>(_data._mem); + int idx = r_iter; +#ifdef DEBUG_ENABLED + if (idx < 0 || idx >= arr->size()) { + r_valid = false; + return Variant(); + } +#endif + return arr->get(idx); + } break; + default: { + } + } + + r_valid = false; + return Variant(); +} + +Variant Variant::duplicate(bool deep) const { + switch (type) { + case OBJECT: { + /* breaks stuff :( + if (deep && !_get_obj().ref.is_null()) { + Ref resource = _get_obj().ref; + if (resource.is_valid()) { + return resource->duplicate(true); + } + } + */ + return *this; + } break; + case DICTIONARY: + return operator Dictionary().duplicate(deep); + case ARRAY: + return operator Array().duplicate(deep); + default: + return *this; + } +} + +void Variant::sub(const Variant &a, const Variant &b, Variant &r_dst) { + if (a.type != b.type) { + return; + } + + switch (a.type) { + case NIL: { + r_dst = Variant(); + } + return; + case INT: { + int64_t va = a._data._int; + int64_t vb = b._data._int; + r_dst = int(va - vb); + } + return; + case REAL: { + real_t ra = a._data._real; + real_t rb = b._data._real; + r_dst = ra - rb; + } + return; + case RECT2I: { + const Rect2i *ra = reinterpret_cast(a._data._mem); + const Rect2i *rb = reinterpret_cast(b._data._mem); + + int32_t vax = ra->position.x; + int32_t vay = ra->position.y; + int32_t vbx = ra->size.x; + int32_t vby = ra->size.y; + int32_t vcx = rb->position.x; + int32_t vcy = rb->position.y; + int32_t vdx = rb->size.x; + int32_t vdy = rb->size.y; + + r_dst = Rect2i(int32_t(vax - vbx), int32_t(vay - vby), int32_t(vcx - vdx), int32_t(vcy - vdy)); + } + return; + case VECTOR2I: { + int32_t vax = reinterpret_cast(a._data._mem)->x; + int32_t vbx = reinterpret_cast(b._data._mem)->x; + int32_t vay = reinterpret_cast(a._data._mem)->y; + int32_t vby = reinterpret_cast(b._data._mem)->y; + r_dst = Vector2i(int32_t(vax - vbx), int32_t(vay - vby)); + } + return; + case COLOR: { + const Color *ca = reinterpret_cast(a._data._mem); + const Color *cb = reinterpret_cast(b._data._mem); + float new_r = ca->r - cb->r; + float new_g = ca->g - cb->g; + float new_b = ca->b - cb->b; + float new_a = ca->a - cb->a; + new_r = new_r > 1.0 ? 1.0 : new_r; + new_g = new_g > 1.0 ? 1.0 : new_g; + new_b = new_b > 1.0 ? 1.0 : new_b; + new_a = new_a > 1.0 ? 1.0 : new_a; + r_dst = Color(new_r, new_g, new_b, new_a); + } + return; + default: { + r_dst = a; + } + return; + } +} + +void Variant::blend(const Variant &a, const Variant &b, float c, Variant &r_dst) { + if (a.type != b.type) { + if (a.is_num() && b.is_num()) { + real_t va = a; + real_t vb = b; + r_dst = va + vb * c; + } else { + r_dst = a; + } + return; + } + + switch (a.type) { + case NIL: { + r_dst = Variant(); + } + return; + case INT: { + int64_t va = a._data._int; + int64_t vb = b._data._int; + r_dst = int(va + vb * c + 0.5); + } + return; + case REAL: { + double ra = a._data._real; + double rb = b._data._real; + r_dst = ra + rb * c; + } + return; + case RECT2I: { + const Rect2i *ra = reinterpret_cast(a._data._mem); + const Rect2i *rb = reinterpret_cast(b._data._mem); + r_dst = Rect2i(ra->position + rb->position * c, ra->size + rb->size * c); + } + return; + case VECTOR2I: { + r_dst = *reinterpret_cast(a._data._mem) + *reinterpret_cast(b._data._mem) * c; + } + return; + case COLOR: { + const Color *ca = reinterpret_cast(a._data._mem); + const Color *cb = reinterpret_cast(b._data._mem); + float new_r = ca->r + cb->r * c; + float new_g = ca->g + cb->g * c; + float new_b = ca->b + cb->b * c; + float new_a = ca->a + cb->a * c; + new_r = new_r > 1.0 ? 1.0 : new_r; + new_g = new_g > 1.0 ? 1.0 : new_g; + new_b = new_b > 1.0 ? 1.0 : new_b; + new_a = new_a > 1.0 ? 1.0 : new_a; + r_dst = Color(new_r, new_g, new_b, new_a); + } + return; + default: { + r_dst = c < 0.5 ? a : b; + } + return; + } +} + +void Variant::interpolate(const Variant &a, const Variant &b, float c, Variant &r_dst) { + if (a.type != b.type) { + if (a.is_num() && b.is_num()) { + //not as efficient but.. + real_t va = a; + real_t vb = b; + r_dst = va + (vb - va) * c; + + } else { + r_dst = a; + } + return; + } + + switch (a.type) { + case NIL: { + r_dst = Variant(); + } + return; + case BOOL: { + r_dst = a; + } + return; + case INT: { + int64_t va = a._data._int; + int64_t vb = b._data._int; + r_dst = int(va + (vb - va) * c); + } + return; + case REAL: { + real_t va = a._data._real; + real_t vb = b._data._real; + r_dst = va + (vb - va) * c; + } + return; + case STRING: { + //this is pretty funny and bizarre, but artists like to use it for typewritter effects + String sa = *reinterpret_cast(a._data._mem); + String sb = *reinterpret_cast(b._data._mem); + String dst; + int sa_len = sa.length(); + int sb_len = sb.length(); + int csize = sa_len + (sb_len - sa_len) * c; + if (csize == 0) { + r_dst = ""; + return; + } + dst.resize(csize + 1); + dst[csize] = 0; + int split = csize / 2; + + for (int i = 0; i < csize; i++) { + CharType chr = ' '; + + if (i < split) { + if (i < sa.length()) { + chr = sa[i]; + } else if (i < sb.length()) { + chr = sb[i]; + } + + } else { + if (i < sb.length()) { + chr = sb[i]; + } else if (i < sa.length()) { + chr = sa[i]; + } + } + + dst[i] = chr; + } + + r_dst = dst; + } + return; + case RECT2I: { + r_dst = Rect2i(reinterpret_cast(a._data._mem)->position.linear_interpolate(reinterpret_cast(b._data._mem)->position, c), reinterpret_cast(a._data._mem)->size.linear_interpolate(reinterpret_cast(b._data._mem)->size, c)); + } + return; + case VECTOR2I: { + r_dst = reinterpret_cast(a._data._mem)->linear_interpolate(*reinterpret_cast(b._data._mem), c); + } + return; + case COLOR: { + r_dst = reinterpret_cast(a._data._mem)->linear_interpolate(*reinterpret_cast(b._data._mem), c); + } + return; + case OBJECT: { + r_dst = a; + } + return; + case STRING_NAME: { + r_dst = a; + } + return; + case DICTIONARY: { + } + return; + case ARRAY: { + r_dst = a; + } + return; + case POOL_BYTE_ARRAY: { + r_dst = a; + } + return; + case POOL_INT_ARRAY: { + const PoolVector *arr_a = reinterpret_cast *>(a._data._mem); + const PoolVector *arr_b = reinterpret_cast *>(b._data._mem); + int sz = arr_a->size(); + if (sz == 0 || arr_b->size() != sz) { + r_dst = a; + } else { + PoolVector v; + v.resize(sz); + { + PoolVector::Write vw = v.write(); + PoolVector::Read ar = arr_a->read(); + PoolVector::Read br = arr_b->read(); + + Variant va; + for (int i = 0; i < sz; i++) { + Variant::interpolate(ar[i], br[i], c, va); + vw[i] = va; + } + } + r_dst = v; + } + } + return; + case POOL_REAL_ARRAY: { + const PoolVector *arr_a = reinterpret_cast *>(a._data._mem); + const PoolVector *arr_b = reinterpret_cast *>(b._data._mem); + int sz = arr_a->size(); + if (sz == 0 || arr_b->size() != sz) { + r_dst = a; + } else { + PoolVector v; + v.resize(sz); + { + PoolVector::Write vw = v.write(); + PoolVector::Read ar = arr_a->read(); + PoolVector::Read br = arr_b->read(); + + Variant va; + for (int i = 0; i < sz; i++) { + Variant::interpolate(ar[i], br[i], c, va); + vw[i] = va; + } + } + r_dst = v; + } + } + return; + case POOL_STRING_ARRAY: { + r_dst = a; + } + return; + case POOL_VECTOR2I_ARRAY: { + const PoolVector *arr_a = reinterpret_cast *>(a._data._mem); + const PoolVector *arr_b = reinterpret_cast *>(b._data._mem); + int sz = arr_a->size(); + if (sz == 0 || arr_b->size() != sz) { + r_dst = a; + } else { + PoolVector v; + v.resize(sz); + { + PoolVector::Write vw = v.write(); + PoolVector::Read ar = arr_a->read(); + PoolVector::Read br = arr_b->read(); + + for (int i = 0; i < sz; i++) { + vw[i] = ar[i].linear_interpolate(br[i], c); + } + } + r_dst = v; + } + } + return; + case POOL_COLOR_ARRAY: { + const PoolVector *arr_a = reinterpret_cast *>(a._data._mem); + const PoolVector *arr_b = reinterpret_cast *>(b._data._mem); + int sz = arr_a->size(); + if (sz == 0 || arr_b->size() != sz) { + r_dst = a; + } else { + PoolVector v; + v.resize(sz); + { + PoolVector::Write vw = v.write(); + PoolVector::Read ar = arr_a->read(); + PoolVector::Read br = arr_b->read(); + + for (int i = 0; i < sz; i++) { + vw[i] = ar[i].linear_interpolate(br[i], c); + } + } + r_dst = v; + } + } + return; + default: { + r_dst = a; + } + } +} + +static const char *_op_names[Variant::OP_MAX] = { + "==", + "!=", + "<", + "<=", + ">", + ">=", + "+", + "-", + "*", + "/", + "- (negation)", + "+ (positive)", + "%", + "+ (concatenation)", + "<<", + ">>", + "&", + "|", + "^", + "~", + "and", + "or", + "xor", + "not", + "in" + +}; + +String Variant::get_operator_name(Operator p_op) { + ERR_FAIL_INDEX_V(p_op, OP_MAX, ""); + return _op_names[p_op]; +} + +#undef CASE_TYPE_ALL +#undef CASE_TYPE_ALL_BUT_INT +#undef TYPE +#undef TYPES +#undef CASES +#undef SWITCH +#undef SWITCH_OP +#undef CASE_TYPE +#undef CASES +#undef SWITCH +#undef SWITCH_OP +#undef CASE_TYPE +#undef _RETURN +#undef _RETURN_FAIL +#undef DEFAULT_OP_NUM +#undef DEFAULT_OP_NUM_NULL +#undef DEFAULT_OP_NUM_DIV +#undef DEFAULT_OP_NUM_DIV +#undef DEFAULT_OP_NUM_NEG +#undef DEFAULT_OP_NUM_POS +#undef DEFAULT_OP_NUM_VEC +#undef DEFAULT_OP_STR_REV +#undef DEFAULT_OP_STR +#undef DEFAULT_OP_STR_NULL +#undef DEFAULT_OP_STR_NULL_NP +#undef DEFAULT_OP_STR_NULL_SN +#undef DEFAULT_OP_LOCALMEM_REV +#undef DEFAULT_OP_LOCALMEM +#undef DEFAULT_OP_LOCALMEM_NULL +#undef DEFAULT_OP_LOCALMEM_NEG +#undef DEFAULT_OP_LOCALMEM_POS +#undef DEFAULT_OP_LOCALMEM_NUM +#undef DEFAULT_OP_PTR +#undef DEFAULT_OP_PTRREF +#undef DEFAULT_OP_PTRREF_NULL +#undef DEFAULT_OP_ARRAY_EQ +#undef DEFAULT_OP_ARRAY_NEQ +#undef DEFAULT_OP_ARRAY_LT +#undef DEFAULT_OP_ARRAY_GT +#undef DEFAULT_OP_ARRAY_OP +#undef DEFAULT_OP_ARRAY_OP_BODY +#undef DEFAULT_OP_ARRAY_ADD +#undef DEFAULT_OP_ARRAY_CMD +#undef DEFAULT_OP_DVECTOR_SET +#undef DEFAULT_OP_DVECTOR_GET +#line 0 diff --git a/sfwl/sfwl.h b/sfwl/sfwl.h new file mode 100644 index 0000000..1e8e77e --- /dev/null +++ b/sfwl/sfwl.h @@ -0,0 +1,14953 @@ +#ifndef SFWL_H +#define SFWL_H + +#define SFWL_VERSION 1 + +// SFW - Simple Framework - Lite Version - https://github.com/Relintai/sfw + +// Simple c++ app / game framework inspired by the single file c game engines +// and libraries, especially [FWK](https://github.com/r-lyeh/FWK). + +// MODULES: +// CORE + OBJECT + +// LICENSES: + +/* +SFW - (MIT) + +Copyright (c) 2023-present Péter Magyar. + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +*/ + +// This Library uses code from the following projects: + +// Pandemonium Engine (MIT) + +/*************************************************************************/ +/* PANDEMONIUM ENGINE LICENSE */ +/* https://github.com/Relintai/pandemonium_engine */ +/*************************************************************************/ +/* Copyright (c) 2022-present Péter Magyar. */ +/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md). */ +/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur. */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ + +// FWK + +//https://github.com/r-lyeh/FWK + +/* + +Unlicense + +This software is released into the [public domain](https://unlicense.org/). +Also dual-licensed as [0-BSD](https://opensource.org/licenses/0BSD) or [MIT (No Attribution)](https://github.com/aws/mit-0) +for those countries where public domain is a concern (sigh). +Any contribution to this repository is implicitly subjected to the same release conditions aforementioned. + +*/ + +// Trantor + +//inet_address.h, .cpp, socket.h and .cpp originates from trantor (they were heavily modified): + +// Trantor - A non-blocking I/O based TCP network library, using C++14/17, +// Copyright (c) 2016-2021, Tao An. All rights reserved. +// https://github.com/an-tao/trantor +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions +// are met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above copyright +// notice, this list of conditions and the following disclaimer in the +// documentation and/or other materials provided with the distribution. +// * Neither the name of Tao An nor the names of other contributors +// may be used to endorse or promote products derived from this software +// without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// Muduo - A reactor-based C++ network library for Linux +// Copyright (c) 2010, Shuo Chen. All rights reserved. +// http://code.google.com/p/muduo/ +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions +// are met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above copyright +// notice, this list of conditions and the following disclaimer in the +// documentation and/or other materials provided with the distribution. +// * Neither the name of Shuo Chen nor the names of other contributors +// may be used to endorse or promote products derived from this software +// without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// PCG + +// pcg.h's License: + +// *Really* minimal PCG32 code / (c) 2014 M.E. O'Neill / pcg-random.org +// Licensed under Apache License 2.0 (NO WARRANTY, etc. see website) + +#ifndef _REENTRANT +#define _REENTRANT +#endif + +#include +#include +#include +#include + +//=================== CORE SECTION =================== + +#line 1 "sfwl/core/int_types.h" +/*************************************************************************/ +/* int_types.h */ +/* From https://github.com/Relintai/pandemonium_engine (MIT) */ +/*************************************************************************/ + +#ifdef _MSC_VER + +typedef signed __int8 int8_t; +typedef unsigned __int8 uint8_t; +typedef signed __int16 int16_t; +typedef unsigned __int16 uint16_t; +typedef signed __int32 int32_t; +typedef unsigned __int32 uint32_t; +typedef signed __int64 int64_t; +typedef unsigned __int64 uint64_t; + +#else + +#ifdef NO_STDINT_H +typedef unsigned char uint8_t; +typedef signed char int8_t; +typedef unsigned short uint16_t; +typedef signed short int16_t; +typedef unsigned int uint32_t; +typedef signed int int32_t; +typedef long long int64_t; +typedef unsigned long long uint64_t; +#else +#include +#endif + +#endif +#line 0 + +#line 1 "sfwl/core/math_defs.h" + +/*************************************************************************/ +/* math_defs.h */ +/* From https://github.com/Relintai/pandemonium_engine (MIT) */ +/*************************************************************************/ + +#define CMP_EPSILON 0.00001 +#define CMP_EPSILON2 (CMP_EPSILON * CMP_EPSILON) + +#define CMP_NORMALIZE_TOLERANCE 0.000001 +#define CMP_POINT_IN_PLANE_EPSILON 0.00001 + +#define Math_SQRT12 0.7071067811865475244008443621048490 +#define Math_SQRT2 1.4142135623730950488016887242 +#define Math_LN2 0.6931471805599453094172321215 +#define Math_TAU 6.2831853071795864769252867666 +#define Math_PI 3.1415926535897932384626433833 +#define Math_E 2.7182818284590452353602874714 +#define Math_INF INFINITY +#define Math_NAN NAN + +#ifdef DEBUG_ENABLED +#define MATH_CHECKS +#endif + +//this epsilon is for values related to a unit size (scalar or vector len) +#ifdef PRECISE_MATH_CHECKS +#define UNIT_EPSILON 0.00001 +#else +//tolerate some more floating point error normally +#define UNIT_EPSILON 0.001 +#endif + +#define USEC_TO_SEC(m_usec) ((m_usec) / 1000000.0) +#define SEC_TO_USEC(m_usec) ((m_usec)*1000000.0) + +enum ClockDirection { + CLOCKWISE, + COUNTERCLOCKWISE +}; + +enum Orientation { + + HORIZONTAL, + VERTICAL +}; + +enum HAlign { + + HALIGN_LEFT, + HALIGN_CENTER, + HALIGN_RIGHT +}; + +enum VAlign { + + VALIGN_TOP, + VALIGN_CENTER, + VALIGN_BOTTOM +}; + +enum Margin { + + MARGIN_LEFT, + MARGIN_TOP, + MARGIN_RIGHT, + MARGIN_BOTTOM +}; + +enum Side { + SIDE_LEFT, + SIDE_TOP, + SIDE_RIGHT, + SIDE_BOTTOM +}; + +enum Corner { + + CORNER_TOP_LEFT, + CORNER_TOP_RIGHT, + CORNER_BOTTOM_RIGHT, + CORNER_BOTTOM_LEFT +}; + +/** + * The "Real" type is an abstract type used for real numbers, such as 1.5, + * in contrast to integer numbers. Precision can be controlled with the + * presence or absence of the REAL_T_IS_DOUBLE define. + */ +#ifdef REAL_T_IS_DOUBLE +typedef double real_t; +#else +typedef float real_t; +#endif + +#line 0 + +#line 1 "sfwl/core/error_list.h" +/*************************************************************************/ +/* error_list.h */ +/* From https://github.com/Relintai/pandemonium_engine (MIT) */ +/*************************************************************************/ + +/** Error List. Please never compare an error against FAILED + * Either do result != OK , or !result. This way, Error fail + * values can be more detailed in the future. + * + * This is a generic error list, mainly for organizing a language of returning errors. + */ + +enum Error { + OK, // (0) + FAILED, ///< Generic fail error + ERR_UNAVAILABLE, ///< What is requested is unsupported/unavailable + ERR_UNCONFIGURED, ///< The object being used hasn't been properly set up yet + ERR_UNAUTHORIZED, ///< Missing credentials for requested resource + ERR_PARAMETER_RANGE_ERROR, ///< Parameter given out of range (5) + ERR_OUT_OF_MEMORY, ///< Out of memory + ERR_FILE_NOT_FOUND, + ERR_FILE_BAD_DRIVE, + ERR_FILE_BAD_PATH, + ERR_FILE_NO_PERMISSION, // (10) + ERR_FILE_ALREADY_IN_USE, + ERR_FILE_CANT_OPEN, + ERR_FILE_CANT_WRITE, + ERR_FILE_CANT_READ, + ERR_FILE_UNRECOGNIZED, // (15) + ERR_FILE_CORRUPT, + ERR_FILE_MISSING_DEPENDENCIES, + ERR_FILE_EOF, + ERR_CANT_OPEN, ///< Can't open a resource/socket/file + ERR_CANT_CREATE, // (20) + ERR_QUERY_FAILED, + ERR_ALREADY_IN_USE, + ERR_LOCKED, ///< resource is locked + ERR_TIMEOUT, + ERR_CANT_CONNECT, // (25) + ERR_CANT_RESOLVE, + ERR_CONNECTION_ERROR, + ERR_CANT_ACQUIRE_RESOURCE, + ERR_CANT_FORK, + ERR_INVALID_DATA, ///< Data passed is invalid (30) + ERR_INVALID_PARAMETER, ///< Parameter passed is invalid + ERR_ALREADY_EXISTS, ///< When adding, item already exists + ERR_DOES_NOT_EXIST, ///< When retrieving/erasing, if item does not exist + ERR_DATABASE_CANT_READ, ///< database is full + ERR_DATABASE_CANT_WRITE, ///< database is full (35) + ERR_COMPILATION_FAILED, + ERR_METHOD_NOT_FOUND, + ERR_LINK_FAILED, + ERR_SCRIPT_FAILED, + ERR_CYCLIC_LINK, // (40) + ERR_INVALID_DECLARATION, + ERR_DUPLICATE_SYMBOL, + ERR_PARSE_ERROR, + ERR_BUSY, + ERR_SKIP, // (45) + ERR_HELP, ///< user requested help!! + ERR_BUG, ///< a bug in the software certainly happened, due to a double check failing or unexpected behavior. + ERR_PRINTER_ON_FIRE, /// the parallel port printer is engulfed in flames +}; + +#line 0 + +#line 1 "sfwl/core/logger.h" + +class String; + +class RLogger { +public: + static void print_trace(const String &str); + static void print_trace(const char *str); + static void print_trace(const char *p_function, const char *p_file, int p_line, const String &str); + static void print_trace(const char *p_function, const char *p_file, int p_line, const char *str); + + static void print_message(const String &str); + static void print_message(const char *str); + static void print_message(const char *p_function, const char *p_file, int p_line, const String &str); + static void print_message(const char *p_function, const char *p_file, int p_line, const char *str); + + static void print_warning(const String &str); + static void print_warning(const char *str); + static void print_warning(const char *p_function, const char *p_file, int p_line, const String &str); + static void print_warning(const char *p_function, const char *p_file, int p_line, const char *str); + + static void print_error(const String &str); + static void print_error(const char *str); + static void print_error(const char *p_function, const char *p_file, int p_line, const char *str); + static void print_error(const char *p_function, const char *p_file, int p_line, const String &str); + static void print_msg_error(const char *p_function, const char *p_file, int p_line, const char *p_msg, const char *str); + static void print_index_error(const char *p_function, const char *p_file, int p_line, const int index, const int size, const char *str); + + static void log_trace(const String &str); + static void log_trace(const char *str); + static void log_trace(const char *p_function, const char *p_file, int p_line, const String &str); + static void log_trace(const char *p_function, const char *p_file, int p_line, const char *str); + + static void log_message(const String &str); + static void log_message(const char *str); + static void log_message(const char *p_function, const char *p_file, int p_line, const String &str); + static void log_message(const char *p_function, const char *p_file, int p_line, const char *str); + + static void log_warning(const String &str); + static void log_warning(const char *str); + static void log_warning(const char *p_function, const char *p_file, int p_line, const String &str); + static void log_warning(const char *p_function, const char *p_file, int p_line, const char *str); + + static void log_error(const String &str); + static void log_error(const char *str); + static void log_error(const char *p_function, const char *p_file, int p_line, const char *str); + static void log_error(const char *p_function, const char *p_file, int p_line, const String &str); + static void log_msg_error(const char *p_function, const char *p_file, int p_line, const char *p_msg, const char *str); + static void log_index_error(const char *p_function, const char *p_file, int p_line, const int index, const int size, const char *str); + static void log_index_error(const char *p_function, const char *p_file, int p_line, const int index, const int size, const String &str); + + static String *get_string_ptr(const int p_default_size = 100); + static String *get_string_ptr(const char *p_function, const char *p_file, int p_line, const int p_default_size = 300); + static String *get_string_ptr(const char *p_prefix, const char *p_function, const char *p_file, int p_line, const int p_default_size = 300); + static void return_string_ptr(String *str); + + static String *get_trace_string_ptr(const int p_default_size = 100); + static String *get_message_string_ptr(const int p_default_size = 100); + static String *get_warning_string_ptr(const int p_default_size = 100); + static String *get_error_string_ptr(const int p_default_size = 100); + + static String *get_trace_string_ptr(const char *p_function, const char *p_file, int p_line, const int p_default_size = 300); + static String *get_message_string_ptr(const char *p_function, const char *p_file, int p_line, const int p_default_size = 300); + static String *get_warning_string_ptr(const char *p_function, const char *p_file, int p_line, const int p_default_size = 300); + static String *get_error_string_ptr(const char *p_function, const char *p_file, int p_line, const int p_default_size = 300); + + static void log_ptr(String *str); + static void log_ret_ptr(String *str); +}; + +#line 0 + +#line 1 "sfwl/core/typedefs.h" + +/*************************************************************************/ +/* typedefs.h */ +/* From https://github.com/Relintai/pandemonium_engine (MIT) */ +/*************************************************************************/ + +/** + * Basic definitions and simple functions to be used everywhere. + */ + +//#include "platform_config.h" + +#ifndef _STR +#define _STR(m_x) #m_x +#define _MKSTR(m_x) _STR(m_x) +#endif + +//should always inline no matter what +#ifndef _ALWAYS_INLINE_ + +#if defined(__GNUC__) && (__GNUC__ >= 4) +#define _ALWAYS_INLINE_ __attribute__((always_inline)) inline +#elif defined(__llvm__) +#define _ALWAYS_INLINE_ __attribute__((always_inline)) inline +#elif defined(_MSC_VER) +#define _ALWAYS_INLINE_ __forceinline +#else +#define _ALWAYS_INLINE_ inline +#endif + +#endif + +// Should always inline, except in dev builds because it makes debugging harder. +#ifndef _FORCE_INLINE_ +#ifdef DEV_ENABLED +#define _FORCE_INLINE_ inline +#else +#define _FORCE_INLINE_ _ALWAYS_INLINE_ +#endif + +#endif + +// No discard allows the compiler to flag warnings if we don't use the return value of functions / classes +#ifndef _NO_DISCARD_ +// c++ 17 onwards +#if __cplusplus >= 201703L +#define _NO_DISCARD_ [[nodiscard]] +#else +// __warn_unused_result__ supported on clang and GCC +#if (defined(__clang__) || defined(__GNUC__)) && defined(__has_attribute) +#if __has_attribute(__warn_unused_result__) +#define _NO_DISCARD_ __attribute__((__warn_unused_result__)) +#endif +#endif + +// Visual Studio 2012 onwards +#if _MSC_VER >= 1700 +#define _NO_DISCARD_ _Check_return_ +#endif + +// If nothing supported, just noop the macro +#ifndef _NO_DISCARD_ +#define _NO_DISCARD_ +#endif +#endif // not c++ 17 +#endif // not defined _NO_DISCARD_ + +// In some cases _NO_DISCARD_ will get false positives, +// we can prevent the warning in specific cases by preceding the call with a cast. +#ifndef _ALLOW_DISCARD_ +#define _ALLOW_DISCARD_ (void) +#endif + +// GCC (prior to c++ 17) Does not seem to support no discard with classes, only functions. +// So we will use a specific macro for classes. +#ifndef _NO_DISCARD_CLASS_ +#if (defined(__clang__) || defined(_MSC_VER)) +#define _NO_DISCARD_CLASS_ _NO_DISCARD_ +#else +#define _NO_DISCARD_CLASS_ +#endif +#endif + +//custom, gcc-safe offsetof, because gcc complains a lot. +template +T *_nullptr() { + T *t = NULL; + return t; +} + +#define OFFSET_OF(st, m) \ + ((size_t)((char *)&(_nullptr()->m) - (char *)0)) +/** + * Some platforms (devices) don't define NULL + */ + +#ifndef NULL +#define NULL 0 +#endif + +/** + * Windows badly defines a lot of stuff we'll never use. Undefine it. + */ + +#if defined(_WIN64) || defined(_WIN32) +#undef min // override standard definition +#undef max // override standard definition +#undef ERROR // override (really stupid) wingdi.h standard definition +#undef DELETE // override (another really stupid) winnt.h standard definition +#undef MessageBox // override winuser.h standard definition +#undef MIN // override standard definition +#undef MAX // override standard definition +#undef CLAMP // override standard definition +#undef Error +#undef OK +#undef CONNECT_DEFERRED // override from Windows SDK, clashes with Object enum +#endif + +/** Generic ABS function, for math uses please use Math::abs */ + +#ifndef ABS +#define ABS(m_v) (((m_v) < 0) ? (-(m_v)) : (m_v)) +#endif + +#define ABSDIFF(x, y) (((x) < (y)) ? ((y) - (x)) : ((x) - (y))) + +#ifndef SGN +#define SGN(m_v) (((m_v) < 0) ? (-1.0f) : (+1.0f)) +#endif + +#ifndef MIN +#define MIN(m_a, m_b) (((m_a) < (m_b)) ? (m_a) : (m_b)) +#endif + +#ifndef MAX +#define MAX(m_a, m_b) (((m_a) > (m_b)) ? (m_a) : (m_b)) +#endif + +#ifndef CLAMP +#define CLAMP(m_a, m_min, m_max) (((m_a) < (m_min)) ? (m_min) : (((m_a) > (m_max)) ? m_max : m_a)) +#endif + +/** Generic swap template */ +#ifndef SWAP + +#define SWAP(m_x, m_y) __swap_tmpl((m_x), (m_y)) +template +inline void __swap_tmpl(T &x, T &y) { + T aux = x; + x = y; + y = aux; +} + +#endif //swap + +/* clang-format off */ +#define HEX2CHR(m_hex) \ + ((m_hex >= '0' && m_hex <= '9') ? (m_hex - '0') : \ + ((m_hex >= 'A' && m_hex <= 'F') ? (10 + m_hex - 'A') : \ + ((m_hex >= 'a' && m_hex <= 'f') ? (10 + m_hex - 'a') : 0))) +/* clang-format on */ + +// Macro to check whether we are compiled by clang +// and we have a specific builtin +#if defined(__llvm__) && defined(__has_builtin) +#define _llvm_has_builtin(x) __has_builtin(x) +#else +#define _llvm_has_builtin(x) 0 +#endif + +#if (defined(__GNUC__) && (__GNUC__ >= 5)) || _llvm_has_builtin(__builtin_mul_overflow) +#define _mul_overflow __builtin_mul_overflow +#endif + +#if (defined(__GNUC__) && (__GNUC__ >= 5)) || _llvm_has_builtin(__builtin_add_overflow) +#define _add_overflow __builtin_add_overflow +#endif + +/** Function to find the next power of 2 to an integer */ + +static _FORCE_INLINE_ unsigned int next_power_of_2(unsigned int x) { + if (x == 0) { + return 0; + } + + --x; + x |= x >> 1; + x |= x >> 2; + x |= x >> 4; + x |= x >> 8; + x |= x >> 16; + + return ++x; +} + +static _FORCE_INLINE_ unsigned int previous_power_of_2(unsigned int x) { + x |= x >> 1; + x |= x >> 2; + x |= x >> 4; + x |= x >> 8; + x |= x >> 16; + return x - (x >> 1); +} + +static _FORCE_INLINE_ unsigned int closest_power_of_2(unsigned int x) { + unsigned int nx = next_power_of_2(x); + unsigned int px = previous_power_of_2(x); + return (nx - x) > (x - px) ? px : nx; +} + +// We need this definition inside the function below. +static inline int get_shift_from_power_of_2(unsigned int p_pixel); + +template +static _FORCE_INLINE_ T nearest_power_of_2_templated(T x) { + --x; + + // The number of operations on x is the base two logarithm + // of the p_number of bits in the type. Add three to account + // for sizeof(T) being in bytes. + size_t num = get_shift_from_power_of_2(sizeof(T)) + 3; + + // If the compiler is smart, it unrolls this loop + // If its dumb, this is a bit slow. + for (size_t i = 0; i < num; i++) { + x |= x >> (1 << i); + } + + return ++x; +} + +/** Function to find the nearest (bigger) power of 2 to an integer */ + +static inline unsigned int nearest_shift(unsigned int p_number) { + for (int i = 30; i >= 0; i--) { + if (p_number & (1 << i)) { + return i + 1; + } + } + + return 0; +} + +/** get a shift value from a power of 2 */ +static inline int get_shift_from_power_of_2(unsigned int p_pixel) { + // return a GL_TEXTURE_SIZE_ENUM + + for (unsigned int i = 0; i < 32; i++) { + if (p_pixel == (unsigned int)(1 << i)) { + return i; + } + } + + return -1; +} + +/** Swap 16 bits value for endianness */ +#if defined(__GNUC__) || _llvm_has_builtin(__builtin_bswap16) +#define BSWAP16(x) __builtin_bswap16(x) +#else +static inline uint16_t BSWAP16(uint16_t x) { + return (x >> 8) | (x << 8); +} +#endif + +/** Swap 32 bits value for endianness */ +#if defined(__GNUC__) || _llvm_has_builtin(__builtin_bswap32) +#define BSWAP32(x) __builtin_bswap32(x) +#else +static inline uint32_t BSWAP32(uint32_t x) { + return ((x << 24) | ((x << 8) & 0x00FF0000) | ((x >> 8) & 0x0000FF00) | (x >> 24)); +} +#endif + +/** Swap 64 bits value for endianness */ +#if defined(__GNUC__) || _llvm_has_builtin(__builtin_bswap64) +#define BSWAP64(x) __builtin_bswap64(x) +#else +static inline uint64_t BSWAP64(uint64_t x) { + x = (x & 0x00000000FFFFFFFF) << 32 | (x & 0xFFFFFFFF00000000) >> 32; + x = (x & 0x0000FFFF0000FFFF) << 16 | (x & 0xFFFF0000FFFF0000) >> 16; + x = (x & 0x00FF00FF00FF00FF) << 8 | (x & 0xFF00FF00FF00FF00) >> 8; + return x; +} +#endif + +/** When compiling with RTTI, we can add an "extra" + * layer of safeness in many operations, so dynamic_cast + * is used besides casting by enum. + */ + +template +struct Comparator { + _ALWAYS_INLINE_ bool operator()(const T &p_a, const T &p_b) const { return (p_a < p_b); } +}; + +void _global_lock(); +void _global_unlock(); + +struct _GlobalLock { + _GlobalLock() { _global_lock(); } + ~_GlobalLock() { _global_unlock(); } +}; + +#define GLOBAL_LOCK_FUNCTION _GlobalLock _global_lock_; + +#ifdef NO_SAFE_CAST +#define SAFE_CAST static_cast +#else +#define SAFE_CAST dynamic_cast +#endif + +#define MT_SAFE + +#define __STRX(m_index) #m_index +#define __STR(m_index) __STRX(m_index) + +#ifdef __GNUC__ +#define likely(x) __builtin_expect(!!(x), 1) +#define unlikely(x) __builtin_expect(!!(x), 0) +#else +#define likely(x) x +#define unlikely(x) x +#endif + +#if defined(__GNUC__) +#define _PRINTF_FORMAT_ATTRIBUTE_2_0 __attribute__((format(printf, 2, 0))) +#define _PRINTF_FORMAT_ATTRIBUTE_2_3 __attribute__((format(printf, 2, 3))) +#else +#define _PRINTF_FORMAT_ATTRIBUTE_2_0 +#define _PRINTF_FORMAT_ATTRIBUTE_2_3 +#endif + +/** This is needed due to a strange OpenGL API that expects a pointer + * type for an argument that is actually an offset. + */ +#define CAST_INT_TO_UCHAR_PTR(ptr) ((uint8_t *)(uintptr_t)(ptr)) + +/** Hint for compilers that this fallthrough in a switch is intentional. + * Can be replaced by [[fallthrough]] annotation if we move to C++17. + * Including conditional support for it for people who set -std=c++17 + * themselves. + * Requires a trailing semicolon when used. + */ +#if __cplusplus >= 201703L +#define FALLTHROUGH [[fallthrough]] +#elif defined(__GNUC__) && __GNUC__ >= 7 +#define FALLTHROUGH __attribute__((fallthrough)) +#elif defined(__llvm__) && __cplusplus >= 201103L && defined(__has_feature) +#if __has_feature(cxx_attributes) && defined(__has_warning) +#if __has_warning("-Wimplicit-fallthrough") +#define FALLTHROUGH [[clang::fallthrough]] +#endif +#endif +#endif + +#ifndef FALLTHROUGH +#define FALLTHROUGH +#endif + +// Limit the depth of recursive algorithms when dealing with Array/Dictionary +#define MAX_RECURSION 100 + +//HAS_TRIVIAL_CONSTRUCTOR + +#if defined(__llvm__) && _llvm_has_builtin(__is_trivially_constructible) +#define HAS_TRIVIAL_CONSTRUCTOR(T) __is_trivially_constructible(T) +#endif + +#ifndef HAS_TRIVIAL_CONSTRUCTOR +#define HAS_TRIVIAL_CONSTRUCTOR(T) __has_trivial_constructor(T) +#endif + +//HAS_TRIVIAL_DESTRUCTOR + +#if defined(__llvm__) && _llvm_has_builtin(__is_trivially_destructible) +#define HAS_TRIVIAL_DESTRUCTOR(T) __is_trivially_destructible(T) +#endif + +#ifndef HAS_TRIVIAL_DESTRUCTOR +#define HAS_TRIVIAL_DESTRUCTOR(T) __has_trivial_destructor(T) +#endif + +//HAS_TRIVIAL_COPY + +#if defined(__llvm__) && _llvm_has_builtin(__is_trivially_copyable) +#define HAS_TRIVIAL_COPY(T) __is_trivially_copyable(T) +#endif + +#ifndef HAS_TRIVIAL_COPY +#define HAS_TRIVIAL_COPY(T) __has_trivial_copy(T) +#endif + +#line 0 + +#line 1 "sfwl/core/marshalls.h" + +/*************************************************************************/ +/* marshalls.h */ +/* From https://github.com/Relintai/pandemonium_engine (MIT) */ +/*************************************************************************/ + +/** + * Miscellaneous helpers for marshalling data types, and encoding + * in an endian independent way + */ + +union MarshallFloat { + uint32_t i; ///< int + float f; ///< float +}; + +union MarshallDouble { + uint64_t l; ///< long long + double d; ///< double +}; + +static inline unsigned int encode_uint16(uint16_t p_uint, uint8_t *p_arr) { + for (int i = 0; i < 2; i++) { + *p_arr = p_uint & 0xFF; + p_arr++; + p_uint >>= 8; + } + + return sizeof(uint16_t); +} + +static inline unsigned int encode_uint32(uint32_t p_uint, uint8_t *p_arr) { + for (int i = 0; i < 4; i++) { + *p_arr = p_uint & 0xFF; + p_arr++; + p_uint >>= 8; + } + + return sizeof(uint32_t); +} + +static inline unsigned int encode_float(float p_float, uint8_t *p_arr) { + MarshallFloat mf; + mf.f = p_float; + encode_uint32(mf.i, p_arr); + + return sizeof(uint32_t); +} + +static inline unsigned int encode_uint64(uint64_t p_uint, uint8_t *p_arr) { + for (int i = 0; i < 8; i++) { + *p_arr = p_uint & 0xFF; + p_arr++; + p_uint >>= 8; + } + + return sizeof(uint64_t); +} + +static inline unsigned int encode_double(double p_double, uint8_t *p_arr) { + MarshallDouble md; + md.d = p_double; + encode_uint64(md.l, p_arr); + + return sizeof(uint64_t); +} + +static inline int encode_cstring(const char *p_string, uint8_t *p_data) { + int len = 0; + + while (*p_string) { + if (p_data) { + *p_data = (uint8_t)*p_string; + p_data++; + } + p_string++; + len++; + }; + + if (p_data) { + *p_data = 0; + } + return len + 1; +} + +static inline uint16_t decode_uint16(const uint8_t *p_arr) { + uint16_t u = 0; + + for (int i = 0; i < 2; i++) { + uint16_t b = *p_arr; + b <<= (i * 8); + u |= b; + p_arr++; + } + + return u; +} + +static inline uint32_t decode_uint32(const uint8_t *p_arr) { + uint32_t u = 0; + + for (int i = 0; i < 4; i++) { + uint32_t b = *p_arr; + b <<= (i * 8); + u |= b; + p_arr++; + } + + return u; +} + +static inline float decode_float(const uint8_t *p_arr) { + MarshallFloat mf; + mf.i = decode_uint32(p_arr); + return mf.f; +} + +static inline uint64_t decode_uint64(const uint8_t *p_arr) { + uint64_t u = 0; + + for (int i = 0; i < 8; i++) { + uint64_t b = (*p_arr) & 0xFF; + b <<= (i * 8); + u |= b; + p_arr++; + } + + return u; +} + +static inline double decode_double(const uint8_t *p_arr) { + MarshallDouble md; + md.l = decode_uint64(p_arr); + return md.d; +} + +#line 0 + +#line 1 "sfwl/core/sfw_time.h" + +// ----------------------------------------------------------------------------- +// time framework utils +// - originally by rlyeh, public domain. + +class SFWTime { +public: + static uint64_t date(); // YYYYMMDDhhmmss + static uint64_t date_epoch(); // linux epoch + static char *date_string(); // "YYYY-MM-DD hh:mm:ss" + static double time_hh(); + static double time_mm(); + static double time_ss(); + static uint64_t time_ms(); + static uint64_t time_us(); + static uint64_t time_ns(); + static void sleep_ss(double ss); + static void sleep_ms(double ms); + static void sleep_us(double us); + static void sleep_ns(double us); +}; + +#line 0 + +#line 1 "sfwl/core/safe_refcount.h" + +/*************************************************************************/ +/* safe_refcount.h */ +/* From https://github.com/Relintai/pandemonium_engine (MIT) */ +/*************************************************************************/ + +#if !defined(NO_THREADS) + +#include +#include + +// Design goals for these classes: +// - No automatic conversions or arithmetic operators, +// to keep explicit the use of atomics everywhere. +// - Using acquire-release semantics, even to set the first value. +// The first value may be set relaxedly in many cases, but adding the distinction +// between relaxed and unrelaxed operation to the interface would make it needlessly +// flexible. There's negligible waste in having release semantics for the initial +// value and, as an important benefit, you can be sure the value is properly synchronized +// even with threads that are already running. + +// This is used in very specific areas of the engine where it's critical that these guarantees are held +#define SAFE_NUMERIC_TYPE_PUN_GUARANTEES(m_type) \ + static_assert(sizeof(SafeNumeric) == sizeof(m_type), ""); \ + static_assert(alignof(SafeNumeric) == alignof(m_type), ""); \ + static_assert(std::is_trivially_destructible>::value, ""); + +#if defined(DEBUG_ENABLED) +void check_lockless_atomics(); +#endif + +template +class SafeNumeric { + std::atomic value; + +public: + _ALWAYS_INLINE_ void set(T p_value) { + value.store(p_value, std::memory_order_release); + } + + _ALWAYS_INLINE_ T get() const { + return value.load(std::memory_order_acquire); + } + + _ALWAYS_INLINE_ T increment() { + return value.fetch_add(1, std::memory_order_acq_rel) + 1; + } + + // Returns the original value instead of the new one + _ALWAYS_INLINE_ T postincrement() { + return value.fetch_add(1, std::memory_order_acq_rel); + } + + _ALWAYS_INLINE_ T decrement() { + return value.fetch_sub(1, std::memory_order_acq_rel) - 1; + } + + // Returns the original value instead of the new one + _ALWAYS_INLINE_ T postdecrement() { + return value.fetch_sub(1, std::memory_order_acq_rel); + } + + _ALWAYS_INLINE_ T add(T p_value) { + return value.fetch_add(p_value, std::memory_order_acq_rel) + p_value; + } + + // Returns the original value instead of the new one + _ALWAYS_INLINE_ T postadd(T p_value) { + return value.fetch_add(p_value, std::memory_order_acq_rel); + } + + _ALWAYS_INLINE_ T sub(T p_value) { + return value.fetch_sub(p_value, std::memory_order_acq_rel) - p_value; + } + + // Returns the original value instead of the new one + _ALWAYS_INLINE_ T postsub(T p_value) { + return value.fetch_sub(p_value, std::memory_order_acq_rel); + } + + _ALWAYS_INLINE_ T exchange_if_greater(T p_value) { + while (true) { + T tmp = value.load(std::memory_order_acquire); + if (tmp >= p_value) { + return tmp; // already greater, or equal + } + if (value.compare_exchange_weak(tmp, p_value, std::memory_order_acq_rel)) { + return p_value; + } + } + } + + _ALWAYS_INLINE_ T conditional_increment() { + while (true) { + T c = value.load(std::memory_order_acquire); + if (c == 0) { + return 0; + } + if (value.compare_exchange_weak(c, c + 1, std::memory_order_acq_rel)) { + return c + 1; + } + } + } + + _ALWAYS_INLINE_ explicit SafeNumeric(T p_value = static_cast(0)) { + set(p_value); + } +}; + +class SafeFlag { + std::atomic_bool flag; + +public: + _ALWAYS_INLINE_ bool is_set() const { + return flag.load(std::memory_order_acquire); + } + + _ALWAYS_INLINE_ void set() { + flag.store(true, std::memory_order_release); + } + + _ALWAYS_INLINE_ void clear() { + flag.store(false, std::memory_order_release); + } + + _ALWAYS_INLINE_ void set_to(bool p_value) { + flag.store(p_value, std::memory_order_release); + } + + _ALWAYS_INLINE_ explicit SafeFlag(bool p_value = false) { + set_to(p_value); + } +}; + +class SafeRefCount { + SafeNumeric count; + +public: + _ALWAYS_INLINE_ bool ref() { // true on success + return count.conditional_increment() != 0; + } + + _ALWAYS_INLINE_ uint32_t refval() { // none-zero on success + return count.conditional_increment(); + } + + _ALWAYS_INLINE_ bool unref() { // true if must be disposed of + return count.decrement() == 0; + } + + _ALWAYS_INLINE_ uint32_t unrefval() { // 0 if must be disposed of + return count.decrement(); + } + + _ALWAYS_INLINE_ uint32_t get() const { + return count.get(); + } + + _ALWAYS_INLINE_ void init(uint32_t p_value = 1) { + count.set(p_value); + } +}; + +#else + +template +class SafeNumeric { +protected: + T value; + +public: + _ALWAYS_INLINE_ void set(T p_value) { + value = p_value; + } + + _ALWAYS_INLINE_ T get() const { + return value; + } + + _ALWAYS_INLINE_ T increment() { + return ++value; + } + + _ALWAYS_INLINE_ T postincrement() { + return value++; + } + + _ALWAYS_INLINE_ T decrement() { + return --value; + } + + _ALWAYS_INLINE_ T postdecrement() { + return value--; + } + + _ALWAYS_INLINE_ T add(T p_value) { + return value += p_value; + } + + _ALWAYS_INLINE_ T postadd(T p_value) { + T old = value; + value += p_value; + return old; + } + + _ALWAYS_INLINE_ T sub(T p_value) { + return value -= p_value; + } + + _ALWAYS_INLINE_ T postsub(T p_value) { + T old = value; + value -= p_value; + return old; + } + + _ALWAYS_INLINE_ T exchange_if_greater(T p_value) { + if (value < p_value) { + value = p_value; + } + return value; + } + + _ALWAYS_INLINE_ T conditional_increment() { + if (value == 0) { + return 0; + } else { + return ++value; + } + } + + _ALWAYS_INLINE_ explicit SafeNumeric(T p_value = static_cast(0)) : + value(p_value) { + } +}; + +class SafeFlag { +protected: + bool flag; + +public: + _ALWAYS_INLINE_ bool is_set() const { + return flag; + } + + _ALWAYS_INLINE_ void set() { + flag = true; + } + + _ALWAYS_INLINE_ void clear() { + flag = false; + } + + _ALWAYS_INLINE_ void set_to(bool p_value) { + flag = p_value; + } + + _ALWAYS_INLINE_ explicit SafeFlag(bool p_value = false) : + flag(p_value) {} +}; + +class SafeRefCount { + uint32_t count; + +public: + _ALWAYS_INLINE_ bool ref() { // true on success + if (count != 0) { + ++count; + return true; + } else { + return false; + } + } + + _ALWAYS_INLINE_ uint32_t refval() { // none-zero on success + if (count != 0) { + return ++count; + } else { + return 0; + } + } + + _ALWAYS_INLINE_ bool unref() { // true if must be disposed of + return --count == 0; + } + + _ALWAYS_INLINE_ uint32_t unrefval() { // 0 if must be disposed of + return --count; + } + + _ALWAYS_INLINE_ uint32_t get() const { + return count; + } + + _ALWAYS_INLINE_ void init(uint32_t p_value = 1) { + count = p_value; + } + + SafeRefCount() : + count(0) {} +}; + +#endif + +#line 0 + +#line 1 "sfwl/core/thread.h" + +/*************************************************************************/ +/* thread.h */ +/* From https://github.com/Relintai/pandemonium_engine (MIT) */ +/*************************************************************************/ + +#if !defined(NO_THREADS) +#include +#endif + +class String; + +class Thread { +public: + typedef void (*Callback)(void *p_userdata); + + typedef uint64_t ID; + + enum Priority { + PRIORITY_LOW, + PRIORITY_NORMAL, + PRIORITY_HIGH + }; + + struct Settings { + Priority priority; + Settings() { priority = PRIORITY_NORMAL; } + }; + +private: +#if !defined(NO_THREADS) + friend class Main; + + static ID main_thread_id; + + static uint64_t _thread_id_hash(const std::thread::id &p_t); + + ID id = _thread_id_hash(std::thread::id()); + std::thread thread; + + static void callback(Thread *p_self, const Settings &p_settings, Thread::Callback p_callback, void *p_userdata); + + static Error (*set_name_func)(const String &); + static void (*set_priority_func)(Thread::Priority); + static void (*init_func)(); + static void (*term_func)(); +#endif + +public: + static void _set_platform_funcs( + Error (*p_set_name_func)(const String &), + void (*p_set_priority_func)(Thread::Priority), + void (*p_init_func)() = nullptr, + void (*p_term_func)() = nullptr); + +#if !defined(NO_THREADS) + _FORCE_INLINE_ ID get_id() const { return id; } + // get the ID of the caller thread + static ID get_caller_id(); + // get the ID of the main thread + _FORCE_INLINE_ static ID get_main_id() { return main_thread_id; } + + _FORCE_INLINE_ static bool is_main_thread() { return get_caller_id() == main_thread_id; } + + static Error set_name(const String &p_name); + + void start(Thread::Callback p_callback, void *p_user, const Settings &p_settings = Settings()); + bool is_started() const; + ///< waits until thread is finished, and deallocates it. + void wait_to_finish(); + + ~Thread(); +#else + _FORCE_INLINE_ ID get_id() const { return 0; } + // get the ID of the caller thread + _FORCE_INLINE_ static ID get_caller_id() { return 0; } + // get the ID of the main thread + _FORCE_INLINE_ static ID get_main_id() { return 0; } + + _FORCE_INLINE_ static bool is_main_thread() { return true; } + + static Error set_name(const String &p_name) { return ERR_UNAVAILABLE; } + + void start(Thread::Callback p_callback, void *p_user, const Settings &p_settings = Settings()) {} + bool is_started() const { return false; } + void wait_to_finish() {} +#endif +}; + +#line 0 + +#line 1 "sfwl/core/error_macros.h" + +// Based on Godot Engine's error_macros.h +// MIT License +// Copyright (c) 2007-2021 Juan Linietsky, Ariel Manzur. +// Copyright (c) 2014-2021 Godot Engine contributors (cf. AUTHORS.md). + +#ifdef _MSC_VER +#define GENERATE_TRAP \ + __debugbreak(); \ + /* Avoid warning about control paths */ \ + for (;;) { \ + } +#else +#define GENERATE_TRAP __builtin_trap(); +#endif + +// template methods for the variadic log macros. Add more as needed. +template +_FORCE_INLINE_ void _RLOG_MACRO_TEMPLATE_FUNC(STR str, A p0) { + str->operator+=(p0); +} + +template +_FORCE_INLINE_ void _RLOG_MACRO_TEMPLATE_FUNC(STR str, A p0, B p1) { + str->operator+=(p0); + str->operator+=(' '); + str->operator+=(p1); +} + +template +_FORCE_INLINE_ void _RLOG_MACRO_TEMPLATE_FUNC(STR str, A p0, B p1, C p2) { + str->operator+=(p0); + str->operator+=(' '); + str->operator+=(p1); + str->operator+=(' '); + str->operator+=(p2); +} + +template +_FORCE_INLINE_ void _RLOG_MACRO_TEMPLATE_FUNC(STR str, A p0, B p1, C p2, D p3) { + str->operator+=(p0); + str->operator+=(' '); + str->operator+=(p1); + str->operator+=(' '); + str->operator+=(p2); + str->operator+=(' '); + str->operator+=(p3); +} + +template +_FORCE_INLINE_ void _RLOG_MACRO_TEMPLATE_FUNC(STR str, A p0, B p1, C p2, D p3, E p4) { + str->operator+=(p0); + str->operator+=(' '); + str->operator+=(p1); + str->operator+=(' '); + str->operator+=(p2); + str->operator+=(' '); + str->operator+=(p3); + str->operator+=(' '); + str->operator+=(p4); +} + +#define PRINT_TRACE(str) \ + RLogger::print_trace(__FUNCTION__, __FILE__, __LINE__, str); + +#define LOG_TRACE(...) \ + { \ + String *_rlogger_string_ptr = RLogger::get_trace_string_ptr(__FUNCTION__, __FILE__, __LINE__); \ + _RLOG_MACRO_TEMPLATE_FUNC(_rlogger_string_ptr, __VA_ARGS__); \ + RLogger::log_ret_ptr(_rlogger_string_ptr); \ + } + +#define PRINT_MSG(str) \ + RLogger::print_message(__FUNCTION__, __FILE__, __LINE__, str); + +#define LOG_MSG(...) \ + { \ + String *_rlogger_string_ptr = RLogger::get_message_string_ptr(__FUNCTION__, __FILE__, __LINE__); \ + _RLOG_MACRO_TEMPLATE_FUNC(_rlogger_string_ptr, __VA_ARGS__); \ + RLogger::log_ret_ptr(_rlogger_string_ptr); \ + } + +#define PRINT_WARN(str) \ + RLogger::print_warning(__FUNCTION__, __FILE__, __LINE__, str); + +#define LOG_WARN(...) \ + { \ + String *_rlogger_string_ptr = RLogger::get_warning_string_ptr(__FUNCTION__, __FILE__, __LINE__); \ + _RLOG_MACRO_TEMPLATE_FUNC(_rlogger_string_ptr, __VA_ARGS__); \ + RLogger::log_ret_ptr(_rlogger_string_ptr); \ + } + +#define PRINT_ERR(str) \ + RLogger::print_error(__FUNCTION__, __FILE__, __LINE__, str); + +#define ERR_PRINT(str) \ + RLogger::print_error(__FUNCTION__, __FILE__, __LINE__, str); + +#define LOG_ERR(...) \ + { \ + String *_rlogger_string_ptr = RLogger::get_error_string_ptr(__FUNCTION__, __FILE__, __LINE__); \ + _RLOG_MACRO_TEMPLATE_FUNC(_rlogger_string_ptr, __VA_ARGS__); \ + RLogger::log_ret_ptr(_rlogger_string_ptr); \ + } + +#define ERR_FAIL_MSG(msg) \ + RLogger::log_error(__FUNCTION__, __FILE__, __LINE__, msg); \ + return; + +#define ERR_FAIL_V(val) \ + RLogger::log_error(__FUNCTION__, __FILE__, __LINE__, ""); \ + return val; + +#define ERR_FAIL_V_MSG(val, msg) \ + RLogger::log_error(__FUNCTION__, __FILE__, __LINE__, msg); \ + return val; + +#define ERR_FAIL_INDEX(index, size) \ + if ((index < 0) || (index >= size)) { \ + RLogger::log_index_error(__FUNCTION__, __FILE__, __LINE__, index, size, ""); \ + return; \ + } else \ + ((void)0) + +#define ERR_FAIL_INDEX_MSG(index, size, msg) \ + if ((index < 0) || (index >= size)) { \ + RLogger::log_index_error(__FUNCTION__, __FILE__, __LINE__, index, size, msg); \ + return; \ + } else \ + ((void)0) + +#define ERR_FAIL_INDEX_V(index, size, val) \ + if ((index < 0) || (index >= size)) { \ + RLogger::log_index_error(__FUNCTION__, __FILE__, __LINE__, index, size, ""); \ + return val; \ + } else \ + ((void)0) + +#define ERR_FAIL_INDEX_V_MSG(index, size, val, msg) \ + if ((index < 0) || (index >= size)) { \ + RLogger::log_index_error(__FUNCTION__, __FILE__, __LINE__, index, size, msg); \ + return val; \ + } else \ + ((void)0) + +#define ERR_FAIL_COND(cond) \ + if (cond) { \ + RLogger::log_error(__FUNCTION__, __FILE__, __LINE__, "ERR_FAIL_COND: \"" #cond "\" is true!"); \ + return; \ + } else \ + ((void)0) + +#define ERR_FAIL_COND_MSG(cond, msg) \ + if (cond) { \ + RLogger::log_error(__FUNCTION__, __FILE__, __LINE__, msg); \ + return; \ + } else \ + ((void)0) + +#define ERR_FAIL_COND_V(cond, val) \ + if (cond) { \ + RLogger::log_error(__FUNCTION__, __FILE__, __LINE__, "ERR_FAIL_COND: \"" #cond "\" is true!"); \ + return val; \ + } else \ + ((void)0) + +#define ERR_FAIL_COND_V_MSG(cond, val, msg) \ + if (cond) { \ + RLogger::log_error(__FUNCTION__, __FILE__, __LINE__, msg); \ + return val; \ + } else \ + ((void)0) + +#define ERR_CONTINUE(cond) \ + if (cond) { \ + RLogger::log_error(__FUNCTION__, __FILE__, __LINE__, "ERR_CONTINUE: \"" #cond "\" is true!"); \ + continue; \ + } else \ + ((void)0) + +#define ERR_CONTINUE_MSG(cond, msg) \ + if (cond) { \ + RLogger::log_error(__FUNCTION__, __FILE__, __LINE__, msg); \ + continue; \ + } else \ + ((void)0) + +#define ERR_CONTINUE_ACTION(cond, action) \ + if (cond) { \ + RLogger::log_error(__FUNCTION__, __FILE__, __LINE__, "ERR_CONTINUE: \"" #cond "\" is true!"); \ + action; \ + continue; \ + } else \ + ((void)0) + +#define ERR_CONTINUE_ACTION_MSG(cond, action, msg) \ + if (cond) { \ + RLogger::log_error(__FUNCTION__, __FILE__, __LINE__, msg); \ + action; \ + continue; \ + } else \ + ((void)0) + +#define CRASH_INDEX(index, size) \ + if ((index < 0) || (index >= size)) { \ + RLogger::log_index_error(__FUNCTION__, __FILE__, __LINE__, index, size, "CRASH!"); \ + GENERATE_TRAP \ + } else \ + ((void)0) + +#define CRASH_BAD_INDEX(index, size) \ + if ((index < 0) || (index >= size)) { \ + RLogger::log_index_error(__FUNCTION__, __FILE__, __LINE__, index, size, "CRASH!"); \ + GENERATE_TRAP \ + } else \ + ((void)0) + +#define CRASH_BAD_UNSIGNED_INDEX(index, size) \ + if ((index < 0) || (index >= size)) { \ + RLogger::log_index_error(__FUNCTION__, __FILE__, __LINE__, index, size, "CRASH!"); \ + GENERATE_TRAP \ + } else \ + ((void)0) + +#define CRASH_COND(cond) \ + if (cond) { \ + RLogger::log_error(__FUNCTION__, __FILE__, __LINE__, "CRASH_COND: \"" #cond "\" is true!"); \ + GENERATE_TRAP \ + } else \ + ((void)0) + +#define CRASH_COND_MSG(cond, msg) \ + if (cond) { \ + RLogger::log_error(__FUNCTION__, __FILE__, __LINE__, msg); \ + GENERATE_TRAP \ + } else \ + ((void)0) + +#define CRASH_MSG(msg) \ + RLogger::log_error(__FUNCTION__, __FILE__, __LINE__, msg); \ + GENERATE_TRAP + +#define CRASH_NOW() \ + RLogger::log_error(__FUNCTION__, __FILE__, __LINE__, "CRASH!"); \ + GENERATE_TRAP + +/** + * This should be a 'free' assert for program flow and should not be needed in any releases, + * only used in dev builds. + */ +#ifdef DEV_ENABLED +#define DEV_ASSERT(m_cond) \ + if (unlikely(!(m_cond))) { \ + _err_print_error(FUNCTION_STR, __FILE__, __LINE__, "FATAL: DEV_ASSERT failed \"" _STR(m_cond) "\" is false."); \ + _err_flush_stdout(); \ + GENERATE_TRAP \ + } else \ + ((void)0) +#else +#define DEV_ASSERT(m_cond) +#endif + +/** + * These should be 'free' checks for program flow and should not be needed in any releases, + * only used in dev builds. + */ +#ifdef DEV_ENABLED +#define DEV_CHECK(m_cond) \ + if (unlikely(!(m_cond))) { \ + ERR_PRINT("DEV_CHECK failed \"" _STR(m_cond) "\" is false."); \ + } else \ + ((void)0) +#else +#define DEV_CHECK(m_cond) +#endif + +#ifdef DEV_ENABLED +#define DEV_CHECK_ONCE(m_cond) \ + if (unlikely(!(m_cond))) { \ + ERR_PRINT_ONCE("DEV_CHECK_ONCE failed \"" _STR(m_cond) "\" is false."); \ + } else \ + ((void)0) +#else +#define DEV_CHECK_ONCE(m_cond) +#endif + +#line 0 + +#line 1 "sfwl/core/memory.h" + +/*************************************************************************/ +/* memory.h */ +/* From https://github.com/Relintai/pandemonium_engine (MIT) */ +/*************************************************************************/ + +#ifndef PAD_ALIGN +#define PAD_ALIGN 16 //must always be greater than this at much +#endif + +class Memory { +#ifdef DEBUG_ENABLED + static SafeNumeric mem_usage; + static SafeNumeric max_usage; +#endif + + static SafeNumeric alloc_count; + +public: + static void *alloc_static(size_t p_bytes, bool p_pad_align = false); + static void *realloc_static(void *p_memory, size_t p_bytes, bool p_pad_align = false); + static void free_static(void *p_ptr, bool p_pad_align = false); + + static uint64_t get_mem_available(); + static uint64_t get_mem_usage(); + static uint64_t get_mem_max_usage(); +}; + +class DefaultAllocator { +public: + _FORCE_INLINE_ static void *alloc(size_t p_memory) { return Memory::alloc_static(p_memory, false); } + _FORCE_INLINE_ static void free(void *p_ptr) { Memory::free_static(p_ptr, false); } +}; + +void *operator new(size_t p_size, const char *p_description); ///< operator new that takes a description and uses MemoryStaticPool +void *operator new(size_t p_size, void *(*p_allocfunc)(size_t p_size)); ///< operator new that takes a description and uses MemoryStaticPool + +void *operator new(size_t p_size, void *p_pointer, size_t check, const char *p_description); ///< operator new that takes a description and uses a pointer to the preallocated memory + +#ifdef _MSC_VER +// When compiling with VC++ 2017, the above declarations of placement new generate many irrelevant warnings (C4291). +// The purpose of the following definitions is to muffle these warnings, not to provide a usable implementation of placement delete. +void operator delete(void *p_mem, const char *p_description); +void operator delete(void *p_mem, void *(*p_allocfunc)(size_t p_size)); +void operator delete(void *p_mem, void *p_pointer, size_t check, const char *p_description); +#endif + +#define memalloc(m_size) Memory::alloc_static(m_size) +#define memrealloc(m_mem, m_size) Memory::realloc_static(m_mem, m_size) +#define memfree(m_mem) Memory::free_static(m_mem) + +_ALWAYS_INLINE_ void postinitialize_handler(void *) {} + +template +_ALWAYS_INLINE_ T *_post_initialize(T *p_obj) { + postinitialize_handler(p_obj); + return p_obj; +} + +#define memnew(m_class) _post_initialize(new ("") m_class) + +_ALWAYS_INLINE_ void *operator new(size_t p_size, void *p_pointer, size_t check, const char *p_description) { + //void *failptr=0; + //ERR_FAIL_COND_V( check < p_size , failptr); /** bug, or strange compiler, most likely */ + + return p_pointer; +} + +#define memnew_allocator(m_class, m_allocator) _post_initialize(new (m_allocator::alloc) m_class) +#define memnew_placement(m_placement, m_class) _post_initialize(new (m_placement, sizeof(m_class), "") m_class) + +_ALWAYS_INLINE_ bool predelete_handler(void *) { + return true; +} + +template +void memdelete(T *p_class) { + if (!predelete_handler(p_class)) { + return; // doesn't want to be deleted + } + if (!HAS_TRIVIAL_DESTRUCTOR(T)) { + p_class->~T(); + } + + Memory::free_static(p_class, false); +} + +template +void memdelete_allocator(T *p_class) { + if (!predelete_handler(p_class)) { + return; // doesn't want to be deleted + } + if (!HAS_TRIVIAL_DESTRUCTOR(T)) { + p_class->~T(); + } + + A::free(p_class); +} + +#define memdelete_notnull(m_v) \ + { \ + if (m_v) \ + memdelete(m_v); \ + } + +#define memnew_arr(m_class, m_count) memnew_arr_template(m_count) + +template +T *memnew_arr_template(size_t p_elements, const char *p_descr = "") { + if (p_elements == 0) { + return nullptr; + } + /** overloading operator new[] cannot be done , because it may not return the real allocated address (it may pad the 'element count' before the actual array). Because of that, it must be done by hand. This is the + same strategy used by std::vector, and the PoolVector class, so it should be safe.*/ + + size_t len = sizeof(T) * p_elements; + uint64_t *mem = (uint64_t *)Memory::alloc_static(len, true); + T *failptr = nullptr; //get rid of a warning + ERR_FAIL_COND_V(!mem, failptr); + *(mem - 1) = p_elements; + + if (!HAS_TRIVIAL_CONSTRUCTOR(T)) { + T *elems = (T *)mem; + + /* call operator new */ + for (size_t i = 0; i < p_elements; i++) { + new (&elems[i], sizeof(T), p_descr) T; + } + } + + return (T *)mem; +} + +/** + * Wonders of having own array functions, you can actually check the length of + * an allocated-with memnew_arr() array + */ + +template +size_t memarr_len(const T *p_class) { + uint64_t *ptr = (uint64_t *)p_class; + return *(ptr - 1); +} + +template +void memdelete_arr(T *p_class) { + uint64_t *ptr = (uint64_t *)p_class; + + if (!HAS_TRIVIAL_DESTRUCTOR(T)) { + uint64_t elem_count = *(ptr - 1); + + for (uint64_t i = 0; i < elem_count; i++) { + p_class[i].~T(); + } + } + + Memory::free_static(ptr, true); +} + +struct _GlobalNil { + int color; + _GlobalNil *right; + _GlobalNil *left; + _GlobalNil *parent; + + _GlobalNil(); +}; + +struct _GlobalNilClass { + static _GlobalNil _nil; +}; + +#line 0 + +#line 1 "sfwl/core/mutex.h" + +/*************************************************************************/ +/* mutex.h */ +/* From https://github.com/Relintai/pandemonium_engine (MIT) */ +/*************************************************************************/ + +#if !defined(NO_THREADS) + +#include + +template +class MutexImpl { + mutable StdMutexT mutex; + friend class MutexLock; + +public: + _ALWAYS_INLINE_ void lock() const { + mutex.lock(); + } + + _ALWAYS_INLINE_ void unlock() const { + mutex.unlock(); + } + + _ALWAYS_INLINE_ Error try_lock() const { + return mutex.try_lock() ? OK : ERR_BUSY; + } +}; + +// This is written this way instead of being a template to overcome a limitation of C++ pre-17 +// that would require MutexLock to be used like this: MutexLock lock; +class MutexLock { + union { + std::recursive_mutex *recursive_mutex; + std::mutex *mutex; + }; + bool recursive; + +public: + _ALWAYS_INLINE_ explicit MutexLock(const MutexImpl &p_mutex) : + recursive_mutex(&p_mutex.mutex), + recursive(true) { + recursive_mutex->lock(); + } + _ALWAYS_INLINE_ explicit MutexLock(const MutexImpl &p_mutex) : + mutex(&p_mutex.mutex), + recursive(false) { + mutex->lock(); + } + + _ALWAYS_INLINE_ ~MutexLock() { + if (recursive) { + recursive_mutex->unlock(); + } else { + mutex->unlock(); + } + } +}; + +using Mutex = MutexImpl; // Recursive, for general use +using BinaryMutex = MutexImpl; // Non-recursive, handle with care + +extern template class MutexImpl; +extern template class MutexImpl; + +#else + +class FakeMutex { + FakeMutex() {} +}; + +template +class MutexImpl { +public: + _ALWAYS_INLINE_ void lock() const {} + _ALWAYS_INLINE_ void unlock() const {} + _ALWAYS_INLINE_ Error try_lock() const { return OK; } +}; + +class MutexLock { +public: + explicit MutexLock(const MutexImpl &p_mutex) {} +}; + +using Mutex = MutexImpl; +using BinaryMutex = MutexImpl; // Non-recursive, handle with care + +#endif // !NO_THREADS + +#line 0 + +#line 1 "sfwl/core/rw_lock.h" + +/*************************************************************************/ +/* rw_lock.h */ +/* From https://github.com/Relintai/pandemonium_engine (MIT) */ +/*************************************************************************/ + +#if !defined(NO_THREADS) + +#include + +class RWLock { + mutable std::shared_timed_mutex mutex; + +public: + // Lock the rwlock, block if locked by someone else + void read_lock() const { + mutex.lock_shared(); + } + + // Unlock the rwlock, let other threads continue + void read_unlock() const { + mutex.unlock_shared(); + } + + // Attempt to lock the rwlock, OK on success, ERR_BUSY means it can't lock. + Error read_try_lock() const { + return mutex.try_lock_shared() ? OK : ERR_BUSY; + } + + // Lock the rwlock, block if locked by someone else + void write_lock() { + mutex.lock(); + } + + // Unlock the rwlock, let other thwrites continue + void write_unlock() { + mutex.unlock(); + } + + // Attempt to lock the rwlock, OK on success, ERR_BUSY means it can't lock. + Error write_try_lock() { + return mutex.try_lock() ? OK : ERR_BUSY; + } +}; + +#else + +class RWLock { +public: + void read_lock() const {} + void read_unlock() const {} + Error read_try_lock() const { return OK; } + + void write_lock() {} + void write_unlock() {} + Error write_try_lock() { return OK; } +}; + +#endif + +class RWLockRead { + const RWLock &lock; + +public: + RWLockRead(const RWLock &p_lock) : + lock(p_lock) { + lock.read_lock(); + } + ~RWLockRead() { + lock.read_unlock(); + } +}; + +class RWLockWrite { + RWLock &lock; + +public: + RWLockWrite(RWLock &p_lock) : + lock(p_lock) { + lock.write_lock(); + } + ~RWLockWrite() { + lock.write_unlock(); + } +}; + +#line 0 + +#line 1 "sfwl/core/spin_lock.h" + +/*************************************************************************/ +/* spin_lock.h */ +/* From https://github.com/Relintai/pandemonium_engine (MIT) */ +/*************************************************************************/ + +class SpinLock { + std::atomic_flag locked = ATOMIC_FLAG_INIT; + +public: + _ALWAYS_INLINE_ void lock() { + while (locked.test_and_set(std::memory_order_acquire)) { + ; + } + } + _ALWAYS_INLINE_ void unlock() { + locked.clear(std::memory_order_release); + } +}; + +#line 0 + +#line 1 "sfwl/core/thread_safe.h" + +/*************************************************************************/ +/* thread_safe.h */ +/* From https://github.com/Relintai/pandemonium_engine (MIT) */ +/*************************************************************************/ + +#define _THREAD_SAFE_CLASS_ mutable Mutex _thread_safe_; +#define _THREAD_SAFE_METHOD_ MutexLock _thread_safe_method_(_thread_safe_); +#define _THREAD_SAFE_LOCK_ _thread_safe_.lock(); +#define _THREAD_SAFE_UNLOCK_ _thread_safe_.unlock(); + +#line 0 + +#line 1 "sfwl/core/pcg.h" +// *Really* minimal PCG32 code / (c) 2014 M.E. O'Neill / pcg-random.org +// Licensed under Apache License 2.0 (NO WARRANTY, etc. see website) + +#define PCG_DEFAULT_INC_64 1442695040888963407ULL + +typedef struct { + uint64_t state; + uint64_t inc; +} pcg32_random_t; +uint32_t pcg32_random_r(pcg32_random_t *rng); +void pcg32_srandom_r(pcg32_random_t *rng, uint64_t initstate, uint64_t initseq); +uint32_t pcg32_boundedrand_r(pcg32_random_t *rng, uint32_t bound); + +#line 0 + +#line 1 "sfwl/core/random_pcg.h" + +/*************************************************************************/ +/* random_pcg.h */ +/* From https://github.com/Relintai/pandemonium_engine (MIT) */ +/*************************************************************************/ + +#if defined(__GNUC__) || (_llvm_has_builtin(__builtin_clz)) +#define CLZ32(x) __builtin_clz(x) +#elif defined(_MSC_VER) +#include "intrin.h" +static int __bsr_clz32(uint32_t x) { + unsigned long index; + _BitScanReverse(&index, x); + return 31 - index; +} +#define CLZ32(x) __bsr_clz32(x) +#else +#endif + +#if defined(__GNUC__) || (_llvm_has_builtin(__builtin_ldexp) && _llvm_has_builtin(__builtin_ldexpf)) +#define LDEXP(s, e) __builtin_ldexp(s, e) +#define LDEXPF(s, e) __builtin_ldexpf(s, e) +#else +#include "math.h" +#define LDEXP(s, e) ldexp(s, e) +#define LDEXPF(s, e) ldexp(s, e) +#endif + +class RandomPCG { + pcg32_random_t pcg; + uint64_t current_seed; // The seed the current generator state started from. + uint64_t current_inc; + +public: + static const uint64_t DEFAULT_SEED = 12047754176567800795U; + static const uint64_t DEFAULT_INC = PCG_DEFAULT_INC_64; + + RandomPCG(uint64_t p_seed = DEFAULT_SEED, uint64_t p_inc = DEFAULT_INC); + + _FORCE_INLINE_ void seed(uint64_t p_seed) { + current_seed = p_seed; + pcg32_srandom_r(&pcg, current_seed, current_inc); + } + _FORCE_INLINE_ uint64_t get_seed() { return current_seed; } + + _FORCE_INLINE_ void set_state(uint64_t p_state) { pcg.state = p_state; } + _FORCE_INLINE_ uint64_t get_state() const { return pcg.state; } + + void randomize(); + _FORCE_INLINE_ uint32_t rand() { + return pcg32_random_r(&pcg); + } + _FORCE_INLINE_ uint32_t rand(uint32_t bounds) { + return pcg32_boundedrand_r(&pcg, bounds); + } + + // Obtaining floating point numbers in [0, 1] range with "good enough" uniformity. + // These functions sample the output of rand() as the fraction part of an infinite binary number, + // with some tricks applied to reduce ops and branching: + // 1. Instead of shifting to the first 1 and connecting random bits, we simply set the MSB and LSB to 1. + // Provided that the RNG is actually uniform bit by bit, this should have the exact same effect. + // 2. In order to compensate for exponent info loss, we count zeros from another random number, + // and just add that to the initial offset. + // This has the same probability as counting and shifting an actual bit stream: 2^-n for n zeroes. + // For all numbers above 2^-96 (2^-64 for floats), the functions should be uniform. + // However, all numbers below that threshold are floored to 0. + // The thresholds are chosen to minimize rand() calls while keeping the numbers within a totally subjective quality standard. + // If clz or ldexp isn't available, fall back to bit truncation for performance, sacrificing uniformity. + _FORCE_INLINE_ double randd() { +#if defined(CLZ32) + uint32_t proto_exp_offset = rand(); + if (unlikely(proto_exp_offset == 0)) { + return 0; + } + uint64_t significand = (((uint64_t)rand()) << 32) | rand() | 0x8000000000000001U; + return LDEXP((double)significand, -64 - CLZ32(proto_exp_offset)); +#else +#pragma message("RandomPCG::randd - intrinsic clz is not available, falling back to bit truncation") + return (double)(((((uint64_t)rand()) << 32) | rand()) & 0x1FFFFFFFFFFFFFU) / (double)0x1FFFFFFFFFFFFFU; +#endif + } + _FORCE_INLINE_ float randf() { +#if defined(CLZ32) + uint32_t proto_exp_offset = rand(); + if (unlikely(proto_exp_offset == 0)) { + return 0; + } + return LDEXPF((float)(rand() | 0x80000001), -32 - CLZ32(proto_exp_offset)); +#else +#pragma message("RandomPCG::randf - intrinsic clz is not available, falling back to bit truncation") + return (float)(rand() & 0xFFFFFF) / (float)0xFFFFFF; +#endif + } + + _FORCE_INLINE_ double randfn(double p_mean, double p_deviation) { + return p_mean + p_deviation * (cos(Math_TAU * randd()) * sqrt(-2.0 * log(randd()))); // Box-Muller transform + } + _FORCE_INLINE_ float randfn(float p_mean, float p_deviation) { + return p_mean + p_deviation * (cos(Math_TAU * randf()) * sqrt(-2.0 * log(randf()))); // Box-Muller transform + } + + double random(double p_from, double p_to); + float random(float p_from, float p_to); + real_t randomr(real_t p_from, real_t p_to) { return random(p_from, p_to); } + int random(int p_from, int p_to); +}; + +#line 0 + +#line 1 "sfwl/core/math_funcs.h" + +/*************************************************************************/ +/* math_funcs.h */ +/* From https://github.com/Relintai/pandemonium_engine (MIT) */ +/*************************************************************************/ + +class Math { + static RandomPCG default_rand; + +public: + Math() {} // useless to instance + + // Not using 'RANDOM_MAX' to avoid conflict with system headers on some OSes (at least NetBSD). + static const uint64_t RANDOM_32BIT_MAX = 0xFFFFFFFF; + + static _ALWAYS_INLINE_ double sin(double p_x) { return ::sin(p_x); } + static _ALWAYS_INLINE_ float sin(float p_x) { return ::sinf(p_x); } + + static _ALWAYS_INLINE_ double cos(double p_x) { return ::cos(p_x); } + static _ALWAYS_INLINE_ float cos(float p_x) { return ::cosf(p_x); } + + static _ALWAYS_INLINE_ double tan(double p_x) { return ::tan(p_x); } + static _ALWAYS_INLINE_ float tan(float p_x) { return ::tanf(p_x); } + + static _ALWAYS_INLINE_ double sinh(double p_x) { return ::sinh(p_x); } + static _ALWAYS_INLINE_ float sinh(float p_x) { return ::sinhf(p_x); } + + static _ALWAYS_INLINE_ float sinc(float p_x) { return p_x == 0 ? 1 : ::sin(p_x) / p_x; } + static _ALWAYS_INLINE_ double sinc(double p_x) { return p_x == 0 ? 1 : ::sin(p_x) / p_x; } + + static _ALWAYS_INLINE_ float sincn(float p_x) { return sinc((float)Math_PI * p_x); } + static _ALWAYS_INLINE_ double sincn(double p_x) { return sinc(Math_PI * p_x); } + + static _ALWAYS_INLINE_ double cosh(double p_x) { return ::cosh(p_x); } + static _ALWAYS_INLINE_ float cosh(float p_x) { return ::coshf(p_x); } + + static _ALWAYS_INLINE_ double tanh(double p_x) { return ::tanh(p_x); } + static _ALWAYS_INLINE_ float tanh(float p_x) { return ::tanhf(p_x); } + + // Always does clamping so always safe to use. + static _ALWAYS_INLINE_ double asin(double p_x) { return p_x < -1 ? (-Math_PI / 2) : (p_x > 1 ? (Math_PI / 2) : ::asin(p_x)); } + static _ALWAYS_INLINE_ float asin(float p_x) { return p_x < -1 ? (-Math_PI / 2) : (p_x > 1 ? (Math_PI / 2) : ::asinf(p_x)); } + + // Always does clamping so always safe to use. + static _ALWAYS_INLINE_ double acos(double p_x) { return p_x < -1 ? Math_PI : (p_x > 1 ? 0 : ::acos(p_x)); } + static _ALWAYS_INLINE_ float acos(float p_x) { return p_x < -1 ? Math_PI : (p_x > 1 ? 0 : ::acosf(p_x)); } + + static _ALWAYS_INLINE_ double asin_unsafe(double p_x) { return ::asin(p_x); } + static _ALWAYS_INLINE_ float asin_unsafe(float p_x) { return ::asinf(p_x); } + + static _ALWAYS_INLINE_ double acos_unsafe(double p_x) { return ::acos(p_x); } + static _ALWAYS_INLINE_ float acos_unsafe(float p_x) { return ::acosf(p_x); } + + static _ALWAYS_INLINE_ double atan(double p_x) { return ::atan(p_x); } + static _ALWAYS_INLINE_ float atan(float p_x) { return ::atanf(p_x); } + + static _ALWAYS_INLINE_ double atan2(double p_y, double p_x) { return ::atan2(p_y, p_x); } + static _ALWAYS_INLINE_ float atan2(float p_y, float p_x) { return ::atan2f(p_y, p_x); } + + static _ALWAYS_INLINE_ double sqrt(double p_x) { return ::sqrt(p_x); } + static _ALWAYS_INLINE_ float sqrt(float p_x) { return ::sqrtf(p_x); } + + static _ALWAYS_INLINE_ double fmod(double p_x, double p_y) { return ::fmod(p_x, p_y); } + static _ALWAYS_INLINE_ float fmod(float p_x, float p_y) { return ::fmodf(p_x, p_y); } + + static _ALWAYS_INLINE_ double floor(double p_x) { return ::floor(p_x); } + static _ALWAYS_INLINE_ float floor(float p_x) { return ::floorf(p_x); } + // x + 0.5 -> so f.e. 0.9999999 will become 1 + static _ALWAYS_INLINE_ int floorf_int(const float x) { return static_cast(x + 0.5); } + + static _ALWAYS_INLINE_ double ceil(double p_x) { return ::ceil(p_x); } + static _ALWAYS_INLINE_ float ceil(float p_x) { return ::ceilf(p_x); } + + static _ALWAYS_INLINE_ double pow(double p_x, double p_y) { return ::pow(p_x, p_y); } + static _ALWAYS_INLINE_ float pow(float p_x, float p_y) { return ::powf(p_x, p_y); } + + static _ALWAYS_INLINE_ double log(double p_x) { return ::log(p_x); } + static _ALWAYS_INLINE_ float log(float p_x) { return ::logf(p_x); } + + static _ALWAYS_INLINE_ double log1p(double p_x) { return ::log1p(p_x); } + static _ALWAYS_INLINE_ float log1p(float p_x) { return ::log1pf(p_x); } + + static _ALWAYS_INLINE_ double log10(double p_x) { return ::log10f(p_x); } + static _ALWAYS_INLINE_ float log10(float p_x) { return ::log10(p_x); } + + static _ALWAYS_INLINE_ double log2(double p_x) { return ::log2(p_x); } + static _ALWAYS_INLINE_ float log2(float p_x) { return ::log2f(p_x); } + + static _ALWAYS_INLINE_ double exp(double p_x) { return ::exp(p_x); } + static _ALWAYS_INLINE_ float exp(float p_x) { return ::expf(p_x); } + + static _ALWAYS_INLINE_ double erf(double p_x) { return ::erf(p_x); } + static _ALWAYS_INLINE_ float erf(float p_x) { return ::erff(p_x); } + + // can save typing static_cast + inline static float divf(const float a, const float b) { return a / b; } + + static _ALWAYS_INLINE_ bool is_nan(double p_val) { +#ifdef _MSC_VER + return _isnan(p_val); +#elif defined(__GNUC__) && __GNUC__ < 6 + union { + uint64_t u; + double f; + } ieee754; + ieee754.f = p_val; + // (unsigned)(0x7ff0000000000001 >> 32) : 0x7ff00000 + return ((((unsigned)(ieee754.u >> 32) & 0x7fffffff) + ((unsigned)ieee754.u != 0)) > 0x7ff00000); +#else + return isnan(p_val); +#endif + } + + static _ALWAYS_INLINE_ bool is_nan(float p_val) { +#ifdef _MSC_VER + return _isnan(p_val); +#elif defined(__GNUC__) && __GNUC__ < 6 + union { + uint32_t u; + float f; + } ieee754; + ieee754.f = p_val; + // ----------------------------------- + // (single-precision floating-point) + // NaN : s111 1111 1xxx xxxx xxxx xxxx xxxx xxxx + // : (> 0x7f800000) + // where, + // s : sign + // x : non-zero number + // ----------------------------------- + return ((ieee754.u & 0x7fffffff) > 0x7f800000); +#else + return isnan(p_val); +#endif + } + + static _ALWAYS_INLINE_ bool is_inf(double p_val) { +#ifdef _MSC_VER + return !_finite(p_val); +// use an inline implementation of isinf as a workaround for problematic libstdc++ versions from gcc 5.x era +#elif defined(__GNUC__) && __GNUC__ < 6 + union { + uint64_t u; + double f; + } ieee754; + ieee754.f = p_val; + return ((unsigned)(ieee754.u >> 32) & 0x7fffffff) == 0x7ff00000 && + ((unsigned)ieee754.u == 0); +#else + return isinf(p_val); +#endif + } + + static _ALWAYS_INLINE_ bool is_inf(float p_val) { +#ifdef _MSC_VER + return !_finite(p_val); +// use an inline implementation of isinf as a workaround for problematic libstdc++ versions from gcc 5.x era +#elif defined(__GNUC__) && __GNUC__ < 6 + union { + uint32_t u; + float f; + } ieee754; + ieee754.f = p_val; + return (ieee754.u & 0x7fffffff) == 0x7f800000; +#else + return isinf(p_val); +#endif + } + + static _ALWAYS_INLINE_ double abs(double g) { + return absd(g); + } + static _ALWAYS_INLINE_ float abs(float g) { + return absf(g); + } + static _ALWAYS_INLINE_ int abs(int g) { + return g > 0 ? g : -g; + } + static _ALWAYS_INLINE_ int64_t abs(int64_t g) { + return g > 0 ? g : -g; + } + static _ALWAYS_INLINE_ int absi(int g) { + return g > 0 ? g : -g; + } + static _ALWAYS_INLINE_ int64_t absi(int64_t g) { + return g > 0 ? g : -g; + } + + static _ALWAYS_INLINE_ double fposmod(double p_x, double p_y) { + double value = Math::fmod(p_x, p_y); + if (((value < 0) && (p_y > 0)) || ((value > 0) && (p_y < 0))) { + value += p_y; + } + value += 0.0; + return value; + } + static _ALWAYS_INLINE_ float fposmod(float p_x, float p_y) { + float value = Math::fmod(p_x, p_y); + if (((value < 0) && (p_y > 0)) || ((value > 0) && (p_y < 0))) { + value += p_y; + } + value += 0.0f; + return value; + } + + static _ALWAYS_INLINE_ float fposmodp(float p_x, float p_y) { + float value = Math::fmod(p_x, p_y); + if (value < 0) { + value += p_y; + } + value += 0.0f; + return value; + } + static _ALWAYS_INLINE_ double fposmodp(double p_x, double p_y) { + double value = Math::fmod(p_x, p_y); + if (value < 0) { + value += p_y; + } + value += 0.0; + return value; + } + + static _ALWAYS_INLINE_ int64_t posmod(int64_t p_x, int64_t p_y) { + ERR_FAIL_COND_V_MSG(p_y == 0, 0, "Division by zero in posmod is undefined. Returning 0 as fallback."); + int64_t value = p_x % p_y; + if (((value < 0) && (p_y > 0)) || ((value > 0) && (p_y < 0))) { + value += p_y; + } + return value; + } + + static _ALWAYS_INLINE_ double deg2rad(double p_y) { + return p_y * Math_PI / 180.0; + } + static _ALWAYS_INLINE_ float deg2rad(float p_y) { + return p_y * (float)(Math_PI / 180.0); + } + + static _ALWAYS_INLINE_ double rad2deg(double p_y) { + return p_y * 180.0 / Math_PI; + } + static _ALWAYS_INLINE_ float rad2deg(float p_y) { + return p_y * (float)(180.0 / Math_PI); + } + + static _ALWAYS_INLINE_ double lerp(double p_from, double p_to, double p_weight) { + return p_from + (p_to - p_from) * p_weight; + } + static _ALWAYS_INLINE_ float lerp(float p_from, float p_to, float p_weight) { + return p_from + (p_to - p_from) * p_weight; + } + + static _ALWAYS_INLINE_ double lerp_angle(double p_from, double p_to, double p_weight) { + double difference = fmod(p_to - p_from, Math_TAU); + double distance = fmod(2.0 * difference, Math_TAU) - difference; + return p_from + distance * p_weight; + } + static _ALWAYS_INLINE_ float lerp_angle(float p_from, float p_to, float p_weight) { + float difference = fmod(p_to - p_from, (float)Math_TAU); + float distance = fmod(2.0f * difference, (float)Math_TAU) - difference; + return p_from + distance * p_weight; + } + + static _ALWAYS_INLINE_ double inverse_lerp(double p_from, double p_to, double p_value) { + return (p_value - p_from) / (p_to - p_from); + } + static _ALWAYS_INLINE_ float inverse_lerp(float p_from, float p_to, float p_value) { + return (p_value - p_from) / (p_to - p_from); + } + + static _ALWAYS_INLINE_ double range_lerp(double p_value, double p_istart, double p_istop, double p_ostart, double p_ostop) { + return Math::lerp(p_ostart, p_ostop, Math::inverse_lerp(p_istart, p_istop, p_value)); + } + static _ALWAYS_INLINE_ float range_lerp(float p_value, float p_istart, float p_istop, float p_ostart, float p_ostop) { + return Math::lerp(p_ostart, p_ostop, Math::inverse_lerp(p_istart, p_istop, p_value)); + } + + static _ALWAYS_INLINE_ double cubic_interpolate(double p_from, double p_to, double p_pre, double p_post, double p_weight) { + return 0.5 * + ((p_from * 2.0) + + (-p_pre + p_to) * p_weight + + (2.0 * p_pre - 5.0 * p_from + 4.0 * p_to - p_post) * (p_weight * p_weight) + + (-p_pre + 3.0 * p_from - 3.0 * p_to + p_post) * (p_weight * p_weight * p_weight)); + } + static _ALWAYS_INLINE_ float cubic_interpolate(float p_from, float p_to, float p_pre, float p_post, float p_weight) { + return 0.5f * + ((p_from * 2.0f) + + (-p_pre + p_to) * p_weight + + (2.0f * p_pre - 5.0f * p_from + 4.0f * p_to - p_post) * (p_weight * p_weight) + + (-p_pre + 3.0f * p_from - 3.0f * p_to + p_post) * (p_weight * p_weight * p_weight)); + } + + static _ALWAYS_INLINE_ double bezier_interpolate(double p_start, double p_control_1, double p_control_2, double p_end, double p_t) { + /* Formula from Wikipedia article on Bezier curves. */ + double omt = (1.0 - p_t); + double omt2 = omt * omt; + double omt3 = omt2 * omt; + double t2 = p_t * p_t; + double t3 = t2 * p_t; + + return p_start * omt3 + p_control_1 * omt2 * p_t * 3.0 + p_control_2 * omt * t2 * 3.0 + p_end * t3; + } + static _ALWAYS_INLINE_ float bezier_interpolate(float p_start, float p_control_1, float p_control_2, float p_end, float p_t) { + /* Formula from Wikipedia article on Bezier curves. */ + float omt = (1.0f - p_t); + float omt2 = omt * omt; + float omt3 = omt2 * omt; + float t2 = p_t * p_t; + float t3 = t2 * p_t; + + return p_start * omt3 + p_control_1 * omt2 * p_t * 3.0f + p_control_2 * omt * t2 * 3.0f + p_end * t3; + } + + static _ALWAYS_INLINE_ double smoothstep(double p_from, double p_to, double p_s) { + if (is_equal_approx(p_from, p_to)) { + return p_from; + } + double s = CLAMP((p_s - p_from) / (p_to - p_from), 0.0, 1.0); + return s * s * (3.0 - 2.0 * s); + } + static _ALWAYS_INLINE_ float smoothstep(float p_from, float p_to, float p_s) { + if (is_equal_approx(p_from, p_to)) { + return p_from; + } + float s = CLAMP((p_s - p_from) / (p_to - p_from), 0.0f, 1.0f); + return s * s * (3.0f - 2.0f * s); + } + static _ALWAYS_INLINE_ double move_toward(double p_from, double p_to, double p_delta) { + return abs(p_to - p_from) <= p_delta ? p_to : p_from + SGN(p_to - p_from) * p_delta; + } + static _ALWAYS_INLINE_ float move_toward(float p_from, float p_to, float p_delta) { + return abs(p_to - p_from) <= p_delta ? p_to : p_from + SGN(p_to - p_from) * p_delta; + } + + static _ALWAYS_INLINE_ double linear2db(double p_linear) { + return Math::log(p_linear) * 8.6858896380650365530225783783321; + } + static _ALWAYS_INLINE_ float linear2db(float p_linear) { + return Math::log(p_linear) * (float)8.6858896380650365530225783783321; + } + + static _ALWAYS_INLINE_ double db2linear(double p_db) { + return Math::exp(p_db * 0.11512925464970228420089957273422); + } + static _ALWAYS_INLINE_ float db2linear(float p_db) { + return Math::exp(p_db * (float)0.11512925464970228420089957273422); + } + + static _ALWAYS_INLINE_ double round(double p_val) { + return ::round(p_val); + } + static _ALWAYS_INLINE_ float round(float p_val) { + return ::roundf(p_val); + } + + static _ALWAYS_INLINE_ int64_t wrapi(int64_t value, int64_t min, int64_t max) { + int64_t range = max - min; + return range == 0 ? min : min + ((((value - min) % range) + range) % range); + } + static _ALWAYS_INLINE_ double wrapf(double value, double min, double max) { + double range = max - min; + double result = is_zero_approx(range) ? min : value - (range * Math::floor((value - min) / range)); + if (is_equal_approx(result, max)) { + return min; + } + return result; + } + static _ALWAYS_INLINE_ float wrapf(float value, float min, float max) { + float range = max - min; + float result = is_zero_approx(range) ? min : value - (range * Math::floor((value - min) / range)); + if (is_equal_approx(result, max)) { + return min; + } + return result; + } + + static _ALWAYS_INLINE_ float fract(float value) { + return value - floor(value); + } + static _ALWAYS_INLINE_ double fract(double value) { + return value - floor(value); + } + static _ALWAYS_INLINE_ float pingpong(float value, float length) { + return (length != 0.0f) ? abs(fract((value - length) / (length * 2.0f)) * length * 2.0f - length) : 0.0f; + } + static _ALWAYS_INLINE_ double pingpong(double value, double length) { + return (length != 0.0) ? abs(fract((value - length) / (length * 2.0)) * length * 2.0 - length) : 0.0; + } + + // double only, as these functions are mainly used by the editor and not performance-critical, + static double ease(double p_x, double p_c); + static int step_decimals(double p_step); + static int range_step_decimals(double p_step); + static double stepify(double p_value, double p_step); + static double dectime(double p_value, double p_amount, double p_step); + + static uint32_t larger_prime(uint32_t p_val); + + static void seed(uint64_t x); + static void randomize(); + static uint32_t rand_from_seed(uint64_t *seed); + static uint32_t rand(); + static _ALWAYS_INLINE_ double randd() { + return (double)rand() / (double)Math::RANDOM_32BIT_MAX; + } + static _ALWAYS_INLINE_ float randf() { + return (float)rand() / (float)Math::RANDOM_32BIT_MAX; + } + static double randfn(double mean, double deviation); + + static double random(double from, double to); + static float random(float from, float to); + static real_t randomr(real_t from, real_t to); + static int random(int from, int to); + static _ALWAYS_INLINE_ int randomi(int from, int to) { + return random(from, to); + } + + static _ALWAYS_INLINE_ bool is_equal_approx_ratio(real_t a, real_t b, real_t epsilon = CMP_EPSILON, real_t min_epsilon = CMP_EPSILON) { + // this is an approximate way to check that numbers are close, as a ratio of their average size + // helps compare approximate numbers that may be very big or very small + real_t diff = abs(a - b); + if (diff == 0 || diff < min_epsilon) { + return true; + } + real_t avg_size = (abs(a) + abs(b)) / 2; + diff /= avg_size; + return diff < epsilon; + } + + static _ALWAYS_INLINE_ bool is_equal_approx(float a, float b) { + // Check for exact equality first, required to handle "infinity" values. + if (a == b) { + return true; + } + // Then check for approximate equality. + float tolerance = (float)CMP_EPSILON * abs(a); + if (tolerance < (float)CMP_EPSILON) { + tolerance = (float)CMP_EPSILON; + } + return abs(a - b) < tolerance; + } + + static _ALWAYS_INLINE_ bool is_equal_approx(float a, float b, float tolerance) { + // Check for exact equality first, required to handle "infinity" values. + if (a == b) { + return true; + } + // Then check for approximate equality. + return abs(a - b) < tolerance; + } + + static _ALWAYS_INLINE_ bool is_equal_approxt(float a, float b, float tolerance) { + // Check for exact equality first, required to handle "infinity" values. + if (a == b) { + return true; + } + // Then check for approximate equality. + return abs(a - b) < tolerance; + } + + static _ALWAYS_INLINE_ bool is_zero_approx(float s) { + return abs(s) < (float)CMP_EPSILON; + } + + static _ALWAYS_INLINE_ bool is_equal_approx(double a, double b) { + // Check for exact equality first, required to handle "infinity" values. + if (a == b) { + return true; + } + // Then check for approximate equality. + double tolerance = CMP_EPSILON * abs(a); + if (tolerance < CMP_EPSILON) { + tolerance = CMP_EPSILON; + } + return abs(a - b) < tolerance; + } + + static _ALWAYS_INLINE_ bool is_equal_approx(double a, double b, double tolerance) { + // Check for exact equality first, required to handle "infinity" values. + if (a == b) { + return true; + } + // Then check for approximate equality. + return abs(a - b) < tolerance; + } + + static _ALWAYS_INLINE_ bool is_zero_approx(double s) { + return abs(s) < CMP_EPSILON; + } + + static _ALWAYS_INLINE_ float absf(float g) { + union { + float f; + uint32_t i; + } u; + + u.f = g; + u.i &= 2147483647u; + return u.f; + } + + static _ALWAYS_INLINE_ double absd(double g) { + union { + double d; + uint64_t i; + } u; + u.d = g; + u.i &= (uint64_t)9223372036854775807ll; + return u.d; + } + + // This function should be as fast as possible and rounding mode should not matter. + static _ALWAYS_INLINE_ int fast_ftoi(float a) { + // Assuming every supported compiler has `lrint()`. + return lrintf(a); + } + + static _ALWAYS_INLINE_ uint32_t halfbits_to_floatbits(uint16_t h) { + uint16_t h_exp, h_sig; + uint32_t f_sgn, f_exp, f_sig; + + h_exp = (h & 0x7c00u); + f_sgn = ((uint32_t)h & 0x8000u) << 16; + switch (h_exp) { + case 0x0000u: /* 0 or subnormal */ + h_sig = (h & 0x03ffu); + /* Signed zero */ + if (h_sig == 0) { + return f_sgn; + } + /* Subnormal */ + h_sig <<= 1; + while ((h_sig & 0x0400u) == 0) { + h_sig <<= 1; + h_exp++; + } + f_exp = ((uint32_t)(127 - 15 - h_exp)) << 23; + f_sig = ((uint32_t)(h_sig & 0x03ffu)) << 13; + return f_sgn + f_exp + f_sig; + case 0x7c00u: /* inf or NaN */ + /* All-ones exponent and a copy of the significand */ + return f_sgn + 0x7f800000u + (((uint32_t)(h & 0x03ffu)) << 13); + default: /* normalized */ + /* Just need to adjust the exponent and shift */ + return f_sgn + (((uint32_t)(h & 0x7fffu) + 0x1c000u) << 13); + } + } + + static _ALWAYS_INLINE_ float halfptr_to_float(const uint16_t *h) { + union { + uint32_t u32; + float f32; + } u; + + u.u32 = halfbits_to_floatbits(*h); + return u.f32; + } + + static _ALWAYS_INLINE_ float half_to_float(const uint16_t h) { + return halfptr_to_float(&h); + } + + static _ALWAYS_INLINE_ uint16_t make_half_float(float f) { + union { + float fv; + uint32_t ui; + } ci; + ci.fv = f; + + uint32_t x = ci.ui; + uint32_t sign = (unsigned short)(x >> 31); + uint32_t mantissa; + uint32_t exp; + uint16_t hf; + + // get mantissa + mantissa = x & ((1 << 23) - 1); + // get exponent bits + exp = x & (0xFF << 23); + if (exp >= 0x47800000) { + // check if the original single precision float number is a NaN + if (mantissa && (exp == (0xFF << 23))) { + // we have a single precision NaN + mantissa = (1 << 23) - 1; + } else { + // 16-bit half-float representation stores number as Inf + mantissa = 0; + } + hf = (((uint16_t)sign) << 15) | (uint16_t)((0x1F << 10)) | + (uint16_t)(mantissa >> 13); + } + // check if exponent is <= -15 + else if (exp <= 0x38000000) { + /*// store a denorm half-float value or zero + exp = (0x38000000 - exp) >> 23; + mantissa >>= (14 + exp); + + hf = (((uint16_t)sign) << 15) | (uint16_t)(mantissa); + */ + hf = 0; //denormals do not work for 3D, convert to zero + } else { + hf = (((uint16_t)sign) << 15) | + (uint16_t)((exp - 0x38000000) >> 13) | + (uint16_t)(mantissa >> 13); + } + + return hf; + } + + static _ALWAYS_INLINE_ float snap_scalar(float p_offset, float p_step, float p_target) { + return p_step != 0 ? Math::stepify(p_target - p_offset, p_step) + p_offset : p_target; + } + + static _ALWAYS_INLINE_ float snap_scalar_separation(float p_offset, float p_step, float p_target, float p_separation) { + if (p_step != 0) { + float a = Math::stepify(p_target - p_offset, p_step + p_separation) + p_offset; + float b = a; + if (p_target >= 0) { + b -= p_separation; + } else { + b += p_step; + } + return (Math::abs(p_target - a) < Math::abs(p_target - b)) ? a : b; + } + return p_target; + } +}; + +#line 0 + +#line 1 "sfwl/core/cowdata.h" + +/*************************************************************************/ +/* cowdata.h */ +/* From https://github.com/Relintai/pandemonium_engine (MIT) */ +/*************************************************************************/ + +template +class Vector; +class String; +class Char16String; +class CharString; +template +class VMap; + +#if !defined(NO_THREADS) +SAFE_NUMERIC_TYPE_PUN_GUARANTEES(uint32_t) +#endif + +template +class CowData { + template + friend class Vector; + friend class String; + friend class Char16String; + friend class CharString; + template + friend class VMap; + +private: + mutable T *_ptr; + + // internal helpers + + _FORCE_INLINE_ SafeNumeric *_get_refcount() const { + if (!_ptr) { + return nullptr; + } + + return reinterpret_cast *>(_ptr) - 2; + } + + _FORCE_INLINE_ uint32_t *_get_size() const { + if (!_ptr) { + return nullptr; + } + + return reinterpret_cast(_ptr) - 1; + } + + _FORCE_INLINE_ size_t _get_alloc_size(size_t p_elements) const { + //return nearest_power_of_2_templated(p_elements*sizeof(T)+sizeof(SafeRefCount)+sizeof(int)); + return next_power_of_2(p_elements * sizeof(T)); + } + + _FORCE_INLINE_ bool _get_alloc_size_checked(size_t p_elements, size_t *out) const { +#if defined(_add_overflow) && defined(_mul_overflow) + size_t o; + size_t p; + if (_mul_overflow(p_elements, sizeof(T), &o)) { + *out = 0; + return false; + } + *out = next_power_of_2(o); + if (_add_overflow(o, static_cast(32), &p)) { + return false; //no longer allocated here + } + return true; +#else + // Speed is more important than correctness here, do the operations unchecked + // and hope the best + *out = _get_alloc_size(p_elements); + return true; +#endif + } + + void _unref(void *p_data); + void _ref(const CowData *p_from); + void _ref(const CowData &p_from); + uint32_t _copy_on_write(); + +public: + void operator=(const CowData &p_from) { _ref(p_from); } + + _FORCE_INLINE_ T *ptrw() { + _copy_on_write(); + return _ptr; + } + + _FORCE_INLINE_ const T *ptr() const { + return _ptr; + } + + _FORCE_INLINE_ int size() const { + uint32_t *size = (uint32_t *)_get_size(); + if (size) { + return *size; + } else { + return 0; + } + } + + _FORCE_INLINE_ void clear() { resize(0); } + _FORCE_INLINE_ bool empty() const { return _ptr == nullptr; } + + _FORCE_INLINE_ void set(int p_index, const T &p_elem) { + CRASH_BAD_INDEX(p_index, size()); + _copy_on_write(); + _ptr[p_index] = p_elem; + } + + _FORCE_INLINE_ T &get_m(int p_index) { + CRASH_BAD_INDEX(p_index, size()); + _copy_on_write(); + return _ptr[p_index]; + } + + _FORCE_INLINE_ const T &get(int p_index) const { + CRASH_BAD_INDEX(p_index, size()); + + return _ptr[p_index]; + } + + Error resize(int p_size); + + _FORCE_INLINE_ void remove(int p_index) { + ERR_FAIL_INDEX(p_index, size()); + T *p = ptrw(); + int len = size(); + for (int i = p_index; i < len - 1; i++) { + p[i] = p[i + 1]; + }; + + resize(len - 1); + } + + Error insert(int p_pos, const T &p_val) { + ERR_FAIL_INDEX_V(p_pos, size() + 1, ERR_INVALID_PARAMETER); + resize(size() + 1); + for (int i = (size() - 1); i > p_pos; i--) { + set(i, get(i - 1)); + } + set(p_pos, p_val); + + return OK; + } + + void fill(const T &p_val) { + int len = size(); + + if (len == 0) { + return; + } + + T *p = ptrw(); + for (int i = 0; i < len; ++i) { + p[i] = p_val; + } + } + + int find(const T &p_val, int p_from = 0) const; + + _FORCE_INLINE_ CowData(); + _FORCE_INLINE_ ~CowData(); + _FORCE_INLINE_ CowData(CowData &p_from) { _ref(p_from); }; +}; + +template +void CowData::_unref(void *p_data) { + if (!p_data) { + return; + } + + SafeNumeric *refc = _get_refcount(); + + if (refc->decrement() > 0) { + return; // still in use + } + // clean up + + if (!HAS_TRIVIAL_DESTRUCTOR(T)) { + uint32_t *count = _get_size(); + T *data = (T *)(count + 1); + + for (uint32_t i = 0; i < *count; ++i) { + // call destructors + data[i].~T(); + } + } + + // free mem + Memory::free_static((uint8_t *)p_data, true); +} + +template +uint32_t CowData::_copy_on_write() { + if (!_ptr) { + return 0; + } + + SafeNumeric *refc = _get_refcount(); + + uint32_t rc = refc->get(); + if (likely(rc > 1)) { + /* in use by more than me */ + uint32_t current_size = *_get_size(); + + uint32_t *mem_new = (uint32_t *)Memory::alloc_static(_get_alloc_size(current_size), true); + + new (mem_new - 2, sizeof(uint32_t), "") SafeNumeric(1); //refcount + *(mem_new - 1) = current_size; //size + + T *_data = (T *)(mem_new); + + // initialize new elements + if (HAS_TRIVIAL_COPY(T)) { + memcpy(mem_new, _ptr, current_size * sizeof(T)); + + } else { + for (uint32_t i = 0; i < current_size; i++) { + memnew_placement(&_data[i], T(_ptr[i])); + } + } + + _unref(_ptr); + _ptr = _data; + + rc = 1; + } + return rc; +} + +template +Error CowData::resize(int p_size) { + ERR_FAIL_COND_V(p_size < 0, ERR_INVALID_PARAMETER); + + int current_size = size(); + + if (p_size == current_size) { + return OK; + } + + if (p_size == 0) { + // wants to clean up + _unref(_ptr); + _ptr = nullptr; + return OK; + } + + // possibly changing size, copy on write + uint32_t rc = _copy_on_write(); + + size_t current_alloc_size = _get_alloc_size(current_size); + size_t alloc_size; + ERR_FAIL_COND_V(!_get_alloc_size_checked(p_size, &alloc_size), ERR_OUT_OF_MEMORY); + + if (p_size > current_size) { + if (alloc_size != current_alloc_size) { + if (current_size == 0) { + // alloc from scratch + uint32_t *ptr = (uint32_t *)Memory::alloc_static(alloc_size, true); + ERR_FAIL_COND_V(!ptr, ERR_OUT_OF_MEMORY); + *(ptr - 1) = 0; //size, currently none + new (ptr - 2, sizeof(uint32_t), "") SafeNumeric(1); //refcount + + _ptr = (T *)ptr; + + } else { + uint32_t *_ptrnew = (uint32_t *)Memory::realloc_static(_ptr, alloc_size, true); + ERR_FAIL_COND_V(!_ptrnew, ERR_OUT_OF_MEMORY); + new (_ptrnew - 2, sizeof(uint32_t), "") SafeNumeric(rc); //refcount + + _ptr = (T *)(_ptrnew); + } + } + + // construct the newly created elements + + if (!HAS_TRIVIAL_CONSTRUCTOR(T)) { + for (int i = *_get_size(); i < p_size; i++) { + memnew_placement(&_ptr[i], T); + } + } + + *_get_size() = p_size; + + } else if (p_size < current_size) { + if (!HAS_TRIVIAL_DESTRUCTOR(T)) { + // deinitialize no longer needed elements + for (uint32_t i = p_size; i < *_get_size(); i++) { + T *t = &_ptr[i]; + t->~T(); + } + } + + if (alloc_size != current_alloc_size) { + uint32_t *_ptrnew = (uint32_t *)Memory::realloc_static(_ptr, alloc_size, true); + ERR_FAIL_COND_V(!_ptrnew, ERR_OUT_OF_MEMORY); + new (_ptrnew - 2, sizeof(uint32_t), "") SafeNumeric(rc); //refcount + + _ptr = (T *)(_ptrnew); + } + + *_get_size() = p_size; + } + + return OK; +} + +template +int CowData::find(const T &p_val, int p_from) const { + int ret = -1; + + if (p_from < 0 || size() == 0) { + return ret; + } + + for (int i = p_from; i < size(); i++) { + if (get(i) == p_val) { + ret = i; + break; + } + } + + return ret; +} + +template +void CowData::_ref(const CowData *p_from) { + _ref(*p_from); +} + +template +void CowData::_ref(const CowData &p_from) { + if (_ptr == p_from._ptr) { + return; // self assign, do nothing. + } + + _unref(_ptr); + _ptr = nullptr; + + if (!p_from._ptr) { + return; //nothing to do + } + + if (p_from._get_refcount()->conditional_increment() > 0) { // could reference + _ptr = p_from._ptr; + } +} + +template +CowData::CowData() { + _ptr = nullptr; +} + +template +CowData::~CowData() { + _unref(_ptr); +} + +#line 0 + +#line 1 "sfwl/core/sort_array.h" + +/*************************************************************************/ +/* sort_array.h */ +/* From https://github.com/Relintai/pandemonium_engine (MIT) */ +/*************************************************************************/ + +#define ERR_BAD_COMPARE(cond) \ + if (unlikely(cond)) { \ + ERR_PRINT("bad comparison function; sorting will be broken"); \ + break; \ + } + +template +struct _DefaultComparator { + _FORCE_INLINE_ bool operator()(const T &a, const T &b) const { return (a < b); } +}; + +#ifdef DEBUG_ENABLED +#define SORT_ARRAY_VALIDATE_ENABLED true +#else +#define SORT_ARRAY_VALIDATE_ENABLED false +#endif + +template , bool Validate = SORT_ARRAY_VALIDATE_ENABLED> +class SortArray { + enum { + + INTROSORT_THRESHOLD = 16 + }; + +public: + Comparator compare; + + inline const T &median_of_3(const T &a, const T &b, const T &c) const { + if (compare(a, b)) { + if (compare(b, c)) { + return b; + } else if (compare(a, c)) { + return c; + } else { + return a; + } + } else if (compare(a, c)) { + return a; + } else if (compare(b, c)) { + return c; + } else { + return b; + } + } + + inline int bitlog(int n) const { + int k; + for (k = 0; n != 1; n >>= 1) { + ++k; + } + return k; + } + + /* Heap / Heapsort functions */ + + inline void push_heap(int p_first, int p_hole_idx, int p_top_index, T p_value, T *p_array) const { + int parent = (p_hole_idx - 1) / 2; + while (p_hole_idx > p_top_index && compare(p_array[p_first + parent], p_value)) { + p_array[p_first + p_hole_idx] = p_array[p_first + parent]; + p_hole_idx = parent; + parent = (p_hole_idx - 1) / 2; + } + p_array[p_first + p_hole_idx] = p_value; + } + + inline void pop_heap(int p_first, int p_last, int p_result, T p_value, T *p_array) const { + p_array[p_result] = p_array[p_first]; + adjust_heap(p_first, 0, p_last - p_first, p_value, p_array); + } + inline void pop_heap(int p_first, int p_last, T *p_array) const { + pop_heap(p_first, p_last - 1, p_last - 1, p_array[p_last - 1], p_array); + } + + inline void adjust_heap(int p_first, int p_hole_idx, int p_len, T p_value, T *p_array) const { + int top_index = p_hole_idx; + int second_child = 2 * p_hole_idx + 2; + + while (second_child < p_len) { + if (compare(p_array[p_first + second_child], p_array[p_first + (second_child - 1)])) { + second_child--; + } + + p_array[p_first + p_hole_idx] = p_array[p_first + second_child]; + p_hole_idx = second_child; + second_child = 2 * (second_child + 1); + } + + if (second_child == p_len) { + p_array[p_first + p_hole_idx] = p_array[p_first + (second_child - 1)]; + p_hole_idx = second_child - 1; + } + push_heap(p_first, p_hole_idx, top_index, p_value, p_array); + } + + inline void sort_heap(int p_first, int p_last, T *p_array) const { + while (p_last - p_first > 1) { + pop_heap(p_first, p_last--, p_array); + } + } + + inline void make_heap(int p_first, int p_last, T *p_array) const { + if (p_last - p_first < 2) { + return; + } + int len = p_last - p_first; + int parent = (len - 2) / 2; + + while (true) { + adjust_heap(p_first, parent, len, p_array[p_first + parent], p_array); + if (parent == 0) { + return; + } + parent--; + } + } + + inline void partial_sort(int p_first, int p_last, int p_middle, T *p_array) const { + make_heap(p_first, p_middle, p_array); + for (int i = p_middle; i < p_last; i++) { + if (compare(p_array[i], p_array[p_first])) { + pop_heap(p_first, p_middle, i, p_array[i], p_array); + } + } + sort_heap(p_first, p_middle, p_array); + } + + inline void partial_select(int p_first, int p_last, int p_middle, T *p_array) const { + make_heap(p_first, p_middle, p_array); + for (int i = p_middle; i < p_last; i++) { + if (compare(p_array[i], p_array[p_first])) { + pop_heap(p_first, p_middle, i, p_array[i], p_array); + } + } + } + + inline int partitioner(int p_first, int p_last, T p_pivot, T *p_array) const { + const int unmodified_first = p_first; + const int unmodified_last = p_last; + + while (true) { + while (compare(p_array[p_first], p_pivot)) { + if (Validate) { + ERR_BAD_COMPARE(p_first == unmodified_last - 1); + } + p_first++; + } + p_last--; + while (compare(p_pivot, p_array[p_last])) { + if (Validate) { + ERR_BAD_COMPARE(p_last == unmodified_first); + } + p_last--; + } + + if (!(p_first < p_last)) { + return p_first; + } + + SWAP(p_array[p_first], p_array[p_last]); + p_first++; + } + } + + inline void introsort(int p_first, int p_last, T *p_array, int p_max_depth) const { + while (p_last - p_first > INTROSORT_THRESHOLD) { + if (p_max_depth == 0) { + partial_sort(p_first, p_last, p_last, p_array); + return; + } + + p_max_depth--; + + int cut = partitioner( + p_first, + p_last, + median_of_3( + p_array[p_first], + p_array[p_first + (p_last - p_first) / 2], + p_array[p_last - 1]), + p_array); + + introsort(cut, p_last, p_array, p_max_depth); + p_last = cut; + } + } + + inline void introselect(int p_first, int p_nth, int p_last, T *p_array, int p_max_depth) const { + while (p_last - p_first > 3) { + if (p_max_depth == 0) { + partial_select(p_first, p_nth + 1, p_last, p_array); + SWAP(p_first, p_nth); + return; + } + + p_max_depth--; + + int cut = partitioner( + p_first, + p_last, + median_of_3( + p_array[p_first], + p_array[p_first + (p_last - p_first) / 2], + p_array[p_last - 1]), + p_array); + + if (cut <= p_nth) { + p_first = cut; + } else { + p_last = cut; + } + } + + insertion_sort(p_first, p_last, p_array); + } + + inline void unguarded_linear_insert(int p_last, T p_value, T *p_array) const { + int next = p_last - 1; + while (compare(p_value, p_array[next])) { + if (Validate) { + ERR_BAD_COMPARE(next == 0); + } + p_array[p_last] = p_array[next]; + p_last = next; + next--; + } + p_array[p_last] = p_value; + } + + inline void linear_insert(int p_first, int p_last, T *p_array) const { + T val = p_array[p_last]; + if (compare(val, p_array[p_first])) { + for (int i = p_last; i > p_first; i--) { + p_array[i] = p_array[i - 1]; + } + + p_array[p_first] = val; + } else { + unguarded_linear_insert(p_last, val, p_array); + } + } + + inline void insertion_sort(int p_first, int p_last, T *p_array) const { + if (p_first == p_last) { + return; + } + for (int i = p_first + 1; i != p_last; i++) { + linear_insert(p_first, i, p_array); + } + } + + inline void unguarded_insertion_sort(int p_first, int p_last, T *p_array) const { + for (int i = p_first; i != p_last; i++) { + unguarded_linear_insert(i, p_array[i], p_array); + } + } + + inline void final_insertion_sort(int p_first, int p_last, T *p_array) const { + if (p_last - p_first > INTROSORT_THRESHOLD) { + insertion_sort(p_first, p_first + INTROSORT_THRESHOLD, p_array); + unguarded_insertion_sort(p_first + INTROSORT_THRESHOLD, p_last, p_array); + } else { + insertion_sort(p_first, p_last, p_array); + } + } + + inline void sort_range(int p_first, int p_last, T *p_array) const { + if (p_first != p_last) { + introsort(p_first, p_last, p_array, bitlog(p_last - p_first) * 2); + final_insertion_sort(p_first, p_last, p_array); + } + } + + inline void sort(T *p_array, int p_len) const { + sort_range(0, p_len, p_array); + } + + inline void nth_element(int p_first, int p_last, int p_nth, T *p_array) const { + if (p_first == p_last || p_nth == p_last) { + return; + } + introselect(p_first, p_nth, p_last, p_array, bitlog(p_last - p_first) * 2); + } +}; + +#undef ERR_BAD_COMPARE + +#line 0 + +#line 1 "sfwl/core/rb_map.h" + +/*************************************************************************/ +/* rb_map.h */ +/* From https://github.com/Relintai/pandemonium_engine (MIT) */ +/*************************************************************************/ + +// based on the very nice implementation of rb-trees by: +// https://web.archive.org/web/20120507164830/http://web.mit.edu/~emin/www/source_code/red_black_tree/index.html + +template , class A = DefaultAllocator> +class RBMap { + enum Color { + RED, + BLACK + }; + struct _Data; + +public: + class Element { + private: + friend class RBMap; + int color; + Element *right; + Element *left; + Element *parent; + Element *_next; + Element *_prev; + K _key; + V _value; + //_Data *data; + + public: + const Element *next() const { + return _next; + } + Element *next() { + return _next; + } + const Element *prev() const { + return _prev; + } + Element *prev() { + return _prev; + } + const K &key() const { + return _key; + }; + V &value() { + return _value; + }; + const V &value() const { + return _value; + }; + V &get() { + return _value; + }; + const V &get() const { + return _value; + }; + Element() { + color = RED; + right = nullptr; + left = nullptr; + parent = nullptr; + _next = nullptr; + _prev = nullptr; + }; + }; + +private: + struct _Data { + Element *_root; + Element *_nil; + int size_cache; + + _FORCE_INLINE_ _Data() { +#ifdef GLOBALNIL_DISABLED + _nil = memnew_allocator(Element, A); + _nil->parent = _nil->left = _nil->right = _nil; + _nil->color = BLACK; +#else + _nil = (Element *)&_GlobalNilClass::_nil; +#endif + _root = nullptr; + size_cache = 0; + } + + void _create_root() { + _root = memnew_allocator(Element, A); + _root->parent = _root->left = _root->right = _nil; + _root->color = BLACK; + } + + void _free_root() { + if (_root) { + memdelete_allocator(_root); + _root = nullptr; + } + } + + ~_Data() { + _free_root(); + +#ifdef GLOBALNIL_DISABLED + memdelete_allocator(_nil); +#endif + } + }; + + _Data _data; + + inline void _set_color(Element *p_node, int p_color) { + ERR_FAIL_COND(p_node == _data._nil && p_color == RED); + p_node->color = p_color; + } + + inline void _rotate_left(Element *p_node) { + Element *r = p_node->right; + p_node->right = r->left; + if (r->left != _data._nil) { + r->left->parent = p_node; + } + r->parent = p_node->parent; + if (p_node == p_node->parent->left) { + p_node->parent->left = r; + } else { + p_node->parent->right = r; + } + + r->left = p_node; + p_node->parent = r; + } + + inline void _rotate_right(Element *p_node) { + Element *l = p_node->left; + p_node->left = l->right; + if (l->right != _data._nil) { + l->right->parent = p_node; + } + l->parent = p_node->parent; + if (p_node == p_node->parent->right) { + p_node->parent->right = l; + } else { + p_node->parent->left = l; + } + + l->right = p_node; + p_node->parent = l; + } + + inline Element *_successor(Element *p_node) const { + Element *node = p_node; + + if (node->right != _data._nil) { + node = node->right; + while (node->left != _data._nil) { /* returns the minimum of the right subtree of node */ + node = node->left; + } + return node; + } else { + while (node == node->parent->right) { + node = node->parent; + } + + if (node->parent == _data._root) { + return nullptr; // No successor, as p_node = last node + } + return node->parent; + } + } + + inline Element *_predecessor(Element *p_node) const { + Element *node = p_node; + + if (node->left != _data._nil) { + node = node->left; + while (node->right != _data._nil) { /* returns the minimum of the left subtree of node */ + node = node->right; + } + return node; + } else { + while (node == node->parent->left) { + node = node->parent; + } + + if (node == _data._root) { + return nullptr; // No predecessor, as p_node = first node + } + return node->parent; + } + } + + Element *_find(const K &p_key) const { + Element *node = _data._root->left; + C less; + + while (node != _data._nil) { + if (less(p_key, node->_key)) { + node = node->left; + } else if (less(node->_key, p_key)) { + node = node->right; + } else { + return node; // found + } + } + + return nullptr; + } + + Element *_find_closest(const K &p_key) const { + Element *node = _data._root->left; + Element *prev = nullptr; + C less; + + while (node != _data._nil) { + prev = node; + + if (less(p_key, node->_key)) { + node = node->left; + } else if (less(node->_key, p_key)) { + node = node->right; + } else { + return node; // found + } + } + + if (prev == nullptr) { + return nullptr; // tree empty + } + + if (less(p_key, prev->_key)) { + prev = prev->_prev; + } + + return prev; + } + + void _insert_rb_fix(Element *p_new_node) { + Element *node = p_new_node; + Element *nparent = node->parent; + Element *ngrand_parent; + + while (nparent->color == RED) { + ngrand_parent = nparent->parent; + + if (nparent == ngrand_parent->left) { + if (ngrand_parent->right->color == RED) { + _set_color(nparent, BLACK); + _set_color(ngrand_parent->right, BLACK); + _set_color(ngrand_parent, RED); + node = ngrand_parent; + nparent = node->parent; + } else { + if (node == nparent->right) { + _rotate_left(nparent); + node = nparent; + nparent = node->parent; + } + _set_color(nparent, BLACK); + _set_color(ngrand_parent, RED); + _rotate_right(ngrand_parent); + } + } else { + if (ngrand_parent->left->color == RED) { + _set_color(nparent, BLACK); + _set_color(ngrand_parent->left, BLACK); + _set_color(ngrand_parent, RED); + node = ngrand_parent; + nparent = node->parent; + } else { + if (node == nparent->left) { + _rotate_right(nparent); + node = nparent; + nparent = node->parent; + } + _set_color(nparent, BLACK); + _set_color(ngrand_parent, RED); + _rotate_left(ngrand_parent); + } + } + } + + _set_color(_data._root->left, BLACK); + } + + Element *_insert(const K &p_key, const V &p_value) { + Element *new_parent = _data._root; + Element *node = _data._root->left; + C less; + + while (node != _data._nil) { + new_parent = node; + + if (less(p_key, node->_key)) { + node = node->left; + } else if (less(node->_key, p_key)) { + node = node->right; + } else { + node->_value = p_value; + return node; // Return existing node with new value + } + } + + Element *new_node = memnew_allocator(Element, A); + new_node->parent = new_parent; + new_node->right = _data._nil; + new_node->left = _data._nil; + new_node->_key = p_key; + new_node->_value = p_value; + //new_node->data=_data; + + if (new_parent == _data._root || less(p_key, new_parent->_key)) { + new_parent->left = new_node; + } else { + new_parent->right = new_node; + } + + new_node->_next = _successor(new_node); + new_node->_prev = _predecessor(new_node); + if (new_node->_next) { + new_node->_next->_prev = new_node; + } + if (new_node->_prev) { + new_node->_prev->_next = new_node; + } + + _data.size_cache++; + _insert_rb_fix(new_node); + return new_node; + } + + void _erase_fix_rb(Element *p_node) { + Element *root = _data._root->left; + Element *node = _data._nil; + Element *sibling = p_node; + Element *parent = sibling->parent; + + while (node != root) { // If red node found, will exit at a break + if (sibling->color == RED) { + _set_color(sibling, BLACK); + _set_color(parent, RED); + if (sibling == parent->right) { + sibling = sibling->left; + _rotate_left(parent); + } else { + sibling = sibling->right; + _rotate_right(parent); + } + } + if ((sibling->left->color == BLACK) && (sibling->right->color == BLACK)) { + _set_color(sibling, RED); + if (parent->color == RED) { + _set_color(parent, BLACK); + break; + } else { // loop: haven't found any red nodes yet + node = parent; + parent = node->parent; + sibling = (node == parent->left) ? parent->right : parent->left; + } + } else { + if (sibling == parent->right) { + if (sibling->right->color == BLACK) { + _set_color(sibling->left, BLACK); + _set_color(sibling, RED); + _rotate_right(sibling); + sibling = sibling->parent; + } + _set_color(sibling, parent->color); + _set_color(parent, BLACK); + _set_color(sibling->right, BLACK); + _rotate_left(parent); + break; + } else { + if (sibling->left->color == BLACK) { + _set_color(sibling->right, BLACK); + _set_color(sibling, RED); + _rotate_left(sibling); + sibling = sibling->parent; + } + + _set_color(sibling, parent->color); + _set_color(parent, BLACK); + _set_color(sibling->left, BLACK); + _rotate_right(parent); + break; + } + } + } + + ERR_FAIL_COND(_data._nil->color != BLACK); + } + + void _erase(Element *p_node) { + Element *rp = ((p_node->left == _data._nil) || (p_node->right == _data._nil)) ? p_node : p_node->_next; + Element *node = (rp->left == _data._nil) ? rp->right : rp->left; + + Element *sibling; + if (rp == rp->parent->left) { + rp->parent->left = node; + sibling = rp->parent->right; + } else { + rp->parent->right = node; + sibling = rp->parent->left; + } + + if (node->color == RED) { + node->parent = rp->parent; + _set_color(node, BLACK); + } else if (rp->color == BLACK && rp->parent != _data._root) { + _erase_fix_rb(sibling); + } + + if (rp != p_node) { + ERR_FAIL_COND(rp == _data._nil); + + rp->left = p_node->left; + rp->right = p_node->right; + rp->parent = p_node->parent; + rp->color = p_node->color; + if (p_node->left != _data._nil) { + p_node->left->parent = rp; + } + if (p_node->right != _data._nil) { + p_node->right->parent = rp; + } + + if (p_node == p_node->parent->left) { + p_node->parent->left = rp; + } else { + p_node->parent->right = rp; + } + } + + if (p_node->_next) { + p_node->_next->_prev = p_node->_prev; + } + if (p_node->_prev) { + p_node->_prev->_next = p_node->_next; + } + + memdelete_allocator(p_node); + _data.size_cache--; + ERR_FAIL_COND(_data._nil->color == RED); + } + + void _calculate_depth(Element *p_element, int &max_d, int d) const { + if (p_element == _data._nil) { + return; + } + + _calculate_depth(p_element->left, max_d, d + 1); + _calculate_depth(p_element->right, max_d, d + 1); + + if (d > max_d) { + max_d = d; + } + } + + void _cleanup_tree(Element *p_element) { + if (p_element == _data._nil) { + return; + } + + _cleanup_tree(p_element->left); + _cleanup_tree(p_element->right); + memdelete_allocator(p_element); + } + + void _copy_from(const RBMap &p_map) { + clear(); + // not the fastest way, but safeset to write. + for (Element *I = p_map.front(); I; I = I->next()) { + insert(I->key(), I->value()); + } + } + +public: + const Element *find(const K &p_key) const { + if (!_data._root) { + return nullptr; + } + + const Element *res = _find(p_key); + return res; + } + + Element *find(const K &p_key) { + if (!_data._root) { + return nullptr; + } + + Element *res = _find(p_key); + return res; + } + + const Element *find_closest(const K &p_key) const { + if (!_data._root) { + return NULL; + } + + const Element *res = _find_closest(p_key); + return res; + } + + Element *find_closest(const K &p_key) { + if (!_data._root) { + return nullptr; + } + + Element *res = _find_closest(p_key); + return res; + } + + bool has(const K &p_key) const { + return find(p_key) != nullptr; + } + + Element *insert(const K &p_key, const V &p_value) { + if (!_data._root) { + _data._create_root(); + } + return _insert(p_key, p_value); + } + + void erase(Element *p_element) { + if (!_data._root || !p_element) { + return; + } + + _erase(p_element); + if (_data.size_cache == 0 && _data._root) { + _data._free_root(); + } + } + + bool erase(const K &p_key) { + if (!_data._root) { + return false; + } + + Element *e = find(p_key); + if (!e) { + return false; + } + + _erase(e); + if (_data.size_cache == 0 && _data._root) { + _data._free_root(); + } + return true; + } + + const V &operator[](const K &p_key) const { + CRASH_COND(!_data._root); + const Element *e = find(p_key); + CRASH_COND(!e); + return e->_value; + } + + V &operator[](const K &p_key) { + if (!_data._root) { + _data._create_root(); + } + + Element *e = find(p_key); + if (!e) { + e = insert(p_key, V()); + } + + return e->_value; + } + + Element *front() const { + if (!_data._root) { + return nullptr; + } + + Element *e = _data._root->left; + if (e == _data._nil) { + return nullptr; + } + + while (e->left != _data._nil) { + e = e->left; + } + + return e; + } + + Element *back() const { + if (!_data._root) { + return nullptr; + } + + Element *e = _data._root->left; + if (e == _data._nil) { + return nullptr; + } + + while (e->right != _data._nil) { + e = e->right; + } + + return e; + } + + inline bool empty() const { return _data.size_cache == 0; } + inline int size() const { return _data.size_cache; } + + int calculate_depth() const { + // used for debug mostly + if (!_data._root) { + return 0; + } + + int max_d = 0; + _calculate_depth(_data._root->left, max_d, 0); + return max_d; + } + + void clear() { + if (!_data._root) { + return; + } + + _cleanup_tree(_data._root->left); + _data._root->left = _data._nil; + _data.size_cache = 0; + _data._free_root(); + } + + void operator=(const RBMap &p_map) { + _copy_from(p_map); + } + + RBMap(const RBMap &p_map) { + _copy_from(p_map); + } + + _FORCE_INLINE_ RBMap() { + } + + ~RBMap() { + clear(); + } +}; + +#line 0 + +#line 1 "sfwl/core/rb_set.h" + +/*************************************************************************/ +/* rb_set.h */ +/* From https://github.com/Relintai/pandemonium_engine (MIT) */ +/*************************************************************************/ + +// based on the very nice implementation of rb-trees by: +// https://web.archive.org/web/20120507164830/http://web.mit.edu/~emin/www/source_code/red_black_tree/index.html + +template , class A = DefaultAllocator> +class RBSet { + enum Color { + RED, + BLACK + }; + struct _Data; + +public: + class Element { + private: + friend class RBSet; + int color; + Element *right; + Element *left; + Element *parent; + Element *_next; + Element *_prev; + T value; + //_Data *data; + + public: + const Element *next() const { + return _next; + } + Element *next() { + return _next; + } + const Element *prev() const { + return _prev; + } + Element *prev() { + return _prev; + } + const T &get() const { + return value; + }; + Element() { + color = RED; + right = nullptr; + left = nullptr; + parent = nullptr; + _next = nullptr; + _prev = nullptr; + }; + }; + +private: + struct _Data { + Element *_root; + Element *_nil; + int size_cache; + + _FORCE_INLINE_ _Data() { +#ifdef GLOBALNIL_DISABLED + _nil = memnew_allocator(Element, A); + _nil->parent = _nil->left = _nil->right = _nil; + _nil->color = BLACK; +#else + _nil = (Element *)&_GlobalNilClass::_nil; +#endif + _root = nullptr; + size_cache = 0; + } + + void _create_root() { + _root = memnew_allocator(Element, A); + _root->parent = _root->left = _root->right = _nil; + _root->color = BLACK; + } + + void _free_root() { + if (_root) { + memdelete_allocator(_root); + _root = nullptr; + } + } + + ~_Data() { + _free_root(); + +#ifdef GLOBALNIL_DISABLED + memdelete_allocator(_nil); +#endif + } + }; + + _Data _data; + + inline void _set_color(Element *p_node, int p_color) { + ERR_FAIL_COND(p_node == _data._nil && p_color == RED); + p_node->color = p_color; + } + + inline void _rotate_left(Element *p_node) { + Element *r = p_node->right; + p_node->right = r->left; + if (r->left != _data._nil) { + r->left->parent = p_node; + } + r->parent = p_node->parent; + if (p_node == p_node->parent->left) { + p_node->parent->left = r; + } else { + p_node->parent->right = r; + } + + r->left = p_node; + p_node->parent = r; + } + + inline void _rotate_right(Element *p_node) { + Element *l = p_node->left; + p_node->left = l->right; + if (l->right != _data._nil) { + l->right->parent = p_node; + } + l->parent = p_node->parent; + if (p_node == p_node->parent->right) { + p_node->parent->right = l; + } else { + p_node->parent->left = l; + } + + l->right = p_node; + p_node->parent = l; + } + + inline Element *_successor(Element *p_node) const { + Element *node = p_node; + + if (node->right != _data._nil) { + node = node->right; + while (node->left != _data._nil) { /* returns the minimum of the right subtree of node */ + node = node->left; + } + return node; + } else { + while (node == node->parent->right) { + node = node->parent; + } + + if (node->parent == _data._root) { + return nullptr; // No successor, as p_node = last node + } + return node->parent; + } + } + + inline Element *_predecessor(Element *p_node) const { + Element *node = p_node; + + if (node->left != _data._nil) { + node = node->left; + while (node->right != _data._nil) { /* returns the minimum of the left subtree of node */ + node = node->right; + } + return node; + } else { + while (node == node->parent->left) { + node = node->parent; + } + + if (node == _data._root) { + return nullptr; // No predecessor, as p_node = first node. + } + return node->parent; + } + } + + Element *_find(const T &p_value) const { + Element *node = _data._root->left; + C less; + + while (node != _data._nil) { + if (less(p_value, node->value)) { + node = node->left; + } else if (less(node->value, p_value)) { + node = node->right; + } else { + return node; // found + } + } + + return nullptr; + } + + Element *_lower_bound(const T &p_value) const { + Element *node = _data._root->left; + Element *prev = nullptr; + C less; + + while (node != _data._nil) { + prev = node; + + if (less(p_value, node->value)) { + node = node->left; + } else if (less(node->value, p_value)) { + node = node->right; + } else { + return node; // found + } + } + + if (prev == nullptr) { + return nullptr; // tree empty + } + + if (less(prev->value, p_value)) { + prev = prev->_next; + } + + return prev; + } + + void _insert_rb_fix(Element *p_new_node) { + Element *node = p_new_node; + Element *nparent = node->parent; + Element *ngrand_parent; + + while (nparent->color == RED) { + ngrand_parent = nparent->parent; + + if (nparent == ngrand_parent->left) { + if (ngrand_parent->right->color == RED) { + _set_color(nparent, BLACK); + _set_color(ngrand_parent->right, BLACK); + _set_color(ngrand_parent, RED); + node = ngrand_parent; + nparent = node->parent; + } else { + if (node == nparent->right) { + _rotate_left(nparent); + node = nparent; + nparent = node->parent; + } + _set_color(nparent, BLACK); + _set_color(ngrand_parent, RED); + _rotate_right(ngrand_parent); + } + } else { + if (ngrand_parent->left->color == RED) { + _set_color(nparent, BLACK); + _set_color(ngrand_parent->left, BLACK); + _set_color(ngrand_parent, RED); + node = ngrand_parent; + nparent = node->parent; + } else { + if (node == nparent->left) { + _rotate_right(nparent); + node = nparent; + nparent = node->parent; + } + _set_color(nparent, BLACK); + _set_color(ngrand_parent, RED); + _rotate_left(ngrand_parent); + } + } + } + + _set_color(_data._root->left, BLACK); + } + + Element *_insert(const T &p_value) { + Element *new_parent = _data._root; + Element *node = _data._root->left; + C less; + + while (node != _data._nil) { + new_parent = node; + + if (less(p_value, node->value)) { + node = node->left; + } else if (less(node->value, p_value)) { + node = node->right; + } else { + return node; // Return existing node + } + } + + Element *new_node = memnew_allocator(Element, A); + new_node->parent = new_parent; + new_node->right = _data._nil; + new_node->left = _data._nil; + new_node->value = p_value; + //new_node->data=_data; + + if (new_parent == _data._root || less(p_value, new_parent->value)) { + new_parent->left = new_node; + } else { + new_parent->right = new_node; + } + + new_node->_next = _successor(new_node); + new_node->_prev = _predecessor(new_node); + if (new_node->_next) { + new_node->_next->_prev = new_node; + } + if (new_node->_prev) { + new_node->_prev->_next = new_node; + } + + _data.size_cache++; + _insert_rb_fix(new_node); + return new_node; + } + + void _erase_fix_rb(Element *p_node) { + Element *root = _data._root->left; + Element *node = _data._nil; + Element *sibling = p_node; + Element *parent = sibling->parent; + + while (node != root) { // If red node found, will exit at a break + if (sibling->color == RED) { + _set_color(sibling, BLACK); + _set_color(parent, RED); + if (sibling == parent->right) { + sibling = sibling->left; + _rotate_left(parent); + } else { + sibling = sibling->right; + _rotate_right(parent); + } + } + if ((sibling->left->color == BLACK) && (sibling->right->color == BLACK)) { + _set_color(sibling, RED); + if (parent->color == RED) { + _set_color(parent, BLACK); + break; + } else { // loop: haven't found any red nodes yet + node = parent; + parent = node->parent; + sibling = (node == parent->left) ? parent->right : parent->left; + } + } else { + if (sibling == parent->right) { + if (sibling->right->color == BLACK) { + _set_color(sibling->left, BLACK); + _set_color(sibling, RED); + _rotate_right(sibling); + sibling = sibling->parent; + } + _set_color(sibling, parent->color); + _set_color(parent, BLACK); + _set_color(sibling->right, BLACK); + _rotate_left(parent); + break; + } else { + if (sibling->left->color == BLACK) { + _set_color(sibling->right, BLACK); + _set_color(sibling, RED); + _rotate_left(sibling); + sibling = sibling->parent; + } + + _set_color(sibling, parent->color); + _set_color(parent, BLACK); + _set_color(sibling->left, BLACK); + _rotate_right(parent); + break; + } + } + } + + ERR_FAIL_COND(_data._nil->color != BLACK); + } + + void _erase(Element *p_node) { + Element *rp = ((p_node->left == _data._nil) || (p_node->right == _data._nil)) ? p_node : p_node->_next; + Element *node = (rp->left == _data._nil) ? rp->right : rp->left; + + Element *sibling; + if (rp == rp->parent->left) { + rp->parent->left = node; + sibling = rp->parent->right; + } else { + rp->parent->right = node; + sibling = rp->parent->left; + } + + if (node->color == RED) { + node->parent = rp->parent; + _set_color(node, BLACK); + } else if (rp->color == BLACK && rp->parent != _data._root) { + _erase_fix_rb(sibling); + } + + if (rp != p_node) { + ERR_FAIL_COND(rp == _data._nil); + + rp->left = p_node->left; + rp->right = p_node->right; + rp->parent = p_node->parent; + rp->color = p_node->color; + if (p_node->left != _data._nil) { + p_node->left->parent = rp; + } + if (p_node->right != _data._nil) { + p_node->right->parent = rp; + } + + if (p_node == p_node->parent->left) { + p_node->parent->left = rp; + } else { + p_node->parent->right = rp; + } + } + + if (p_node->_next) { + p_node->_next->_prev = p_node->_prev; + } + if (p_node->_prev) { + p_node->_prev->_next = p_node->_next; + } + + memdelete_allocator(p_node); + _data.size_cache--; + ERR_FAIL_COND(_data._nil->color == RED); + } + + void _calculate_depth(Element *p_element, int &max_d, int d) const { + if (p_element == _data._nil) { + return; + } + + _calculate_depth(p_element->left, max_d, d + 1); + _calculate_depth(p_element->right, max_d, d + 1); + + if (d > max_d) { + max_d = d; + } + } + + void _cleanup_tree(Element *p_element) { + if (p_element == _data._nil) { + return; + } + + _cleanup_tree(p_element->left); + _cleanup_tree(p_element->right); + memdelete_allocator(p_element); + } + + void _copy_from(const RBSet &p_set) { + clear(); + // not the fastest way, but safeset to write. + for (Element *I = p_set.front(); I; I = I->next()) { + insert(I->get()); + } + } + +public: + const Element *find(const T &p_value) const { + if (!_data._root) { + return nullptr; + } + + const Element *res = _find(p_value); + return res; + } + + Element *find(const T &p_value) { + if (!_data._root) { + return nullptr; + } + + Element *res = _find(p_value); + return res; + } + + Element *lower_bound(const T &p_value) const { + if (!_data._root) { + return nullptr; + } + return _lower_bound(p_value); + } + + bool has(const T &p_value) const { + return find(p_value) != nullptr; + } + + Element *insert(const T &p_value) { + if (!_data._root) { + _data._create_root(); + } + return _insert(p_value); + } + + void erase(Element *p_element) { + if (!_data._root || !p_element) { + return; + } + + _erase(p_element); + if (_data.size_cache == 0 && _data._root) { + _data._free_root(); + } + } + + bool erase(const T &p_value) { + if (!_data._root) { + return false; + } + + Element *e = find(p_value); + if (!e) { + return false; + } + + _erase(e); + if (_data.size_cache == 0 && _data._root) { + _data._free_root(); + } + return true; + } + + Element *front() const { + if (!_data._root) { + return nullptr; + } + + Element *e = _data._root->left; + if (e == _data._nil) { + return nullptr; + } + + while (e->left != _data._nil) { + e = e->left; + } + + return e; + } + + Element *back() const { + if (!_data._root) { + return nullptr; + } + + Element *e = _data._root->left; + if (e == _data._nil) { + return nullptr; + } + + while (e->right != _data._nil) { + e = e->right; + } + + return e; + } + + inline bool empty() const { return _data.size_cache == 0; } + inline int size() const { return _data.size_cache; } + + int calculate_depth() const { + // used for debug mostly + if (!_data._root) { + return 0; + } + + int max_d = 0; + _calculate_depth(_data._root->left, max_d, 0); + return max_d; + } + + void clear() { + if (!_data._root) { + return; + } + + _cleanup_tree(_data._root->left); + _data._root->left = _data._nil; + _data.size_cache = 0; + _data._free_root(); + } + + void operator=(const RBSet &p_set) { + _copy_from(p_set); + } + + RBSet(const RBSet &p_set) { + _copy_from(p_set); + } + + _FORCE_INLINE_ RBSet() { + } + + ~RBSet() { + clear(); + } +}; + +#line 0 + +#line 1 "sfwl/core/vmap.h" + +/*************************************************************************/ +/* vmap.h */ +/* From https://github.com/Relintai/pandemonium_engine (MIT) */ +/*************************************************************************/ + +template +class VMap { +public: + struct Pair { + T key; + V value; + + _FORCE_INLINE_ Pair() {} + + _FORCE_INLINE_ Pair(const T &p_key, const V &p_value) { + key = p_key; + value = p_value; + } + }; + +private: + CowData _cowdata; + + _FORCE_INLINE_ int _find(const T &p_val, bool &r_exact) const { + r_exact = false; + if (_cowdata.empty()) { + return 0; + } + + int low = 0; + int high = _cowdata.size() - 1; + const Pair *a = _cowdata.ptr(); + int middle = 0; + +#ifdef DEBUG_ENABLED + if (low > high) + ERR_PRINT("low > high, this may be a bug"); +#endif + while (low <= high) { + middle = (low + high) / 2; + + if (p_val < a[middle].key) { + high = middle - 1; //search low end of array + } else if (a[middle].key < p_val) { + low = middle + 1; //search high end of array + } else { + r_exact = true; + return middle; + } + } + + //return the position where this would be inserted + if (a[middle].key < p_val) { + middle++; + } + return middle; + } + + _FORCE_INLINE_ int _find_exact(const T &p_val) const { + if (_cowdata.empty()) { + return -1; + } + + int low = 0; + int high = _cowdata.size() - 1; + int middle; + const Pair *a = _cowdata.ptr(); + + while (low <= high) { + middle = (low + high) / 2; + + if (p_val < a[middle].key) { + high = middle - 1; //search low end of array + } else if (a[middle].key < p_val) { + low = middle + 1; //search high end of array + } else { + return middle; + } + } + + return -1; + } + +public: + int insert(const T &p_key, const V &p_val) { + bool exact; + int pos = _find(p_key, exact); + if (exact) { + _cowdata.get_m(pos).value = p_val; + return pos; + } + _cowdata.insert(pos, Pair(p_key, p_val)); + return pos; + } + + bool has(const T &p_val) const { + return _find_exact(p_val) != -1; + } + + void erase(const T &p_val) { + int pos = _find_exact(p_val); + if (pos < 0) { + return; + } + _cowdata.remove(pos); + } + + int find(const T &p_val) const { + return _find_exact(p_val); + } + + int find_nearest(const T &p_val) const { + if (_cowdata.empty()) { + return -1; + } + bool exact; + return _find(p_val, exact); + } + + _FORCE_INLINE_ int size() const { return _cowdata.size(); } + _FORCE_INLINE_ bool empty() const { return _cowdata.empty(); } + + const Pair *get_array() const { + return _cowdata.ptr(); + } + + Pair *get_array() { + return _cowdata.ptrw(); + } + + const V &getv(int p_index) const { + return _cowdata.get(p_index).value; + } + + V &getv(int p_index) { + return _cowdata.get_m(p_index).value; + } + + const T &getk(int p_index) const { + return _cowdata.get(p_index).key; + } + + T &getk(int p_index) { + return _cowdata.get_m(p_index).key; + } + + inline const V &operator[](const T &p_key) const { + int pos = _find_exact(p_key); + + CRASH_COND(pos < 0); + + return _cowdata.get(pos).value; + } + + inline V &operator[](const T &p_key) { + int pos = _find_exact(p_key); + if (pos < 0) { + pos = insert(p_key, V()); + } + + return _cowdata.get_m(pos).value; + } + + _FORCE_INLINE_ VMap(){}; + _FORCE_INLINE_ VMap(const VMap &p_from) { _cowdata._ref(p_from._cowdata); } + inline VMap &operator=(const VMap &p_from) { + _cowdata._ref(p_from._cowdata); + return *this; + } +}; + +#line 0 + +#line 1 "sfwl/core/vector.h" + +/*************************************************************************/ +/* vector.h */ +/* From https://github.com/Relintai/pandemonium_engine (MIT) */ +/*************************************************************************/ + +/** + * @class Vector + * @author Juan Linietsky + * Vector container. Regular Vector Container. Use with care and for smaller arrays when possible. Use PoolVector for large arrays. + */ + +template +class VectorWriteProxy { +public: + _FORCE_INLINE_ T &operator[](int p_index) { + CRASH_BAD_INDEX(p_index, ((Vector *)(this))->_cowdata.size()); + + return ((Vector *)(this))->_cowdata.ptrw()[p_index]; + } +}; + +template +class Vector { + friend class VectorWriteProxy; + +public: + VectorWriteProxy write; + +private: + CowData _cowdata; + +public: + bool push_back(T p_elem); + + void remove(int p_index) { _cowdata.remove(p_index); } + _FORCE_INLINE_ bool erase(const T &p_val) { + int idx = find(p_val); + if (idx >= 0) { + remove(idx); + return true; + } + return false; + }; + void invert(); + + _FORCE_INLINE_ T *ptrw() { return _cowdata.ptrw(); } + _FORCE_INLINE_ const T *ptr() const { return _cowdata.ptr(); } + _FORCE_INLINE_ void clear() { resize(0); } + _FORCE_INLINE_ bool empty() const { return _cowdata.empty(); } + + _FORCE_INLINE_ T get(int p_index) { return _cowdata.get(p_index); } + _FORCE_INLINE_ const T &get(int p_index) const { return _cowdata.get(p_index); } + _FORCE_INLINE_ void set(int p_index, const T &p_elem) { _cowdata.set(p_index, p_elem); } + _FORCE_INLINE_ int size() const { return _cowdata.size(); } + Error resize(int p_size) { return _cowdata.resize(p_size); } + _FORCE_INLINE_ const T &operator[](int p_index) const { return _cowdata.get(p_index); } + Error insert(int p_pos, T p_val) { return _cowdata.insert(p_pos, p_val); } + int find(const T &p_val, int p_from = 0) const { return _cowdata.find(p_val, p_from); } + _FORCE_INLINE_ void fill(const T &p_val) { _cowdata.fill(p_val); } + + void append_array(Vector p_other); + + template + void sort_custom() { + int len = _cowdata.size(); + if (len == 0) { + return; + } + + T *data = ptrw(); + SortArray sorter; + sorter.sort(data, len); + } + + void sort() { + sort_custom<_DefaultComparator>(); + } + + void ordered_insert(const T &p_val) { + int i; + for (i = 0; i < _cowdata.size(); i++) { + if (p_val < operator[](i)) { + break; + }; + }; + insert(i, p_val); + } + + _FORCE_INLINE_ Vector() {} + _FORCE_INLINE_ Vector(const Vector &p_from) { _cowdata._ref(p_from._cowdata); } + inline Vector &operator=(const Vector &p_from) { + _cowdata._ref(p_from._cowdata); + return *this; + } + + Vector to_byte_array() const { + Vector ret; + ret.resize(size() * sizeof(T)); + memcpy(ret.ptrw(), ptr(), sizeof(T) * size()); + return ret; + } + + Vector slice(int p_begin, int p_end = INT32_MAX) const { + Vector result; + + const int s = size(); + + int begin = CLAMP(p_begin, -s, s); + if (begin < 0) { + begin += s; + } + int end = CLAMP(p_end, -s, s); + if (end < 0) { + end += s; + } + + ERR_FAIL_COND_V(begin > end, result); + + int result_size = end - begin; + result.resize(result_size); + + const T *const r = ptr(); + T *const w = result.ptrw(); + for (int i = 0; i < result_size; ++i) { + w[i] = r[begin + i]; + } + + return result; + } + + _FORCE_INLINE_ ~Vector() {} +}; + +template +void Vector::invert() { + for (int i = 0; i < size() / 2; i++) { + T *p = ptrw(); + SWAP(p[i], p[size() - i - 1]); + } +} + +template +void Vector::append_array(Vector p_other) { + const int ds = p_other.size(); + if (ds == 0) { + return; + } + const int bs = size(); + resize(bs + ds); + for (int i = 0; i < ds; ++i) { + ptrw()[bs + i] = p_other[i]; + } +} + +template +bool Vector::push_back(T p_elem) { + Error err = resize(size() + 1); + ERR_FAIL_COND_V(err, true); + set(size() - 1, p_elem); + + return false; +} + +#line 0 + +#line 1 "sfwl/core/vset.h" + +/*************************************************************************/ +/* vset.h */ +/* From https://github.com/Relintai/pandemonium_engine (MIT) */ +/*************************************************************************/ + +template +class VSet { + Vector _data; + + _FORCE_INLINE_ int _find(const T &p_val, bool &r_exact) const { + r_exact = false; + if (_data.empty()) { + return 0; + } + + int low = 0; + int high = _data.size() - 1; + const T *a = &_data[0]; + int middle = 0; + +#ifdef DEBUG_ENABLED + if (low > high) + ERR_PRINT("low > high, this may be a bug"); +#endif + + while (low <= high) { + middle = (low + high) / 2; + + if (p_val < a[middle]) { + high = middle - 1; //search low end of array + } else if (a[middle] < p_val) { + low = middle + 1; //search high end of array + } else { + r_exact = true; + return middle; + } + } + + //return the position where this would be inserted + if (a[middle] < p_val) { + middle++; + } + return middle; + } + + _FORCE_INLINE_ int _find_exact(const T &p_val) const { + if (_data.empty()) { + return -1; + } + + int low = 0; + int high = _data.size() - 1; + int middle; + const T *a = &_data[0]; + + while (low <= high) { + middle = (low + high) / 2; + + if (p_val < a[middle]) { + high = middle - 1; //search low end of array + } else if (a[middle] < p_val) { + low = middle + 1; //search high end of array + } else { + return middle; + } + } + + return -1; + } + +public: + void insert(const T &p_val) { + bool exact; + int pos = _find(p_val, exact); + if (exact) { + return; + } + _data.insert(pos, p_val); + } + + bool has(const T &p_val) const { + return _find_exact(p_val) != -1; + } + + void erase(const T &p_val) { + int pos = _find_exact(p_val); + if (pos < 0) { + return; + } + _data.remove(pos); + } + + int find(const T &p_val) const { + return _find_exact(p_val); + } + + _FORCE_INLINE_ bool empty() const { return _data.empty(); } + + _FORCE_INLINE_ int size() const { return _data.size(); } + + inline T &operator[](int p_index) { + return _data.write[p_index]; + } + + inline const T &operator[](int p_index) const { + return _data[p_index]; + } +}; + +#line 0 + +#line 1 "sfwl/core/list.h" + +/*************************************************************************/ +/* list.h */ +/* From https://github.com/Relintai/pandemonium_engine (MIT) */ +/*************************************************************************/ + +/** + * Generic Templatized Linked List Implementation. + * The implementation differs from the STL one because + * a compatible preallocated linked list can be written + * using the same API, or features such as erasing an element + * from the iterator. + */ + +template +class List { + struct _Data; + +public: + class Element { + private: + friend class List; + + T value; + Element *next_ptr; + Element *prev_ptr; + _Data *data; + + public: + /** + * Get NEXT Element iterator, for constant lists. + */ + _FORCE_INLINE_ const Element *next() const { + return next_ptr; + }; + /** + * Get NEXT Element iterator, + */ + _FORCE_INLINE_ Element *next() { + return next_ptr; + }; + + /** + * Get PREV Element iterator, for constant lists. + */ + _FORCE_INLINE_ const Element *prev() const { + return prev_ptr; + }; + /** + * Get PREV Element iterator, + */ + _FORCE_INLINE_ Element *prev() { + return prev_ptr; + }; + + /** + * * operator, for using as *iterator, when iterators are defined on stack. + */ + _FORCE_INLINE_ const T &operator*() const { + return value; + }; + /** + * operator->, for using as iterator->, when iterators are defined on stack, for constant lists. + */ + _FORCE_INLINE_ const T *operator->() const { + return &value; + }; + /** + * * operator, for using as *iterator, when iterators are defined on stack, + */ + _FORCE_INLINE_ T &operator*() { + return value; + }; + /** + * operator->, for using as iterator->, when iterators are defined on stack, for constant lists. + */ + _FORCE_INLINE_ T *operator->() { + return &value; + }; + + /** + * get the value stored in this element. + */ + _FORCE_INLINE_ T &get() { + return value; + }; + /** + * get the value stored in this element, for constant lists + */ + _FORCE_INLINE_ const T &get() const { + return value; + }; + /** + * set the value stored in this element. + */ + _FORCE_INLINE_ void set(const T &p_value) { + value = (T &)p_value; + }; + + void erase() { + data->erase(this); + } + + _FORCE_INLINE_ Element() { + next_ptr = nullptr; + prev_ptr = nullptr; + data = nullptr; + }; + }; + +private: + struct _Data { + Element *first; + Element *last; + int size_cache; + + bool erase(const Element *p_I) { + ERR_FAIL_COND_V(!p_I, false); + ERR_FAIL_COND_V(p_I->data != this, false); + + if (first == p_I) { + first = p_I->next_ptr; + }; + + if (last == p_I) { + last = p_I->prev_ptr; + } + + if (p_I->prev_ptr) { + p_I->prev_ptr->next_ptr = p_I->next_ptr; + } + + if (p_I->next_ptr) { + p_I->next_ptr->prev_ptr = p_I->prev_ptr; + } + + memdelete_allocator(const_cast(p_I)); + size_cache--; + + return true; + } + }; + + _Data *_data; + +public: + /** + * return a const iterator to the beginning of the list. + */ + _FORCE_INLINE_ const Element *front() const { + return _data ? _data->first : nullptr; + }; + + /** + * return an iterator to the beginning of the list. + */ + _FORCE_INLINE_ Element *front() { + return _data ? _data->first : nullptr; + }; + + /** + * return a const iterator to the last member of the list. + */ + _FORCE_INLINE_ const Element *back() const { + return _data ? _data->last : nullptr; + }; + + /** + * return an iterator to the last member of the list. + */ + _FORCE_INLINE_ Element *back() { + return _data ? _data->last : nullptr; + }; + + /** + * store a new element at the end of the list + */ + Element *push_back(const T &value) { + if (!_data) { + _data = memnew_allocator(_Data, A); + _data->first = nullptr; + _data->last = nullptr; + _data->size_cache = 0; + } + + Element *n = memnew_allocator(Element, A); + n->value = (T &)value; + + n->prev_ptr = _data->last; + n->next_ptr = nullptr; + n->data = _data; + + if (_data->last) { + _data->last->next_ptr = n; + } + + _data->last = n; + + if (!_data->first) { + _data->first = n; + } + + _data->size_cache++; + + return n; + }; + + void pop_back() { + if (_data && _data->last) { + erase(_data->last); + } + } + + /** + * store a new element at the beginning of the list + */ + Element *push_front(const T &value) { + if (!_data) { + _data = memnew_allocator(_Data, A); + _data->first = nullptr; + _data->last = nullptr; + _data->size_cache = 0; + } + + Element *n = memnew_allocator(Element, A); + n->value = (T &)value; + n->prev_ptr = nullptr; + n->next_ptr = _data->first; + n->data = _data; + + if (_data->first) { + _data->first->prev_ptr = n; + } + + _data->first = n; + + if (!_data->last) { + _data->last = n; + } + + _data->size_cache++; + + return n; + }; + + void pop_front() { + if (_data && _data->first) { + erase(_data->first); + } + } + + Element *insert_after(Element *p_element, const T &p_value) { + CRASH_COND(p_element && (!_data || p_element->data != _data)); + + if (!p_element) { + return push_back(p_value); + } + + Element *n = memnew_allocator(Element, A); + n->value = (T &)p_value; + n->prev_ptr = p_element; + n->next_ptr = p_element->next_ptr; + n->data = _data; + + if (!p_element->next_ptr) { + _data->last = n; + } else { + p_element->next_ptr->prev_ptr = n; + } + + p_element->next_ptr = n; + + _data->size_cache++; + + return n; + } + + Element *insert_before(Element *p_element, const T &p_value) { + CRASH_COND(p_element && (!_data || p_element->data != _data)); + + if (!p_element) { + return push_back(p_value); + } + + Element *n = memnew_allocator(Element, A); + n->value = (T &)p_value; + n->prev_ptr = p_element->prev_ptr; + n->next_ptr = p_element; + n->data = _data; + + if (!p_element->prev_ptr) { + _data->first = n; + } else { + p_element->prev_ptr->next_ptr = n; + } + + p_element->prev_ptr = n; + + _data->size_cache++; + + return n; + } + + /** + * find an element in the list, + */ + template + Element *find(const T_v &p_val) { + Element *it = front(); + while (it) { + if (it->value == p_val) { + return it; + } + it = it->next(); + }; + + return nullptr; + }; + + /** + * erase an element in the list, by iterator pointing to it. Return true if it was found/erased. + */ + bool erase(const Element *p_I) { + if (_data) { + bool ret = _data->erase(p_I); + + if (_data->size_cache == 0) { + memdelete_allocator<_Data, A>(_data); + _data = nullptr; + } + + return ret; + } + + return false; + }; + + /** + * erase the first element in the list, that contains value + */ + bool erase(const T &value) { + Element *I = find(value); + return erase(I); + }; + + /** + * return whether the list is empty + */ + _FORCE_INLINE_ bool empty() const { + return (!_data || !_data->size_cache); + } + + /** + * clear the list + */ + void clear() { + while (front()) { + erase(front()); + }; + }; + + _FORCE_INLINE_ int size() const { + return _data ? _data->size_cache : 0; + } + + void swap(Element *p_A, Element *p_B) { + ERR_FAIL_COND(!p_A || !p_B); + ERR_FAIL_COND(p_A->data != _data); + ERR_FAIL_COND(p_B->data != _data); + + if (p_A == p_B) { + return; + } + Element *A_prev = p_A->prev_ptr; + Element *A_next = p_A->next_ptr; + Element *B_prev = p_B->prev_ptr; + Element *B_next = p_B->next_ptr; + + if (A_prev) { + A_prev->next_ptr = p_B; + } else { + _data->first = p_B; + } + if (B_prev) { + B_prev->next_ptr = p_A; + } else { + _data->first = p_A; + } + if (A_next) { + A_next->prev_ptr = p_B; + } else { + _data->last = p_B; + } + if (B_next) { + B_next->prev_ptr = p_A; + } else { + _data->last = p_A; + } + p_A->prev_ptr = A_next == p_B ? p_B : B_prev; + p_A->next_ptr = B_next == p_A ? p_B : B_next; + p_B->prev_ptr = B_next == p_A ? p_A : A_prev; + p_B->next_ptr = A_next == p_B ? p_A : A_next; + } + /** + * copy the list + */ + void operator=(const List &p_list) { + clear(); + const Element *it = p_list.front(); + while (it) { + push_back(it->get()); + it = it->next(); + } + } + + T &operator[](int p_index) { + CRASH_BAD_INDEX(p_index, size()); + + Element *I = front(); + int c = 0; + while (I) { + if (c == p_index) { + return I->get(); + } + I = I->next(); + c++; + } + + CRASH_NOW(); // bug!! + } + + const T &operator[](int p_index) const { + CRASH_BAD_INDEX(p_index, size()); + + const Element *I = front(); + int c = 0; + while (I) { + if (c == p_index) { + return I->get(); + } + I = I->next(); + c++; + } + + CRASH_NOW(); // bug!! + } + + void move_to_back(Element *p_I) { + ERR_FAIL_COND(p_I->data != _data); + if (!p_I->next_ptr) { + return; + } + + if (_data->first == p_I) { + _data->first = p_I->next_ptr; + }; + + if (_data->last == p_I) { + _data->last = p_I->prev_ptr; + } + + if (p_I->prev_ptr) { + p_I->prev_ptr->next_ptr = p_I->next_ptr; + } + + p_I->next_ptr->prev_ptr = p_I->prev_ptr; + + _data->last->next_ptr = p_I; + p_I->prev_ptr = _data->last; + p_I->next_ptr = nullptr; + _data->last = p_I; + } + + void invert() { + int s = size() / 2; + Element *F = front(); + Element *B = back(); + for (int i = 0; i < s; i++) { + SWAP(F->value, B->value); + F = F->next(); + B = B->prev(); + } + } + + void move_to_front(Element *p_I) { + ERR_FAIL_COND(p_I->data != _data); + if (!p_I->prev_ptr) { + return; + } + + if (_data->first == p_I) { + _data->first = p_I->next_ptr; + }; + + if (_data->last == p_I) { + _data->last = p_I->prev_ptr; + } + + p_I->prev_ptr->next_ptr = p_I->next_ptr; + + if (p_I->next_ptr) { + p_I->next_ptr->prev_ptr = p_I->prev_ptr; + } + + _data->first->prev_ptr = p_I; + p_I->next_ptr = _data->first; + p_I->prev_ptr = nullptr; + _data->first = p_I; + } + + void move_before(Element *value, Element *where) { + if (value->prev_ptr) { + value->prev_ptr->next_ptr = value->next_ptr; + } else { + _data->first = value->next_ptr; + } + if (value->next_ptr) { + value->next_ptr->prev_ptr = value->prev_ptr; + } else { + _data->last = value->prev_ptr; + } + + value->next_ptr = where; + if (!where) { + value->prev_ptr = _data->last; + _data->last = value; + return; + }; + + value->prev_ptr = where->prev_ptr; + + if (where->prev_ptr) { + where->prev_ptr->next_ptr = value; + } else { + _data->first = value; + }; + + where->prev_ptr = value; + }; + + /** + * simple insertion sort + */ + + void sort() { + sort_custom>(); + } + + template + void sort_custom_inplace() { + if (size() < 2) { + return; + } + + Element *from = front(); + Element *current = from; + Element *to = from; + + while (current) { + Element *next = current->next_ptr; + + if (from != current) { + current->prev_ptr = NULL; + current->next_ptr = from; + + Element *find = from; + C less; + while (find && less(find->value, current->value)) { + current->prev_ptr = find; + current->next_ptr = find->next_ptr; + find = find->next_ptr; + } + + if (current->prev_ptr) { + current->prev_ptr->next_ptr = current; + } else { + from = current; + } + + if (current->next_ptr) { + current->next_ptr->prev_ptr = current; + } else { + to = current; + } + } else { + current->prev_ptr = NULL; + current->next_ptr = NULL; + } + + current = next; + } + _data->first = from; + _data->last = to; + } + + template + struct AuxiliaryComparator { + C compare; + _FORCE_INLINE_ bool operator()(const Element *a, const Element *b) const { + return compare(a->value, b->value); + } + }; + + template + void sort_custom() { + //this version uses auxiliary memory for speed. + //if you don't want to use auxiliary memory, use the in_place version + + int s = size(); + if (s < 2) { + return; + } + + Element **aux_buffer = memnew_arr(Element *, s); + + int idx = 0; + for (Element *E = front(); E; E = E->next_ptr) { + aux_buffer[idx] = E; + idx++; + } + + SortArray> sort; + sort.sort(aux_buffer, s); + + _data->first = aux_buffer[0]; + aux_buffer[0]->prev_ptr = nullptr; + aux_buffer[0]->next_ptr = aux_buffer[1]; + + _data->last = aux_buffer[s - 1]; + aux_buffer[s - 1]->prev_ptr = aux_buffer[s - 2]; + aux_buffer[s - 1]->next_ptr = nullptr; + + for (int i = 1; i < s - 1; i++) { + aux_buffer[i]->prev_ptr = aux_buffer[i - 1]; + aux_buffer[i]->next_ptr = aux_buffer[i + 1]; + } + + memdelete_arr(aux_buffer); + } + + const void *id() const { + return (void *)_data; + } + + /** + * copy constructor for the list + */ + List(const List &p_list) { + _data = nullptr; + const Element *it = p_list.front(); + while (it) { + push_back(it->get()); + it = it->next(); + } + } + + List() { + _data = nullptr; + }; + ~List() { + clear(); + if (_data) { + ERR_FAIL_COND(_data->size_cache); + memdelete_allocator<_Data, A>(_data); + } + }; +}; + +#line 0 + +#line 1 "sfwl/core/ring_buffer.h" + +/*************************************************************************/ +/* ring_buffer.h */ +/* From https://github.com/Relintai/pandemonium_engine (MIT) */ +/*************************************************************************/ + +template +class RingBuffer { + Vector data; + int read_pos; + int write_pos; + int size_mask; + + inline int inc(int &p_var, int p_size) const { + int ret = p_var; + p_var += p_size; + p_var = p_var & size_mask; + return ret; + }; + +public: + T read() { + ERR_FAIL_COND_V(space_left() < 1, T()); + return data.ptr()[inc(read_pos, 1)]; + }; + + int read(T *p_buf, int p_size, bool p_advance = true) { + int left = data_left(); + p_size = MIN(left, p_size); + int pos = read_pos; + int to_read = p_size; + int dst = 0; + while (to_read) { + int end = pos + to_read; + end = MIN(end, size()); + int total = end - pos; + const T *read = data.ptr(); + for (int i = 0; i < total; i++) { + p_buf[dst++] = read[pos + i]; + }; + to_read -= total; + pos = 0; + }; + if (p_advance) { + inc(read_pos, p_size); + }; + return p_size; + }; + + int copy(T *p_buf, int p_offset, int p_size) const { + int left = data_left(); + if ((p_offset + p_size) > left) { + p_size -= left - p_offset; + if (p_size <= 0) { + return 0; + } + } + p_size = MIN(left, p_size); + int pos = read_pos; + inc(pos, p_offset); + int to_read = p_size; + int dst = 0; + while (to_read) { + int end = pos + to_read; + end = MIN(end, size()); + int total = end - pos; + for (int i = 0; i < total; i++) { + p_buf[dst++] = data[pos + i]; + }; + to_read -= total; + pos = 0; + }; + return p_size; + }; + + int find(const T &t, int p_offset, int p_max_size) const { + int left = data_left(); + if ((p_offset + p_max_size) > left) { + p_max_size -= left - p_offset; + if (p_max_size <= 0) { + return 0; + } + } + p_max_size = MIN(left, p_max_size); + int pos = read_pos; + inc(pos, p_offset); + int to_read = p_max_size; + while (to_read) { + int end = pos + to_read; + end = MIN(end, size()); + int total = end - pos; + for (int i = 0; i < total; i++) { + if (data[pos + i] == t) { + return i + (p_max_size - to_read); + } + }; + to_read -= total; + pos = 0; + } + return -1; + } + + inline int advance_read(int p_n) { + p_n = MIN(p_n, data_left()); + inc(read_pos, p_n); + return p_n; + }; + + inline int decrease_write(int p_n) { + p_n = MIN(p_n, data_left()); + inc(write_pos, size_mask + 1 - p_n); + return p_n; + } + + Error write(const T &p_v) { + ERR_FAIL_COND_V(space_left() < 1, FAILED); + data.write[inc(write_pos, 1)] = p_v; + return OK; + }; + + int write(const T *p_buf, int p_size) { + int left = space_left(); + p_size = MIN(left, p_size); + + int pos = write_pos; + int to_write = p_size; + int src = 0; + while (to_write) { + int end = pos + to_write; + end = MIN(end, size()); + int total = end - pos; + + for (int i = 0; i < total; i++) { + data.write[pos + i] = p_buf[src++]; + }; + to_write -= total; + pos = 0; + }; + + inc(write_pos, p_size); + return p_size; + }; + + inline int space_left() const { + int left = read_pos - write_pos; + if (left < 0) { + return size() + left - 1; + }; + if (left == 0) { + return size() - 1; + }; + return left - 1; + }; + inline int data_left() const { + return size() - space_left() - 1; + }; + + inline int size() const { + return data.size(); + }; + + inline void clear() { + read_pos = 0; + write_pos = 0; + } + + void resize(int p_power) { + int old_size = size(); + int new_size = 1 << p_power; + int mask = new_size - 1; + data.resize(1 << p_power); + if (old_size < new_size && read_pos > write_pos) { + for (int i = 0; i < write_pos; i++) { + data.write[(old_size + i) & mask] = data[i]; + }; + write_pos = (old_size + write_pos) & mask; + } else { + read_pos = read_pos & mask; + write_pos = write_pos & mask; + }; + + size_mask = mask; + }; + + RingBuffer(int p_power = 0) { + read_pos = 0; + write_pos = 0; + resize(p_power); + }; + ~RingBuffer(){}; +}; + +#line 0 + +#line 1 "sfwl/core/paged_allocator.h" + +/*************************************************************************/ +/* paged_allocator.h */ +/* From https://github.com/Relintai/pandemonium_engine (MIT) */ +/*************************************************************************/ + +template +class PagedAllocator { + T **page_pool = nullptr; + T ***available_pool = nullptr; + uint32_t pages_allocated = 0; + uint32_t allocs_available = 0; + + uint32_t page_shift = 0; + uint32_t page_mask = 0; + uint32_t page_size = 0; + SpinLock spin_lock; + +public: + T *alloc() { + if (thread_safe) { + spin_lock.lock(); + } + if (unlikely(allocs_available == 0)) { + uint32_t pages_used = pages_allocated; + + pages_allocated++; + page_pool = (T **)memrealloc(page_pool, sizeof(T *) * pages_allocated); + available_pool = (T ***)memrealloc(available_pool, sizeof(T **) * pages_allocated); + + page_pool[pages_used] = (T *)memalloc(sizeof(T) * page_size); + available_pool[pages_used] = (T **)memalloc(sizeof(T *) * page_size); + + for (uint32_t i = 0; i < page_size; i++) { + available_pool[0][i] = &page_pool[pages_used][i]; + } + allocs_available += page_size; + } + + allocs_available--; + T *alloc = available_pool[allocs_available >> page_shift][allocs_available & page_mask]; + if (thread_safe) { + spin_lock.unlock(); + } + memnew_placement(alloc, T); + return alloc; + } + + void free(T *p_mem) { + if (thread_safe) { + spin_lock.lock(); + } + p_mem->~T(); + available_pool[allocs_available >> page_shift][allocs_available & page_mask] = p_mem; + if (thread_safe) { + spin_lock.unlock(); + } + allocs_available++; + } + + void reset(bool p_allow_unfreed = false) { + if (!p_allow_unfreed || !HAS_TRIVIAL_DESTRUCTOR(T)) { + ERR_FAIL_COND(allocs_available < pages_allocated * page_size); + } + if (pages_allocated) { + for (uint32_t i = 0; i < pages_allocated; i++) { + memfree(page_pool[i]); + memfree(available_pool[i]); + } + memfree(page_pool); + memfree(available_pool); + page_pool = nullptr; + available_pool = nullptr; + pages_allocated = 0; + allocs_available = 0; + } + } + bool is_configured() const { + return page_size > 0; + } + + void configure(uint32_t p_page_size) { + ERR_FAIL_COND(page_pool != nullptr); //sanity check + ERR_FAIL_COND(p_page_size == 0); + page_size = nearest_power_of_2_templated(p_page_size); + page_mask = page_size - 1; + page_shift = get_shift_from_power_of_2(page_size); + } + + // Power of 2 recommended because of alignment with OS page sizes. + // Even if element is bigger, its still a multiple and get rounded amount of pages + PagedAllocator(uint32_t p_page_size = 4096) { + configure(p_page_size); + } + + ~PagedAllocator() { + ERR_FAIL_COND_MSG(allocs_available < pages_allocated * page_size, "Pages in use exist at exit in PagedAllocator"); + reset(); + } +}; + +#line 0 + +#line 1 "sfwl/core/pool_allocator.h" + +/*************************************************************************/ +/* pool_allocator.h */ +/* From https://github.com/Relintai/pandemonium_engine (MIT) */ +/*************************************************************************/ + +/** + @author Juan Linietsky + * Generic Pool Allocator. + * This is a generic memory pool allocator, with locking, compacting and alignment. (@TODO alignment) + * It used as a standard way to manage allocation in a specific region of memory, such as texture memory, + * audio sample memory, or just any kind of memory overall. + * (@TODO) abstraction should be greater, because in many platforms, you need to manage a nonreachable memory. +*/ + +enum { + + POOL_ALLOCATOR_INVALID_ID = -1 ///< default invalid value. use INVALID_ID( id ) to test +}; + +class PoolAllocator { +public: + typedef int ID; + +private: + enum { + CHECK_BITS = 8, + CHECK_LEN = (1 << CHECK_BITS), + CHECK_MASK = CHECK_LEN - 1 + + }; + + struct Entry { + unsigned int pos; + unsigned int len; + unsigned int lock; + unsigned int check; + + inline void clear() { + pos = 0; + len = 0; + lock = 0; + check = 0; + } + Entry() { clear(); } + }; + + typedef int EntryArrayPos; + typedef int EntryIndicesPos; + + Entry *entry_array; + int *entry_indices; + int entry_max; + int entry_count; + + uint8_t *pool; + void *mem_ptr; + int pool_size; + + int free_mem; + int free_mem_peak; + + unsigned int check_count; + int align; + + bool needs_locking; + + inline int entry_end(const Entry &p_entry) const { + return p_entry.pos + aligned(p_entry.len); + } + inline int aligned(int p_size) const { + int rem = p_size % align; + if (rem) { + p_size += align - rem; + } + + return p_size; + } + + void compact(int p_up_to = -1); + void compact_up(int p_from = 0); + bool get_free_entry(EntryArrayPos *p_pos); + bool find_hole(EntryArrayPos *p_pos, int p_for_size); + bool find_entry_index(EntryIndicesPos *p_map_pos, Entry *p_entry); + Entry *get_entry(ID p_mem); + const Entry *get_entry(ID p_mem) const; + + void create_pool(void *p_mem, int p_size, int p_max_entries); + +protected: + virtual void mt_lock() const; ///< Reimplement for custom mt locking + virtual void mt_unlock() const; ///< Reimplement for custom mt locking + +public: + enum { + DEFAULT_MAX_ALLOCS = 4096, + }; + + ID alloc(int p_size); ///< Alloc memory, get an ID on success, POOL_ALOCATOR_INVALID_ID on failure + void free(ID p_mem); ///< Free allocated memory + Error resize(ID p_mem, int p_new_size); ///< resize a memory chunk + int get_size(ID p_mem) const; + + int get_free_mem(); ///< get free memory + int get_used_mem() const; + int get_free_peak(); ///< get free memory + + Error lock(ID p_mem); //@todo move this out + void *get(ID p_mem); + const void *get(ID p_mem) const; + void unlock(ID p_mem); + bool is_locked(ID p_mem) const; + + PoolAllocator(int p_size, bool p_needs_locking = false, int p_max_entries = DEFAULT_MAX_ALLOCS); + PoolAllocator(void *p_mem, int p_size, int p_align = 1, bool p_needs_locking = false, int p_max_entries = DEFAULT_MAX_ALLOCS); + PoolAllocator(int p_align, int p_size, bool p_needs_locking = false, int p_max_entries = DEFAULT_MAX_ALLOCS); + + virtual ~PoolAllocator(); +}; + +#line 0 + +#line 1 "sfwl/core/char_range.inc" +/*************************************************************************/ +/* char_range.inc */ +/* From https://github.com/Relintai/pandemonium_engine (MIT) */ +/*************************************************************************/ + +struct CharRange { + char32_t start; + char32_t end; +}; + +static CharRange xid_start[] = { + { 0x41, 0x5a }, + { 0x5f, 0x5f }, + { 0x61, 0x7a }, + { 0xaa, 0xaa }, + { 0xb5, 0xb5 }, + { 0xba, 0xba }, + { 0xc0, 0xd6 }, + { 0xd8, 0xf6 }, + { 0xf8, 0x2c1 }, + { 0x2c6, 0x2d1 }, + { 0x2e0, 0x2e4 }, + { 0x2ec, 0x2ec }, + { 0x2ee, 0x2ee }, + { 0x370, 0x374 }, + { 0x376, 0x377 }, + { 0x37a, 0x37d }, + { 0x37f, 0x37f }, + { 0x386, 0x386 }, + { 0x388, 0x38a }, + { 0x38c, 0x38c }, + { 0x38e, 0x3a1 }, + { 0x3a3, 0x3f5 }, + { 0x3f7, 0x481 }, + { 0x48a, 0x52f }, + { 0x531, 0x556 }, + { 0x559, 0x559 }, + { 0x560, 0x588 }, + { 0x5d0, 0x5ea }, + { 0x5ef, 0x5f2 }, + { 0x620, 0x64a }, + { 0x66e, 0x66f }, + { 0x671, 0x6d3 }, + { 0x6d5, 0x6d5 }, + { 0x6e5, 0x6e6 }, + { 0x6ee, 0x6ef }, + { 0x6fa, 0x6fc }, + { 0x6ff, 0x6ff }, + { 0x710, 0x710 }, + { 0x712, 0x72f }, + { 0x74d, 0x7a5 }, + { 0x7b1, 0x7b1 }, + { 0x7ca, 0x7ea }, + { 0x7f4, 0x7f5 }, + { 0x7fa, 0x7fa }, + { 0x800, 0x815 }, + { 0x81a, 0x81a }, + { 0x824, 0x824 }, + { 0x828, 0x828 }, + { 0x840, 0x858 }, + { 0x860, 0x86a }, + { 0x870, 0x887 }, + { 0x889, 0x88e }, + { 0x8a0, 0x8c9 }, + { 0x904, 0x939 }, + { 0x93d, 0x93d }, + { 0x950, 0x950 }, + { 0x958, 0x961 }, + { 0x971, 0x980 }, + { 0x985, 0x98c }, + { 0x98f, 0x990 }, + { 0x993, 0x9a8 }, + { 0x9aa, 0x9b0 }, + { 0x9b2, 0x9b2 }, + { 0x9b6, 0x9b9 }, + { 0x9bd, 0x9bd }, + { 0x9ce, 0x9ce }, + { 0x9dc, 0x9dd }, + { 0x9df, 0x9e1 }, + { 0x9f0, 0x9f1 }, + { 0x9fc, 0x9fc }, + { 0xa05, 0xa0a }, + { 0xa0f, 0xa10 }, + { 0xa13, 0xa28 }, + { 0xa2a, 0xa30 }, + { 0xa32, 0xa33 }, + { 0xa35, 0xa36 }, + { 0xa38, 0xa39 }, + { 0xa59, 0xa5c }, + { 0xa5e, 0xa5e }, + { 0xa72, 0xa74 }, + { 0xa85, 0xa8d }, + { 0xa8f, 0xa91 }, + { 0xa93, 0xaa8 }, + { 0xaaa, 0xab0 }, + { 0xab2, 0xab3 }, + { 0xab5, 0xab9 }, + { 0xabd, 0xabd }, + { 0xad0, 0xad0 }, + { 0xae0, 0xae1 }, + { 0xaf9, 0xaf9 }, + { 0xb05, 0xb0c }, + { 0xb0f, 0xb10 }, + { 0xb13, 0xb28 }, + { 0xb2a, 0xb30 }, + { 0xb32, 0xb33 }, + { 0xb35, 0xb39 }, + { 0xb3d, 0xb3d }, + { 0xb5c, 0xb5d }, + { 0xb5f, 0xb61 }, + { 0xb71, 0xb71 }, + { 0xb83, 0xb83 }, + { 0xb85, 0xb8a }, + { 0xb8e, 0xb90 }, + { 0xb92, 0xb95 }, + { 0xb99, 0xb9a }, + { 0xb9c, 0xb9c }, + { 0xb9e, 0xb9f }, + { 0xba3, 0xba4 }, + { 0xba8, 0xbaa }, + { 0xbae, 0xbb9 }, + { 0xbd0, 0xbd0 }, + { 0xc05, 0xc0c }, + { 0xc0e, 0xc10 }, + { 0xc12, 0xc28 }, + { 0xc2a, 0xc39 }, + { 0xc3d, 0xc3d }, + { 0xc58, 0xc5a }, + { 0xc5d, 0xc5d }, + { 0xc60, 0xc61 }, + { 0xc80, 0xc80 }, + { 0xc85, 0xc8c }, + { 0xc8e, 0xc90 }, + { 0xc92, 0xca8 }, + { 0xcaa, 0xcb3 }, + { 0xcb5, 0xcb9 }, + { 0xcbd, 0xcbd }, + { 0xcdd, 0xcde }, + { 0xce0, 0xce1 }, + { 0xcf1, 0xcf2 }, + { 0xd04, 0xd0c }, + { 0xd0e, 0xd10 }, + { 0xd12, 0xd3a }, + { 0xd3d, 0xd3d }, + { 0xd4e, 0xd4e }, + { 0xd54, 0xd56 }, + { 0xd5f, 0xd61 }, + { 0xd7a, 0xd7f }, + { 0xd85, 0xd96 }, + { 0xd9a, 0xdb1 }, + { 0xdb3, 0xdbb }, + { 0xdbd, 0xdbd }, + { 0xdc0, 0xdc6 }, + { 0xe01, 0xe30 }, + { 0xe32, 0xe33 }, + { 0xe40, 0xe46 }, + { 0xe81, 0xe82 }, + { 0xe84, 0xe84 }, + { 0xe86, 0xe8a }, + { 0xe8c, 0xea3 }, + { 0xea5, 0xea5 }, + { 0xea7, 0xeb0 }, + { 0xeb2, 0xeb3 }, + { 0xebd, 0xebd }, + { 0xec0, 0xec4 }, + { 0xec6, 0xec6 }, + { 0xedc, 0xedf }, + { 0xf00, 0xf00 }, + { 0xf40, 0xf47 }, + { 0xf49, 0xf6c }, + { 0xf88, 0xf8c }, + { 0x1000, 0x102a }, + { 0x103f, 0x103f }, + { 0x1050, 0x1055 }, + { 0x105a, 0x105d }, + { 0x1061, 0x1061 }, + { 0x1065, 0x1066 }, + { 0x106e, 0x1070 }, + { 0x1075, 0x1081 }, + { 0x108e, 0x108e }, + { 0x10a0, 0x10c5 }, + { 0x10c7, 0x10c7 }, + { 0x10cd, 0x10cd }, + { 0x10d0, 0x10fa }, + { 0x10fc, 0x1248 }, + { 0x124a, 0x124d }, + { 0x1250, 0x1256 }, + { 0x1258, 0x1258 }, + { 0x125a, 0x125d }, + { 0x1260, 0x1288 }, + { 0x128a, 0x128d }, + { 0x1290, 0x12b0 }, + { 0x12b2, 0x12b5 }, + { 0x12b8, 0x12be }, + { 0x12c0, 0x12c0 }, + { 0x12c2, 0x12c5 }, + { 0x12c8, 0x12d6 }, + { 0x12d8, 0x1310 }, + { 0x1312, 0x1315 }, + { 0x1318, 0x135a }, + { 0x1380, 0x138f }, + { 0x13a0, 0x13f5 }, + { 0x13f8, 0x13fd }, + { 0x1401, 0x166c }, + { 0x166f, 0x167f }, + { 0x1681, 0x169a }, + { 0x16a0, 0x16ea }, + { 0x16ee, 0x16f8 }, + { 0x1700, 0x1711 }, + { 0x171f, 0x1731 }, + { 0x1740, 0x1751 }, + { 0x1760, 0x176c }, + { 0x176e, 0x1770 }, + { 0x1780, 0x17b3 }, + { 0x17d7, 0x17d7 }, + { 0x17dc, 0x17dc }, + { 0x1820, 0x1878 }, + { 0x1880, 0x1884 }, + { 0x1887, 0x18a8 }, + { 0x18aa, 0x18aa }, + { 0x18b0, 0x18f5 }, + { 0x1900, 0x191e }, + { 0x1950, 0x196d }, + { 0x1970, 0x1974 }, + { 0x1980, 0x19ab }, + { 0x19b0, 0x19c9 }, + { 0x1a00, 0x1a16 }, + { 0x1a20, 0x1a54 }, + { 0x1aa7, 0x1aa7 }, + { 0x1b05, 0x1b33 }, + { 0x1b45, 0x1b4c }, + { 0x1b83, 0x1ba0 }, + { 0x1bae, 0x1baf }, + { 0x1bba, 0x1be5 }, + { 0x1c00, 0x1c23 }, + { 0x1c4d, 0x1c4f }, + { 0x1c5a, 0x1c7d }, + { 0x1c80, 0x1c88 }, + { 0x1c90, 0x1cba }, + { 0x1cbd, 0x1cbf }, + { 0x1ce9, 0x1cec }, + { 0x1cee, 0x1cf3 }, + { 0x1cf5, 0x1cf6 }, + { 0x1cfa, 0x1cfa }, + { 0x1d00, 0x1dbf }, + { 0x1e00, 0x1f15 }, + { 0x1f18, 0x1f1d }, + { 0x1f20, 0x1f45 }, + { 0x1f48, 0x1f4d }, + { 0x1f50, 0x1f57 }, + { 0x1f59, 0x1f59 }, + { 0x1f5b, 0x1f5b }, + { 0x1f5d, 0x1f5d }, + { 0x1f5f, 0x1f7d }, + { 0x1f80, 0x1fb4 }, + { 0x1fb6, 0x1fbc }, + { 0x1fbe, 0x1fbe }, + { 0x1fc2, 0x1fc4 }, + { 0x1fc6, 0x1fcc }, + { 0x1fd0, 0x1fd3 }, + { 0x1fd6, 0x1fdb }, + { 0x1fe0, 0x1fec }, + { 0x1ff2, 0x1ff4 }, + { 0x1ff6, 0x1ffc }, + { 0x2071, 0x2071 }, + { 0x207f, 0x207f }, + { 0x2090, 0x209c }, + { 0x2102, 0x2102 }, + { 0x2107, 0x2107 }, + { 0x210a, 0x2113 }, + { 0x2115, 0x2115 }, + { 0x2118, 0x211d }, + { 0x2124, 0x2124 }, + { 0x2126, 0x2126 }, + { 0x2128, 0x2128 }, + { 0x212a, 0x2139 }, + { 0x213c, 0x213f }, + { 0x2145, 0x2149 }, + { 0x214e, 0x214e }, + { 0x2160, 0x2188 }, + { 0x2c00, 0x2ce4 }, + { 0x2ceb, 0x2cee }, + { 0x2cf2, 0x2cf3 }, + { 0x2d00, 0x2d25 }, + { 0x2d27, 0x2d27 }, + { 0x2d2d, 0x2d2d }, + { 0x2d30, 0x2d67 }, + { 0x2d6f, 0x2d6f }, + { 0x2d80, 0x2d96 }, + { 0x2da0, 0x2da6 }, + { 0x2da8, 0x2dae }, + { 0x2db0, 0x2db6 }, + { 0x2db8, 0x2dbe }, + { 0x2dc0, 0x2dc6 }, + { 0x2dc8, 0x2dce }, + { 0x2dd0, 0x2dd6 }, + { 0x2dd8, 0x2dde }, + { 0x3005, 0x3007 }, + { 0x3021, 0x3029 }, + { 0x3031, 0x3035 }, + { 0x3038, 0x303c }, + { 0x3041, 0x3096 }, + { 0x309b, 0x309f }, + { 0x30a1, 0x30fa }, + { 0x30fc, 0x30ff }, + { 0x3105, 0x312f }, + { 0x3131, 0x318e }, + { 0x31a0, 0x31bf }, + { 0x31f0, 0x31ff }, + { 0x3400, 0x4dbf }, + { 0x4e00, 0xa48c }, + { 0xa4d0, 0xa4fd }, + { 0xa500, 0xa60c }, + { 0xa610, 0xa61f }, + { 0xa62a, 0xa62b }, + { 0xa640, 0xa66e }, + { 0xa67f, 0xa69d }, + { 0xa6a0, 0xa6ef }, + { 0xa717, 0xa71f }, + { 0xa722, 0xa788 }, + { 0xa78b, 0xa7ca }, + { 0xa7d0, 0xa7d1 }, + { 0xa7d3, 0xa7d3 }, + { 0xa7d5, 0xa7d9 }, + { 0xa7f2, 0xa801 }, + { 0xa803, 0xa805 }, + { 0xa807, 0xa80a }, + { 0xa80c, 0xa822 }, + { 0xa840, 0xa873 }, + { 0xa882, 0xa8b3 }, + { 0xa8f2, 0xa8f7 }, + { 0xa8fb, 0xa8fb }, + { 0xa8fd, 0xa8fe }, + { 0xa90a, 0xa925 }, + { 0xa930, 0xa946 }, + { 0xa960, 0xa97c }, + { 0xa984, 0xa9b2 }, + { 0xa9cf, 0xa9cf }, + { 0xa9e0, 0xa9e4 }, + { 0xa9e6, 0xa9ef }, + { 0xa9fa, 0xa9fe }, + { 0xaa00, 0xaa28 }, + { 0xaa40, 0xaa42 }, + { 0xaa44, 0xaa4b }, + { 0xaa60, 0xaa76 }, + { 0xaa7a, 0xaa7a }, + { 0xaa7e, 0xaaaf }, + { 0xaab1, 0xaab1 }, + { 0xaab5, 0xaab6 }, + { 0xaab9, 0xaabd }, + { 0xaac0, 0xaac0 }, + { 0xaac2, 0xaac2 }, + { 0xaadb, 0xaadd }, + { 0xaae0, 0xaaea }, + { 0xaaf2, 0xaaf4 }, + { 0xab01, 0xab06 }, + { 0xab09, 0xab0e }, + { 0xab11, 0xab16 }, + { 0xab20, 0xab26 }, + { 0xab28, 0xab2e }, + { 0xab30, 0xab5a }, + { 0xab5c, 0xab69 }, + { 0xab70, 0xabe2 }, + { 0xac00, 0xd7a3 }, + { 0xd7b0, 0xd7c6 }, + { 0xd7cb, 0xd7fb }, + { 0xf900, 0xfa6d }, + { 0xfa70, 0xfad9 }, + { 0xfb00, 0xfb06 }, + { 0xfb13, 0xfb17 }, + { 0xfb1d, 0xfb1d }, + { 0xfb1f, 0xfb28 }, + { 0xfb2a, 0xfb36 }, + { 0xfb38, 0xfb3c }, + { 0xfb3e, 0xfb3e }, + { 0xfb40, 0xfb41 }, + { 0xfb43, 0xfb44 }, + { 0xfb46, 0xfbb1 }, + { 0xfbd3, 0xfd3d }, + { 0xfd50, 0xfd8f }, + { 0xfd92, 0xfdc7 }, + { 0xfdf0, 0xfdfb }, + { 0xfe70, 0xfe74 }, + { 0xfe76, 0xfefc }, + { 0xff21, 0xff3a }, + { 0xff41, 0xff5a }, + { 0xff66, 0xffbe }, + { 0xffc2, 0xffc7 }, + { 0xffca, 0xffcf }, + { 0xffd2, 0xffd7 }, + { 0xffda, 0xffdc }, + { 0x10000, 0x1000b }, + { 0x1000d, 0x10026 }, + { 0x10028, 0x1003a }, + { 0x1003c, 0x1003d }, + { 0x1003f, 0x1004d }, + { 0x10050, 0x1005d }, + { 0x10080, 0x100fa }, + { 0x10140, 0x10174 }, + { 0x10280, 0x1029c }, + { 0x102a0, 0x102d0 }, + { 0x10300, 0x1031f }, + { 0x1032d, 0x1034a }, + { 0x10350, 0x10375 }, + { 0x10380, 0x1039d }, + { 0x103a0, 0x103c3 }, + { 0x103c8, 0x103cf }, + { 0x103d1, 0x103d5 }, + { 0x10400, 0x1049d }, + { 0x104b0, 0x104d3 }, + { 0x104d8, 0x104fb }, + { 0x10500, 0x10527 }, + { 0x10530, 0x10563 }, + { 0x10570, 0x1057a }, + { 0x1057c, 0x1058a }, + { 0x1058c, 0x10592 }, + { 0x10594, 0x10595 }, + { 0x10597, 0x105a1 }, + { 0x105a3, 0x105b1 }, + { 0x105b3, 0x105b9 }, + { 0x105bb, 0x105bc }, + { 0x10600, 0x10736 }, + { 0x10740, 0x10755 }, + { 0x10760, 0x10767 }, + { 0x10780, 0x10785 }, + { 0x10787, 0x107b0 }, + { 0x107b2, 0x107ba }, + { 0x10800, 0x10805 }, + { 0x10808, 0x10808 }, + { 0x1080a, 0x10835 }, + { 0x10837, 0x10838 }, + { 0x1083c, 0x1083c }, + { 0x1083f, 0x10855 }, + { 0x10860, 0x10876 }, + { 0x10880, 0x1089e }, + { 0x108e0, 0x108f2 }, + { 0x108f4, 0x108f5 }, + { 0x10900, 0x10915 }, + { 0x10920, 0x10939 }, + { 0x10980, 0x109b7 }, + { 0x109be, 0x109bf }, + { 0x10a00, 0x10a00 }, + { 0x10a10, 0x10a13 }, + { 0x10a15, 0x10a17 }, + { 0x10a19, 0x10a35 }, + { 0x10a60, 0x10a7c }, + { 0x10a80, 0x10a9c }, + { 0x10ac0, 0x10ac7 }, + { 0x10ac9, 0x10ae4 }, + { 0x10b00, 0x10b35 }, + { 0x10b40, 0x10b55 }, + { 0x10b60, 0x10b72 }, + { 0x10b80, 0x10b91 }, + { 0x10c00, 0x10c48 }, + { 0x10c80, 0x10cb2 }, + { 0x10cc0, 0x10cf2 }, + { 0x10d00, 0x10d23 }, + { 0x10e80, 0x10ea9 }, + { 0x10eb0, 0x10eb1 }, + { 0x10f00, 0x10f1c }, + { 0x10f27, 0x10f27 }, + { 0x10f30, 0x10f45 }, + { 0x10f70, 0x10f81 }, + { 0x10fb0, 0x10fc4 }, + { 0x10fe0, 0x10ff6 }, + { 0x11003, 0x11037 }, + { 0x11071, 0x11072 }, + { 0x11075, 0x11075 }, + { 0x11083, 0x110af }, + { 0x110d0, 0x110e8 }, + { 0x11103, 0x11126 }, + { 0x11144, 0x11144 }, + { 0x11147, 0x11147 }, + { 0x11150, 0x11172 }, + { 0x11176, 0x11176 }, + { 0x11183, 0x111b2 }, + { 0x111c1, 0x111c4 }, + { 0x111da, 0x111da }, + { 0x111dc, 0x111dc }, + { 0x11200, 0x11211 }, + { 0x11213, 0x1122b }, + { 0x11280, 0x11286 }, + { 0x11288, 0x11288 }, + { 0x1128a, 0x1128d }, + { 0x1128f, 0x1129d }, + { 0x1129f, 0x112a8 }, + { 0x112b0, 0x112de }, + { 0x11305, 0x1130c }, + { 0x1130f, 0x11310 }, + { 0x11313, 0x11328 }, + { 0x1132a, 0x11330 }, + { 0x11332, 0x11333 }, + { 0x11335, 0x11339 }, + { 0x1133d, 0x1133d }, + { 0x11350, 0x11350 }, + { 0x1135d, 0x11361 }, + { 0x11400, 0x11434 }, + { 0x11447, 0x1144a }, + { 0x1145f, 0x11461 }, + { 0x11480, 0x114af }, + { 0x114c4, 0x114c5 }, + { 0x114c7, 0x114c7 }, + { 0x11580, 0x115ae }, + { 0x115d8, 0x115db }, + { 0x11600, 0x1162f }, + { 0x11644, 0x11644 }, + { 0x11680, 0x116aa }, + { 0x116b8, 0x116b8 }, + { 0x11700, 0x1171a }, + { 0x11740, 0x11746 }, + { 0x11800, 0x1182b }, + { 0x118a0, 0x118df }, + { 0x118ff, 0x11906 }, + { 0x11909, 0x11909 }, + { 0x1190c, 0x11913 }, + { 0x11915, 0x11916 }, + { 0x11918, 0x1192f }, + { 0x1193f, 0x1193f }, + { 0x11941, 0x11941 }, + { 0x119a0, 0x119a7 }, + { 0x119aa, 0x119d0 }, + { 0x119e1, 0x119e1 }, + { 0x119e3, 0x119e3 }, + { 0x11a00, 0x11a00 }, + { 0x11a0b, 0x11a32 }, + { 0x11a3a, 0x11a3a }, + { 0x11a50, 0x11a50 }, + { 0x11a5c, 0x11a89 }, + { 0x11a9d, 0x11a9d }, + { 0x11ab0, 0x11af8 }, + { 0x11c00, 0x11c08 }, + { 0x11c0a, 0x11c2e }, + { 0x11c40, 0x11c40 }, + { 0x11c72, 0x11c8f }, + { 0x11d00, 0x11d06 }, + { 0x11d08, 0x11d09 }, + { 0x11d0b, 0x11d30 }, + { 0x11d46, 0x11d46 }, + { 0x11d60, 0x11d65 }, + { 0x11d67, 0x11d68 }, + { 0x11d6a, 0x11d89 }, + { 0x11d98, 0x11d98 }, + { 0x11ee0, 0x11ef2 }, + { 0x11fb0, 0x11fb0 }, + { 0x12000, 0x12399 }, + { 0x12400, 0x1246e }, + { 0x12480, 0x12543 }, + { 0x12f90, 0x12ff0 }, + { 0x13000, 0x1342e }, + { 0x14400, 0x14646 }, + { 0x16800, 0x16a38 }, + { 0x16a40, 0x16a5e }, + { 0x16a70, 0x16abe }, + { 0x16ad0, 0x16aed }, + { 0x16b00, 0x16b2f }, + { 0x16b40, 0x16b43 }, + { 0x16b63, 0x16b77 }, + { 0x16b7d, 0x16b8f }, + { 0x16e40, 0x16e7f }, + { 0x16f00, 0x16f4a }, + { 0x16f50, 0x16f50 }, + { 0x16f93, 0x16f9f }, + { 0x16fe0, 0x16fe1 }, + { 0x16fe3, 0x16fe3 }, + { 0x17000, 0x187f7 }, + { 0x18800, 0x18cd5 }, + { 0x18d00, 0x18d08 }, + { 0x1aff0, 0x1aff3 }, + { 0x1aff5, 0x1affb }, + { 0x1affd, 0x1affe }, + { 0x1b000, 0x1b122 }, + { 0x1b150, 0x1b152 }, + { 0x1b164, 0x1b167 }, + { 0x1b170, 0x1b2fb }, + { 0x1bc00, 0x1bc6a }, + { 0x1bc70, 0x1bc7c }, + { 0x1bc80, 0x1bc88 }, + { 0x1bc90, 0x1bc99 }, + { 0x1d400, 0x1d454 }, + { 0x1d456, 0x1d49c }, + { 0x1d49e, 0x1d49f }, + { 0x1d4a2, 0x1d4a2 }, + { 0x1d4a5, 0x1d4a6 }, + { 0x1d4a9, 0x1d4ac }, + { 0x1d4ae, 0x1d4b9 }, + { 0x1d4bb, 0x1d4bb }, + { 0x1d4bd, 0x1d4c3 }, + { 0x1d4c5, 0x1d505 }, + { 0x1d507, 0x1d50a }, + { 0x1d50d, 0x1d514 }, + { 0x1d516, 0x1d51c }, + { 0x1d51e, 0x1d539 }, + { 0x1d53b, 0x1d53e }, + { 0x1d540, 0x1d544 }, + { 0x1d546, 0x1d546 }, + { 0x1d54a, 0x1d550 }, + { 0x1d552, 0x1d6a5 }, + { 0x1d6a8, 0x1d6c0 }, + { 0x1d6c2, 0x1d6da }, + { 0x1d6dc, 0x1d6fa }, + { 0x1d6fc, 0x1d714 }, + { 0x1d716, 0x1d734 }, + { 0x1d736, 0x1d74e }, + { 0x1d750, 0x1d76e }, + { 0x1d770, 0x1d788 }, + { 0x1d78a, 0x1d7a8 }, + { 0x1d7aa, 0x1d7c2 }, + { 0x1d7c4, 0x1d7cb }, + { 0x1df00, 0x1df1e }, + { 0x1e100, 0x1e12c }, + { 0x1e137, 0x1e13d }, + { 0x1e14e, 0x1e14e }, + { 0x1e290, 0x1e2ad }, + { 0x1e2c0, 0x1e2eb }, + { 0x1e7e0, 0x1e7e6 }, + { 0x1e7e8, 0x1e7eb }, + { 0x1e7ed, 0x1e7ee }, + { 0x1e7f0, 0x1e7fe }, + { 0x1e800, 0x1e8c4 }, + { 0x1e900, 0x1e943 }, + { 0x1e94b, 0x1e94b }, + { 0x1ee00, 0x1ee03 }, + { 0x1ee05, 0x1ee1f }, + { 0x1ee21, 0x1ee22 }, + { 0x1ee24, 0x1ee24 }, + { 0x1ee27, 0x1ee27 }, + { 0x1ee29, 0x1ee32 }, + { 0x1ee34, 0x1ee37 }, + { 0x1ee39, 0x1ee39 }, + { 0x1ee3b, 0x1ee3b }, + { 0x1ee42, 0x1ee42 }, + { 0x1ee47, 0x1ee47 }, + { 0x1ee49, 0x1ee49 }, + { 0x1ee4b, 0x1ee4b }, + { 0x1ee4d, 0x1ee4f }, + { 0x1ee51, 0x1ee52 }, + { 0x1ee54, 0x1ee54 }, + { 0x1ee57, 0x1ee57 }, + { 0x1ee59, 0x1ee59 }, + { 0x1ee5b, 0x1ee5b }, + { 0x1ee5d, 0x1ee5d }, + { 0x1ee5f, 0x1ee5f }, + { 0x1ee61, 0x1ee62 }, + { 0x1ee64, 0x1ee64 }, + { 0x1ee67, 0x1ee6a }, + { 0x1ee6c, 0x1ee72 }, + { 0x1ee74, 0x1ee77 }, + { 0x1ee79, 0x1ee7c }, + { 0x1ee7e, 0x1ee7e }, + { 0x1ee80, 0x1ee89 }, + { 0x1ee8b, 0x1ee9b }, + { 0x1eea1, 0x1eea3 }, + { 0x1eea5, 0x1eea9 }, + { 0x1eeab, 0x1eebb }, + { 0x20000, 0x2a6df }, + { 0x2a700, 0x2b738 }, + { 0x2b740, 0x2b81d }, + { 0x2b820, 0x2cea1 }, + { 0x2ceb0, 0x2ebe0 }, + { 0x2f800, 0x2fa1d }, + { 0x30000, 0x3134a }, + { 0x0, 0x0 }, +}; + +static CharRange xid_continue[] = { + { 0x30, 0x39 }, + { 0x41, 0x5a }, + { 0x5f, 0x5f }, + { 0x61, 0x7a }, + { 0xaa, 0xaa }, + { 0xb5, 0xb5 }, + { 0xb7, 0xb7 }, + { 0xba, 0xba }, + { 0xc0, 0xd6 }, + { 0xd8, 0xf6 }, + { 0xf8, 0x2c1 }, + { 0x2c6, 0x2d1 }, + { 0x2e0, 0x2e4 }, + { 0x2ec, 0x2ec }, + { 0x2ee, 0x2ee }, + { 0x300, 0x374 }, + { 0x376, 0x377 }, + { 0x37a, 0x37d }, + { 0x37f, 0x37f }, + { 0x386, 0x38a }, + { 0x38c, 0x38c }, + { 0x38e, 0x3a1 }, + { 0x3a3, 0x3f5 }, + { 0x3f7, 0x481 }, + { 0x483, 0x487 }, + { 0x48a, 0x52f }, + { 0x531, 0x556 }, + { 0x559, 0x559 }, + { 0x560, 0x588 }, + { 0x591, 0x5bd }, + { 0x5bf, 0x5bf }, + { 0x5c1, 0x5c2 }, + { 0x5c4, 0x5c5 }, + { 0x5c7, 0x5c7 }, + { 0x5d0, 0x5ea }, + { 0x5ef, 0x5f2 }, + { 0x610, 0x61a }, + { 0x620, 0x669 }, + { 0x66e, 0x6d3 }, + { 0x6d5, 0x6dc }, + { 0x6df, 0x6e8 }, + { 0x6ea, 0x6fc }, + { 0x6ff, 0x6ff }, + { 0x710, 0x74a }, + { 0x74d, 0x7b1 }, + { 0x7c0, 0x7f5 }, + { 0x7fa, 0x7fa }, + { 0x7fd, 0x7fd }, + { 0x800, 0x82d }, + { 0x840, 0x85b }, + { 0x860, 0x86a }, + { 0x870, 0x887 }, + { 0x889, 0x88e }, + { 0x898, 0x8e1 }, + { 0x8e3, 0x963 }, + { 0x966, 0x96f }, + { 0x971, 0x983 }, + { 0x985, 0x98c }, + { 0x98f, 0x990 }, + { 0x993, 0x9a8 }, + { 0x9aa, 0x9b0 }, + { 0x9b2, 0x9b2 }, + { 0x9b6, 0x9b9 }, + { 0x9bc, 0x9c4 }, + { 0x9c7, 0x9c8 }, + { 0x9cb, 0x9ce }, + { 0x9d7, 0x9d7 }, + { 0x9dc, 0x9dd }, + { 0x9df, 0x9e3 }, + { 0x9e6, 0x9f1 }, + { 0x9fc, 0x9fc }, + { 0x9fe, 0x9fe }, + { 0xa01, 0xa03 }, + { 0xa05, 0xa0a }, + { 0xa0f, 0xa10 }, + { 0xa13, 0xa28 }, + { 0xa2a, 0xa30 }, + { 0xa32, 0xa33 }, + { 0xa35, 0xa36 }, + { 0xa38, 0xa39 }, + { 0xa3c, 0xa3c }, + { 0xa3e, 0xa42 }, + { 0xa47, 0xa48 }, + { 0xa4b, 0xa4d }, + { 0xa51, 0xa51 }, + { 0xa59, 0xa5c }, + { 0xa5e, 0xa5e }, + { 0xa66, 0xa75 }, + { 0xa81, 0xa83 }, + { 0xa85, 0xa8d }, + { 0xa8f, 0xa91 }, + { 0xa93, 0xaa8 }, + { 0xaaa, 0xab0 }, + { 0xab2, 0xab3 }, + { 0xab5, 0xab9 }, + { 0xabc, 0xac5 }, + { 0xac7, 0xac9 }, + { 0xacb, 0xacd }, + { 0xad0, 0xad0 }, + { 0xae0, 0xae3 }, + { 0xae6, 0xaef }, + { 0xaf9, 0xaff }, + { 0xb01, 0xb03 }, + { 0xb05, 0xb0c }, + { 0xb0f, 0xb10 }, + { 0xb13, 0xb28 }, + { 0xb2a, 0xb30 }, + { 0xb32, 0xb33 }, + { 0xb35, 0xb39 }, + { 0xb3c, 0xb44 }, + { 0xb47, 0xb48 }, + { 0xb4b, 0xb4d }, + { 0xb55, 0xb57 }, + { 0xb5c, 0xb5d }, + { 0xb5f, 0xb63 }, + { 0xb66, 0xb6f }, + { 0xb71, 0xb71 }, + { 0xb82, 0xb83 }, + { 0xb85, 0xb8a }, + { 0xb8e, 0xb90 }, + { 0xb92, 0xb95 }, + { 0xb99, 0xb9a }, + { 0xb9c, 0xb9c }, + { 0xb9e, 0xb9f }, + { 0xba3, 0xba4 }, + { 0xba8, 0xbaa }, + { 0xbae, 0xbb9 }, + { 0xbbe, 0xbc2 }, + { 0xbc6, 0xbc8 }, + { 0xbca, 0xbcd }, + { 0xbd0, 0xbd0 }, + { 0xbd7, 0xbd7 }, + { 0xbe6, 0xbef }, + { 0xc00, 0xc0c }, + { 0xc0e, 0xc10 }, + { 0xc12, 0xc28 }, + { 0xc2a, 0xc39 }, + { 0xc3c, 0xc44 }, + { 0xc46, 0xc48 }, + { 0xc4a, 0xc4d }, + { 0xc55, 0xc56 }, + { 0xc58, 0xc5a }, + { 0xc5d, 0xc5d }, + { 0xc60, 0xc63 }, + { 0xc66, 0xc6f }, + { 0xc80, 0xc83 }, + { 0xc85, 0xc8c }, + { 0xc8e, 0xc90 }, + { 0xc92, 0xca8 }, + { 0xcaa, 0xcb3 }, + { 0xcb5, 0xcb9 }, + { 0xcbc, 0xcc4 }, + { 0xcc6, 0xcc8 }, + { 0xcca, 0xccd }, + { 0xcd5, 0xcd6 }, + { 0xcdd, 0xcde }, + { 0xce0, 0xce3 }, + { 0xce6, 0xcef }, + { 0xcf1, 0xcf2 }, + { 0xd00, 0xd0c }, + { 0xd0e, 0xd10 }, + { 0xd12, 0xd44 }, + { 0xd46, 0xd48 }, + { 0xd4a, 0xd4e }, + { 0xd54, 0xd57 }, + { 0xd5f, 0xd63 }, + { 0xd66, 0xd6f }, + { 0xd7a, 0xd7f }, + { 0xd81, 0xd83 }, + { 0xd85, 0xd96 }, + { 0xd9a, 0xdb1 }, + { 0xdb3, 0xdbb }, + { 0xdbd, 0xdbd }, + { 0xdc0, 0xdc6 }, + { 0xdca, 0xdca }, + { 0xdcf, 0xdd4 }, + { 0xdd6, 0xdd6 }, + { 0xdd8, 0xddf }, + { 0xde6, 0xdef }, + { 0xdf2, 0xdf3 }, + { 0xe01, 0xe3a }, + { 0xe40, 0xe4e }, + { 0xe50, 0xe59 }, + { 0xe81, 0xe82 }, + { 0xe84, 0xe84 }, + { 0xe86, 0xe8a }, + { 0xe8c, 0xea3 }, + { 0xea5, 0xea5 }, + { 0xea7, 0xebd }, + { 0xec0, 0xec4 }, + { 0xec6, 0xec6 }, + { 0xec8, 0xecd }, + { 0xed0, 0xed9 }, + { 0xedc, 0xedf }, + { 0xf00, 0xf00 }, + { 0xf18, 0xf19 }, + { 0xf20, 0xf29 }, + { 0xf35, 0xf35 }, + { 0xf37, 0xf37 }, + { 0xf39, 0xf39 }, + { 0xf3e, 0xf47 }, + { 0xf49, 0xf6c }, + { 0xf71, 0xf84 }, + { 0xf86, 0xf97 }, + { 0xf99, 0xfbc }, + { 0xfc6, 0xfc6 }, + { 0x1000, 0x1049 }, + { 0x1050, 0x109d }, + { 0x10a0, 0x10c5 }, + { 0x10c7, 0x10c7 }, + { 0x10cd, 0x10cd }, + { 0x10d0, 0x10fa }, + { 0x10fc, 0x1248 }, + { 0x124a, 0x124d }, + { 0x1250, 0x1256 }, + { 0x1258, 0x1258 }, + { 0x125a, 0x125d }, + { 0x1260, 0x1288 }, + { 0x128a, 0x128d }, + { 0x1290, 0x12b0 }, + { 0x12b2, 0x12b5 }, + { 0x12b8, 0x12be }, + { 0x12c0, 0x12c0 }, + { 0x12c2, 0x12c5 }, + { 0x12c8, 0x12d6 }, + { 0x12d8, 0x1310 }, + { 0x1312, 0x1315 }, + { 0x1318, 0x135a }, + { 0x135d, 0x135f }, + { 0x1369, 0x1369 }, + { 0x1371, 0x1371 }, + { 0x1380, 0x138f }, + { 0x13a0, 0x13f5 }, + { 0x13f8, 0x13fd }, + { 0x1401, 0x166c }, + { 0x166f, 0x167f }, + { 0x1681, 0x169a }, + { 0x16a0, 0x16ea }, + { 0x16ee, 0x16f8 }, + { 0x1700, 0x1715 }, + { 0x171f, 0x1734 }, + { 0x1740, 0x1753 }, + { 0x1760, 0x176c }, + { 0x176e, 0x1770 }, + { 0x1772, 0x1773 }, + { 0x1780, 0x17d3 }, + { 0x17d7, 0x17d7 }, + { 0x17dc, 0x17dd }, + { 0x17e0, 0x17e9 }, + { 0x180b, 0x180d }, + { 0x180f, 0x1819 }, + { 0x1820, 0x1878 }, + { 0x1880, 0x18aa }, + { 0x18b0, 0x18f5 }, + { 0x1900, 0x191e }, + { 0x1920, 0x192b }, + { 0x1930, 0x193b }, + { 0x1946, 0x196d }, + { 0x1970, 0x1974 }, + { 0x1980, 0x19ab }, + { 0x19b0, 0x19c9 }, + { 0x19d0, 0x19da }, + { 0x1a00, 0x1a1b }, + { 0x1a20, 0x1a5e }, + { 0x1a60, 0x1a7c }, + { 0x1a7f, 0x1a89 }, + { 0x1a90, 0x1a99 }, + { 0x1aa7, 0x1aa7 }, + { 0x1ab0, 0x1abd }, + { 0x1abf, 0x1ace }, + { 0x1b00, 0x1b4c }, + { 0x1b50, 0x1b59 }, + { 0x1b6b, 0x1b73 }, + { 0x1b80, 0x1bf3 }, + { 0x1c00, 0x1c37 }, + { 0x1c40, 0x1c49 }, + { 0x1c4d, 0x1c7d }, + { 0x1c80, 0x1c88 }, + { 0x1c90, 0x1cba }, + { 0x1cbd, 0x1cbf }, + { 0x1cd0, 0x1cd2 }, + { 0x1cd4, 0x1cfa }, + { 0x1d00, 0x1f15 }, + { 0x1f18, 0x1f1d }, + { 0x1f20, 0x1f45 }, + { 0x1f48, 0x1f4d }, + { 0x1f50, 0x1f57 }, + { 0x1f59, 0x1f59 }, + { 0x1f5b, 0x1f5b }, + { 0x1f5d, 0x1f5d }, + { 0x1f5f, 0x1f7d }, + { 0x1f80, 0x1fb4 }, + { 0x1fb6, 0x1fbc }, + { 0x1fbe, 0x1fbe }, + { 0x1fc2, 0x1fc4 }, + { 0x1fc6, 0x1fcc }, + { 0x1fd0, 0x1fd3 }, + { 0x1fd6, 0x1fdb }, + { 0x1fe0, 0x1fec }, + { 0x1ff2, 0x1ff4 }, + { 0x1ff6, 0x1ffc }, + { 0x203f, 0x2040 }, + { 0x2054, 0x2054 }, + { 0x2071, 0x2071 }, + { 0x207f, 0x207f }, + { 0x2090, 0x209c }, + { 0x20d0, 0x20dc }, + { 0x20e1, 0x20e1 }, + { 0x20e5, 0x20f0 }, + { 0x2102, 0x2102 }, + { 0x2107, 0x2107 }, + { 0x210a, 0x2113 }, + { 0x2115, 0x2115 }, + { 0x2118, 0x211d }, + { 0x2124, 0x2124 }, + { 0x2126, 0x2126 }, + { 0x2128, 0x2128 }, + { 0x212a, 0x2139 }, + { 0x213c, 0x213f }, + { 0x2145, 0x2149 }, + { 0x214e, 0x214e }, + { 0x2160, 0x2188 }, + { 0x2c00, 0x2ce4 }, + { 0x2ceb, 0x2cf3 }, + { 0x2d00, 0x2d25 }, + { 0x2d27, 0x2d27 }, + { 0x2d2d, 0x2d2d }, + { 0x2d30, 0x2d67 }, + { 0x2d6f, 0x2d6f }, + { 0x2d7f, 0x2d96 }, + { 0x2da0, 0x2da6 }, + { 0x2da8, 0x2dae }, + { 0x2db0, 0x2db6 }, + { 0x2db8, 0x2dbe }, + { 0x2dc0, 0x2dc6 }, + { 0x2dc8, 0x2dce }, + { 0x2dd0, 0x2dd6 }, + { 0x2dd8, 0x2dde }, + { 0x2de0, 0x2dff }, + { 0x3005, 0x3007 }, + { 0x3021, 0x302f }, + { 0x3031, 0x3035 }, + { 0x3038, 0x303c }, + { 0x3041, 0x3096 }, + { 0x3099, 0x309f }, + { 0x30a1, 0x30fa }, + { 0x30fc, 0x30ff }, + { 0x3105, 0x312f }, + { 0x3131, 0x318e }, + { 0x31a0, 0x31bf }, + { 0x31f0, 0x31ff }, + { 0x3400, 0x4dbf }, + { 0x4e00, 0xa48c }, + { 0xa4d0, 0xa4fd }, + { 0xa500, 0xa60c }, + { 0xa610, 0xa62b }, + { 0xa640, 0xa66f }, + { 0xa674, 0xa67d }, + { 0xa67f, 0xa6f1 }, + { 0xa717, 0xa71f }, + { 0xa722, 0xa788 }, + { 0xa78b, 0xa7ca }, + { 0xa7d0, 0xa7d1 }, + { 0xa7d3, 0xa7d3 }, + { 0xa7d5, 0xa7d9 }, + { 0xa7f2, 0xa827 }, + { 0xa82c, 0xa82c }, + { 0xa840, 0xa873 }, + { 0xa880, 0xa8c5 }, + { 0xa8d0, 0xa8d9 }, + { 0xa8e0, 0xa8f7 }, + { 0xa8fb, 0xa8fb }, + { 0xa8fd, 0xa92d }, + { 0xa930, 0xa953 }, + { 0xa960, 0xa97c }, + { 0xa980, 0xa9c0 }, + { 0xa9cf, 0xa9d9 }, + { 0xa9e0, 0xa9fe }, + { 0xaa00, 0xaa36 }, + { 0xaa40, 0xaa4d }, + { 0xaa50, 0xaa59 }, + { 0xaa60, 0xaa76 }, + { 0xaa7a, 0xaac2 }, + { 0xaadb, 0xaadd }, + { 0xaae0, 0xaaef }, + { 0xaaf2, 0xaaf6 }, + { 0xab01, 0xab06 }, + { 0xab09, 0xab0e }, + { 0xab11, 0xab16 }, + { 0xab20, 0xab26 }, + { 0xab28, 0xab2e }, + { 0xab30, 0xab5a }, + { 0xab5c, 0xab69 }, + { 0xab70, 0xabea }, + { 0xabec, 0xabed }, + { 0xabf0, 0xabf9 }, + { 0xac00, 0xd7a3 }, + { 0xd7b0, 0xd7c6 }, + { 0xd7cb, 0xd7fb }, + { 0xf900, 0xfa6d }, + { 0xfa70, 0xfad9 }, + { 0xfb00, 0xfb06 }, + { 0xfb13, 0xfb17 }, + { 0xfb1d, 0xfb28 }, + { 0xfb2a, 0xfb36 }, + { 0xfb38, 0xfb3c }, + { 0xfb3e, 0xfb3e }, + { 0xfb40, 0xfb41 }, + { 0xfb43, 0xfb44 }, + { 0xfb46, 0xfbb1 }, + { 0xfbd3, 0xfd3d }, + { 0xfd50, 0xfd8f }, + { 0xfd92, 0xfdc7 }, + { 0xfdf0, 0xfdfb }, + { 0xfe00, 0xfe0f }, + { 0xfe20, 0xfe2f }, + { 0xfe33, 0xfe34 }, + { 0xfe4d, 0xfe4f }, + { 0xfe70, 0xfe74 }, + { 0xfe76, 0xfefc }, + { 0xff10, 0xff19 }, + { 0xff21, 0xff3a }, + { 0xff3f, 0xff3f }, + { 0xff41, 0xff5a }, + { 0xff66, 0xffbe }, + { 0xffc2, 0xffc7 }, + { 0xffca, 0xffcf }, + { 0xffd2, 0xffd7 }, + { 0xffda, 0xffdc }, + { 0x10000, 0x1000b }, + { 0x1000d, 0x10026 }, + { 0x10028, 0x1003a }, + { 0x1003c, 0x1003d }, + { 0x1003f, 0x1004d }, + { 0x10050, 0x1005d }, + { 0x10080, 0x100fa }, + { 0x10140, 0x10174 }, + { 0x101fd, 0x101fd }, + { 0x10280, 0x1029c }, + { 0x102a0, 0x102d0 }, + { 0x102e0, 0x102e0 }, + { 0x10300, 0x1031f }, + { 0x1032d, 0x1034a }, + { 0x10350, 0x1037a }, + { 0x10380, 0x1039d }, + { 0x103a0, 0x103c3 }, + { 0x103c8, 0x103cf }, + { 0x103d1, 0x103d5 }, + { 0x10400, 0x1049d }, + { 0x104a0, 0x104a9 }, + { 0x104b0, 0x104d3 }, + { 0x104d8, 0x104fb }, + { 0x10500, 0x10527 }, + { 0x10530, 0x10563 }, + { 0x10570, 0x1057a }, + { 0x1057c, 0x1058a }, + { 0x1058c, 0x10592 }, + { 0x10594, 0x10595 }, + { 0x10597, 0x105a1 }, + { 0x105a3, 0x105b1 }, + { 0x105b3, 0x105b9 }, + { 0x105bb, 0x105bc }, + { 0x10600, 0x10736 }, + { 0x10740, 0x10755 }, + { 0x10760, 0x10767 }, + { 0x10780, 0x10785 }, + { 0x10787, 0x107b0 }, + { 0x107b2, 0x107ba }, + { 0x10800, 0x10805 }, + { 0x10808, 0x10808 }, + { 0x1080a, 0x10835 }, + { 0x10837, 0x10838 }, + { 0x1083c, 0x1083c }, + { 0x1083f, 0x10855 }, + { 0x10860, 0x10876 }, + { 0x10880, 0x1089e }, + { 0x108e0, 0x108f2 }, + { 0x108f4, 0x108f5 }, + { 0x10900, 0x10915 }, + { 0x10920, 0x10939 }, + { 0x10980, 0x109b7 }, + { 0x109be, 0x109bf }, + { 0x10a00, 0x10a03 }, + { 0x10a05, 0x10a06 }, + { 0x10a0c, 0x10a13 }, + { 0x10a15, 0x10a17 }, + { 0x10a19, 0x10a35 }, + { 0x10a38, 0x10a3a }, + { 0x10a3f, 0x10a3f }, + { 0x10a60, 0x10a7c }, + { 0x10a80, 0x10a9c }, + { 0x10ac0, 0x10ac7 }, + { 0x10ac9, 0x10ae6 }, + { 0x10b00, 0x10b35 }, + { 0x10b40, 0x10b55 }, + { 0x10b60, 0x10b72 }, + { 0x10b80, 0x10b91 }, + { 0x10c00, 0x10c48 }, + { 0x10c80, 0x10cb2 }, + { 0x10cc0, 0x10cf2 }, + { 0x10d00, 0x10d27 }, + { 0x10d30, 0x10d39 }, + { 0x10e80, 0x10ea9 }, + { 0x10eab, 0x10eac }, + { 0x10eb0, 0x10eb1 }, + { 0x10f00, 0x10f1c }, + { 0x10f27, 0x10f27 }, + { 0x10f30, 0x10f50 }, + { 0x10f70, 0x10f85 }, + { 0x10fb0, 0x10fc4 }, + { 0x10fe0, 0x10ff6 }, + { 0x11000, 0x11046 }, + { 0x11066, 0x11075 }, + { 0x1107f, 0x110ba }, + { 0x110c2, 0x110c2 }, + { 0x110d0, 0x110e8 }, + { 0x110f0, 0x110f9 }, + { 0x11100, 0x11134 }, + { 0x11136, 0x1113f }, + { 0x11144, 0x11147 }, + { 0x11150, 0x11173 }, + { 0x11176, 0x11176 }, + { 0x11180, 0x111c4 }, + { 0x111c9, 0x111cc }, + { 0x111ce, 0x111da }, + { 0x111dc, 0x111dc }, + { 0x11200, 0x11211 }, + { 0x11213, 0x11237 }, + { 0x1123e, 0x1123e }, + { 0x11280, 0x11286 }, + { 0x11288, 0x11288 }, + { 0x1128a, 0x1128d }, + { 0x1128f, 0x1129d }, + { 0x1129f, 0x112a8 }, + { 0x112b0, 0x112ea }, + { 0x112f0, 0x112f9 }, + { 0x11300, 0x11303 }, + { 0x11305, 0x1130c }, + { 0x1130f, 0x11310 }, + { 0x11313, 0x11328 }, + { 0x1132a, 0x11330 }, + { 0x11332, 0x11333 }, + { 0x11335, 0x11339 }, + { 0x1133b, 0x11344 }, + { 0x11347, 0x11348 }, + { 0x1134b, 0x1134d }, + { 0x11350, 0x11350 }, + { 0x11357, 0x11357 }, + { 0x1135d, 0x11363 }, + { 0x11366, 0x1136c }, + { 0x11370, 0x11374 }, + { 0x11400, 0x1144a }, + { 0x11450, 0x11459 }, + { 0x1145e, 0x11461 }, + { 0x11480, 0x114c5 }, + { 0x114c7, 0x114c7 }, + { 0x114d0, 0x114d9 }, + { 0x11580, 0x115b5 }, + { 0x115b8, 0x115c0 }, + { 0x115d8, 0x115dd }, + { 0x11600, 0x11640 }, + { 0x11644, 0x11644 }, + { 0x11650, 0x11659 }, + { 0x11680, 0x116b8 }, + { 0x116c0, 0x116c9 }, + { 0x11700, 0x1171a }, + { 0x1171d, 0x1172b }, + { 0x11730, 0x11739 }, + { 0x11740, 0x11746 }, + { 0x11800, 0x1183a }, + { 0x118a0, 0x118e9 }, + { 0x118ff, 0x11906 }, + { 0x11909, 0x11909 }, + { 0x1190c, 0x11913 }, + { 0x11915, 0x11916 }, + { 0x11918, 0x11935 }, + { 0x11937, 0x11938 }, + { 0x1193b, 0x11943 }, + { 0x11950, 0x11959 }, + { 0x119a0, 0x119a7 }, + { 0x119aa, 0x119d7 }, + { 0x119da, 0x119e1 }, + { 0x119e3, 0x119e4 }, + { 0x11a00, 0x11a3e }, + { 0x11a47, 0x11a47 }, + { 0x11a50, 0x11a99 }, + { 0x11a9d, 0x11a9d }, + { 0x11ab0, 0x11af8 }, + { 0x11c00, 0x11c08 }, + { 0x11c0a, 0x11c36 }, + { 0x11c38, 0x11c40 }, + { 0x11c50, 0x11c59 }, + { 0x11c72, 0x11c8f }, + { 0x11c92, 0x11ca7 }, + { 0x11ca9, 0x11cb6 }, + { 0x11d00, 0x11d06 }, + { 0x11d08, 0x11d09 }, + { 0x11d0b, 0x11d36 }, + { 0x11d3a, 0x11d3a }, + { 0x11d3c, 0x11d3d }, + { 0x11d3f, 0x11d47 }, + { 0x11d50, 0x11d59 }, + { 0x11d60, 0x11d65 }, + { 0x11d67, 0x11d68 }, + { 0x11d6a, 0x11d8e }, + { 0x11d90, 0x11d91 }, + { 0x11d93, 0x11d98 }, + { 0x11da0, 0x11da9 }, + { 0x11ee0, 0x11ef6 }, + { 0x11fb0, 0x11fb0 }, + { 0x12000, 0x12399 }, + { 0x12400, 0x1246e }, + { 0x12480, 0x12543 }, + { 0x12f90, 0x12ff0 }, + { 0x13000, 0x1342e }, + { 0x14400, 0x14646 }, + { 0x16800, 0x16a38 }, + { 0x16a40, 0x16a5e }, + { 0x16a60, 0x16a69 }, + { 0x16a70, 0x16abe }, + { 0x16ac0, 0x16ac9 }, + { 0x16ad0, 0x16aed }, + { 0x16af0, 0x16af4 }, + { 0x16b00, 0x16b36 }, + { 0x16b40, 0x16b43 }, + { 0x16b50, 0x16b59 }, + { 0x16b63, 0x16b77 }, + { 0x16b7d, 0x16b8f }, + { 0x16e40, 0x16e7f }, + { 0x16f00, 0x16f4a }, + { 0x16f4f, 0x16f87 }, + { 0x16f8f, 0x16f9f }, + { 0x16fe0, 0x16fe1 }, + { 0x16fe3, 0x16fe4 }, + { 0x16ff0, 0x16ff1 }, + { 0x17000, 0x187f7 }, + { 0x18800, 0x18cd5 }, + { 0x18d00, 0x18d08 }, + { 0x1aff0, 0x1aff3 }, + { 0x1aff5, 0x1affb }, + { 0x1affd, 0x1affe }, + { 0x1b000, 0x1b122 }, + { 0x1b150, 0x1b152 }, + { 0x1b164, 0x1b167 }, + { 0x1b170, 0x1b2fb }, + { 0x1bc00, 0x1bc6a }, + { 0x1bc70, 0x1bc7c }, + { 0x1bc80, 0x1bc88 }, + { 0x1bc90, 0x1bc99 }, + { 0x1bc9d, 0x1bc9e }, + { 0x1cf00, 0x1cf2d }, + { 0x1cf30, 0x1cf46 }, + { 0x1d165, 0x1d169 }, + { 0x1d16d, 0x1d172 }, + { 0x1d17b, 0x1d182 }, + { 0x1d185, 0x1d18b }, + { 0x1d1aa, 0x1d1ad }, + { 0x1d242, 0x1d244 }, + { 0x1d400, 0x1d454 }, + { 0x1d456, 0x1d49c }, + { 0x1d49e, 0x1d49f }, + { 0x1d4a2, 0x1d4a2 }, + { 0x1d4a5, 0x1d4a6 }, + { 0x1d4a9, 0x1d4ac }, + { 0x1d4ae, 0x1d4b9 }, + { 0x1d4bb, 0x1d4bb }, + { 0x1d4bd, 0x1d4c3 }, + { 0x1d4c5, 0x1d505 }, + { 0x1d507, 0x1d50a }, + { 0x1d50d, 0x1d514 }, + { 0x1d516, 0x1d51c }, + { 0x1d51e, 0x1d539 }, + { 0x1d53b, 0x1d53e }, + { 0x1d540, 0x1d544 }, + { 0x1d546, 0x1d546 }, + { 0x1d54a, 0x1d550 }, + { 0x1d552, 0x1d6a5 }, + { 0x1d6a8, 0x1d6c0 }, + { 0x1d6c2, 0x1d6da }, + { 0x1d6dc, 0x1d6fa }, + { 0x1d6fc, 0x1d714 }, + { 0x1d716, 0x1d734 }, + { 0x1d736, 0x1d74e }, + { 0x1d750, 0x1d76e }, + { 0x1d770, 0x1d788 }, + { 0x1d78a, 0x1d7a8 }, + { 0x1d7aa, 0x1d7c2 }, + { 0x1d7c4, 0x1d7cb }, + { 0x1d7ce, 0x1d7ff }, + { 0x1da00, 0x1da36 }, + { 0x1da3b, 0x1da6c }, + { 0x1da75, 0x1da75 }, + { 0x1da84, 0x1da84 }, + { 0x1da9b, 0x1da9f }, + { 0x1daa1, 0x1daaf }, + { 0x1df00, 0x1df1e }, + { 0x1e000, 0x1e006 }, + { 0x1e008, 0x1e018 }, + { 0x1e01b, 0x1e021 }, + { 0x1e023, 0x1e024 }, + { 0x1e026, 0x1e02a }, + { 0x1e100, 0x1e12c }, + { 0x1e130, 0x1e13d }, + { 0x1e140, 0x1e149 }, + { 0x1e14e, 0x1e14e }, + { 0x1e290, 0x1e2ae }, + { 0x1e2c0, 0x1e2f9 }, + { 0x1e7e0, 0x1e7e6 }, + { 0x1e7e8, 0x1e7eb }, + { 0x1e7ed, 0x1e7ee }, + { 0x1e7f0, 0x1e7fe }, + { 0x1e800, 0x1e8c4 }, + { 0x1e8d0, 0x1e8d6 }, + { 0x1e900, 0x1e94b }, + { 0x1e950, 0x1e959 }, + { 0x1ee00, 0x1ee03 }, + { 0x1ee05, 0x1ee1f }, + { 0x1ee21, 0x1ee22 }, + { 0x1ee24, 0x1ee24 }, + { 0x1ee27, 0x1ee27 }, + { 0x1ee29, 0x1ee32 }, + { 0x1ee34, 0x1ee37 }, + { 0x1ee39, 0x1ee39 }, + { 0x1ee3b, 0x1ee3b }, + { 0x1ee42, 0x1ee42 }, + { 0x1ee47, 0x1ee47 }, + { 0x1ee49, 0x1ee49 }, + { 0x1ee4b, 0x1ee4b }, + { 0x1ee4d, 0x1ee4f }, + { 0x1ee51, 0x1ee52 }, + { 0x1ee54, 0x1ee54 }, + { 0x1ee57, 0x1ee57 }, + { 0x1ee59, 0x1ee59 }, + { 0x1ee5b, 0x1ee5b }, + { 0x1ee5d, 0x1ee5d }, + { 0x1ee5f, 0x1ee5f }, + { 0x1ee61, 0x1ee62 }, + { 0x1ee64, 0x1ee64 }, + { 0x1ee67, 0x1ee6a }, + { 0x1ee6c, 0x1ee72 }, + { 0x1ee74, 0x1ee77 }, + { 0x1ee79, 0x1ee7c }, + { 0x1ee7e, 0x1ee7e }, + { 0x1ee80, 0x1ee89 }, + { 0x1ee8b, 0x1ee9b }, + { 0x1eea1, 0x1eea3 }, + { 0x1eea5, 0x1eea9 }, + { 0x1eeab, 0x1eebb }, + { 0x1fbf0, 0x1fbf9 }, + { 0x20000, 0x2a6df }, + { 0x2a700, 0x2b738 }, + { 0x2b740, 0x2b81d }, + { 0x2b820, 0x2cea1 }, + { 0x2ceb0, 0x2ebe0 }, + { 0x2f800, 0x2fa1d }, + { 0x30000, 0x3134a }, + { 0xe0100, 0xe01ef }, + { 0x0, 0x0 }, +}; + +#line 0 + +#line 1 "sfwl/core/char_utils.h" +/*************************************************************************/ +/* char_utils.h */ +/* From https://github.com/Relintai/pandemonium_engine (MIT) */ +/*************************************************************************/ + +static _FORCE_INLINE_ bool is_unicode_identifier_start(char32_t c) { + for (int i = 0; xid_start[i].start != 0; i++) { + if (c >= xid_start[i].start && c <= xid_start[i].end) { + return true; + } + } + return false; +} + +static _FORCE_INLINE_ bool is_unicode_identifier_continue(char32_t c) { + for (int i = 0; xid_continue[i].start != 0; i++) { + if (c >= xid_continue[i].start && c <= xid_continue[i].end) { + return true; + } + } + return false; +} + +static _FORCE_INLINE_ bool is_ascii_upper_case(char32_t c) { + return (c >= 'A' && c <= 'Z'); +} + +static _FORCE_INLINE_ bool is_ascii_lower_case(char32_t c) { + return (c >= 'a' && c <= 'z'); +} + +static _FORCE_INLINE_ bool is_digit(char32_t c) { + return (c >= '0' && c <= '9'); +} + +static _FORCE_INLINE_ bool is_hex_digit(char32_t c) { + return (is_digit(c) || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F')); +} + +static _FORCE_INLINE_ bool is_binary_digit(char32_t c) { + return (c == '0' || c == '1'); +} + +static _FORCE_INLINE_ bool is_ascii_char(char32_t c) { + return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'); +} + +static _FORCE_INLINE_ bool is_ascii_alphanumeric_char(char32_t c) { + return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9'); +} + +static _FORCE_INLINE_ bool is_ascii_identifier_char(char32_t c) { + return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9') || c == '_'; +} + +static _FORCE_INLINE_ bool is_symbol(char32_t c) { + return c != '_' && ((c >= '!' && c <= '/') || (c >= ':' && c <= '@') || (c >= '[' && c <= '`') || (c >= '{' && c <= '~') || c == '\t' || c == ' '); +} + +static _FORCE_INLINE_ bool is_control(char32_t p_char) { + return (p_char <= 0x001f) || (p_char >= 0x007f && p_char <= 0x009f); +} + +static _FORCE_INLINE_ bool is_whitespace(char32_t p_char) { + return (p_char == ' ') || (p_char == 0x00a0) || (p_char == 0x1680) || (p_char >= 0x2000 && p_char <= 0x200a) || (p_char == 0x202f) || (p_char == 0x205f) || (p_char == 0x3000) || (p_char == 0x2028) || (p_char == 0x2029) || (p_char >= 0x0009 && p_char <= 0x000d) || (p_char == 0x0085); +} + +static _FORCE_INLINE_ bool is_linebreak(char32_t p_char) { + return (p_char >= 0x000a && p_char <= 0x000d) || (p_char == 0x0085) || (p_char == 0x2028) || (p_char == 0x2029); +} + +static _FORCE_INLINE_ bool is_punct(char32_t p_char) { + return (p_char >= ' ' && p_char <= '/') || (p_char >= ':' && p_char <= '@') || (p_char >= '[' && p_char <= '^') || (p_char == '`') || (p_char >= '{' && p_char <= '~') || (p_char >= 0x2000 && p_char <= 0x206f) || (p_char >= 0x3000 && p_char <= 0x303f); +} + +static _FORCE_INLINE_ bool is_underscore(char32_t p_char) { + return (p_char == '_'); +} + +#line 0 + +#line 1 "sfwl/core/ustring.h" + +/*************************************************************************/ +/* ustring.h */ +/* From https://github.com/Relintai/pandemonium_engine (MIT) */ +/*************************************************************************/ + +/*************************************************************************/ +/* CharProxy */ +/*************************************************************************/ + +template +class CharProxy { + friend class Char16String; + friend class CharString; + friend class String; + + const int _index; + CowData &_cowdata; + static const T _null = 0; + + _FORCE_INLINE_ CharProxy(const int &p_index, CowData &p_cowdata) : + _index(p_index), + _cowdata(p_cowdata) {} + +public: + _FORCE_INLINE_ CharProxy(const CharProxy &p_other) : + _index(p_other._index), + _cowdata(p_other._cowdata) {} + + _FORCE_INLINE_ operator T() const { + if (unlikely(_cowdata.size() == 0)) { + return _null; + } + + return _cowdata.get(_index); + } + + _FORCE_INLINE_ const T *operator&() const { + return _cowdata.ptr() + _index; + } + + _FORCE_INLINE_ void operator=(const T &p_other) const { + _cowdata.set(_index, p_other); + } + + _FORCE_INLINE_ void operator=(const CharProxy &p_other) const { + _cowdata.set(_index, p_other.operator T()); + } +}; + +/*************************************************************************/ +/* Char16String */ +/*************************************************************************/ + +class Char16String { + CowData _cowdata; + static const char16_t _null; + +public: + _FORCE_INLINE_ char16_t *ptrw() { return _cowdata.ptrw(); } + _FORCE_INLINE_ const char16_t *ptr() const { return _cowdata.ptr(); } + _FORCE_INLINE_ int size() const { return _cowdata.size(); } + Error resize(int p_size) { + Error err = _cowdata.resize(p_size); + + //Ensure null terminator + if (err == OK && _cowdata.size() > 0) { + _cowdata.set(_cowdata.size() - 1, '\0'); + } + + return err; + } + + _FORCE_INLINE_ char16_t get(int p_index) const { return _cowdata.get(p_index); } + _FORCE_INLINE_ void set(int p_index, const char16_t &p_elem) { _cowdata.set(p_index, p_elem); } + _FORCE_INLINE_ const char16_t &operator[](int p_index) const { + if (unlikely(_cowdata.size() == 0)) { + return _null; + } + + return _cowdata.get(p_index); + } + _FORCE_INLINE_ CharProxy operator[](int p_index) { return CharProxy(p_index, _cowdata); } + + _FORCE_INLINE_ Char16String() {} + _FORCE_INLINE_ Char16String(const Char16String &p_str) { _cowdata._ref(p_str._cowdata); } + _FORCE_INLINE_ void operator=(const Char16String &p_str) { _cowdata._ref(p_str._cowdata); } + _FORCE_INLINE_ Char16String(const char16_t *p_cstr) { copy_from(p_cstr); } + + void operator=(const char16_t *p_cstr); + bool operator<(const Char16String &p_right) const; + Char16String &operator+=(char16_t p_char); + int length() const { return size() ? size() - 1 : 0; } + const char16_t *get_data() const; + operator const char16_t *() const { return get_data(); }; + +protected: + void copy_from(const char16_t *p_cstr); +}; + +/*************************************************************************/ +/* CharString */ +/*************************************************************************/ + +class CharString { + CowData _cowdata; + static const char _null; + +public: + _FORCE_INLINE_ char *ptrw() { return _cowdata.ptrw(); } + _FORCE_INLINE_ const char *ptr() const { return _cowdata.ptr(); } + _FORCE_INLINE_ int size() const { return _cowdata.size(); } + Error resize(int p_size) { + Error err = _cowdata.resize(p_size); + + //Ensure null terminator + if (err == OK && _cowdata.size() > 0) { + _cowdata.set(_cowdata.size() - 1, '\0'); + } + + return err; + } + + _FORCE_INLINE_ char get(int p_index) const { return _cowdata.get(p_index); } + _FORCE_INLINE_ void set(int p_index, const char &p_elem) { _cowdata.set(p_index, p_elem); } + _FORCE_INLINE_ const char &operator[](int p_index) const { + if (unlikely(_cowdata.size() == 0)) { + return _null; + } + + return _cowdata.get(p_index); + } + _FORCE_INLINE_ CharProxy operator[](int p_index) { return CharProxy(p_index, _cowdata); } + + _FORCE_INLINE_ CharString() {} + _FORCE_INLINE_ CharString(const CharString &p_str) { _cowdata._ref(p_str._cowdata); } + _FORCE_INLINE_ void operator=(const CharString &p_str) { _cowdata._ref(p_str._cowdata); } + _FORCE_INLINE_ CharString(const char *p_cstr) { copy_from(p_cstr); } + + void operator=(const char *p_cstr); + bool operator<(const CharString &p_right) const; + CharString &operator+=(char p_char); + int length() const { return size() ? size() - 1 : 0; } + const char *get_data() const; + operator const char *() const { return get_data(); }; + +protected: + void copy_from(const char *p_cstr); +}; + +/*************************************************************************/ +/* String */ +/*************************************************************************/ + +typedef char32_t CharType; + +struct StrRange { + const CharType *c_str; + int len; + + StrRange(const CharType *p_c_str = nullptr, int p_len = 0) { + c_str = p_c_str; + len = p_len; + } +}; + +class String { +public: + enum { + npos = -1 /// 0) { + _cowdata.set(_cowdata.size() - 1, '\0'); + } + } + + _FORCE_INLINE_ void clear() { resize(0); } + + _FORCE_INLINE_ CharType get(int p_index) const { return _cowdata.get(p_index); } + _FORCE_INLINE_ void set(int p_index, const CharType &p_elem) { _cowdata.set(p_index, p_elem); } + _FORCE_INLINE_ int size() const { return _cowdata.size(); } + _FORCE_INLINE_ Error resize(int p_size) { + Error err = _cowdata.resize(p_size); + + //Ensure null terminator + if (err == OK && _cowdata.size() > 0) { + _cowdata.set(_cowdata.size() - 1, '\0'); + } + + return err; + } + _FORCE_INLINE_ Error set_length(int p_length) { return resize(p_length + 1); } + + _FORCE_INLINE_ const CharType &operator[](int p_index) const { + return _cowdata.get(p_index); + } + _FORCE_INLINE_ CharProxy operator[](int p_index) { return CharProxy(p_index, _cowdata); } + + bool operator==(const String &p_str) const; + bool operator!=(const String &p_str) const; + String operator+(const String &p_str) const; + //String operator+(CharType p_char) const; + + String &operator+=(const String &); + String &operator+=(CharType p_char); + String &operator+=(const char *p_str); + String &operator+=(const wchar_t *p_str); + String &operator+=(const CharType *p_str); + + /* Compatibility Operators */ + + void operator=(const char *p_str); + void operator=(const wchar_t *p_str); + void operator=(const CharType *p_str); + + bool operator==(const char *p_str) const; + bool operator==(const wchar_t *p_str) const; + bool operator==(const CharType *p_str) const; + bool operator==(const StrRange &p_str_range) const; + + bool operator!=(const char *p_str) const; + bool operator!=(const wchar_t *p_str) const; + bool operator!=(const CharType *p_str) const; + + bool operator<(const CharType *p_str) const; + bool operator<(const char *p_str) const; + bool operator<(const wchar_t *p_str) const; + + bool operator<(const String &p_str) const; + bool operator<=(const String &p_str) const; + bool operator>(const String &p_str) const; + bool operator>=(const String &p_str) const; + + signed char casecmp_to(const String &p_str) const; + signed char nocasecmp_to(const String &p_str) const; + signed char naturalnocasecmp_to(const String &p_str) const; + + const CharType *get_data() const; + + /* standard size stuff */ + + _FORCE_INLINE_ int length() const { + int s = size(); + return s ? (s - 1) : 0; // length does not include zero + } + + bool is_valid_string() const; + + /* debug, error messages */ + void print_unicode_error(const String &p_message, bool p_critical = false) const; + + /* complex helpers */ + String substr(int p_from, int p_chars = -1) const; + String substr_index(const int p_start_index, const int p_end_index) const; //end_index is not included + + int find(const String &p_str, int p_from = 0) const; ///< return <0 if failed + int find(const char *p_str, int p_from = 0) const; ///< return <0 if failed + int find_char(const CharType &p_char, int p_from = 0) const; ///< return <0 if failed + int find_last(const String &p_str) const; ///< return <0 if failed + int findn(const String &p_str, int p_from = 0) const; ///< return <0 if failed, case insensitive + int rfind(const String &p_str, int p_from = -1) const; ///< return <0 if failed + int rfindn(const String &p_str, int p_from = -1) const; ///< return <0 if failed, case insensitive + int findmk(const Vector &p_keys, int p_from = 0, int *r_key = nullptr) const; ///< return <0 if failed + int find_first_difference_index(const String &p_str) const; + + bool is_word_at(const int p_index, const char *p_str) const; + bool is_word_at(const int p_index, const String &p_str) const; + + bool match(const String &p_wildcard) const; + bool matchn(const String &p_wildcard) const; + + bool begins_with(const String &p_string) const; + bool begins_with(const char *p_string) const; + bool ends_with(const String &p_string) const; + + bool is_enclosed_in(const String &p_string) const; + bool is_subsequence_of(const String &p_string) const; + bool is_subsequence_ofi(const String &p_string) const; + bool is_quoted() const; + + Vector bigrams() const; + float similarity(const String &p_string) const; + //String format(const Variant &values, String placeholder = "{_}") const; + + String replace_first(const String &p_key, const String &p_with) const; + String replace(const String &p_key, const String &p_with) const; + String replace(const char *p_key, const char *p_with) const; + String replacen(const String &p_key, const String &p_with) const; + + String newline_to_br() const; + + String repeat(int p_count) const; + String insert(int p_at_pos, const String &p_string) const; + + String pad_decimals(int p_digits) const; + String pad_zeros(int p_digits) const; + + String trim_prefix(const String &p_prefix) const; + String trim_suffix(const String &p_suffix) const; + + String lpad(int min_length, const String &character = " ") const; + String rpad(int min_length, const String &character = " ") const; + + //Moved this to Array to simplify the library's design + //String sprintf(const Array &values, bool *error) const; + + String quote(String quotechar = "\"") const; + String unquote() const; + + static String num(double p_num, int p_decimals = -1); + static String num_scientific(double p_num); + static String num_real(double p_num); + static String num_int64(int64_t p_num, int base = 10, bool capitalize_hex = false); + static String num_uint64(uint64_t p_num, int base = 10, bool capitalize_hex = false); + + static String chr(CharType p_char); + + static String md5(const uint8_t *p_md5); + + static String hex_encode_buffer(const uint8_t *p_buffer, int p_len); + + static String bool_num(bool p_val); + static String bool_str(bool p_val); + + bool is_numeric() const; + bool is_zero() const; + + double to_double() const; + float to_float() const; + int to_int() const; + bool to_bool() const; + uint32_t to_uint() const; + + int hex_to_int(bool p_with_prefix = true) const; + int64_t hex_to_int64(bool p_with_prefix = true) const; + int64_t bin_to_int64(bool p_with_prefix = true) const; + int64_t to_int64() const; + + static int64_t to_int(const char *p_str, int p_len = -1); + static int64_t to_int(const wchar_t *p_str, int p_len = -1); + static int64_t to_int(const CharType *p_str, int p_len = -1, bool p_clamp = false); + + static double to_float(const char *p_str); + static double to_float(const wchar_t *p_str, const wchar_t **r_end = nullptr); + static double to_float(const CharType *p_str, const CharType **r_end = nullptr); + + static double to_double(const char *p_str); + static double to_double(const wchar_t *p_str, const wchar_t **r_end = nullptr); + static double to_double(const CharType *p_str, const CharType **r_end = nullptr); + + static uint32_t num_characters(int64_t p_int); + + String capitalize() const; + String camelcase_to_underscore(bool lowercase = true) const; + + int get_slice_count(String p_splitter) const; + String get_slice(String p_splitter, int p_slice) const; + String get_slicec(CharType p_splitter, int p_slice) const; + + Vector split(const String &p_splitter, bool p_allow_empty = true, int p_maxsplit = 0) const; + Vector rsplit(const String &p_splitter, bool p_allow_empty = true, int p_maxsplit = 0) const; + Vector split_spaces() const; + Vector split_floats(const String &p_splitter, bool p_allow_empty = true) const; + Vector split_floats_mk(const Vector &p_splitters, bool p_allow_empty = true) const; + Vector split_ints(const String &p_splitter, bool p_allow_empty = true) const; + Vector split_ints_mk(const Vector &p_splitters, bool p_allow_empty = true) const; + + String join(const Vector &parts) const; + + static CharType char_uppercase(CharType p_char); + static CharType char_lowercase(CharType p_char); + String to_upper() const; + String to_lower() const; + + int count(const String &p_string, int p_from = 0, int p_to = 0) const; + int countn(const String &p_string, int p_from = 0, int p_to = 0) const; + + String left(int p_pos) const; + String right(int p_pos) const; + String indent(const String &p_prefix) const; + String dedent() const; + + String strip_edges(bool left = true, bool right = true) const; + String strip_escapes() const; + String lstrip(const String &p_chars) const; + String rstrip(const String &p_chars) const; + + String get_extension() const; + String get_basename() const; + String plus_file(const String &p_file) const; + + CharType unicode_at(int p_idx) const; + CharType ord_at(int p_idx) const; + + void erase(int p_pos, int p_chars); + + CharString ascii(bool p_allow_extended = false) const; + CharString utf8() const; + Error parse_utf8(const char *p_utf8, int p_len = -1, bool p_skip_cr = false); //return true on error + static String utf8(const char *p_utf8, int p_len = -1); + int utf8_byte_length() const; + + Char16String utf16() const; + Error parse_utf16(const char16_t *p_utf16, int p_len = -1); + static String utf16(const char16_t *p_utf16, int p_len = -1); + int utf16_byte_length() const; + + static uint32_t hash(const char *p_cstr); /* hash the string */ + static uint32_t hash(const char *p_cstr, int p_len); /* hash the string */ + static uint32_t hash(const wchar_t *p_cstr); /* hash the string */ + static uint32_t hash(const wchar_t *p_cstr, int p_len); /* hash the string */ + static uint32_t hash(const CharType *p_cstr); /* hash the string */ + static uint32_t hash(const CharType *p_cstr, int p_len); /* hash the string */ + + uint32_t hash() const; /* hash the string */ + uint64_t hash64() const; /* hash the string */ + + _FORCE_INLINE_ bool empty() const { return length() == 0; } + _FORCE_INLINE_ bool contains(const char *p_str) const { return find(p_str) != -1; } + _FORCE_INLINE_ bool contains(const String &p_str) const { return find(p_str) != -1; } + + // path functions + bool is_abs_path() const; + bool is_rel_path() const; + bool is_resource_file() const; + String path_to(const String &p_path) const; + String path_to_file(const String &p_path) const; + String get_base_dir() const; + String get_file() const; + static String humanize_size(uint64_t p_size); + String simplify_path() const; + bool is_network_share_path() const; + String append_path(const char *p_path) const; + String append_path(const String &p_path) const; + String path_clean_end_slash() const; + String path_ensure_end_slash() const; + String path_get_prev_dir() const; + + String xml_escape(bool p_escape_quotes = false) const; + String xml_unescape() const; + String http_escape() const; + String http_unescape() const; + String uri_encode() const; + String uri_decode() const; + String c_escape() const; + String c_escape_multiline() const; + String c_unescape() const; + String json_escape() const; + String word_wrap(int p_chars_per_line) const; + Error parse_url(String &r_scheme, String &r_host, int &r_port, String &r_path) const; + + String percent_encode() const; + String percent_decode() const; + + String property_name_encode() const; + + // node functions + static String get_invalid_node_name_characters(); + String validate_node_name() const; + String validate_identifier() const; + + bool is_valid_identifier() const; + bool is_valid_integer() const; + bool is_valid_float() const; + bool is_valid_hex_number(bool p_with_prefix) const; + bool is_valid_html_color() const; + bool is_valid_ip_address() const; + bool is_valid_filename() const; + bool is_valid_bool() const; + bool is_valid_unsigned_integer() const; + + /** + * The constructors must not depend on other overloads + */ + + /* String(CharType p_char);*/ + _FORCE_INLINE_ String() {} + _FORCE_INLINE_ String(const String &p_str) { _cowdata._ref(p_str._cowdata); } + + void operator=(const String &p_str) { + _cowdata._ref(p_str._cowdata); + } + + Vector to_ascii_buffer() const; + Vector to_utf8_buffer() const; + Vector to_utf16_buffer() const; + Vector to_utf32_buffer() const; + + String(const char *p_str); + String(const wchar_t *p_str); + String(const CharType *p_str); + String(const char *p_str, int p_clip_to_len); + String(const wchar_t *p_str, int p_clip_to_len); + String(const CharType *p_str, int p_clip_to_len); + String(const StrRange &p_range); + +private: + CowData _cowdata; + static const CharType _null; + + void copy_from(const char *p_cstr); + void copy_from(const char *p_cstr, const int p_clip_to); + void copy_from(const wchar_t *p_cstr); + void copy_from(const wchar_t *p_cstr, const int p_clip_to); + void copy_from(const CharType *p_cstr); + void copy_from(const CharType *p_cstr, const int p_clip_to); + + void copy_from(const CharType &p_char); + + void copy_from_unchecked(const CharType *p_char, const int p_length); + + bool _base_is_subsequence_of(const String &p_string, bool case_insensitive) const; + int _count(const String &p_string, int p_from, int p_to, bool p_case_insensitive) const; +}; + +bool operator==(const char *p_chr, const String &p_str); +bool operator==(const wchar_t *p_chr, const String &p_str); +bool operator!=(const char *p_chr, const String &p_str); +bool operator!=(const wchar_t *p_chr, const String &p_str); + +String operator+(const char *p_chr, const String &p_str); +String operator+(const wchar_t *p_chr, const String &p_str); +String operator+(CharType p_chr, const String &p_str); + +String itos(int64_t p_val); +String uitos(uint64_t p_val); +String rtos(double p_val); +String rtoss(double p_val); //scientific version + +struct NoCaseComparator { + bool operator()(const String &p_a, const String &p_b) const { + return p_a.nocasecmp_to(p_b) < 0; + } +}; + +struct NaturalNoCaseComparator { + bool operator()(const String &p_a, const String &p_b) const { + return p_a.naturalnocasecmp_to(p_b) < 0; + } +}; + +template +_FORCE_INLINE_ bool is_str_less(const L *l_ptr, const R *r_ptr) { + while (true) { + const CharType l = *l_ptr; + const CharType r = *r_ptr; + + if (l == 0 && r == 0) { + return false; + } else if (l == 0) { + return true; + } else if (r == 0) { + return false; + } else if (l < r) { + return true; + } else if (l > r) { + return false; + } + + l_ptr++; + r_ptr++; + } +} + +/* end of namespace */ + +// Tool translate (TTR and variants) for the editor UI, +// and doc translate for the class reference (DTR). +#ifdef TOOLS_ENABLED +// Gets parsed. +String TTR(const String &p_text, const String &p_context = ""); +String DTR(const String &); +// Use for C strings. +#define TTRC(m_value) (m_value) +// Use to avoid parsing (for use later with C strings). +#define TTRGET(m_value) TTR(m_value) + +#else +#define TTR(m_value) (String()) +#define DTR(m_value) (String()) +#define TTRC(m_value) (m_value) +#define TTRGET(m_value) (m_value) +#endif + +// Runtime translate for the public node API. +String RTR(const String &); + +bool select_word(const String &p_s, int p_col, int &r_beg, int &r_end); + +#line 0 + +#line 1 "sfwl/core/string_name.h" + +/*************************************************************************/ +/* string_name.h */ +/* From https://github.com/Relintai/pandemonium_engine (MIT) */ +/*************************************************************************/ + +struct StaticCString { + const char *ptr; + static StaticCString create(const char *p_ptr); +}; + +class StringName { + enum { + STRING_TABLE_BITS = 14, + STRING_TABLE_LEN = 1 << STRING_TABLE_BITS, + STRING_TABLE_MASK = STRING_TABLE_LEN - 1 + }; + + struct _Data { + SafeRefCount refcount; + SafeNumeric static_count; + const char *cname; + String name; + +#ifdef DEBUG_ENABLED + uint32_t debug_references; +#endif + + String get_name() const { + return cname ? String(cname) : name; + } + + int idx; + uint32_t hash; + _Data *prev; + _Data *next; + + _Data() { +#ifdef DEBUG_ENABLED + debug_references = 0; +#endif + cname = nullptr; + prev = nullptr; + next = nullptr; + idx = 0; + hash = 0; + } + }; + + static _Data *_table[STRING_TABLE_LEN]; + + _Data *_data; + + union _HashUnion { + _Data *ptr; + uint32_t hash; + + _HashUnion() { + ptr = nullptr; + } + }; + + void unref(); + friend void register_core_types(); + friend void unregister_core_types(); + + static Mutex lock; + static bool configured; +#ifdef DEBUG_ENABLED + struct DebugSortReferences { + bool operator()(const _Data *p_left, const _Data *p_right) const { + return p_left->debug_references > p_right->debug_references; + } + }; + + static bool debug_stringname; +#endif + + StringName(_Data *p_data) { + _data = p_data; + } + +public: + operator const void *() const { + return (_data && (_data->cname || !_data->name.empty())) ? (void *)1 : nullptr; + } + + bool operator==(const String &p_name) const; + bool operator==(const char *p_name) const; + bool operator!=(const String &p_name) const; + + _FORCE_INLINE_ bool is_node_unique_name() const { + if (!_data) { + return false; + } + + if (_data->cname != nullptr) { + return _data->cname[0] == '%'; + } else { + return _data->name[0] == '%'; + } + } + + _FORCE_INLINE_ bool operator<(const StringName &p_name) const { + return _data < p_name._data; + } + _FORCE_INLINE_ bool operator==(const StringName &p_name) const { + // the real magic of all this mess happens here. + // this is why path comparisons are very fast + return _data == p_name._data; + } + _FORCE_INLINE_ uint32_t hash() const { + if (_data) { + return _data->hash; + } else { + return 0; + } + } + _FORCE_INLINE_ const void *data_unique_pointer() const { + return (void *)_data; + } + bool operator!=(const StringName &p_name) const; + + _FORCE_INLINE_ operator String() const { + if (_data) { + if (_data->cname) { + return String(_data->cname); + } else { + return _data->name; + } + } + + return String(); + } + + static StringName search(const char *p_name); + static StringName search(const CharType *p_name); + static StringName search(const String &p_name); + + struct AlphCompare { + _FORCE_INLINE_ bool operator()(const StringName &l, const StringName &r) const { + const char *l_cname = l._data ? l._data->cname : ""; + const char *r_cname = r._data ? r._data->cname : ""; + + if (l_cname) { + if (r_cname) { + return is_str_less(l_cname, r_cname); + } else { + return is_str_less(l_cname, r._data->name.ptr()); + } + } else { + if (r_cname) { + return is_str_less(l._data->name.ptr(), r_cname); + } else { + return is_str_less(l._data->name.ptr(), r._data->name.ptr()); + } + } + } + }; + + void operator=(const StringName &p_name); + StringName(const char *p_name, bool p_static = false); + StringName(const StringName &p_name); + StringName(const String &p_name, bool p_static = false); + StringName(const StaticCString &p_static_string, bool p_static = false); + StringName(); + _FORCE_INLINE_ ~StringName() { + if (likely(configured) && _data) { //only free if configured + unref(); + } + } + + static void setup(); + static void cleanup(); +}; + +/* +bool operator==(const String &p_name, const StringName &p_string_name); +bool operator!=(const String &p_name, const StringName &p_string_name); +bool operator==(const char *p_name, const StringName &p_string_name); +bool operator!=(const char *p_name, const StringName &p_string_name); +*/ + +StringName _scs_create(const char *p_chr, bool p_static = false); + +/* + * The SNAME macro is used to speed up StringName creation, as it allows caching it after the first usage in a very efficient way. + * It should NOT be used everywhere, but instead in places where high performance is required and the creation of a StringName + * can be costly. Places where it should be used are: + * - Control::get_theme_*( and Window::get_theme_*( functions. + * - emit_signal(,..) function + * - call_deferred(,..) function + * - Comparisons to a StringName in overridden _set and _get methods. + * + * Use in places that can be called hundreds of times per frame (or more) is recommended, but this situation is very rare. If in doubt, do not use. + */ + +//#define SNAME(m_arg) ([]() -> const StringName & { static StringName sname = _scs_create(m_arg, true); return sname; })() + +#line 0 + +#line 1 "sfwl/core/color.h" + +/*************************************************************************/ +/* color.h */ +/* From https://github.com/Relintai/pandemonium_engine (MIT) */ +/*************************************************************************/ + +struct _NO_DISCARD_CLASS_ Color { + union { + struct { + float r; + float g; + float b; + float a; + }; + float components[4]; + }; + + bool operator==(const Color &p_color) const { return (r == p_color.r && g == p_color.g && b == p_color.b && a == p_color.a); } + bool operator!=(const Color &p_color) const { return (r != p_color.r || g != p_color.g || b != p_color.b || a != p_color.a); } + + uint32_t to_rgba32() const; + uint32_t to_argb32() const; + uint32_t to_abgr32() const; + uint64_t to_rgba64() const; + uint64_t to_argb64() const; + uint64_t to_abgr64() const; + float get_h() const; + float get_s() const; + float get_v() const; + void set_hsv(float p_h, float p_s, float p_v, float p_alpha = 1.0); + + _FORCE_INLINE_ float &operator[](int idx) { + return components[idx]; + } + _FORCE_INLINE_ const float &operator[](int idx) const { + return components[idx]; + } + + Color operator+(const Color &p_color) const; + void operator+=(const Color &p_color); + + Color operator-() const; + Color operator-(const Color &p_color) const; + void operator-=(const Color &p_color); + + Color operator*(const Color &p_color) const; + Color operator*(const real_t &rvalue) const; + void operator*=(const Color &p_color); + void operator*=(const real_t &rvalue); + + Color operator/(const Color &p_color) const; + Color operator/(const real_t &rvalue) const; + void operator/=(const Color &p_color); + void operator/=(const real_t &rvalue); + + bool is_equal_approx(const Color &p_color) const; + + Color clamp(const Color &p_min = Color(0, 0, 0, 0), const Color &p_max = Color(1, 1, 1, 1)) const; + + void invert(); + void contrast(); + Color inverted() const; + Color contrasted() const; + + _FORCE_INLINE_ float get_luminance() const { + return 0.2126 * r + 0.7152 * g + 0.0722 * b; + } + + _FORCE_INLINE_ Color linear_interpolate(const Color &p_to, float p_weight) const { + Color res = *this; + + res.r += (p_weight * (p_to.r - r)); + res.g += (p_weight * (p_to.g - g)); + res.b += (p_weight * (p_to.b - b)); + res.a += (p_weight * (p_to.a - a)); + + return res; + } + + _FORCE_INLINE_ Color darkened(float p_amount) const { + Color res = *this; + res.r = res.r * (1.0f - p_amount); + res.g = res.g * (1.0f - p_amount); + res.b = res.b * (1.0f - p_amount); + return res; + } + + _FORCE_INLINE_ Color lightened(float p_amount) const { + Color res = *this; + res.r = res.r + (1.0f - res.r) * p_amount; + res.g = res.g + (1.0f - res.g) * p_amount; + res.b = res.b + (1.0f - res.b) * p_amount; + return res; + } + + _FORCE_INLINE_ uint32_t to_rgbe9995() const { + const float pow2to9 = 512.0f; + const float B = 15.0f; + //const float Emax = 31.0f; + const float N = 9.0f; + + float sharedexp = 65408.000f; //(( pow2to9 - 1.0f)/ pow2to9)*powf( 2.0f, 31.0f - 15.0f); + + float cRed = MAX(0.0f, MIN(sharedexp, r)); + float cGreen = MAX(0.0f, MIN(sharedexp, g)); + float cBlue = MAX(0.0f, MIN(sharedexp, b)); + + float cMax = MAX(cRed, MAX(cGreen, cBlue)); + + // expp = MAX(-B - 1, log2(maxc)) + 1 + B + + float expp = MAX(-B - 1.0f, floor(Math::log(cMax) / Math_LN2)) + 1.0f + B; + + float sMax = (float)floor((cMax / Math::pow(2.0f, expp - B - N)) + 0.5f); + + float exps = expp + 1.0f; + + if (0.0 <= sMax && sMax < pow2to9) { + exps = expp; + } + + float sRed = Math::floor((cRed / pow(2.0f, exps - B - N)) + 0.5f); + float sGreen = Math::floor((cGreen / pow(2.0f, exps - B - N)) + 0.5f); + float sBlue = Math::floor((cBlue / pow(2.0f, exps - B - N)) + 0.5f); + + return (uint32_t(Math::fast_ftoi(sRed)) & 0x1FF) | ((uint32_t(Math::fast_ftoi(sGreen)) & 0x1FF) << 9) | ((uint32_t(Math::fast_ftoi(sBlue)) & 0x1FF) << 18) | ((uint32_t(Math::fast_ftoi(exps)) & 0x1F) << 27); + } + + _FORCE_INLINE_ Color blend(const Color &p_over) const { + Color res; + float sa = 1.0 - p_over.a; + res.a = a * sa + p_over.a; + if (res.a == 0) { + return Color(0, 0, 0, 0); + } else { + res.r = (r * a * sa + p_over.r * p_over.a) / res.a; + res.g = (g * a * sa + p_over.g * p_over.a) / res.a; + res.b = (b * a * sa + p_over.b * p_over.a) / res.a; + } + return res; + } + + _FORCE_INLINE_ Color to_linear() const { + return Color( + r < 0.04045 ? r * (1.0 / 12.92) : Math::pow((r + 0.055) * (1.0 / (1 + 0.055)), 2.4), + g < 0.04045 ? g * (1.0 / 12.92) : Math::pow((g + 0.055) * (1.0 / (1 + 0.055)), 2.4), + b < 0.04045 ? b * (1.0 / 12.92) : Math::pow((b + 0.055) * (1.0 / (1 + 0.055)), 2.4), + a); + } + _FORCE_INLINE_ Color to_srgb() const { + return Color( + r < 0.0031308 ? 12.92 * r : (1.0 + 0.055) * Math::pow(r, 1.0f / 2.4f) - 0.055, + g < 0.0031308 ? 12.92 * g : (1.0 + 0.055) * Math::pow(g, 1.0f / 2.4f) - 0.055, + b < 0.0031308 ? 12.92 * b : (1.0 + 0.055) * Math::pow(b, 1.0f / 2.4f) - 0.055, a); + } + + static Color hex(uint32_t p_hex); + static Color hex64(uint64_t p_hex); + static Color html(const String &p_color); + static bool html_is_valid(const String &p_color); + String to_html(bool p_alpha = true) const; + Color from_hsv(float p_h, float p_s, float p_v, float p_a) const; + static Color from_rgbe9995(uint32_t p_rgbe); + + _FORCE_INLINE_ bool operator<(const Color &p_color) const; //used in set keys + operator String() const; + + static _FORCE_INLINE_ Color color8(int r, int g, int b) { + return Color(static_cast(r) / 255.0f, static_cast(g) / 255.0f, static_cast(b) / 255.0f); + } + + static _FORCE_INLINE_ Color color8(int r, int g, int b, int a) { + return Color(static_cast(r) / 255.0f, static_cast(g) / 255.0f, static_cast(b) / 255.0f, static_cast(a) / 255.0f); + } + + _FORCE_INLINE_ void set_r8(int32_t r8) { r = (CLAMP(r8, 0, 255) / 255.0f); } + _FORCE_INLINE_ int32_t get_r8() const { return int32_t(CLAMP(Math::round(r * 255.0f), 0.0f, 255.0f)); } + _FORCE_INLINE_ void set_g8(int32_t g8) { g = (CLAMP(g8, 0, 255) / 255.0f); } + _FORCE_INLINE_ int32_t get_g8() const { return int32_t(CLAMP(Math::round(g * 255.0f), 0.0f, 255.0f)); } + _FORCE_INLINE_ void set_b8(int32_t b8) { b = (CLAMP(b8, 0, 255) / 255.0f); } + _FORCE_INLINE_ int32_t get_b8() const { return int32_t(CLAMP(Math::round(b * 255.0f), 0.0f, 255.0f)); } + _FORCE_INLINE_ void set_a8(int32_t a8) { a = (CLAMP(a8, 0, 255) / 255.0f); } + _FORCE_INLINE_ int32_t get_a8() const { return int32_t(CLAMP(Math::round(a * 255.0f), 0.0f, 255.0f)); } + + _FORCE_INLINE_ void set_h(float p_h) { set_hsv(p_h, get_s(), get_v(), a); } + _FORCE_INLINE_ void set_s(float p_s) { set_hsv(get_h(), p_s, get_v(), a); } + _FORCE_INLINE_ void set_v(float p_v) { set_hsv(get_h(), get_s(), p_v, a); } + + /** + * No construct parameters, r=0, g=0, b=0. a=255 + */ + _FORCE_INLINE_ Color() { + r = 0; + g = 0; + b = 0; + a = 1.0; + } + + /** + * RGB / RGBA construct parameters. Alpha is optional, but defaults to 1.0 + */ + _FORCE_INLINE_ Color(float p_r, float p_g, float p_b, float p_a = 1.0) { + r = p_r; + g = p_g; + b = p_b; + a = p_a; + } + + /** + * Construct a Color from another Color, but with the specified alpha value. + */ + _FORCE_INLINE_ Color(const Color &p_c, float p_a) { + r = p_c.r; + g = p_c.g; + b = p_c.b; + a = p_a; + } +}; + +bool Color::operator<(const Color &p_color) const { + if (r == p_color.r) { + if (g == p_color.g) { + if (b == p_color.b) { + return (a < p_color.a); + } else { + return (b < p_color.b); + } + } else { + return g < p_color.g; + } + } else { + return r < p_color.r; + } +} + +#line 0 + +#line 1 "sfwl/core/vector2i.h" + +/*************************************************************************/ +/* vector2i.h */ +/* From https://github.com/Relintai/pandemonium_engine (MIT) */ +/*************************************************************************/ + +class String; + +struct _NO_DISCARD_CLASS_ Vector2i { + enum Axis { + AXIS_X, + AXIS_Y, + }; + + union { + struct { + union { + int x; + int width; + }; + union { + int y; + int height; + }; + }; + + int coord[2]; + }; + + _FORCE_INLINE_ int &operator[](int p_idx) { + DEV_ASSERT((unsigned int)p_idx < 2); + return coord[p_idx]; + } + _FORCE_INLINE_ const int &operator[](int p_idx) const { + DEV_ASSERT((unsigned int)p_idx < 2); + return coord[p_idx]; + } + + _FORCE_INLINE_ void set_all(int p_value) { + x = y = p_value; + } + + _FORCE_INLINE_ int min_axis() const { + return x < y ? 0 : 1; + } + + _FORCE_INLINE_ int max_axis() const { + return x < y ? 1 : 0; + } + + Vector2i min(const Vector2i &p_vector2i) const { + return Vector2i(MIN(x, p_vector2i.x), MIN(y, p_vector2i.y)); + } + + Vector2i max(const Vector2i &p_vector2i) const { + return Vector2i(MAX(x, p_vector2i.x), MAX(y, p_vector2i.y)); + } + + _FORCE_INLINE_ static Vector2i linear_interpolate(const Vector2i &p_a, const Vector2i &p_b, real_t p_weight); + _FORCE_INLINE_ Vector2i linear_interpolate(const Vector2i &p_to, real_t p_weight) const; + + Vector2i operator+(const Vector2i &p_v) const; + void operator+=(const Vector2i &p_v); + Vector2i operator-(const Vector2i &p_v) const; + void operator-=(const Vector2i &p_v); + Vector2i operator*(const Vector2i &p_v1) const; + + Vector2i operator*(const int &rvalue) const; + void operator*=(const int &rvalue); + + Vector2i operator/(const Vector2i &p_v1) const; + + Vector2i operator/(const int &rvalue) const; + + void operator/=(const int &rvalue); + + Vector2i operator-() const; + bool operator<(const Vector2i &p_vec2) const { return (x == p_vec2.x) ? (y < p_vec2.y) : (x < p_vec2.x); } + bool operator>(const Vector2i &p_vec2) const { return (x == p_vec2.x) ? (y > p_vec2.y) : (x > p_vec2.x); } + bool operator<=(const Vector2i &p_vec2) const { return x == p_vec2.x ? (y <= p_vec2.y) : (x < p_vec2.x); } + bool operator>=(const Vector2i &p_vec2) const { return x == p_vec2.x ? (y >= p_vec2.y) : (x > p_vec2.x); } + + bool operator==(const Vector2i &p_vec2) const; + bool operator!=(const Vector2i &p_vec2) const; + + int64_t length_squared() const; + double length() const; + + real_t aspect() const { return width / (real_t)height; } + Vector2i sign() const { return Vector2i(SGN(x), SGN(y)); } + Vector2i abs() const { return Vector2i(ABS(x), ABS(y)); } + Vector2i clamp(const Vector2i &p_min, const Vector2i &p_max) const; + + operator String() const; + + inline Vector2i(const Vector2i &p_vec2) { + x = p_vec2.x; + y = p_vec2.y; + } + inline Vector2i(int p_x, int p_y) { + x = p_x; + y = p_y; + } + inline Vector2i() { + x = 0; + y = 0; + } +}; + +Vector2i Vector2i::linear_interpolate(const Vector2i &p_a, const Vector2i &p_b, real_t p_weight) { + Vector2i res = p_a; + + res.x += (p_weight * (p_b.x - p_a.x)); + res.y += (p_weight * (p_b.y - p_a.y)); + + return res; +} + +Vector2i Vector2i::linear_interpolate(const Vector2i &p_to, real_t p_weight) const { + real_t res_x = x; + real_t res_y = y; + + res_x += (p_weight * (p_to.x - x)); + res_y += (p_weight * (p_to.y - y)); + + return Vector2i(res_x, res_y); +} + +typedef Vector2i Size2i; +typedef Vector2i Point2i; + +#line 0 + +#line 1 "sfwl/core/rect2i.h" + +/*************************************************************************/ +/* rect2i.h */ +/* From https://github.com/Relintai/pandemonium_engine (MIT) */ +/*************************************************************************/ + +struct _NO_DISCARD_CLASS_ Rect2i { + Point2i position; + Size2i size; + + const Point2i &get_position() const { return position; } + void set_position(const Point2i &p_position) { position = p_position; } + const Size2i &get_size() const { return size; } + void set_size(const Size2i &p_size) { size = p_size; } + + int get_area() const { return size.width * size.height; } + + _FORCE_INLINE_ Vector2i get_center() const { return position + (size / 2); } + + inline bool intersects(const Rect2i &p_rect) const { + if (position.x > (p_rect.position.x + p_rect.size.width)) { + return false; + } + if ((position.x + size.width) < p_rect.position.x) { + return false; + } + if (position.y > (p_rect.position.y + p_rect.size.height)) { + return false; + } + if ((position.y + size.height) < p_rect.position.y) { + return false; + } + + return true; + } + + inline bool encloses(const Rect2i &p_rect) const { + return (p_rect.position.x >= position.x) && (p_rect.position.y >= position.y) && + ((p_rect.position.x + p_rect.size.x) < (position.x + size.x)) && + ((p_rect.position.y + p_rect.size.y) < (position.y + size.y)); + } + + _FORCE_INLINE_ bool has_no_area() const { + return (size.x <= 0 || size.y <= 0); + } + + inline Rect2i clip(const Rect2i &p_rect) const { /// return a clipped rect + + Rect2i new_rect = p_rect; + + if (!intersects(new_rect)) { + return Rect2i(); + } + + new_rect.position.x = MAX(p_rect.position.x, position.x); + new_rect.position.y = MAX(p_rect.position.y, position.y); + + Point2i p_rect_end = p_rect.position + p_rect.size; + Point2i end = position + size; + + new_rect.size.x = (int)(MIN(p_rect_end.x, end.x) - new_rect.position.x); + new_rect.size.y = (int)(MIN(p_rect_end.y, end.y) - new_rect.position.y); + + return new_rect; + } + + // Returns the instersection between two Rect2is or an empty Rect2i if there is no intersection + inline Rect2i intersection(const Rect2i &p_rect) const { + Rect2i new_rect = p_rect; + + if (!intersects(new_rect)) { + return Rect2i(); + } + + new_rect.position.x = MAX(p_rect.position.x, position.x); + new_rect.position.y = MAX(p_rect.position.y, position.y); + + Point2i p_rect_end = p_rect.position + p_rect.size; + Point2i end = position + size; + + new_rect.size.x = MIN(p_rect_end.x, end.x) - new_rect.position.x; + new_rect.size.y = MIN(p_rect_end.y, end.y) - new_rect.position.y; + + return new_rect; + } + + inline Rect2i merge(const Rect2i &p_rect) const { ///< return a merged rect + + Rect2i new_rect; + + new_rect.position.x = MIN(p_rect.position.x, position.x); + new_rect.position.y = MIN(p_rect.position.y, position.y); + + new_rect.size.x = MAX(p_rect.position.x + p_rect.size.x, position.x + size.x); + new_rect.size.y = MAX(p_rect.position.y + p_rect.size.y, position.y + size.y); + + new_rect.size = new_rect.size - new_rect.position; //make relative again + + return new_rect; + } + + bool has_point(const Point2i &p_point) const { + if (p_point.x < position.x) { + return false; + } + if (p_point.y < position.y) { + return false; + } + + if (p_point.x >= (position.x + size.x)) { + return false; + } + if (p_point.y >= (position.y + size.y)) { + return false; + } + + return true; + } + + bool operator==(const Rect2i &p_rect) const { return position == p_rect.position && size == p_rect.size; } + bool operator!=(const Rect2i &p_rect) const { return position != p_rect.position || size != p_rect.size; } + + Rect2i grow(int p_by) const { + Rect2i g = *this; + g.position.x -= p_by; + g.position.y -= p_by; + g.size.width += p_by * 2; + g.size.height += p_by * 2; + return g; + } + + void grow_by(int p_by) { + position.x -= p_by; + position.y -= p_by; + size.width += p_by * 2; + size.height += p_by * 2; + } + + inline Rect2i grow_margin(Margin p_margin, int p_amount) const { + Rect2i g = *this; + g = g.grow_individual((MARGIN_LEFT == p_margin) ? p_amount : 0, + (MARGIN_TOP == p_margin) ? p_amount : 0, + (MARGIN_RIGHT == p_margin) ? p_amount : 0, + (MARGIN_BOTTOM == p_margin) ? p_amount : 0); + return g; + } + + inline Rect2i grow_side(Side p_side, int p_amount) const { + Rect2i g = *this; + g = g.grow_individual((SIDE_LEFT == p_side) ? p_amount : 0, + (SIDE_TOP == p_side) ? p_amount : 0, + (SIDE_RIGHT == p_side) ? p_amount : 0, + (SIDE_BOTTOM == p_side) ? p_amount : 0); + return g; + } + + inline Rect2i grow_individual(int p_left, int p_top, int p_right, int p_bottom) const { + Rect2i g = *this; + g.position.x -= p_left; + g.position.y -= p_top; + g.size.width += p_left + p_right; + g.size.height += p_top + p_bottom; + + return g; + } + + _FORCE_INLINE_ Rect2i expand(const Vector2i &p_vector) const { + Rect2i r = *this; + r.expand_to(p_vector); + return r; + } + + inline void expand_to(const Point2i &p_vector) { + Point2i begin = position; + Point2i end = position + size; + + if (p_vector.x < begin.x) { + begin.x = p_vector.x; + } + if (p_vector.y < begin.y) { + begin.y = p_vector.y; + } + + if (p_vector.x > end.x) { + end.x = p_vector.x; + } + if (p_vector.y > end.y) { + end.y = p_vector.y; + } + + position = begin; + size = end - begin; + } + + _FORCE_INLINE_ Rect2i abs() const { + return Rect2i(Point2i(position.x + MIN(size.x, 0), position.y + MIN(size.y, 0)), size.abs()); + } + + _FORCE_INLINE_ void set_end(const Vector2i &p_end) { + size = p_end - position; + } + + _FORCE_INLINE_ Vector2i get_end() const { + return position + size; + } + + operator String() const; + + Rect2i() {} + Rect2i(int p_x, int p_y, int p_width, int p_height) : + position(Point2i(p_x, p_y)), + size(Size2i(p_width, p_height)) { + } + Rect2i(const Point2i &p_pos, const Size2i &p_size) : + position(p_pos), + size(p_size) { + } +}; + +#line 0 + +#line 1 "sfwl/core/pool_vector.h" + +/*************************************************************************/ +/* pool_vector.h */ +/* From https://github.com/Relintai/pandemonium_engine (MIT) */ +/*************************************************************************/ + +struct MemoryPool { + //avoid accessing these directly, must be public for template access + + static PoolAllocator *memory_pool; + static uint8_t *pool_memory; + static size_t *pool_size; + + struct Alloc { + SafeRefCount refcount; + SafeNumeric lock; + void *mem; + PoolAllocator::ID pool_id; + size_t size; + + Alloc *free_list; + + Alloc() : + lock(0), + mem(nullptr), + pool_id(POOL_ALLOCATOR_INVALID_ID), + size(0), + free_list(nullptr) { + } + }; + + static Alloc *allocs; + static Alloc *free_list; + static uint32_t alloc_count; + static uint32_t allocs_used; + static Mutex alloc_mutex; + static size_t total_memory; + static size_t max_memory; + + static void setup(uint32_t p_max_allocs = (1 << 16)); + static void cleanup(); +}; + +template +class PoolVector { + MemoryPool::Alloc *alloc; + + void _copy_on_write() { + if (!alloc) { + return; + } + + // ERR_FAIL_COND(alloc->lock>0); should not be illegal to lock this for copy on write, as it's a copy on write after all + + // Refcount should not be zero, otherwise it's a misuse of COW + if (alloc->refcount.get() == 1) { + return; //nothing to do + } + + //must allocate something + + MemoryPool::alloc_mutex.lock(); + if (MemoryPool::allocs_used == MemoryPool::alloc_count) { + MemoryPool::alloc_mutex.unlock(); + ERR_FAIL_MSG("All memory pool allocations are in use, can't COW."); + } + + MemoryPool::Alloc *old_alloc = alloc; + + //take one from the free list + alloc = MemoryPool::free_list; + MemoryPool::free_list = alloc->free_list; + //increment the used counter + MemoryPool::allocs_used++; + + //copy the alloc data + alloc->size = old_alloc->size; + alloc->refcount.init(); + alloc->pool_id = POOL_ALLOCATOR_INVALID_ID; + alloc->lock.set(0); + +#ifdef DEBUG_ENABLED + MemoryPool::total_memory += alloc->size; + if (MemoryPool::total_memory > MemoryPool::max_memory) { + MemoryPool::max_memory = MemoryPool::total_memory; + } +#endif + + MemoryPool::alloc_mutex.unlock(); + + if (MemoryPool::memory_pool) { + } else { + alloc->mem = memalloc(alloc->size); + } + + { + Write w; + w._ref(alloc); + Read r; + r._ref(old_alloc); + + int cur_elements = alloc->size / sizeof(T); + T *dst = (T *)w.ptr(); + const T *src = (const T *)r.ptr(); + for (int i = 0; i < cur_elements; i++) { + memnew_placement(&dst[i], T(src[i])); + } + } + + if (old_alloc->refcount.unref()) { + //this should never happen but.. + +#ifdef DEBUG_ENABLED + MemoryPool::alloc_mutex.lock(); + MemoryPool::total_memory -= old_alloc->size; + MemoryPool::alloc_mutex.unlock(); +#endif + + { + Write w; + w._ref(old_alloc); + + int cur_elements = old_alloc->size / sizeof(T); + T *elems = (T *)w.ptr(); + for (int i = 0; i < cur_elements; i++) { + elems[i].~T(); + } + } + + if (MemoryPool::memory_pool) { + //resize memory pool + //if none, create + //if some resize + } else { + memfree(old_alloc->mem); + old_alloc->mem = nullptr; + old_alloc->size = 0; + + MemoryPool::alloc_mutex.lock(); + old_alloc->free_list = MemoryPool::free_list; + MemoryPool::free_list = old_alloc; + MemoryPool::allocs_used--; + MemoryPool::alloc_mutex.unlock(); + } + } + } + + void _reference(const PoolVector &p_pool_vector) { + if (alloc == p_pool_vector.alloc) { + return; + } + + _unreference(); + + if (!p_pool_vector.alloc) { + return; + } + + if (p_pool_vector.alloc->refcount.ref()) { + alloc = p_pool_vector.alloc; + } + } + + void _unreference() { + if (!alloc) { + return; + } + + if (!alloc->refcount.unref()) { + alloc = nullptr; + return; + } + + //must be disposed! + + { + int cur_elements = alloc->size / sizeof(T); + + // Don't use write() here because it could otherwise provoke COW, + // which is not desirable here because we are destroying the last reference anyways + Write w; + // Reference to still prevent other threads from touching the alloc + w._ref(alloc); + + for (int i = 0; i < cur_elements; i++) { + w[i].~T(); + } + } + +#ifdef DEBUG_ENABLED + MemoryPool::alloc_mutex.lock(); + MemoryPool::total_memory -= alloc->size; + MemoryPool::alloc_mutex.unlock(); +#endif + + if (MemoryPool::memory_pool) { + //resize memory pool + //if none, create + //if some resize + } else { + memfree(alloc->mem); + alloc->mem = nullptr; + alloc->size = 0; + + MemoryPool::alloc_mutex.lock(); + alloc->free_list = MemoryPool::free_list; + MemoryPool::free_list = alloc; + MemoryPool::allocs_used--; + MemoryPool::alloc_mutex.unlock(); + } + + alloc = nullptr; + } + +public: + class Access { + friend class PoolVector; + + protected: + MemoryPool::Alloc *alloc; + T *mem; + + _FORCE_INLINE_ void _ref(MemoryPool::Alloc *p_alloc) { + alloc = p_alloc; + if (alloc) { + if (alloc->lock.increment() == 1) { + if (MemoryPool::memory_pool) { + //lock it and get mem + } + } + + mem = (T *)alloc->mem; + } + } + + _FORCE_INLINE_ void _unref() { + if (alloc) { + if (alloc->lock.decrement() == 0) { + if (MemoryPool::memory_pool) { + //put mem back + } + } + + mem = nullptr; + alloc = nullptr; + } + } + + Access() { + alloc = nullptr; + mem = nullptr; + } + + public: + virtual ~Access() { + _unref(); + } + + void release() { + _unref(); + } + }; + + class Read : public Access { + public: + _FORCE_INLINE_ const T &operator[](int p_index) const { return this->mem[p_index]; } + _FORCE_INLINE_ const T *ptr() const { return this->mem; } + + void operator=(const Read &p_read) { + if (this->alloc == p_read.alloc) { + return; + } + this->_unref(); + this->_ref(p_read.alloc); + } + + Read(const Read &p_read) { + this->_ref(p_read.alloc); + } + + Read() {} + }; + + class Write : public Access { + public: + _FORCE_INLINE_ T &operator[](int p_index) const { return this->mem[p_index]; } + _FORCE_INLINE_ T *ptr() const { return this->mem; } + + void operator=(const Write &p_read) { + if (this->alloc == p_read.alloc) { + return; + } + this->_unref(); + this->_ref(p_read.alloc); + } + + Write(const Write &p_read) { + this->_ref(p_read.alloc); + } + + Write() {} + }; + + Read read() const { + Read r; + if (alloc) { + r._ref(alloc); + } + return r; + } + Write write() { + Write w; + if (alloc) { + _copy_on_write(); //make sure there is only one being accessed + w._ref(alloc); + } + return w; + } + + template + void fill_with(const MC &p_mc) { + int c = p_mc.size(); + resize(c); + Write w = write(); + int idx = 0; + for (const typename MC::Element *E = p_mc.front(); E; E = E->next()) { + w[idx++] = E->get(); + } + } + + void remove(int p_index) { + int s = size(); + ERR_FAIL_INDEX(p_index, s); + Write w = write(); + for (int i = p_index; i < s - 1; i++) { + w[i] = w[i + 1]; + }; + w = Write(); + resize(s - 1); + } + + inline int size() const; + inline bool empty() const; + T get(int p_index) const; + void set(int p_index, const T &p_val); + void fill(const T &p_val); + void push_back(const T &p_val); + void append(const T &p_val) { + push_back(p_val); + } + void append_array(const PoolVector &p_arr) { + int ds = p_arr.size(); + if (ds == 0) { + return; + } + int bs = size(); + resize(bs + ds); + Write w = write(); + Read r = p_arr.read(); + for (int i = 0; i < ds; i++) { + w[bs + i] = r[i]; + } + } + + PoolVector subarray(int p_from, int p_to) const { + if (p_from < 0) { + p_from = size() + p_from; + } + if (p_to < 0) { + p_to = size() + p_to; + } + + ERR_FAIL_INDEX_V(p_from, size(), PoolVector()); + ERR_FAIL_INDEX_V(p_to, size(), PoolVector()); + + PoolVector slice; + int span = 1 + p_to - p_from; + slice.resize(span); + Read r = read(); + Write w = slice.write(); + for (int i = 0; i < span; ++i) { + w[i] = r[p_from + i]; + } + + return slice; + } + + Error insert(int p_pos, const T &p_val) { + int s = size(); + ERR_FAIL_INDEX_V(p_pos, s + 1, ERR_INVALID_PARAMETER); + resize(s + 1); + { + Write w = write(); + for (int i = s; i > p_pos; i--) { + w[i] = w[i - 1]; + } + w[p_pos] = p_val; + } + + return OK; + } + + String join(const String &delimiter) const { + String rs = ""; + int s = size(); + Read r = read(); + for (int i = 0; i < s; i++) { + rs += r[i] + delimiter; + } + rs.erase(rs.length() - delimiter.length(), delimiter.length()); + return rs; + } + + bool contains(const T &p_val) const; + int find(const T &p_val, int p_from = 0) const; + int rfind(const T &p_val, int p_from = -1) const; + int count(const T &p_val) const; + bool has(const T &p_val) const; + + bool is_locked() const { + return alloc && alloc->lock.get() > 0; + } + + inline T operator[](int p_index) const; + + Error resize(int p_size); + Error clear() { + return resize(0); + } + + void invert(); + void sort(); + + void operator=(const PoolVector &p_pool_vector) { + _reference(p_pool_vector); + } + PoolVector() { + alloc = nullptr; + } + PoolVector(const PoolVector &p_pool_vector) { + alloc = nullptr; + _reference(p_pool_vector); + } + ~PoolVector() { + _unreference(); + } +}; + +template +int PoolVector::size() const { + return alloc ? alloc->size / sizeof(T) : 0; +} + +template +bool PoolVector::empty() const { + return alloc ? alloc->size == 0 : true; +} + +template +T PoolVector::get(int p_index) const { + return operator[](p_index); +} + +template +void PoolVector::set(int p_index, const T &p_val) { + ERR_FAIL_INDEX(p_index, size()); + + Write w = write(); + w[p_index] = p_val; +} + +template +void PoolVector::fill(const T &p_val) { + Write w = write(); + for (int i = 0; i < size(); i++) { + w[i] = p_val; + } +} + +template +void PoolVector::push_back(const T &p_val) { + resize(size() + 1); + set(size() - 1, p_val); +} + +template +bool PoolVector::contains(const T &p_val) const { + Read r = read(); + int s = size(); + + for (int i = 0; i < s; ++i) { + if (r[i] == p_val) { + return true; + } + } + + return false; +} + +template +int PoolVector::find(const T &p_val, int p_from) const { + if (p_from < 0) { + return -1; + } + + const int s = size(); + const Read r = read(); + + for (int i = p_from; i < s; i++) { + if (r[i] == p_val) { + return i; + } + } + return -1; +} + +template +int PoolVector::rfind(const T &p_val, int p_from) const { + const int s = size(); + const Read r = read(); + + if (p_from < 0) { + p_from = s + p_from; + } + if (p_from < 0 || p_from >= s) { + p_from = s - 1; + } + + for (int i = p_from; i >= 0; i--) { + if (r[i] == p_val) { + return i; + } + } + return -1; +} + +template +int PoolVector::count(const T &p_val) const { + const int s = size(); + const Read r = read(); + int amount = 0; + for (int i = 0; i < s; i++) { + if (r[i] == p_val) { + amount++; + } + } + return amount; +} + +template +bool PoolVector::has(const T &p_val) const { + return find(p_val) != -1; +} + +template +T PoolVector::operator[](int p_index) const { + CRASH_BAD_INDEX(p_index, size()); + + Read r = read(); + return r[p_index]; +} + +template +Error PoolVector::resize(int p_size) { + ERR_FAIL_COND_V_MSG(p_size < 0, ERR_INVALID_PARAMETER, "Size of PoolVector cannot be negative."); + + if (alloc == nullptr) { + if (p_size == 0) { + return OK; //nothing to do here + } + + //must allocate something + MemoryPool::alloc_mutex.lock(); + if (MemoryPool::allocs_used == MemoryPool::alloc_count) { + MemoryPool::alloc_mutex.unlock(); + ERR_FAIL_V_MSG(ERR_OUT_OF_MEMORY, "All memory pool allocations are in use."); + } + + //take one from the free list + alloc = MemoryPool::free_list; + MemoryPool::free_list = alloc->free_list; + //increment the used counter + MemoryPool::allocs_used++; + + //cleanup the alloc + alloc->size = 0; + alloc->refcount.init(); + alloc->pool_id = POOL_ALLOCATOR_INVALID_ID; + MemoryPool::alloc_mutex.unlock(); + + } else { + ERR_FAIL_COND_V_MSG(alloc->lock.get() > 0, ERR_LOCKED, "Can't resize PoolVector if locked."); //can't resize if locked! + } + + size_t new_size = sizeof(T) * p_size; + + if (alloc->size == new_size) { + return OK; //nothing to do + } + + if (p_size == 0) { + _unreference(); + return OK; + } + + _copy_on_write(); // make it unique + +#ifdef DEBUG_ENABLED + MemoryPool::alloc_mutex.lock(); + MemoryPool::total_memory -= alloc->size; + MemoryPool::total_memory += new_size; + if (MemoryPool::total_memory > MemoryPool::max_memory) { + MemoryPool::max_memory = MemoryPool::total_memory; + } + MemoryPool::alloc_mutex.unlock(); +#endif + + int cur_elements = alloc->size / sizeof(T); + + if (p_size > cur_elements) { + if (MemoryPool::memory_pool) { + //resize memory pool + //if none, create + //if some resize + } else { + if (alloc->size == 0) { + alloc->mem = memalloc(new_size); + } else { + alloc->mem = memrealloc(alloc->mem, new_size); + } + } + + alloc->size = new_size; + + Write w = write(); + + for (int i = cur_elements; i < p_size; i++) { + memnew_placement(&w[i], T); + } + + } else { + { + Write w = write(); + for (int i = p_size; i < cur_elements; i++) { + w[i].~T(); + } + } + + if (MemoryPool::memory_pool) { + //resize memory pool + //if none, create + //if some resize + } else { + if (new_size == 0) { + memfree(alloc->mem); + alloc->mem = nullptr; + alloc->size = 0; + + MemoryPool::alloc_mutex.lock(); + alloc->free_list = MemoryPool::free_list; + MemoryPool::free_list = alloc; + MemoryPool::allocs_used--; + MemoryPool::alloc_mutex.unlock(); + + } else { + alloc->mem = memrealloc(alloc->mem, new_size); + alloc->size = new_size; + } + } + } + + return OK; +} + +template +void PoolVector::invert() { + T temp; + Write w = write(); + int s = size(); + int half_s = s / 2; + + for (int i = 0; i < half_s; i++) { + temp = w[i]; + w[i] = w[s - i - 1]; + w[s - i - 1] = temp; + } +} + +template +void PoolVector::sort() { + int len = size(); + if (len == 0) { + return; + } + + Write w = write(); + SortArray sorter; + sorter.sort(w.ptr(), len); +} + +#line 0 + +#line 1 "sfwl/core/tight_local_vector.h" + +/*************************************************************************/ +/* tight_local_vector.h */ +/* From https://github.com/Relintai/pandemonium_engine (MIT) */ +/*************************************************************************/ + +// It grows strictly as much as needed. (The vanilla LocalVector is what you want in most cases). +template +class TightLocalVector { +private: + U count = 0; + U capacity = 0; + T *data = nullptr; + +public: + T *ptr() { + return data; + } + + const T *ptr() const { + return data; + } + + _FORCE_INLINE_ void push_back(T p_elem) { + if (unlikely(count == capacity)) { + if (capacity == 0) { + capacity = 1; + } else { + capacity <<= 1; + } + data = (T *)memrealloc(data, capacity * sizeof(T)); + CRASH_COND_MSG(!data, "Out of memory"); + } + + if (!HAS_TRIVIAL_CONSTRUCTOR(T) && !force_trivial) { + memnew_placement(&data[count++], T(p_elem)); + } else { + data[count++] = p_elem; + } + } + + void remove(U p_index) { + ERR_FAIL_UNSIGNED_INDEX(p_index, count); + count--; + for (U i = p_index; i < count; i++) { + data[i] = data[i + 1]; + } + if (!HAS_TRIVIAL_DESTRUCTOR(T) && !force_trivial) { + data[count].~T(); + } + } + + /// Removes the item copying the last value into the position of the one to + /// remove. It's generally faster than `remove`. + void remove_unordered(U p_index) { + ERR_FAIL_INDEX(p_index, count); + count--; + if (count > p_index) { + data[p_index] = data[count]; + } + if (!HAS_TRIVIAL_DESTRUCTOR(T) && !force_trivial) { + data[count].~T(); + } + } + + void erase(const T &p_val) { + int64_t idx = find(p_val); + if (idx >= 0) { + remove(idx); + } + } + + U erase_multiple_unordered(const T &p_val) { + U from = 0; + U count = 0; + while (true) { + int64_t idx = find(p_val, from); + + if (idx == -1) { + break; + } + remove_unordered(idx); + from = idx; + count++; + } + return count; + } + + void invert() { + for (U i = 0; i < count / 2; i++) { + SWAP(data[i], data[count - i - 1]); + } + } + + _FORCE_INLINE_ void clear() { resize(0); } + _FORCE_INLINE_ void reset() { + clear(); + if (data) { + memfree(data); + data = nullptr; + capacity = 0; + } + } + _FORCE_INLINE_ bool empty() const { return count == 0; } + _FORCE_INLINE_ U get_capacity() const { return capacity; } + _FORCE_INLINE_ void reserve(U p_size) { + if (p_size > capacity) { + capacity = p_size; + data = (T *)memrealloc(data, capacity * sizeof(T)); + CRASH_COND_MSG(!data, "Out of memory"); + } + } + + _FORCE_INLINE_ U size() const { return count; } + void resize(U p_size) { + if (p_size < count) { + if (!HAS_TRIVIAL_DESTRUCTOR(T) && !force_trivial) { + for (U i = p_size; i < count; i++) { + data[i].~T(); + } + } + count = p_size; + } else if (p_size > count) { + if (unlikely(p_size > capacity)) { + if (capacity == 0) { + capacity = 1; + } + while (capacity < p_size) { + capacity <<= 1; + } + data = (T *)memrealloc(data, capacity * sizeof(T)); + CRASH_COND_MSG(!data, "Out of memory"); + } + if (!HAS_TRIVIAL_CONSTRUCTOR(T) && !force_trivial) { + for (U i = count; i < p_size; i++) { + memnew_placement(&data[i], T); + } + } + count = p_size; + } + } + _FORCE_INLINE_ const T &operator[](U p_index) const { + CRASH_BAD_UNSIGNED_INDEX(p_index, count); + return data[p_index]; + } + _FORCE_INLINE_ T &operator[](U p_index) { + CRASH_BAD_UNSIGNED_INDEX(p_index, count); + return data[p_index]; + } + + void fill(T p_val) { + for (U i = 0; i < count; i++) { + data[i] = p_val; + } + } + + void insert(U p_pos, T p_val) { + ERR_FAIL_UNSIGNED_INDEX(p_pos, count + 1); + if (p_pos == count) { + push_back(p_val); + } else { + resize(count + 1); + for (U i = count - 1; i > p_pos; i--) { + data[i] = data[i - 1]; + } + data[p_pos] = p_val; + } + } + + int64_t find(const T &p_val, U p_from = 0) const { + for (U i = p_from; i < count; i++) { + if (data[i] == p_val) { + return int64_t(i); + } + } + return -1; + } + + template + void sort_custom() { + U len = count; + if (len == 0) { + return; + } + + SortArray sorter; + sorter.sort(data, len); + } + + void sort() { + sort_custom<_DefaultComparator>(); + } + + void ordered_insert(T p_val) { + U i; + for (i = 0; i < count; i++) { + if (p_val < data[i]) { + break; + } + } + insert(i, p_val); + } + + operator Vector() const { + Vector ret; + ret.resize(size()); + T *w = ret.ptrw(); + memcpy(w, data, sizeof(T) * count); + return ret; + } + + operator PoolVector() const { + PoolVector pl; + if (size()) { + pl.resize(size()); + typename PoolVector::Write w = pl.write(); + T *dest = w.ptr(); + memcpy(dest, data, sizeof(T) * count); + } + return pl; + } + + Vector to_byte_array() const { //useful to pass stuff to gpu or variant + Vector ret; + ret.resize(count * sizeof(T)); + uint8_t *w = ret.ptrw(); + memcpy(w, data, sizeof(T) * count); + return ret; + } + + _FORCE_INLINE_ TightLocalVector() {} + _FORCE_INLINE_ TightLocalVector(const TightLocalVector &p_from) { + resize(p_from.size()); + for (U i = 0; i < p_from.count; i++) { + data[i] = p_from.data[i]; + } + } + TightLocalVector(const Vector &p_from) { + resize(p_from.size()); + for (U i = 0; i < count; i++) { + data[i] = p_from[i]; + } + } + TightLocalVector(const PoolVector &p_from) { + resize(p_from.size()); + typename PoolVector::Read r = p_from.read(); + for (U i = 0; i < count; i++) { + data[i] = r[i]; + } + } + + inline void operator=(const TightLocalVector &p_from) { + resize(p_from.size()); + for (U i = 0; i < p_from.count; i++) { + data[i] = p_from.data[i]; + } + } + inline void operator=(const Vector &p_from) { + resize(p_from.size()); + for (U i = 0; i < count; i++) { + data[i] = p_from[i]; + } + } + inline TightLocalVector &operator=(const PoolVector &p_from) { + resize(p_from.size()); + typename PoolVector::Read r = p_from.read(); + for (U i = 0; i < count; i++) { + data[i] = r[i]; + } + return *this; + } + + _FORCE_INLINE_ ~TightLocalVector() { + if (data) { + reset(); + } + } +}; + +// Integer default version +template +class TightLocalVectori : public TightLocalVector { +}; + +#line 0 + +#line 1 "sfwl/core/local_vector.h" + +/*************************************************************************/ +/* local_vector.h */ +/* From https://github.com/Relintai/pandemonium_engine (MIT) */ +/*************************************************************************/ + +template +class LocalVector { +protected: + U count = 0; + U capacity = 0; + T *data = nullptr; + +public: + T *ptr() { + return data; + } + + const T *ptr() const { + return data; + } + + _FORCE_INLINE_ void push_back(T p_elem) { + if (unlikely(count == capacity)) { + if (capacity == 0) { + capacity = 1; + } else { + capacity <<= 1; + } + data = (T *)memrealloc(data, capacity * sizeof(T)); + CRASH_COND_MSG(!data, "Out of memory"); + } + + if (!HAS_TRIVIAL_CONSTRUCTOR(T) && !force_trivial) { + memnew_placement(&data[count++], T(p_elem)); + } else { + data[count++] = p_elem; + } + } + + void remove(U p_index) { + ERR_FAIL_UNSIGNED_INDEX(p_index, count); + count--; + for (U i = p_index; i < count; i++) { + data[i] = data[i + 1]; + } + if (!HAS_TRIVIAL_DESTRUCTOR(T) && !force_trivial) { + data[count].~T(); + } + } + + // Removes the item copying the last value into the position of the one to + // remove. It's generally faster than `remove`. + void remove_unordered(U p_index) { + ERR_FAIL_INDEX(p_index, count); + count--; + if (count > p_index) { + data[p_index] = data[count]; + } + if (!HAS_TRIVIAL_DESTRUCTOR(T) && !force_trivial) { + data[count].~T(); + } + } + + _FORCE_INLINE_ bool erase(const T &p_val) { + int64_t idx = find(p_val); + if (idx >= 0) { + remove(idx); + return true; + } + return false; + } + + U erase_multiple_unordered(const T &p_val) { + U from = 0; + U count = 0; + while (true) { + int64_t idx = find(p_val, from); + + if (idx == -1) { + break; + } + remove_unordered(idx); + from = idx; + count++; + } + return count; + } + + void invert() { + for (U i = 0; i < count / 2; i++) { + SWAP(data[i], data[count - i - 1]); + } + } + + _FORCE_INLINE_ void clear() { resize(0); } + _FORCE_INLINE_ void reset() { + clear(); + if (data) { + memfree(data); + data = nullptr; + capacity = 0; + } + } + _FORCE_INLINE_ bool empty() const { return count == 0; } + _FORCE_INLINE_ U get_capacity() const { return capacity; } + _FORCE_INLINE_ void reserve(U p_size, bool p_allow_shrink = false) { + p_size = nearest_power_of_2_templated(p_size); + if (!p_allow_shrink ? p_size > capacity : ((p_size >= count) && (p_size != capacity))) { + capacity = p_size; + data = (T *)memrealloc(data, capacity * sizeof(T)); + CRASH_COND_MSG(!data, "Out of memory"); + } + } + + _FORCE_INLINE_ U size() const { return count; } + void resize(U p_size) { + if (p_size < count) { + if (!HAS_TRIVIAL_DESTRUCTOR(T) && !force_trivial) { + for (U i = p_size; i < count; i++) { + data[i].~T(); + } + } + count = p_size; + } else if (p_size > count) { + if (unlikely(p_size > capacity)) { + if (capacity == 0) { + capacity = 1; + } + while (capacity < p_size) { + capacity <<= 1; + } + data = (T *)memrealloc(data, capacity * sizeof(T)); + CRASH_COND_MSG(!data, "Out of memory"); + } + if (!HAS_TRIVIAL_CONSTRUCTOR(T) && !force_trivial) { + for (U i = count; i < p_size; i++) { + memnew_placement(&data[i], T); + } + } + count = p_size; + } + } + _FORCE_INLINE_ const T &operator[](U p_index) const { + CRASH_BAD_UNSIGNED_INDEX(p_index, count); + return data[p_index]; + } + _FORCE_INLINE_ T &operator[](U p_index) { + CRASH_BAD_UNSIGNED_INDEX(p_index, count); + return data[p_index]; + } + + void fill(T p_val) { + for (U i = 0; i < count; i++) { + data[i] = p_val; + } + } + + void insert(U p_pos, T p_val) { + ERR_FAIL_UNSIGNED_INDEX(p_pos, count + 1); + if (p_pos == count) { + push_back(p_val); + } else { + resize(count + 1); + for (U i = count - 1; i > p_pos; i--) { + data[i] = data[i - 1]; + } + data[p_pos] = p_val; + } + } + + int64_t find(const T &p_val, U p_from = 0) const { + for (U i = p_from; i < count; i++) { + if (data[i] == p_val) { + return int64_t(i); + } + } + return -1; + } + + template + void sort_custom() { + U len = count; + if (len == 0) { + return; + } + + SortArray sorter; + sorter.sort(data, len); + } + + void sort() { + sort_custom<_DefaultComparator>(); + } + + void ordered_insert(T p_val) { + U i; + for (i = 0; i < count; i++) { + if (p_val < data[i]) { + break; + } + } + insert(i, p_val); + } + + operator Vector() const { + Vector ret; + ret.resize(size()); + T *w = ret.ptrw(); + memcpy(w, data, sizeof(T) * count); + return ret; + } + + operator PoolVector() const { + PoolVector pl; + if (size()) { + pl.resize(size()); + typename PoolVector::Write w = pl.write(); + T *dest = w.ptr(); + memcpy(dest, data, sizeof(T) * count); + } + return pl; + } + + Vector to_byte_array() const { //useful to pass stuff to gpu or variant + Vector ret; + ret.resize(count * sizeof(T)); + uint8_t *w = ret.ptrw(); + memcpy(w, data, sizeof(T) * count); + return ret; + } + + _FORCE_INLINE_ LocalVector() {} + _FORCE_INLINE_ LocalVector(const LocalVector &p_from) { + resize(p_from.size()); + for (U i = 0; i < p_from.count; i++) { + data[i] = p_from.data[i]; + } + } + LocalVector(const Vector &p_from) { + resize(p_from.size()); + for (U i = 0; i < count; i++) { + data[i] = p_from[i]; + } + } + LocalVector(const PoolVector &p_from) { + resize(p_from.size()); + typename PoolVector::Read r = p_from.read(); + for (U i = 0; i < count; i++) { + data[i] = r[i]; + } + } + + inline LocalVector &operator=(const LocalVector &p_from) { + resize(p_from.size()); + for (U i = 0; i < p_from.count; i++) { + data[i] = p_from.data[i]; + } + return *this; + } + inline LocalVector &operator=(const Vector &p_from) { + resize(p_from.size()); + for (U i = 0; i < count; i++) { + data[i] = p_from[i]; + } + return *this; + } + inline LocalVector &operator=(const PoolVector &p_from) { + resize(p_from.size()); + typename PoolVector::Read r = p_from.read(); + for (U i = 0; i < count; i++) { + data[i] = r[i]; + } + return *this; + } + + _FORCE_INLINE_ ~LocalVector() { + if (data) { + reset(); + } + } +}; + +// Integer default version +template +class LocalVectori : public LocalVector { +}; + +#line 0 + +#line 1 "sfwl/core/hashfuncs.h" + +/*************************************************************************/ +/* hashfuncs.h */ +/* From https://github.com/Relintai/pandemonium_engine (MIT) */ +/*************************************************************************/ + +/** + * Hashing functions + */ + +/** + * DJB2 Hash function + * @param C String + * @return 32-bits hashcode + */ +static inline uint32_t hash_djb2(const char *p_cstr) { + const unsigned char *chr = (const unsigned char *)p_cstr; + uint32_t hash = 5381; + uint32_t c; + + while ((c = *chr++)) { + hash = ((hash << 5) + hash) ^ c; /* hash * 33 ^ c */ + } + + return hash; +} + +static inline uint32_t hash_djb2_buffer(const uint8_t *p_buff, int p_len, uint32_t p_prev = 5381) { + uint32_t hash = p_prev; + + for (int i = 0; i < p_len; i++) { + hash = ((hash << 5) + hash) ^ p_buff[i]; /* hash * 33 ^ c */ + } + + return hash; +} + +static inline uint32_t hash_djb2_one_32(uint32_t p_in, uint32_t p_prev = 5381) { + return ((p_prev << 5) + p_prev) ^ p_in; +} + +/** + * Thomas Wang's 64-bit to 32-bit Hash function: + * https://web.archive.org/web/20071223173210/https:/www.concentric.net/~Ttwang/tech/inthash.htm + * + * @param p_int - 64-bit unsigned integer key to be hashed + * @return unsigned 32-bit value representing hashcode + */ +static inline uint32_t hash_one_uint64(const uint64_t p_int) { + uint64_t v = p_int; + v = (~v) + (v << 18); // v = (v << 18) - v - 1; + v = v ^ (v >> 31); + v = v * 21; // v = (v + (v << 2)) + (v << 4); + v = v ^ (v >> 11); + v = v + (v << 6); + v = v ^ (v >> 22); + return (uint32_t)v; +} + +#define HASH_MURMUR3_SEED 0x7F07C65 +// Murmurhash3 32-bit version. +// All MurmurHash versions are public domain software, and the author disclaims all copyright to their code. + +static _FORCE_INLINE_ uint32_t hash_murmur3_one_32(uint32_t p_in, uint32_t p_seed = HASH_MURMUR3_SEED) { + p_in *= 0xcc9e2d51; + p_in = (p_in << 15) | (p_in >> 17); + p_in *= 0x1b873593; + + p_seed ^= p_in; + p_seed = (p_seed << 13) | (p_seed >> 19); + p_seed = p_seed * 5 + 0xe6546b64; + + return p_seed; +} + +static _FORCE_INLINE_ uint32_t hash_murmur3_one_float(float p_in, uint32_t p_seed = HASH_MURMUR3_SEED) { + union { + float f; + uint32_t i; + } u; + + // Normalize +/- 0.0 and NaN values so they hash the same. + if (p_in == 0.0f) { + u.f = 0.0; + } else if (Math::is_nan(p_in)) { + u.f = NAN; + } else { + u.f = p_in; + } + + return hash_murmur3_one_32(u.i, p_seed); +} + +static _FORCE_INLINE_ uint32_t hash_murmur3_one_64(uint64_t p_in, uint32_t p_seed = HASH_MURMUR3_SEED) { + p_seed = hash_murmur3_one_32(p_in & 0xFFFFFFFF, p_seed); + return hash_murmur3_one_32(p_in >> 32, p_seed); +} + +static _FORCE_INLINE_ uint32_t hash_murmur3_one_double(double p_in, uint32_t p_seed = HASH_MURMUR3_SEED) { + union { + double d; + uint64_t i; + } u; + + // Normalize +/- 0.0 and NaN values so they hash the same. + if (p_in == 0.0f) { + u.d = 0.0; + } else if (Math::is_nan(p_in)) { + u.d = NAN; + } else { + u.d = p_in; + } + + return hash_murmur3_one_64(u.i, p_seed); +} + +static _FORCE_INLINE_ uint32_t hash_murmur3_one_real(real_t p_in, uint32_t p_seed = HASH_MURMUR3_SEED) { +#ifdef REAL_T_IS_DOUBLE + return hash_murmur3_one_double(p_in, p_seed); +#else + return hash_murmur3_one_float(p_in, p_seed); +#endif +} + +static _FORCE_INLINE_ uint32_t hash_rotl32(uint32_t x, int8_t r) { + return (x << r) | (x >> (32 - r)); +} + +static _FORCE_INLINE_ uint32_t hash_fmix32(uint32_t h) { + h ^= h >> 16; + h *= 0x85ebca6b; + h ^= h >> 13; + h *= 0xc2b2ae35; + h ^= h >> 16; + + return h; +} + +static _FORCE_INLINE_ uint32_t hash_murmur3_buffer(const void *key, int length, const uint32_t seed = HASH_MURMUR3_SEED) { + // Although not required, this is a random prime number. + const uint8_t *data = (const uint8_t *)key; + const int nblocks = length / 4; + + uint32_t h1 = seed; + + const uint32_t c1 = 0xcc9e2d51; + const uint32_t c2 = 0x1b873593; + + const uint32_t *blocks = (const uint32_t *)(data + nblocks * 4); + + for (int i = -nblocks; i; i++) { + uint32_t k1 = blocks[i]; + + k1 *= c1; + k1 = hash_rotl32(k1, 15); + k1 *= c2; + + h1 ^= k1; + h1 = hash_rotl32(h1, 13); + h1 = h1 * 5 + 0xe6546b64; + } + + const uint8_t *tail = (const uint8_t *)(data + nblocks * 4); + + uint32_t k1 = 0; + + switch (length & 3) { + case 3: + k1 ^= tail[2] << 16; + FALLTHROUGH; + case 2: + k1 ^= tail[1] << 8; + FALLTHROUGH; + case 1: + k1 ^= tail[0]; + k1 *= c1; + k1 = hash_rotl32(k1, 15); + k1 *= c2; + h1 ^= k1; + }; + + // Finalize with additional bit mixing. + h1 ^= length; + return hash_fmix32(h1); +} + +static inline uint32_t hash_djb2_one_float(double p_in, uint32_t p_prev = 5381) { + union { + double d; + uint64_t i; + } u; + + // Normalize +/- 0.0 and NaN values so they hash the same. + if (p_in == 0.0f) { + u.d = 0.0; + } else if (Math::is_nan(p_in)) { + u.d = Math_NAN; + } else { + u.d = p_in; + } + + return ((p_prev << 5) + p_prev) + hash_one_uint64(u.i); +} + +template +static inline uint32_t make_uint32_t(T p_in) { + union { + T t; + uint32_t _u32; + } _u; + _u._u32 = 0; + _u.t = p_in; + return _u._u32; +} + +static _FORCE_INLINE_ uint64_t hash_djb2_one_float_64(double p_in, uint64_t p_prev = 5381) { + union { + double d; + uint64_t i; + } u; + + // Normalize +/- 0.0 and NaN values so they hash the same. + if (p_in == 0.0f) { + u.d = 0.0; + } else if (Math::is_nan(p_in)) { + u.d = NAN; + } else { + u.d = p_in; + } + + return ((p_prev << 5) + p_prev) + u.i; +} + +static _FORCE_INLINE_ uint64_t hash_djb2_one_64(uint64_t p_in, uint64_t p_prev = 5381) { + return ((p_prev << 5) + p_prev) ^ p_in; +} + +template +static _FORCE_INLINE_ uint64_t hash_make_uint64_t(T p_in) { + union { + T t; + uint64_t _u64; + } _u; + _u._u64 = 0; // in case p_in is smaller + + _u.t = p_in; + return _u._u64; +} + +template +static inline uint64_t make_uint64_t(T p_in) { + union { + T t; + uint64_t _u64; + } _u; + _u._u64 = 0; // in case p_in is smaller + + _u.t = p_in; + return _u._u64; +} + +template +class Ref; + +struct HashMapHasherDefault { + // Generic hash function for any type. + template + static _FORCE_INLINE_ uint32_t hash(const T *p_pointer) { return hash_one_uint64((uint64_t)p_pointer); } + + template + static _FORCE_INLINE_ uint32_t hash(const Ref &p_ref) { return hash_one_uint64((uint64_t)p_ref.operator->()); } + + static _FORCE_INLINE_ uint32_t hash(const String &p_string) { return p_string.hash(); } + static _FORCE_INLINE_ uint32_t hash(const char *p_cstr) { return hash_djb2(p_cstr); } + static _FORCE_INLINE_ uint32_t hash(const wchar_t p_wchar) { return hash_fmix32(p_wchar); } + static _FORCE_INLINE_ uint32_t hash(const char16_t p_uchar) { return hash_fmix32(p_uchar); } + static _FORCE_INLINE_ uint32_t hash(const char32_t p_uchar) { return hash_fmix32(p_uchar); } + static _FORCE_INLINE_ uint32_t hash(const StringName &p_string_name) { return p_string_name.hash(); } + + static _FORCE_INLINE_ uint32_t hash(const uint64_t p_int) { return hash_one_uint64(p_int); } + static _FORCE_INLINE_ uint32_t hash(const int64_t p_int) { return hash_one_uint64(p_int); } + static _FORCE_INLINE_ uint32_t hash(const float p_float) { return hash_murmur3_one_float(p_float); } + static _FORCE_INLINE_ uint32_t hash(const double p_double) { return hash_murmur3_one_double(p_double); } + static _FORCE_INLINE_ uint32_t hash(const uint32_t p_int) { return hash_fmix32(p_int); } + static _FORCE_INLINE_ uint32_t hash(const int32_t p_int) { return hash_fmix32(p_int); } + static _FORCE_INLINE_ uint32_t hash(const uint16_t p_int) { return hash_fmix32(p_int); } + static _FORCE_INLINE_ uint32_t hash(const int16_t p_int) { return hash_fmix32(p_int); } + static _FORCE_INLINE_ uint32_t hash(const uint8_t p_int) { return hash_fmix32(p_int); } + static _FORCE_INLINE_ uint32_t hash(const int8_t p_int) { return hash_fmix32(p_int); } + + static _FORCE_INLINE_ uint32_t hash(const Vector2i &p_vec) { + uint32_t h = hash_murmur3_one_32(p_vec.x); + h = hash_murmur3_one_32(p_vec.y, h); + return hash_fmix32(h); + } + static _FORCE_INLINE_ uint32_t hash(const Rect2i &p_rect) { + uint32_t h = hash_murmur3_one_32(p_rect.position.x); + h = hash_murmur3_one_32(p_rect.position.y, h); + h = hash_murmur3_one_32(p_rect.size.x, h); + h = hash_murmur3_one_32(p_rect.size.y, h); + return hash_fmix32(h); + } +}; + +template +struct HashMapComparatorDefault { + static bool compare(const T &p_lhs, const T &p_rhs) { + return p_lhs == p_rhs; + } +}; + +template <> +struct HashMapComparatorDefault { + static bool compare(const float &p_lhs, const float &p_rhs) { + return (p_lhs == p_rhs) || (Math::is_nan(p_lhs) && Math::is_nan(p_rhs)); + } +}; + +template <> +struct HashMapComparatorDefault { + static bool compare(const double &p_lhs, const double &p_rhs) { + return (p_lhs == p_rhs) || (Math::is_nan(p_lhs) && Math::is_nan(p_rhs)); + } +}; + +constexpr uint32_t HASH_TABLE_SIZE_MAX = 29; + +const uint32_t hash_table_size_primes[HASH_TABLE_SIZE_MAX] = { + 5, + 13, + 23, + 47, + 97, + 193, + 389, + 769, + 1543, + 3079, + 6151, + 12289, + 24593, + 49157, + 98317, + 196613, + 393241, + 786433, + 1572869, + 3145739, + 6291469, + 12582917, + 25165843, + 50331653, + 100663319, + 201326611, + 402653189, + 805306457, + 1610612741, +}; + +// Computed with elem_i = UINT64_C (0 x FFFFFFFF FFFFFFFF ) / d_i + 1, where d_i is the i-th element of the above array. +const uint64_t hash_table_size_primes_inv[HASH_TABLE_SIZE_MAX] = { + 3689348814741910324, + 1418980313362273202, + 802032351030850071, + 392483916461905354, + 190172619316593316, + 95578984837873325, + 47420935922132524, + 23987963684927896, + 11955116055547344, + 5991147799191151, + 2998982941588287, + 1501077717772769, + 750081082979285, + 375261795343686, + 187625172388393, + 93822606204624, + 46909513691883, + 23456218233098, + 11728086747027, + 5864041509391, + 2932024948977, + 1466014921160, + 733007198436, + 366503839517, + 183251896093, + 91625960335, + 45812983922, + 22906489714, + 11453246088 +}; + +/** + * Fastmod computes ( n mod d ) given the precomputed c much faster than n % d. + * The implementation of fastmod is based on the following paper by Daniel Lemire et al. + * Faster Remainder by Direct Computation: Applications to Compilers and Software Libraries + * https://arxiv.org/abs/1902.01961 + */ +static _FORCE_INLINE_ uint32_t fastmod(const uint32_t n, const uint64_t c, const uint32_t d) { +#if defined(_MSC_VER) + // Returns the upper 64 bits of the product of two 64-bit unsigned integers. + // This intrinsic function is required since MSVC does not support unsigned 128-bit integers. +#if defined(_M_X64) || defined(_M_ARM64) + return __umulh(c * n, d); +#else + // Fallback to the slower method for 32-bit platforms. + return n % d; +#endif // _M_X64 || _M_ARM64 +#else +#ifdef __SIZEOF_INT128__ + // Prevent compiler warning, because we know what we are doing. + uint64_t lowbits = c * n; + __extension__ typedef unsigned __int128 uint128; + return static_cast(((uint128)lowbits * d) >> 64); +#else + // Fallback to the slower method if no 128-bit unsigned integer type is available. + return n % d; +#endif // __SIZEOF_INT128__ +#endif // _MSC_VER +} + +#line 0 + +#line 1 "sfwl/core/pair.h" + +/*************************************************************************/ +/* pair.h */ +/* From https://github.com/Relintai/pandemonium_engine (MIT) */ +/*************************************************************************/ + +template +struct Pair { + F first; + S second; + + Pair() : + first(), + second() { + } + + Pair(F p_first, const S &p_second) : + first(p_first), + second(p_second) { + } +}; + +template +bool operator==(const Pair &pair, const Pair &other) { + return (pair.first == other.first) && (pair.second == other.second); +} + +template +bool operator!=(const Pair &pair, const Pair &other) { + return (pair.first != other.first) || (pair.second != other.second); +} + +template +struct PairSort { + bool operator()(const Pair &A, const Pair &B) const { + if (A.first != B.first) { + return A.first < B.first; + } + return A.second < B.second; + } +}; + +template +struct PairHash { + static uint32_t hash(const Pair &P) { + uint64_t h1 = HashMapHasherDefault::hash(P.first); + uint64_t h2 = HashMapHasherDefault::hash(P.second); + return hash_one_uint64((h1 << 32) | h2); + } +}; + +template +struct KeyValue { + const K key; + V value; + + void operator=(const KeyValue &p_kv) = delete; + _FORCE_INLINE_ KeyValue(const KeyValue &p_kv) : + key(p_kv.key), + value(p_kv.value) { + } + _FORCE_INLINE_ KeyValue(const K &p_key, const V &p_value) : + key(p_key), + value(p_value) { + } +}; + +template +bool operator==(const KeyValue &pair, const KeyValue &other) { + return (pair.key == other.key) && (pair.value == other.value); +} + +template +bool operator!=(const KeyValue &pair, const KeyValue &other) { + return (pair.key != other.key) || (pair.value != other.value); +} + +template +struct KeyValueSort { + bool operator()(const KeyValue &A, const KeyValue &B) const { + return A.key < B.key; + } +}; + +#line 0 + +#line 1 "sfwl/core/og_hash_map.h" + +/*************************************************************************/ +/* og_hash_map.h */ +/* From https://github.com/Relintai/pandemonium_engine (MIT) */ +/*************************************************************************/ + +/** + * @class OGHashMap + * @author Juan Linietsky + * + * Implementation of a standard Hashing HashMap, for quick lookups of Data associated with a Key. + * The implementation provides hashers for the default types, if you need a special kind of hasher, provide + * your own. + * @param TKey Key, search is based on it, needs to be hasheable. It is unique in this container. + * @param TData Data, data associated with the key + * @param Hasher Hasher object, needs to provide a valid static hash function for TKey + * @param Comparator comparator object, needs to be able to safely compare two TKey values. It needs to ensure that x == x for any items inserted in the map. Bear in mind that nan != nan when implementing an equality check. + * @param MIN_HASH_TABLE_POWER Miminum size of the hash table, as a power of two. You rarely need to change this parameter. + * @param RELATIONSHIP Relationship at which the hash table is resized. if amount of elements is RELATIONSHIP + * times bigger than the hash table, table is resized to solve this condition. if RELATIONSHIP is zero, table is always MIN_HASH_TABLE_POWER. + * + */ + +template , uint8_t MIN_HASH_TABLE_POWER = 3, uint8_t RELATIONSHIP = 8> +class OGHashMap { +public: + struct Pair { + TKey key; + TData data; + + Pair(const TKey &p_key) : + key(p_key), + data() {} + Pair(const TKey &p_key, const TData &p_data) : + key(p_key), + data(p_data) { + } + }; + + struct Element { + private: + friend class OGHashMap; + + uint32_t hash; + Element *next; + Element() { next = nullptr; } + Pair pair; + + public: + const TKey &key() const { + return pair.key; + } + + TData &value() { + return pair.data; + } + + const TData &value() const { + return pair.data; + } + + TData &get() { + return pair.data; + }; + const TData &get() const { + return pair.data; + }; + + Element(const TKey &p_key) : + pair(p_key) {} + Element(const Element &p_other) : + hash(p_other.hash), + pair(p_other.pair.key, p_other.pair.data) {} + }; + +private: + Element **hash_table; + uint8_t hash_table_power; + uint32_t elements; + + void make_hash_table() { + ERR_FAIL_COND(hash_table); + + hash_table = memnew_arr(Element *, (1 << MIN_HASH_TABLE_POWER)); + + hash_table_power = MIN_HASH_TABLE_POWER; + elements = 0; + for (int i = 0; i < (1 << MIN_HASH_TABLE_POWER); i++) { + hash_table[i] = nullptr; + } + } + + void erase_hash_table() { + ERR_FAIL_COND_MSG(elements, "Cannot erase hash table if there are still elements inside."); + + memdelete_arr(hash_table); + hash_table = nullptr; + hash_table_power = 0; + elements = 0; + } + + void check_hash_table() { + int new_hash_table_power = -1; + + if ((int)elements > ((1 << hash_table_power) * RELATIONSHIP)) { + /* rehash up */ + new_hash_table_power = hash_table_power + 1; + + while ((int)elements > ((1 << new_hash_table_power) * RELATIONSHIP)) { + new_hash_table_power++; + } + + } else if ((hash_table_power > (int)MIN_HASH_TABLE_POWER) && ((int)elements < ((1 << (hash_table_power - 1)) * RELATIONSHIP))) { + /* rehash down */ + new_hash_table_power = hash_table_power - 1; + + while ((int)elements < ((1 << (new_hash_table_power - 1)) * RELATIONSHIP)) { + new_hash_table_power--; + } + + if (new_hash_table_power < (int)MIN_HASH_TABLE_POWER) { + new_hash_table_power = MIN_HASH_TABLE_POWER; + } + } + + if (new_hash_table_power == -1) { + return; + } + + Element **new_hash_table = memnew_arr(Element *, ((uint64_t)1 << new_hash_table_power)); + ERR_FAIL_COND_MSG(!new_hash_table, "Out of memory."); + + for (int i = 0; i < (1 << new_hash_table_power); i++) { + new_hash_table[i] = nullptr; + } + + if (hash_table) { + for (int i = 0; i < (1 << hash_table_power); i++) { + while (hash_table[i]) { + Element *se = hash_table[i]; + hash_table[i] = se->next; + int new_pos = se->hash & ((1 << new_hash_table_power) - 1); + se->next = new_hash_table[new_pos]; + new_hash_table[new_pos] = se; + } + } + + memdelete_arr(hash_table); + } + hash_table = new_hash_table; + hash_table_power = new_hash_table_power; + } + + /* I want to have only one function.. */ + _FORCE_INLINE_ const Element *get_element(const TKey &p_key) const { + uint32_t hash = Hasher::hash(p_key); + uint32_t index = hash & ((1 << hash_table_power) - 1); + + Element *e = hash_table[index]; + + while (e) { + /* checking hash first avoids comparing key, which may take longer */ + if (e->hash == hash && Comparator::compare(e->pair.key, p_key)) { + /* the pair exists in this hashtable, so just update data */ + return e; + } + + e = e->next; + } + + return nullptr; + } + + Element *create_element(const TKey &p_key) { + /* if element doesn't exist, create it */ + Element *e = memnew(Element(p_key)); + ERR_FAIL_COND_V_MSG(!e, nullptr, "Out of memory."); + uint32_t hash = Hasher::hash(p_key); + uint32_t index = hash & ((1 << hash_table_power) - 1); + e->next = hash_table[index]; + e->hash = hash; + + hash_table[index] = e; + elements++; + + return e; + } + + void copy_from(const OGHashMap &p_t) { + if (&p_t == this) { + return; /* much less bother with that */ + } + + clear(); + + if (!p_t.hash_table || p_t.hash_table_power == 0) { + return; /* not copying from empty table */ + } + + hash_table = memnew_arr(Element *, (uint64_t)1 << p_t.hash_table_power); + hash_table_power = p_t.hash_table_power; + elements = p_t.elements; + + for (int i = 0; i < (1 << p_t.hash_table_power); i++) { + hash_table[i] = nullptr; + + const Element *e = p_t.hash_table[i]; + + while (e) { + Element *le = memnew(Element(*e)); /* local element */ + + /* add to list and reassign pointers */ + le->next = hash_table[i]; + hash_table[i] = le; + + e = e->next; + } + } + } + +public: + Element *set(const TKey &p_key, const TData &p_data) { + return set(Pair(p_key, p_data)); + } + + Element *set(const Pair &p_pair) { + Element *e = nullptr; + if (!hash_table) { + make_hash_table(); // if no table, make one + } else { + e = const_cast(get_element(p_pair.key)); + } + + /* if we made it up to here, the pair doesn't exist, create and assign */ + + if (!e) { + e = create_element(p_pair.key); + if (!e) { + return nullptr; + } + check_hash_table(); // perform mantenience routine + } + + e->pair.data = p_pair.data; + return e; + } + + bool has(const TKey &p_key) const { + return getptr(p_key) != nullptr; + } + + /** + * Get a key from data, return a const reference. + * WARNING: this doesn't check errors, use either getptr and check NULL, or check + * first with has(key) + */ + + const TData &get(const TKey &p_key) const { + const TData *res = getptr(p_key); + CRASH_COND_MSG(!res, "Map key not found."); + return *res; + } + + TData &get(const TKey &p_key) { + TData *res = getptr(p_key); + CRASH_COND_MSG(!res, "Map key not found."); + return *res; + } + + /** + * Same as get, except it can return NULL when item was not found. + * This is mainly used for speed purposes. + */ + + _FORCE_INLINE_ TData *getptr(const TKey &p_key) { + if (unlikely(!hash_table)) { + return nullptr; + } + + Element *e = const_cast(get_element(p_key)); + + if (e) { + return &e->pair.data; + } + + return nullptr; + } + + _FORCE_INLINE_ const TData *getptr(const TKey &p_key) const { + if (unlikely(!hash_table)) { + return nullptr; + } + + const Element *e = const_cast(get_element(p_key)); + + if (e) { + return &e->pair.data; + } + + return nullptr; + } + + const Element *find(const TKey &p_key) const { + if (unlikely(!hash_table)) { + return nullptr; + } + + const Element *e = const_cast(get_element(p_key)); + + return e; + } + + Element *find(const TKey &p_key) { + if (unlikely(!hash_table)) { + return nullptr; + } + + Element *e = const_cast(get_element(p_key)); + + return e; + } + + /** + * Same as get, except it can return NULL when item was not found. + * This version is custom, will take a hash and a custom key (that should support operator==() + */ + + template + _FORCE_INLINE_ TData *custom_getptr(C p_custom_key, uint32_t p_custom_hash) { + if (unlikely(!hash_table)) { + return nullptr; + } + + uint32_t hash = p_custom_hash; + uint32_t index = hash & ((1 << hash_table_power) - 1); + + Element *e = hash_table[index]; + + while (e) { + /* checking hash first avoids comparing key, which may take longer */ + if (e->hash == hash && Comparator::compare(e->pair.key, p_custom_key)) { + /* the pair exists in this hashtable, so just update data */ + return &e->pair.data; + } + + e = e->next; + } + + return nullptr; + } + + template + _FORCE_INLINE_ const TData *custom_getptr(C p_custom_key, uint32_t p_custom_hash) const { + if (unlikely(!hash_table)) { + return NULL; + } + + uint32_t hash = p_custom_hash; + uint32_t index = hash & ((1 << hash_table_power) - 1); + + const Element *e = hash_table[index]; + + while (e) { + /* checking hash first avoids comparing key, which may take longer */ + if (e->hash == hash && Comparator::compare(e->pair.key, p_custom_key)) { + /* the pair exists in this hashtable, so just update data */ + return &e->pair.data; + } + + e = e->next; + } + + return NULL; + } + + /** + * Erase an item, return true if erasing was successful + */ + + bool erase(const TKey &p_key) { + if (unlikely(!hash_table)) { + return false; + } + + uint32_t hash = Hasher::hash(p_key); + uint32_t index = hash & ((1 << hash_table_power) - 1); + + Element *e = hash_table[index]; + Element *p = nullptr; + while (e) { + /* checking hash first avoids comparing key, which may take longer */ + if (e->hash == hash && Comparator::compare(e->pair.key, p_key)) { + if (p) { + p->next = e->next; + } else { + //begin of list + hash_table[index] = e->next; + } + + memdelete(e); + elements--; + + if (elements == 0) { + erase_hash_table(); + } else { + check_hash_table(); + } + return true; + } + + p = e; + e = e->next; + } + + return false; + } + + inline const TData &operator[](const TKey &p_key) const { //constref + + return get(p_key); + } + inline TData &operator[](const TKey &p_key) { //assignment + + Element *e = nullptr; + if (!hash_table) { + make_hash_table(); // if no table, make one + } else { + e = const_cast(get_element(p_key)); + } + + /* if we made it up to here, the pair doesn't exist, create */ + if (!e) { + e = create_element(p_key); + CRASH_COND(!e); + check_hash_table(); // perform mantenience routine + } + + return e->pair.data; + } + + /** + * Get the next key to p_key, and the first key if p_key is null. + * Returns a pointer to the next key if found, NULL otherwise. + * Adding/Removing elements while iterating will, of course, have unexpected results, don't do it. + * + * Example: + * + * const TKey *k=NULL; + * + * while( (k=table.next(k)) ) { + * + * print( *k ); + * } + * + */ + const TKey *next(const TKey *p_key) const { + if (unlikely(!hash_table)) { + return nullptr; + } + + if (!p_key) { /* get the first key */ + + for (int i = 0; i < (1 << hash_table_power); i++) { + if (hash_table[i]) { + return &hash_table[i]->pair.key; + } + } + + } else { /* get the next key */ + + const Element *e = get_element(*p_key); + ERR_FAIL_COND_V_MSG(!e, nullptr, "Invalid key supplied."); + if (e->next) { + /* if there is a "next" in the list, return that */ + return &e->next->pair.key; + } else { + /* go to next elements */ + uint32_t index = e->hash & ((1 << hash_table_power) - 1); + index++; + for (int i = index; i < (1 << hash_table_power); i++) { + if (hash_table[i]) { + return &hash_table[i]->pair.key; + } + } + } + + /* nothing found, was at end */ + } + + return nullptr; /* nothing found */ + } + + inline unsigned int size() const { + return elements; + } + + inline bool empty() const { + return elements == 0; + } + + void clear() { + /* clean up */ + if (hash_table) { + for (int i = 0; i < (1 << hash_table_power); i++) { + while (hash_table[i]) { + Element *e = hash_table[i]; + hash_table[i] = e->next; + memdelete(e); + } + } + + memdelete_arr(hash_table); + } + + hash_table = nullptr; + hash_table_power = 0; + elements = 0; + } + + void operator=(const OGHashMap &p_table) { + copy_from(p_table); + } + + OGHashMap() { + hash_table = nullptr; + elements = 0; + hash_table_power = 0; + } + + void get_key_value_ptr_array(const Pair **p_pairs) const { + if (unlikely(!hash_table)) { + return; + } + for (int i = 0; i < (1 << hash_table_power); i++) { + Element *e = hash_table[i]; + while (e) { + *p_pairs = &e->pair; + p_pairs++; + e = e->next; + } + } + } + + void get_key_list(List *p_keys) const { + if (unlikely(!hash_table)) { + return; + } + for (int i = 0; i < (1 << hash_table_power); i++) { + Element *e = hash_table[i]; + while (e) { + p_keys->push_back(e->pair.key); + e = e->next; + } + } + } + + OGHashMap(const OGHashMap &p_table) { + hash_table = nullptr; + elements = 0; + hash_table_power = 0; + + copy_from(p_table); + } + + ~OGHashMap() { + clear(); + } +}; + +#line 0 + +#line 1 "sfwl/core/ordered_hash_map.h" + +/*************************************************************************/ +/* ordered_hash_map.h */ +/* From https://github.com/Relintai/pandemonium_engine (MIT) */ +/*************************************************************************/ + +/** + * A hash map which allows to iterate elements in insertion order. + * Insertion, lookup, deletion have O(1) complexity. + * The API aims to be consistent with Map rather than HashMap, because the + * former is more frequently used and is more coherent with the rest of the + * codebase. + * Deletion during iteration is safe and will preserve the order. + */ +template , uint8_t MIN_HASH_TABLE_POWER = 3, uint8_t RELATIONSHIP = 8> +class OrderedHashMap { + typedef List> InternalList; + typedef OGHashMap InternalMap; + + InternalList list; + InternalMap map; + +public: + class Element { + friend class OrderedHashMap; + + typename InternalList::Element *list_element; + typename InternalList::Element *prev_element; + typename InternalList::Element *next_element; + + Element(typename InternalList::Element *p_element) { + list_element = p_element; + + if (list_element) { + next_element = list_element->next(); + prev_element = list_element->prev(); + } + } + + public: + _FORCE_INLINE_ Element() : + list_element(nullptr), + prev_element(nullptr), + next_element(nullptr) { + } + + Element next() const { + return Element(next_element); + } + + Element prev() const { + return Element(prev_element); + } + + Element(const Element &other) : + list_element(other.list_element), + prev_element(other.prev_element), + next_element(other.next_element) { + } + + Element &operator=(const Element &other) { + list_element = other.list_element; + next_element = other.next_element; + prev_element = other.prev_element; + return *this; + } + + _FORCE_INLINE_ bool operator==(const Element &p_other) const { + return this->list_element == p_other.list_element; + } + _FORCE_INLINE_ bool operator!=(const Element &p_other) const { + return this->list_element != p_other.list_element; + } + + operator bool() const { + return (list_element != nullptr); + } + + const K &key() const { + CRASH_COND(!list_element); + return *(list_element->get().first); + }; + + V &value() { + CRASH_COND(!list_element); + return list_element->get().second; + }; + + const V &value() const { + CRASH_COND(!list_element); + return list_element->get().second; + }; + + V &get() { + CRASH_COND(!list_element); + return list_element->get().second; + }; + + const V &get() const { + CRASH_COND(!list_element); + return list_element->get().second; + }; + }; + + class ConstElement { + friend class OrderedHashMap; + + const typename InternalList::Element *list_element; + + ConstElement(const typename InternalList::Element *p_element) : + list_element(p_element) { + } + + public: + _FORCE_INLINE_ ConstElement() : + list_element(NULL) { + } + + ConstElement(const ConstElement &other) : + list_element(other.list_element) { + } + + ConstElement &operator=(const ConstElement &other) { + list_element = other.list_element; + return *this; + } + + ConstElement next() const { + return ConstElement(list_element ? list_element->next() : nullptr); + } + + ConstElement prev() const { + return ConstElement(list_element ? list_element->prev() : NULL); + } + + _FORCE_INLINE_ bool operator==(const ConstElement &p_other) const { + return this->list_element == p_other.list_element; + } + _FORCE_INLINE_ bool operator!=(const ConstElement &p_other) const { + return this->list_element != p_other.list_element; + } + + operator bool() const { + return (list_element != nullptr); + } + + const K &key() const { + CRASH_COND(!list_element); + return *(list_element->get().first); + }; + + const V &value() const { + CRASH_COND(!list_element); + return list_element->get().second; + }; + + const V &get() const { + CRASH_COND(!list_element); + return list_element->get().second; + }; + }; + + ConstElement find(const K &p_key) const { + typename InternalList::Element *const *list_element = map.getptr(p_key); + if (list_element) { + return ConstElement(*list_element); + } + return ConstElement(nullptr); + } + + Element find(const K &p_key) { + typename InternalList::Element **list_element = map.getptr(p_key); + if (list_element) { + return Element(*list_element); + } + return Element(nullptr); + } + + Element insert(const K &p_key, const V &p_value) { + typename InternalList::Element **list_element = map.getptr(p_key); + if (list_element) { + (*list_element)->get().second = p_value; + return Element(*list_element); + } + // Incorrectly set the first value of the pair with a value that will + // be invalid as soon as we leave this function... + typename InternalList::Element *new_element = list.push_back(Pair(&p_key, p_value)); + // ...this is needed here in case the hashmap recursively reference itself... + typename InternalMap::Element *e = map.set(p_key, new_element); + // ...now we can set the right value ! + new_element->get().first = &e->key(); + + return Element(new_element); + } + + void erase(Element &p_element) { + map.erase(p_element.key()); + list.erase(p_element.list_element); + p_element.list_element = nullptr; + } + + bool erase(const K &p_key) { + typename InternalList::Element **list_element = map.getptr(p_key); + if (list_element) { + list.erase(*list_element); + map.erase(p_key); + return true; + } + return false; + } + + inline bool has(const K &p_key) const { + return map.has(p_key); + } + + const V &operator[](const K &p_key) const { + ConstElement e = find(p_key); + CRASH_COND(!e); + return e.value(); + } + + V &operator[](const K &p_key) { + Element e = find(p_key); + if (!e) { + // consistent with Map behaviour + e = insert(p_key, V()); + } + return e.value(); + } + + inline Element front() { + return Element(list.front()); + } + + inline Element back() { + return Element(list.back()); + } + + inline ConstElement front() const { + return ConstElement(list.front()); + } + + inline ConstElement back() const { + return ConstElement(list.back()); + } + + inline bool empty() const { return list.empty(); } + inline int size() const { return list.size(); } + + const void *id() const { + return list.id(); + } + + void clear() { + map.clear(); + list.clear(); + } + +private: + void _copy_from(const OrderedHashMap &p_map) { + for (ConstElement E = p_map.front(); E; E = E.next()) { + insert(E.key(), E.value()); + } + } + +public: + void operator=(const OrderedHashMap &p_map) { + _copy_from(p_map); + } + + OrderedHashMap(const OrderedHashMap &p_map) { + _copy_from(p_map); + } + + _FORCE_INLINE_ OrderedHashMap() { + } +}; + +#line 0 + +#line 1 "sfwl/core/hash_map.h" + +/*************************************************************************/ +/* hash_map.h */ +/* From https://github.com/Relintai/pandemonium_engine (MIT) */ +/*************************************************************************/ + +/** + * A HashMap implementation that uses open addressing with Robin Hood hashing. + * Robin Hood hashing swaps out entries that have a smaller probing distance + * than the to-be-inserted entry, that evens out the average probing distance + * and enables faster lookups. Backward shift deletion is employed to further + * improve the performance and to avoid infinite loops in rare cases. + * + * Keys and values are stored in a double linked list by insertion order. This + * has a slight performance overhead on lookup, which can be mostly compensated + * using a paged allocator if required. + * + * The assignment operator copy the pairs from one map to the other. + */ + +template > +class HashMap { +public: + const uint32_t MIN_CAPACITY_INDEX = 2; // Use a prime. + const float MAX_OCCUPANCY = 0.75; + const uint32_t EMPTY_HASH = 0; + +public: + struct Element { + Element *next = nullptr; + Element *prev = nullptr; + KeyValue data; + + const TKey &key() const { + return data.key; + } + + TValue &value() { + return data.value; + } + + const TValue &value() const { + return data.value; + } + + TValue &get() { + return data.value; + }; + const TValue &get() const { + return data.value; + }; + + Element() {} + Element(const TKey &p_key, const TValue &p_value) : + data(p_key, p_value) {} + }; + +public: + _FORCE_INLINE_ uint32_t get_capacity() const { return hash_table_size_primes[capacity_index]; } + _FORCE_INLINE_ uint32_t size() const { return num_elements; } + + /* Standard Godot Container API */ + + bool empty() const { + return num_elements == 0; + } + + void clear() { + if (elements == nullptr || num_elements == 0) { + return; + } + uint32_t capacity = hash_table_size_primes[capacity_index]; + for (uint32_t i = 0; i < capacity; i++) { + if (hashes[i] == EMPTY_HASH) { + continue; + } + + hashes[i] = EMPTY_HASH; + memdelete(elements[i]); + elements[i] = nullptr; + } + + tail_element = nullptr; + head_element = nullptr; + num_elements = 0; + } + + TValue &get(const TKey &p_key) { + uint32_t pos = 0; + bool exists = _lookup_pos(p_key, pos); + CRASH_COND_MSG(!exists, "HashMap key not found."); + return elements[pos]->data.value; + } + + const TValue &get(const TKey &p_key) const { + uint32_t pos = 0; + bool exists = _lookup_pos(p_key, pos); + CRASH_COND_MSG(!exists, "HashMap key not found."); + return elements[pos]->data.value; + } + + const TValue *getptr(const TKey &p_key) const { + uint32_t pos = 0; + bool exists = _lookup_pos(p_key, pos); + + if (exists) { + return &elements[pos]->data.value; + } + return nullptr; + } + + TValue *getptr(const TKey &p_key) { + uint32_t pos = 0; + bool exists = _lookup_pos(p_key, pos); + + if (exists) { + return &elements[pos]->data.value; + } + return nullptr; + } + + const Element *get_element(const TKey &p_key) const { + uint32_t pos = 0; + bool exists = _lookup_pos(p_key, pos); + + if (exists) { + return elements[pos]; + } + + return NULL; + } + + Element *get_element(const TKey &p_key) { + uint32_t pos = 0; + bool exists = _lookup_pos(p_key, pos); + + if (exists) { + return elements[pos]; + } + + return NULL; + } + + _FORCE_INLINE_ const Element *find(const TKey &p_key) const { + return get_element(p_key); + } + + _FORCE_INLINE_ Element *find(const TKey &p_key) { + return get_element(p_key); + } + + /** + * Same as get, except it can return NULL when item was not found. + * This version is custom, will take a hash and a custom key (that should support operator==() + */ + + template + _FORCE_INLINE_ TValue *custom_getptr(C p_custom_key, uint32_t p_custom_hash) { + if (unlikely(!elements)) { + return NULL; + } + + const uint32_t capacity = hash_table_size_primes[capacity_index]; + const uint64_t capacity_inv = hash_table_size_primes_inv[capacity_index]; + uint32_t hash = p_custom_hash; + uint32_t pos = fastmod(hash, capacity_inv, capacity); + uint32_t distance = 0; + + while (true) { + if (hashes[pos] == EMPTY_HASH) { + return NULL; + } + + if (distance > _get_probe_length(pos, hashes[pos], capacity, capacity_inv)) { + return NULL; + } + + if (hashes[pos] == hash && Comparator::compare(elements[pos]->data.key, p_custom_key)) { + return &elements[pos]->data.value; + } + + pos = fastmod((pos + 1), capacity_inv, capacity); + distance++; + } + + return NULL; + } + + template + _FORCE_INLINE_ const TValue *custom_getptr(C p_custom_key, uint32_t p_custom_hash) const { + if (unlikely(!elements)) { + return NULL; + } + + const uint32_t capacity = hash_table_size_primes[capacity_index]; + const uint64_t capacity_inv = hash_table_size_primes_inv[capacity_index]; + uint32_t hash = p_custom_hash; + uint32_t pos = fastmod(hash, capacity_inv, capacity); + uint32_t distance = 0; + + while (true) { + if (hashes[pos] == EMPTY_HASH) { + return NULL; + } + + if (distance > _get_probe_length(pos, hashes[pos], capacity, capacity_inv)) { + return NULL; + } + + if (hashes[pos] == hash && Comparator::compare(elements[pos]->data.key, p_custom_key)) { + return &elements[pos]->data.value; + } + + pos = fastmod((pos + 1), capacity_inv, capacity); + distance++; + } + + return NULL; + } + + _FORCE_INLINE_ bool has(const TKey &p_key) const { + uint32_t _pos = 0; + return _lookup_pos(p_key, _pos); + } + + bool erase(const TKey &p_key) { + uint32_t pos = 0; + bool exists = _lookup_pos(p_key, pos); + + if (!exists) { + return false; + } + + const uint32_t capacity = hash_table_size_primes[capacity_index]; + const uint64_t capacity_inv = hash_table_size_primes_inv[capacity_index]; + uint32_t next_pos = fastmod((pos + 1), capacity_inv, capacity); + while (hashes[next_pos] != EMPTY_HASH && _get_probe_length(next_pos, hashes[next_pos], capacity, capacity_inv) != 0) { + SWAP(hashes[next_pos], hashes[pos]); + SWAP(elements[next_pos], elements[pos]); + pos = next_pos; + next_pos = fastmod((pos + 1), capacity_inv, capacity); + } + + hashes[pos] = EMPTY_HASH; + + if (head_element == elements[pos]) { + head_element = elements[pos]->next; + } + + if (tail_element == elements[pos]) { + tail_element = elements[pos]->prev; + } + + if (elements[pos]->prev) { + elements[pos]->prev->next = elements[pos]->next; + } + + if (elements[pos]->next) { + elements[pos]->next->prev = elements[pos]->prev; + } + + memdelete(elements[pos]); + elements[pos] = nullptr; + + num_elements--; + return true; + } + + // Reserves space for a number of elements, useful to avoid many resizes and rehashes. + // If adding a known (possibly large) number of elements at once, must be larger than old capacity. + void reserve(uint32_t p_new_capacity) { + uint32_t new_index = capacity_index; + + while (hash_table_size_primes[new_index] < p_new_capacity) { + ERR_FAIL_COND_MSG(new_index + 1 == (uint32_t)HASH_TABLE_SIZE_MAX, nullptr); + new_index++; + } + + if (new_index == capacity_index) { + return; + } + + if (elements == nullptr) { + capacity_index = new_index; + return; // Unallocated yet. + } + _resize_and_rehash(new_index); + } + + _FORCE_INLINE_ Element *front() { + return head_element; + } + _FORCE_INLINE_ Element *back() { + return tail_element; + } + + _FORCE_INLINE_ const Element *front() const { + return head_element; + } + _FORCE_INLINE_ const Element *back() const { + return tail_element; + } + + /** + * Get the next key to p_key, and the first key if p_key is null. + * Returns a pointer to the next key if found, NULL otherwise. + * Adding/Removing elements while iterating will, of course, have unexpected results, don't do it. + * + * Example: + * + * const TKey *k=NULL; + * + * while( (k=table.next(k)) ) { + * + * print( *k ); + * } + * + * This is for backwards compatibility. Use this syntax instead for new code: + * + * for (const HashMap::Element *E = map.front(); E; E = E->next) { + * ... + * } + * + */ + const TKey *next(const TKey *p_key) const { + if (unlikely(!elements)) { + return nullptr; + } + + if (!p_key) { /* get the first key */ + + if (unlikely(!front())) { + return nullptr; + } + + return &front()->data.key; + + } else { /* get the next key */ + + const Element *e = get_element(*p_key); + ERR_FAIL_COND_V_MSG(!e, nullptr, "Invalid key supplied."); + if (e->next) { + /* if there is a "next" in the list, return that */ + return &e->next->data.key; + } + + /* nothing found, was at end */ + } + + return nullptr; /* nothing found */ + } + + /* Indexing */ + + const TValue &operator[](const TKey &p_key) const { + uint32_t pos = 0; + bool exists = _lookup_pos(p_key, pos); + CRASH_COND(!exists); + return elements[pos]->data.value; + } + + TValue &operator[](const TKey &p_key) { + uint32_t pos = 0; + bool exists = _lookup_pos(p_key, pos); + if (!exists) { + return _insert(p_key, TValue())->data.value; + } else { + return elements[pos]->data.value; + } + } + + /* Insert */ + + Element *insert(const TKey &p_key, const TValue &p_value, bool p_front_insert = false) { + return _insert(p_key, p_value, p_front_insert); + } + + Element *set(const TKey &p_key, const TValue &p_value, bool p_front_insert = false) { + return _insert(p_key, p_value, p_front_insert); + } + + /* Helpers */ + + void get_key_list(List *p_keys) const { + if (unlikely(!elements)) { + return; + } + + for (const Element *E = front(); E; E = E->next) { + p_keys->push_back(E->data.key); + } + } + + /* Constructors */ + + HashMap(const HashMap &p_other) { + reserve(hash_table_size_primes[p_other.capacity_index]); + + if (p_other.num_elements == 0) { + return; + } + + for (const Element *E = p_other.front(); E; E = E->next) { + insert(E->data.key, E->data.value); + } + } + + void operator=(const HashMap &p_other) { + if (this == &p_other) { + return; // Ignore self assignment. + } + if (num_elements != 0) { + clear(); + } + + reserve(hash_table_size_primes[p_other.capacity_index]); + + if (p_other.elements == nullptr) { + return; // Nothing to copy. + } + + for (const Element *E = p_other.front(); E; E = E->next) { + insert(E->data.key, E->data.value); + } + } + + HashMap(uint32_t p_initial_capacity) { + // Capacity can't be 0. + capacity_index = 0; + reserve(p_initial_capacity); + } + HashMap() { + capacity_index = MIN_CAPACITY_INDEX; + } + + uint32_t debug_get_hash(uint32_t p_index) { + if (num_elements == 0) { + return 0; + } + ERR_FAIL_INDEX_V(p_index, get_capacity(), 0); + return hashes[p_index]; + } + Element *debug_get_element(uint32_t p_index) { + if (num_elements == 0) { + return NULL; + } + + ERR_FAIL_INDEX_V(p_index, get_capacity(), NULL); + + return elements[p_index]; + } + + ~HashMap() { + clear(); + + if (elements != nullptr) { + Memory::free_static(elements); + Memory::free_static(hashes); + } + } + +private: + Element **elements = nullptr; + uint32_t *hashes = nullptr; + Element *head_element = nullptr; + Element *tail_element = nullptr; + + uint32_t capacity_index = 0; + uint32_t num_elements = 0; + + _FORCE_INLINE_ uint32_t _hash(const TKey &p_key) const { + uint32_t hash = Hasher::hash(p_key); + + if (unlikely(hash == EMPTY_HASH)) { + hash = EMPTY_HASH + 1; + } + + return hash; + } + + static _FORCE_INLINE_ uint32_t _get_probe_length(const uint32_t p_pos, const uint32_t p_hash, const uint32_t p_capacity, const uint64_t p_capacity_inv) { + const uint32_t original_pos = fastmod(p_hash, p_capacity_inv, p_capacity); + return fastmod(p_pos - original_pos + p_capacity, p_capacity_inv, p_capacity); + } + + bool _lookup_pos(const TKey &p_key, uint32_t &r_pos) const { + if (elements == nullptr || num_elements == 0) { + return false; // Failed lookups, no elements + } + + const uint32_t capacity = hash_table_size_primes[capacity_index]; + const uint64_t capacity_inv = hash_table_size_primes_inv[capacity_index]; + uint32_t hash = _hash(p_key); + uint32_t pos = fastmod(hash, capacity_inv, capacity); + uint32_t distance = 0; + + while (true) { + if (hashes[pos] == EMPTY_HASH) { + return false; + } + + if (distance > _get_probe_length(pos, hashes[pos], capacity, capacity_inv)) { + return false; + } + + if (hashes[pos] == hash && Comparator::compare(elements[pos]->data.key, p_key)) { + r_pos = pos; + return true; + } + + pos = fastmod((pos + 1), capacity_inv, capacity); + distance++; + } + } + + void _insert_with_hash(uint32_t p_hash, Element *p_value) { + const uint32_t capacity = hash_table_size_primes[capacity_index]; + const uint64_t capacity_inv = hash_table_size_primes_inv[capacity_index]; + uint32_t hash = p_hash; + Element *value = p_value; + uint32_t distance = 0; + uint32_t pos = fastmod(hash, capacity_inv, capacity); + + while (true) { + if (hashes[pos] == EMPTY_HASH) { + elements[pos] = value; + hashes[pos] = hash; + + num_elements++; + + return; + } + + // Not an empty slot, let's check the probing length of the existing one. + uint32_t existing_probe_len = _get_probe_length(pos, hashes[pos], capacity, capacity_inv); + if (existing_probe_len < distance) { + SWAP(hash, hashes[pos]); + SWAP(value, elements[pos]); + distance = existing_probe_len; + } + + pos = fastmod((pos + 1), capacity_inv, capacity); + distance++; + } + } + + void _resize_and_rehash(uint32_t p_new_capacity_index) { + uint32_t old_capacity = hash_table_size_primes[capacity_index]; + + // Capacity can't be 0. + capacity_index = MAX((uint32_t)MIN_CAPACITY_INDEX, p_new_capacity_index); + + uint32_t capacity = hash_table_size_primes[capacity_index]; + + Element **old_elements = elements; + uint32_t *old_hashes = hashes; + + num_elements = 0; + hashes = reinterpret_cast(Memory::alloc_static(sizeof(uint32_t) * capacity)); + elements = reinterpret_cast(Memory::alloc_static(sizeof(Element *) * capacity)); + + for (uint32_t i = 0; i < capacity; i++) { + hashes[i] = 0; + elements[i] = nullptr; + } + + if (old_capacity == 0) { + // Nothing to do. + return; + } + + for (uint32_t i = 0; i < old_capacity; i++) { + if (old_hashes[i] == EMPTY_HASH) { + continue; + } + + _insert_with_hash(old_hashes[i], old_elements[i]); + } + + Memory::free_static(old_elements); + Memory::free_static(old_hashes); + } + + _FORCE_INLINE_ Element *_insert(const TKey &p_key, const TValue &p_value, bool p_front_insert = false) { + uint32_t capacity = hash_table_size_primes[capacity_index]; + if (unlikely(elements == nullptr)) { + // Allocate on demand to save memory. + + hashes = reinterpret_cast(Memory::alloc_static(sizeof(uint32_t) * capacity)); + elements = reinterpret_cast(Memory::alloc_static(sizeof(Element *) * capacity)); + + for (uint32_t i = 0; i < capacity; i++) { + hashes[i] = EMPTY_HASH; + elements[i] = nullptr; + } + } + + uint32_t pos = 0; + bool exists = _lookup_pos(p_key, pos); + + if (exists) { + elements[pos]->data.value = p_value; + return elements[pos]; + } else { + if (num_elements + 1 > MAX_OCCUPANCY * capacity) { + ERR_FAIL_COND_V_MSG(capacity_index + 1 == HASH_TABLE_SIZE_MAX, nullptr, "Hash table maximum capacity reached, aborting insertion."); + _resize_and_rehash(capacity_index + 1); + } + + Element *elem = memnew(Element(p_key, p_value)); + + if (tail_element == nullptr) { + head_element = elem; + tail_element = elem; + } else if (p_front_insert) { + head_element->prev = elem; + elem->next = head_element; + head_element = elem; + } else { + tail_element->next = elem; + elem->prev = tail_element; + tail_element = elem; + } + + uint32_t hash = _hash(p_key); + _insert_with_hash(hash, elem); + return elem; + } + } +}; + +#line 0 + +#line 1 "sfwl/core/hash_set.h" + +/*************************************************************************/ +/* hash_set.h */ +/* From https://github.com/Relintai/pandemonium_engine (MIT) */ +/*************************************************************************/ + +/** + * Implementation of Set using a bidi indexed hash map. + * Use RBSet instead of this only if the following conditions are met: + * + * - You need to keep an iterator or const pointer to Key and you intend to add/remove elements in the meantime. + * - Iteration order does matter (via operator<) + * + */ + +template > +class HashSet { +public: + static constexpr uint32_t MIN_CAPACITY_INDEX = 2; // Use a prime. + static constexpr float MAX_OCCUPANCY = 0.75; + static constexpr uint32_t EMPTY_HASH = 0; + +private: + TKey *keys = nullptr; + uint32_t *hash_to_key = nullptr; + uint32_t *key_to_hash = nullptr; + uint32_t *hashes = nullptr; + + uint32_t capacity_index = 0; + uint32_t num_elements = 0; + + _FORCE_INLINE_ uint32_t _hash(const TKey &p_key) const { + uint32_t hash = Hasher::hash(p_key); + + if (unlikely(hash == EMPTY_HASH)) { + hash = EMPTY_HASH + 1; + } + + return hash; + } + + static _FORCE_INLINE_ uint32_t _get_probe_length(const uint32_t p_pos, const uint32_t p_hash, const uint32_t p_capacity, const uint64_t p_capacity_inv) { + const uint32_t original_pos = fastmod(p_hash, p_capacity_inv, p_capacity); + return fastmod(p_pos - original_pos + p_capacity, p_capacity_inv, p_capacity); + } + + bool _lookup_pos(const TKey &p_key, uint32_t &r_pos) const { + if (keys == nullptr || num_elements == 0) { + return false; // Failed lookups, no elements + } + + const uint32_t capacity = hash_table_size_primes[capacity_index]; + const uint64_t capacity_inv = hash_table_size_primes_inv[capacity_index]; + uint32_t hash = _hash(p_key); + uint32_t pos = fastmod(hash, capacity_inv, capacity); + uint32_t distance = 0; + + while (true) { + if (hashes[pos] == EMPTY_HASH) { + return false; + } + + if (distance > _get_probe_length(pos, hashes[pos], capacity, capacity_inv)) { + return false; + } + + if (hashes[pos] == hash && Comparator::compare(keys[hash_to_key[pos]], p_key)) { + r_pos = hash_to_key[pos]; + return true; + } + + pos = fastmod(pos + 1, capacity_inv, capacity); + distance++; + } + } + + uint32_t _insert_with_hash(uint32_t p_hash, uint32_t p_index) { + const uint32_t capacity = hash_table_size_primes[capacity_index]; + const uint64_t capacity_inv = hash_table_size_primes_inv[capacity_index]; + uint32_t hash = p_hash; + uint32_t index = p_index; + uint32_t distance = 0; + uint32_t pos = fastmod(hash, capacity_inv, capacity); + + while (true) { + if (hashes[pos] == EMPTY_HASH) { + hashes[pos] = hash; + key_to_hash[index] = pos; + hash_to_key[pos] = index; + return pos; + } + + // Not an empty slot, let's check the probing length of the existing one. + uint32_t existing_probe_len = _get_probe_length(pos, hashes[pos], capacity, capacity_inv); + if (existing_probe_len < distance) { + key_to_hash[index] = pos; + SWAP(hash, hashes[pos]); + SWAP(index, hash_to_key[pos]); + distance = existing_probe_len; + } + + pos = fastmod(pos + 1, capacity_inv, capacity); + distance++; + } + } + + void _resize_and_rehash(uint32_t p_new_capacity_index) { + // Capacity can't be 0. + capacity_index = MAX((uint32_t)MIN_CAPACITY_INDEX, p_new_capacity_index); + + uint32_t capacity = hash_table_size_primes[capacity_index]; + + uint32_t *old_hashes = hashes; + uint32_t *old_key_to_hash = key_to_hash; + + hashes = reinterpret_cast(Memory::alloc_static(sizeof(uint32_t) * capacity)); + keys = reinterpret_cast(Memory::realloc_static(keys, sizeof(TKey) * capacity)); + key_to_hash = reinterpret_cast(Memory::alloc_static(sizeof(uint32_t) * capacity)); + hash_to_key = reinterpret_cast(Memory::realloc_static(hash_to_key, sizeof(uint32_t) * capacity)); + + for (uint32_t i = 0; i < capacity; i++) { + hashes[i] = EMPTY_HASH; + } + + for (uint32_t i = 0; i < num_elements; i++) { + uint32_t h = old_hashes[old_key_to_hash[i]]; + _insert_with_hash(h, i); + } + + Memory::free_static(old_hashes); + Memory::free_static(old_key_to_hash); + } + + _FORCE_INLINE_ int32_t _insert(const TKey &p_key) { + uint32_t capacity = hash_table_size_primes[capacity_index]; + if (unlikely(keys == nullptr)) { + // Allocate on demand to save memory. + + hashes = reinterpret_cast(Memory::alloc_static(sizeof(uint32_t) * capacity)); + keys = reinterpret_cast(Memory::alloc_static(sizeof(TKey) * capacity)); + key_to_hash = reinterpret_cast(Memory::alloc_static(sizeof(uint32_t) * capacity)); + hash_to_key = reinterpret_cast(Memory::alloc_static(sizeof(uint32_t) * capacity)); + + for (uint32_t i = 0; i < capacity; i++) { + hashes[i] = EMPTY_HASH; + } + } + + uint32_t pos = 0; + bool exists = _lookup_pos(p_key, pos); + + if (exists) { + return pos; + } else { + if (num_elements + 1 > MAX_OCCUPANCY * capacity) { + ERR_FAIL_COND_V_MSG(capacity_index + 1 == HASH_TABLE_SIZE_MAX, -1, "Hash table maximum capacity reached, aborting insertion."); + _resize_and_rehash(capacity_index + 1); + } + + uint32_t hash = _hash(p_key); + memnew_placement(&keys[num_elements], TKey(p_key)); + _insert_with_hash(hash, num_elements); + num_elements++; + return num_elements - 1; + } + } + + void _init_from(const HashSet &p_other) { + capacity_index = p_other.capacity_index; + num_elements = p_other.num_elements; + + if (p_other.num_elements == 0) { + return; + } + + uint32_t capacity = hash_table_size_primes[capacity_index]; + + hashes = reinterpret_cast(Memory::alloc_static(sizeof(uint32_t) * capacity)); + keys = reinterpret_cast(Memory::alloc_static(sizeof(TKey) * capacity)); + key_to_hash = reinterpret_cast(Memory::alloc_static(sizeof(uint32_t) * capacity)); + hash_to_key = reinterpret_cast(Memory::alloc_static(sizeof(uint32_t) * capacity)); + + for (uint32_t i = 0; i < num_elements; i++) { + memnew_placement(&keys[i], TKey(p_other.keys[i])); + key_to_hash[i] = p_other.key_to_hash[i]; + } + + for (uint32_t i = 0; i < capacity; i++) { + hashes[i] = p_other.hashes[i]; + hash_to_key[i] = p_other.hash_to_key[i]; + } + } + +public: + _FORCE_INLINE_ uint32_t get_capacity() const { return hash_table_size_primes[capacity_index]; } + _FORCE_INLINE_ uint32_t size() const { return num_elements; } + + /* Standard Godot Container API */ + + bool is_empty() const { + return num_elements == 0; + } + + void clear() { + if (keys == nullptr || num_elements == 0) { + return; + } + uint32_t capacity = hash_table_size_primes[capacity_index]; + for (uint32_t i = 0; i < capacity; i++) { + hashes[i] = EMPTY_HASH; + } + for (uint32_t i = 0; i < num_elements; i++) { + keys[i].~TKey(); + } + + num_elements = 0; + } + + _FORCE_INLINE_ bool has(const TKey &p_key) const { + uint32_t _pos = 0; + return _lookup_pos(p_key, _pos); + } + + bool erase(const TKey &p_key) { + uint32_t pos = 0; + bool exists = _lookup_pos(p_key, pos); + + if (!exists) { + return false; + } + + uint32_t key_pos = pos; + pos = key_to_hash[pos]; //make hash pos + + const uint32_t capacity = hash_table_size_primes[capacity_index]; + const uint64_t capacity_inv = hash_table_size_primes_inv[capacity_index]; + uint32_t next_pos = fastmod(pos + 1, capacity_inv, capacity); + while (hashes[next_pos] != EMPTY_HASH && _get_probe_length(next_pos, hashes[next_pos], capacity, capacity_inv) != 0) { + uint32_t kpos = hash_to_key[pos]; + uint32_t kpos_next = hash_to_key[next_pos]; + SWAP(key_to_hash[kpos], key_to_hash[kpos_next]); + SWAP(hashes[next_pos], hashes[pos]); + SWAP(hash_to_key[next_pos], hash_to_key[pos]); + + pos = next_pos; + next_pos = fastmod(pos + 1, capacity_inv, capacity); + } + + hashes[pos] = EMPTY_HASH; + keys[key_pos].~TKey(); + num_elements--; + if (key_pos < num_elements) { + // Not the last key, move the last one here to keep keys lineal + memnew_placement(&keys[key_pos], TKey(keys[num_elements])); + keys[num_elements].~TKey(); + key_to_hash[key_pos] = key_to_hash[num_elements]; + hash_to_key[key_to_hash[num_elements]] = key_pos; + } + + return true; + } + + // Reserves space for a number of elements, useful to avoid many resizes and rehashes. + // If adding a known (possibly large) number of elements at once, must be larger than old capacity. + void reserve(uint32_t p_new_capacity) { + uint32_t new_index = capacity_index; + + while (hash_table_size_primes[new_index] < p_new_capacity) { + ERR_FAIL_COND_MSG(new_index + 1 == (uint32_t)HASH_TABLE_SIZE_MAX, nullptr); + new_index++; + } + + if (new_index == capacity_index) { + return; + } + + if (keys == nullptr) { + capacity_index = new_index; + return; // Unallocated yet. + } + _resize_and_rehash(new_index); + } + + /** Iterator API **/ + + struct Iterator { + _FORCE_INLINE_ const TKey &operator*() const { + return keys[index]; + } + _FORCE_INLINE_ const TKey *operator->() const { + return &keys[index]; + } + _FORCE_INLINE_ Iterator &operator++() { + index++; + if (index >= (int32_t)num_keys) { + index = -1; + keys = nullptr; + num_keys = 0; + } + return *this; + } + _FORCE_INLINE_ Iterator &operator--() { + index--; + if (index < 0) { + index = -1; + keys = nullptr; + num_keys = 0; + } + return *this; + } + + _FORCE_INLINE_ const TKey &key() const { + return keys[index]; + } + _FORCE_INLINE_ const TKey *key_ptr() const { + return &keys[index]; + } + + _FORCE_INLINE_ Iterator &next() { + index++; + if (index >= (int32_t)num_keys) { + index = -1; + keys = nullptr; + num_keys = 0; + } + return *this; + } + _FORCE_INLINE_ Iterator &prev() { + index--; + if (index < 0) { + index = -1; + keys = nullptr; + num_keys = 0; + } + return *this; + } + + _FORCE_INLINE_ bool valid() const { + return keys != nullptr; + } + + _FORCE_INLINE_ bool operator==(const Iterator &b) const { return keys == b.keys && index == b.index; } + _FORCE_INLINE_ bool operator!=(const Iterator &b) const { return keys != b.keys || index != b.index; } + + _FORCE_INLINE_ explicit operator bool() const { + return keys != nullptr; + } + + _FORCE_INLINE_ Iterator(const TKey *p_keys, uint32_t p_num_keys, int32_t p_index = -1) { + keys = p_keys; + num_keys = p_num_keys; + index = p_index; + } + _FORCE_INLINE_ Iterator() {} + _FORCE_INLINE_ Iterator(const Iterator &p_it) { + keys = p_it.keys; + num_keys = p_it.num_keys; + index = p_it.index; + } + _FORCE_INLINE_ void operator=(const Iterator &p_it) { + keys = p_it.keys; + num_keys = p_it.num_keys; + index = p_it.index; + } + + private: + const TKey *keys = nullptr; + uint32_t num_keys = 0; + int32_t index = -1; + }; + + _FORCE_INLINE_ Iterator begin() const { + return num_elements ? Iterator(keys, num_elements, 0) : Iterator(); + } + _FORCE_INLINE_ Iterator end() const { + return Iterator(); + } + _FORCE_INLINE_ Iterator last() const { + if (num_elements == 0) { + return Iterator(); + } + return Iterator(keys, num_elements, num_elements - 1); + } + + _FORCE_INLINE_ Iterator find(const TKey &p_key) const { + uint32_t pos = 0; + bool exists = _lookup_pos(p_key, pos); + if (!exists) { + return end(); + } + return Iterator(keys, num_elements, pos); + } + + _FORCE_INLINE_ void remove(const Iterator &p_iter) { + if (p_iter) { + erase(*p_iter); + } + } + + /* Insert */ + + Iterator insert(const TKey &p_key) { + uint32_t pos = _insert(p_key); + return Iterator(keys, num_elements, pos); + } + + /* Constructors */ + + HashSet(const HashSet &p_other) { + _init_from(p_other); + } + + void operator=(const HashSet &p_other) { + if (this == &p_other) { + return; // Ignore self assignment. + } + + clear(); + + if (keys != nullptr) { + Memory::free_static(keys); + Memory::free_static(key_to_hash); + Memory::free_static(hash_to_key); + Memory::free_static(hashes); + keys = nullptr; + hashes = nullptr; + hash_to_key = nullptr; + key_to_hash = nullptr; + } + + _init_from(p_other); + } + + HashSet(uint32_t p_initial_capacity) { + // Capacity can't be 0. + capacity_index = 0; + reserve(p_initial_capacity); + } + HashSet() { + capacity_index = MIN_CAPACITY_INDEX; + } + + void reset() { + clear(); + + if (keys != nullptr) { + Memory::free_static(keys); + Memory::free_static(key_to_hash); + Memory::free_static(hash_to_key); + Memory::free_static(hashes); + keys = nullptr; + hashes = nullptr; + hash_to_key = nullptr; + key_to_hash = nullptr; + } + capacity_index = MIN_CAPACITY_INDEX; + } + + ~HashSet() { + clear(); + + if (keys != nullptr) { + Memory::free_static(keys); + Memory::free_static(key_to_hash); + Memory::free_static(hash_to_key); + Memory::free_static(hashes); + } + } +}; + +#line 0 + +#line 1 "sfwl/core/file_access.h" + +/*************************************************************************/ +/* file_access.h */ +/* From https://github.com/Relintai/pandemonium_engine (MIT) */ +/*************************************************************************/ + +#if defined(_WIN64) || defined(_WIN32) + +// Mingw +struct _iobuf; +typedef struct _iobuf FILE; + +#elif defined(__APPLE__) + +struct __sFILE; +typedef struct __sFILE FILE; + +typedef void (*FileCloseNotificationFunc)(const String &p_file, int p_flags); + +#else +struct _IO_FILE; +typedef struct _IO_FILE FILE; + +typedef void (*FileCloseNotificationFunc)(const String &p_file, int p_flags); +#endif + +class FileAccess { +public: + typedef void (*FileCloseFailNotify)(const String &); + + bool endian_swap; + bool real_is_double; + + virtual uint32_t _get_unix_permissions(const String &p_file); + virtual Error _set_unix_permissions(const String &p_file, uint32_t p_permissions); + +protected: + String fix_path(const String &p_path) const; + virtual Error _open(const String &p_path, int p_mode_flags); ///< open a file + virtual uint64_t _get_modified_time(const String &p_file); + + static FileCloseFailNotify close_fail_notify; + +private: + static bool backup_save; + +public: + static void set_file_close_fail_notify_callback(FileCloseFailNotify p_cbk) { close_fail_notify = p_cbk; } + + enum ModeFlags { + READ = 1, + WRITE = 2, + READ_WRITE = 3, + WRITE_READ = 7, + }; + + virtual void close(); ///< close a file + virtual bool is_open() const; ///< true when file is open + + virtual String get_path() const; /// returns the path for the current open file + virtual String get_path_absolute() const; /// returns the absolute path for the current open file + + virtual void seek(uint64_t p_position); ///< seek to a given position + virtual void seek_end(int64_t p_position = 0); ///< seek from the end of file with negative offset + virtual uint64_t get_position() const; ///< get position in the file + virtual uint64_t get_len() const; ///< get size of the file + + virtual bool eof_reached() const; ///< reading passed EOF + + virtual uint8_t get_8() const; ///< get a byte + virtual uint16_t get_16() const; ///< get 16 bits uint + virtual uint32_t get_32() const; ///< get 32 bits uint + virtual uint64_t get_64() const; ///< get 64 bits uint + + virtual float get_float() const; + virtual double get_double() const; + virtual real_t get_real() const; + + virtual uint64_t get_buffer(uint8_t *p_dst, uint64_t p_length) const; ///< get an array of bytes + virtual String get_line() const; + virtual String get_token() const; + virtual Vector get_csv_line(const String &p_delim = ",") const; + virtual String get_as_utf8_string(bool p_skip_cr = true) const; // Skip CR by default for compat. + + /**< use this for files WRITTEN in _big_ endian machines (ie, amiga/mac) + * It's not about the current CPU type but file formats. + * this flags get reset to false (little endian) on each open + */ + + virtual void set_endian_swap(bool p_swap) { endian_swap = p_swap; } + inline bool get_endian_swap() const { return endian_swap; } + + virtual Error get_error() const; ///< get last error + + virtual void flush(); + virtual void store_8(uint8_t p_dest); ///< store a byte + virtual void store_16(uint16_t p_dest); ///< store 16 bits uint + virtual void store_32(uint32_t p_dest); ///< store 32 bits uint + virtual void store_64(uint64_t p_dest); ///< store 64 bits uint + + virtual void store_float(float p_dest); + virtual void store_double(double p_dest); + virtual void store_real(real_t p_real); + + virtual void store_string(const String &p_string); + virtual void store_line(const String &p_line); + virtual void store_csv_line(const Vector &p_values, const String &p_delim = ","); + + virtual void store_pascal_string(const String &p_string); + virtual String get_pascal_string(); + + void store_buffer_vec(const Vector &data); ///< store an array of bytes + virtual void store_buffer(const uint8_t *p_src, uint64_t p_length); ///< store an array of bytes + + virtual bool file_exists(const String &p_name); ///< return true if a file exists + + virtual Error reopen(const String &p_path, int p_mode_flags); ///< does not change the AccessType + + Error open(const String &p_path, int p_mode_flags); + + static FileAccess *create(); /// Helper that Creates a file access + static FileAccess *create_and_open(const String &p_path, int p_mode_flags, Error *r_error = nullptr); + static bool exists(const String &p_name); ///< return true if a file exists + static uint64_t get_modified_time(const String &p_file); + static uint32_t get_unix_permissions(const String &p_file); + static Error set_unix_permissions(const String &p_file, uint32_t p_permissions); + + static void set_backup_save(bool p_enable) { backup_save = p_enable; }; + static bool is_backup_save_enabled() { return backup_save; }; + + static Vector get_file_as_array(const String &p_path, Error *r_error = nullptr); + static String get_file_as_string(const String &p_path, Error *r_error = nullptr); + + static void write_file(const String &p_path, const String &data, Error *r_error = nullptr); + static void write_file_buffer(const String &p_path, const Vector &data, Error *r_error = nullptr); + + FileAccess(); + virtual ~FileAccess(); + +#if defined(_WIN64) || defined(_WIN32) +#else + static FileCloseNotificationFunc close_notification_func; +#endif + +protected: +#if defined(_WIN64) || defined(_WIN32) + void check_errors() const; + + FILE *f; + int flags; + mutable int prev_op; + mutable Error last_error; + String path; + String path_src; + String save_path; +#else + void check_errors() const; + + FILE *f; + int flags; + + mutable Error last_error; + String save_path; + String path; + String path_src; +#endif +}; + +struct FileAccessRef { + FileAccess *f; + + _FORCE_INLINE_ bool is_null() const { return f == nullptr; } + _FORCE_INLINE_ bool is_valid() const { return f != nullptr; } + + _FORCE_INLINE_ operator bool() const { return f != nullptr; } + _FORCE_INLINE_ operator FileAccess *() { return f; } + + _FORCE_INLINE_ FileAccess *operator->() { + return f; + } + + FileAccessRef(FileAccess *fa) { f = fa; } + FileAccessRef(FileAccessRef &&other) { + f = other.f; + other.f = nullptr; + } + ~FileAccessRef() { + if (f) { + memdelete(f); + } + } +}; + +#line 0 + +#line 1 "sfwl/core/dir_access.h" + +/*************************************************************************/ +/* dir_access.h */ +/* From https://github.com/Relintai/pandemonium_engine (MIT) */ +/*************************************************************************/ + +#if defined(_WIN64) || defined(_WIN32) +struct DirAccessWindowsPrivate; + +#elif defined(__APPLE__) + +#include + +#else +struct __dirstream; +typedef struct __dirstream DIR; +#endif + +class DirAccess { + Error _copy_dir(DirAccess *p_target_da, String p_to, int p_chmod_flags, bool p_copy_links); + +public: + virtual Error list_dir_begin(bool skip_specials = false); ///< This starts dir listing + virtual String get_next(); + virtual bool current_is_dir() const; + virtual bool current_is_hidden() const; + virtual bool current_is_file() const; + virtual bool current_is_special_dir() const; + + virtual void list_dir_end(); ///< + + virtual int get_drive_count(); + virtual String get_drive(int p_drive); + virtual int get_current_drive(); + virtual bool drives_are_shortcuts(); + + virtual Error change_dir(String p_dir); ///< can be relative or absolute, return false on success + virtual String get_current_dir(); ///< return current dir location + virtual String get_current_dir_without_drive(); + virtual Error make_dir(String p_dir); + virtual Error make_dir_recursive(String p_dir); + virtual Error erase_contents_recursive(); //super dangerous, use with care! + + virtual bool file_exists(String p_file); + virtual bool dir_exists(String p_dir); + static bool exists(String p_dir); + virtual uint64_t get_space_left(); + + Error copy_dir(String p_from, String p_to, int p_chmod_flags = -1, bool p_copy_links = false); + virtual Error copy(String p_from, String p_to, int p_chmod_flags = -1); + virtual Error rename(String p_from, String p_to); + virtual Error remove(String p_name); + + virtual bool is_link(String p_file); + virtual String read_link(String p_file); + virtual Error create_link(String p_source, String p_target); + + virtual uint64_t get_modified_time(String p_file); + + virtual String get_filesystem_type() const; + static String get_full_path(const String &p_path); + + static DirAccess *create_for_path(const String &p_path); + static DirAccess *create(); + + Error open(const String &p_path); + + static String get_filesystem_abspath_for(String p_path); + + static bool is_special(const String &p_path); + + DirAccess(); + virtual ~DirAccess(); + +protected: +#if defined(_WIN64) || defined(_WIN32) +#else + virtual String fix_unicode_name(const char *p_name) const { return String::utf8(p_name); } + virtual bool is_hidden(const String &p_name); +#endif + + bool next_is_dir; + bool _skip_specials; + +#if defined(_WIN64) || defined(_WIN32) + enum { + MAX_DRIVES = 26 + }; + + DirAccessWindowsPrivate *p; + /* Windows stuff */ + + char drives[MAX_DRIVES]; // a-z: + int drive_count; + + String current_dir; + + bool _cisdir; + bool _cishidden; + bool _cisspecial; +#else + String current_dir; + DIR *dir_stream; + + bool _cisdir; + bool _cishidden; + bool _cisspecial; +#endif +}; + +struct DirAccessRef { + DirAccess *f; + + _FORCE_INLINE_ bool is_null() const { return f == nullptr; } + _FORCE_INLINE_ bool is_valid() const { return f != nullptr; } + + _FORCE_INLINE_ operator bool() const { return f != nullptr; } + _FORCE_INLINE_ operator DirAccess *() { return f; } + + _FORCE_INLINE_ DirAccess *operator->() { + return f; + } + + DirAccessRef(DirAccess *fa) { f = fa; } + DirAccessRef(DirAccessRef &&other) { + f = other.f; + other.f = nullptr; + } + ~DirAccessRef() { + if (f) { + memdelete(f); + } + } +}; + +#line 0 + +#line 1 "sfwl/core/inet_address.h" +//Based on: + +// Copyright 2010, Shuo Chen. All rights reserved. +// http://code.google.com/p/muduo/ +// +// Use of this source code is governed by a BSD-style license +// that can be found in the License file. + +// Author: Shuo Chen (chenshuo at chenshuo dot com) +// +// This is a public header file, it must only include public header files. + +// Taken from Muduo and modified +// Copyright 2016, Tao An. All rights reserved. +// https://github.com/an-tao/trantor +// +// Use of this source code is governed by a BSD-style license +// that can be found in the License file. + +// Author: Tao An + +//On windows link to ws2_32 + +#if defined(_WIN64) || defined(_WIN32) +using sa_family_t = unsigned short; +using in_addr_t = uint32_t; +using uint16_t = unsigned short; +#else +#include +#include +#include +#endif + +struct sockaddr_in; +struct sockaddr_in6; + +class InetAddress { +public: + struct InetAddressData; + + sa_family_t family() const; + + String to_ip() const; + String to_ip_port() const; + + uint16_t to_port() const; + + bool is_ip_v6() const; + bool is_intranet_ip() const; + bool is_loopback_ip() const; + + const struct sockaddr *get_sock_addr() const; + + void set_sock_addr_inet6(const struct sockaddr_in6 &addr6); + + uint32_t ip_net_endian() const; + const uint32_t *ip6_net_endian() const; + + uint16_t port_net_endian() const; + + void set_port_net_endian(uint16_t port); + + inline bool is_unspecified() const; + + InetAddress(uint16_t port = 0, bool loopbackOnly = false, bool ipv6 = false); + InetAddress(const String &ip, uint16_t port, bool ipv6 = false); + + explicit InetAddress(const struct sockaddr_in &addr); + explicit InetAddress(const struct sockaddr_in6 &addr); + + ~InetAddress(); + +private: + InetAddressData *_data; + + bool _is_ip_v6; + bool _is_unspecified; +}; + +#line 0 + +#line 1 "sfwl/core/socket.h" + +//Based on: + +/** + * + * Socket.h + * An Tao + * + * Public header file in trantor lib. + * + * Copyright 2018, An Tao. All rights reserved. + * Use of this source code is governed by a BSD-style license + * that can be found in the License file. + * + * + */ + +class Socket { +public: + void create_net_socket(); + void create(int family); + void close_socket(); + + int connect(const InetAddress &address); + int bind_address(const InetAddress &address); + int listen(); + int accept(Socket *sock); + + int close_write(); + + int read(char *buffer, uint64_t len); + int send(const char *buffer, uint64_t len); + + bool is_self_connect(); + + void set_tcp_nodelay(bool on); + void set_reuse_addr(bool on); + int set_reuse_port(bool on); + void set_keep_alive(bool on); + + int set_non_block(); + int set_close_on_exit(); + + int get_error(); + + struct sockaddr_in6 get_local_addr(int *r_err = NULL); + struct sockaddr_in6 get_peer_addr(int *r_err = NULL); + + static int global_init(); + + Socket(); + Socket(int socketFD, const InetAddress &address); + ~Socket(); + + int _socket; + InetAddress _address; +}; + +#line 0 + +#line 1 "sfwl/core/sub_process.h" + +/*************************************************************************/ +/* sub_process.h */ +/* From https://github.com/Relintai/pandemonium_engine (MIT) */ +/*************************************************************************/ + +#if defined(_WIN64) || defined(_WIN32) + +#endif + +/** + * Multi-Platform abstraction for running and communicating with sub processes + */ + +class SubProcess { +public: + typedef int64_t ProcessID; + +#if defined(_WIN64) || defined(_WIN32) + struct SubProcessWindowsData; +#endif + + static SubProcess *create(); + + String get_executable_path() const; + void set_executable_path(const String &p_executable_path); + + Vector get_arguments() const; + void set_arguments(const Vector &p_arguments); + + bool get_blocking() const; + void set_blocking(const bool p_value); + + bool get_read_output() const; + void set_read_output(const bool p_value); + + bool get_read_std() const; + void set_read_std(const bool p_value); + + bool get_read_std_err() const; + void set_read_std_err(const bool p_value); + + bool get_use_pipe_mutex() const; + void set_use_pipe_mutex(const bool p_value); + + bool get_open_console() const; + void set_open_console(const bool p_value); + + String get_data() const { + return _pipe; + } + + int get_process_id() const { + return _process_id; + } + + int get_exitcode() const { + return _exitcode; + } + + virtual Error start(); + virtual Error stop(); + virtual Error poll(); + virtual Error send_signal(const int p_signal); + virtual Error send_data(const String &p_data); + virtual bool is_process_running() const; + + Error run(const String &p_executable_path, const Vector &p_arguments = Vector(), bool p_output = true, bool p_blocking = true, bool p_read_std_err = false, bool p_use_pipe_mutex = false, bool p_open_console = false); + + SubProcess(); + virtual ~SubProcess(); + +protected: + void _setup_pipe_mutex(); + + String _executable_path; + Vector _arguments; + + bool _blocking; + + bool _read_output; + + bool _read_std; + bool _read_std_err; + + String _pipe; + + bool _use_pipe_mutex; + + Mutex *_pipe_mutex; + + bool _open_console; + + ProcessID _process_id; + int _exitcode; + +#if defined(_WIN64) || defined(_WIN32) + + String _quote_command_line_argument(const String &p_text) const; + void _append_to_pipe(char *p_bytes, int p_size); + + bool _process_started; + LocalVector _bytes; + + SubProcessWindowsData *_data; + +#else + FILE *_process_fp; + char _process_buf[65535]; +#endif +}; + +struct SubProcessRef { + SubProcess *f; + + _FORCE_INLINE_ bool is_null() const { return f == nullptr; } + _FORCE_INLINE_ bool is_valid() const { return f != nullptr; } + + _FORCE_INLINE_ operator bool() const { return f != nullptr; } + _FORCE_INLINE_ operator SubProcess *() { return f; } + + _FORCE_INLINE_ SubProcess *operator->() { + return f; + } + + SubProcessRef(SubProcess *fa) { f = fa; } + SubProcessRef(SubProcessRef &&other) { + f = other.f; + other.f = nullptr; + } + ~SubProcessRef() { + if (f) { + memdelete(f); + } + } +}; + +#line 0 + +#line 1 "sfwl/core/sfw_core.h" + +class SFWCore { +public: + static void setup(); + static void cleanup(); + +protected: + static bool _initialized; +}; + +#line 0 + +//=================== OBJECT SECTION =================== + +#line 1 "sfwl/object/ref_ptr.h" + +/*************************************************************************/ +/* ref_ptr.h */ +/* From https://github.com/Relintai/pandemonium_engine (MIT) */ +/*************************************************************************/ + +/** + @author Juan Linietsky + * This class exists to workaround a limitation in C++ but keep the design OK. + * It's basically an opaque container of a Reference reference, so Variant can use it. +*/ + +class RefPtr { + enum { + DATASIZE = sizeof(void *) //*4 -ref was shrunk + }; + + mutable char data[DATASIZE]; // too much probably, virtual class + pointer +public: + bool is_null() const; + void operator=(const RefPtr &p_other); + bool operator==(const RefPtr &p_other) const; + bool operator!=(const RefPtr &p_other) const; + void unref(); + + _FORCE_INLINE_ void *get_data() const { return data; } + RefPtr(const RefPtr &p_other); + RefPtr(); + ~RefPtr(); +}; + +#line 0 + +#line 1 "sfwl/object/object_id.h" + +/*************************************************************************/ +/* object_id.h */ +/* From https://github.com/Relintai/pandemonium_engine (MIT) */ +/*************************************************************************/ + +typedef uint64_t ObjectID; + +#line 0 + +#line 1 "sfwl/object/core_string_names.h" + +/*************************************************************************/ +/* core_string_names.h */ +/* From https://github.com/Relintai/pandemonium_engine (MIT) */ +/*************************************************************************/ + +class CoreStringNames { +public: + static void create() { singleton = memnew(CoreStringNames); } + static void free() { + memdelete(singleton); + singleton = nullptr; + } + + CoreStringNames(); + + _FORCE_INLINE_ static CoreStringNames *get_singleton() { return singleton; } + + static CoreStringNames *singleton; + + StringName _free; + StringName changed; + StringName _meta; + StringName _script; + StringName script_changed; + StringName ___pdcdata; + StringName __getvar; + StringName _iter_init; + StringName _iter_next; + StringName _iter_get; + StringName get_rid; + StringName _to_string; +#ifdef TOOLS_ENABLED + StringName _sections_unfolded; +#endif + StringName _custom_features; + + StringName x; + StringName y; + StringName z; + StringName w; + StringName r; + StringName g; + StringName b; + StringName a; + StringName position; + StringName size; + StringName end; + StringName basis; + StringName origin; + StringName normal; + StringName d; + StringName h; + StringName s; + StringName v; + StringName r8; + StringName g8; + StringName b8; + StringName a8; +}; + +#line 0 + +#line 1 "sfwl/object/array.h" + +/*************************************************************************/ +/* array.h */ +/* From https://github.com/Relintai/pandemonium_engine (MIT) */ +/*************************************************************************/ + +class Variant; +class ArrayPrivate; +class Object; +class StringName; +class String; + +class Array { + mutable ArrayPrivate *_p; + void _ref(const Array &p_from) const; + void _unref() const; + + inline int _clamp_slice_index(int p_index) const; + +public: + Variant &operator[](int p_idx); + const Variant &operator[](int p_idx) const; + + void set(int p_idx, const Variant &p_value); + const Variant &get(int p_idx) const; + + int size() const; + bool empty() const; + void clear(); + + bool deep_equal(const Array &p_array, int p_recursion_count = 0) const; + bool operator==(const Array &p_array) const; + + uint32_t hash() const; + uint32_t recursive_hash(int p_recursion_count) const; + void operator=(const Array &p_array); + + void push_back(const Variant &p_value); + _FORCE_INLINE_ void append(const Variant &p_value) { push_back(p_value); } //for python compatibility + void append_array(const Array &p_array); + Error resize(int p_new_size); + + void insert(int p_pos, const Variant &p_value); + void remove(int p_pos); + void fill(const Variant &p_value); + + Variant front() const; + Variant back() const; + + Array &sort(); + Array &sort_custom(Object *p_obj); + void shuffle(); + int bsearch(const Variant &p_value, bool p_before = true); + int bsearch_custom(const Variant &p_value, Object *p_obj, const StringName &p_function, bool p_before = true); + Array &invert(); + + int find(const Variant &p_value, int p_from = 0) const; + int rfind(const Variant &p_value, int p_from = -1) const; + int find_last(const Variant &p_value) const; + int count(const Variant &p_value) const; + bool has(const Variant &p_value) const; + + void erase(const Variant &p_value); + + void push_front(const Variant &p_value); + Variant pop_back(); + Variant pop_front(); + Variant pop_at(int p_pos); + + Array duplicate(bool p_deep = false) const; + + Array slice(int p_begin, int p_end, int p_step = 1, bool p_deep = false) const; + + Variant min() const; + Variant max() const; + + const void *id() const; + + String sprintf(const String &p_format, bool *error) const; + + Array(const Array &p_from); + Array(); + ~Array(); +}; + +#line 0 + +#line 1 "sfwl/object/dictionary.h" + +/*************************************************************************/ +/* dictionary.h */ +/* From https://github.com/Relintai/pandemonium_engine (MIT) */ +/*************************************************************************/ + +class Variant; + +struct DictionaryPrivate; + +class Dictionary { + mutable DictionaryPrivate *_p; + + void _ref(const Dictionary &p_from) const; + void _unref() const; + +public: + void get_key_list(List *p_keys) const; + Variant get_key_at_index(int p_index) const; + Variant get_value_at_index(int p_index) const; + + Variant &operator[](const Variant &p_key); + const Variant &operator[](const Variant &p_key) const; + + const Variant *getptr(const Variant &p_key) const; + Variant *getptr(const Variant &p_key); + + Variant get_valid(const Variant &p_key) const; + Variant get(const Variant &p_key, const Variant &p_default) const; + + int size() const; + bool empty() const; + void clear(); + void merge(const Dictionary &p_dictionary, bool p_overwrite = false); + + bool has(const Variant &p_key) const; + bool has_all(const Array &p_keys) const; + Variant find_key(const Variant &p_value) const; + + bool erase(const Variant &p_key); + + bool deep_equal(const Dictionary &p_dictionary, int p_recursion_count = 0) const; + bool operator==(const Dictionary &p_dictionary) const; + bool operator!=(const Dictionary &p_dictionary) const; + + uint32_t hash() const; + uint32_t recursive_hash(int p_recursion_count) const; + void operator=(const Dictionary &p_dictionary); + + const Variant *next(const Variant *p_key = nullptr) const; + + Array keys() const; + Array values() const; + + Dictionary duplicate(bool p_deep = false) const; + + const void *id() const; + + Dictionary(const Dictionary &p_from); + Dictionary(); + ~Dictionary(); +}; + +#line 0 + +#line 1 "sfwl/object/variant.h" + +/*************************************************************************/ +/* variant.h */ +/* From https://github.com/Relintai/pandemonium_engine (MIT) */ +/*************************************************************************/ + +class Object; +class ObjectRC; + +typedef PoolVector PoolByteArray; +typedef PoolVector PoolIntArray; +typedef PoolVector PoolRealArray; +typedef PoolVector PoolStringArray; +typedef PoolVector PoolVector2iArray; +typedef PoolVector PoolColorArray; + +// Temporary workaround until c++11 alignas() +#ifdef __GNUC__ +#define GCC_ALIGNED_8 __attribute__((aligned(8))) +#else +#define GCC_ALIGNED_8 +#endif + +#define _REF_OBJ_PTR(m_variant) (reinterpret_cast *>((m_variant)._get_obj().ref.get_data())->ptr()) +#define _OBJ_PTR(m_variant) ((m_variant)._get_obj().rc ? (m_variant)._get_obj().rc->get_ptr() : _REF_OBJ_PTR(m_variant)) +// _UNSAFE_OBJ_PROXY_PTR is needed for comparing an object Variant against NIL or compare two object Variants. +// It's guaranteed to be unique per object, in contrast to the pointer stored in the RC structure, +// which is set to null when the object is destroyed. +#define _UNSAFE_OBJ_PROXY_PTR(m_variant) ((m_variant)._get_obj().rc ? reinterpret_cast((m_variant)._get_obj().rc) : reinterpret_cast(_REF_OBJ_PTR(m_variant))) + +class Variant { +public: + // If this changes the table in variant_op must be updated + enum Type { + + NIL, + + // atomic types + BOOL, + INT, + REAL, + STRING, + + // math types + RECT2I, + VECTOR2I, + + // misc types + COLOR, + OBJECT, + STRING_NAME, + DICTIONARY, + ARRAY, + + // arrays + POOL_BYTE_ARRAY, + POOL_INT_ARRAY, + POOL_REAL_ARRAY, + POOL_STRING_ARRAY, + POOL_VECTOR2I_ARRAY, + POOL_COLOR_ARRAY, + + VARIANT_MAX + + }; + + enum { + // Maximum recursion depth allowed when serializing variants. + MAX_RECURSION_DEPTH = 1024, + }; + +private: + // Variant takes 20 bytes when real_t is float, and 36 if double + // it only allocates extra memory for aabb/matrix. + + Type type; + + struct ObjData { + // Will be null for every type deriving from Reference as they have their + // own reference count mechanism + ObjectRC *rc; + // Always initialized, but will be null if the Ref<> assigned was null + // or this Variant is not even holding a Reference-derived object + RefPtr ref; + }; + + _FORCE_INLINE_ ObjData &_get_obj(); + _FORCE_INLINE_ const ObjData &_get_obj() const; + + union { + bool _bool; + int64_t _int; + double _real; + void *_ptr; //generic pointer + uint8_t _mem[sizeof(ObjData) > (sizeof(real_t) * 4) ? sizeof(ObjData) : (sizeof(real_t) * 4)]; + } _data GCC_ALIGNED_8; + + void reference(const Variant &p_variant); + void clear(); + +public: + _FORCE_INLINE_ Type get_type() const { return type; } + static String get_type_name(Variant::Type p_type); + static bool can_convert(Type p_type_from, Type p_type_to); + static bool can_convert_strict(Type p_type_from, Type p_type_to); + + bool is_ref() const; + _FORCE_INLINE_ bool is_num() const { return type == INT || type == REAL; }; + _FORCE_INLINE_ bool is_array() const { return type >= ARRAY; }; + _FORCE_INLINE_ bool is_null() const { return type == NIL; }; + bool is_shared() const; + bool is_zero() const; + bool is_one() const; + + ObjectID get_object_instance_id() const; + bool is_invalid_object() const; + + operator bool() const; + operator signed int() const; + operator unsigned int() const; // this is the real one + operator signed short() const; + operator unsigned short() const; + operator signed char() const; + operator unsigned char() const; + //operator long unsigned int() const; + operator int64_t() const; + operator uint64_t() const; +#ifdef NEED_LONG_INT + operator signed long() const; + operator unsigned long() const; +#endif + + operator CharType() const; + operator float() const; + operator double() const; + operator String() const; + operator StringName() const; + operator Rect2i() const; + operator Vector2i() const; + + operator Color() const; + operator RefPtr() const; + + operator Object *() const; + + operator Dictionary() const; + operator Array() const; + + operator PoolVector() const; + operator PoolVector() const; + operator PoolVector() const; + operator PoolVector() const; + operator PoolVector() const; + operator PoolVector() const; + + operator Vector() const; + operator Vector() const; + operator Vector() const; + operator Vector() const; + operator Vector() const; + operator Vector() const; + operator Vector() const; + operator Vector() const; + + // some core type enums to convert to + operator Margin() const; + operator Side() const; + operator Orientation() const; + + Variant(bool p_bool); + Variant(signed int p_int); // real one + Variant(unsigned int p_int); +#ifdef NEED_LONG_INT + Variant(signed long p_long); // real one + Variant(unsigned long p_long); +//Variant(long unsigned int p_long); +#endif + Variant(signed short p_short); // real one + Variant(unsigned short p_short); + Variant(signed char p_char); // real one + Variant(unsigned char p_char); + Variant(int64_t p_int); // real one + Variant(uint64_t p_int); + Variant(float p_float); + Variant(double p_double); + Variant(const String &p_string); + Variant(const StringName &p_string); + Variant(const char *const p_cstring); + Variant(const CharType *p_wstring); + Variant(const Vector2i &p_vector2); + Variant(const Rect2i &p_rect2); + Variant(const Color &p_color); + Variant(const RefPtr &p_resource); + Variant(const Object *p_object); + Variant(const Dictionary &p_dictionary); + + Variant(const Array &p_array); + Variant(const PoolVector &p_raw_array); + Variant(const PoolVector &p_int_array); + Variant(const PoolVector &p_real_array); + Variant(const PoolVector &p_string_array); + Variant(const PoolVector &p_color_array); + Variant(const PoolVector &p_vector2_array); + + Variant(const Vector &p_array); + Variant(const Vector &p_array); + Variant(const Vector &p_array); + Variant(const Vector &p_array); + Variant(const Vector &p_array); + Variant(const Vector &p_array); + Variant(const Vector &p_array); + Variant(const Vector &p_array); + + // If this changes the table in variant_op must be updated + enum Operator { + //comparison + OP_EQUAL, + OP_NOT_EQUAL, + OP_LESS, + OP_LESS_EQUAL, + OP_GREATER, + OP_GREATER_EQUAL, + //mathematic + OP_ADD, + OP_SUBTRACT, + OP_MULTIPLY, + OP_DIVIDE, + OP_NEGATE, + OP_POSITIVE, + OP_MODULE, + OP_STRING_CONCAT, + //bitwise + OP_SHIFT_LEFT, + OP_SHIFT_RIGHT, + OP_BIT_AND, + OP_BIT_OR, + OP_BIT_XOR, + OP_BIT_NEGATE, + //logic + OP_AND, + OP_OR, + OP_XOR, + OP_NOT, + //containment + OP_IN, + OP_MAX + }; + + //Maybe add helper methods that use these + //Like max() + //add() + //maybe operators like with add + //? + + static String get_operator_name(Operator p_op); + static void evaluate(const Operator &p_op, const Variant &p_a, const Variant &p_b, Variant &r_ret, bool &r_valid); + static _FORCE_INLINE_ Variant evaluate(const Operator &p_op, const Variant &p_a, const Variant &p_b) { + bool valid = true; + Variant res; + evaluate(p_op, p_a, p_b, res, valid); + return res; + } + + void zero(); + Variant duplicate(bool deep = false) const; + static void blend(const Variant &a, const Variant &b, float c, Variant &r_dst); + static void interpolate(const Variant &a, const Variant &b, float c, Variant &r_dst); + static void sub(const Variant &a, const Variant &b, Variant &r_dst); + + //Maybe add helper methods that call this? like get_x(), set_x() etc Or just x(), x(value)? + //Check if operator[] can take strings and ints that might work too + void set_named(const StringName &p_index, const Variant &p_value, bool *r_valid = nullptr); + Variant get_named(const StringName &p_index, bool *r_valid = nullptr) const; + + //Implement operator[]s that use these? + void set(const Variant &p_index, const Variant &p_value, bool *r_valid = nullptr); + Variant get(const Variant &p_index, bool *r_valid = nullptr) const; + bool in(const Variant &p_index, bool *r_valid = nullptr) const; + + bool iter_init(Variant &r_iter, bool &r_valid) const; + bool iter_next(Variant &r_iter, bool &r_valid) const; + Variant iter_get(const Variant &r_iter, bool &r_valid) const; + + bool deep_equal(const Variant &p_variant, int p_recursion_count = 0) const; + bool operator==(const Variant &p_variant) const; + bool operator!=(const Variant &p_variant) const; + bool operator<(const Variant &p_variant) const; + uint32_t hash() const; + uint32_t recursive_hash(int p_recursion_count) const; + + bool hash_compare(const Variant &p_variant) const; + bool booleanize() const; + String stringify(List &stack) const; + + void operator=(const Variant &p_variant); // only this is enough for all the other types + Variant(const Variant &p_variant); + _FORCE_INLINE_ Variant() { + type = NIL; + } + _FORCE_INLINE_ ~Variant() { + if (type != Variant::NIL) { + clear(); + } + } +}; + +//typedef Dictionary Dictionary; no +//typedef Array Array; + +Vector varray(); +Vector varray(const Variant &p_arg1); +Vector varray(const Variant &p_arg1, const Variant &p_arg2); +Vector varray(const Variant &p_arg1, const Variant &p_arg2, const Variant &p_arg3); +Vector varray(const Variant &p_arg1, const Variant &p_arg2, const Variant &p_arg3, const Variant &p_arg4); +Vector varray(const Variant &p_arg1, const Variant &p_arg2, const Variant &p_arg3, const Variant &p_arg4, const Variant &p_arg5); + +struct VariantHasher { + static _FORCE_INLINE_ uint32_t hash(const Variant &p_variant) { return p_variant.hash(); } +}; + +struct VariantComparator { + static _FORCE_INLINE_ bool compare(const Variant &p_lhs, const Variant &p_rhs) { return p_lhs.hash_compare(p_rhs); } +}; + +Variant::ObjData &Variant::_get_obj() { + return *reinterpret_cast(&_data._mem[0]); +} + +const Variant::ObjData &Variant::_get_obj() const { + return *reinterpret_cast(&_data._mem[0]); +} + +String vformat(const String &p_text, const Variant &p1 = Variant(), const Variant &p2 = Variant(), const Variant &p3 = Variant(), const Variant &p4 = Variant(), const Variant &p5 = Variant()); + +#line 0 + +#line 1 "sfwl/object/psignal.h" + +class Signal { +public: + Object *emitter; + Vector params; + Vector static_data; + + template + void connect(T *obj, void (*func)(T *, Signal *)); + template + void disconnect(T *obj, void (*func)(T *, Signal *)); + template + bool is_connected(T *obj, void (*func)(T *, Signal *)); + + void connect_static(void (*func)(Signal *)); + void disconnect_static(void (*func)(Signal *)); + bool is_connected_static(void (*func)(Signal *)); + + void emit(Object *p_emitter); + void emit(Object *p_emitter, const Variant &p1); + void emit(Object *p_emitter, const Variant &p1, const Variant &p2); + void emit(Object *p_emitter, const Variant &p1, const Variant &p2, const Variant &p3); + void emit(Object *p_emitter, const Variant &p1, const Variant &p2, const Variant &p3, const Variant &p4); + void emit(Object *p_emitter, const Variant &p1, const Variant &p2, const Variant &p3, const Variant &p4, const Variant &p5); + + Signal(); + ~Signal(); + +protected: + enum SignalEntryType { + SIGNAL_ENTRY_TYPE_NONE = 0, + SIGNAL_ENTRY_TYPE_STATIC = 1, + SIGNAL_ENTRY_TYPE_CLASS = 2, + }; + + struct SignalEntry { + SignalEntryType type; + + virtual void call(Signal *s) { + } + + SignalEntry() { + type = SIGNAL_ENTRY_TYPE_NONE; + } + }; + + struct StaticSignalEntry : public SignalEntry { + void (*func)(Signal *); + + virtual void call(Signal *s) { + func(s); + } + + StaticSignalEntry() { + type = SIGNAL_ENTRY_TYPE_STATIC; + func = nullptr; + } + }; + + struct ClassSignalEntry : public SignalEntry { + virtual void *get_obj_ptr() { + return nullptr; + } + + virtual void *get_func_ptr() { + return nullptr; + } + + ClassSignalEntry() { + type = SIGNAL_ENTRY_TYPE_CLASS; + } + }; + + template + struct ClassSignalEntrySpec : public ClassSignalEntry { + union { + T *obj; + void *obj_ptr; + }; + union { + void (*func)(T *, Signal *); + void *func_ptr; + }; + + virtual void call(Signal *s) { + func(obj, s); + } + + void *get_obj_ptr() { + return obj_ptr; + } + + void *get_func_ptr() { + return func_ptr; + } + + ClassSignalEntrySpec() { + obj = nullptr; + func = nullptr; + } + }; + +protected: + Vector entries; +}; + +template +void Signal::connect(T *obj, void (*func)(T *, Signal *)) { + ClassSignalEntrySpec *ce = new ClassSignalEntrySpec(); + ce->obj = obj; + ce->func = func; + + entries.push_back(ce); +} + +template +void Signal::disconnect(T *obj, void (*func)(T *, Signal *)) { + ClassSignalEntrySpec t; + t.obj = obj; + t.func = func; + + void *obj_ptr = t.obj_ptr; + void *func_ptr = t.func_ptr; + + for (int i = 0; i < entries.size(); ++i) { + SignalEntry *e = entries[i]; + + if (e->type == SIGNAL_ENTRY_TYPE_CLASS) { + ClassSignalEntry *se = static_cast(e); + + if (se->get_obj_ptr() == obj_ptr && se->get_func_ptr() == func_ptr) { + entries.remove(i); + return; + } + } + } +} + +template +bool Signal::is_connected(T *obj, void (*func)(T *, Signal *)) { + ClassSignalEntrySpec t; + t.obj = obj; + t.func = func; + + void *obj_ptr = t.obj_ptr; + void *func_ptr = t.func_ptr; + + for (int i = 0; i < entries.size(); ++i) { + SignalEntry *e = entries[i]; + + if (e->type == SIGNAL_ENTRY_TYPE_CLASS) { + ClassSignalEntry *se = static_cast(e); + + if (se->get_obj_ptr() == obj_ptr && se->get_func_ptr() == func_ptr) { + return true; + } + } + } + + return false; +} + +#line 0 + +#line 1 "sfwl/object/object.h" + +/*************************************************************************/ +/* object.h */ +/* From https://github.com/Relintai/pandemonium_engine (MIT) */ +/*************************************************************************/ + +class ObjectRC; + +#define SFW_OBJECT(m_class, m_inherits) \ +private: \ + void operator=(const m_class &p_rval) {} \ + \ +public: \ + virtual String get_class() const { \ + return String(#m_class); \ + } \ + virtual const StringName *_get_class_namev() const { \ + if (!_class_name) \ + _class_name = get_class_static(); \ + return &_class_name; \ + } \ + static void *get_class_ptr_static() { \ + static int ptr; \ + return &ptr; \ + } \ + static String get_class_static() { \ + return String(#m_class); \ + } \ + static String get_parent_class_static() { \ + return m_inherits::get_class_static(); \ + } \ + static void get_inheritance_list_static(Vector *p_inheritance_list) { \ + m_inherits::get_inheritance_list_static(p_inheritance_list); \ + p_inheritance_list->push_back(String(#m_class)); \ + } \ + static String inherits_static() { \ + return String(#m_inherits); \ + } \ + virtual bool is_class(const String &p_class) const { \ + return (p_class == (#m_class)) ? true : m_inherits::is_class(p_class); \ + } \ + virtual bool is_class_ptr(void *p_ptr) const { \ + return (p_ptr == get_class_ptr_static()) ? true : m_inherits::is_class_ptr(p_ptr); \ + } \ + static void get_valid_parents_static(Vector *p_parents) { \ + if (m_class::_get_valid_parents_static != m_inherits::_get_valid_parents_static) { \ + m_class::_get_valid_parents_static(p_parents); \ + } \ + m_inherits::get_valid_parents_static(p_parents); \ + } \ + _FORCE_INLINE_ void (Object::*_get_notification() const)(int) { \ + return (void(Object::*)(int)) & m_class::_notification; \ + } \ + virtual void _notificationv(int p_notification, bool p_reversed) { \ + if (!p_reversed) \ + m_inherits::_notificationv(p_notification, p_reversed); \ + if (m_class::_get_notification() != m_inherits::_get_notification()) { \ + _notification(p_notification); \ + } \ + if (p_reversed) \ + m_inherits::_notificationv(p_notification, p_reversed); \ + } \ + _FORCE_INLINE_ bool (Object::*_get_get() const)(const StringName &p_name, Variant &) const { \ + return (bool(Object::*)(const StringName &, Variant &) const) & m_class::_get; \ + } \ + virtual bool _getv(const StringName &p_name, Variant &r_ret) const { \ + if (m_class::_get_get() != m_inherits::_get_get()) { \ + if (_get(p_name, r_ret)) \ + return true; \ + } \ + return m_inherits::_getv(p_name, r_ret); \ + } \ + _FORCE_INLINE_ bool (Object::*_get_set() const)(const StringName &p_name, const Variant &p_property) { \ + return (bool(Object::*)(const StringName &, const Variant &)) & m_class::_set; \ + } \ + virtual bool _setv(const StringName &p_name, const Variant &p_property) { \ + if (m_inherits::_setv(p_name, p_property)) \ + return true; \ + if (m_class::_get_set() != m_inherits::_get_set()) { \ + return _set(p_name, p_property); \ + } \ + return false; \ + } \ + \ +private: + +class Object { +public: + enum { + NOTIFICATION_POSTINITIALIZE = 0, + NOTIFICATION_PREDELETE = 1 + }; + + void set(const StringName &p_name, const Variant &p_value, bool *r_valid = nullptr); + Variant get(const StringName &p_name, bool *r_valid = nullptr) const; + + //less than. < "operator" used for cutrom sorting Arrays. + virtual bool lt(const Variant &p_value_l, const Variant &p_value_r); + + virtual String get_class() const { return "Object"; } + static void *get_class_ptr_static() { + static int ptr; + return &ptr; + } + + static String get_class_static() { return "Object"; } + static String get_parent_class_static() { return String(); } + + static void get_inheritance_list_static(Vector *p_inheritance_list) { p_inheritance_list->push_back("Object"); } + + virtual bool is_class(const String &p_class) const { return (p_class == "Object"); } + virtual bool is_class_ptr(void *p_ptr) const { return get_class_ptr_static() == p_ptr; } + + static void get_valid_parents_static(Vector *p_parents) {} + static void _get_valid_parents_static(Vector *p_parents) {} + + virtual const StringName *_get_class_namev() const { + if (!_class_name) { + _class_name = get_class_static(); + } + return &_class_name; + } + + _FORCE_INLINE_ const StringName &get_class_name() const { + if (!_class_ptr) { + return *_get_class_namev(); + } else { + return *_class_ptr; + } + } + + ObjectRC *_use_rc(); + + _FORCE_INLINE_ ObjectID get_instance_id() const { + return _instance_id; + } + + void notification(int p_notification, bool p_reversed = false); + virtual String to_string(); + + bool _is_queued_for_deletion; + bool is_queued_for_deletion() const { + return _is_queued_for_deletion; + } + + void cancel_free(); + + bool has_meta(const String &p_name) const; + void set_meta(const String &p_name, const Variant &p_value); + void remove_meta(const String &p_name); + Variant get_meta(const String &p_name, const Variant &p_default = Variant()) const; + void get_meta_list(List *p_list) const; + + Object(); + virtual ~Object(); + + template + static T *cast_to(Object *p_object) { + if (!p_object) + return NULL; + if (p_object->is_class_ptr(T::get_class_ptr_static())) + return static_cast(p_object); + else + return NULL; + } + + template + static const T *cast_to(const Object *p_object) { + if (!p_object) + return NULL; + if (p_object->is_class_ptr(T::get_class_ptr_static())) + return static_cast(p_object); + else + return NULL; + } + +protected: + _FORCE_INLINE_ void (Object::*_get_notification() const)(int) { + return &Object::_notification; + } + + bool _set(const StringName &p_name, const Variant &p_property) { + return false; + }; + bool _get(const StringName &p_name, Variant &r_property) const { + return false; + }; + + virtual bool _setv(const StringName &p_name, const Variant &p_property) { + return false; + }; + virtual bool _getv(const StringName &p_name, Variant &r_property) const { + return false; + }; + + _FORCE_INLINE_ bool (Object::*_get_get() const)(const StringName &p_name, Variant &r_ret) const { + return &Object::_get; + } + _FORCE_INLINE_ bool (Object::*_get_set() const)(const StringName &p_name, const Variant &p_property) { + return &Object::_set; + } + + virtual void _notificationv(int p_notification, bool p_reversed){}; + void _notification(int p_notification){}; + + friend bool predelete_handler(Object *); + friend void postinitialize_handler(Object *); + + int _predelete_ok; + bool _predelete(); + void _postinitialize(); + + mutable StringName _class_name; + mutable const StringName *_class_ptr; + + ObjectID _instance_id; + std::atomic _rc; + + Dictionary metadata; +}; + +bool predelete_handler(Object *p_object); +void postinitialize_handler(Object *p_object); + +class ObjectDB { + struct ObjectPtrHash { + static _FORCE_INLINE_ uint32_t hash(const Object *p_obj) { + union { + const Object *p; + unsigned long i; + } u; + u.p = p_obj; + return HashMapHasherDefault::hash((uint64_t)u.i); + } + }; + + static HashMap instances; + static HashMap instance_checks; + + static ObjectID instance_counter; + friend class Object; + friend void unregister_core_types(); + + static RWLock rw_lock; + static void cleanup(); + static ObjectID add_instance(Object *p_object); + static void remove_instance(Object *p_object); + friend void register_core_types(); + +public: + typedef void (*DebugFunc)(Object *p_obj); + + static Object *get_instance(ObjectID p_instance_id); + static void debug_objects(DebugFunc p_func); + static int get_object_count(); + + // This one may give false positives because a new object may be allocated at the same memory of a previously freed one + _FORCE_INLINE_ static bool instance_validate(Object *p_ptr) { + rw_lock.read_lock(); + + bool exists = instance_checks.has(p_ptr); + + rw_lock.read_unlock(); + + return exists; + } +}; + +#line 0 + +#line 1 "sfwl/object/object_rc.h" + +/*************************************************************************/ +/* object_rc.h */ +/* From https://github.com/Relintai/pandemonium_engine (MIT) */ +/*************************************************************************/ + +class Object; + +// Used to track Variants pointing to a non-Reference Object +class ObjectRC { + std::atomic _ptr; + std::atomic _users; + +public: + // This is for allowing debug builds to check for instance ID validity, + // so warnings are shown in debug builds when a stray Variant (one pointing + // to a released Object) would have happened. + const ObjectID instance_id; + + _FORCE_INLINE_ void increment() { + _users.fetch_add(1, std::memory_order_relaxed); + } + + _FORCE_INLINE_ bool decrement() { + return _users.fetch_sub(1, std::memory_order_relaxed) == 1; + } + + _FORCE_INLINE_ bool invalidate() { + _ptr.store(nullptr, std::memory_order_release); + return decrement(); + } + + _FORCE_INLINE_ Object *get_ptr() { + return _ptr.load(std::memory_order_acquire); + } + + _FORCE_INLINE_ ObjectRC(Object *p_object) : + instance_id(p_object->get_instance_id()) { + // 1 (the Object) + 1 (the first user) + _users.store(2, std::memory_order_relaxed); + _ptr.store(p_object, std::memory_order_release); + } +}; + +#line 0 + +#line 1 "sfwl/object/reference.h" + +/*************************************************************************/ +/* reference.h */ +/* From https://github.com/Relintai/pandemonium_engine (MIT) */ +/*************************************************************************/ + +class Reference : public Object { + SFW_OBJECT(Reference, Object); + +public: + _FORCE_INLINE_ bool is_referenced() const { return refcount_init.get() != 1; } + bool init_ref(); + bool reference(); // returns false if refcount is at zero and didn't get increased + bool unreference(); + int reference_get_count() const; + + Reference(); + virtual ~Reference(); + +private: + SafeRefCount refcount; + SafeRefCount refcount_init; +}; + +template +class Ref { + T *reference; + + void ref(const Ref &p_from) { + if (p_from.reference == reference) { + return; + } + + unref(); + + reference = p_from.reference; + if (reference) { + reference->reference(); + } + } + + void ref_pointer(T *p_ref) { + //ERR_FAIL_COND(!p_ref); + + if (p_ref->init_ref()) { + reference = p_ref; + } + } + + //virtual Reference * get_reference() const { return reference; } +public: + _FORCE_INLINE_ bool operator==(const T *p_ptr) const { + return reference == p_ptr; + } + _FORCE_INLINE_ bool operator!=(const T *p_ptr) const { + return reference != p_ptr; + } + + _FORCE_INLINE_ bool operator<(const Ref &p_r) const { + return reference < p_r.reference; + } + _FORCE_INLINE_ bool operator==(const Ref &p_r) const { + return reference == p_r.reference; + } + _FORCE_INLINE_ bool operator!=(const Ref &p_r) const { + return reference != p_r.reference; + } + + _FORCE_INLINE_ T *operator->() { + return reference; + } + + _FORCE_INLINE_ T *operator*() { + return reference; + } + + _FORCE_INLINE_ const T *operator->() const { + return reference; + } + + _FORCE_INLINE_ const T *ptr() const { + return reference; + } + _FORCE_INLINE_ T *ptr() { + return reference; + } + + _FORCE_INLINE_ const T *operator*() const { + return reference; + } + + void operator=(const Ref &p_from) { + ref(p_from); + } + + template + void operator=(const Ref &p_from) { + Reference *refb = const_cast(static_cast(p_from.ptr())); + if (!refb) { + unref(); + return; + } + Ref r; + r.reference = Object::cast_to(refb); + ref(r); + r.reference = nullptr; + } + + template + void reference_ptr(T_Other *p_ptr) { + if (reference == p_ptr) { + return; + } + unref(); + + T *r = Object::cast_to(p_ptr); + if (r) { + ref_pointer(r); + } + } + + Ref(const Ref &p_from) { + reference = nullptr; + ref(p_from); + } + + template + Ref(const Ref &p_from) { + reference = nullptr; + Reference *refb = const_cast(static_cast(p_from.ptr())); + if (!refb) { + unref(); + return; + } + Ref r; + r.reference = Object::cast_to(refb); + ref(r); + r.reference = nullptr; + } + + Ref(T *p_reference) { + reference = nullptr; + if (p_reference) { + ref_pointer(p_reference); + } + } + + inline bool is_valid() const { return reference != nullptr; } + inline bool is_null() const { return reference == nullptr; } + + void unref() { + //TODO this should be moved to mutexes, since this engine does not really + // do a lot of referencing on references and stuff + // mutexes will avoid more crashes? + + if (reference && reference->unreference()) { + memdelete(reference); + } + reference = nullptr; + } + + void instance() { + ref(memnew(T)); + } + + RefPtr get_ref_ptr() const { + RefPtr refptr; + Ref *irr = reinterpret_cast *>(refptr.get_data()); + *irr = *this; + return refptr; + }; + + operator Variant() const { + return Variant(get_ref_ptr()); + } + + void operator=(const RefPtr &p_refptr) { + Ref *irr = reinterpret_cast *>(p_refptr.get_data()); + Reference *refb = irr->ptr(); + if (!refb) { + unref(); + return; + } + Ref r; + r.reference = Object::cast_to(refb); + ref(r); + r.reference = nullptr; + } + + void operator=(const Variant &p_variant) { + RefPtr refptr = p_variant; + Ref *irr = reinterpret_cast *>(refptr.get_data()); + Reference *refb = irr->ptr(); + if (!refb) { + unref(); + return; + } + Ref r; + r.reference = Object::cast_to(refb); + ref(r); + r.reference = nullptr; + } + + Ref(const Variant &p_variant) { + RefPtr refptr = p_variant; + Ref *irr = reinterpret_cast *>(refptr.get_data()); + reference = nullptr; + Reference *refb = irr->ptr(); + if (!refb) { + unref(); + return; + } + Ref r; + r.reference = Object::cast_to(refb); + ref(r); + r.reference = nullptr; + } + + Ref(const RefPtr &p_refptr) { + Ref *irr = reinterpret_cast *>(p_refptr.get_data()); + reference = nullptr; + Reference *refb = irr->ptr(); + if (!refb) { + unref(); + return; + } + Ref r; + r.reference = Object::cast_to(refb); + ref(r); + r.reference = nullptr; + } + + Ref() { + reference = nullptr; + } + + ~Ref() { + unref(); + } +}; + +typedef Ref REF; + +/* +class WeakRef : public Reference { + SFW_OBJECT(WeakRef, Reference); + + ObjectID ref; + +protected: + static void _bind_methods(); + +public: + void set_obj(Object *p_object); + void set_ref(const REF &p_ref); + + WeakRef(); +}; +*/ + +#line 0 + +#line 1 "sfwl/object/resource.h" + +class Resource : public Reference { + SFW_OBJECT(Resource, Reference); + +public: + Signal changed; + + void emit_changed(); + + virtual Error load(const String &path); + virtual Error save(const String &path); + + Resource(); + virtual ~Resource(); +}; + +#line 0 + +#endif