elonmusk 1.0.53 → 1.0.71

data/src/rgsub.c

@@ -0,0 +1,404 @@
+#include <libgen.h>
+
+#include <dirent.h>
+#include <limits.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/stat.h>
+
+#define print(s) fputs((s), stdout)
+#ifdef __cplusplus
+#define restrict __restrict__
+#endif
+
+#if __GNUC__
+#define likely(x) __builtin_expect(!!(x), true)
+#define unlikely(x) __builtin_expect(!!(x), false)
+#else
+#define likely(x) (x)
+#define unlikely(x) (x)
+#endif
+
+static bool rename_mode = false;
+static const char *prog_name = NULL;
+static bool verbose_mode = false;
+static size_t len1 = 0, len2 = 0;
+
+static void err() {
+  perror("Error");
+  exit(1);
+}
+
+static bool is_valid_utf8(const char *str, size_t len) {
+  size_t i = 0;
+
+  while (i < len) {
+    if ((str[i] & 0x80) == 0) {
+      // ASCII character (0xxxxxxx)
+      i++;
+    } else if ((str[i] & 0xE0) == 0xC0) {
+      // 2-byte UTF-8 character (110xxxxx)
+      if (i + 1 >= len || (str[i + 1] & 0xC0) != 0x80)
+        return 0;
+      i += 2;
+    } else if ((str[i] & 0xF0) == 0xE0) {
+      // 3-byte UTF-8 character (1110xxxx)
+      if (i + 2 >= len || (str[i + 1] & 0xC0) != 0x80 ||
+          (str[i + 2] & 0xC0) != 0x80)
+        return 0;
+      i += 3;
+    } else if ((str[i] & 0xF8) == 0xF0) {
+      // 4-byte UTF-8 character (11110xxx)
+      if (i + 3 >= len || (str[i + 1] & 0xC0) != 0x80 ||
+          (str[i + 2] & 0xC0) != 0x80 || (str[i + 3] & 0xC0) != 0x80)
+        return 0;
+      i += 4;
+    } else {
+      // Invalid UTF-8 encoding
+      return false;
+    }
+  }
+
+  return true;
+}
+
+static void string_replace(const char *source, const char *find,
+                           const char *replace, size_t source_len,
+                           size_t find_len, size_t replace_len, bool *use_orig,
+                           size_t *num_matches, char **new_text) {
+  size_t matches = 0;
+
+  // Count the occurrences of 'find' in 'source'
+  const char *p = source;
+  while ((p = strstr(p, find)) != NULL) {
+    ++matches;
+    p += find_len;
+  }
+
+  if (!num_matches) {
+    *use_orig = true;
+    return;
+  }
+  *use_orig = false;
+  *num_matches = matches;
+
+  // Calculate the final length of the replaced string
+  size_t final_len = source_len + matches * (replace_len - find_len);
+
+  // Allocate memory for the replaced string
+  char *result = (char *)malloc(final_len + 1);
+
+  *new_text = result;
+  if (unlikely(result == NULL)) {
+    err();
+  }
+
+  // Perform the replacement
+  char *rp = result;
+  p = source;
+  while ((p = strstr(p, find)) != NULL) {
+    size_t prefix_len = p - source;
+    memcpy(rp, source, prefix_len);
+    rp += prefix_len;
+    memcpy(rp, replace, replace_len);
+    rp += replace_len;
+    p += find_len;
+    source = p;
+  }
+
+  // Copy the remaining part of the source string
+  size_t remaining_len = strlen(source);
+  memcpy(rp, source, remaining_len);
+  rp[remaining_len] = '\0';
+}
+
+static void proc_stdin(const char *restrict one, const char *restrict two) {
+  const size_t inc = 4096;
+  size_t size = inc + 1;
+
+  char *data = (char *)malloc(size);
+
+  size_t base = 0;
+
+  size_t num_to_read = inc;
+
+  for (;;) {
+    if (base + num_to_read > size) {
+      data = (char *)realloc(
+          data,
+          (base + num_to_read) *
+              1.5); // 1.5 is safe because lowest it coud be is 0 +
+                    // 4096 * 1.5, which is always bigger than 4096
+    }
+    size_t br = fread(data + base, 1, num_to_read, stdin);
+
+    base += br;
+    if (br < num_to_read) {
+      data[base] = '\0';
+      break;
+    }
+  }
+
+  bool use_orig;
+  size_t num_matches;
+  char *new_text;
+
+  string_replace(data, one, two, base, len1, len2, &use_orig, &num_matches,
+                 &new_text);
+  print(new_text);
+
+  free(data);
+
+  if (!use_orig) {
+    free(new_text);
+    return;
+  }
+
+  return;
+}
+
+static void process_file(const char *restrict filename,
+                         const char *restrict one, const char *restrict two) {
+
+  if (!strcmp("/dev/stdin", filename)) {
+    if (verbose_mode) {
+      print("STDIN\n");
+    }
+    proc_stdin(one, two);
+    return;
+  }
+
+  if (!strncmp(filename, "-", 1)) {
+    proc_stdin(one, two);
+    return;
+  }
+
+  FILE *f = fopen(filename, "r");
+
+  if (unlikely(f == NULL)) {
+    printf("Failed to open file: '%s'\n", filename);
+    return;
+  }
+
+  // Get the size of the file
+  fseek(f, 0, SEEK_END);
+  size_t fsize = ftell(f);
+  if (fsize == 0) {
+    fclose(f);
+    return;
+  }
+  fseek(f, 0, SEEK_SET);
+
+  // Allocate memory for the file content
+  // Add to surpress valgrind warnings.
+  char *text = (char *)malloc(fsize + 1);
+  if (unlikely(text == NULL)) {
+    fclose(f);
+    printf("Memory allocation failed\n");
+    return;
+  }
+
+  size_t bytes_read = 0;
+  size_t total_bytes_read = 0;
+
+  // Read the file content in chunks
+  while (total_bytes_read < fsize) {
+    size_t len_to_read = fsize - total_bytes_read;
+    if (len_to_read > 4096) {
+      len_to_read = 4096;
+    }
+    bytes_read = fread(text + total_bytes_read, 1, len_to_read, f);
+    if (unlikely(bytes_read == 0)) {
+      fclose(f);
+      free(text);
+      printf("Failed to read file: '%s'\n", filename);
+      return;
+    }
+
+    if (!is_valid_utf8(text + total_bytes_read, bytes_read)) {
+      // printf("Skipping non-text file '%s'\n", filename);
+      fclose(f);
+      free(text);
+      return;
+    }
+    total_bytes_read += bytes_read;
+  }
+
+  fclose(f);
+
+  text[fsize] = '\0';
+
+  bool use_orig;
+  size_t num_matches;
+  char *new_text;
+
+  string_replace(text, one, two, total_bytes_read, len1, len2, &use_orig,
+                 &num_matches, &new_text);
+
+  free(text);
+
+  if (use_orig) {
+    return;
+  }
+
+  const size_t rep_len = strlen(new_text);
+
+  f = fopen(filename, "w");
+  if (unlikely(f == NULL)) {
+    free(text);
+    printf("Failed to open file for writing: '%s'\n", filename);
+    return;
+  }
+
+  // Write the replaced content to the file
+  {
+    size_t bytes_written = fwrite(new_text, 1, rep_len, f);
+    if (bytes_written == 0) {
+      fclose(f);
+      free(new_text);
+      printf("Failed to write file: '%s'\n", filename);
+      return;
+    }
+  }
+  free(new_text);
+  fclose(f);
+
+  if (num_matches == 1) {
+    printf("%s: %s: 1 replacement for %s => %s\n", prog_name, filename, one,
+           two);
+  } else {
+    printf("%s: %s: %ld replacements for %s => %s\n", prog_name, filename,
+           num_matches, one, two);
+  }
+}
+
+static void process_directory(const char *dirPath, const char *one,
+                              const char *two, bool check_file) {
+  if (strstr(dirPath, "/.")) {
+    // printf("Skipping hidden file '%s'\n", filename);
+    return;
+  }
+  DIR *dir = opendir(dirPath);
+  if (dir == NULL) {
+    if (check_file) {
+      process_file(dirPath, one, two);
+      return;
+    }
+    printf("Failed to open directory: '%s'\n", dirPath);
+    return;
+  }
+
+  struct dirent *entry;
+  while ((entry = readdir(dir)) != NULL) {
+    if ((!strcmp(entry->d_name, ".")) || strcmp(entry->d_name, ".."))
+      continue;
+
+    char path[PATH_MAX];
+    snprintf(path, sizeof(path), "%s/%s", dirPath, entry->d_name);
+
+    if (rename_mode) {
+      bool use_orig;
+      size_t num_matches;
+      char *new_text;
+
+      string_replace(path, one, two, strlen(path), strlen(one), strlen(two),
+                     &use_orig, &num_matches, &new_text);
+
+      if (use_orig)
+        continue;
+      printf("%s: Renamed %s => %s\n", prog_name, path, new_text);
+
+      rename(path, new_text);
+      free(new_text);
+      continue;
+    }
+
+    struct stat statbuf;
+    if (stat(path, &statbuf) == -1) {
+      printf("Failed to get file information: %s\n", path);
+      continue;
+    }
+
+    if (S_ISDIR(statbuf.st_mode)) {
+      process_directory(path, one, two, false);
+    } else if (S_ISREG(statbuf.st_mode)) {
+      process_file(path, one, two);
+    }
+  }
+
+  closedir(dir);
+}
+
+int main(int argc, char **argv) {
+  prog_name = basename(argv[0]);
+  if (argc < 2) {
+    printf(
+        "Usage: %s <find> <replace> [optional list of files instead of "
+        "recursive search]\n\nIf a file is \"-\" or stdin, read from stdin "
+        "and output to stdout.\nOptions"
+        "\n\n\n    -r, rename files instead "
+        "of replacing contents of files. find and replace in file and dir "
+        "names instead"
+        "\n\n\n    -v, verbose mode\n\n\n    -- Indicate end of options.\n\n",
+        prog_name);
+    return 1;
+  }
+
+  char *actual_argv[argc];
+  int actual_argc = 0;
+  bool auto_continue = false;
+
+  size_t lens[argc];
+
+  for (int i = 0; i < argc; ++i) {
+    if (auto_continue)
+      continue;
+    {
+      size_t len;
+      len = strlen(argv[i]);
+
+      if (len == 2) {
+        if (argv[i][0] == '-') {
+          switch (argv[i][1]) {
+          case '-':
+            auto_continue = true;
+            continue;
+          case 'r':
+            rename_mode = true;
+            if (verbose_mode) {
+              print("File name replace mode\n");
+            }
+            continue;
+          case 'v':
+            verbose_mode = true;
+            print("Verbose mode\n");
+            continue;
+          }
+        }
+      }
+
+      lens[actual_argc] = len;
+
+      actual_argv[actual_argc] = argv[i];
+      actual_argc++;
+    }
+  }
+  len1 = lens[1];
+  len2 = lens[2];
+  //  printf("%d %d\n", actual_argc, actual_argc);
+
+  if (actual_argc == 3) {
+    process_directory(".", actual_argv[1], actual_argv[2], false);
+  } else if (actual_argc > 3) {
+    for (int i = 3; i < actual_argc; ++i) {
+      if (verbose_mode) {
+        printf("Processing directory '%s'\n", argv[i]);
+      }
+      {}
+      process_directory(actual_argv[i], actual_argv[1], actual_argv[2], true);
+    }
+  }
+  return 0;
+}

