+| F

+

+- Remove type specifier from version macro;

+- Add mathematical functions abs and fma;

+- Update documentation;

+- Remove nothrw attribute from foreach;

+- Remove UB from foreach test;

+- Fix parameter mismatch in foreach test;

+- Use unsigned char instead of uint_least8_t;

+- Remove unnecessary casts;

+- Add new headers: 'zap/math.h' (for mathematical functions), 'zap/mem.h' (for memory sequence functions);

+- Restructure makefile;

+- Fix not using INT_LEAST8_MAX and INT_LEAST8_MIN instead of INT8_MAX and INT8_MIN;

+- Remove '/build' from gitignore;

+

+LIBZAP = zap/libzap.a

+.PHONY: clean install purge zap

+zap:

+ $(MAKE) -Czap

+install: zap

+ install -Dm644 zap/include/zap/math.h $(HDRDIR)/zap

+ install -Dm644 zap/include/zap/mem.h $(HDRDIR)/zap

+ install -Dm755 $(LIBZAP) $(LIBDIR)

+ $(MAKE) -Czap clean

+purge:

+ $(MAKE) -Czap purge

+ <h3>abs</h3>

+ <h4>Synopsis</h4>

+ <code>#include &ltzap/math.h&gt<br />signed char zap_abs_c(signed char val);<br />int zap_abs_i(int val);<br />long zap_abs_l(long val);<br />long long zap_abs_ll(long long val);<br />short zap_abs_s(short val);</code>

+ <h4>Description</h4>

+ <p>Returns the absolute value of <i>val</i>.</p>

+ <br />

+ <h3>fma</h3>

+ <h4>Synopsis</h4>

+ <code>#include &ltzap/math.h&gt<br />signed char zap_fma_c(signed char a,signed char b,signed char c);<br/>int zap_fma_i(int a,int b,int c);<br/>long zap_fma_l(long a,long b,long c);<br/>long long zap_fma_ll(long long a,long long b,long long c);<br/>short zap_fma_s(short a,short b,short c);<br/>unsigned char zap_fma_uc(unsigned char a,unsigned char b,unsigned char c);<br/>unsigned int zap_fma_ui(unsigned int a,unsigned int b,unsigned int c);<br/>unsigned long zap_fma_ul( unsigned long a,unsigned long b,unsigned long c);<br/>unsigned long long zap_fma_ull(unsigned long long a,unsigned long long b,unsigned long long c);<br/>unsigned short zap_fma_us( unsigned short a,unsigned short b,unsigned short c);</code>

+ <h4>Description</h4>

+ <p>Returns the the fused multiply-add of <i>a</i>, <i>b</i>, and <i>c</i>.</p>

+ <br />

+ <code>#include &ltzap/mem.h&gt<br />size_t zap_fndbtyte(void const * ptr,size_t num,unsigned char byte);</code>

+ <p>If <i>ptr</i> is not a valid pointer to a null-terminated string, the behaviour is undefined.</p>

+ <p>If the byte-value is found within the domain, the position of it's first occurrence (starting at zero) is returned. Otherwise, <i>SIZE_MAX</i> is returned.</p>

+ <code>#include &ltzap/mem.h&gt<br />size_t zap_fndchr(char const * str,char chr);</code>

+ <p>If the character is found in the string, the position of it's first occurrence (starting at zero) is returned. Otherwise, <i>SIZE_MAX</i> is returned.</p>

+ <code>#include &ltzap/mem.h&gt<br />void zap_foreach(void * ptr,size_t sz,size_t num,void (* fn)(void *),void * * rem);</code>

+ <p>Iterates through the array pointed to by <i>ptr</i>, invoking the function <i>fn</i> with a pointer to the current element. Each pointer value after the first is equal to the previous plus <i>sz</i>.</p>

+ <p>If the pointed-to object of <i>rem</i> is not a null pointer, the iterations are started from that address. If <i>fn</i> throws an exception, the current position is written to the pointed-to object of <i>rem</i> (unless <i>rem</i> is a null pointer) and <i>foreach</i> returns the control-flow to the caller via this exception.</p>

+ <p>If <i>fn</i> is not a valid pointer to a function with C language linkage, the behaviour is undefined.</p>

+ <p>If <i>rem</i> is not a null pointer and the pointed-to object is not initialised to <i>NULL</i> before the call to <i>foreach</i>, the behaviour is undefined.</p>

+ <code>#include &ltzap/mem.h&gt<br />int_least8_t zap_memcmp(void const * lptr,size_t num,void const * rptr);</code>

