sheepy

common.c (6809B)

---

 // MIT License
 //
 // Copyright (c) 2026 Remy Noulin
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 #include "libsheepyObject.h"
 #include "common.h"
 
 #define internal static
 
 #include <stdio.h>
 #include <dirent.h>
 #include <string.h>
 #include <sys/wait.h>
 #include <stdlib.h>
 #include <unistd.h>
 
 #if (!(__arm__ || __APPLE__ || __FreeBSD__ || __TERMUX__ || __OpenBSD__ || __DragonFly__ || MUSL_LIBC || __sun__))
 #elif (__TERMUX__)
 #elif ((__HAIKU__))
 #else
 #endif
 smallJsont *loadSheepyConfig(char **homedir);
 void sourceFromTemplate(const char *filename);
 void pkgFromTemplate(const char *pkgname);
 void spawnProc(cbFt cb, void *arg);
 void waitForJobs(void);
 void childProc(void *arg);
 char* findLocalPackageDir(smallDictt* cfgD);
 
 /**
  * \file
  * common functions and data
  */
 
 #if (!(__arm__ || __APPLE__ || __FreeBSD__ || __TERMUX__ || __OpenBSD__ || __DragonFly__ || MUSL_LIBC || __sun__))
 char *defaultSpC = CONFIG_YML;
 #elif (__TERMUX__)
 // gold doesn't work in raspbian - deactivate
 // define __arm__
 char *defaultSpC = CONFIG_YML_NO_GOLD_ARM;
 #elif ((__HAIKU__))
 // gold doesn't work in raspbian - deactivate
 // remove -rdynamic
 // install in /boot/home/config/non-packaged
 char *defaultSpC = CONFIG_YML_HAIKU;
 #else
 // gold doesn't work in raspbian - deactivate
 char *defaultSpC = CONFIG_YML_NO_GOLD;
 #endif
 
 //^^ __arm__
 /**
  * child process list compiling the code
  */
 jobst jobs;
 
 /**
  * load ~/.sheepy/config.yml
  * if config.yml doesn't exists, create a default config
  *
  * \return
  *  homedir real sheepy home path
  *  json configuration
  */
 smallJsont *loadSheepyConfig(char **homedir) {
   char *dum = NULL;
 
   // Steps
   // create homedir and default configuration
   // load sheepy configuration
 
   // create homedir
   *homedir   = expandHomeG(HOME_DIR);
   char *file = catS(*homedir, CONFIG_NAME);
   if (!fileExists(*homedir) || !fileExists(file)) {
     pError0(mkdirParents(*homedir));
     pError0(writeFileG(defaultSpC, file));
   }
 
   // load sheepy configuration
   createAllocateSmallJson(cfgJ);
   pErrorNULL(readFileG(cfgJ, file));
   free(file);
   return(cfgJ);
 }
 
 void sourceFromTemplate(const char *filename) {
 
   if (!filename || isBlankG(filename)) {
     return;
   }
 
   char *fn;
   if (endsWithG(filename, ".c")) {
     fn = strdup(filename);
   }
   else {
     fn = appendG(filename, ".c");
   }
 
   if (fileExists(fn)) {
     printf(BLD RED "%s already exists. Current path: ", fn);
     char *s = getCwd();;
     logNFree(s);
     puts(RST);
     free(fn);
     return;
   }
 
   pError0(writeFileG(C_TEMPLATE, fn));
   pError0(fileChmod(fn, S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH));
 
   free(fn);
 }
 
 
 
 void pkgFromTemplate(const char *pkgname) {
 
   if (!pkgname || isBlankG(pkgname)) {
     return;
   }
 
   if (fileExists(PACKAGE)) {
     printf(BLD RED "%s already exists. Current path: ", PACKAGE);
     char *s = getCwd();;
     logNFree(s);
     puts(RST);
     return;
   }
 
   char *testname = dupG(pkgname);;
   toUpper(testname[0]);
   char *memcheckname = dupG(testname);;
   char *asanname = dupG(testname);;
   pErrorNULL(iPrependS(&testname, "test"));
   pErrorNULL(iPrependS(&memcheckname, "memcheck"));
   pErrorNULL(iPrependS(&asanname, "asan"));
 
   char *t = replaceManyS(PKG_TEMPLATE, "<PKG_NAME>", pkgname, "<TEST_NAME>", testname, "<MEMCHECK_NAME>", memcheckname, "<ASAN_NAME>", asanname);;
 
   writeFileG(t, PACKAGE);
   freeManyS(testname, memcheckname, asanname, t);
 }
 
 /**
  * spawn a child process and add to the list
  */
 void spawnProc(cbFt cb, void *arg) {
   pid_t pid;
   int status;
 
   staticArrayPush(jobs)
   staticArrayLast(jobs).pid = fork();
   switch (staticArrayLast(jobs).pid) {
     case -1:
       perror("spawnProc error: ");
       XFAILURE
     case 0:
       cb(arg);
       perror("spawnProc error: ");
       XFAILURE
     default:
       break;
   }
 
   return;
 }
 
 /**
  * wait for all child processes to finish
  */
 void waitForJobs(void) {
 
   range(i, staticArrayCount(jobs)) {
     if (waitpid(staticArrayGet(jobs,i).pid, &(staticArrayGet(jobs,i).status), 0) == -1) {
       printf("couldn't wait for child %d\n", jobs.list[i].pid); {
       XFAILURE
     }
       }
 
     #ifdef __HAIKU__
     if (WEXITSTATUS(staticArrayGet(jobs,i).status) || WTERMSIG(staticArrayGet(jobs,i).status)) {
       puts("subprocess trouble, check output");
       XFAILURE
     }
     #else
     if (WEXITSTATUS(staticArrayGet(jobs,i).status) || WTERMSIG(staticArrayGet(jobs,i).status) || WCOREDUMP(staticArrayGet(jobs,i).status)) {
       puts("subprocess trouble, check output");
       XFAILURE
     }
     #endif
   }
 }
 
 void childProc(void *arg) {
   char **args = NULL;
   char **userArgs = NULL;
 
   userArgs = (char **) arg;
 
   //listPrintS(userArgs);
 
   execvp(userArgs[0], userArgs);
   perror("failed to start: ");
   puts(userArgs[0]);
   XFAILURE
 }
 
 
 char* findLocalPackageDir(smallDictt* cfgD) {
 
   char *localPackageDir = PACKAGE_DIR;
 
   if (!isDirG(PACKAGE_DIR)) {
     // search in parent directories
     char *cwd  = getCwd();
     char **spl = splitG(cwd, '/');
     while (!isBlankG(spl)) {
       char *p = joinG(spl, '/');;
       pErrorNULL(iAppendManyS(&p, "/", PACKAGE_DIR));
       if (isDir(p)) {
         localPackageDir = p;
         break;
       }
       //logVarG(p);
       free(p);
       pErrorNULL(delG(&spl, -1, 0));
     }
     freeG(spl);
     free(cwd);
 
     // ignore found dir if it is the global package dir
     char *packageDir = catS(getG(cfgD, rtChar, "system") , "/", PACKAGE_DIR);
     pErrorNULL(normalizePathG(&packageDir));
     pErrorNULL(expandHomeG(&packageDir));
     if (eqG(localPackageDir, packageDir)) {
       // revert to default package dir, the local package dir cant be the global package dir
       free(localPackageDir);
       localPackageDir = PACKAGE_DIR;
     }
     free(packageDir);
   }
   return(localPackageDir);
 }