data/src/src/code2

@@ -0,0 +1,57 @@
+require "fileutils"
+
+txt = "$array = {"
+Dir.glob("/home/a/democracy/documentation/" + "*").each do |i|
+	doc = File.read i
+	i = File.basename i
+	txt<< <<~A
+	      "#{i}" => ["#{i}", "[#{i}] [arguments]", #{doc.strip.dump}],
+	A
+end;
+
+txt<<"}"
+
+
+eval txt
+
+
+def iter(arg)
+#  warn arg
+  FileUtils.mkdir_p("../compilation")
+  name, args = arg.scan(/^def\s+(.+)(\(.*\))\s*$/)[0]
+  args_split = args[1..-2].strip.split(",")
+  invoke_function = if args_split.empty?
+      name
+    else
+      "#{name}(#{["", "ARGV[0]", "ARGV[0], ARGV[1]",
+                  "ARGV[0], ARGV[1], ARGV[2]"][args_split.length]})"
+    end
+
+  File.open("../compilation/#{name}", "w") do |file|
+    file << (File.read("functions.cr")) << text = <<CR
+
+
+def main()
+  if ARGV.size != #{args_split.length}
+    Funcs.argument_data(#{$array[name].to_s[1..-2]})
+    exit 1
+  end
+
+  #{invoke_function}
+end
+
+
+main
+CR
+    #abort text
+
+    #START
+    system "#notify-send  #&"
+  end
+end
+
+File.read("functions.cr").each_line.reject do |i|
+  !i.start_with?("def ")
+end.each do |arg|
+  iter(arg.strip)
+end

data/src/src/functions.cr

@@ -0,0 +1,274 @@
+#!/usr/bin/crystal
+require "file_utils"
+require "json"
+require "colorize"
+
+include FileUtils
+
+def lines()
+  if !STDIN.tty?
+    puts STDIN.gets_to_end.count("\n")
+  else
+    res = `find .`.count("\n") - 1
+    puts res
+  end
+end
+
+def args(arg1)
+  sections = Process.parse_arguments(arg1)
+  program, args = sections[0], sections[1..]
+
+  sections = Process.parse_arguments(arg1)
+
+  program = Process.find_executable(program)
+  if program.nil?
+    puts "Can't find program #{arg1}"
+    raise "Error"
+  end
+
+  lines = STDIN.gets_to_end.strip
+  lines = lines.split "\n"
+  times = (lines.size % 2000000 == 0) ? 2 : 1
+
+  times += lines.size // 2000000
+  n = 0
+  times.times do
+    prog_args = args
+
+    prog_args += lines[n..(n + 2000000 - 1)]; n += 2000000
+
+    if (p = Process.fork).nil?
+      Process.exec(
+        program,
+        prog_args
+      )
+    else
+      p.wait
+    end
+  end
+end
+
+def copy()
+  command = "/usr/bin/xclip"
+  args = ["-selection", "c"]
+  Process.run(command, args, output: STDOUT) do |file|
+    file.input.print STDIN.gets_to_end
+  end
+end
+
+def mul()
+  t = STDIN.read_line.to_f64
+
+  i = 0f64; STDIN.each_line do |line|
+    t *= line.to_f64
+  end
+
+  puts t
+end
+
+def add()
+  t = STDIN.read_line.to_f64
+
+  i = 0f64; STDIN.each_line do |line|
+    t += line.to_f64
+  end
+
+  puts t
+end
+
+def div()
+  t = STDIN.read_line.to_f64
+
+  i = 0f64; STDIN.each_line do |line|
+    t /= line.to_f64
+  end
+
+  puts t
+end
+
+def sub()
+  t = STDIN.read_line.to_f64
+
+  i = 0f64; STDIN.each_line do |line|
+    t -= line.to_f64
+  end
+
+  puts t
+end
+
+def floor()
+  puts STDIN.read_line.to_f64.to_i64
+end
+
+def abs()
+  STDIN.each_line do |l|
+    l = l.to_f64.abs
+    puts l
+  end
+end
+
+def dump()
+  puts STDIN.gets_to_end.dump
+end
+
+def undump()
+  puts JSON.parse(STDIN.gets_to_end)
+end
+
+def exp()
+  t = STDIN.read_line.to_f64
+
+  STDIN.each_line do |line|
+    t **= line.to_f64
+  end
+
+  puts t
+end
+
+def nth(arg1)
+  end_ = arg1.to_u64
+  i = 0u64; STDIN.each_line do |line|
+    i += 1
+    if i == end_
+      puts line
+      break
+    end
+  end
+end
+
+def last_nth(arg1)
+  end_ = arg1.to_u64
+  i = 0u64;
+  t = STDIN.gets_to_end
+  if t[-1] == '\n'
+  	t = t[0..-2]
+  end
+
+  t.split("\n").reverse_each do |line|
+    i += 1
+    if i == end_
+      puts line
+      break
+    end
+  end
+end
+
+def gsubip(arg1, arg2, arg3)
+  regex = Regex.new(arg1)
+  text = File.read(arg3).gsub(/#{arg1}/m, arg2)
+  File.open(t = File.tempname("coreutils", "_tmp"), "w", File.info(arg3).permissions) do |h|
+    h.print text
+  end
+  begin
+    mv t, arg3
+  rescue
+    rm t
+  end
+end
+
+def rip(arg1, arg2, arg3)
+  text = File.read(arg3).gsub(arg1, arg2)
+  File.open(t = File.tempname("coreutils", "_tmp"), "w", File.info(arg3).permissions) do |h|
+    h.print text
+  end
+  begin
+    mv t, arg3
+  rescue
+    rm t
+  end
+end
+
+def gsub(arg1, arg2)
+  print STDIN.gets_to_end.gsub(/#{arg1}/m, arg2)
+end
+
+def rnip(arg1, arg2)
+  print STDIN.gets_to_end.gsub(arg1, arg2)
+end
+
+def selectlines()
+  STDIN.each_line do |line|
+    if line.strip.size > 0
+      puts line
+    end
+  end
+end
+
+
+def swap(file1, file2)
+  [file1, file2].each do |f|
+    File.exists?(f) || abort("No file named #{f.dump}".colorize(:red))
+  end
+  t = File.tempname("coreutils", "_tmp")
+
+  mv file1, t
+  mv file2, file1
+  mv t, file2
+end
+
+def prepend(file)
+  file_data = File.read(file)
+  new_data = STDIN.gets_to_end
+  File.open(t = File.tempname("coreutils", "_tmp"), "w", File.info(file).permissions) do |h|
+    h << new_data + file_data
+  end
+
+  begin
+    mv t, file
+  rescue
+    rm t
+  end
+end
+
+def append(file)
+  file_data = File.read(file)
+  new_data = STDIN.gets_to_end
+  File.open(t = File.tempname("coreutils", "_tmp"), "w", File.info(file).permissions) do |h|
+    h << file_data + new_data
+  end
+  begin
+    mv t, file
+  rescue
+    rm t
+  end
+end
+
+class Funcs
+  def self.bold(text)
+    text = text.to_s
+    # text += two.to_s
+
+    if STDOUT.tty?
+      return text.colorize.bold.to_s
+    else
+      return "<b>" + text + "</b>"
+    end
+  end
+
+  def self.argument_data(program, usage, long_desc)
+    if !(STDOUT.tty?)
+      text = "<div style='border-radius: 50px; border: 10px dotted cyan; padding: 30px;'>\n"
+    else
+      text = ""
+    end
+
+    text += bold("NAME") + "\n\t" + program
+    text += " - "
+    text += program + "\n" * 2 + bold("SYNOPSIS") + "\n"
+    #	tebold_("SYNOPSIS_")# + bold("SYNOPSIS")
+    text += "\t"
+    text += bold(program) + " "
+    text += usage + "\n\n"
+    text += long_desc + "\n\n"
+
+    if STDOUT.tty? == false
+      text = text.gsub("\n", "<br/>     ").gsub("\t", "&nbsp;" * 5)
+      text += "</div>\n\n"
+    end
+
+    puts text
+
+    #		puts "</
+    #		puts "</
+  end
+end