+ <h3>memcpy</h3>

+ <h4>Synopsis</h4>

+ <code>#include &ltzap/mem.h&gt<br />void zap_memcpy(void const * in,size_t num,void * out);</code>

+ <h4>Description</h4>

+ <p>Copies <i>num</i>-bytes from the buffer pointed to by <i>in</i> into the same relative position in the buffer pointer to by <i>out</i>.</p>

+ <p>If <i>in</i> or <i>out</i> (or both) are not valid pointers to arrays, the behaviour is undefined.</p>

+ <p>If <i>num</i> is larger (but not smaller) than the number of bytes of the smallest array, the behaviour is undefined.</p>

+ <br />

+ <code>#include &ltzap/mem.h&gt<br />void * zap_memdup(void const * ptr,size_t num);</code>

+ <h3>memeq</h3>

+ <h4>Synopsis</h4>

+ <code>#include &ltzap/mem.h&gt<br />bool zap_memeq(void const * lptr,size_t num,void * rptr);</code>

+ <h4>Description</h4>

+ <p>Checks <i>num</i>-bytes of the buffers pointed to by <i>lptr</i> and <i>rptr</i> for equality.</p>

+ <p>If any two bytes are found to be different in the two buffers, false is returned. Otherwise, true is returned.</p>

+ <p>If <i>lptr</i> or <i>rptr</i> (or both) are not valid pointers to arrays, the behaviour is undefined.</p>

+ <p>If <i>num</i> is larger (but not smaller) than the number of bytes of the smallest array, the behaviour is undefined.</p>

+ <br />

+ <h3>memfill</h3>

+ <h4>Synopsis</h4>

+ <code>#include &ltzap/mem.h&gt<br />void zap_memfill(void const * ptr,size_t num,unsigned char byte);</code>

+ <h4>Description</h4>

+ <p>Fills <i>num</i>-bytes of the buffer pointed to by <i>ptr</i> with the representation of <i>byte</i>.</p>

+ <p>If <i>ptr</i> is not a valid pointer to an array, the behaviour is undefined.</p>

+ <p>If <i>num</i> is larger (but not smaller) than the number of bytes of in the array, the behaviour is undefined.</p>

+ <br />

+ <code>#include &ltzap/mem.h&gt<br />bool zap_streq(char const * lstr,char const * rstr);</code>

+ <code>#include &ltzap/mem.h&gt<br />void zap_strfill(char * str,char chr);</code>

+ <code>#include &ltzap/mem.h&gt<br />size_t zap_strlen(char const * str);</code>

+/* c++ -Izap/include -Lzap -otest test.cc -lzap */

+#include <stdexcept>

+#include <zap/math.h>

+#include <zap/mem.h>

+

+extern "C" auto zap_test_foreachfn(void * const _ptr) -> void { /* This function is passed to foreach, which requires C-linkage function pointers. I tried to overload the function to also accept C++-linkage function pointers, but that only made GCC moan. */

+ auto const ptr {static_cast<int *>(_ptr)};

+ auto val {*ptr};

+ if (val == 0x45) {throw ::std::domain_error {"Damn!"};}

+ val %= 0x2;

+ *ptr = val;

+}

+ {

+ auto val {::zap_abs_c(-0x5D)};

+ ::std::fprintf(stderr,"val: %hhi\n",val);

+ assert(val == 0x5D);

+ }

+ {

+ auto val {::zap_abs_i(-0xEF4)};

+ ::std::fprintf(stderr,"val: %i\n",val);

+ assert(val == 0xEF4);

+ }

+ {

+ auto val {::zap_abs_l(-0x6666E67B)};

+ ::std::fprintf(stderr,"val: %li\n",val);

+ assert(val == 0x6666E67B);

+ }

+ {

+ auto val {::zap_abs_ll(-0x7C91A4B244F0DC99)};

+ ::std::fprintf(stderr,"val: %lli\n",val);

+ assert(val == 0x7C91A4B244F0DC99);

+ }

+ {

+ auto val {::zap_abs_s(-0xDC9)};

+ ::std::fprintf(stderr,"val: %i\n",val);

+ assert(val == 0xDC9);

+ }

+ }

+ ::std::fprintf(stderr,"\n");

