-#include <cstdlib>

-#include <exception>

-#include <iostream>

-#include <source_location>

-#include <typeinfo>

-#include <zp/mem>

-#include <zp/mth>

-#include <zp/str>

-

-int main() {

- int unsigned num;

- int unsigned numerr = 0x0u;

-

- auto const tst = [&num](char const * const cmp) noexcept {

- ::std::cout << "\n\x1B[38;5;75mtesting\x1B[0m " << cmp << "\n\n";

-

- num = 0x0;

- };

-

- auto const cmp = [&num,&numerr]<typename ltyp,typename rtyp>(ltyp const & lvalref,rtyp const & rvalref,::std::source_location const srcloc = ::std::source_location::current()) {

- char const * const ltypnm = typeid (ltyp).name();

- char const * const rtypnm = typeid (rtyp).name();

-

- auto const getval = []<typename typ>(typ const & valref) {

- if constexpr (::zp::ischr<typ>::val) {return static_cast<::zp::i02m>(valref);}

- else if constexpr (::zp::isptr<typ>::val) {return reinterpret_cast<void *>(valref);}

- else {return valref;}

- };

-

- auto const lval = getval(lvalref);

- auto const rval = getval(rvalref);

-

- ::std::cout << " " << num++ << ". comparing " << ltypnm << " (" << lval << ") vs. " << rtypnm << " (" << rval << ")... ";

-

- if (lval != rval) {

- ::std::cout << "\x1B[38;5;161munequal\x1B[0m (at #" << srcloc.line() << ")\n";

- //throw ::std::exception {};

- ++numerr;

-

- return;

- }

-

- ::std::cout << "\x1B[38;5;77mequal\x1B[0m\n";

- };

-

- ::std::cout << "zp " << ::zp::ver << "." << ::zp::extver << ", run-time test\n";

-

- try {

- [&] {

- tst("vectors");

-

- ::zp::vec2<int> const lvec2 = {

- .x = +0x1,

- .y = -0x3,

- };

- ::zp::vec2<int> const rvec2 = {

- .x = +0x2,

- .y = -0x4,

- };

- cmp(::zp::dot(lvec2,rvec2),0xE);

-

- ::zp::vec3<int> const lvec3 = {

- .x = +0x1,

- .y = -0x3,

- .z = +0x5,

- };

- ::zp::vec3<int> const rvec3 = {

- .x = +0x2,

- .y = -0x4,

- .z = +0x6,

- };

- cmp(::zp::dot(lvec3,rvec3),0x2C);

-

- ::zp::vec4<int> const lvec4 = {

- .x = +0x1,

- .y = -0x3,

- .z = +0x5,

- .w = -0x7,

- };

- ::zp::vec4<int> const rvec4 = {

- .x = +0x2,

- .y = -0x4,

- .z = +0x6,

- .w = -0x8,

- };

- cmp(::zp::dot(lvec4,rvec4),0x64);

-

- auto const avec2 = ::zp::vadd(lvec2,rvec2);

- auto const svec2 = ::zp::vsub(lvec2,rvec2);

- cmp(avec2.x,+0x3);

- cmp(avec2.y,-0x7);

- cmp(svec2.x,-0x1);

- cmp(svec2.y,+0x1);

- }();

-

- [&] {

- tst("special numbers");

-

- cmp(zp_isnanf( zp_nanf), true);

- cmp(zp_isnand( zp_nand), true);

- cmp(zp_isnanld(zp_nanld),true);

- }();

-

- [&] {

- tst("memory sequences");

-

- ::zp::i04 filbuf;

-

- cmp(::zp::memfil(&filbuf,0xFFu,0x8u),reinterpret_cast<unsigned char *>(&filbuf)+0x8u);

- cmp(::zp::memfil(&filbuf,0x7Fu,0x4u),reinterpret_cast<unsigned char *>(&filbuf)+0x4u);

- cmp(::zp::memfil(&filbuf,0x3Fu,0x2u),reinterpret_cast<unsigned char *>(&filbuf)+0x2u);

- cmp(::zp::memfil(&filbuf,0x1Fu,0x1u),reinterpret_cast<unsigned char *>(&filbuf)+0x1u);

-

- cmp(filbuf,0xFFFFFFFF7F7F3F1Fu);

-

- ::zp::i04 cpybuf;

- ::zp::memcpy(&cpybuf,&filbuf,0x8u);

-

- cmp(cpybuf,filbuf);

-

- cmp(::zp::memsrh(&cpybuf,0x1Fu,0x8u),reinterpret_cast<unsigned char *>(&cpybuf));

- }();

-

- [&] {

- tst("strings");

-

- char str[] = "Hello there!";

- wchar_t wstr[] = L"Hello there!";

- char32_t str02[] = U"Hello there!";

-

- ::zp::sz const len = ::zp_strlen( str);

- ::zp::sz const wlen = ::zp_wstrlen( wstr);

- ::zp::sz const len02 = ::zp_utf32len(str02);

-

- cmp(len, 0xCu);

- cmp(wlen, 0xCu);

- cmp(len02,0xCu);

-

- auto const buf = new char[ len];

- auto const wbuf = new wchar_t[ wlen];

- auto const buf02 = new char32_t[len02];

-

- cmp(::zp_strcpy( buf, str), len);

- cmp(::zp_wstrcpy( wbuf, wstr), wlen);

- cmp(::zp_utf32cpy(buf02,str02),len02);

-

- delete[] buf;

- delete[] wbuf;

- delete[] buf02;

- }();

-

- [&] {

- tst("UTF-8");

-

- char32_t const src[] = U"\U0001F480";

-

- ::zp::sz const buf8len = ::zp_utf8enclen(src);

- cmp(buf8len,0x4u);

-

- char8_t * buf8 = new char8_t[buf8len+0x1u];

-

- ::zp_utf8enc(buf8,src);

-

- cmp(buf8[0x0u],0xF0u);

- cmp(buf8[0x1u],0x9Fu);

- cmp(buf8[0x2u],0x92u);

- cmp(buf8[0x3u],0x80u);

- cmp(buf8[0x4u],0x00u);

-

- ::zp::sz const buf02len = ::zp_utf8declen(buf8);

- cmp(buf02len,0x1u);

-

- char32_t * buf02 = new char32_t[buf02len+0x1u];

-

- ::zp_utf8dec(buf02,buf8);

-

- cmp(buf02[0x0u],0x1F480u);

- cmp(buf02[0x1u],0x0u);

-

- delete[] buf8;

- delete[] buf02;

- }();

-

- [&] {

- tst("UTF-16");

-

- char32_t const src[] = U"\U0001F480\u00F0";

-

- ::zp::sz const buf01len = ::zp_utf16enclen(src);

- cmp(buf01len,0x3u);

-

- char16_t * buf01 = new char16_t[buf01len+0x1u];

-

- ::zp_utf16enc(buf01,src);

-

- cmp(buf01[0x0u],0xD83Du);

- cmp(buf01[0x1u],0xDC80u);

- cmp(buf01[0x2u],0x00F0u);

- cmp(buf01[0x3u],0x0000u);

-

- ::zp::sz const buf02len = ::zp_utf16declen(buf01);

- cmp(buf02len,0x2u);

-

- char32_t * buf02 = new char32_t[buf02len+0x1u];

-

- ::zp_utf16dec(buf02,buf01);

-

- cmp(buf02[0x0u],0x1F480u);

- cmp(buf02[0x1u],0xF0u);

- cmp(buf02[0x2u],0x0u);

-

- delete[] buf01;

- delete[] buf02;

- }();

- }

- catch (::std::exception const &) {

- return EXIT_FAILURE;

- }

-

- ::std::cout << "\nDone \u2212 " << numerr << " error(s)\n";

-

- return EXIT_SUCCESS;

-}

-#include <cstdint>

-#include <type_traits>

-#include <zp/mth>

