foundational_lib 1.0

data/tools/run_lib

@@ -0,0 +1,365 @@
+#!/usr/bin/env ruby
+$dangerous_c_functions_to_fail_to_compile_if_detected = [
+  "gets", "fgets",
+  "strcpy", "strcat",
+  "sprintf", "vsprintf",
+  "scanf", "fscanf",
+  "system",
+  "chown", "chmod", "chgrp",
+  "alloca",
+  "execl", "execle", "execlp", "execv", "execve", "execvp",
+  "bcopy", "bzero",
+]
+
+puts "Not using #{$dangerous_c_functions_to_fail_to_compile_if_detected.inspect}"
+
+file_name = "funcs_c"
+FILE_NAME = file_name
+at_exit do
+  system "rm -f destination_file.txt ex_ample.txt existing_file.txt source_file.txt"
+end
+
+NETWORKING = false
+
+if ARGV[0] == "short"
+  short = "short"
+elsif ARGV[0] == "supershort"
+  short = "supershort"
+else
+  short = ""
+end
+
+
+def format_file(file, suf = "")
+  #return
+
+  require "shellwords"
+
+  c = <<CMD
+clang-format -i -style="{BasedOnStyle: LLVM, IndentWidth: 4, UseTab: Never, IndentCaseLabels: true, ColumnLimit: 500, BreakBeforeBraces: Allman}" 
+CMD
+  #"
+  c.strip!
+  file = file.shellescape
+  c << " " << file
+  c << suf
+  puts c
+  system c, exception: true
+end
+
+def fix(string)
+  string.gsub(/\n{3,}/, "\n\n").gsub(/\*\/\n+FOUN/m, "*/\nFOUN")
+end
+
+def write_file(a, b)
+  File.write(a, fix(b))
+end
+
+FORMAT = true
+
+if FORMAT && short == ""
+  format_file file_name
+end
+
+
+VALGRIND = "valgrind --leak-check=full --show-leak-kinds=all --exit-on-first-error=yes --error-exitcode=1"
+if FORMAT
+  system "which clang-format > /dev/null", exception: true
+end
+require "fileutils"
+
+begin
+  FileUtils.cd "tools"
+rescue StandardError
+end
+
+begin
+  FileUtils.mkdir_p "../platforms/header_and_separate_compilation_unit"
+rescue StandardError
+end
+
+data = <<INTRO
+/*
+ *   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 use it for any commercial or noncommercial purpose.
+ * 
+ */
+
+#ifndef _FOUNDATIONAL_LIB_HEADER_GUARD
+#define _FOUNDATIONAL_LIB_HEADER_GUARD
+
+#ifdef _WIN32
+#define _CRT_RAND_S
+#endif
+
+#include <stdint.h> /* FOR SIZE_MAX */
+#include <ctype.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+#include <assert.h>
+
+/* Make sure memmem() is defined in all cases to avoid warnings or errors. */
+void *memmem(const void *haystack, size_t haystacklen, const void *needle, size_t needlelen);
+
+// structs (types)
+struct Dict;
+struct FrozenDict;
+struct Set;
+struct FrozenSet;
+
+#ifndef FOUNDATIONAL_LIB_AGGRESSIVE_DIE_TYPE
+/**
+ * @brief Type of the aggressive die variable.
+ *
+ * This macro defines the type of the aggressive die variable, which
+ * uses 1 byte of overhead by default. It can be configured as static
+ * or nonstatic based on user preference.
+ */
+#define FOUNDATIONAL_LIB_AGGRESSIVE_DIE_TYPE unsigned char
+#endif
+
+
+
+INTRO
+
+# C++ is more strict, so catch more possible errors
+write_file file_name, fix(File.read(file_name))
+
+def get_headers(foundational_lib_func_replacement, hg = true)
+  require "set"
+  malloc_func = false
+
+  current_func = ""
+
+  malloc_funcs = Set.new
+
+  file = File.read("funcs_c").gsub("static", "")
+
+  $dangerous_c_functions_to_fail_to_compile_if_detected.map do |i|
+    "(" + i + "\\([^\\n]+?\\)" + ")"
+  end.each do |q|
+    if match = file.match(/#{q}/mi)
+      raise match.to_s
+    end
+  end
+
+  if match = file.match(/^(size_t|void)/)
+    raise match.to_s
+  end
+  if match = file.match(/=\s*(malloc|realloc|calloc)\(/)
+    raise match.to_s
+  end
+  if match = file.match(/^\s*free\(/)
+    raise match.to_s
+  end
+
+  line_num = 0
+  match = file.gsub("char *", "").gsub("\n") do |i|
+    "\n#{line_num += 1}."
+  end.split("\n").grep(/ALLOC|CPY/).map do |i|
+    i.split("//")[0]
+  end.grep(/ [\*\-\+\/] /)
+  match -= match.grep(/FOUNDATIONAL_LIB_FUNC|#define|^.*\*\/\s*$|^\s*\d+\.\s*\* /)
+
+  match -= match.grep(/Safe/)
+
+  if match.size > 0
+    # If unsable allocation, fail to compile.
+    match.join("\n").gsub("()", "(char *)").split("\n").each_with_index do |i, index|
+      puts i
+      cmd = "micro +%s:80 %s" % [i.split(".", 2).first.to_i + 1, FILE_NAME]
+      puts cmd
+      system cmd
+      exit
+      puts "#{index} | #{i}"
+    end
+
+    exit if ARGV.first == "e"
+  end
+
+  file.split("\n").each_with_index do |line, index|
+    index += 1
+    if match = (line.match /(?:static inline|FOUNDATIONAL_LIB_FUNC) ([_0-9a-zA-Z\* ]+) ([\*_a-zA-Z0-9]+)\(.+/)
+      if match[2].match /test/
+      else
+        current_func = match[0].gsub("FOUNDATIONAL_LIB_FUNC", foundational_lib_func_replacement).split("{", 2)[0].strip
+      end
+      next
+    elsif line.match /FOUNDATIONAL_LIB_FUNC/
+      unless line.match /#ifndef|#define/
+        raise [index, line].inspect
+      end
+    end
+    if !malloc_func || ((line.match /FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_/) && !line.match(/FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_FREE|#ifndef|#ifdef|#define/))
+      # puts "%s" % [current_func, line.strip.clear]
+      unless current_func.strip == ""
+        malloc_funcs.add current_func + ";"
+      end
+    end
+  end
+  funcs = malloc_funcs.to_a.sort
+
+  # Remove internal functions like lib compare ushorts etc.
+  funcs -= funcs.grep(/FOUNDATIONAL/)
+
+  #  raise(match.to_s) if match = funcs.grep(/FOUNDATIONAL/)
+
+  hg = ""
+  hge = ""
+  if hg
+    hg = "#ifndef _FOUNDATIONAL_LIB_HEADER_GUARD
+#define _FOUNDATIONAL_LIB_HEADER_GUARD
+"
+
+    hge = "#endif"
+  end
+
+  "
+#{hg}
+#include <ctype.h>
+#include <stdarg.h>
+#include <stdio.h>
+#ifdef _WIN32
+#define _CRT_RAND_S
+#endif
+#include <stdlib.h>
+
+
+#include <string.h>
+
+
+#include <errno.h>
+
+
+#ifndef FOUNDATIONAL_LIB_AGGRESSIVE_DIE_TYPE
+/**
+ * @brief Type of the aggressive die variable.
+ *
+ * This macro defines the type of the aggressive die variable, which
+ * uses 1 byte of overhead by default. It can be configured as static
+ * or nonstatic based on user preference.
+ */
+#define FOUNDATIONAL_LIB_AGGRESSIVE_DIE_TYPE static unsigned char
+#endif
+
+struct Dict;
+struct FrozenDict;
+struct Set;
+struct FrozenSet;
+" << ($funcs = funcs.join("\n")) << "\n" << hge
+end
+
+# If even a single function is not documented, fail.
+nondocs = []
+
+File.read(file_name).gsub(/FOUNDATIONAL_LIB_([A-Z]+)\s*\nFOUNDATIONAL_LIB_FUNC [a-z]+ test[a-zA-Z0-9_]+/m) do |i|
+  raise i
+end
+
+File.read(file_name).gsub(/\}\s+(?:FOUNDATIONAL_LIB_[A-Z]+\s+)*(static inline|FOUNDATIONAL_LIB_FUNC)([^\n]+)/m) do |i|
+  nondocs << i
+  nil
+end
+
+nondocs -= nondocs.grep(/test/)
+unless nondocs.size == 0
+  puts nondocs
+  raise "lacking docs"
+end
+
+main = nil
+
+data2 = data + (File.read(file_name).gsub(/(int main|((FOUNDATIONAL_LIB_FUNC|static inline) (int|void|char) \**test.*?))\s*\(.*?\)\s*.*?\n\}/m) do |i|
+  if i.match /int main/
+    main = i
+  end
+
+  if i.match /#define/
+    raise i.to_s
+  end
+  ""
+end)
+raise if main.nil?
+DELIM = "Philosophy of this is in"
+data2 = data2.split(DELIM, 2)
+
+data2[1].gsub!(/^.*[tT]est.*$/, "")
+
+raise if data2[0].size < 100
+
+#puts data2[0]
+data2 = data2.join(DELIM)
+
+data2 = data2.gsub("#include <assert.h>\n", "") + "\n#endif"
+
+puts nondocs.sort
+write_file "HEADERS.h", get_headers("")
+write_file "HEADERS_ONLY_FUNCTIONS.h", $funcs + "\n"
+write_file "HEADERS_WITH_PREFIX.h", get_headers("FOUNDATIONAL_LIB_FUNC")
+write_file "foundationallib.h", data2
+write_file "../foundationallib.h", data2
+
+# If the person wants a module to link with,
+# then we change the per compilation unit aggressive die variable
+# (used to control error handling at runtime, it usually takes 1 byte
+# per compilation unit), and make it global
+# for the whole program - 1 byte of overhead to control error
+# handling (actually, this can save on code,
+# if aggressive die is set to true (1) )
+#
+# The variable will be defined in this file only, and not the header then.
+
+regex = /(FOUNDATIONAL_LIB_PURE|FOUNDATIONAL_LIB_NOTHROW|FOUNDATIONAL_LIB_MALLOC|FOUNDATIONAL_LIB_WARN_UNUSED_RESULT|FOUNDATIONAL_LIB_NONNULL|FOUNDATIONAL_LIB_PRINTF_FUNC)\n/m
+write_file("../platforms/header_and_separate_compilation_unit/foundationallib_noninline.c",
+           ("#include \"./foundationallib_noninline.h\"\n" + "#define FOUNDATIONAL_LIB_UNSAFE_FUNCTIONS_ENABLED 0\n\n" + data2.gsub(regex, " \\1 ").gsub(/static inline/, " ").gsub(/inline/, " ").gsub("#ifndef _FOUNDATIONAL_LIB_HEADER_GUARD\n#define _FOUNDATIONAL_LIB_HEADER_GUARD", "#if 1")))
+
+write_file "../platforms/header_and_separate_compilation_unit/foundationallib_noninline.h", get_headers("")
+format_file("../platforms/header_and_separate_compilation_unit/foundationallib_noninline.c", "&")
+
+write_file("../platforms/header_and_separate_compilation_unit_all_safe_funcs/foundationallib_noninline.c",
+           ("#include \"./foundationallib_noninline.h\"\n" + "#define FOUNDATIONAL_LIB_UNSAFE_FUNCTIONS_ENABLED 0\n\n" + data2.gsub(regex, " \\1 ").gsub(/static inline/, " ").gsub(/inline/, " ").gsub("#ifndef _FOUNDATIONAL_LIB_HEADER_GUARD\n#define _FOUNDATIONAL_LIB_HEADER_GUARD", "#if 1")))
+
+format_file("../platforms/header_and_separate_compilation_unit_all_safe_funcs/foundationallib_noninline.c", "&")
+write_file "../platforms/header_and_separate_compilation_unit_all_safe_funcs/foundationallib_noninline.h", "#define FOUNDATIONAL_LIB_UNSAFE_FUNCTIONS_ENABLED 0\n\n" + get_headers("")
+
+omit_list =/FOUNDATIONAL_LIB_PURE|FOUNDATIONAL_LIB_NOTHROW|FOUNDATIONAL_LIB_MALLOC|FOUNDATIONAL_LIB_WARN_UNUSED_RESULT|FOUNDATIONAL_LIB_NONNULL|FOUNDATIONAL_LIB_PRINTF_FUNC/m
+write_file "../docs/src/foundationallib.h", data2.gsub(omit_list, "")
+write_file wtests = file_name.sub(/_c.c$/, "") + "_with_tests.c", wtests_data = data.sub("struct FrozenSet;\n", "struct FrozenSet;\n\n#define test_foundationallib_test_error_handler(msg) perror(msg); exit(1);\n\n") + File.read(file_name) + "\n#endif"
+write_file "../tests/lib_and_tests.c", wtests_data
+puts "Copied."
+if ARGV[0] == "norun"
+  puts "No run"
+else
+  if NETWORKING
+    curl_flag = "-lcurl"
+  else
+    curl_flag = ""
+  end
+
+  # C++ is more strict, so catch more possible errors
+  cmd = "set -x; set -e;
+  gcc -DFOUNDATIONAL_LIB_LIBC_LOCKING_IO_OPERATIONS=0   -DFOUNDATIONAL_LIB_ASSERT_ARGUMENT_CHECKING=0 -O2 -pedantic -xc -m32 -g #{wtests} -o with_tests32 -Wall -Wextra -Werror -Wfatal-errors #{curl_flag} &&\\
+  g++ -DFOUNDATIONAL_LIB_ASSERT_ARGUMENT_CHECKING=1    -pedantic -xc++ -g #{wtests} -o with_tests -Wall -Wextra -Werror -Wfatal-errors #{curl_flag} &&\\
+./with_tests #{short}   && #{VALGRIND} ./with_tests #{short}"
+  puts cmd
+  system cmd, exception: true
+end

data/tools/update

@@ -0,0 +1,44 @@
+#!/bin/bash
+set -x
+set -e
+
+cd ../tools/..
+for file in `find -name '*.c'`
+do
+clang-format -style="{BasedOnStyle: LLVM, IndentWidth: 4, UseTab: Never, IndentCaseLabels: true, ColumnLimit: 500, BreakBeforeBraces: Allman}" -i "$file"
+done
+
+cd ./tools
+
+if test "$1" = "fast"; then
+	cond=true
+	echo Fast
+else
+	echo Checking
+	./run_lib 2>&1 | grep -q 'ERROR SUMMARY: 0 errors from 0 contexts'
+fi
+
+if [ $? -eq 0 ]; then
+	./documentation_generate
+	./make_image_of_docs
+	cd ../tests
+	./run_test_suite.sh
+	cd ../tools
+	ruby lynx.rb
+	cd ..
+	./GENERATE_CUSTOM_FOUNDATIONALLIB.rb foundationallib.h MY_COMPANY_ custom_library_example.h
+
+	cd platforms/header_and_separate_compilation_unit
+
+	make clean || true
+	make
+
+	./non_inline_example
+
+	exit 0
+else
+	echo Failed to run
+	exit 1
+fi
+
+exit 1

data/transpile_slow_scripting_into_c.rb

@@ -0,0 +1,225 @@
+#!/usr/bin/env ruby
+#
+#
+#
+# transpile_slow_scripting_into_c.rb
+# Usage: transpile_slow_into_c.rb <file-to-transpile> <out-file [/dev/stdout] by default>
+
+# The output then has helpful comments to allow you to easily transpile the scripting language into fast C, either with ChatGPT or manually.
+# This is an invaluable resource to help you speed up code - in general.
+# And the C functions in this library are very very fast and tested.
+#
+# I would appreciate someone making this script longer and better to acommodate for more languages.
+# That would be a great contribution. Please email me <gregorycohennew@gmail.com>.
+#
+#
+# It would be great if this took an OpenAI API key and then used GPT4 to transpile.
+# Could do a hell of a good and safe job - because these functions are really obvious how they work and have exceptional error handling.
+#
+
+def green(str = "", file = STDOUT)
+  if file.tty?
+    green = "\033[0;32m"
+    nc = "\033[0m" # No Color
+    file.puts green << str << nc << "\n"
+  else
+    file.puts str
+  end
+end
+
+if ARGV.size != 1 && ARGV.size != 2
+  GREEN = '\033[0;32m'
+  NC = '\033[0m' # No Color
+  green "transpile_slow_into_c.rb"
+  green
+  green "Usage: transpile_slow_into_c.rb <file-to-transpile> <out-file [/dev/stdout] by default>"
+  green
+  green
+  green "The output then has helpful comments to allow you to easily transpile the scripting language into fast C, either with ChatGPT or manually."
+  green "This is an invaluable resource to help you speed up code - in general."
+
+  green "And the C functions in this library are very very fast and tested."
+
+  green
+
+  green "I would appreciate someone making this script longer and better to acommodate for more languages."
+
+  green "That would be a great contribution. Please email me <gregorycohennew@gmail.com>."
+  green
+  green "It would be great if this took an OpenAI API key and then used GPT4 to transpile."
+  green "Could do a hell of a good and safe job - because these functions are really obvious how they work and have exceptional error handling."
+
+  exit 1
+end
+outfile = ARGV[1] || "/dev/stdout"
+green("Writing to #{outfile}", file = STDERR)
+
+H = File.read(`find -name HEADERS_ONLY_FUNCTIONS.h`.chomp("\n"))
+H_LINES = H.split("\n")
+$out = String.new
+
+def puts(str = "")
+  $out << str << "\n"
+end
+
+$comments = 0
+in_ = File.read(ARGV.first)
+
+def tr(*a)
+  $comments += 1
+  first = a.shift.split(/\s+OR\s+/i)
+  rest = a.flatten
+  if rest.size > 1
+    q = "#                     "
+    q2 = q + "    "
+    newline = "\n"
+  else
+    q = ""
+    q2 = ""
+    newline = " "
+  end
+
+  num = 0
+
+  first = first.map do |i|
+    res = String.new
+    if first.size > 1
+      #num += 1
+      #res << num.to_s << ". "
+    end
+    res + i + "()"
+  end.join(" or ")
+
+  num = 0
+
+  rest = rest.map do |i|
+    if i.class == Array
+      raise rest.to_s
+    end
+    res = String.new
+    if rest.size > 1
+      num += 1
+      res << num.to_s << ". "
+    end
+    res << i.chomp(";")
+
+    if rest.size > 1
+      res << "\n"
+    else
+      res << " "
+    end
+
+    res << q
+  end.join(" or ")
+
+  "    # Transpile #{first} with | #{newline}" << q2 << (rest) << " as appropriate."
+end
+
+line_n = 0
+in_.each_line do |line|
+  line_n += 1
+  if line_n == 2
+    require "shellwords"
+    puts "# Generated from #{File.basename __FILE__}"
+    nlines = "#\n" + `echo #{"Allows for easy transpilation from slow languages that hinder people's lives in many ways (scriping languages) into machine-efficient code that actually runs the same operations without wasting CPU power, electricity, money, time, user's (programmer's) programmatic interactivity (ability to quickly run and recompile near-instantly) or people's attention, and is somewhat ideal.".shellescape}  | fmt -w 78`
+    nlines << "\n" << `echo #{"You can easily (manually, or with AI) transpile this code now into code that actually runs fast - and actually compiles quickly (C++, Crystal and Rust can't do this and are awful at it, especially the latter two - Zig maybe is good); is safe; has good error handling; and performs the intended operations, with ease.".shellescape}  | fmt -w 78`
+    nlines.gsub! "\n", "\n# "
+
+    puts nlines
+    nlines = nil
+  end
+
+  newline = line.chomp("\n")
+  if newline.strip == ""
+    puts
+    next
+  end
+
+  if (newline.include? "length") || (newline.include? "size")
+    newline << tr("length or size", (["strlen()"] + H_LINES.grep(/_size\(/)))
+  end
+
+  if newline.include? "replace"
+    newline << tr("replace", H_LINES.grep(/replace_all\(/))
+  end
+  if newline.include? "uniq"
+    newline << tr("uniq", H_LINES.grep(/uniq\(/))
+  end
+
+  # PHP
+  if newline.include? "file_get_contents"
+    newline << tr("file_get_contents", H_LINES.grep(/read_file_into_array\(/))
+  end
+
+  # Python, Ruby
+  if newline.include? "readlines"
+    newline << tr("readlines", H_LINES.grep(/read_file_into_array\(/))
+  end
+
+  # Ruby
+  if newline.include? "File.read"
+    newline << tr("File.read", H_LINES.grep(/read_file_into_string\(/))
+  end
+
+  if newline.include? "sort"
+    newline << tr("sort", H_LINES.grep(/sort(?:ed)?_long_longs\(/)).chomp("\n").chomp(".") + " or similar functions depending on the type name"
+  end
+  if newline.include? "gsub!"
+    newline << tr("gsub!", H_LINES.grep(/replace_all.*\(/))
+  elsif newline.include? "gsub"
+    newline << tr("gsub", H_LINES.grep(/replace_all.*\(/))
+  end
+
+  if newline.include? "delete"
+    newline << tr("delete", H_LINES.grep(/del_key\(/))
+  end
+
+  if newline.include? "split"
+    newline << tr("split", H_LINES.grep(/split\(/))
+  end
+
+  if newline.include? "join"
+    newline << tr("join", H_LINES.grep(/join\(/))
+  end
+
+  if newline.include? "strip"
+    newline << tr("strip", H_LINES.grep(/strip\(/))
+  end
+  if newline.include? "map"
+    fs = H_LINES.grep(/filesystem.*\(/)
+    newline << tr("map", H_LINES.grep(/map.*\(/) - fs)
+  end
+
+  if newline.include? "start_with?"
+    newline << tr("start_with?", H_LINES.grep(/starts_with.*\(/))
+  end
+  if newline.include? "start_with"
+    newline << tr("start_with", H_LINES.grep(/starts_with.*\(/))
+  end
+
+  if newline.include? "end_with?"
+    newline << tr("end_with?", H_LINES.grep(/ends_with.*\(/))
+  end
+
+  if newline.include? "end_with"
+    newline << tr("end_with", H_LINES.grep(/ends_with.*\(/))
+  end
+  if newline.include? "starts_with"
+    newline << tr("starts_with", H_LINES.grep(/starts_with.*\(/))
+  end
+  if newline.include? "ends_with"
+    newline << tr("ends_with", H_LINES.grep(/ends_with.*\(/))
+  end
+
+  if newline.include? "count"
+    newline << tr("count", H_LINES.grep(/count.*\(/))
+  end
+
+  puts newline
+end
+
+File.open(outfile, "w") do |file|
+  file.puts $out
+end
+
+green("Wrote #{$comments} transpilation comments.", file = STDERR)