+ {

+ { /* Largest number for each signed parameter: (floor(cbrt(2^(x-1)-1))) */

+ auto val {::zap_fma_c(0x5,0x2,0x2)};

+ ::std::fprintf(stderr,"val: %hhi\n",val);

+ assert(val == 0x9);

+ }

+ {

+ auto val {::zap_fma_i(0x29,0x4AD,0x453)};

+ ::std::fprintf(stderr,"val: %i\n",val);

+ assert(val == 0x143840);

+ }

+ {

+ auto val {::zap_fma_l(0x1BAA11,0x361DA,0x17462F)};

+ ::std::fprintf(stderr,"val: %li\n",val);

+ assert(val == 0x4EB8123D17);

+ }

+ {

+ auto val {::zap_fma_ll(0x45,0x60,0x1A4)};

+ ::std::fprintf(stderr,"val: %lli\n",val);

+ assert(val == 0x9DC5);

+ }

+ {

+ auto val {::zap_fma_s(0x7,0xE,0x1D)};

+ ::std::fprintf(stderr,"val: %i\n",val);

+ assert(val == 0x19D);

+ }

+ { /* Largest number for each unsigned parameter: (floor(cbrt(2^x-1))) */

+ auto val {::zap_fma_uc(0x6u,0x6u,0x3u)};

+ ::std::fprintf(stderr,"val: %hhu\n",val);

+ assert(val == 0x18u);

+ }

+ {

+ auto val {::zap_fma_ui(0x14u,0x17u,0x3u)};

+ ::std::fprintf(stderr,"val: %u\n",val);

+ assert(val == 0x59);

+ }

+ {

+ auto val {::zap_fma_ul(0x5AAu,0x412u,0x16Du)};

+ ::std::fprintf(stderr,"val: %lu\n",val);

+ assert(val == 0x5D354u);

+ }

+ {

+ auto val {::zap_fma_ull(0x10EFC7u,0x19FB63u,0x1133259u)};

+ ::std::fprintf(stderr,"val: %llu\n",val);

+ assert(val == 0x1BEE278BAB32u);

+ }

+ {

+ auto val {::zap_fma_us(0x23u,0x19u,0x1Cu)};

+ ::std::fprintf(stderr,"val: %u\n",val);

+ assert(val == 0x2DF);

+ }

+ }

+ ::std::fprintf(stderr,"\n");

