sheepy

sheepy.c (80668B)

---

 // 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.
 //
 //
 // sheepy compilation system
 
 #include "libsheepyObject.h"
 #undef inc
 #include "sheepy.h"
 #include "common.h"
 
 #define internal static
 
 #include <sys/stat.h>
 #include <ctype.h>
 #include <stdio.h>
 #include <dirent.h>
 #include <libgen.h>
 #include <stdbool.h>
 #include <string.h>
 #include <stdlib.h>
 #include <unistd.h>
 
 #undef inc
 #if (__TERMUX__)
 #elif (__sun__)
 #else
 #endif
 #if (__HAIKU__)
 #else
 #endif
 #ifndef unitTest
 #endif
 int MAIN(int ARGC, char** ARGV);
 char *getInclude(smallStringt *L);
 void addFileToCompile(char *actualDir, const char *cFileName, char *oPath, smallDictt *toCompile);
 void storeHeaderDep(smallArrayt *copyHeaderDepToBuildPath, char *bPath, struct stat hst);
 void copyHeaderToBuildPath(char *bPath, struct stat hst);
 void copyHeaderDates(char *actualDir, smallArrayt *hDeps, char *buildPath);
 bool symlinkFile(char *path, char *buildPath);
 bool isC(const char *path);
 bool isH(const char *path);
 bool isCP(const char *path);
 bool isCH(const char *path);
 void generateC(char *src, char *bpath);
 void generateCBuffers(smallArrayt *sheepySrc, smallArrayt *cCode);
 void splash(void);
 
 int argc; char **argv;
 
 #include "parser/EasyLexer.h"
 #include "parser/parser.h"
 
 // when the LIBSHEEPY environment variable exists, it replaces the default libsheepy location
 #if (__TERMUX__)
 #define LIBSHEEPY_DIR            "/data/data/com.termux/files/usr/lib"
 #define LIBSHEEPY_INC_DIR        "/data/data/com.termux/files/usr/include"
 #elif (__sun__)
 #define LIBSHEEPY_DIR            "/usr/lib"
 #define LIBSHEEPY_INC_DIR        "/usr/include"
 #else
 #define LIBSHEEPY_DIR            "/usr/local/lib"
 #define LIBSHEEPY_INC_DIR        "/usr/local/include"
 #endif
 
 #define GCC   "gcc"
 
 #if (__HAIKU__)
 #define PTHREAD   ""
 #else
 #define PTHREAD   "-pthread"
 #endif
 
 int programResult;
 
 /**
  * build and execute program
  * sheepy help lists the options
  *
  * The program is built in ~/.sheepy/build/realpathToMain
  */
 #ifndef unitTest
 // Remove main when running the unit tests
 #define MAIN   main
 #endif
 int MAIN(int ARGC, char** ARGV) {
   char *dum = NULL;
   char *mainFilename = NULL;
   char *homedir = NULL;
   char *libsheepyDir = NULL;
   char *libsheepyIncDir = NULL;
   smallStringt *bin = NULL;
 
   argc = ARGC; argv = ARGV;
   char *libsheepy = "libsheepy.a";
 
   // variables:
   // dum:           temporary string for selecting type in generics
   // mainFilename:  main filename as given on the command line
   // homedir:       real sheepy homedir path
   // libsheepyDir:  runtime libsheepy location. Default LIBSHEEPY_DIR or env("LIBSHEEPY")
   // programResult: result from compilation, linking, program execution, 0 is success, not 0 is failure
 
   // TODO
   // split main into smaller functions
   //
   // Steps
   // load sheepy configuration
   // set libsheepy location
   // process parameters for sheepy
   // get basename (rootMain)
   // main source folder (dir)
   // load main source (mainCode)
   // detect execute bit
   // if yes then run (run)
   // compile
   // link and run
   // clean executable
 
   // load sheepy configuration - to create config.yml even when there is no command
   smallJsont *cfgJ = loadSheepyConfig(&homedir);
   smallDictt *cfgD = getTopG(cfgJ, rtSmallDictt);
   //putsG(cfgJ);
 
   // set libsheepy location
   libsheepyDir = getenv("LIBSHEEPY");
 
   if (!libsheepyDir) {
     // set default libsheepy location
     libsheepyDir    = LIBSHEEPY_DIR;
     libsheepyIncDir = LIBSHEEPY_INC_DIR;
   }
   else {
     libsheepyIncDir = libsheepyDir;
   }
 
   dum = catS(libsheepyDir, "/libsheepy.a");
   if (!fileExists(dum)) {
     printf("\n" BLD RED "Libsheepy not found: %s not accessible" RST "\nIf libsheepy in another directory, set LIBSHEEPY to libsheepy path, for example: export LIBSHEEPY=/home/$USER/libsheepy/release/\n", dum); {
     free(dum);
     XFAILURE
   }
     }
   freen(dum);
 
   // success result by default
   programResult                  = 0;
 
   // process parameters for sheepy
   // when any compile parameter is given, dont execute the program
   // -l compileLib=1 build the dynamic and static libraries
   sheepyParams.compileLib        = 0;
   // -c compileOnly=1 build and dont execute the program
   sheepyParams.compileOnly       = 0;
   // set to 0 when main is detected in main source file
   // 1 - only objects are compiled, linking is not done
   // no effect when compileLib=0
   sheepyParams.dontCompileExe    = 1;
   sheepyParams.clean             = 0;
   sheepyParams.test              = 0;
   sheepyParams.memcheck          = 0;
   sheepyParams.libsheepyMemcheck = 0;
   sheepyParams.asan              = 0;
   sheepyParams.libsheepyAsan     = 0;
   sheepyParams.new               = 0;
   sheepyParams.showExe           = 0;
   sheepyParams.removeBuild       = 0;
   sheepyParams.parallel          = 1;
   sheepyParams.genTest           = 0;
   sheepyParams.debugExe          = 0;
 
   // parallel has to be defined and 0 to disable parallel compilation
   if (hasG(cfgD, "parallelSheepy") && !getG(cfgD, rtI32, "parallelSheepy")) {
     sheepyParams.parallel = 0;
   }
 
   // enable crash debug
   initLibsheepy(argv[0]);
   setLogMode(LOG_PROGNDATE);
 
   // initialize child process list
   staticArrayInit(jobs);
 
   if (argc < 2 || (argv[1][0] == '-' && argc == 2)) {
     // no argument or one option argument
     // read package.yml
     if (fileExists(PACKAGE)) {
       createSmallJson(packageyml);
       readFileG(&packageyml, PACKAGE);
       bin = getNDupG(&packageyml, rtSmallStringt, "bin");
       freeG(&packageyml);
   }
     }
 
   if (argc < 2) {
     // default run program or compile the library in package.yml
     if (bin) {
       var libHeader = dupG(bin);
       if (fileExistsG(setG(libHeader, -1, 'h'))) {
         // compile lib
         sheepyParams.compileLib  = 1;
       }
       else {
         // compile program
         sheepyParams.compileOnly = 1;
       }
       terminateG(libHeader);
       mainFilename = normalizePath(ssGet(bin));
       terminateG(bin);
       goto sheepyRun;
     }
     splash();
     printf("Nothing to do. sheepy -h for help\n"); {
     printf("\n");
     goto help;
   }
     }
 
   // after this line, argc > 1, there is at least one argument
 
   if (eqS(argv[1], "-h") || eqS(argv[1], "--help") || eqS(argv[1], "help")) {
     terminateG(bin);
     splash();
     help:
     putsG(BLD GRN "Sheepy Help (build system)" RST);
     putsG("  " UDL YLW "Environment" RST);
     if (!startsWithG(argv[0], "/usr/local/bin/")) {
       putsG("  sheepy is not running from /usr/local/bin/. To run this sheepy, the path to the sheepy executable needs to be in $PATH:");
       char *dir = shDirname(getRealProgPath());
       printf(YLW"  export PATH=%s:$PATH or setenv PATH %s:$PATH\n"RST, dir, dir);
       free(dir);
     }
 
     putsG("  when the LIBSHEEPY environment variable exists, it replaces the default libsheepy location");
     if (libsheepyIncDir != libsheepyDir) {
       // give an example setup
       putsG(YLW "  export LIBSHEEPY=/home/user/git/tmp/libsheepy/release or setenv LIBSHEEPY /usr/home/user/git/tmp/libsheepy/release" RST);
       printf("  Current libsheepy location is " UDL "%s" RST " and " UDL "%s" RST "\n", libsheepyDir, libsheepyIncDir);
     }
     else {
       // give current setup
       printf(YLW "  export LIBSHEEPY=%s or setenv LIBSHEEPY %s\n" RST, libsheepyDir, libsheepyDir);
       printf("  Current libsheepy location is " UDL "%s" RST "\n", libsheepyDir);
     }
     putsG("  The configuration is located in " UDL HOME_DIR CONFIG_NAME RST);
     char *dum = expandHome(HOME_DIR CONFIG_NAME);
     if (!fileExists(dum)) {
       printf("  %s missing.", dum);
     }
     printf("  The build directory is located in " UDL "%sbuild/" RST "\n", HOME_DIR);
     printf("  The local package repository is located in " UDL "%s" RST "\n", findLocalPackageDir(cfgD));
     if (dum) {
       char *p = formatS("%s/%s", getG(cfgD, rtChar, "system"), PACKAGE_DIR);
       pErrorNULL(iNormalizePath(&p));
       pErrorNULL(iExpandHome(&p));
       printf("  The global package repository is located in " UDL "%s" RST "\n", p);
       free(p);
       p = formatS("%s/%s", getG(cfgD, rtChar, "system"), "bin");
       pErrorNULL(iNormalizePath(&p));
       pErrorNULL(iExpandHome(&p));
       printf("  Commands from packages are added in " UDL "%s" RST "\n", p);
       free(p);
     }
     free(dum);
     if (hasG(cfgD, "parallelSpm") && !getG(cfgD, rtI32, "parallelSpm")) {
       puts(BLD RED "  Parallel package processing is disabled." RST);
     }
     if (hasG(cfgD, "parallelSheepy") && !getG(cfgD, rtI32, "parallelSheepy")) {
       puts(BLD RED "  Parallel compilation is disabled." RST);
     }
     put
     putsG("For spm package manager help, run: spm help");
     put
     putsG(BLD CYN"  NO ARGUMENT"RST"     Compile bin executable or compile library from package.yml");
     putsG(BLD CYN"  PROGNAME.c"RST"      No option: compile and run executable");
     put
     putsG(BLD CYN"  -c (PROGNAME.c)"RST"  Compile executable in argument or bin from package");
     putsG(BLD CYN"  -e (PROGNAME.c)"RST"  Show executable path for argument or bin from package"); {
     putsG(BLD CYN"  -l (PROGNAME.c)"RST"  Compile static and dynamic libraries for argument or bin from package"); {
     putsG(BLD CYN"  -d (PROGNAME.c)"RST"  Delete intermediary files for argument or bin from package"); {
     putsG(BLD CYN"  -t (PROGNAME.c)"RST"  Compile executable in argument or testBin from package using the test compiler and test linker flags");
     putsG(BLD CYN"  -m (PROGNAME.c)"RST"  Compile executable in argument or memcheckBin from package using the memcheck compiler and linker flags and disabling container recycling in libsheepy");
     putsG(BLD CYN"  -a (PROGNAME.c)"RST"  Compile executable in argument or asanBin from package using the asan compiler and linker flags and disabling container recycling in libsheepy");
     putsG(BLD CYN"  -n PROGNAME(.c)"RST"  New source program from template");
     putsG(BLD CYN"  -r"RST"               Remove all temporary build files in ~/.sheepy/build");
     putsG(BLD CYN"  -C CLASSNAME"RST"     Generate C templates for classname (classnames start with lowercase letters, the first char in classname is lowered)"); {
     putsG(BLD CYN"  -T"RST"               Generate C unit test templates (using the libcheck test library), the generated filename is set with testBin in "PACKAGE);
     putsG(BLD CYN"  -g (PROGNAME.c)"RST"  Debug already compiled executable with debuggerCmd in config.yml");
     putsG(BLD CYN"  -gt (PROGNAME.c)"RST" Debug already compiled testBin executable from package with debuggerCmd in config.yml");
     putsG(BLD CYN"  -gm (PROGNAME.c)"RST" Debug already compiled memcheckBin executable from package with debuggerCmd in config.yml");
     putsG(BLD CYN"  -ga (PROGNAME.c)"RST" Debug already compiled asanBin executable from package with debuggerCmd in config.yml");
     putsG(BLD CYN"  -D"RST"               Show default " HOME_DIR CONFIG_NAME " configuration");
     putsG(BLD CYN"  -h"RST"               Show this help text");
     XSUCCESS
   }
     }
     }
     }
     }
 
   if (eqS(argv[1], "-D")) {
     terminateG(bin);
     puts(defaultSpC);
     XSUCCESS
   }
 
   // bin is allocated when there is package.yml and there is only one argmument
   // when there is one arguments and the argument is an option, take the program name from package.yml
   // when there are 2 arguments and first argument is an option, second argument is the program name
   // else run normally argv[1] is main filename
   if (eqG(argv[1], "-l")) {
     sheepyParams.compileLib  = 1;
     dum                      = bin ? ssGet(bin) : argv[2];
   }
   else if (eqG(argv[1], "-c")) {
     sheepyParams.compileOnly = 1;
     dum                      = bin ? ssGet(bin) : argv[2];
   }
   else if (eqG(argv[1], "-e")) {
     sheepyParams.showExe     = 1;
     dum                      = bin ? ssGet(bin) : argv[2];
   }
   else if (eqG(argv[1], "-d")) {
     sheepyParams.clean       = 1;
     dum                      = bin ? ssGet(bin) : argv[2];
   }
   else if (eqG(argv[1], "-t")) {
     testOption:
     sheepyParams.test        = 1;
     if (bin) {
       terminateG(bin);
       createSmallJson(packageyml);
       readFileG(&packageyml, PACKAGE);
       bin = getNDupG(&packageyml, rtSmallStringt, "testBin");
       freeG(&packageyml);
       dum                      = bin ? ssGet(bin) : argv[2];
     }
     else {
       dum                    = argv[2];
   }
     }
   else if (eqG(argv[1], "-m")) {
     memcheckOption:
     sheepyParams.memcheck          = 1;
     sheepyParams.libsheepyMemcheck = 1;
     // check if libsheepyMemcheck exists
     dum = catS(libsheepyDir, "/libsheepyMemcheck.a");
     if (!fileExists(dum)) {
       printf("\n" BLD RED "LibsheepyMemcheck not found: %s not accessible" RST "\nIf libsheepy in another directory, set LIBSHEEPY to libsheepy path, for example: export LIBSHEEPY=/home/$USER/libsheepy/release/\nand compile libsheepyMemcheck with buildMemcheck.sh in the libsheepy git repo\n", dum); {
       terminateG(bin);
       free(dum);
       XFAILURE
     }
       }
     freen(dum);
     // select main c file
     if (bin) {
       terminateG(bin);
       createSmallJson(packageyml);
       readFileG(&packageyml, PACKAGE);
       bin = getNDupG(&packageyml, rtSmallStringt, "memcheckBin");
       freeG(&packageyml);
       dum                      = bin ? ssGet(bin) : argv[2];
     }
     else {
       dum                    = argv[2];
   }
     }
   else if (eqG(argv[1], "-a")) {
     asanOption:
     sheepyParams.asan              = 1;
     sheepyParams.libsheepyAsan     = 1;
     // check if libsheepyMemAsan exists
     dum = catS(libsheepyDir, "/libsheepyAsan.a");
     if (!fileExists(dum)) {
       printf("\n" BLD RED "LibsheepyAsan not found: %s not accessible" RST "\nIf libsheepy in another directory, set LIBSHEEPY to libsheepy path, for example: export LIBSHEEPY=/home/$USER/libsheepy/release/\nand compile libsheepyAsan with buildAsan.sh in the libsheepy git repo\n", dum); {
       terminateG(bin);
       free(dum);
       XFAILURE
     }
       }
     freen(dum);
     // select main c file
     if (bin) {
       terminateG(bin);
       createSmallJson(packageyml);
       readFileG(&packageyml, PACKAGE);
       bin = getNDupG(&packageyml, rtSmallStringt, "asanBin");
       freeG(&packageyml);
       dum                      = bin ? ssGet(bin) : argv[2];
     }
     else {
       dum                    = argv[2];
   }
     }
   else if (eqG(argv[1], "-n")) {
     sheepyParams.new         = 1;
     dum                      = argv[2];
   }
   else if (eqG(argv[1], "-C")) {
     sheepyParams.cclass      = 1;
     dum                      = argv[2];
   }
   else if (eqG(argv[1], "-r")) {
     sheepyParams.removeBuild = 1;
     dum                      = argv[1];
   }
   else if (eqG(argv[1], "-T")) {
     sheepyParams.genTest     = 1;
     dum                      = argv[1];
   }
   else if (eqG(argv[1], "-g")) {
     sheepyParams.debugExe    = 1;
     dum                      = bin ? ssGet(bin) : argv[2];
   }
   else if (eqG(argv[1], "-gt")) {
     sheepyParams.debugExe    = 1;
     goto testOption;
   }
   else if (eqG(argv[1], "-gm")) {
     sheepyParams.debugExe    = 1;
     goto memcheckOption;
   }
   else if (eqG(argv[1], "-ga")) {
     sheepyParams.debugExe    = 1;
     goto asanOption;
   }
   else {
     dum = argv[1];
   }
 
   if (!dum) {
     terminateG(bin);
     putsG(BLD RED "Missing program name argument." RST);
     XFAILURE
   }
 
 
   if (sheepyParams.new) {
     terminateG(bin);
     rangeFrom(i, 2, argc)
       sourceFromTemplate(argv[i]);
     XSUCCESS
   }
 
   if (sheepyParams.removeBuild) {
     terminateG(bin);
     char *build = catS(homedir, "build");
     if (fileExists(build)) {
       pError0(rmAll(build));
       pError0(mkdirParents(build));
     }
     free(build);
     XSUCCESS
   }
 
   if (sheepyParams.genTest) {
     terminateG(bin);
     if (!fileExists(PACKAGE)) {
       putsG(BLD RED PACKAGE " is missing. Test templates not generated." RST);
       XFAILURE
     }
     createSmallJson(pkgInfo);
     readFileG(&pkgInfo, PACKAGE);
     //logVarG(&pkgInfo);
 
     // generate testBin
     char *testBin = getG(&pkgInfo, rtChar, "testBin");
     if (!testBin) {
       putsG(BLD RED "testBin is not set in " UDL PACKAGE RST BLD RED ", add a line with '  testBin: test.c'. Test templates not generated." RST);
       XFAILURE
     }
     if (fileExists(testBin)) {
       printf(BLD RED "test template %s already exists. Test templates not generated." RST, testBin);
       XFAILURE
     }
     char *s = replaceG(C_TEST_TEMPLATE, "testTemplate", getG(&pkgInfo, rtChar, "name"), 0);
     pError0(writeFileG(s, testBin));
     free(s);
     printf("Generated: "BLD GRN "%s" RST " " UDL "< add the test cases in this file" RST "\n", testBin);
     printf("To run the test, execute: " BLD WHT "spm test" RST "\n");
     printf(BLD YLW "Warning" RST ": do not call " UDL "initLibsheepy" RST " in " UDL "%s" RST ", it conflicts with libcheck\n", testBin);
 
     // generate memcheckBin and asanBin
     char *memcheckBin = getG(&pkgInfo, rtChar, "memcheckBin");
     char *asanBin     = getG(&pkgInfo, rtChar, "asanBin");
     if (!memcheckBin and !asanBin) {
       putsG(BLD RED "memcheckBin and asanBin are not set in " UDL PACKAGE RST BLD RED ", add a line with '  memcheckBin: testMem.c' or '  asanBin: testMem.c'. Memcheck test templates not generated." RST);
       XFAILURE
     }
 
     if (!fileExists(MEMTEST_C_TEMPLATE_NAME)) {
       pError0(writeFileG(MEMTEST_C_TEMPLATE, MEMTEST_C_TEMPLATE_NAME));
       putsG("Generated: "BLD GRN MEMTEST_C_TEMPLATE_NAME RST);
     }
     if (!fileExists(RUNMEMTEST_TEMPLATE_NAME)) {
       pError0(writeFileG(RUNMEMTEST_TEMPLATE, RUNMEMTEST_TEMPLATE_NAME));
       pError0(fileChmod(RUNMEMTEST_TEMPLATE_NAME, S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH));
       putsG("Generated: "BLD GRN RUNMEMTEST_TEMPLATE_NAME RST);
     }
     if (memcheckBin) {
       char *shell = NULL;
       if (isC(testBin)) {
         pErrorNULL(setG(testBin, -2, 0));
         shell = catS(testBin, "Mem.sh");
         // restore original testBin
         testBin[strlen(testBin)] = '.';
         if (!fileExists(shell)) {
           s = replaceManyS(MEMCHECK_SH_TEMPLATE, "testBin", testBin, "memcheckBin", memcheckBin);
           pError0(writeFileG(s, shell));
           free(s);
           pError0(fileChmod(shell, S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH));
           printf("Generated: "BLD GRN "%s" RST"\n", shell);
       }
         }
       printf("To run the memcheck test, execute: " BLD WHT "%s" RST "\n", shell);
       free(shell);
     }
     if (asanBin) {
       char *shell = NULL;
       if (isC(testBin)) {
         pErrorNULL(setG(testBin, -2, 0));
         shell = catS(testBin, "Asan.sh");
         // restore original testBin
         testBin[strlen(testBin)] = '.';
         if (!fileExists(shell)) {
           s = replaceManyS(ASAN_SH_TEMPLATE, "testBin", testBin, "asanBin", asanBin);
           pError0(writeFileG(s, shell));
           free(s);
           pError0(fileChmod(shell, S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH));
           printf("Generated: "BLD GRN "%s" RST"\n", shell);
       }
         }
       printf("To run the asan test, execute: " BLD WHT "%s" RST "\n", shell);
       free(shell);
     }
 
     freeG(&pkgInfo);
     XSUCCESS
   }
 
   if (sheepyParams.test or sheepyParams.memcheck or sheepyParams.asan) {
     sheepyParams.compileOnly = 1;
   }
 
   if (sheepyParams.cclass) {
     terminateG(bin);
     // make sure first char is lower case
     dum[0]   = tolower(dum[0]);
 
     // generate template filenames
     char *fn  = catS(dum, ".h");
     char *fn1 = catS(dum, ".c");
     char *fn2 = catS(dum, "Internal.h");
 
     if (fileExists(fn)) {
       printf(BLD RED "class file '%s' already exists." RST, fn);
       XFAILURE
     }
     if (fileExists(fn1)) {
       printf(BLD RED "class file '%s' already exists." RST, fn1);
       XFAILURE
     }
     if (fileExists(fn2)) {
       printf(BLD RED "class file '%s' already exists." RST, fn2);
       XFAILURE
     }
 
     char *s  = replaceS(H_CLASS_TEMPLATE, "classTemplate", dum, 0);
     char *s1 = replaceS(C_CLASS_TEMPLATE, "classTemplate", dum, 0);
     char *s2 = replaceS(INTERNAL_H_CLASS_TEMPLATE, "classTemplate", dum, 0);
     dum[0]   = toupper(dum[0]);
     pErrorNULL(iReplaceS(&s, "ClassTemplate", dum, 0));
     pErrorNULL(iReplaceS(&s1, "ClassTemplate", dum, 0));
     pErrorNULL(iReplaceS(&s2, "ClassTemplate", dum, 0));
 
     char *DUM = upperS(dum);
     pErrorNULL(iReplaceS(&s, "CLASSTEMPLATE", DUM, 0));
     free(DUM);
 
     pError0(writeFileG(s, fn));
     pError0(writeFileG(s1, fn1));
     pError0(writeFileG(s2, fn2));
 
     dum[0]   = tolower(dum[0]);
     printf("Created files for class "BLD GRN"%s"RST":\n%s\n%s\n%s", dum, fn, fn1, fn2); {
     freeManyS(s, s1, s2, fn, fn1, fn2);
     XSUCCESS
   }
     }
 
   if (sheepyParams.libsheepyMemcheck) {
     libsheepy = "libsheepyMemcheck.a";
   }
 
   if (sheepyParams.libsheepyAsan) {
     libsheepy = "libsheepyAsan.a";
   }
 
   mainFilename = normalizePath(dum);
 
   sheepyRun:
 
   if (!fileExists(mainFilename)) {
     // add c and cp extension and check if file exists
     dum = catS(mainFilename, ".c");
     if (fileExists(dum)) {
       // add c extension to mainFilename
       free(dum);
       pErrorNULL(pushG(&mainFilename, ".c"));
     }
     else {
       free(dum);
       dum = catS(mainFilename, ".cp");
       if (fileExists(dum)) {
         // add cp extension to mainFilename
         free(dum);
         pErrorNULL(pushG(&mainFilename, ".cp"));
       }
       else {
         free(dum);
         puts(BLD RED "File not found:" RST);
         puts(mainFilename);
         XFAILURE
   }
     }
       }
 
   if (isLink(mainFilename)) {
     char *tmp = endlink(mainFilename);
     if (!tmp) {
       printf(BLD RED "couldn't read link '%s'" RST, mainFilename);
       free(mainFilename);
       XFAILURE
     }
     free(mainFilename);
     mainFilename = tmp;
   }
 
   // get basename (rootMain)
   // mainSrc is main filename without path
   // rootMain is the main filename without path and extension
   // exePath is the main filename without the extension
   // dir is the relative path without the main filename
   // actualDir is the real path to main
   // sheepy ../bin/example.c p1
   //  > mainSrc   = example.c
   //  > rootMain  = example
   //  > dir       = ../bin
   //  > actualDir = /home/remy/bin
   char *mainSrc = strdup(basename(mainFilename));
   if (isH(mainSrc) || isCH(mainSrc)) {
     // print this message only when compiling
     if (!sheepyParams.clean) {
       puts("No compilation needed for header files.");
     } {
     XSUCCESS
   }
       }
   if (!isC(mainSrc) && !isCP(mainSrc)) {
     // add c and cp extension and check if file exists
     dum = catS(mainSrc, ".c");
     if (fileExists(dum)) {
       // add c extension to mainSrc
       free(dum);
       pErrorNULL(pushG(&mainSrc, ".c"));
     }
     else {
       free(dum);
       dum = catS(mainSrc, ".cp");
       if (fileExists(dum)) {
         // add cp extension to mainSrc
         free(dum);
         pErrorNULL(pushG(&mainSrc, ".cp"));
       }
       else {
         free(dum);
         puts(BLD RED "Unknown extension. Stop." RST);
         puts(mainSrc);
         XFAILURE
   }
     }
       }
 
   char *exePath = strdup(mainFilename);
   if (isC(mainSrc)) {
     pErrorNULL(setS(exePath, -2, 0));
   }
   else {
     pErrorNULL(setS(exePath, -3, 0));
   }
 
   char *mainH       = strdup(mainSrc);
   pErrorNULL(setS(mainH, -1, 'h'));
 
   // [0] root name [1] extension
   char **rootMain_l = split(mainSrc, ".");
   char *rootMain    = rootMain_l[0];
 
   // main source folder (dir)
   // Ex: dir = ../bin or ./ when there is no folder in mainFilename
   char *dir = shDirname(mainFilename);
 
   // if there is package.yml in dir, check if there are package dependencies and the shpPackages folder
   // install the packages when shpPackages is not found
   dum = catS(dir, "/"PACKAGE_DIR);
   pErrorNULL(normalizePathG(&dum));
   if (!sheepyParams.clean && not isDir(dum)) {
     free(dum);
     dum = catS(dir, "/", PACKAGE);
     pErrorNULL(normalizePathG(&dum));
     if (fileExists(dum)) {
       createSmallJson(pkgInfo);
       readFileG(&pkgInfo, dum);
       smallDictt *pkgDeps = getG(&pkgInfo, rtSmallDictt, "dependencies");
       if (pkgDeps) {
         if (lenG(pkgDeps)) {
           char *c = formatS("cd %s ; spm install", dir);
           if (getG(cfgD, rtBool, "print_compile_commands")) {
             printf("%s\n", c);
           }
           programResult |= commandNFree(c);;
         }
         finishG(pkgDeps);
       }
       freeG(&pkgInfo);
     }
     free(dum);
   }
   else {
     free(dum);
   }
 
   // find out real path for main source
   char actualpath[PATH_MAX+1];
   char *actualDir;
   realpath(mainFilename, actualpath);
   actualDir = shDirname(actualpath);
   //logVarG(actualDir);
 
   char *buildPath;
 
   if (sheepyParams.test) {
     buildPath = catS(homedir, "build", actualDir, "Test");
   }
   else if (sheepyParams.memcheck) {
     buildPath = catS(homedir, "build", actualDir, "Memcheck");
   }
   else if (sheepyParams.asan) {
     buildPath = catS(homedir, "build", actualDir, "Asan");
   }
   else {
     // compile, run or clean
     buildPath = catS(homedir, "build", actualDir);
     if (sheepyParams.clean) {
       // delete test build folders: test, memcheck...
       dum = catS(homedir, "build", actualDir, "Test");
       if (isDir(dum)) {
         if (getG(cfgD, rtBool, "print_compile_commands")) {
           printf("rm -rf %s", dum);
           printf("\n");
         }
         pError0(rmAll(dum));
       }
       free(dum);
       dum = catS(homedir, "build", actualDir, "Memcheck");
       if (isDir(dum)) {
         if (getG(cfgD, rtBool, "print_compile_commands")) {
           printf("rm -rf %s", dum);
           printf("\n");
         }
         pError0(rmAll(dum));
       }
       free(dum);
       dum = catS(homedir, "build", actualDir, "Asan");
       if (isDir(dum)) {
         if (getG(cfgD, rtBool, "print_compile_commands")) {
           printf("rm -rf %s", dum);
           printf("\n");
         }
         pError0(rmAll(dum));
       }
       free(dum);
   }
     }
 
 
   char *buildExePath = catS(buildPath, "/", rootMain);
   //logVarG(buildPath);
 
 
   if (sheepyParams.debugExe) {
     char *debuggerCmd = getG(cfgJ, rtChar, "debuggerCmd");;
     if (!debuggerCmd) {
       printf(BLD RED"debuggerCmd not found in "HOME_DIR CONFIG_NAME ", run 'sheepy -D' to see an example." RST);
       XFailure;
     }
     if (!fileExists(buildExePath)) {
       printf(BLD RED"Executable not found, run the compile command first. Path was: %s"RST, buildExePath);
       XFailure;
     }
 
     createAllocateSmallArray(paramL);
     // debug program with parameters on command line
     rangeFrom(i, 3, argc)
       pErrorNULL(pushG(paramL, argv[i]));
     // create parameter string for running the program in argv[1]
     // add quotes to keep the same number of arguments
     char *params = joinSG(paramL, "\" \"");
     if (!params) {
       emptyS(params);
     }
     else {
       pErrorNULL(prependG(&params, "\""));
       pErrorNULL(pushG(&params, "\""));
     }
 
     char *debugCommand = formatS("%s %s %s", debuggerCmd, buildExePath, params);;
     pErrorNot0(system(debugCommand));
     if (getG(cfgD, rtBool, "print_compile_commands")) {
       printf("%s\n", debugCommand);
     }
     XSuccess;
   }
 
 
   if (sheepyParams.showExe) {
     printf("The executable path is:      " GRN "%s" RST
          "\nThe executable directory is: " GRN "%s" RST, buildExePath, shDirname(buildExePath));
     XSUCCESS
   }
   if (!fileExists(buildPath)) {
     pError0(mkdirParents(buildPath));
   }
 
   // load main source (mainCode)
   // Steps
     // detect hash bang and remove
     // find dependencies
     // recursively search dependencies
     // search for other includes
   createAllocateSmallArray(mainFile);
   readFileG(mainFile, mainFilename);
 
     // detect hash bang and remove
   char *hBang = NULL;
   hBang = getG(mainFile, hBang, 0);
   if (hBang && hBang[0] == '#' && hBang[1] == '!' && findS(hBang, "sheepy")) {
     pErrorNULL(setG(mainFile, 0, ""));
   }
 
   // if main is cp, convert to c in buildpath
   smallArrayt *cCode;
   if (isC(mainSrc)) {
     cCode = dupG(mainFile);
   }
   else {
     // main is cp, convert to c in buildpath
     // generate c
     initiateG(&cCode);
     generateCBuffers(mainFile, cCode);
   }
     /* forEachSmallArray(mainFile, lO) */
     /*   // convert ch include to h */
     /*   castS(l, duplicateG(lO)) */
     /*   if hasG(l, ".ch\"") */
     /*     replaceG(l, ".ch\"", ".h\"", 0); */
     /*   pushNFreeG(cCode, l); */
     /*   free lO */
 
   // create generated main path and save the main c code in it
   char *mainCPath = catS(buildPath, "/", mainSrc);
   if (isCP(mainSrc)) {
     // cp file
     pErrorNULL(setS(mainCPath, -2, 'c'));
     pErrorNULL(setS(mainCPath, -1, 0));
   }
   writeTextO(cCode, mainCPath);
   terminateG(cCode);
 
     // find dependencies
     // recursively search dependencies
     // TODO remove/ignore comments before searching for includes
     // inc is the list of all includes from all h and c files
     // the c files associated with the includes are compiled
     // create dependency dictionary
   createAllocateSmallDict(dependencies);
   // dependencies dict:
   // keys:   h files
   // values: first level header dependencies
   createAllocateSmallArray(inc);
   // TODO check if the h is already in dependencies
   createAllocateSmallArray(mainDepFiles);
   iter(mainFile, l) {
     castS(L, l)
     // TODO improve main function detection
     if (hasG(L, "main") && (hasG(L, "int") || hasG(L, "define")) && !sheepyParams.compileLib) {
       // main function detected
       // compile the executable if requested
       sheepyParams.dontCompileExe = 0;
     }
     char *s = getInclude(L);
     if (s) {
       // check if c includes itself
       char *fN;
       fN = strdup(basename(s));
       // add new include to inc array
       char *realFPath  = catS(actualDir, "/", s);
       char *buildFPath = catS(buildPath, "/", s);
       pErrorNULL(iNormalizePath(&realFPath));
       pErrorNULL(iNormalizePath(&buildFPath));
       // create a link to header in buildPath
       // because main.c is in buildPath and the compiler needs
       // to find the headers
       if (symlinkFile(realFPath, buildFPath)) {
         pErrorNULL(pushG(inc, s));
         pErrorNULL(pushG(mainDepFiles, s));
       }
       freeManyS(realFPath, buildFPath);
       free(fN);
       free(s);
     }
   }
   terminateG(mainFile);
 
   // add mainFilename.h to dependencies for cases when mainFilename doesn't include the header
   // (this handles empty main source files)
   if (isC(mainFilename)) {
     pErrorNULL(setG(mainFilename, -1, 'h'));
     if (fileExistsG(mainFilename) && !hasG(inc, mainH)) {
       pErrorNULL(pushG(inc, mainH));
       pErrorNULL(pushG(mainDepFiles, mainH));
     }
     pErrorNULL(setG(mainFilename, -1, 'c'));
   }
 
   setNFreeG(dependencies, mainSrc, mainDepFiles);
   //logVarG(dependencies);
   //print '**** inc ****'
   //logVarG(inc);
 
     // search for other includes
   forEachSmallArray(inc, otherIncs) {
     castS(L, dupG(otherIncs))
     //logVarG(inc);
     //logVarG(dependencies);
 
     createAllocateSmallArray(file);
     char *fileDir  = shDirname(ssGet(L));
     char *fileName;
     fileName = strdup(basename(ssGet(L)));
 
 
     if (hasG(L, PACKAGE_DIR)) {
       // this include belongs to a package
       // the package are already compiled
       // stop searching for further includes
       // check if the h is already in dependencies, process only new found sources
       if (!hasG(dependencies, ssGet(L))) {
         // scan the package header to symlink includes in the build path so that the compiler find them
         // real path to h file
         dum = catS(actualDir, "/", ssGet(L));
         readFileG(file, dum);
         free(dum);
 
         iter(file, hl) {
         castS(hL, hl)
           char *s = getInclude(hL);
           if (s) {
             // check if c includes itself
             char *fN;
             fN = strdup(basename(s));
             // !hasG(inc, s): add to inc only new files to avoid infinite loops
             if (!eqG(fN, fileName) && !hasG(inc, s)) {
               // add new include to inc array
               char *tmp        = catS(fileDir, "/", s);
               pErrorNULL(iNormalizePath(&tmp));
               char *realFPath  = catS(actualDir, "/", tmp);
               char *buildFPath = catS(buildPath, "/", tmp);
               pErrorNULL(iNormalizePath(&realFPath));
               pErrorNULL(iNormalizePath(&buildFPath));
               //logVarG(fileDir);
               //logVarG(s);
               //logVarG(realFPath);
               // create a link to header in buildPath
               // because main.c is in buildPath and the compiler needs
               // to find the headers
               symlinkFile(realFPath, buildFPath);
               freeManyS(tmp, realFPath, buildFPath);
             }
             free(fN);
             free(s);
           }
         }
         freeG(file);
 
         // add the a libs to detect when the package dependencies are updated and recompile the source files
         createAllocateSmallArray(libDep);
         // TODO support ch and cp
         // remove sub directories in packages, the a file is located at the package root
         // shpPackages/ini/src/ini.h
         // shpPackages/ini/ini.a
         smallArrayt *spl    = splitG(L, PACKAGE_DIR"/");
         smallStringt *last  = getG(spl, rtSmallStringt, -1);
         pErrorNULL(setG(last, -1, 'a'));
         // last is "ini/src/ini.a"
         smallArrayt *sslash = splitG(last, '/');
         finishG(last);
         char *lib           = catS(getG(sslash, rtChar, 0), "/", getG(sslash, rtChar, -1));
         setNFreeG(spl, -1, lib);
         lib                 = joinSG(spl, PACKAGE_DIR"/");
         terminateManyG(spl,sslash);
         if (fileExists(lib)) {
           // link library only when it exists, there is no library in header only packages
           pushNFreeG(libDep, lib);
         }
         else {
           free(lib);
         }
         pErrorNULL(setG(L, -1, 'h'));
         setNFreeG(dependencies, ssGet(L), libDep);
       }
       terminateG(L);
       finishG(otherIncs);
       continue;
     }
 
     smallArrayt *depFiles = NULL;
     // check if the h is already in dependencies, process only new found sources
     if (!hasG(dependencies, ssGet(L))) {
       initiateAllocateSmallArray(&depFiles);
 
       // scan h
       // real path to h file
       dum = catS(actualDir, "/", ssGet(L));
       readFileG(file, dum);
       free(dum);
 
       forEachSmallArray(file, hl) {
         castS(hL, hl)
         char *s = getInclude(hL);
         if (s) {
           // check if c includes itself
           char *fN;
           fN = strdup(basename(s));
           if (!eqG(fN, fileName)) {
             // add new include to inc array
             char *tmp        = catS(fileDir, "/", s);
             pErrorNULL(iNormalizePath(&tmp));
             char *realFPath  = catS(actualDir, "/", tmp);
             char *buildFPath = catS(buildPath, "/", tmp);
             pErrorNULL(iNormalizePath(&realFPath));
             pErrorNULL(iNormalizePath(&buildFPath));
             //logVarG(fileDir);
             //logVarG(s);
             //logVarG(realFPath);
             // create a link to header in buildPath
             // because main.c is in buildPath and the compiler needs
             // to find the headers
             if (symlinkFile(realFPath, buildFPath)) {
               // !hasG(inc, s): add to inc only new files to avoid infinite loops
               if (!hasG(inc, s)) {
                 pErrorNULL(pushG(inc, tmp));
               }
               pErrorNULL(pushG(depFiles, tmp));
             }
             freeManyS(tmp, realFPath, buildFPath);
           }
           free(fN);
           free(s);
         }
         finishG(hL);
       }
 
       pErrorNULL(normalizePathO(L));
       setNFreeG(dependencies, ssGet(L), depFiles);
     }
 
     // scan c or cp
     freeG(file);
     if (isH(fileName)) {
       pErrorNULL(setG(L, -1, 'c'));
     }
     else {
       // scan .cp
       pErrorNULL(setG(L, -1, 'p'));
     }
 
     // check if the c is already in dependencies, process only new found sources
     if (!hasG(dependencies, ssGet(L))) {
       initiateAllocateSmallArray(&depFiles);
 
       dum = catS(actualDir, "/", ssGet(L));
       if (fileExists(dum)) {
         readFileG(file, dum);
 
         forEachSmallArray(file, cl) {
           castS(cL, cl)
           char *s = getInclude(cL);
           // !hasG(inc, s): add to inc only new files to avoid infinite loops
           if (s) {
             char *tmp = catS(fileDir, "/", s);
             pErrorNULL(iNormalizePath(&tmp));
             char *realFPath  = catS(actualDir, "/", tmp);
             char *buildFPath = catS(buildPath, "/", tmp);
             pErrorNULL(iNormalizePath(&realFPath));
             pErrorNULL(iNormalizePath(&buildFPath));
             if (symlinkFile(realFPath, buildFPath)) {
               pErrorNULL(pushG(depFiles, tmp));
               // check if c includes itself
               char *fN;
               fN = strdup(basename(s));
               if (!eqG(fN, fileName) && !hasG(inc, s)) {
                 // add new include to inc array
                 pErrorNULL(pushG(inc, tmp));
               }
               free(fN);
             }
             freeManyS(tmp, s, realFPath, buildFPath);
           }
           finishG(cL);
         }
 
         setNFreeG(dependencies, ssGet(L), depFiles);
       }
 
       free(dum);
     }
     freeManyS(fileName, fileDir, otherIncs);
     terminateManyG(file, L);
   }
 
   //logVarG(dependencies);
   //print '**** inc ****'
   //logVarG(inc);
 
   // uniquify inc list
   // to avoid compiling and linking several times the same file
   enumerateSmallArray(inc, hE, i) {
     castS(h, hE)
     pErrorNULL(normalizePathO(h));
     setNFreePG(inc, i, h);
   }
   uniqG(inc, unusedV);
 
   //logVarG(inc);
 
   // parameters
   createAllocateSmallArray(paramL);
 
   // run program with parameters on command line
   // when argv[1] is an option (-l, -c ...) the program is not
   // executed
   rangeFrom(i, 2, argc)
     pErrorNULL(pushG(paramL, argv[i]));
 
   // create parameter string for running the program in argv[1]
   // add quotes to keep the same number of arguments
   char *params = joinSG(paramL, "\" \"");
   if (!params) {
     emptyS(params);
   }
   else {
     pErrorNULL(prependG(&params, "\""));
     pErrorNULL(pushG(&params, "\""));
   }
 
   // detect execute bit
   // if yes then run (run)
   char *run = emptySF();
 
   if (!sheepyParams.compileLib && !sheepyParams.compileOnly && access(mainFilename, X_OK) == 0) {
     // run
     // -l is not in the parameters
     pErrorNULL(iAppendManyS(&run, "; ", buildExePath, " ", params));
   }
   else if (!sheepyParams.clean) {
     printf(BLD BLU "Compile only" RST " %s\n", rootMain);
   }
 
   // compile options
   char *m32bit;
   char *ar32bit;
   if (getG(cfgD, rtBool, "32bit")) {
     m32bit  = "-m32";
     ar32bit = "--target=elf32-i386";
   }
   else {
     m32bit  = "";
     ar32bit = "";
   }
 
   //logVarG(dependencies);
     // check updates in all dependencies
   // create cDependencies dict
   // key:   c files
   // value: array of direct/indirect includes
   //logP("--- cDependencies");
   createAllocateSmallDict(cDependencies);
   if (lenG(dependencies) > 0) {
     char *k;
     iter(dependencies, depArray) {
       k = (char*)iterKeyG(dependencies);
       if (isC(k) || isCP(k)) {
         //logVarG(k);
         cast(smallArrayt *, depsOrig, depArray);
         // add dependencies from header file to c dependency list
         // to recompile when a header is updated
         if (isC(k)) {
           pErrorNULL(setS(k, -1, 'h'));
           if (hasG(dependencies, k)) {
             pErrorNULL(appendNFreeG(depsOrig, getNDupG(dependencies, rtSmallArrayt, k)));
           }
           pErrorNULL(setS(k, -1, 'c'));
         }
         elif (isCP(k)) {
           pErrorNULL(setS(k, -1, 'h'));
           if (hasG(dependencies, k)) {
             pErrorNULL(appendNFreeG(depsOrig, getNDupG(dependencies, rtSmallArrayt, k)));
           }
           pErrorNULL(setS(k, -1, 'p'));
         }
         // update depArray pointer in dependencies because it might have been updated
         setPG(dependencies, k, depsOrig);
         smallArrayt *deps = dupG(depsOrig);
         // recursively add dependencies for the C file 'k'
         createAllocateSmallArray(depStack);
         pErrorNULL(pushG(depStack, depsOrig));
         while (not isEmptyG(depStack)) {
           smallArrayt *fileDeps = dequeueG(depStack, rtSmallArrayt);;
           // for each dep, append dep array to c dep array
           forEachSmallArray(fileDeps, dep) {
             castS(depName, dep)
             if (isH(ssGet(depName)) || isCH(ssGet(depName))) {
               // check if the array is empty
               smallArrayt *dp       = getG(dependencies, rtSmallArrayt, ssGet(depName));
               if (dp and not isEmptyG(dp)) {
                 pErrorNULL(pushG(depStack, dp));
                 smallArrayt *thisDeps = getNDupG(dependencies, rtSmallArrayt, ssGet(depName));
                 pErrorNULL(appendNSmashG(deps, thisDeps));
               }
               finishG(dp);
             }
             finishG(dep);
           }
           finishG(fileDeps);
         }
         terminateG(depStack);
         // uniquify deps
         uniqG(deps, unusedV);
         // add array to cDependencies
         setNFreeG(cDependencies, k, deps);
       }
     }
   }
 
   terminateG(dependencies);
 
   //logVarG(cDependencies);
 
   createAllocateSmallDict(toCompile);
 
   // check if h and c (not all of them are in the list) files are modified
   if (lenG(cDependencies) > 0) {
     const char *k;
     createSmallArray(copyAllHeaderDatesToDep);
     // Array to store h deps to be able to copy deps after all dependencies are found
     createSmallArray(copyHeaderDepToBuildPath);
     iter(cDependencies, depValue) {
       k = iterKeyG(cDependencies);
       //logVarG(k);
       cast(smallArrayt *, hDeps, depValue)
 
       char *realCPath  = catS(actualDir, "/", k);
       char *buildCPath = catS(buildPath, "/", k);
       // TODO free ^^ before continue and at the end
       pErrorNULL(iNormalizePath(&realCPath));
       pErrorNULL(iNormalizePath(&buildCPath));
       // detect c file is updated
       // get modification time for c file k
       struct stat cst;
       pError(stat(realCPath, &cst))
       free(realCPath);
 
       // check if object already exists in build path
       if (isC(k)) {
         pErrorNULL(setS(buildCPath, -1, 'o'));
       }
       else {
         pErrorNULL(setS(buildCPath, -2, 'o'));
         pErrorNULL(setS(buildCPath, -1, 0));
       }
       //puts(buildCPath);
       if (fileExists(buildCPath)) {
         //logP("EXISTS");
 
         struct stat ost;
         pError(stat(buildCPath, &ost))
         //logVarG(cst.st_mtime);
         //logVarG(ost.st_mtime);
         if (cst.st_mtime != ost.st_mtime or sheepyParams.clean) {
           // when cleaning, add all C files
           //logP("DIFFERENT DATES RECOMPILE");
           addFileToCompile(actualDir, k, buildCPath, toCompile);
           // copy header dates to not recompile unecesserarily next time
           // change dep files after all modified files are found
           createSmallArray(headerInfo);
           pErrorNULL(pushG     (&headerInfo, actualDir));
           pErrorNULL(pushNFreeG(&headerInfo, dupG(hDeps)));
           pErrorNULL(pushG     (&headerInfo, buildPath));
           pErrorNULL(pushG     (&copyAllHeaderDatesToDep, &headerInfo));
           free(buildCPath);
           continue;
         }
         else {
           // logP("C AND O HAVE SAME DATE - CHECK IF H FILES ARE UPDATED");
           // check if h file for this c file is modified
           // if not check if h files dependencies are modified
           // execute the code below
 
           //logP("CHECK HEADER");
           // get modification time for header
           struct stat hst;
           dum = catS(actualDir, "/", k);
           pErrorNULL(setS(dum, -1, 'h'));
           if (fileExists(dum)) {
             pError(stat(dum, &hst))
             free(dum);
 
             // get modification time for dep file
             dum = catS(buildPath, "/", k, ".dep");
             pErrorNULL(setS(dum, -5, 'h'));
             //logVarG(k);
             //logVarG(dum);
             if (fileExists(dum)) {
               //puts("H EXISTS");
               // compare to header modification time in build path
               struct stat bst;
               pError(stat(dum, &bst))
               if (hst.st_mtime != bst.st_mtime) {
                 // h file for the k c file is modified, recompile the c file
                 addFileToCompile(actualDir, k, buildCPath, toCompile);
                 // copy header dates to not recompile unecesserarily next time
                 // change dep files after all modified files are found
                 createSmallArray(headerInfo);
                 pErrorNULL(pushG     (&headerInfo, actualDir));
                 pErrorNULL(pushNFreeG(&headerInfo, dupG(hDeps)));
                 pErrorNULL(pushG     (&headerInfo, buildPath));
                 pErrorNULL(pushG     (&copyAllHeaderDatesToDep, &headerInfo));
                 free(buildCPath);
                 free(dum);
                 continue;
           }
             }
               }
           free(dum);
       }
         }
       else {
         // object file not found, compile c file
         //logP("COMPILE");
         //puts(buildCPath);
         addFileToCompile(actualDir, k, buildCPath, toCompile);
         // copy header dates to not recompile unecesserarily next time
         // change dep files after all modified files are found
         createSmallArray(headerInfo);
         pErrorNULL(pushG     (&headerInfo, actualDir));
         pErrorNULL(pushNFreeG(&headerInfo, dupG(hDeps)));
         pErrorNULL(pushG     (&headerInfo, buildPath));
         pErrorNULL(pushG     (&copyAllHeaderDatesToDep, &headerInfo));
         free(buildCPath);
         continue;
       }
 
       bool addCFileK = no;
       // check if h files are modified
       forEachSmallArray(hDeps, dep) {
         castS(Dep, dep);
         char *depName = ssGet(Dep);
 
         // get modification time for header depName
         struct stat hst;
         dum = catS(actualDir, "/", depName);
         pError(stat(dum, &hst))
         free(dum);
 
         dum = catS(buildPath, "/", depName, ".dep");
         //logVarG(depName);
         //logVarG(dum);
         if (fileExists(dum)) {
           //logP("H EXISTS");
           // compare to header modification time in build path
           struct stat bst;
           pError(stat(dum, &bst))
           if (hst.st_mtime != bst.st_mtime or sheepyParams.clean) {
             // clean all files
             // header is updated
             //logP("H UPDATED");
             addCFileK = yes;
             char *hBP = catS(buildPath, "/", depName);
             // store h dep in array to copy deps after all dependencies are found
             storeHeaderDep(&copyHeaderDepToBuildPath, hBP, hst);
             addFileToCompile(actualDir, k, buildCPath, toCompile);
 
             // when h file is modified, recompile the associated C/CP file
             if (!hasG(depName, PACKAGE_DIR)) {
                 char *cfile = dupG(depName);
                 if (isH(cfile)) {
                   pErrorNULL(setG(cfile, -1, 'c'));
                 }
                 else {
                   pErrorNULL(setG(cfile, -1, 'p'));
                 }
                 if (fileExists(cfile)) {
                   char *buildCPathForH = catS(buildPath, "/", cfile);
                   if (isC(k)) {
                     pErrorNULL(setS(buildCPathForH, -1, 'o'));
                   }
                   else {
                     pErrorNULL(setS(buildCPathForH, -2, 'o'));
                     pErrorNULL(setS(buildCPathForH, -1, 0));
                   }
                   addFileToCompile(actualDir, cfile, buildCPathForH, toCompile);
                   free(buildCPathForH);
                 }
                 free(cfile);
           }
             }
           else if (endsWithG(depName, ".a")) {
             // check if package is newer than executable or library
             // to handle case when several program/libraries use a common package
             // (for example: 2 programs in the directory using a common package)
             if (!sheepyParams.compileLib) {
               // check buildExePath
               if (fileExists(buildExePath)) {
                 struct stat bst;
                 pError(stat(buildExePath, &bst))
                 if (bst.st_mtime < hst.st_mtime) {
                   // recompile source file k because the existing exe is older than the depName lib
                   if (!sheepyParams.clean) {
                     logI("recompile source file '%s' because the existing exe is older than %s", k, depName);
                   }
                   char *hBP = catS(buildPath, "/", depName);
                   // store h dep in array to copy deps after all dependencies are found
                   storeHeaderDep(&copyHeaderDepToBuildPath, hBP, hst);
                   addFileToCompile(actualDir, k, buildCPath, toCompile);
             }
               }
                 }
             else {
               // check if package is newer than the library currently being built
               char *libName = catS(rootMain, ".a");
               if (fileExists(libName)) {
                 struct stat bst;
                 pError(stat(libName, &bst))
                 if (bst.st_mtime < hst.st_mtime) {
                   // recompile source file k because the existing exe is older than the depName lib
                   if (!sheepyParams.clean) {
                     logI("recompile source file '%s' because the existing exe is older than %s", k, depName);
                   }
                   char *hBP = catS(buildPath, "/", depName);
                   // store h dep in array to copy deps after all dependencies are found
                   storeHeaderDep(&copyHeaderDepToBuildPath, hBP, hst);
                   addFileToCompile(actualDir, k, buildCPath, toCompile);
               }
                 }
               free(libName);
         }
           }
             }
         else {
           // new h file: compile dependencies and copy h file to build path
           char *hBP = catS(buildPath, "/", depName);
           // store h dep in array to copy deps after all dependencies are found
           storeHeaderDep(&copyHeaderDepToBuildPath, hBP, hst);
           addFileToCompile(actualDir, k, buildCPath, toCompile);
         }
 
         free(dum);
         finishG(dep);
       }
       if (addCFileK) {
         addFileToCompile(actualDir, k, buildCPath, toCompile);
       }
       free(buildCPath);
       //logVarG(toCompile);
     }
     // copy all header dates to dep files in build directory
     iter(&copyAllHeaderDatesToDep, HeaderInfo) {
       cast(smallArrayt*, headerInfo, HeaderInfo);
       copyHeaderDates(/*actualDir*/getG(headerInfo, rtChar, 0), /*hDeps*/getG(headerInfo, rtSmallArrayt, 1), /*buildPath*/getG(headerInfo, rtChar, 2));
     }
     iter(&copyHeaderDepToBuildPath, HeaderInfo) {
       cast(smallContainert*,headerInfo, HeaderInfo);
       srcFilet *srcI = O(headerInfo,get);;
       copyHeaderToBuildPath(srcI->bpath, srcI->st);
       free(srcI->bpath);
       free(srcI);
     }
     freeG(&copyAllHeaderDatesToDep);
   }
 
   // add all c file to compile list
   if (lenG(inc) > 0) {
     smallArrayt *hList = duplicateG(inc);
     forEachSmallArray(hList, incI) {
       castS(L, incI)
 
       if (hasG(L, PACKAGE_DIR)) {
         // the packages are already compiled
         // dont need to compile corresponding c file
         finishG(incI);
         continue;
       }
 
       if (isH(ssGet(L))) {
         pErrorNULL(setG(L, -1, 'c'));
       }
       else {
         pErrorNULL(setG(L, -1, 'p'));
       }
 
       if (!fileExistsO(L)) {
         // no corresponding c file
         // skip
         finishG(incI);
         continue;
       }
 
       // create object path
       char *oPath;
 
       if (isC(ssGet(L))) {
         pErrorNULL(setG(L, -1, 'o'));
         oPath = catS(buildPath, "/", ssGet(L));
         // restore c extension
         pErrorNULL(setG(L, -1, 'c'));
       }
       else {
         char *tmp = toStringG(L);
         pErrorNULL(setS(tmp, -2, 'o'));
         pErrorNULL(setS(tmp, -1, 0));
         oPath = catS(buildPath, "/", tmp);
         free(tmp);
       }
 
 
       // compare c and o file dates
       // get modification time for c file L
       struct stat cst;
       pError(stat(ssGet(L), &cst))
 
       //putsG(L);
       //puts(oPath);
       if (fileExists(oPath)) {
         //puts("EXISTS");
 
         struct stat ost;
         pError(stat(oPath, &ost))
         if (cst.st_mtime != ost.st_mtime or sheepyParams.clean) {
           // clean all files
           //puts("DIFFERENT DATES RECOMPILE");
           addFileToCompile(actualDir, ssGet(L), oPath, toCompile);
         }
         //else
         //  puts("C AND O HAVE SAME DATE SKIP COMPILATION");
       }
       else {
         // object file not found, compile c file
         //puts("COMPILE");
         //puts(oPath);
         addFileToCompile(actualDir, ssGet(L), oPath, toCompile);
       }
 
       free(oPath);
       finishG(incI);
     }
     terminateG(hList);
   }
 
   //logVarG(toCompile);
 
   char **sourcesToCompile = keysG(toCompile);
 
   // TODO search index of mainSrc, delete from sourcesToCompile and remove if eqG(*src, mainSrc)
 
   // generate the h and c code from sheepy files
   if (lenG(toCompile) > 0) {
     forEachCharP(sourcesToCompile, src) {
       if (eqG(*src, mainSrc)) {
         // main c file is compiled seperately to take care of the hashbang
         continue;
       }
       if (isCP(*src)) {
         // convert cp to c
         char *bpath = catS(buildPath, "/", *src);
         pErrorNULL(setS(bpath, -1, 0));
         // generate c
         generateC(*src, bpath);
         //copy(*src, bpath);
         free(bpath);
 
         // convert ch to h
         smallArrayt *deps = getG(cDependencies, rtSmallArrayt, *src);
         if (deps != NULL && lenG(deps) > 0) {
           forEachSmallArray(deps, dep) {
             castS(depName, dep)
             if (isCH(ssGet(depName))) {
               bpath = catS(buildPath, "/", ssGet(depName));
               pErrorNULL(setS(bpath, -2, 'h'));
               pErrorNULL(setS(bpath, -1, 0));
               // generate h
               pError0(copy(ssGet(depName), bpath));
               free(bpath);
             }
             finishG(dep);
     }
       }
         }
           }
 
     // convert ch to h
     forEachSmallArray(inc, INCF) {
       castS(hFilename, INCF);
       if (isCH(ssGet(hFilename))) {
         char *bpath = catS(buildPath, "/", ssGet(hFilename));
         pErrorNULL(setS(bpath, -2, 'h'));
         pErrorNULL(setS(bpath, -1, 0));
         // generate h
         pError0(copy(ssGet(hFilename), bpath));
         free(bpath);
       }
       finishG(INCF);
   }
     }
 
   terminateG(cDependencies);
 
   // compile
 
   // modify dir when main is cp
   // TODO remove -I dir not needed
   if (isCP(mainSrc)) {
     // TODO use another variable, keep dir as the path to the original main src from the command line argument
     // because dir is used to find the packages
     // the new variable should be used in the compile commands below
     pErrorNULL(iPrependS(&dir, "/"));
     pErrorNULL(iPrependS(&dir, buildPath));
   }
 
   // create object path for main file to compile and link program
   char *mainOPath = catS(buildPath, "/", mainSrc);
   if (isC(mainSrc)) {
     pErrorNULL(setS(mainOPath, -1, 'o'));
   }
   else {
     // cp file
     pErrorNULL(setS(mainOPath, -2, 'o'));
     pErrorNULL(setS(mainOPath, -1, 0));
   }
 
 
   // load package.yml
   dum = catS(dir,"/", PACKAGE);
   smallDictt *pkgD = NULL;
   if (fileExists(dum)) {
     createAllocateSmallJson(pkgInfo);
     readFileG(pkgInfo, dum);
     //putsG(pkgInfo);
 
     pkgD = getTopG(pkgInfo, rtSmallDictt);
     finishG(pkgInfo);
   }
   free(dum);
 
   // continue after this when clean is set
   if (!lenG(toCompile) && !sheepyParams.clean) {
     // main doesnt need to be recompiled
     //print 'main doesnt need to be recompiled'
     if (sheepyParams.compileLib) {
       // check if the library exists
       char *libname = appendS(rootMain, ".so");
       if (!fileExists(libname)) {
         free(libname);
         goto linkOrClean;
       }
       free(libname);
       libname = appendS(rootMain, ".a");
       if (!fileExists(libname)) {
         free(libname);
         goto linkOrClean;
       }
       // already compiled > finish
       free(libname);
     }
     else if (!sheepyParams.dontCompileExe) {
       if (!fileExists(buildExePath)) {
         goto linkOrClean;
         //TODO puts(BLD RED "Executable already compiled but not found in build folder!" RST);
         //TODO XFAILURE
       }
       if (!isEmptyS(run)) {
         // the exe is compiled and the user wants to run it
         dum            = malloc(strlen(buildExePath) + strlen(params) + 1 + 1);
         sprintf(dum, "%s %s", buildExePath, params);
         setMaxLogLevel(LOG_DISABLE);
         programResult |= commandNFree(dum);
         setMaxLogLevel(LOG_INFO);
     }
       }
     goto finish;
     // NOTE: free variables allocated after this line before finish:, to avoid freeing initialized buffers
   }
 
   // delete existing executable in buildPath
   // to avoid running an old executable when the compilation fails
   if (fileExists(buildExePath)) {
     pError0(rmAll(buildExePath));
   }
 
   // setup cflags key depending on the options: -c cflags, -t testCflags, -m memcheckCflags
   const char *cflagsKey;
   const char *cflagsAlwaysKey;
 
   if (sheepyParams.test) {
     cflagsKey       = "testCflags";
     cflagsAlwaysKey = "testCflagsAlways";
   }
   else if (sheepyParams.memcheck) {
     cflagsKey       = "memcheckCflags";
     cflagsAlwaysKey = "memcheckCflagsAlways";
   }
   else if (sheepyParams.asan) {
     cflagsKey       = "asanCflags";
     cflagsAlwaysKey = "asanCflagsAlways";
   }
   else {
     cflagsKey       = "cflags";
     cflagsAlwaysKey = "cflagsAlways";
   }
 
 
   // get compile options from user configuration
   char *cflags = NULL;
   if (pkgD) {
     cflags = getG(pkgD, rtChar, cflagsKey);
     if (!cflags) {
       cflags = getG(cfgD, rtChar, cflagsKey);
   }
     }
   else {
     cflags = getG(cfgD, rtChar, cflagsKey);
   }
 
   if (!cflags) {
     cflags = emptySF();
   }
   else {
     cflags = dupG(cflags);
   }
 
   if (hasG(cfgD, cflagsAlwaysKey) && !isBlankG(getG(cfgD, rtChar, cflagsAlwaysKey))) {
     if (!isBlankG(cflags)) {
       pErrorNULL(prependG(&cflags, ' '));
     }
     pErrorNULL(prependG(&cflags, getG(cfgD, rtChar, cflagsAlwaysKey)));
   }
   //logVarG(cflags);
 
   if (sheepyParams.clean) {
     // continue after this when clean is set
     goto linkOrClean;
   }
 
   if (hasG(toCompile, mainSrc)) {
     // compile main c file
 
     FILE* fp;
     char *cc;
     if (!getG(cfgD, rtBool, "tcc")) {
       asprintf(&cc, GCC " %s %s -I %s -I %s -o %s -c %s", cflags, m32bit, dir, libsheepyIncDir, mainOPath, mainCPath);
     }
     else {
       cc = malloc(strlen(dir) + strlen(libsheepyIncDir) + strlen(mainOPath) + strlen(mainCPath) + 1 + 19);
       sprintf(cc, "tcc -I %s -I %s -o %s -c %s", dir, libsheepyIncDir, mainOPath, mainCPath);
     }
     //char *cc = "cat"
     if (getG(cfgD, rtBool, "print_compile_commands")) {
       printf("%s\n", cc);
     }
     programResult |= command(cc);
 
     // compile includes
   }
   char *subcc;
   if (!getG(cfgD, rtBool, "tcc")) {
     asprintf(&subcc, GCC " %s %s -I %s -I %s -c -o", cflags, m32bit, dir, libsheepyIncDir);
   }
   else {
     subcc = malloc(strlen(dir) + strlen(libsheepyIncDir) + 1 + 17);
     sprintf(subcc, "tcc -I %s -I %s -c -o", dir, libsheepyIncDir);
   }
 
   free(cflags);
 
   if (listLengthS(sourcesToCompile) > 0) {
     forEachCharP(sourcesToCompile, src) {
       if (eqG(*src, mainSrc)) {
         // main c file is compiled seperately to take care of the hashbang
         continue;
       }
 
       // set c file path and create object path
       char *cpath;
       char *oPath;
       if (isC(*src)) {
         cpath = catS(actualDir, "/", *src);
         oPath = catS(buildPath, "/", *src);
       }
       else {
         // cp file has been converted to c in buildPath
         cpath = catS(buildPath, "/", *src);
         pErrorNULL(setS(cpath, -1, 0));
         oPath = strdup(cpath);
       }
       pErrorNULL(setS(oPath, -1, 'o'));
 
       // create compile command and run with system
       createAllocateSmallArray(ccmdL);
 
       pErrorNULL(pushG(ccmdL, subcc));
 
       char *buildMirrorD;
       // macOS: touch object to avoid error in macOS
       buildMirrorD = catS("touch ", oPath);
       char *D = shDirname(oPath);
       pError0(mkdirParents(D));
       free(D);
       programResult |= commandNFree(buildMirrorD);
       buildMirrorD = shDirname(oPath);
       if (!fileExists(buildMirrorD)) {
         // create c file dir in homedir/build
         pError0(mkdirParents(buildMirrorD));
       }
       free(buildMirrorD);
       pushNFreeG(ccmdL, oPath);
 
       pErrorNULL(pushG(ccmdL, cpath));
       char *ccmd = joinSG(ccmdL, " ");
       if (getG(cfgD, rtBool, "print_compile_commands")) {
        printf("%s\n", ccmd);
       }
 
       if (sheepyParams.parallel) {
         // compile in parallel
         // create argument list for child process that compile the source code
         char **jobArgs = split(ccmd, " ");
         terminateG(ccmdL);
 
         // remove possible empty strings due to split before
         pErrorNULL(iListCompactS(&jobArgs));
         spawnProc(childProc, jobArgs);
         listFreeS(jobArgs);
       }
       else {
         programResult |= command(ccmd);
       }
       free(ccmd);
   }
     }
 
   free(subcc);
 
   if (sheepyParams.parallel) {
     // wait for the compilation to finish and start linking
     waitForJobs();
   }
 
   // link and run
   linkOrClean:
 
   listFreeS(sourcesToCompile);
 
     // list include objects and libraries in incObjFiles
   char *incObjFiles;
     // collect lflags from packages
   char *packageLflags = NULL;
   createAllocateSmallArray(incList);
   cleanAllocateSmallArray(aLibPackages);
   forEachSmallArray(inc, incL) {
     castS(L, incL)
     if (eqG(L, mainH)) {
       // main c file is already in the compile list, dont add the main object file to avoid multiple definitions
       // while linking
       finishG(L);
       continue;
     }
     char *s = strdup(ssGet(L));
 
     if (hasG(L, PACKAGE_DIR)) {
       // the packages are already compiled
       // use the static library
       if (isH(ssGet(L))) {
         pErrorNULL(setS(s, -1, 'a'));
       }
       else {
         // L is .ch extension
         pErrorNULL(setS(s, -2, 'a'));
         pErrorNULL(setS(s, -1, 0));
       }
       // the path in L can contain subdirectories in the package
       // shpPackages/ini/src/ini.a
       // the package is compiled at the package root
       // remove the the subdirectories in L
       smallStringt *sp = allocG(s);
       smallArrayt *arr = splitG(sp, "/");
       terminateG(sp);
 
       int keepIndex;
       // find package dir in L
       enumerateSmallArray(arr, E, i) {
         if (eqG(E, PACKAGE_DIR)) {
           keepIndex = i;
           finishG(E);
           break;
         }
         finishG(E);
       }
 
       // keep package name and delete subdirectories
       pErrorNULL(delG(arr, keepIndex+2, -1));
       //logVarG(arr);
 
       free(s);
       // add path to main file to be able to run program from any
       // directory
       pErrorNULL(prependG(arr, dir));
       s = joinSG(arr, "/");
       terminateG(arr);
       if (!fileExists(s)) {
         // link library only when it exists, there is no library in header only packages
         free(s);
         finishG(L);
         continue;
       }
 
       // collect lflags for this package
       char *pkg = shDirnameG(s);
       pErrorNULL(iAppendManyS(&pkg, "/", PACKAGE));
       //logVarG(pkg);
       createAllocateSmallJson(pkgJ);
       if (readFileG(pkgJ, pkg)) {
         if (!isBlankG(getG(pkgJ, rtChar, "lflags"))) {
           if (!packageLflags) {
             packageLflags = getNDupG(pkgJ, rtChar, "lflags");
           }
           else {
             pErrorNULL(iAppendManyS(&packageLflags, " ", getG(pkgJ, rtChar, "lflags")));
       }
         }
           }
       free(pkg);
       terminateG(pkgJ);
     }
     else {
       // it is allowed to include an h without a corresponding c file
       if (isH(ssGet(L))) {
         pErrorNULL(setG(L, -1, 'c'));
       }
       else {
         // L is .ch extension
         pErrorNULL(setS(s, -1, 'p'));
       }
       dum = catS(actualDir, "/", ssGet(L));
       if (!fileExistsG(dum)) {
         // no corresponding c file
         // skip
         freeManyS(L,s, dum);
         continue;
       }
       free(dum);
 
       if (isC(ssGet(L))) {
         pErrorNULL(setS(s, -1, 'o'));
       }
       else {
         // L is .ch extension
         pErrorNULL(setS(s, -2, 'o'));
         pErrorNULL(setS(s, -1, 0));
       }
       pErrorNULL(iPrependS(&s, "/"));
       pErrorNULL(iPrependS(&s, buildPath));
     }
     if (getG(s, unusedV, -1) == 'a') {
       pushNFreeG(aLibPackages, s);
     }
     else {
       pushNFreeG(incList, s);
     }
     finishG(L);
   }
 
   // uniquify the object list to avoid multiple symbol definitions
   uniqG(incList, unusedV);
   uniqG(aLibPackages, unusedV);
 
   //logVarG(inc);
   //logVarG(incList)
 
   if (sheepyParams.clean) {
     // clean objects
     // mainCPath is the generacted main in .sheepy
     if (fileExistsG(mainCPath)) {
       if (getG(cfgD, rtBool, "print_compile_commands")) {
         printf("rm %s", mainCPath);
         printf("\n");
       }
       pError0(rmAll(mainCPath));
     }
     if (fileExistsG(mainOPath)) {
       if (getG(cfgD, rtBool, "print_compile_commands")) {
         printf("rm %s", mainOPath);
         printf("\n");
       }
       pError0(rmAll(mainOPath));
     }
     if (getG(cfgD, rtBool, "clean_exe")) {
       // delete executable or library (.a and .so)
       // executable in buildExePath is already deleted (above after if !lenG(toCompile))
       if (fileExists(exePath)) {
         if (getG(cfgD, rtBool, "print_compile_commands")) {
           printf("rm %s", exePath);
           printf("\n");
         }
         pError0(rmAll(exePath));
       }
       char *libname = appendS(rootMain, ".so");
       if (fileExists(libname)) {
         if (getG(cfgD, rtBool, "print_compile_commands")) {
           printf("rm %s", libname);
           printf("\n");
         }
         pError0(rmAll(libname));
       }
       free(libname);
       libname = appendS(rootMain, ".a");
       if (fileExists(libname)) {
         if (getG(cfgD, rtBool, "print_compile_commands")) {
           printf("rm %s", libname);
           printf("\n");
         }
         pError0(rmAll(libname));
       }
       free(libname);
     }
     forEachSmallArray(incList, incL) {
       castS(L, incL)
 
       char *l = ssGet(L);
       if (startsWithG(l, buildPath)) {
         // skip buildPath when looking for PACKAGE_DIR in L
         // because the user can be cleaning a package
         // without this the object files are not deleted
         l += strlen(buildPath);
       }
 
       if (fileExistsG(ssGet(L))) {
         if (getG(cfgD, rtBool, "print_compile_commands")) {
           printf("rm %s", ssGet(L));
           printf("\n");
         }
         pError0(rmAll(ssGet(L)));
       }
       finishG(L);
     }
 
     free(mainOPath);
     terminateG(incList);
     goto finish;
   }
 
   incObjFiles = joinSG(incList, " ");
   if (!incObjFiles) {
     // when there are no other object files beside the main one, set incList to empty string
     emptyS(incObjFiles);
   }
   char *aLibFiles = joinSG(aLibPackages, " ");
   if (!aLibFiles) {
     // when there are no a libs, set aLibFiles to empty string
     emptyS(aLibFiles);
   }
 
   terminateG(incList);
   terminateG(aLibPackages);
   //logVarG(incObjFiles)
 
   // setup lflags key depending on the options: -c lflags, -t testLflags, -m memcheckLflags
   const char *lflagsKey;
 
   if (sheepyParams.test) {
     lflagsKey       = "testLflags";
   }
   else if (sheepyParams.memcheck) {
     lflagsKey       = "memcheckLflags";
   }
   else if (sheepyParams.asan) {
     lflagsKey       = "asanLflags";
   }
   else {
     lflagsKey       = "lflags";
 
     // create link command gcc/tcc exe/lib/no linking
   }
   char *lflags;
   if (pkgD) {
     lflags = getG(pkgD, rtChar, lflagsKey);
     if (!lflags) {
       lflags = getG(cfgD, rtChar, lflagsKey);
   }
     }
   else {
     lflags = getG(cfgD, rtChar, lflagsKey);
   }
   if (!lflags) {
     lflags = "";
   }
 
   lflags = dupG(lflags);
 
   if (!isBlankG(packageLflags)) {
     pErrorNULL(iAppendManyS(&lflags, " ",packageLflags));
     free(packageLflags);
   }
   //logVarG(lflags);
 
   // setup linkWithGold key depending on the options: -c compile, -t test, -m memcheck
   const char *linkWithGoldKey;
 
   if (sheepyParams.test) {
     linkWithGoldKey       = "testLinkWithGold";
   }
   else if (sheepyParams.memcheck) {
     linkWithGoldKey       = "memcheckLinkWithGold";
   }
   else if (sheepyParams.asan) {
     linkWithGoldKey       = "asanLinkWithGold";
   }
   else {
     linkWithGoldKey       = "linkWithGold";
   }
 
   char *ld;
   if (!getG(cfgD, rtBool, "tcc")) {
     char *linker;
     if (getG(cfgD, rtBool, linkWithGoldKey)) {
       linker = " -fuse-ld=gold -Xlinker --threads";
     }
     else {
       linker = "";
     }
 
     if (!sheepyParams.compileLib) {
       if (!sheepyParams.dontCompileExe) {
         asprintf(&ld, GCC " %s -o %s %s %s %s %s/%s "PTHREAD" %s%s %s", m32bit, buildExePath, mainOPath, incObjFiles, aLibFiles, libsheepyDir, libsheepy, lflags, linker, run);
       }
       else {
         ld = emptySF();
     }
       }
     else {
       // link library in current folder
       asprintf(&ld, "gcc %s -shared -o %s.so %s %s %s %s/%s "PTHREAD" %s%s", m32bit, rootMain, mainOPath, incObjFiles, aLibFiles, libsheepyDir, libsheepy, lflags, linker);
   }
     }
   else {
     // TODO update command
     ld = malloc(strlen(buildExePath) + strlen(mainOPath) + strlen(incObjFiles) + strlen(aLibFiles) + strlen(libsheepyDir) + strlen(libsheepy) + strlen(lflags) + strlen(run) + 1 + 23);
     sprintf(ld, "tcc -o %s %s %s %s %s/%s -pthread %s %s", buildExePath, mainOPath, incObjFiles, aLibFiles, libsheepyDir, libsheepy, lflags, run);
   }
 
   free(lflags);
 
   if (getG(cfgD, rtBool, "print_compile_commands")) {
     printf("%s\n", ld);
   }
 
   // hide eventual error from the compiled program
   setMaxLogLevel(LOG_DISABLE);
   programResult |= commandNFree(ld);
   setMaxLogLevel(LOG_INFO);
 
   // build static lib
   if (sheepyParams.compileLib) {
     // link library in current folder
     // options: c create, q append objects, T thin archive for recursive library dependencies in packages
     ld = malloc(strlen(ar32bit) + strlen(rootMain) + strlen(mainOPath) + strlen(incObjFiles) + strlen(aLibFiles) + 1 + 26);
     sprintf(ld, "ar %s -cqT %s.a %s %s %s > /dev/null", ar32bit, rootMain, mainOPath, incObjFiles, aLibFiles);
     if (getG(cfgD, rtBool, "print_compile_commands")) {
       printf("%s\n", ld);
     }
     programResult |= commandNFree(ld);
   }
 
   // mainOPath is not used after link step
   free(mainOPath);
   free(incObjFiles);
   free(aLibFiles);
 
   //puts("LIST SOURCES");
   //TODO use logE in pError0 and setModificationTime and disable logging with setMaxLogLevel
   if (lenG(toCompile) > 0) {
     // copy c file modified dates to newly created object files
     iter(toCompile, info) {
       cast(smallContainert *, infoC, info)
       srcFilet *srcF = getG(infoC, rtVoid, 0);
       //logVarG(srcF->fpath);
 
       if (isH(srcF->bpath) || isCH(srcF->bpath)) {
         char *dep = catS(srcF->bpath, ".dep");
         if (!fileExistsG(dep)) {
           logW("'%s' not found.", dep);
         }
         else {
           pError0(setModificationTime(dep, srcF->st.st_mtime)) {
           // bug in cg_c
       }
         }
           }
       else {
         if (!fileExistsG(srcF->bpath)) {
           logW("'%s' not found.", srcF->bpath);
         }
         else {
           //logP("SET TIME FOR %s", srcF->bpath);
           pError0(setModificationTime(srcF->bpath, srcF->st.st_mtime)) {
           // bug in cg_c
       }
         }
           }
     }
   }
 
   // TODO free toCompile and containers
 
 
   finish:
   // copy exe
   if (isEmptyS(run) && !sheepyParams.dontCompileExe && !sheepyParams.clean) {
     // copy it to main source folder
     pError0(copy(buildExePath, exePath));
     if (programResult) {
       dum = BLD UDL BGYLW RED"Failed to build Executable:"RST" %s\n";
     }
     else {
       dum = BLD GRN"Built Executable:"RST" %s\n";
     }
     printf(dum, exePath);
   }
   if (getG(cfgD, rtBool, "print_compile_commands") && !isEmptyS(run) && !sheepyParams.clean) {
     if (programResult) {
       dum = BLD UDL BGYLW RED"Failed to build Executable:"RST" %s\n";
     }
     else {
       dum = BLD GRN"Built Executable:"RST" %s\n";
     }
     printf(dum, buildExePath);
   }
 
   // free
   free(mainCPath);
   free(buildExePath);
   free(buildPath);
   free(mainH);
   free(mainFilename);
   free(exePath);
   free(mainSrc);
   terminateG(inc);
   free(actualDir);
   free(dir);
   listFreeS(rootMain_l);
   terminateG(paramL);
   free(params);
   free(run);
   free(cfgD);
   terminateG(cfgJ);
   free(homedir);
   finalizeLibsheepy();
 
   exit(programResult);
 }
 
 char *getInclude(smallStringt *L) {
   char *r = NULL;
 
   if (strncmp(ssGet(L), "#include ", strlen("#include ")) == 0 && !hasG(L,"libsheepy.h") && !hasG(L, "libsheepyObject.h")) {
     char **genericLib = extractS(ssGet(L), "<", ">");
     if (listLengthS(genericLib) == 0) {
       char **incFileL = splitSG(L, "\"");
       if (listLengthS(incFileL) > 2) {
         r = strdup(incFileL[1]);
       }
       listFreeS(incFileL);
     }
     listFreeS(genericLib);
   }
   return(r);
 }
 
 void addFileToCompile(char *actualDir, const char *cFileName, char *oPath, smallDictt *toCompile) {
 
   // add c file to compile list
   if (!hasG(toCompile, cFileName)) {
     //logP("ADD TO TOCOMPILE");
     //logVarG(actualDir);
     //logVarG(cFileName);
     //logVarG(oPath);
     srcFilet *srcI;
     // allocate srcFile info, set later
     srcI                      = malloc(sizeof(srcFilet));
     char *tmp                 = catS(actualDir, "/", cFileName);
     pError(stat(tmp, &(srcI->st)))
     srcI->fpath               = strdup(tmp);
     srcI->bpath               = strdup(oPath);
     free(tmp);
     smallContainert *srcFInfo = allocSmallContainer(srcI);
     setNFreeG(toCompile, cFileName, srcFInfo);
 }
   }
 
 void storeHeaderDep(smallArrayt *copyHeaderDepToBuildPath, char *bPath, struct stat hst) {
     srcFilet *srcI = NULL;
 
     // allocate srcFile info, set later
     srcI                      = malloc(sizeof(srcFilet));
     srcI->bpath               = bPath;
     srcI->st                  = hst;
     smallContainert *srcFInfo = allocSmallContainer(srcI);
     pushNFreeG(copyHeaderDepToBuildPath, srcFInfo);
 }
 
 void copyHeaderToBuildPath(char *bPath, struct stat hst) {
 
   // 'copy' header to build path, to check modification time next time
   // the h.dep hold the modification time of the original header
   char *tmp = catS("touch ", bPath, ".dep");
   char *D = shDirname(bPath);
   pError0(mkdirParents(D));
   free(D);
   programResult |= commandNFree(tmp);
 
   // copy modification time
   char *b = catS(bPath, ".dep");
   pError0(setModificationTime(b, hst.st_mtime)) {
   free(b);
   // bug in cg_c - IF in MODIFICATION
 }
   }
 
 
 void copyHeaderDates(char *actualDir, smallArrayt *hDeps, char *buildPath) {
 
   forEachSmallArray(hDeps, dep) {
     char *depName = toStringG(dep);
 
     // get modification time for header depName
     struct stat hst;
     char *tmp = catS(actualDir, "/", depName);
     pError(stat(tmp, &hst))
     free(tmp);
 
     char *bPath = catS(buildPath, "/", depName, ".dep");
     //puts(depName);
     //puts(bPath);
 
     // 'copy' header to build path, to check modification time next time
     tmp = catS("touch ", bPath);
     char *D = shDirname(bPath);
     pError0(mkdirParents(D));
     free(D);
     programResult |= commandNFree(tmp);
 
     // copy modification time
     pError0(setModificationTime(bPath, hst.st_mtime)) {
 
     finishG(dep);
 }
   }
     }
 
 bool symlinkFile(char *path, char *buildPath) {
   bool r = false;;
 
   if (!isCH(path) && !isCP(path) && fileExists(path)) {
     if (!fileExists(buildPath)) {
       // symlink (h) file
       char *D = shDirname(buildPath);
       pError0(mkdirParents(D));
       free(D);
       char *cmd = catS("ln -s ", path, " ", buildPath);
       programResult |= commandNFree(cmd);
     }
     r = true;
   }
   return(r);
 }
 
 bool isC(const char *path) {
 
   if (getS(path, -1) == 'c') {
     return(true);
   }
   else {
     return(false);
 }
   }
 
 bool isH(const char *path) {
 
   if (getS(path, -2) == '.' && getS(path, -1) == 'h') {
     return(true);
   }
   else {
     return(false);
 }
   }
 
 bool isCP(const char *path) {
 
   if (getS(path, -2) == 'c' && getS(path, -1) == 'p') {
     return(true);
   }
   else {
     return(false);
 }
   }
 
 bool isCH(const char *path) {
 
   if (getS(path, -2) == 'c' && getS(path, -1) == 'h') {
     return(true);
   }
   else {
     return(false);
 }
   }
 
 void generateC(char *src, char *bpath) {
 
   createAllocateSmallArray(sheepySrc);
   readFileG(sheepySrc, src);
 
   createAllocateSmallArray(cCode);
 
   generateCBuffers(sheepySrc, cCode);
 
   pError0(writeFileG(cCode, bpath));
 
   terminateG(sheepySrc);
   terminateG(cCode);
 }
 
 
 void generateCBuffers(smallArrayt *sheepySrc, smallArrayt *cCode) {
 
   generatedC  = cCode;
   initiateAllocateSmallArray(&sheepyC);
   initiateAllocateSmallArray(&stateStack);
   initiateAllocateSmallArray(&textStack);
 
   smallStringt *srcO               = joinG(sheepySrc, "\n");
   char *src                        = ssGet(srcO);
   size_t len                       = strlen(src) +2;
   *(src-1)                         = 0;
   quex_Token*     token_p          = NULL;
   size_t          number_of_tokens = 0;
   quex_EasyLexer  qlex;
   bool            start            = true;
 
   /* if len <= QUEX_SETTING_BUFFER_MIN_FALLBACK_N+2 */
   /*   char *tmp = realloc(src-1, QUEX_SETTING_BUFFER_MIN_FALLBACK_N+3) */
   /*   len = QUEX_SETTING_BUFFER_MIN_FALLBACK_N+3 */
   /*   src = tmp+1 */
 
   quex_EasyLexer_from_memory(&qlex, (QUEX_TYPE_LEXATOM*)(src-1), len, (QUEX_TYPE_LEXATOM*)(src+len-2));
 
   //#ifdef PRINT_TOKEN
   const size_t    BufferSize = 1024;
   char            buffer[1024];
   //#endif
   while ((start == true) || (token_p->_id != QUEX_TKN_TERMINATION)) {
     start = false;
     quex_EasyLexer_receive(&qlex, &token_p);
     // process token with the state machine
     char *text = (char*)QUEX_NAME_TOKEN(pretty_char_text)(token_p, buffer, BufferSize);
     range(i, TRANSITIONS) {
       if (stateTkn(i) == -1) {
         // no more next state, stop
         STATEDEFAULTF[stateM](stateM, text);
         break;
       }
       if (token_p->_id == stateTkn(i)) {
         callNxt(i);
         break;
       }
     }
 
     //printf("nxt stateM %s, %s \n", STATESSTR[stateM], QUEX_NAME_TOKEN(get_string)(token_p, buffer, BufferSize));
     ++number_of_tokens;
   }
 
   quex_EasyLexer_destruct(&qlex);
 
   terminateG(srcO);
 
   //printf("| [END] number of token = %i\n", (int)number_of_tokens);
 
   // TODO free stuff
 }
 
 void splash(void) {
 
     putsG(
           "           __  _\n"
           "       .-.'  `; `-._  __  _\n"
           "      (_,         .-:'  `; `-._\n"
           "    ,'o\"(        (_,           )\n"
           "   (__,-'      ,'o\"(  sheepy    )>\n"
           "      (       (__,-'            )\n"
           "       `-'._.--._(             )\n"
           "          |||  |||`-'._.--._.-'\n"
           "                     |||  |||\n"
           "Project:                 " BLD WHT "https://spartatek.se/r/sheepy/file/README.md.html" RST "\n"
           "Libsheepy documentation: " BLD WHT "https://spartatek.se/libsheepy/" RST "\n"
           );
 }
 
 // vim: set expandtab ts=2 sw=2: