libsheepy

genMake.c (6010B)

---

 //
 #include <stdio.h>
 #include <stdint.h>
 #include <stdbool.h>
 #include <stdlib.h>
 #include <sys/stat.h>
 #include <string.h>
 #include <unistd.h>
 
 ssize_t fileSize(const char *filePath) {
   struct stat st;
 
   int r = stat(filePath, &st);;
   if (r) {
     return(-1);
   }
 
   // macOS returns a varying number a number above the constant below
   // when the file doesnt exists
   if ((uint64_t)(st.st_size) > 140734000000000) {
     return(-1);//LCOV_EXCL_LINE
   }
   return(st.st_size);
 }
 
 void *readFileToS(const char *filePath) {
   FILE *f = NULL;
   void *r = NULL;
   ssize_t len;
   size_t readStatus;
 
   len = fileSize(filePath);;
 
   // +1 to add \0 at the end
   r = malloc(len+1);
   if (!r) {
     return(NULL);
   }
 
   f = fopen(filePath, "r");
   readStatus = fread(r, 1, len , f);
   fclose(f);
 
   if  (readStatus != (size_t)len) {
     return(NULL);
   }
 
   *((char*)r+len) = 0;
 
   return(r);
 }
 
 int iReplaceS(char **s, const char *olds, const char *news, size_t max ) {
   char *r = NULL;
   char *tmp = NULL;
   char *workingS = NULL;
   // ins is next insert point
   char *ins = NULL;
   size_t count;
   size_t lfront;
   bool freeNewsStatus = false;;
   char *internalNews = NULL;
 
   // sanity checks and initialization
   // count the number of replacements needed
   // allocate result
   // replace olds with news
   // copy end of string
 
   size_t lolds;
   lolds = strlen(olds);
   if (!lolds) {
     // empty olds causes infinite loop
     return(-1);
   }
   internalNews = (char *) news;
 
   // count the number of replacements needed
   ins = workingS = *s;
   for (count = 0 ; (tmp = strstr(ins, olds)) ; ++count) {
      ins = tmp + lolds;
      if (max && (count == max)) {
        // the maximum number is replacements is reached, stop
        break;
   }
      }
 
 
   size_t lnews;
   lnews       = strlen(internalNews);
 
   // allocate result
   size_t rLen = strlen(*s) + (lnews - lolds) * count + 1;;
   tmp = r     = malloc(rLen);
   if (!r) {
     if (freeNewsStatus) {
       free(internalNews);
     }
     return(-1);
   }
 
   // replace olds with news
   // ins points to the start of olds in s
   // tmp is the front of s, tmp points the end of s front in r
   // copy news to tmp, tmp points the end of news in r
   // s is the remainder of s after end of olds
   while (count--) {
     ins       = strstr(workingS, olds);
     lfront    = ins - workingS;
     tmp       = strncpy(tmp, workingS, lfront) + lfront;
     tmp       = strcpy(tmp, internalNews) + lnews;
     workingS += lfront + lolds;
   }
 
   // copy end of string
   strcpy(tmp, workingS);
   if (freeNewsStatus) {
     free(internalNews);
   }
 
   free(*s);
   *s = r;
   return(0);
 }
 
 int writeFileS(const char *filePath, char *string) {
   FILE *f = NULL;
   size_t len;
   size_t writeStatus;
 
   len = strlen(string);
 
   f = fopen(filePath, "w");
   writeStatus = fwrite(string, 1, len , f);
   fclose(f);
 
   if (writeStatus != len) {
     return(-1);
   }
 
   return(0);
 }
 
 bool fileExists(const char *filePath) {
 
   int r = access(filePath, F_OK);
   //if r
   //  perror("fileExists error");
   // dont print error because this is a test
   return(r != -1);
 }
 
 int main(int ARGC, char** ARGV) {
 
 #if __arm__ || __aarch64__ || __riscv
 
   // remove -mrdrnd cflag in Makefile on ARM platforms
   // because there is no HW random number generator
   char *m = readFileToS("Makefile");
   char *b = readFileToS("build.sh");
   char *B = readFileToS("buildMemcheck.sh");
   char *a = readFileToS("buildAsan.sh");
 #if !TERMUX
 #if __riscv
   puts("RISCV cpu");
 #else
   puts("ARM cpu");
 #endif
   iReplaceS(&m, " -mrdrnd", "", 1);
   iReplaceS(&b, " -mrdrnd", "", 2);
   iReplaceS(&B, " -mrdrnd", "", 1);
   iReplaceS(&a, " -mrdrnd", "", 1);
 #else // #if !TERMUX
   puts("ARM cpu Termux");
   char *i = readFileToS("install.sh");
   iReplaceS(&m, "gnu99", "gnu11", 2);
   iReplaceS(&b, "gnu99", "gnu11", 2);
   iReplaceS(&B, "gnu99", "gnu11", 2);
   iReplaceS(&m, " -mrdrnd", " -D__TERMUX__=1 -D__arm__=1", 1);
   iReplaceS(&b, " -mrdrnd", " -D__TERMUX__=1 -D__arm__=1", 1);
   iReplaceS(&B, " -mrdrnd", " -D__TERMUX__=1 -D__arm__=1", 1);
   iReplaceS(&m, "/usr/local/include/", "/data/data/com.termux/files/usr/include/", 0);
   iReplaceS(&i, "/usr/local/include/", "/data/data/com.termux/files/usr/include/", 0);
   iReplaceS(&m, "/usr/local/lib/", "/data/data/com.termux/files/usr/lib/", 0);
   iReplaceS(&i, "/usr/local/lib/", "/data/data/com.termux/files/usr/lib/", 0);
   writeFileS("install.sh", i);
   free(i);
 #endif // #if !TERMUX
   writeFileS("Makefile", m);
   writeFileS("build.sh", b);
   writeFileS("buildMemcheck.sh", B);
   writeFileS("buildAsan.sh", a);
   free(m);
   free(b);
   free(B);
   free(a);
 
 #endif // #if __arm__ || __aarch64__ || __riscv
 
 #if __APPLE__
 
   puts("macOS");
   // compile with gcc (not clang)
   char *m = readFileToS("Makefile");
   iReplaceS(&m, "gnu99", "gnu11", 2);
   writeFileS("Makefile", m);
   free(m);
 
 #else // #if __APPLE__
   // check if the os is alpine linux because the libc in alpine is musl
   if (fileExists("/etc/alpine-release")) {
     puts("alpine linux detected, add define MUSL_LIBC=1 in Makefile and build.sh");
 
     char *M = readFileToS("Makefile");
     char *b = readFileToS("build.sh");
     char *B = readFileToS("buildMemcheck.sh");
     iReplaceS(&M, "-pipe", "-pipe -DMUSL_LIBC=1", 1);
     iReplaceS(&b, "-pipe", "-pipe -DMUSL_LIBC=1", 1);
     iReplaceS(&B, "-pipe", "-pipe -DMUSL_LIBC=1", 1);
     writeFileS("Makefile", M);
     writeFileS("build.sh", b);
     writeFileS("buildMemcheck.sh", B);
     free(M);
     free(b);
     free(B);
   }
 #endif // #if __APPLE__
 
 #if __HAIKU__
 
   // remove -pthread cflag in Makefile in Haiku
   // because pthread is linked by default
   char *m = readFileToS("Makefile");
   char *b = readFileToS("build.sh");
   char *B = readFileToS("buildMemcheck.sh");
   iReplaceS(&m, " -pthread", "", 1);
   iReplaceS(&b, " -pthread", "", 1);
   iReplaceS(&B, " -pthread", "", 1);
   writeFileS("Makefile", m);
   writeFileS("build.sh", b);
   writeFileS("buildMemcheck.sh", B);
   free(m);
   free(b);
   free(B);
 
 #endif // #if __HAIKU__
 }