+ {

+ ::std::fprintf(stderr,"arr0[0]: %" PRIXLEAST64 "\n",arr0[0x0u]);

+ ::std::fprintf(stderr,"arr0[1]: %" PRIXLEAST64 "\n",arr0[0x1u]);

+ ::std::fprintf(stderr,"arr0[2]: %" PRIXLEAST64 "\n",arr0[0x2u]);

+ ::std::fprintf(stderr,"arr0[3]: %" PRIXLEAST64 "\n",arr0[0x3u]);

+ ::std::fprintf(stderr,"arr0[4]: %" PRIXLEAST64 "\n",arr0[0x4u]);

+ ::std::fprintf(stderr,"arr0[5]: %" PRIXLEAST64 "\n",arr0[0x5u]);

+ ::std::fprintf(stderr,"arr0[6]: %" PRIXLEAST64 "\n",arr0[0x6u]);

+ ::std::fprintf(stderr,"arr0[0]: %" PRIXLEAST64 "\n",arr0[0x0u]);

+ ::std::fprintf(stderr,"arr0[1]: %" PRIXLEAST64 "\n",arr0[0x1u]);

+ ::std::fprintf(stderr,"arr0[2]: %" PRIXLEAST64 "\n",arr0[0x2u]);

+ ::std::fprintf(stderr,"arr0[3]: %" PRIXLEAST64 "\n",arr0[0x3u]);

+ ::std::fprintf(stderr,"arr0[4]: %" PRIXLEAST64 "\n",arr0[0x4u]);

+ ::std::fprintf(stderr,"arr0[5]: %" PRIXLEAST64 "\n",arr0[0x5u]);

+ ::std::fprintf(stderr,"arr0[6]: %" PRIXLEAST64 "\n",arr0[0x6u]);

+ ::std::fprintf(stderr,"arr1[0]: %" PRIXLEAST64 "\n",arr1[0x0u]);

+ ::std::fprintf(stderr,"arr1[1]: %" PRIXLEAST64 "\n",arr1[0x1u]);

+ ::std::fprintf(stderr,"arr1[2]: %" PRIXLEAST64 "\n",arr1[0x2u]);

+ ::std::fprintf(stderr,"arr1[3]: %" PRIXLEAST64 "\n",arr1[0x3u]);

+ ::std::fprintf(stderr,"arr1[4]: %" PRIXLEAST64 "\n",arr1[0x4u]);

+ ::std::fprintf(stderr,"arr1[5]: %" PRIXLEAST64 "\n",arr1[0x5u]);

+ ::std::fprintf(stderr,"arr1[6]: %" PRIXLEAST64 "\n",arr1[0x6u]);

+ ::std::size_t pos1 = ::zap_fndbyte(str,len,(unsigned char)' ');

+ pos1 = ::zap_fndbyte(str,len,(unsigned char)' ');

+ pos1 = ::zap_fndbyte(str,len,(unsigned char)' ');

+ void * rem {nullptr};

+ ::zap_foreach(arr,sizeof (int),sizeof (arr) / sizeof (int),::zap_test_foreachfn);

+# TOOLS

+

+#CC = clang

+#CC = gcc

+

+# TOOL FLAGS

+

+CFLAGS = \

+ -Iinclude \

+ -Iinclude-priv \

+ -O3 \

+ -fPIC \

+ -g \

+ -march=native \

+ -std=c99 \

+ -Wall \

+ -Wextra \

+ -Wpedantic

+

+# ARTIFACTS

+

+OBJS = \

+ src/abs.o \

+ src/fastimpl.o \

+ src/fma.o \

+ src/fndbyte.o \

+ src/fndchr.o \

+ src/foreach.o \

+ src/memcmp.o \

+ src/memcpy.o \

+ src/memdup.o \

+ src/memeq.o \

+ src/memfill.o \

+ src/strcmp.o \

+ src/strdup.o \

+ src/streq.o \

+ src/strfill.o \

+ src/strcpy.o \

+ src/strlen.o

+

+LIB = libzap.a

+

+# OPTIONS

+

+# Uncomment to disable assembly algorithms:

+#CFLAGS += -Dzap_priv_noasm

+

+# Uncomment to enable freestanding mode (requries no runtime):

+#CFLAGS += \

+ -Dzap_priv_nostdlib \

+ -ffreestanding

+

+# TARGETS

+

+.PHONY: clean purge

+

+$(LIB): $(OBJS)

+ ar r $@ $(OBJS)

+

+clean:

+ rm -fr $(OBJS)

+

+purge: clean

+ rm -fr $(LIB)

+#if !defined(zap_priv_hdr_priv)

+#define zap_priv_hdr_priv

+#define zap_priv_fastimpl (0x1u)

+#else

+#define zap_priv_fastimpl (0x0u)

+#if !defined(zap_priv_hdr_base)

+#define zap_priv_hdr_base

+#define zap_ver (0xFu)

+/*

+ Copyright 2022 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 <zap/base.h>

+

+#include <susinfo.h>

+

+#if !defined(zap_priv_hdr_math)

+#define zap_priv_hdr_math

+

+#if !defined(sus_langfeat_c_llng) && !defined(sus_langfeat_cxx_llng)

+#error The (long long) type is required but unsupported by the implementation !

+#endif

+

+#if defined(sus_lang_cxx)

+extern "C" {

+#endif

+

+sus_attr_const sus_attr_hot sus_attr_nothrw sus_attr_useret signed char zap_abs_c( signed char val);

+sus_attr_const sus_attr_hot sus_attr_nothrw sus_attr_useret int zap_abs_i( int val);

+sus_attr_const sus_attr_hot sus_attr_nothrw sus_attr_useret long zap_abs_l( long val);

+sus_attr_const sus_attr_hot sus_attr_nothrw sus_attr_useret long long zap_abs_ll( long long val);

+sus_attr_const sus_attr_hot sus_attr_nothrw sus_attr_useret short zap_abs_s( short val);

+

+sus_attr_const sus_attr_hot sus_attr_nothrw sus_attr_useret signed char zap_fma_c( signed char a,signed char b,signed char c);

+sus_attr_const sus_attr_hot sus_attr_nothrw sus_attr_useret int zap_fma_i( int a,int b,int c);

+sus_attr_const sus_attr_hot sus_attr_nothrw sus_attr_useret long zap_fma_l( long a,long b,long c);

+sus_attr_const sus_attr_hot sus_attr_nothrw sus_attr_useret long long zap_fma_ll( long long a,long long b,long long c);

+sus_attr_const sus_attr_hot sus_attr_nothrw sus_attr_useret short zap_fma_s( short a,short b,short c);

+sus_attr_const sus_attr_hot sus_attr_nothrw sus_attr_useret unsigned char zap_fma_uc( unsigned char a,unsigned char b,unsigned char c);

+sus_attr_const sus_attr_hot sus_attr_nothrw sus_attr_useret unsigned int zap_fma_ui( unsigned int a,unsigned int b,unsigned int c);

+sus_attr_const sus_attr_hot sus_attr_nothrw sus_attr_useret unsigned long zap_fma_ul( unsigned long a,unsigned long b,unsigned long c);

+sus_attr_const sus_attr_hot sus_attr_nothrw sus_attr_useret unsigned long long zap_fma_ull(unsigned long long a,unsigned long long b,unsigned long long c);

+sus_attr_const sus_attr_hot sus_attr_nothrw sus_attr_useret unsigned short zap_fma_us( unsigned short a,unsigned short b,unsigned short c);

+

+#if defined(sus_langfeat_c_generic)

+

+#define zap_abs_tg(_val) \

+ (_Generic((_val), \

+ signed char:zap_abs_c, \

+ int: zap_abs_i, \

+ long: zap_abs_l, \

+ long long: zap_abs_ll,\

+ short: zap_abs_s, \

+ )((_val)))

+

+#define zap_fma_tg(_a,_b,_c) \

+ (_Generic((_a), \

+ signed char: zap_fma_c, \

+ int: zap_fma_i, \

+ long: zap_fma_l, \

+ long long: zap_fma_ll, \

+ short: zap_fma_s, \

+ unsigned char: zap_fma_uc, \

+ unsigned int: zap_fma_ui, \

+ unsigned long: zap_fma_ul, \

+ unsigned long long:zap_fma_ull,\

+ unsigned short: zap_fma_us, \

+ )((_a),(_b),(_c)))

+

+#elif defined(sus_lang_cxx)

+

+extern "C++" {

+ sus_attr_const sus_attr_inline sus_attr_useret sus_inline signed char zap_priv_cxxtg_abs(signed char const _val) {return ::zap_abs_c( _val);};

+ sus_attr_const sus_attr_inline sus_attr_useret sus_inline int zap_priv_cxxtg_abs(int const _val) {return ::zap_abs_i( _val);};

+ sus_attr_const sus_attr_inline sus_attr_useret sus_inline long zap_priv_cxxtg_abs(long const _val) {return ::zap_abs_l( _val);};

+ sus_attr_const sus_attr_inline sus_attr_useret sus_inline long long zap_priv_cxxtg_abs(long long const _val) {return ::zap_abs_ll(_val);};

+ sus_attr_const sus_attr_inline sus_attr_useret sus_inline short zap_priv_cxxtg_abs(short const _val) {return ::zap_abs_s( _val);};

+

+ sus_attr_const sus_attr_inline sus_attr_useret sus_inline signed char zap_priv_cxxtg_fma(signed char const _a,signed char const _b,signed char const _c) {return ::zap_fma_c( _a,_b,_c);};

+ sus_attr_const sus_attr_inline sus_attr_useret sus_inline int zap_priv_cxxtg_fma(int const _a,int const _b,int const _c) {return ::zap_fma_i( _a,_b,_c);};

+ sus_attr_const sus_attr_inline sus_attr_useret sus_inline long zap_priv_cxxtg_fma(long const _a,long const _b,long const _c) {return ::zap_fma_l( _a,_b,_c);};

+ sus_attr_const sus_attr_inline sus_attr_useret sus_inline long long zap_priv_cxxtg_fma(long long const _a,long long const _b,long long const _c) {return ::zap_fma_ll( _a,_b,_c);};

+ sus_attr_const sus_attr_inline sus_attr_useret sus_inline short zap_priv_cxxtg_fma(short const _a,short const _b,short const _c) {return ::zap_fma_s( _a,_b,_c);};

+ sus_attr_const sus_attr_inline sus_attr_useret sus_inline unsigned char zap_priv_cxxtg_fma(unsigned char const _a,unsigned char const _b,unsigned char const _c) {return ::zap_fma_uc( _a,_b,_c);};

+ sus_attr_const sus_attr_inline sus_attr_useret sus_inline unsigned int zap_priv_cxxtg_fma(unsigned int const _a,unsigned int const _b,unsigned int const _c) {return ::zap_fma_ui( _a,_b,_c);};

+ sus_attr_const sus_attr_inline sus_attr_useret sus_inline unsigned long zap_priv_cxxtg_fma(unsigned long const _a,unsigned long const _b,unsigned long const _c) {return ::zap_fma_ul( _a,_b,_c);};

+ sus_attr_const sus_attr_inline sus_attr_useret sus_inline unsigned long long zap_priv_cxxtg_fma(unsigned long long const _a,unsigned long long const _b,unsigned long long const _c) {return ::zap_fma_ull(_a,_b,_c);};

+ sus_attr_const sus_attr_inline sus_attr_useret sus_inline unsigned short zap_priv_cxxtg_fma(unsigned short const _a,unsigned short const _b,unsigned short const _c) {return ::zap_fma_us( _a,_b,_c);};

+}

+

+#define zap_abs_tg(_val) (::zap_priv_cxxtg_abs( _val))

+#define zap_fma_tg(_a, _b,_c) (::zap_priv_cxxtg_fma(_a, _b,_c))

+

+#endif

+

+#if defined(sus_lang_cxx)

+}

+#endif

+

+#endif

+/*

+ Copyright 2022 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 <zap/base.h>

+

+#include <stdbool.h>

+#include <stddef.h>

+#include <stdint.h>

+#include <susinfo.h>

+

+#if !defined(zap_priv_hdr_mem)

+#define zap_priv_hdr_mem

+

+#if defined(sus_lang_asm)

+

+.extern zap_fndbyte

+.extern zap_fndchr

+.extern zap_foreach

+.extern zap_memcmp

+.extern zap_memcpy

+.extern zap_memeq

+.extern zap_memfill

+.extern zap_memfill

+.extern zap_strcmp

+.extern zap_strcpy

+.extern zap_streq

+.extern zap_strfill

+.extern zap_strlen

+

+#else

+

+#if defined(sus_lang_cxx)

+extern "C" {

+#endif

+

+sus_attr_hot sus_attr_nothrw sus_attr_useret size_t zap_fndbyte( void const * ptr, size_t num, unsigned char byte);

+sus_attr_hot sus_attr_nothrw sus_attr_useret size_t zap_fndchr( char const * str, char chr);

+sus_attr_hot void zap_foreach( void * ptr, size_t sz, size_t num, void (* fn)(void *));

+sus_attr_hot sus_attr_nothrw sus_attr_useret int_least8_t zap_memcmp( void const * lstr,size_t num, void const * rstr);

+sus_attr_hot sus_attr_nothrw void zap_memcpy( void const * in, size_t num, void * out);

+sus_attr_alloc sus_attr_allocsz(0x2) sus_attr_hot sus_attr_nothrw sus_attr_useret void * zap_memdup( void const * ptr, size_t num);

+sus_attr_hot sus_attr_nothrw sus_attr_useret bool zap_memeq( void const * lptr,size_t num, void const * rptr);

+sus_attr_hot sus_attr_nothrw void zap_memfill( void * ptr, size_t num, unsigned char val);

+sus_attr_hot sus_attr_nothrw sus_attr_useret int_least8_t zap_strcmp( char const * lstr,char const * rstr);

+sus_attr_hot sus_attr_nothrw sus_attr_useret size_t zap_strcpy( char const * in, char * out);

+sus_attr_alloc sus_attr_hot sus_attr_nothrw sus_attr_useret char * zap_strdup( char const * str);

+sus_attr_hot sus_attr_nothrw sus_attr_useret bool zap_streq( char const * lstr,char const * rstr);

+sus_attr_hot sus_attr_nothrw void zap_strfill( char * lstr,char chr);

+sus_attr_hot sus_attr_nothrw sus_attr_useret size_t zap_strlen( char const * str);

+

+#endif

+#if defined(sus_lang_cxx)

+}

+#endif

+

+#endif

+/*

+ Copyright 2022 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 <zap/priv.h>

+

+#include <zap/math.h>

+

+#include <stdint.h>

+

+#if zap_priv_fastimpl

+__asm__ (

+ ".globl zap_abs_c\n"

+ ".globl zap_abs_i\n"

+ ".globl zap_abs_l\n"

+ ".globl zap_abs_ll\n"

+ ".globl zap_abs_s\n"

+

+ "zap_abs_c:\n"

+ /*

+ signed char val

+ */

+#if defined(sus_arch_amd64) || defined(sus_arch_ia32)

+ "movb %dil,%al\n"

+ "sarb $0x3F,%al\n"

+ "xorb %al,%dil\n"

+ "subb %al,%dil\n"

+ "movb %dil,%al\n"

+ "ret\n"

+#endif

+

+ "zap_abs_i:\n"

+ /*

+ int val

+ */

+#if defined(sus_arch_amd64) || defined(sus_arch_ia32)

+ "movl %edi,%eax\n"

+ "sarl $0x3F,%eax\n"

+ "xorl %eax,%edi\n"

+ "subl %eax,%edi\n"

+ "movl %edi,%eax\n"

+ "ret\n"

+#endif

+

+ "zap_abs_l:\n"

+ /*

+ long val

+ */

+#if defined(sus_arch_amd64)

+ "movq %rdi,%rax\n"

+ "sarq $0x3F,%rax\n"

+ "xorq %rax,%rdi\n"

+ "subq %rax,%rdi\n"

+ "movq %rdi,%rax\n"

+ "ret\n"

+#endif

+

+ "zap_abs_ll:\n"

+ /*

+ long long val

+ */

+#if defined(sus_arch_amd64)

+ "movq %rdi,%rax\n"

+ "sarq $0x3F,%rax\n"

+ "xorq %rax,%rdi\n"

+ "subq %rax,%rdi\n"

+ "movq %rdi,%rax\n"

+ "ret\n"

+#endif

+

+ "zap_abs_s:\n"

+ /*

+ short val

+ */

+#if defined(sus_arch_amd64) || defined(sus_arch_ia32)

+ "movw %di,%ax\n"

+ "sarw $0x3F,%ax\n"

+ "xorw %ax,%di\n"

+ "subw %ax,%di\n"

+ "movw %di,%ax\n"

+ "ret\n"

+#endif

+);

