foundational_lib 1.0

data/tools/RSUB_LICENSE.txt

@@ -0,0 +1,25 @@
+BSD 2-Clause License
+
+Copyright (c) 2023, Gregory Cohen
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/tools/benchmark_libc.c

@@ -0,0 +1,263 @@
+// Just a little benchmark program to test out libc.
+//
+// memmem() is REALLY fast.
+//
+// To compile
+// gcc benchmark_libc.c -o benchmark_libc -O2 -Wall -Werror -Wextra -s -fwhole-program&& ./l | editor
+
+#include "foundationallib.h"
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+
+FOUNDATIONAL_LIB_FUNC void *FOUNDATIONAL_LIB_mempcpy(void *dest, const void *src, size_t n)
+{
+    char *d = dest;
+    const char *s = src;
+
+    while (n--)
+    {
+        *d++ = *s++;
+    }
+
+    return d;
+}
+
+FOUNDATIONAL_LIB_FUNC void FOUNDATIONAL_LIB_memcpy(char *restrict dest, const char *restrict src, size_t n)
+{
+    while (n--)
+    {
+        *dest++ = *src++;
+    }
+}
+FOUNDATIONAL_LIB_FUNC char *FOUNDATIONAL_LIB_stpcpy(char *restrict dst, const char *restrict src)
+{
+    char *p;
+
+    p = FOUNDATIONAL_LIB_mempcpy(dst, src, strlen(src));
+    *p = '\0';
+
+    return p;
+}
+
+FOUNDATIONAL_LIB_FUNC char *FOUNDATIONAL_LIB_STRCPY(char *restrict dst, const char *restrict src)
+{
+    stpcpy(dst, src);
+    return dst;
+}
+
+FOUNDATIONAL_LIB_FUNC char *FOUNDATIONAL_LIB_FOUNDATIONAL_LIB_STRCAT(char *restrict dst, const char *restrict src)
+{
+    stpcpy(dst + strlen(dst), src);
+    return dst;
+}
+
+FOUNDATIONAL_LIB_FUNC int FOUNDATIONAL_LIB_FUNC_memcmp(const void *s1, const void *s2, size_t n)
+{
+    const unsigned char *u1 = s1;
+    const unsigned char *u2 = s2;
+
+    while (n--)
+    {
+        if (*u1 != *u2)
+        {
+            return (*u1 < *u2) ? -1 : 1;
+        }
+
+        u1++;
+        u2++;
+    }
+
+    return 0;
+}
+
+FOUNDATIONAL_LIB_FUNC void *memory_locate_(const void *haystack, size_t haystack_len, const void *needle, size_t needle_len)
+{
+    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(haystack);
+    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(needle_len);
+    if (FOUNDATIONAL_LIB_UNLIKELY(needle_len == 0))
+    {
+        return (void *)haystack;
+    }
+
+    if (FOUNDATIONAL_LIB_UNLIKELY(haystack_len < needle_len))
+    {
+        return NULL;
+    }
+
+    const char *h = (const char *)haystack;
+    const char *n = (const char *)needle;
+
+    const size_t max_search = haystack_len - needle_len;
+    for (size_t i = 0; i <= max_search; ++i)
+    {
+        if (FOUNDATIONAL_LIB_MEMCMP(h + i, n, needle_len) == 0)
+        {
+            return (void *)(h + i);
+        }
+    }
+
+    return NULL;
+}
+
+static void one(char *file, const char *str, size_t str_len, size_t size, size_t times)
+{
+    char *pointer_total = 0;
+
+    clock_t a, b;
+    a = clock();
+    for (size_t i = 0; i < times; ++i)
+    {
+        pointer_total += (size_t)memory_locate_(file, size, str, str_len);
+    }
+    b = clock();
+    double used = (double)(b - a) / CLOCKS_PER_SEC;
+    printf("1. memory_locate_ %lf %p pointer is %p\n\t", used, pointer_total, memory_locate(file, size, str, str_len));
+
+    //    		fwrite(memory_locate(file, size, str,str_len)-30, str_len+60, 1, stdout);
+    assert(memcmp(memory_locate(file, size, str, str_len), str, str_len) == 0);
+    puts("");
+}
+
+static void two(char *file, const char *str, size_t str_len, size_t size, size_t times)
+{
+    puts("two");
+    char *pointer_total = 0;
+
+    clock_t a, b;
+    a = clock();
+    for (size_t i = 0; i < times; ++i)
+    {
+        pointer_total += (size_t)memmem(file, size, str, str_len);
+    }
+    printf("%p\n", memmem(file, size, str, str_len));
+    b = clock();
+    double used = (double)(b - a) / CLOCKS_PER_SEC;
+    printf("2. memmem %lf %p pointer is %p\n\t", used, pointer_total, memory_locate(file, size, str, str_len));
+
+    //		fwrite(memory_locate(file, size, str,str_len)-30, str_len+60, 1, stdout);
+    assert(memcmp(memory_locate(file, size, str, str_len), str, str_len) == 0);
+    puts("");
+}
+
+static void three(char *file, const char *str, size_t str_len, size_t size, size_t times)
+{
+    char *pointer_total = 0;
+
+    clock_t a, b;
+    a = clock();
+    for (size_t i = 0; i < times; ++i)
+    {
+        pointer_total += (size_t)strstr(file, str);
+    }
+    printf("%p\n", memmem(file, size, str, str_len));
+    b = clock();
+    double used = (double)(b - a) / CLOCKS_PER_SEC;
+    printf("3. strstr %lf %p pointer is %p\n\t", used, pointer_total, memory_locate(file, size, str, str_len));
+
+    //		fwrite(memory_locate(file, size, str,str_len)-30, str_len+60, 1, stdout);
+    assert(memcmp(memory_locate(file, size, str, str_len), str, str_len) == 0);
+    puts("");
+}
+
+static double four(char *file, const char *str, size_t str_len, size_t size, size_t times)
+
+{
+    clock_t a, b;
+    a = clock();
+    volatile char *buf = malloc(16384);
+    for (size_t i = 0; i < times; ++i)
+    {
+        memcpy(buf + i, str, 16384 - i);
+    }
+    free(buf);
+    b = clock();
+    double used = (double)(b - a) / CLOCKS_PER_SEC;
+    printf("4. memcpy %lf\n", used);
+
+    //		fwrite(memory_locate(file, size, str,str_len)-30, str_len+60, 1, stdout);
+    assert(memcmp(memory_locate(file, size, str, str_len), str, str_len) == 0);
+    puts("");
+    return used;
+}
+
+static double five(char *file, const char *str, size_t str_len, size_t size, size_t times)
+{
+    (void)file;
+    (void)size;
+    (void)str_len;
+
+    clock_t a, b;
+    a = clock();
+    const size_t size_ = 16384;
+    volatile char *buf = malloc(size_);
+    for (size_t i = 0; i < times; ++i)
+    {
+        FOUNDATIONAL_LIB_memcpy(buf, str, size_);
+    }
+    free(buf);
+    b = clock();
+    double used = (double)(b - a) / CLOCKS_PER_SEC;
+    printf("5. memcpy copy %lf\n", used);
+
+    puts("");
+
+    return used;
+}
+
+static double six(char *file, const char *str, size_t str_len, size_t size, size_t times)
+{
+    (void)file;
+    (void)size;
+    (void)str_len;
+
+    clock_t a, b;
+    a = clock();
+    volatile char *buf = malloc(size_);
+    for (size_t i = 0; i < times; ++i)
+    {
+        __builtin_memcpy(buf + i, str, 16384 - i);
+    }
+    free(buf);
+    b = clock();
+    double used = (double)(b - a) / CLOCKS_PER_SEC;
+    printf("6. __builtin_memcpy %lf\n", used);
+
+    puts("");
+
+    return used;
+}
+
+int main()
+{
+
+    puts("Benchmark.");
+
+    size_t size = 0;
+    char *file = read_file_into_string("/usr/share/dict/words", &size);
+
+    const char *str = "zealousness's";
+    size_t str_len = strlen(str);
+
+    assert(memory_has_subchunk(file, size, str, str_len) == 1);
+    const size_t times = 500000000000000;
+    const size_t times2 = 2000;
+
+    for (int t = 0; t < 1; ++t)
+    {
+
+        one(file, str, str_len, size, times2);
+        two(file, str, str_len, size, times2);
+        three(file, str, str_len, size, times2);
+        double time = four(file, file, str_len, size, times);
+        double time2 = five(file, file, str_len, size, times);
+        double time3 = six(file, file, str_len, size, times);
+
+        printf("Custom memcpy() (probably using __builtin_memcpy()) is %lf times faster than default memcpy()\n", time / time2);
+        printf("__builtin_memcpy() is %lf times faster than default memcpy()\n", time / time3);
+    }
+
+    return 0;
+}