-int main() {

- static_assert([] {

- static_assert(::zp::isptr<int>::val == false);

- static_assert(::zp::isptr<int *>::val == true);

- static_assert(::zp::isptr<int const *>::val == true);

- static_assert(::zp::isptr<int volatile *>::val == true);

- static_assert(::zp::isptr<int const volatile *>::val == true);

- static_assert(::zp::isptr<int * const>::val == true);

- static_assert(::zp::isptr<int const * const>::val == true);

- static_assert(::zp::isptr<int volatile * const>::val == true);

- static_assert(::zp::isptr<int const volatile * const>::val == true);

- static_assert(::zp::isptr<int * volatile>::val == true);

- static_assert(::zp::isptr<int const * volatile>::val == true);

- static_assert(::zp::isptr<int volatile * volatile>::val == true);

- static_assert(::zp::isptr<int const volatile * volatile>::val == true);

- static_assert(::zp::isptr<int * const volatile>::val == true);

- static_assert(::zp::isptr<int const * const volatile>::val == true);

- static_assert(::zp::isptr<int volatile * const volatile>::val == true);

- static_assert(::zp::isptr<int const volatile * const volatile>::val == true);

-

- static_assert(::zp::typequ<int,int>::val == true);

- static_assert(::zp::typequ<int,long>::val == false);

-

- static_assert(::zp::typequ<::zp::sgn<int>::typ, int>::val == true);

- static_assert(::zp::typequ<::zp::sgn<int unsigned>::typ,int>::val == true);

-

- static_assert(::zp::typequ<::zp::usgn<int unsigned>::typ,int unsigned>::val == true);

- static_assert(::zp::typequ<::zp::usgn<int>::typ, int unsigned>::val == true);

-

- static_assert(::zp::typequ<::zp::remqual<int volatile>::typ, int>::val == true);

- static_assert(::zp::typequ<::zp::remqual<int const volatile>::typ,int>::val == true);

-

- static_assert(::zp::typequ<::zp::remqual<int>::typ, int>::val == true);

- static_assert(::zp::typequ<::zp::remqual<int const>::typ, int>::val == true);

- static_assert(::zp::typequ<::zp::remqual<int volatile>::typ, int>::val == true);

- static_assert(::zp::typequ<::zp::remqual<int const volatile>::typ,int>::val == true);

- static_assert(::zp::typequ<::zp::nulptrtyp,::std::nullptr_t>::val == true);

-

- static_assert(::zp::typequ<::zp::i8m, ::std::uint_least8_t>::val == true);

- static_assert(::zp::typequ<::zp::i8ms, ::std::int_least8_t>::val == true);

- static_assert(::zp::typequ<::zp::i01m, ::std::uint_least16_t>::val == true);

- static_assert(::zp::typequ<::zp::i01ms,::std::int_least16_t>::val == true);

- static_assert(::zp::typequ<::zp::i02m, ::std::uint_least32_t>::val == true);

- static_assert(::zp::typequ<::zp::i02ms,::std::int_least32_t>::val == true);

- static_assert(::zp::typequ<::zp::i04m, ::std::uint_least64_t>::val == true);

- static_assert(::zp::typequ<::zp::i04ms,::std::int_least64_t>::val == true);

-

- static_assert(::zp::typequ<::zp::intptr,::std::uintptr_t>::val == true);

- static_assert(::zp::typequ<::zp::sz, ::std::size_t>::val == true);

-

- static_assert(::zp::isusgn<char>::val == ::std::is_unsigned_v<char>);

- static_assert(::zp::isusgn<char16_t>::val == ::std::is_unsigned_v<char16_t>);

- static_assert(::zp::isusgn<char32_t>::val == ::std::is_unsigned_v<char32_t>);

- static_assert(::zp::isusgn<char8_t>::val == ::std::is_unsigned_v<char8_t>);

- static_assert(::zp::isusgn<double>::val == ::std::is_unsigned_v<double>);

- static_assert(::zp::isusgn<float>::val == ::std::is_unsigned_v<float>);

- static_assert(::zp::isusgn<int>::val == ::std::is_unsigned_v<int>);

- static_assert(::zp::isusgn<long>::val == ::std::is_unsigned_v<long>);

- static_assert(::zp::isusgn<long double>::val == ::std::is_unsigned_v<long double>);

- static_assert(::zp::isusgn<long long>::val == ::std::is_unsigned_v<long long>);

- static_assert(::zp::isusgn<short>::val == ::std::is_unsigned_v<short>);

- static_assert(::zp::isusgn<char signed>::val == ::std::is_unsigned_v<char signed>);

- static_assert(::zp::isusgn<char unsigned>::val == ::std::is_unsigned_v<char unsigned>);

- static_assert(::zp::isusgn<int unsigned>::val == ::std::is_unsigned_v<int unsigned>);

- static_assert(::zp::isusgn<long unsigned>::val == ::std::is_unsigned_v<long unsigned>);

- static_assert(::zp::isusgn<long long unsigned>::val == ::std::is_unsigned_v<long long unsigned>);

- static_assert(::zp::isusgn<short unsigned>::val == ::std::is_unsigned_v<short unsigned>);

- static_assert(::zp::isusgn<wchar_t>::val == ::std::is_unsigned_v<wchar_t>);

-

- static_assert(::zp::issgn<char>::val == ::std::is_signed_v<char>);

- static_assert(::zp::issgn<double>::val == ::std::is_signed_v<double>);

- static_assert(::zp::issgn<float>::val == ::std::is_signed_v<float>);

- static_assert(::zp::issgn<int>::val == ::std::is_signed_v<int>);

- static_assert(::zp::issgn<long>::val == ::std::is_signed_v<long>);

- static_assert(::zp::issgn<long double>::val == ::std::is_signed_v<long double>);

- static_assert(::zp::issgn<long long>::val == ::std::is_signed_v<long long>);

- static_assert(::zp::issgn<short>::val == ::std::is_signed_v<short>);

- static_assert(::zp::issgn<char signed>::val == ::std::is_signed_v<char signed>);

- static_assert(::zp::issgn<char unsigned>::val == ::std::is_signed_v<char unsigned>);

- static_assert(::zp::issgn<int unsigned>::val == ::std::is_signed_v<int unsigned>);

- static_assert(::zp::issgn<long unsigned>::val == ::std::is_signed_v<long unsigned>);

- static_assert(::zp::issgn<long long unsigned>::val == ::std::is_signed_v<long long unsigned>);

- static_assert(::zp::issgn<short unsigned>::val == ::std::is_signed_v<short unsigned>);

- static_assert(::zp::issgn<wchar_t>::val == ::std::is_signed_v<wchar_t>);

-

- static_assert(::zp::bytelen == CHAR_BIT);

-

- static_assert(::zp::minval<bool>::val == ::std::numeric_limits<bool>::lowest());

- static_assert(::zp::minval<char>::val == ::std::numeric_limits<char>::lowest());

- static_assert(::zp::minval<char16_t>::val == ::std::numeric_limits<char16_t>::lowest());

- static_assert(::zp::minval<char32_t>::val == ::std::numeric_limits<char32_t>::lowest());

- static_assert(::zp::minval<char8_t>::val == ::std::numeric_limits<char8_t>::lowest());

- static_assert(::zp::minval<double>::val == ::std::numeric_limits<double>::lowest());

- static_assert(::zp::minval<float>::val == ::std::numeric_limits<float>::lowest());

- static_assert(::zp::minval<int>::val == ::std::numeric_limits<int>::lowest());

- static_assert(::zp::minval<long>::val == ::std::numeric_limits<long>::lowest());

- static_assert(::zp::minval<long double>::val == ::std::numeric_limits<long double>::lowest());

- static_assert(::zp::minval<long long>::val == ::std::numeric_limits<long long>::lowest());

- static_assert(::zp::minval<short>::val == ::std::numeric_limits<short>::lowest());

- static_assert(::zp::minval<char signed>::val == ::std::numeric_limits<char signed>::lowest());

- static_assert(::zp::minval<char unsigned>::val == ::std::numeric_limits<char unsigned>::lowest());

- static_assert(::zp::minval<short unsigned>::val == ::std::numeric_limits<short unsigned>::lowest());

- static_assert(::zp::minval<int unsigned>::val == ::std::numeric_limits<int unsigned>::lowest());

- static_assert(::zp::minval<long unsigned>::val == ::std::numeric_limits<long unsigned>::lowest());

- static_assert(::zp::minval<long long unsigned>::val == ::std::numeric_limits<long long unsigned>::lowest());

- static_assert(::zp::minval<wchar_t>::val == ::std::numeric_limits<wchar_t>::lowest());

-

- static_assert(::zp::maxval<bool>::val == ::std::numeric_limits<bool>::max());

- static_assert(::zp::maxval<char>::val == ::std::numeric_limits<char>::max());

- static_assert(::zp::maxval<char16_t>::val == ::std::numeric_limits<char16_t>::max());

- static_assert(::zp::maxval<char32_t>::val == ::std::numeric_limits<char32_t>::max());

- static_assert(::zp::maxval<char8_t>::val == ::std::numeric_limits<char8_t>::max());

- static_assert(::zp::maxval<double>::val == ::std::numeric_limits<double>::max());

- static_assert(::zp::maxval<float>::val == ::std::numeric_limits<float>::max());

- static_assert(::zp::maxval<int>::val == ::std::numeric_limits<int>::max());

- static_assert(::zp::maxval<long>::val == ::std::numeric_limits<long>::max());

- static_assert(::zp::maxval<long double>::val == ::std::numeric_limits<long double>::max());

- static_assert(::zp::maxval<long long>::val == ::std::numeric_limits<long long>::max());

- static_assert(::zp::maxval<short>::val == ::std::numeric_limits<short>::max());

- static_assert(::zp::maxval<char signed>::val == ::std::numeric_limits<char signed>::max());

- static_assert(::zp::maxval<char unsigned>::val == ::std::numeric_limits<char unsigned>::max());

- static_assert(::zp::maxval<short unsigned>::val == ::std::numeric_limits<short unsigned>::max());

- static_assert(::zp::maxval<int unsigned>::val == ::std::numeric_limits<int unsigned>::max());

- static_assert(::zp::maxval<long unsigned>::val == ::std::numeric_limits<long unsigned>::max());

- static_assert(::zp::maxval<long long unsigned>::val == ::std::numeric_limits<long long unsigned>::max());

- static_assert(::zp::maxval<wchar_t>::val == ::std::numeric_limits<wchar_t>::max());

-

- return true;

- }());

-stdc := c99

-stdcxx := c++11

-OBJ_MTH_ABS := source/any/mth/abs.o

-OBJ_MTH_DIVMOD := source/any/mth/divmod.o

-OBJ_MTH_DOT := source/any/mth/dot.o

-OBJ_MTH_VADD := source/any/mth/vadd.o

-OBJ_MTH_VSUB := source/any/mth/vsub.o

- include/zp/bs \

- include/zp/bs.h \

- include/zp/mem \

- include/zp/mem.h \

- include/zp/mth \

- include/zp/mth.h \

- include/zp/str \

- include/zp/str.h \

- include/zp/bs.d/isconsteval.ii \

- include/zp/bs.d/syscl.ii \

- include/zp/bs.d/trp.ii \

- include/zp/bs.d/urch.ii \

- include/zp/mem.d/cpy.ii \

- include/zp/mem.d/equ.ii \

- include/zp/mem.d/fil.ii \

- include/zp/mem.d/memcpy.ii \

- include/zp/mem.d/memequ.ii \

- include/zp/mem.d/memfil.ii \

- include/zp/mem.d/memsrh.ii \

- include/zp/mem.d/srh.ii \

- include/zp/mth.d/abs.ii \

- include/zp/mth.d/dist.ii \

- include/zp/mth.d/divmod.ii \

- include/zp/mth.d/dot.ii \

- include/zp/mth.d/exp.ii \

- include/zp/mth.d/isnan.ii \

- include/zp/mth.d/vadd.ii \

- include/zp/mth.d/vsub.ii \

- include/zp/mth.d/pair/cpair.ii \

- include/zp/mth.d/vec2/cvec.ii \

- include/zp/mth.d/vec3/cvec.ii \

- include/zp/mth.d/vec4/cvec.ii \

- include/zp/prv/arc.h \

- include/zp/prv/chr.h \

- include/zp/prv/flt.h \

- include/zp/prv/imp.h \

- include/zp/prv/int.h \

- include/zp/prv/std.h \

- include/zp/prv/sys.h \

- include/zp/str.d/fmt.ii \

- include/zp/str.d/fmtlen.ii \

- include/zp/str.d/numdig.ii \

- include/zp/str.d/strcpy.ii \

- include/zp/str.d/strequ.ii \

- include/zp/str.d/strlen.ii \

- include/zp/str.d/strsrh.ii \

- include/zp/str.d/utf16dec.ii \

- include/zp/str.d/utf16declen.ii \

- include/zp/str.d/utf16enc.ii \

- include/zp/str.d/utf16enclen.ii \

- include/zp/str.d/utf8dec.ii \

- include/zp/str.d/utf8declen.ii \

- include/zp/str.d/utf8enc.ii \

- include/zp/str.d/utf8enclen.ii \

- include/zp/str.d/win1252dec.ii \

- include/zp/str.d/win1252enc.ii

-CXXFLAGS := \

- -Dzp_prv_nconsteval \

- -Oz \

- -fno-exceptions \

- mkdir -pvm755 "$(HDRDIR)/zp/mth.d/"{"pair","vec2","vec3","vec4"}

- install -vm644 "include/zp/bs.d/"{"isconsteval","syscl","trp","urch"}".ii" "$(HDRDIR)/zp/bs.d"

- install -vm644 "include/zp/mem.d/"{"cpy","equ","fil","memcpy","memequ","memfil","memsrh","srh"}".ii" "$(HDRDIR)/zp/mem.d"

- install -vm644 "include/zp/mth.d/"{"abs","dist","divmod","dot","exp","isnan","vadd","vsub"}".ii" "$(HDRDIR)/zp/mth.d"

- install -vm644 "include/zp/mth.d/pair/cpair.ii" "$(HDRDIR)/zp/mth.d/pair"

- install -vm644 "include/zp/mth.d/vec2/cvec.ii" "$(HDRDIR)/zp/mth.d/vec2"

- install -vm644 "include/zp/mth.d/vec3/cvec.ii" "$(HDRDIR)/zp/mth.d/vec3"

- install -vm644 "include/zp/mth.d/vec4/cvec.ii" "$(HDRDIR)/zp/mth.d/vec4"

- install -vm644 "include/zp/str.d/"{"fmt","fmtlen","numdig","strcpy","strequ","strlen","strsrh","utf16dec","utf16declen","utf16enc","utf16enclen","utf8dec","utf8declen","utf8enc","utf8enclen","win1252dec","win1252enc"}".ii" "$(HDRDIR)/zp/str.d"

-template<typename typ> zp_prv_constexpr auto ::zp::strequ(typ const * lstr,typ const * rstr) zp_prv_nthrw -> bool {

- static_assert(::zp::ischr<typ>::val,"type must be a character type");

- zp_ulik (*lstr == typ {0x0}) {break;}

-inline auto ::zp::trp() zp_prv_nthrw -> void {

- ::zp_trp();

-} \ No newline at end of file

-#error C++ header included from C!

-#if zp_std_cxx14 // C++11 doesn't support void as a return type for translation-time functions.

-#define zp_prv_constexpr constexpr

-#elif zp_std_cxx

-#define zp_prv_constexpr inline

-#endif

-

-#define zp_prv_nthrw noexcept

-#elif zp_std_cxx

-#define zp_prv_nthrw

- using i8m = ::zp_i8m;

- using i8ms = ::zp_i8ms;

- using i01m = ::zp_i01m;

- using i01ms = ::zp_i01ms;

- using i02m = ::zp_i02m;

- using i02ms = ::zp_i02ms;

- using i04m = ::zp_i04m;

- using i04ms = ::zp_i04ms;

- using i8 = ::zp_i8;

- using i8s = ::zp_i8s;

- using i01 = ::zp_i01;

- using i01s = ::zp_i01s;

- using i02 = ::zp_i02;

- using i02s = ::zp_i02s;

- using i04 = ::zp_i04;

- using i04s = ::zp_i04s;

- using i08 = ::zp_i08;

- using i08s = ::zp_i08s;

- using i08 = ::zp_i08;

- using i08s = ::zp_i08s;

- using intptr = ::zp_intptr;

- using sz = ::zp_sz;

- using f01 = ::zp_f01;

- using f02 = ::zp_f02;

- using f04 = ::zp_f04;

- using f08 = ::zp_f08;

- using wchr = ::zp_wchr;

- using c8 = ::zp_c8;

- using c01 = ::zp_c01;

- using c02 = ::zp_c02;

- using sysclid = ::zp_sysclid;

- using sysclres = ::zp_sysclres;

- template<typename typ> struct minval {constexpr static typ val = {};};

- template<> struct minval<char16_t> {constexpr static auto val = zp_minvalc01;};

- template<> struct minval<char32_t> {constexpr static auto val = zp_minvalc02;};

- template<> struct minval<long long> {constexpr static auto val = zp_minvalll;};

- template<> struct minval<long long unsigned> {constexpr static auto val = zp_minvalllu;};

- template<typename typ> struct maxval {constexpr static typ val = {};};

- template<> struct maxval<char16_t> {constexpr static auto val = zp_maxvalc01;};

- template<> struct maxval<char32_t> {constexpr static auto val = zp_maxvalc02;};

- template<> struct maxval<long long> {constexpr static auto val = zp_maxvalll;};

- template<> struct maxval<long long unsigned> {constexpr static auto val = zp_maxvalllu;};

- template<typename ityp> struct sgn {using typ = ityp;};

- template<> struct sgn<char unsigned> {using typ = char signed;};

- template<> struct sgn<int unsigned> {using typ = int;};

- template<> struct sgn<long unsigned> {using typ = long;};

- template<> struct sgn<long long unsigned> {using typ = long long;};

- template<> struct sgn<short unsigned> {using typ = short;};

- template<typename ityp> struct usgn {using typ = ityp;};

- template<> struct usgn<char signed> {using typ = char unsigned;};

- template<> struct usgn<int> {using typ = int unsigned;};

- template<> struct usgn<long> {using typ = long unsigned;};

- template<> struct usgn<long long> {using typ = long long unsigned;};

- template<> struct usgn<short> {using typ = short unsigned;};

- template<typename ityp> struct remqual {using typ = ityp;};

- template<typename ityp> struct remqual<ityp const> {using typ = ityp;};

- template<typename ityp> struct remqual<ityp volatile> {using typ = ityp;};

- template<typename ityp> struct remqual<ityp const volatile> {using typ = ityp;};

- template<typename ltyp,typename rtyp> struct typequ {constexpr static bool val = false;};

- template<typename typ> struct typequ<typ,typ> {constexpr static auto val = true;};

-

- template<typename typ> struct isptr {constexpr static bool val = false;};

-

- template<typename typ> struct isptr<typ *> {constexpr static auto val = true;};

- template<typename typ> struct isptr<typ const *> {constexpr static auto val = true;};

- template<typename typ> struct isptr<typ volatile *> {constexpr static auto val = true;};

- template<typename typ> struct isptr<typ const volatile *> {constexpr static auto val = true;};

- template<typename typ> struct isptr<typ * const> {constexpr static auto val = true;};

- template<typename typ> struct isptr<typ const * const> {constexpr static auto val = true;};

- template<typename typ> struct isptr<typ volatile * const> {constexpr static auto val = true;};

- template<typename typ> struct isptr<typ const volatile * const> {constexpr static auto val = true;};

- template<typename typ> struct isptr<typ * volatile> {constexpr static auto val = true;};

- template<typename typ> struct isptr<typ const * volatile> {constexpr static auto val = true;};

- template<typename typ> struct isptr<typ volatile * volatile> {constexpr static auto val = true;};

- template<typename typ> struct isptr<typ const volatile * volatile> {constexpr static auto val = true;};

- template<typename typ> struct isptr<typ * const volatile> {constexpr static auto val = true;};

- template<typename typ> struct isptr<typ const * const volatile> {constexpr static auto val = true;};

- template<typename typ> struct isptr<typ volatile * const volatile> {constexpr static auto val = true;};

- template<typename typ> struct isptr<typ const volatile * const volatile> {constexpr static auto val = true;};

-

- template<typename typ> struct isusgn {constexpr static bool val = false;};

-

- template<> struct isusgn<char16_t> {constexpr static auto val = true;};

- template<> struct isusgn<char32_t> {constexpr static auto val = true;};

- template<> struct isusgn<char unsigned> {constexpr static auto val = true;};

- template<> struct isusgn<int unsigned> {constexpr static auto val = true;};

- template<> struct isusgn<long unsigned> {constexpr static auto val = true;};

- template<> struct isusgn<long long unsigned> {constexpr static auto val = true;};

- template<> struct isusgn<short unsigned> {constexpr static auto val = true;};

- template<> struct isusgn<char8_t> {constexpr static auto val = true;};

- template<> struct isusgn<char> {constexpr static auto val = true;};

- template<> struct isusgn<wchar_t> {constexpr static auto val = true;};

- template<typename typ> struct issgn {constexpr static bool val = false;};

- template<> struct issgn<double> {constexpr static auto val = true;};

- template<> struct issgn<float> {constexpr static auto val = true;};

- template<> struct issgn<int> {constexpr static auto val = true;};

- template<> struct issgn<long> {constexpr static auto val = true;};

- template<> struct issgn<long double> {constexpr static auto val = true;};

- template<> struct issgn<long long> {constexpr static auto val = true;};

- template<> struct issgn<short> {constexpr static auto val = true;};

- template<> struct issgn<char signed> {constexpr static auto val = true;};

- template<> struct issgn<decltype (0.0bf16)> {constexpr static auto val = true;};

- template<> struct issgn<decltype (0.0f128)> {constexpr static auto val = true;};

- template<> struct issgn<decltype (0.0f16)> {constexpr static auto val = true;};

- template<> struct issgn<decltype (0.0f32)> {constexpr static auto val = true;};

- template<> struct issgn<decltype (0.0f64)> {constexpr static auto val = true;};

- template<> struct issgn<char> {constexpr static auto val = true;};

- template<> struct issgn<wchar_t> {constexpr static auto val = true;};

- template<typename typ> struct isflt {constexpr static bool val = false;};

- template<> struct isflt<double> {constexpr static auto val = true;};

- template<> struct isflt<float> {constexpr static auto val = true;};

- template<> struct isflt<long double> {constexpr static auto val = true;};

- template<> struct isflt<decltype (0.0bf16)> {constexpr static auto val = true;};

- template<> struct isflt<decltype (0.0f128)> {constexpr static auto val = true;};

- template<> struct isflt<decltype (0.0f16)> {constexpr static auto val = true;};

- template<> struct isflt<decltype (0.0f32)> {constexpr static auto val = true;};

- template<> struct isflt<decltype (0.0f64)> {constexpr static auto val = true;};

- template<typename typ> struct isint {constexpr static bool val = false;};

- template<> struct isint<int> {constexpr static auto val = true;};

- template<> struct isint<long> {constexpr static auto val = true;};

- template<> struct isint<long long> {constexpr static auto val = true;};

- template<> struct isint<short> {constexpr static auto val = true;};

- template<> struct isint<char signed> {constexpr static auto val = true;};

- template<> struct isint<char unsigned> {constexpr static auto val = true;};

- template<> struct isint<int unsigned> {constexpr static auto val = true;};

- template<> struct isint<long unsigned> {constexpr static auto val = true;};

- template<> struct isint<long long unsigned> {constexpr static auto val = true;};

- template<> struct isint<short unsigned> {constexpr static auto val = true;};

- template<typename typ> struct isari {constexpr static bool val = ::zp::isflt<typ>::val || ::zp::isint<typ>::val;};

- template<typename typ> struct ischr {constexpr static bool val = false;};

- template<> struct ischr<char> {constexpr static auto val = true;};

- template<> struct ischr<char unsigned> {constexpr static auto val = true;};

- template<> struct ischr<char16_t> {constexpr static auto val = true;};

- template<> struct ischr<char32_t> {constexpr static auto val = true;};

- template<> struct ischr<wchar_t> {constexpr static auto val = true;};

- template<> struct ischr<char8_t> {constexpr static auto val = true;};

- constexpr auto ver = zp_ver;

- constexpr auto extver = zp_extver;

- constexpr auto bytelen = zp_bytelen;

- constexpr auto nopos = zp_nopos;

- constexpr auto unimax = zp_unimax;

- zp_iln constexpr auto isconsteval() zp_prv_nthrw -> bool;

- [[noreturn]] zp_iln inline auto trp() zp_prv_nthrw -> void;

- [[noreturn]] zp_iln inline auto urch() zp_prv_nthrw -> void;

- template<typename... typs> zp_iln inline auto syscl(::zp::sysclid id,typs const &... args) zp_prv_nthrw -> ::zp::sysclres;

-#include <zp/bs.d/syscl.ii>

-#include <zp/bs.d/trp.ii>

-#include <zp/bs.d/urch.ii>

-constexpr auto ::zp::isconsteval() zp_prv_nthrw -> bool {

-#if zp_prv_hasbuiltin(__builtin_is_constant_evaluated)

-// All identifiers in the "priv" namespaces are,

-// well, private, and may not be used by any

-// program (causes UB or something).

-// C99: long long

-

- this could lead to reaching non-zp_prv_constexpr

-#define zp_prv_hasbuiltin(builtin) __has_builtin(builtin)

-#define zp_prv_hasbuiltin(builtin) (0x0)

-#define zp_prv_hasattr(attr) __has_attribute(attr)

-#define zp_prv_hasattr(attr) (0x0)

-// ext: GCC complains when we use __int128 without using "__extension__".

-#ifndef __cplusplus

-#ifndef zp_std_c23

- ISO/IEC 9899:1999 7.16.4 "Notwithstanding the

- provisions of 7.1.3, a program may undefine and

- perhaps then redefine the macros bool, true,

- type (zp_bool), but this is... better. :)

-#define bool _Bool

-#define false (0x0)

-#define true (0x1)

-#endif

-#if zp_imp_gcc

-#define zp_restr __restrict__

-#elif zp_imp_msvc

-#define zp_restr __restrict

-#elif zp_std_c99

-#define zp_restr restrict

-#else

-#define zp_restr

-#if zp_prv_hasbuiltin(__builtin_expect)

-#if zp_prv_hasattr(__noreturn__)

-#if zp_prv_hasattr(__always_inline__)

-#if zp_prv_hasattr(__nothrow__)

-#if zp_prv_hasattr(__const__)

-#if zp_prv_hasattr(__unused__)

-#if zp_prv_hasbuiltin(__builtin_unreachable)

-#if zp_prv_hasattr(__warn_unused_result__)

-/*

- nullptrtyp: The strange type.

-

- In C23 and C++11, the nullptr_t type is a sui

- generis (distinct) type: It is not an

- arithmetic type and has only one valid value,

- yet it may be converted to pointer types and

- bool, the result of which is the null-pointer

- value of that pointer type or false.

-

- However, we define it a little differently: We

- define it as the type of our constant nullptr,

- which may be the standard nullptr_t, but may

- also be a pointer-to-void type (C) or an

- integral type (before C++11). Therefore, we

- don't assert the same limitations/guarantees as

- the standard, except that it may be cast to any

- pointer type, and that such casts results in

- the null-pointer value for that pointer type.

-*/

-

-#elif zp_std_cxx

-#else

-typedef void * zp_nulptrtyp;

-#define zp_ver ((zp_i04m)+0x1u) // Programs expecting this version will still compile with the current extension version.

-#define zp_extver ((zp_i04m)+0x0u) // The extension versions adds functionality without breaking the existing ones.

- // The patch version is not public as it only changes implementation details.

-#if zp_std_c23 || zp_std_cxx

- template<typename dsttyp,typename srctyp> zp_iln inline auto memcpy(dsttyp * zp_restr dst,srctyp const * zp_restr src,::zp::sz const num) zp_prv_nthrw -> ::zp::cpyres<dsttyp,srctyp>;

-

- template<typename ltyp,typename rtyp> zp_useres zp_iln inline auto memequ(ltyp const * lbuf,rtyp const * rbuf,::zp::sz const num) zp_prv_nthrw -> bool;

-

- template<typename typ> zp_iln inline auto memfil(typ * dst,char unsigned val,::zp::sz const num) zp_prv_nthrw -> typ *;

-

- template<typename typ> zp_useres zp_iln inline auto memsrh(typ * buf,char unsigned val,::zp::sz const num) zp_prv_nthrw -> typ *;

- template<typename typ> zp_useres zp_iln inline auto memsrh(typ const * buf,char unsigned val,::zp::sz const num) zp_prv_nthrw -> typ const *;

-

- template<typename typ> zp_prv_constexpr auto cpy(typ * zp_restr dst,typ const * zp_restr src,::zp::sz const num) zp_prv_nthrw -> ::zp::cpyres<typ,typ>;

-

- template<typename typ> zp_useres zp_prv_constexpr auto equ(typ const * lbuf,typ const * rbuf,::zp::sz const num) zp_prv_nthrw -> bool;

-

- template<typename typ> zp_prv_constexpr auto fil(typ * dst,typ const val,::zp::sz const num) zp_prv_nthrw -> typ *;

-

- template<typename typ> zp_useres zp_prv_constexpr auto srh(typ * buf,typ const val,::zp::sz const num) zp_prv_nthrw -> typ *;

- template<typename typ> zp_useres zp_prv_constexpr auto srh(typ const * buf,typ const val,::zp::sz const num) zp_prv_nthrw -> typ const *;

-#include <zp/mem.d/memcpy.ii>

-#include <zp/mem.d/memequ.ii>

-#include <zp/mem.d/memfil.ii>

-#include <zp/mem.d/memsrh.ii>

-template<typename typ> zp_prv_constexpr auto ::zp::cpy(typ * zp_restr dst,typ const * zp_restr src,::zp::sz const num) zp_prv_nthrw -> ::zp::cpyres<typ,typ> {

- typ * const zp_restr stp = dst+num;

- return ::zp::cpyres<typ,typ> {dst,const_cast<typ *>(src),};

-template<typename typ> zp_prv_constexpr auto ::zp::equ(typ const * lbuf,typ const * rbuf,::zp::sz const num) zp_prv_nthrw -> bool {

- typ const * const stp = lbuf+num;

-template<typename typ> zp_prv_constexpr auto ::zp::fil(typ * dst,typ const val,::zp::sz const num) zp_prv_nthrw -> typ * {

- typ * const stp = dst+num;

- while (dst != stp) {*dst++ = val;}

-template<typename dsttyp,typename srctyp> inline auto ::zp::memcpy(dsttyp * zp_restr dst,srctyp const * zp_restr src,::zp::sz const num) zp_prv_nthrw -> ::zp::cpyres<dsttyp,srctyp> {

- return ::zp::cpyres<dsttyp,srctyp> {static_cast<dsttyp *>(cpyres.dst),static_cast<srctyp *>(cpyres.src),};

-/*

- Copyright 2022-2023 Gabriel Jensen.

- This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.

- If a copy of the MPL was not distributed with this file, You can obtain one at <https://mozilla.org/MPL/2.0>.

-*/

-

-template<typename ltyp,typename rtyp> inline auto ::zp::memequ(ltyp const * lbuf,rtyp const * rbuf,::zp::sz const num) zp_prv_nthrw -> bool {

- return ::zp_memequ(lbuf,rbuf,num);

-}

-/*

- Copyright 2022-2023 Gabriel Jensen.

- This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.

- If a copy of the MPL was not distributed with this file, You can obtain one at <https://mozilla.org/MPL/2.0>.

-*/

-

-template<typename typ> inline auto ::zp::memfil(typ * dst,char unsigned const val,::zp::sz const num) zp_prv_nthrw -> typ * {

- return static_cast<typ *>(::zp_memfil(dst,val,num));

-}

-/*

- Copyright 2022-2023 Gabriel Jensen.

- This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.

- If a copy of the MPL was not distributed with this file, You can obtain one at <https://mozilla.org/MPL/2.0>.

-*/

-

-template<typename typ> inline auto ::zp::memsrh(typ * buf,char unsigned const val,::zp::sz const num) zp_prv_nthrw -> typ * {

- return static_cast<typ *>(::zp_memsrh(buf,val,num));

-}

-

-template<typename typ> inline auto ::zp::memsrh(typ const * buf,char unsigned const val,::zp::sz const num) zp_prv_nthrw -> typ const * {

- return const_cast<typ const *>(static_cast<typ *>(::zp_memsrh(buf,val,num)));

-}

-template<typename typ> zp_prv_constexpr auto ::zp::srh(typ * buf,typ val,::zp::sz const num) zp_prv_nthrw -> typ * {

- return const_cast<typ *>(::zp::srh(const_cast<typ const *>(buf),val,num));

-}

-

-template<typename typ> zp_prv_constexpr auto ::zp::srh(typ const * buf,typ const val,::zp::sz const num) zp_prv_nthrw -> typ const * {

- typ const * const stp = buf+num;

- typ const * addr = buf++;

-zp_nthrw struct zp_cpyres zp_memcpy(void * zp_restr dst, void const * zp_restr src, zp_sz num);

- namespace prv {

- template<typename ityp> struct cpairtyp {using typ = void;};

-

- template<> struct cpairtyp<char signed> {using typ = ::zp_pairsc;};

- template<> struct cpairtyp<short> {using typ = ::zp_pairs;};

- template<> struct cpairtyp<int> {using typ = ::zp_pairi;};

- template<> struct cpairtyp<long> {using typ = ::zp_pairl;};

- template<> struct cpairtyp<long long> {using typ = ::zp_pairll;};

- }

-

- template<typename typ> class pair {

- public:

- using ctyp = typename ::zp::prv::cpairtyp<typ>::typ;

-

-

- zp_prv_constexpr auto cpair() const zp_prv_nthrw -> ctyp;

- namespace det {

- template<typename ityp> struct cvec2typ {using typ = void;};

-

- template<> struct cvec2typ<double> {using typ = ::zp_vec2d;};

- template<> struct cvec2typ<float> {using typ = ::zp_vec2f;};

- template<> struct cvec2typ<long double> {using typ = ::zp_vec2ld;};

-

- template<typename ityp> struct cvec3typ {using typ = void;};

-

- template<> struct cvec3typ<double> {using typ = ::zp_vec3d;};

- template<> struct cvec3typ<float> {using typ = ::zp_vec3f;};

- template<> struct cvec3typ<long double> {using typ = ::zp_vec3ld;};

-

- template<typename ityp> struct cvec4typ {using typ = void;};

-

- template<> struct cvec4typ<double> {using typ = ::zp_vec4d;};

- template<> struct cvec4typ<float> {using typ = ::zp_vec4f;};

- template<> struct cvec4typ<long double> {using typ = ::zp_vec4ld;};

- }

-

- template<typename typ> class vec2 {

- public:

- using ctyp = typename ::zp::det::cvec2typ<typ>::typ;

-

-

- zp_prv_constexpr auto cvec() const zp_prv_nthrw -> ctyp;

- template<typename typ> class vec3 {

- public:

- using ctyp = typename ::zp::det::cvec3typ<typ>::typ;

-

-

- zp_prv_constexpr auto cvec() const zp_prv_nthrw -> ctyp;

- template<typename typ> class vec4 {

- public:

- using ctyp = typename ::zp::det::cvec4typ<typ>::typ;

-

-

- zp_prv_constexpr auto cvec() const zp_prv_nthrw -> ctyp;

- template<typename typ> zp_prv_constexpr auto abs(typ val) zp_prv_nthrw -> typename ::zp::usgn<typ>::typ;

-

- template<typename typ> zp_prv_constexpr auto acos(typ val) zp_prv_nthrw -> typ;

-

- template<typename typ> zp_prv_constexpr auto asin(typ val) zp_prv_nthrw -> typ;

-

- template<typename typ> zp_prv_constexpr auto atan(typ val) zp_prv_nthrw -> typ;

-

- template<typename typ> zp_prv_constexpr auto cbrt(typ val) zp_prv_nthrw -> typ;

-

- template<typename typ> zp_prv_constexpr auto cos(typ val) zp_prv_nthrw -> typ;

-

- template<typename typ> zp_prv_constexpr auto dist(typ x,typ y) zp_prv_nthrw -> typ;

- template<typename typ> zp_prv_constexpr auto dist(typ x,typ y,typ z) zp_prv_nthrw -> typ;

- template<typename typ> zp_prv_constexpr auto dist(typ x,typ y,typ z,typ w) zp_prv_nthrw -> typ;

-

- template<typename typ> zp_prv_constexpr auto divmod(typ num,typ den) zp_prv_nthrw -> ::zp::pair<typ>;

-

- template<typename typ> zp_prv_constexpr auto dot(::zp::vec2<typ> lvec,::zp::vec2<typ> rvec) zp_prv_nthrw -> typ;

- template<typename typ> zp_prv_constexpr auto dot(::zp::vec3<typ> lvec,::zp::vec3<typ> rvec) zp_prv_nthrw -> typ;

- template<typename typ> zp_prv_constexpr auto dot(::zp::vec4<typ> lvec,::zp::vec4<typ> rvec) zp_prv_nthrw -> typ;

-

- template<typename typ> zp_prv_constexpr auto exp(typ val,typ n) zp_prv_nthrw -> typ;

-

- template<typename typ> zp_prv_constexpr auto isnan(typ val) zp_prv_nthrw -> bool;

-

- template<typename typ> zp_prv_constexpr auto lb(typ val) zp_prv_nthrw -> typ;

-

- template<typename typ> zp_prv_constexpr auto lg(typ val) zp_prv_nthrw -> typ;

-

- template<typename typ> zp_prv_constexpr auto ln(typ val) zp_prv_nthrw -> typ;

-

- template<typename typ> zp_prv_constexpr auto log(typ val) zp_prv_nthrw -> typ;

-

- template<typename typ> zp_prv_constexpr auto nrt(typ val) zp_prv_nthrw -> typ;

-

- template<typename typ> zp_prv_constexpr auto sin(typ val) zp_prv_nthrw -> typ;

-

- template<typename typ> zp_prv_constexpr auto sqrt(typ val) zp_prv_nthrw -> typ;

-

- template<typename typ> zp_prv_constexpr auto tan(typ val) zp_prv_nthrw -> typ;

-

- template<typename typ> zp_prv_constexpr auto tsrt(typ val) zp_prv_nthrw -> typ;

-

- template<typename typ> zp_prv_constexpr auto vadd(::zp::vec2<typ> lvec,::zp::vec2<typ> rvec) zp_prv_nthrw -> ::zp::vec2<typ>;

- template<typename typ> zp_prv_constexpr auto vadd(::zp::vec3<typ> lvec,::zp::vec3<typ> rvec) zp_prv_nthrw -> ::zp::vec3<typ>;

- template<typename typ> zp_prv_constexpr auto vadd(::zp::vec4<typ> lvec,::zp::vec4<typ> rvec) zp_prv_nthrw -> ::zp::vec4<typ>;

-

- template<typename typ> zp_prv_constexpr auto vsub(::zp::vec2<typ> lvec,::zp::vec2<typ> rvec) zp_prv_nthrw -> ::zp::vec2<typ>;

- template<typename typ> zp_prv_constexpr auto vsub(::zp::vec3<typ> lvec,::zp::vec3<typ> rvec) zp_prv_nthrw -> ::zp::vec3<typ>;

- template<typename typ> zp_prv_constexpr auto vsub(::zp::vec4<typ> lvec,::zp::vec4<typ> rvec) zp_prv_nthrw -> ::zp::vec4<typ>;

-#include <zp/mth.d/pair/cpair.ii>

-#include <zp/mth.d/vec2/cvec.ii>

-#include <zp/mth.d/vec3/cvec.ii>

-#include <zp/mth.d/vec4/cvec.ii>

-#include <zp/mth.d/abs.ii>

-#include <zp/mth.d/dist.ii>

-#include <zp/mth.d/divmod.ii>

-#include <zp/mth.d/dot.ii>

-#include <zp/mth.d/exp.ii>

-#include <zp/mth.d/isnan.ii>

-#include <zp/mth.d/vadd.ii>

-#include <zp/mth.d/vsub.ii>

-

-/*

- Copyright 2022-2023 Gabriel Jensen.

- This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.

- If a copy of the MPL was not distributed with this file, You can obtain one at <https://mozilla.org/MPL/2.0>.

-*/

-

-template<typename typ> zp_prv_constexpr auto ::zp::abs(typ const val) zp_prv_nthrw -> typename ::zp::usgn<typ>::typ {

- static_assert(::zp::isari<typ>::val,"type must be an arithmetic type");

-

- using newtyp = typename ::zp::usgn<typ>::typ; // If a floating-point type was used, the new type would be identical.

-

- if (val > typ {0x0}) return static_cast<newtyp>(val);

-

- return typ {0x0}-static_cast<newtyp>(val);

-}

-/*

- Copyright 2022-2023 Gabriel Jensen.

- This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.

- If a copy of the MPL was not distributed with this file, You can obtain one at <https://mozilla.org/MPL/2.0>.

-*/

-

-/*template<typename typ> zp_prv_constexpr auto ::zp::dist(typ const x,typ const y) zp_prv_nthrw -> typ {

- static_assert(::zp::isari<typ>::val,"type must be an arithmetic type");

-

- return ::zp::sqrt(x*x+y*y);

-}

-

-template<typename typ> zp_prv_constexpr auto ::zp::dist(typ const x,typ const y,typ const z) zp_prv_nthrw -> typ {

- static_assert(::zp::isari<typ>::val,"type must be an arithmetic type");

-

- return ::zp::cbrt(x*x+y*y+z*z);

-}

-

-template<typename typ> zp_prv_constexpr auto ::zp::dist(typ const x,typ const y,typ const z,typ const w) zp_prv_nthrw -> typ {

- static_assert(::zp::isari<typ>::val,"type must be an arithmetic type");

-

- return ::zp::tsrt(x*x+y*y+z*z+w*w);

-}*/

-/*

- Copyright 2022-2023 Gabriel Jensen.

- This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.

- If a copy of the MPL was not distributed with this file, You can obtain one at <https://mozilla.org/MPL/2.0>.

-*/

-

-template<typename typ> zp_prv_constexpr auto ::zp::divmod(typ const num,typ const den) zp_prv_nthrw -> ::zp::pair<typ> {

- static_assert(::zp::isint<typ>::val,"type must be an integral type");

-

- ::zp::pair<typ> pair;

-

- zp_ulik (den == 0x0) {

- pair.lval = ::zp::inf<typ>::val;

- pair.rval = pair.lval;

-

- return pair;

- }

-

- for (pair = ::zp::pair<typ> {typ {0x0},num};pair.rval >= den;++pair.lval,pair.rval -= den);

-

- return pair;

-}

-/*

- Copyright 2022-2023 Gabriel Jensen.

- This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.

- If a copy of the MPL was not distributed with this file, You can obtain one at <https://mozilla.org/MPL/2.0>.

-*/

-

-template<typename typ> zp_prv_constexpr auto ::zp::dot(::zp::vec2<typ> const lvec,::zp::vec2<typ> const rvec) zp_prv_nthrw -> typ {

- static_assert(::zp::isari<typ>::val,"type must be an arithmetic type");

-

- return lvec.x*rvec.x+lvec.y*rvec.y;

-}

-

-template<typename typ> zp_prv_constexpr auto ::zp::dot(::zp::vec3<typ> const lvec,::zp::vec3<typ> const rvec) zp_prv_nthrw -> typ {

- static_assert(::zp::isari<typ>::val,"type must be an arithmetic type");

-

- return lvec.x*rvec.x+lvec.y*rvec.y+lvec.z*rvec.z;

-}

-

-template<typename typ> zp_prv_constexpr auto ::zp::dot(::zp::vec4<typ> const lvec,::zp::vec4<typ> const rvec) zp_prv_nthrw -> typ {

- static_assert(::zp::isari<typ>::val,"type must be an arithmetic type");

-

- return lvec.x*rvec.x+lvec.y*rvec.y+lvec.z*rvec.z+lvec.w*rvec.w;

-}

-/*

- Copyright 2022-2023 Gabriel Jensen.

- This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.

- If a copy of the MPL was not distributed with this file, You can obtain one at <https://mozilla.org/MPL/2.0>.

-*/

-

-template<typename typ> zp_prv_constexpr auto ::zp::exp(typ const val,typ const n) zp_prv_nthrw -> typ {

- static_assert(::zp::isari<typ>::val,"type must be an arithmetic type");

-

- zp_ulik (n == typ {0x0}) {

- return typ {0x1};

- }

-

- zp_ulik (val == typ {0x0}) {

- return typ {0x0};

- }

-

- typ exp = val;

- for (typ i = typ {0x1};i < n;++i) exp *= val;

-

- return exp;

-}

-/*

- Copyright 2022-2023 Gabriel Jensen.

- This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.

- If a copy of the MPL was not distributed with this file, You can obtain one at <https://mozilla.org/MPL/2.0>.

-*/

-

-template<typename typ> zp_prv_constexpr auto ::zp::isnan(typ const val) zp_prv_nthrw -> bool {

- static_assert(::zp::isari<typ>::val,"type must be an arithmetic type");

-

- if (::zp::isint<typ>::val) {return false;}

-

- return val != val;

-}

-/*

- Copyright 2022-2023 Gabriel Jensen.

- This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.

- If a copy of the MPL was not distributed with this file, You can obtain one at <https://mozilla.org/MPL/2.0>.

-*/

-

-template<typename typ> zp_prv_constexpr auto ::zp::pair<typ>::cpair() const zp_prv_nthrw -> ::zp::pair<typ>::ctyp {

- return ::zp::pair<typ>::ctyp {

- this->lval,

- this->rval,

- };

-}

-/*

- Copyright 2022-2023 Gabriel Jensen.

- This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.

- If a copy of the MPL was not distributed with this file, You can obtain one at <https://mozilla.org/MPL/2.0>.

-*/

-

-template<typename typ> zp_prv_constexpr auto ::zp::vadd(::zp::vec2<typ> const lvec,::zp::vec2<typ> const rvec) zp_prv_nthrw -> ::zp::vec2<typ> {

- static_assert(::zp::isari<typ>::val,"type must be an arithmetic type");

-

- return ::zp::vec2<typ> {

- lvec.x+rvec.x,

- lvec.y+rvec.y,

- };

-}

-

-template<typename typ> zp_prv_constexpr auto ::zp::vadd(::zp::vec3<typ> const lvec,::zp::vec3<typ> const rvec) zp_prv_nthrw -> ::zp::vec3<typ> {

- static_assert(::zp::isari<typ>::val,"type must be an arithmetic type");

-

- return ::zp::vec3<typ> {

- lvec.x+rvec.x,

- lvec.y+rvec.y,

- lvec.z+rvec.z,

- };

-}

-

-template<typename typ> zp_prv_constexpr auto ::zp::vadd(::zp::vec4<typ> const lvec,::zp::vec4<typ> const rvec) zp_prv_nthrw -> ::zp::vec4<typ> {

- static_assert(::zp::isari<typ>::val,"type must be an arithmetic type");

-

- return ::zp::vec4<typ> {

- lvec.x+rvec.x,

- lvec.y+rvec.y,

- lvec.z+rvec.z,

- lvec.w+rvec.w,

- };

-}

-/*

- Copyright 2022-2023 Gabriel Jensen.

- This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.

- If a copy of the MPL was not distributed with this file, You can obtain one at <https://mozilla.org/MPL/2.0>.

-*/

-

-template<typename typ> zp_prv_constexpr auto ::zp::vec2<typ>::cvec() const zp_prv_nthrw -> ::zp::vec2<typ>::ctyp {

- return typename ::zp::vec2<typ>::ctyp {

- this->x,

- this->y,

- };

-}

-/*

- Copyright 2022-2023 Gabriel Jensen.

- This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.

- If a copy of the MPL was not distributed with this file, You can obtain one at <https://mozilla.org/MPL/2.0>.

-*/

-

-template<typename typ> zp_prv_constexpr auto ::zp::vec3<typ>::cvec() const zp_prv_nthrw -> ::zp::vec3<typ>::ctyp {

- return typename ::zp::vec3<typ>::ctyp {

- this->x,

- this->y,

- this->z,

- };

-}

-/*

- Copyright 2022-2023 Gabriel Jensen.

- This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.

- If a copy of the MPL was not distributed with this file, You can obtain one at <https://mozilla.org/MPL/2.0>.

-*/

-

-template<typename typ> zp_prv_constexpr auto ::zp::vec4<typ>::cvec() const zp_prv_nthrw -> ::zp::vec4<typ>::ctyp {

- return typename ::zp::vec4<typ>::ctyp {

- this->x,

- this->y,

- this->z,

- this->w,

- };

-}

-/*

- Copyright 2022-2023 Gabriel Jensen.

- This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.

- If a copy of the MPL was not distributed with this file, You can obtain one at <https://mozilla.org/MPL/2.0>.

-*/

-

-template<typename typ> zp_prv_constexpr auto ::zp::vsub(::zp::vec2<typ> const lvec,::zp::vec2<typ> const rvec) zp_prv_nthrw -> ::zp::vec2<typ> {

- static_assert(::zp::isari<typ>::val,"type must be an arithmetic type");

-

- return ::zp::vec2<typ> {

- lvec.x-rvec.x,

- lvec.y-rvec.y,

- };

-}

-

-template<typename typ> zp_prv_constexpr auto ::zp::vsub(::zp::vec3<typ> const lvec,::zp::vec3<typ> const rvec) zp_prv_nthrw -> ::zp::vec3<typ> {

- static_assert(::zp::isari<typ>::val,"type must be an arithmetic type");

-

- return ::zp::vec3<typ> {

- lvec.x-rvec.x,

- lvec.y-rvec.y,

- lvec.z-rvec.z,

- };

-}

-

-template<typename typ> zp_prv_constexpr auto ::zp::vsub(::zp::vec4<typ> const lvec,::zp::vec4<typ> const rvec) zp_prv_nthrw -> ::zp::vec4<typ> {

- static_assert(::zp::isari<typ>::val,"type must be an arithmetic type");

-

- return ::zp::vec4<typ> {

- lvec.x-rvec.x,

- lvec.y-rvec.y,

- lvec.z-rvec.z,

- lvec.w-rvec.w,

- };

-}

-#if zp_prv_hasbuiltin(__builtin_huge_val)

-#if zp_prv_hasbuiltin(__builtin_huge_valf)

-#if zp_prv_hasbuiltin(__builtin_huge_vall)

-#if zp_prv_hasbuiltin(__builtin_nan)

-#if zp_prv_hasbuiltin(__builtin_nanf)

-#if zp_prv_hasbuiltin(__builtin_nanl)

-struct zp_pairsc {

-struct zp_pairs {

-struct zp_pairi {

-struct zp_pairl {

-struct zp_pairll {

-// is not-a-number

-// absolute

-// arc cosine

-// arc sine

-// arc tangens

-// cube root

-// cosine

-// two-space distance

-// three-space distance

-// four-space distance

-// division-modulo

-zp_nthrw zp_useq zp_useres struct zp_pairsc zp_divmodsc(char signed num,char signed den);

-zp_nthrw zp_useq zp_useres struct zp_pairs zp_divmods( short num,short den);

-zp_nthrw zp_useq zp_useres struct zp_pairi zp_divmodi( int num,int den);

-zp_nthrw zp_useq zp_useres struct zp_pairl zp_divmodl( long num,long den);

-zp_nthrw zp_useq zp_useres struct zp_pairll zp_divmodll(long long num,long long den);

-zp_nthrw zp_useq zp_useres struct zp_pairsc zp_divmodsc(char signed num,char signed den);

-zp_nthrw zp_useq zp_useres struct zp_pairs zp_divmods( short num,short den);

-zp_nthrw zp_useq zp_useres struct zp_pairi zp_divmodi( int num,int den);

-zp_nthrw zp_useq zp_useres struct zp_pairl zp_divmodl( long num,long den);

-zp_nthrw zp_useq zp_useres struct zp_pairll zp_divmodll(long long num,long long den);

-

-// two-space dot product

-// three-space dot product

-// four-space dot product

-// two-space dot product

-zp_nthrw zp_useq zp_useres float zp_dotf( float x,float y);

-zp_nthrw zp_useq zp_useres double zp_dotd( double x,double y);

-zp_nthrw zp_useq zp_useres long double zp_dotld(long double x,long double y);

-

-// exponentation

-// binary logarithm

-// common logarithm

-// natual logarithm

-// logarithm

-// nth root

-// sine

-// square root

-// tangens

-// "tesseract" (fourth) root

-// two-space vector addition

-zp_nthrw zp_useq zp_useres zp_vec2f zp_v2addf( zp_vec2f lvec,zp_vec2f rvec);

-zp_nthrw zp_useq zp_useres zp_vec2d zp_v2addd( zp_vec2d lvec,zp_vec2d rvec);

-zp_nthrw zp_useq zp_useres zp_vec2ld zp_v2addld(zp_vec2ld lvec,zp_vec2ld rvec);

-// three-space vector addition

-zp_nthrw zp_useq zp_useres zp_vec3f zp_v3addf( zp_vec3f lvec,zp_vec3f rvec);

-zp_nthrw zp_useq zp_useres zp_vec3d zp_v3addd( zp_vec3d lvec,zp_vec3d rvec);

-zp_nthrw zp_useq zp_useres zp_vec3ld zp_v3addld(zp_vec3ld lvec,zp_vec3ld rvec);

-// four-space vector addition

-// two-space vector subtraction

-zp_nthrw zp_useq zp_useres zp_vec2f zp_v2subf( zp_vec2f lvec,zp_vec2f rvec);

-zp_nthrw zp_useq zp_useres zp_vec2d zp_v2subd( zp_vec2d lvec,zp_vec2d rvec);

-zp_nthrw zp_useq zp_useres zp_vec2ld zp_v2subld(zp_vec2ld lvec,zp_vec2ld rvec);

-// three-space vector subtraction

-zp_nthrw zp_useq zp_useres zp_vec3f zp_v3subf( zp_vec3f lvec,zp_vec3f rvec);

-zp_nthrw zp_useq zp_useres zp_vec3d zp_v3subd( zp_vec3d lvec,zp_vec3d rvec);

-zp_nthrw zp_useq zp_useres zp_vec3ld zp_v3subld(zp_vec3ld lvec,zp_vec3ld rvec);

-// four-space vector subtraction

-#ifdef zp_std_cxx

-#ifdef zp_std_cxx

- zp_arc_arm64 // x86 jealous :(

-#define zp_minvalz ((zp_sz) +0x0u)

-// For some reason long.

-#define zp_minvall ((long) -0x8000000000000000ll)

-#define zp_maxvallu ((long unsigned)+0xFFFFFFFFFFFFFFFFllu)

-#define zp_maxvall ((long) +0x7FFFFFFFFFFFFFFFll)

- zp_sys_win

- template<typename typ> zp_useres zp_prv_constexpr auto numdig(typ val,::zp::i8m bs) zp_prv_nthrw -> ::zp::sz;

- template<typename typ> zp_prv_constexpr auto strcpy(typ * dst, typ const * src) zp_prv_nthrw -> ::zp::sz;

- template<typename typ> zp_useres zp_prv_constexpr auto strequ(typ const * lstr,typ const * rstr) zp_prv_nthrw -> bool;

- template<typename typ> zp_prv_constexpr auto strlen(typ const * str) zp_prv_nthrw -> ::zp::sz;

- template<typename typ> zp_useres zp_prv_constexpr auto strsrh(typ * str, typ chr) zp_prv_nthrw -> typ *;

- template<typename typ> zp_useres zp_prv_constexpr auto strsrh(typ const * str, typ chr) zp_prv_nthrw -> typ const *;

-

- zp_useres zp_prv_constexpr auto utf8enclen( ::zp::c02 const * str) zp_prv_nthrw -> ::zp::sz;

- zp_useres zp_prv_constexpr auto utf8declen( ::zp::c8 const * str) zp_prv_nthrw -> ::zp::sz;

- zp_useres zp_prv_constexpr auto utf16enclen(::zp::c02 const * str) zp_prv_nthrw -> ::zp::sz;

- zp_useres zp_prv_constexpr auto utf16declen(::zp::c01 const * str) zp_prv_nthrw -> ::zp::sz;

-

- zp_prv_constexpr auto utf8enc( ::zp::c8 * dst,::zp::c02 const * src) zp_prv_nthrw -> void;

- zp_prv_constexpr auto utf8dec( ::zp::c02 * dst,::zp::c8 const * src) zp_prv_nthrw -> void;

- zp_prv_constexpr auto utf16enc( ::zp::c01 * dst,::zp::c02 const * src) zp_prv_nthrw -> void;

- zp_prv_constexpr auto utf16dec( ::zp::c02 * dst,::zp::c01 const * src) zp_prv_nthrw -> void;

- zp_prv_constexpr auto win1252enc(::zp::c8 * dst,::zp::c02 const * src) zp_prv_nthrw -> void;

- zp_prv_constexpr auto win1252dec(::zp::c02 * dst,::zp::c8 const * src) zp_prv_nthrw -> void;

-

- template<typename typ> zp_useres zp_prv_constexpr auto fmtlen(typ val,::zp::i8m bs) zp_prv_nthrw -> ::zp::sz; // Including (potential) decorations.

-

- template<typename typ> zp_prv_constexpr auto fmt(::zp::c02 * buf,typ val,::zp::i8m bs,bool rtl = false) zp_prv_nthrw -> void;

-#include <zp/str.d/fmt.ii>

-#include <zp/str.d/fmtlen.ii>

-#include <zp/str.d/strcpy.ii>

-#include <zp/str.d/strequ.ii>

-#include <zp/str.d/strlen.ii>

-#include <zp/str.d/strsrh.ii>

-#include <zp/str.d/utf16dec.ii>

-#include <zp/str.d/utf16declen.ii>

-#include <zp/str.d/utf16enc.ii>

-#include <zp/str.d/utf16enclen.ii>

-#include <zp/str.d/utf8dec.ii>

-#include <zp/str.d/utf8declen.ii>

-#include <zp/str.d/utf8enc.ii>

-#include <zp/str.d/utf8enclen.ii>

-#include <zp/str.d/win1252dec.ii>

-#include <zp/str.d/win1252enc.ii>

-template<typename sgntyp> zp_prv_constexpr auto ::zp::fmt(::zp::c02 * buf,sgntyp sgnval,::zp::i8m const bs,bool const rtl) zp_prv_nthrw -> void {

- for (;val > 0x0u;val /= bs) *buf-- = digs[static_cast<::zp::sz>(val % static_cast<typ>(bs))];

- for (;val > 0x0u;val /= bs) *buf++ = digs[static_cast<::zp::sz>(val % static_cast<typ>(bs))];

-template<typename typ> zp_prv_constexpr auto ::zp::fmtlen(typ val,::zp::i8m const bs) zp_prv_nthrw -> ::zp::sz {

-template<typename typ> zp_prv_constexpr auto ::zp::prv::numdig(typ fmtval,::zp::i8m const bs) zp_prv_nthrw -> ::zp::sz {

- static_assert(::zp::isint<typ>::val,"type must be an integral type");

- if (fmtval == typ {0x0}) return 0x1u;

- for (typ val = fmtval;val > typ {0x0};val /= static_cast<typ>(bs)) {++len;}

-/*

- Copyright 2022-2023 Gabriel Jensen.

- This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.

- If a copy of the MPL was not distributed with this file, You can obtain one at <https://mozilla.org/MPL/2.0>.

-*/

-

-template<typename typ> zp_prv_constexpr auto ::zp::strcpy(typ * dst,typ const * src) zp_prv_nthrw -> ::zp::sz {

- static_assert(::zp::ischr<typ>::val,"type must be a character type");

-

- auto const dstsrt = dst;

-

- while (*src != typ {0x0}) {*dst++ = *src++;}

-

- return static_cast<::zp::sz>(dst-dstsrt); // Number of values copied.

-}

-/*

- Copyright 2022-2023 Gabriel Jensen.

- This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.

- If a copy of the MPL was not distributed with this file, You can obtain one at <https://mozilla.org/MPL/2.0>.

-*/

-

-template<typename typ> zp_prv_constexpr auto ::zp::strlen(typ const * str) zp_prv_nthrw -> ::zp::sz {

- static_assert(::zp::ischr<typ>::val,"type must be a character type"); // If the string format uses multiple values per character, the number of these values is returned (use utfXdeclen if the number of characters is needed).

-

- auto const srt = str;

-

- while (*str++ != typ {0x0}) {}

-

- return static_cast<::zp::sz>(str-srt)-0x1u;

-}

-/*

- Copyright 2022-2023 Gabriel Jensen.

- This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.

- If a copy of the MPL was not distributed with this file, You can obtain one at <https://mozilla.org/MPL/2.0>.

-*/

-

-template<typename typ> zp_prv_constexpr auto ::zp::strsrh(typ * str,typ const chr) zp_prv_nthrw -> typ * {

- return const_cast<typ *>(::zp::strsrh(const_cast<typ const *>(str),chr));

-}

-

-template<typename typ> zp_prv_constexpr auto ::zp::strsrh(typ const * str,typ const chr) zp_prv_nthrw -> typ const * {

- static_assert(::zp::ischr<typ>::val,"type must be a character type");

-

- for (;;++str) {

- auto const curchr = *str;

-

- zp_ulik (curchr == chr) {return str;}

- zp_ulik (curchr == typ {0x0}) {break;}

- }

-

- return nullptr;

-}

-/*

- Copyright 2022-2023 Gabriel Jensen.

- This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.

- If a copy of the MPL was not distributed with this file, You can obtain one at <https://mozilla.org/MPL/2.0>.

-*/

-

-zp_prv_constexpr auto ::zp::utf8dec(::zp::c02 * dst,::zp::c8 const * src) zp_prv_nthrw -> void {

- for (;;++dst) {

- auto const oct = *src++;

-

- if (oct >= 0xF0u) { /* Four octets. */

- ::zp::c02 chr = (static_cast<::zp::c02>(oct)^0xF0u)<<0x12u;

-

- chr |= (static_cast<::zp::c02>(*src++)^0b10000000u)<<0xCu;

- chr |= (static_cast<::zp::c02>(*src++)^0b10000000u)<<0x6u;

- chr |= static_cast<::zp::c02>(*src++)^0b10000000u;

-

- *dst = chr;

-

- continue;

- }

-

- if (oct >= 0xE0u) { /* Three octets. */

- ::zp::c02 chr = (static_cast<::zp::c02>(oct)^0b11100000u)<<0xCu;

-

- chr |= (static_cast<::zp::c02>(*src++)^0b10000000u)<<0x6u;

- chr |= static_cast<::zp::c02>(*src++)^0b10000000u;

-

- *dst = chr;

-

- continue;

- }

-

- if (oct >= 0xC0u) { /* Two octets. */

- ::zp::c02 chr = (static_cast<::zp::c02>(oct)^0b11000000u)<<0x6u;

-

- chr |= static_cast<::zp::c02>(*src++)^0b10000000u;

-

- *dst = chr;

-

- continue;

- }

-

- /* One octet. */

- *dst = oct;

- ++src;

-

- zp_ulik (oct == 0x0u) {break;}

- }

-}

-/*

- Copyright 2022-2023 Gabriel Jensen.

- This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.

- If a copy of the MPL was not distributed with this file, You can obtain one at <https://mozilla.org/MPL/2.0>.

-*/

-

-zp_prv_constexpr auto ::zp::utf8enc(::zp::c8 * dst,::zp::c02 const * src) zp_prv_nthrw -> void {

- for (;;++src) {

- auto const chr = *src;

-

- if (chr > 0xFFFFu) { /* Four octets. */

- *dst++ = (chr>>0x12u) |0b11110000u;

- *dst++ = (chr>>0xCu &0b00111111u)|0b10000000u;

- *dst++ = (chr>>0x6u &0b00111111u)|0b10000000u;

- *dst++ = (chr &0b00111111u)|0b10000000u;

-

- continue;

- }

-

- if (chr >= 0x7FFu) { /* Three octets. */

- *dst++ = (chr>>0xCu) |0b11100000u;

- *dst++ = (chr>>0x6u&0b00111111u)|0b10000000u;

- *dst++ = (chr &0b00111111u)|0b10000000u;

-

- continue;

- }

-

- if (chr >= 0x7Fu) { /* Two octets. */

- *dst++ = (chr>>0x6u) |0b11000000u;

- *dst++ = (chr &0b00111111u)|0b10000000u;

-

- continue;

- }

-

- /* One octet. */

- *dst++ = chr;

-

- zp_ulik (chr == 0x0u) {break;}

- }

-}

-zp_nthrw void zp_utf8enc( zp_c8 * zp_restr dst,zp_c02 const * zp_restr src);

-zp_nthrw void zp_utf8dec( zp_c02 * zp_restr dst,zp_c8 const * zp_restr src);

-zp_nthrw void zp_utf16enc( zp_c01 * zp_restr dst,zp_c02 const * zp_restr src);

-zp_nthrw void zp_utf16dec( zp_c02 * zp_restr dst,zp_c01 const * zp_restr src);

-zp_nthrw void zp_win1252enc(zp_c8 * zp_restr dst,zp_c02 const * zp_restr src);

-zp_nthrw void zp_win1252dec(zp_c02 * zp_restr dst,zp_c8 const * zp_restr src);

-zp_nthrw zp_useres zp_sz zp_fmtlenll( long long val,zp_i8m bs);

-zp_nthrw zp_useres zp_sz zp_fmtlenull(long long unsigned val,zp_i8m bs);

-zp_nthrw void zp_fmtll( zp_c02 * buf,long long val,zp_i8m bs,bool rtl);

-zp_nthrw void zp_fmtull(zp_c02 * buf,long long unsigned val,zp_i8m bs,bool rtl);

-.big02cpy: ; big02cpy:; // We assume AVX.

-inline auto ::zp::urch() zp_prv_nthrw -> void {

- zp_urch();

-#include <zp/bs>

-extern "C" void zp_trp() {

-#if zp_prv_hasbuiltin(__builtin_trap)

-/*

- Copyright 2022-2023 Gabriel Jensen.

- This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.

- If a copy of the MPL was not distributed with this file, You can obtain one at <https://mozilla.org/MPL/2.0>.

-*/

-

-#include <zp/mem>

-

-extern "C" zp_nthrw auto zp_memcpy(void * const zp_restr dst,void const * const zp_restr src,zp_sz const num) -> struct zp_cpyres {

- auto const ret = ::zp::cpy(static_cast<char unsigned *>(dst),static_cast<char unsigned const *>(src),num);

-

- return ::zp_cpyres {

- ret.dst,

- ret.src,

- };

-}

-/*

- Copyright 2022-2023 Gabriel Jensen.

- This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.

- If a copy of the MPL was not distributed with this file, You can obtain one at <https://mozilla.org/MPL/2.0>.

-*/

-

-#include <zp/mem>

-

-extern "C" zp_nthrw auto zp_memequ(void const * const lbuf,void const * const rbuf,::zp::sz const num) -> bool {

- return ::zp::equ(static_cast<char unsigned const *>(lbuf),static_cast<char unsigned const *>(rbuf),num);

-}

-template<typename... typs> inline auto ::zp::syscl(::zp::sysclid const id,typs const &... args) zp_prv_nthrw -> ::zp::sysclres {

- return ::zp_syscl(id,args...);

-/*

- Copyright 2022-2023 Gabriel Jensen.

- This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.

- If a copy of the MPL was not distributed with this file, You can obtain one at <https://mozilla.org/MPL/2.0>.

-*/

-

-#include <zp/mem>

-

-extern "C" zp_nthrw auto zp_memfil(void * const dst,char unsigned const val,::zp::sz const num) -> void * {

- return ::zp::fil(static_cast<char unsigned *>(dst),val,num);

-}

-/*

- Copyright 2022-2023 Gabriel Jensen.

- This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.

- If a copy of the MPL was not distributed with this file, You can obtain one at <https://mozilla.org/MPL/2.0>.

-*/

-

-#include <zp/mem>

-

-extern "C" zp_nthrw auto zp_memsrh(void const * const buf,char unsigned const val,::zp::sz const num) -> void * {

- return const_cast<char unsigned *>(::zp::srh(static_cast<char unsigned const *>(buf),val,num));

-}

- zp_nthrw auto zp_divmodsc(char signed const num,char signed const den) -> ::zp_pairsc {return ::zp::divmod(num,den).cpair();}

- zp_nthrw auto zp_divmods( short const num,short const den) -> ::zp_pairs {return ::zp::divmod(num,den).cpair();}

- zp_nthrw auto zp_divmodi( int const num,int const den) -> ::zp_pairi {return ::zp::divmod(num,den).cpair();}

- zp_nthrw auto zp_divmodl( long const num,long const den) -> ::zp_pairl {return ::zp::divmod(num,den).cpair();}

- zp_nthrw auto zp_divmodll(long long const num,long long const den) -> ::zp_pairll {return ::zp::divmod(num,den).cpair();}

- zp_nthrw auto zp_v2addf( ::zp_vec2f const lvec,::zp_vec2f const rvec) -> ::zp_vec2f {return ::zp::vadd(::zp::vec2<float> {lvec.x,lvec.y,},::zp::vec2<float> {rvec.x,rvec.y,}).cvec();}

- zp_nthrw auto zp_v2addd( ::zp_vec2d const lvec,::zp_vec2d const rvec) -> ::zp_vec2d {return ::zp::vadd(::zp::vec2<double> {lvec.x,lvec.y,},::zp::vec2<double> {rvec.x,rvec.y,}).cvec();}

- zp_nthrw auto zp_v2addld(::zp_vec2ld const lvec,::zp_vec2ld const rvec) -> ::zp_vec2ld {return ::zp::vadd(::zp::vec2<long double> {lvec.x,lvec.y,},::zp::vec2<long double> {rvec.x,rvec.y,}).cvec();}

- zp_nthrw auto zp_v3addf( ::zp_vec3f const lvec,::zp_vec3f const rvec) -> ::zp_vec3f {return ::zp::vadd(::zp::vec3<float> {lvec.x,lvec.y,lvec.z,},::zp::vec3<float> {rvec.x,rvec.y,rvec.z,}).cvec();}

- zp_nthrw auto zp_v3addd( ::zp_vec3d const lvec,::zp_vec3d const rvec) -> ::zp_vec3d {return ::zp::vadd(::zp::vec3<double> {lvec.x,lvec.y,lvec.z,},::zp::vec3<double> {rvec.x,rvec.y,rvec.z,}).cvec();}

- zp_nthrw auto zp_v3addld(::zp_vec3ld const lvec,::zp_vec3ld const rvec) -> ::zp_vec3ld {return ::zp::vadd(::zp::vec3<long double> {lvec.x,lvec.y,lvec.z,},::zp::vec3<long double> {rvec.x,rvec.y,rvec.z,}).cvec();}

- zp_nthrw auto zp_v2subf( ::zp_vec2f const lvec,::zp_vec2f const rvec) -> ::zp_vec2f {return ::zp::vsub(::zp::vec2<float> {lvec.x,lvec.y,},::zp::vec2<float> {rvec.x,rvec.y,}).cvec();}

- zp_nthrw auto zp_v2subd( ::zp_vec2d const lvec,::zp_vec2d const rvec) -> ::zp_vec2d {return ::zp::vsub(::zp::vec2<double> {lvec.x,lvec.y,},::zp::vec2<double> {rvec.x,rvec.y,}).cvec();}

- zp_nthrw auto zp_v2subld(::zp_vec2ld const lvec,::zp_vec2ld const rvec) -> ::zp_vec2ld {return ::zp::vsub(::zp::vec2<long double> {lvec.x,lvec.y,},::zp::vec2<long double> {rvec.x,rvec.y,}).cvec();}

- zp_nthrw auto zp_v3subf( ::zp_vec3f const lvec,::zp_vec3f const rvec) -> ::zp_vec3f {return ::zp::vsub(::zp::vec3<float> {lvec.x,lvec.y,lvec.z,},::zp::vec3<float> {rvec.x,rvec.y,rvec.z,}).cvec();}

- zp_nthrw auto zp_v3subd( ::zp_vec3d const lvec,::zp_vec3d const rvec) -> ::zp_vec3d {return ::zp::vsub(::zp::vec3<double> {lvec.x,lvec.y,lvec.z,},::zp::vec3<double> {rvec.x,rvec.y,rvec.z,}).cvec();}

- zp_nthrw auto zp_v3subld(::zp_vec3ld const lvec,::zp_vec3ld const rvec) -> ::zp_vec3ld {return ::zp::vsub(::zp::vec3<long double> {lvec.x,lvec.y,lvec.z,},::zp::vec3<long double> {rvec.x,rvec.y,rvec.z,}).cvec();}

-extern "C" {

-}

-extern "C" {

-}

-#include <zp/str>

-extern "C" zp_nthrw auto zp_strcpy(char * const dst,char const * const src) -> ::zp::sz {

- return ::zp::strcpy(dst,src);

-#include <zp/str>

-extern "C" zp_nthrw auto zp_strequ(char const * const lstr,char const * const rstr) -> bool {

- return ::zp::strequ(lstr,rstr);

-#include <zp/bs>

-extern "C" ::zp::sysclres zp_syscl(zp_nuse ::zp::sysclid id,...) {

- ::zp::urch(); // Unsupported.

-#include <zp/str>

-extern "C" zp_nthrw auto zp_strlen(char const * const str) -> ::zp::sz {

- return ::zp::strlen(str);

-#include <zp/str>

-extern "C" zp_nthrw auto zp_strsrh(char const * const str,char const chr) -> char * {

- return const_cast<char *>(::zp::strsrh(str,chr));

-zp_prv_constexpr auto ::zp::utf16dec(::zp::c02 * dst,::zp::c01 const * src) zp_prv_nthrw -> void {

- auto const hex = *src++;

- ::zp::c02 chr = (static_cast<::zp::c02>(hex)^0b1101100000000000u)<<0xAu;

- chr |= static_cast<::zp::c02>(*src++)^0b1101110000000000u;

-/*

- Copyright 2022-2023 Gabriel Jensen.

- This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.

- If a copy of the MPL was not distributed with this file, You can obtain one at <https://mozilla.org/MPL/2.0>.

-*/

-

-#include <zp/str>

-

-extern "C" zp_nthrw auto zp_utf16dec(::zp::c02 * const dst,::zp::c01 const * const src) -> void {

- return ::zp::utf16dec(dst,src);

-}

-zp_prv_constexpr auto ::zp::utf16declen(::zp::c01 const * str) zp_prv_nthrw -> ::zp::sz {

- ::zp::sz len = 0x0u;

- auto const chr = *str;

- if (chr >= 0xD800u && chr < 0xDC00u) {

- zp_ulik (chr == 0x0u) {break;}

-zp_prv_constexpr auto ::zp::utf16enc(::zp::c01 * dst,::zp::c02 const * src) zp_prv_nthrw -> void {

- auto const chr = *src;

- ::zp::c02 const tmp = chr-0x10000u;

- *dst++ = (tmp>>0xAu) |0b1101100000000000u;

- *dst++ = (tmp &0b0000001111111111u)|0b1101110000000000u;

-/*

- Copyright 2022-2023 Gabriel Jensen.

- This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.

- If a copy of the MPL was not distributed with this file, You can obtain one at <https://mozilla.org/MPL/2.0>.

-*/

-

-#include <zp/str>

-

-extern "C" zp_nthrw auto zp_utf16enc(::zp::c01 * const dst,::zp::c02 const * const src) -> void {

- return ::zp::utf16enc(dst,src);

-}

-zp_prv_constexpr auto ::zp::utf16enclen(::zp::c02 const * str) zp_prv_nthrw -> ::zp::sz {

- ::zp::sz len = 0x0u;

- auto const chr = *str;

-#include <zp/str>

-extern "C" zp_nthrw auto zp_utf32cpy(::zp::c02 * const dst,::zp::c02 const * const src) -> ::zp::sz {

- return ::zp::strcpy(dst,src);

-#include <zp/str>

-extern "C" zp_nthrw auto zp_utf32equ(::zp::c02 const * const lstr,::zp::c02 const * const rstr) -> bool {

- return ::zp::strequ(lstr,rstr);

-#include <zp/str>

-extern "C" zp_nthrw auto zp_utf16declen(::zp::c01 const * const str) -> ::zp::sz {

- return ::zp::utf16declen(str);

-#include <zp/str>

-extern "C" zp_nthrw auto zp_utf32len(::zp::c02 const * const str) -> ::zp::sz {

- return ::zp::strlen(str);

-#include <zp/str>

-extern "C" zp_nthrw auto zp_utf32srh(::zp::c02 const * const str,::zp::c02 const chr) -> ::zp::c02 * {

- return const_cast<::zp::c02 *>(::zp::strsrh(str,chr));

-/*

- Copyright 2022-2023 Gabriel Jensen.

- This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.

- If a copy of the MPL was not distributed with this file, You can obtain one at <https://mozilla.org/MPL/2.0>.

-*/

-

-#include <zp/str>

-

-extern "C" zp_nthrw auto zp_utf8dec(::zp::c02 * const dst,::zp::c8 const * const src) -> void {

- return ::zp::utf8dec(dst,src);

-}

-zp_prv_constexpr auto ::zp::utf8declen(::zp::c8 const * str) zp_prv_nthrw -> ::zp::sz {

- ::zp::sz len = 0x0u;

- auto const oct = *str;

-/*

- Copyright 2022-2023 Gabriel Jensen.

- This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.

- If a copy of the MPL was not distributed with this file, You can obtain one at <https://mozilla.org/MPL/2.0>.

-*/

-

-#include <zp/str>

-

-extern "C" zp_nthrw auto zp_utf8declen(::zp::c8 const * const str) -> ::zp::sz {

- return ::zp::utf8declen(str);

-}

-/*

- Copyright 2022-2023 Gabriel Jensen.

- This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.

- If a copy of the MPL was not distributed with this file, You can obtain one at <https://mozilla.org/MPL/2.0>.

-*/

-

-#include <zp/str>

-

-extern "C" zp_nthrw auto zp_utf8enc(::zp::c8 * const dst,::zp::c02 const * const src) -> void {

- return ::zp::utf8enc(dst,src);

-}

-zp_prv_constexpr auto ::zp::utf8enclen(::zp::c02 const * str) zp_prv_nthrw -> ::zp::sz {

- ::zp::sz len = 0x0u;

- auto const chr = *str;

-/*

- Copyright 2022-2023 Gabriel Jensen.

- This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.

- If a copy of the MPL was not distributed with this file, You can obtain one at <https://mozilla.org/MPL/2.0>.

-*/

-

-#include <zp/str>

-

-extern "C" zp_nthrw auto zp_utf8enclen(::zp::c02 const * const str) -> ::zp::sz {

- return ::zp::utf8enclen(str);

-}

-zp_prv_constexpr auto ::zp::win1252dec(::zp::c02 * dst,::zp::c8 const * src) zp_prv_nthrw -> void {

- ::zp::c8 const chr = *src;

-/*

- Copyright 2022-2023 Gabriel Jensen.

- This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.

- If a copy of the MPL was not distributed with this file, You can obtain one at <https://mozilla.org/MPL/2.0>.

-*/

-

-#include <zp/str>

-

-extern "C" zp_nthrw auto zp_win1252dec(::zp::c02 * const dst,::zp::c8 const * const src) -> void {

- return ::zp::win1252dec(dst,src);

-}

-zp_prv_constexpr auto ::zp::win1252enc(::zp::c8 * dst,::zp::c02 const * src) zp_prv_nthrw -> void {

- ::zp::c02 const chr = *src;

- constexpr ::zp::c8 bad = 0x3Fu;

-/*

- Copyright 2022-2023 Gabriel Jensen.

- This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.

- If a copy of the MPL was not distributed with this file, You can obtain one at <https://mozilla.org/MPL/2.0>.

-*/

-

-#include <zp/str>

-

-extern "C" zp_nthrw auto zp_win1252enc(::zp::c8 * const dst,::zp::c02 const * const src) -> void {

- return ::zp::win1252enc(dst,src);

-}

-#include <zp/str>

-extern "C" zp_nthrw auto zp_wstrcpy(::zp::wchr * const dst,::zp::wchr const * const src) -> ::zp::sz {

- return ::zp::strcpy(dst,src);

-#include <zp/str>

-extern "C" zp_nthrw auto zp_wstrequ(::zp::wchr const * const lstr,::zp::wchr const * const rstr) -> bool {

- return ::zp::strequ(lstr,rstr);

-#include <zp/str>

-extern "C" zp_nthrw auto zp_utf16enclen(::zp::c02 const * const str) -> ::zp::sz {

- return ::zp::utf16enclen(str);

-#include <zp/str>

-extern "C" zp_nthrw auto zp_wstrlen(::zp::wchr const * const str) -> ::zp::sz {

- return ::zp::strlen(str);

-#include <zp/str>

-extern "C" zp_nthrw auto zp_wstrsrh(::zp::wchr const * const str,::zp::wchr const chr) -> ::zp::wchr * {

- return const_cast<::zp::wchr *>(::zp::strsrh(str,chr));

-// Copyright 2022-2023 Gabriel Jensen.

-// This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.

-// If a copy of the MPL was not distributed with this file, You can obtain one at <https://mozilla.org/MPL/2.0>.

- // System calls on ARM64 use the following registers:

- // x0 : System call identifier

- // x1 : First parameter

- // x2 : Second parameter

- // x3 : Third parameter

- // x4 : Fourth parameter

- // x5 : Fifth parameter

- // x6 : Sixth parameter

- // x0 : Return value

- mov x8,x0 // Move the first parameter (the identifier) to x8.

- mov x0,x1 // Shift all of the other parameters to the left.

- svc 0x0 // Zephyr

- // No need to move the return value (already in x0).