+#else

+#define zap_local_abs(_typ,_sufx) \

+ _typ zap_abs_ ## _sufx (_typ const _val) {return _val > (_typ)0x0 ? _val : -_val;}

+

+zap_local_abs(signed char,c)

+zap_local_abs(int,i)

+zap_local_abs(long,l)

+zap_local_abs(long long,ll)

+zap_local_abs(short,s)

+

+#endif

+bool const zap_fastimpl = zap_priv_fastimpl;

+/*

+ Copyright 2022 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 <zap/priv.h>

+

+#include <zap/math.h>

+

+#include <stdint.h>

+

+#if zap_priv_fastimpl

+__asm__ (

+ ".globl zap_fma_c\n"

+ ".globl zap_fma_i\n"

+ ".globl zap_fma_l\n"

+ ".globl zap_fma_ll\n"

+ ".globl zap_fma_s\n"

+ ".globl zap_fma_uc\n"

+ ".globl zap_fma_ui\n"

+ ".globl zap_fma_ul\n"

+ ".globl zap_fma_ull\n"

+ ".globl zap_fma_us\n"

+

+ "zap_fma_c:\n"

+ /*

+ signed char a

+ signed char b

+ signed char c

+ */

+#if defined(sus_arch_amd64)

+ "movb %sil,%al\n"