data/tools/deprecated/GENERATE_CUSTOM_FOUNDATIONALLIB.sh.old

@@ -0,0 +1,67 @@
+#!/bin/bash
+# This is somewhat broken - this script.
+# 2023, Gregory Cohen <gregorycohennew@gmail.com>
+#
+#
+#    DONATION REQUEST: If this free software has helped you and you find
+#    it valuable, please consider making a donation to support the ongoing
+#    development and maintenance of this project. Your contribution helps
+#    ensure the availability of this library to the community and encourages
+#    further improvements.
+#
+#
+#                          Donations can be made at:
+#                 https://www.paypal.com/paypalme/cfoundationallib
+#
+#	This code is in the Public domain. You are free to do anything with it.
+#
+#
+set -e
+# Check if the number of arguments is not equal to 3
+if [ "$#" -ne 3 ]; then
+	echo "Generate custom \`foundationallib' library (github.com/gregoryc/foundationallib) with a given prefix to make it customized and to avoid any possibility whatsoever of namespace collisons."
+	echo "Usage $0 <origin_header_file> <prefix (e.g., \"l\", \"g\", [your company name], etc.> <custom_header_output_file>"
+	exit 1
+fi
+
+function green_text() {
+	# ANSI escape code for green text
+	GREEN='\033[0;32m'
+	NC='\033[0m' # No Color
+
+	# Print text in green
+	echo -e "${GREEN}$1${NC}"
+}
+
+function main() {
+	prefix="$2"
+	outfile="$3"
+	inputfile="$1"
+
+	data=$(
+		cat "$inputfile" | grep -oP '^(FOUNDATIONAL_LIB_FUNC|struct).+?\(' | sort -r  |
+			sed -E "s/(FOUNDATIONAL_LIB_FUNC|struct)\s+.*?\s+\**?([a-zA-Z0-9_]+).*?\(/sed 's\/\\2\/${prefix}\\2\/'/"
+
+	)
+	# Iterate over the lines in data and combine them with |
+	while IFS= read -r line; do
+		combined_data+="|$line"
+	done <<<"$data"
+
+	data="cat $inputfile | sed -E 's/struct (stat|dirent)/struct \/\/\n\\1/g' | sed -E 's/(FOUNDATIONAL_LIB)/${prefix}\\1/g' | sed -E 's/struct (.+;)/struct ${prefix}\\1/g' | sed -E 's/struct ThreadData/struct ${prefix}ThreadData/g' ${combined_data} | sed -E 's/${prefix}filter_func/filter_func/g' | sed -E 's/thrd_${prefix}join/thrd_join/g' | sed -E 's/${prefix}(map_function|reduce_function)/\\1/g' | sed -E 's/struct (DictKeyValue|SetKey|FrozenDict|FrozenSet|Dict|Set)/struct ${prefix}\\1/g'  | sed -E 's/\s(dict_destructor|set_destructor)/${prefix}\\1/g' | sed -E 's/struct \/\//struct /gm'"
+	eval "$data" >"$outfile"
+
+	green_text "Custom foundationallib.h file generated to $(realpath $outfile)"
+
+	echo "#include \"$outfile\"" >"${prefix}example.c"
+	echo "int main() { int array[] = {1, 2, 3, 4, 5}; ${prefix}print_int_array(array, 5); printf(\"\\nIt compiles and runs\"); }" >>"${prefix}example.c"
+
+	gcc -Wall -Werror -Wextra -Wfatal-errors "${prefix}example.c" -o "${prefix}example_out"
+	"./${prefix}example_out"
+	green_text "Compiles and runs (${prefix}example_out) using $(realpath $outfile)."
+	rm -f "${prefix}example_out" "${prefix}example.c"
+
+	echo "All good."
+}
+
+main "$1" "$2" "$3"

data/tools/deps_for_testing.sh

@@ -0,0 +1,23 @@
+#!/bin/sh
+
+sudo apt update && \
+	sudo apt install ruby-dev ruby clang-format valgrind build-essential graphviz && \
+	sudo gem install rouge puppeteer-ruby
+exit 0
+
+#sudo apt update && \
+#	sudo dnf install ruby-dev ruby clang-format valgrind build-essential graphviz && \
+#	sudo gem install rouge puppeteer-ruby
+
+#If you want to run all the different scripts in this repository,
+#you just need these
+
+
+#ruby-dev ruby clang-format valgrind build-essential graphviz
+
+#and gem intall rouge puppeteer-ruby
+
+#and nothing else
+
+#Of course, some scripts don't need all of these, but if you
+# install these it makes for easy testing.

data/tools/documentation_generate

@@ -0,0 +1,17 @@
+set -e
+set -x
+
+cd ../docs
+rm -r -f html
+doxygen Doxyfile || (
+	# We don't want absolute file paths
+	# recursively replace them with '.'
+	cd ..
+	echo $PWD
+	tools/rsub $PWD '.'
+	exit 1
+)
+
+cd ..
+echo $PWD
+tools/rsub $PWD '.'