+ "imulb %dl\n"

+ "addb %dil,%al\n"

+ "ret\n"

+#endif

+

+ "zap_fma_i:\n"

+ /*

+ int a

+ int b

+ int c

+ */

+#if defined(sus_arch_amd64)

+ "movl %edx,%eax\n"

+ "imull %esi\n"

+ "addl %edi,%eax\n"

+ "ret\n"

+#endif

+

+ "zap_fma_l:\n"

+ /*

+ long a

+ long b

+ long c

+ */

+#if defined(sus_arch_amd64)

+ "movq %rdx,%rax\n"

+ "imulq %rsi\n"

+ "addq %rdi,%rax\n"

+ "ret\n"

+#endif

+

+ "zap_fma_ll:\n"

+ /*

+ long long a

+ long long b

+ long long c

+ */

+#if defined(sus_arch_amd64)

+ "movq %rdx,%rax\n"

+ "imulq %rsi\n"

+ "addq %rdi,%rax\n"

+ "ret\n"

+#endif

+

+ "zap_fma_s:\n"

+ /*

+ short a

+ short b

+ short c

+ */

+#if defined(sus_arch_amd64)

+ "movw %dx,%ax\n"

+ "imulw %si\n"

+ "addw %di,%ax\n"

+ "ret\n"

+#endif

+

+ "zap_fma_uc:\n"

+ /*

+ unsigned char a

+ unsigned char b

+ unsigned char c

+ */

+#if defined(sus_arch_amd64)

+ "movb %sil,%al\n" /* mulb uses ax instead of al:dl (like the other variants), so we don't need to worry about it overwritting dl. */

+ "mulb %dl\n"

+ "addb %dil,%al\n"

+ "ret\n"

+#endif

+

+ "zap_fma_ui:\n"

+ /*

+ unsigned int a

+ unsigned int b

+ unsigned int c

+ */

+#if defined(sus_arch_amd64)

+ "movl %edx,%eax\n"

+ "mull %esi\n"

+ "addl %edi,%eax\n"

+ "ret\n"

+#endif

+

+ "zap_fma_ul:\n"

+ /*

+ unsigned long a

+ unsigned long b

+ unsigned long c

+ */

+#if defined(sus_arch_amd64)

+ "movq %rdx,%rax\n"

+ "mulq %rsi\n"

+ "addq %rdi,%rax\n"

+ "ret\n"

+#endif

+

+ "zap_fma_ull:\n"

+ /*

+ unsigned long long a

+ unsigned long long b

+ unsigned long long c

+ */

+#if defined(sus_arch_amd64)

+ "movq %rdx,%rax\n" /* rdx get overwritten by mulq, so might as well just make it the first operand (in multiplication, the order is meaningless). */

+ "mulq %rsi\n"

+ "addq %rdi,%rax\n"

+ "ret\n"

+#endif

+

+ "zap_fma_us:\n"

+ /*

+ unsigned short a

+ unsigned short b

+ unsigned short c

+ */

+#if defined(sus_arch_amd64)

+ "movw %dx,%ax\n"

+ "mulw %si\n"

+ "addw %di,%ax\n"

+ "ret\n"

+#endif

+);

+#else

+#define zap_local_fma(_typ,_sufx) \

+ _typ zap_fma_ ## _sufx (_typ const _a,_typ const _b,_typ const _c) {return _a + _b * _c;}

+

+zap_local_fma(signed char,c)

+zap_local_fma(int,i)

+zap_local_fma(long,l)

+zap_local_fma(long long,ll)

+zap_local_fma(short,s)

+zap_local_fma(unsigned char,uc)

+zap_local_fma(unsigned int,ui)

+zap_local_fma(unsigned long,ul)

+zap_local_fma(unsigned long long,ull)

+zap_local_fma(unsigned short,us)

+

+#endif

+#include <zap/mem.h>

+

+#if zap_priv_fastimpl

+ void const * pos

+ size_t num

+ unsigned char byte

+size_t zap_fndbyte(void const * const _ptr,size_t const _num,unsigned char const _byte) {

+ unsigned char const * startpos = _ptr;

+ unsigned char const * pos = startpos;

+ unsigned char const * const afterbuf = pos + _num;

+ for (;pos != afterbuf;++pos) {sus_unlikely (*pos == _byte) {return pos - startpos;}}

+#include <zap/mem.h>

+

+#if zap_priv_fastimpl

+#include <zap/mem.h>

+

+ unsigned char * pos = _ptr;

+ size_t const numbyte = _sz * _num;

+ unsigned char * const afterbuf = pos + numbyte;

+ for (;pos != afterbuf;pos += _sz) {_fn(pos);}

+#include <zap/mem.h>

+

+ unsigned char const * lpos = _lstr;

+ unsigned char const * rpos = _rstr;

+ sus_likely (lbyte != rbyte) {return lbyte < rbyte ? INT_LEAST8_MIN : INT_LEAST8_MAX;}

+#include <zap/mem.h>

+

+#if zap_priv_fastimpl

+ unsigned char const * in = _in;

+ unsigned char * out = _out;

+ unsigned char const * const afterbuf = in + _num;

+#include <zap/mem.h>

+

+#include <zap/mem.h>

+

+#if zap_priv_fastimpl

+ unsigned char const * lpos = _lptr;

+ unsigned char const * rpos = _rptr;

+ unsigned char const * const afterbuf = lpos + _num;

+#include <zap/mem.h>

+

+#if zap_priv_fastimpl

+ void const * ptr

+ size_t num

+ unsigned char val

+void zap_memfill(void * const _ptr,size_t const _num,unsigned char const _byte) {

+ unsigned char * pos = _ptr;

+ unsigned char * const afterbuf = pos + _num;

+#include <zap/mem.h>

+

+ sus_likely (lchr != rchr) {return lchr < rchr ? INT_LEAST8_MIN : INT_LEAST8_MAX;}

+#include <zap/mem.h>

+

+#if zap_priv_fastimpl

+ if (chr == '\x0') {return inpos - _in;}

+#include <zap/mem.h>

+

+#include <zap/mem.h>

+

+#if zap_priv_fastimpl

+#include <zap/mem.h>

+

+void zap_strfill(char * const _str,char const _chr) {zap_memfill(_str,zap_strlen(_str),(unsigned char)_chr);}

+#include <zap/mem.h>

+

+#if zap_priv_fastimpl