The Ecere SDK - sdk/blob - ide/src/project/Project.ec

   1 #ifdef ECERE_STATIC
   2 public import static "ecere"
   3 #else
   4 public import "ecere"
   5 #endif
   6
   7 #ifndef MAKEFILE_GENERATOR
   8 import "ide"
   9 // We should have the .sln/.vcproj generation even on other platforms
  10 // e.g. detect from an environment variable pointing to a Windows drive
  11 #ifdef __WIN32__
  12 import "vsSupport"
  13 #endif
  14 #endif
  15
  16 import "ProjectConfig"
  17 import "ProjectNode"
  18 import "IDESettings"
  19
  20 default:
  21
  22 static void DummyFunction()
  23 {
  24 int a;
  25 a.OnFree();
  26 }
  27
  28 private:
  29
  30 extern int __ecereVMethodID_class_OnCompare;
  31 extern int __ecereVMethodID_class_OnFree;
  32
  33 IDESettings ideSettings;
  34
  35 IDESettingsContainer settingsContainer
  36 {
  37    driver = "JSON";
  38    dataOwner = &ideSettings;
  39    dataClass = class(IDESettings);
  40
  41    void OnLoad(GlobalSettingsData data)
  42    {
  43       IDESettings settings = (IDESettings)data;
  44 #ifndef MAKEFILE_GENERATOR
  45       globalSettingsDialog.ideSettings = settings;
  46       ide.UpdateRecentMenus();
  47 #endif
  48    }
  49 };
  50
  51 #ifdef MAKEFILE_GENERATOR
  52 CompilerConfig defaultCompiler;
  53 #endif
  54
  55 // LEGACY BINARY EPJ LOADING
  56
  57 SetBool ParseTrueFalseValue(char * string)
  58 {
  59    if(!strcmpi(string, "True")) return true;
  60    return false;
  61 }
  62
  63 void ParseArrayValue(Array<String> array, char * equal)
  64 {
  65    char * start, * comma;
  66    char * string;
  67    string = CopyString(equal);
  68    start = string;
  69    while(start)
  70    {
  71       comma = strstr(start, ",");
  72       if(comma)
  73          comma[0] = '\0';
  74       array.Add(CopyString(start));
  75       if(comma)
  76          comma++;
  77       if(comma)
  78          comma++;
  79       start = comma;
  80    }
  81    delete string;
  82 }
  83
  84 void ProjectNode::LegacyBinaryLoadNode(File f)
  85 {
  86    int len, count, c;
  87    int fileNameLen;
  88
  89    f.Read(&len, sizeof(len), 1);
  90    name = new char[len+1];
  91    fileNameLen = len;
  92    f.Read(name, sizeof(char), len+1);
  93    f.Read(&len, sizeof(len), 1);
  94    fileNameLen += len;
  95    path = new char[len+1];
  96    f.Read(path, sizeof(char), len+1);
  97
  98    /*
  99    fileName = new char[fileNameLen+2];
 100    strcpy(fileName, path);
 101    if(fileName[0]) strcat(fileName, "/");
 102    strcat(fileName, name);
 103    */
 104
 105    f.Read(&type, sizeof(type), 1);
 106    f.Read(&count, sizeof(count), 1);
 107
 108    if(type == file)
 109    {
 110       nodeType = file;
 111       icon = NodeIcons::SelectFileIcon(name);
 112    }
 113    else
 114    {
 115       nodeType = folder;
 116       icon = NodeIcons::SelectNodeIcon(type);
 117    }
 118
 119    if(count && !files) files = { };
 120    for(c = 0; c < count; c++)
 121    {
 122       ProjectNode child { };
 123       files.Add(child);
 124       child.parent = this;
 125       child.indent = indent + 1;
 126       LegacyBinaryLoadNode(child, f);
 127    }
 128 }
 129
 130 /*void LegacyBinarySaveNode(File f)
 131 {
 132    int len;
 133    ProjectNode child;
 134    len = strlen(name);
 135    f.Write(&len, sizeof(len), 1);
 136    f.Write(name, sizeof(char), len+1);
 137
 138    if(type == project)
 139    {
 140       // Projects Absolute Path Are Not Saved
 141       len = 0;
 142       f.Write(&len, sizeof(len), 1);
 143       f.Write(&len, sizeof(char), 1);
 144    }
 145    else
 146    {
 147       len = strlen(path);
 148       f.Write(&len, sizeof(len), 1);
 149       f.Write(path, sizeof(char), len+1);
 150    }
 151    f.Write(&type, sizeof(type), 1);
 152    f.Write(&children.count, sizeof(children.count), 1);
 153    for(child = children.first; child; child.next)
 154       child.SaveNode(f);
 155 }*/
 156
 157 void ProjectNode::LegacyAsciiSaveNode(File f, char * indentation, char * insidePath)
 158 {
 159    int len;
 160    char printPath[MAX_LOCATION];
 161
 162    if(type == project && (files.count /*|| preprocessorDefs.first*/))
 163    {
 164       f.Printf("\n   Files\n");
 165    }
 166    else if(type == file)
 167    {
 168       if(!strcmp(path, insidePath))
 169          f.Printf("%s - %s\n", indentation, name);
 170       else
 171       {
 172          strcpy(printPath, path);
 173          len = strlen(printPath);
 174          if(len)
 175             if(printPath[len-1] != '/')
 176                strcat(printPath, "/");
 177          strcat(printPath, name);
 178          f.Printf("%s = %s\n", indentation, printPath);
 179       }
 180       if(files.count)
 181          f.Printf("\nError\n\n");
 182    }
 183    else if(type == folder)
 184    {
 185       f.Printf("%s + %s\n", indentation, name);
 186    }
 187    else if(type == resources && files.count)
 188    {
 189       PathCatSlash(insidePath, path);
 190       f.Printf("\n%sResources\n", indentation);
 191       if(path && path[0])
 192          f.Printf("%s   Path = %s\n", indentation, path);
 193    }
 194
 195    /*if(buildExclusions.first && type != project)
 196    {
 197       for(item = buildExclusions.first; item; item = item.next)
 198       {
 199          if(item == buildExclusions.first)
 200             f.Printf("%s      Build Exclusions = %s", indentation, item.name);
 201          else
 202             f.Printf(", %s", item.name);
 203       }
 204       f.Printf("\n");
 205    }
 206
 207    if(preprocessorDefs.first && (type == project || ((type == file || type == folder) && !isInResources)))
 208    {
 209       for(item = preprocessorDefs.first; item; item = item.next)
 210       {
 211          if(item == preprocessorDefs.first)
 212             f.Printf("%s%s   Preprocessor Definitions = %s", indentation, type == project ? "" : "   ", item.name);
 213          else
 214             f.Printf(", %s", item.name);
 215       }
 216       f.Printf("\n");
 217    }
 218    */
 219
 220    if(type == project && (files.count /*|| preprocessorDefs.first*/))
 221    {
 222       f.Printf("\n");
 223       for(child : files)
 224          LegacyAsciiSaveNode(child, f, indentation, insidePath);
 225    }
 226    else if(type == folder)
 227    {
 228       strcat(indentation, "   ");
 229       // WHAT WAS THIS: strcpy(printPath, path);
 230       // TOCHECK: why is Unix/PathCat not used here
 231       len = strlen(insidePath);
 232       if(len)
 233          if(insidePath[len-1] != '/')
 234             strcat(insidePath, "/");
 235       strcat(insidePath, name);
 236
 237       for(child : files)
 238          LegacyAsciiSaveNode(child, f, indentation, insidePath);
 239       f.Printf("%s -\n", indentation);
 240       indentation[strlen(indentation) - 3] = '\0';
 241       StripLastDirectory(insidePath, insidePath);
 242    }
 243    else if(type == resources && files.count)
 244    {
 245       f.Printf("\n");
 246       for(child : files)
 247          LegacyAsciiSaveNode(child, f, indentation, insidePath);
 248       StripLastDirectory(insidePath, insidePath);
 249    }
 250 }
 251
 252 /*
 253 void ProjectConfig::LegacyProjectConfigSave(File f)
 254 {
 255    char * indentation = "      ";
 256    //if(isCommonConfig)
 257       //f.Printf("\n * Common\n");
 258    //else
 259       f.Printf("\n + %s\n", name);
 260    f.Printf("\n   Compiler\n\n");
 261    if(objDir.expression[0])
 262       f.Printf("%sIntermediate Directory = %s\n", indentation, objDir.expression);
 263    f.Printf("%sDebug = %s\n", indentation, (options.debug == true) ? "True" : "False");
 264    switch(options.optimization)
 265    {
 266       // case none:   f.Printf("%sOptimize = %s\n", indentation, "None"); break;
 267       case speed: f.Printf("%sOptimize = %s\n", indentation, "Speed"); break;
 268       case size:  f.Printf("%sOptimize = %s\n", indentation, "Size");  break;
 269    }
 270    f.Printf("%sAllWarnings = %s\n", indentation, (options.warnings == all) ? "True" : "False");
 271    if(options.profile)
 272       f.Printf("%sProfile = %s\n", indentation, (options.profile == true) ? "True" : "False");
 273    if(options.memoryGuard == true)
 274       f.Printf("%sMemoryGuard = %s\n", indentation, (options.memoryGuard == true) ? "True" : "False");
 275    if(options.strictNameSpaces == true)
 276       f.Printf("%sStrict Name Spaces = %s\n", indentation, (options.strictNameSpaces == true) ? "True" : "False");
 277    if(options.defaultNameSpace && strlen(options.defaultNameSpace))
 278       f.Printf("%sDefault Name Space = %s\n", indentation, options.defaultNameSpace);
 279     TOFIX: Compiler Bug {
 280       if(options.preprocessorDefinitions.count)
 281       {
 282          bool isFirst = true;
 283          for(item : options.preprocessorDefinitions)
 284          {
 285             if(isFirst)
 286             {
 287                f.Printf("\n%sPreprocessor Definitions = %s", indentation, item);
 288                isFirst = false;
 289             }
 290             else
 291                f.Printf(", %s", item);
 292          }
 293          f.Printf("\n");
 294       }
 295    }
 296    if(options.includeDirs.count)
 297    {
 298       f.Printf("\n%sInclude Directories\n", indentation);
 299       for(item : options.includeDirs)
 300          f.Printf("%s - %s\n", indentation, name);
 301       f.Printf("\n");
 302    }
 303
 304    f.Printf("\n%sLinker\n\n", indentation);
 305    f.Printf("%sTarget Name = %s\n", indentation, options.targetFileName);
 306    switch(options.targetType)
 307    {
 308       case executable:     f.Printf("%sTarget Type = %s\n", indentation, "Executable"); break;
 309       case sharedLibrary:  f.Printf("%sTarget Type = %s\n", indentation, "Shared");     break;
 310       case staticLibrary:  f.Printf("%sTarget Type = %s\n", indentation, "Static");     break;
 311    }
 312    if(targetDir.expression[0])
 313       f.Printf("%sTarget Directory = %s\n", indentation, targetDir.expression);
 314    if(options.console)
 315       f.Printf("%sConsole = %s\n", indentation, options.console ? "True" : "False");
 316    if(options.compress)
 317       f.Printf("%sCompress = %s\n", indentation, options.compress ? "True" : "False");
 318    if(options.libraries.count)
 319    {
 320       bool isFirst = true;
 321       for(item : options.libraries)
 322       {
 323          if(isFirst)
 324          {
 325             f.Printf("\n%sLibraries = %s", indentation, name);
 326             isFirst = false;
 327          }
 328          else
 329             f.Printf(", %s", item);
 330       }
 331       f.Printf("\n");
 332    }
 333    if(options.libraryDirs.count)
 334    {
 335       f.Printf("\n%sLibrary Directories\n\n", indentation);
 336       for(item : options.libraryDirs)
 337          f.Printf("       - %s\n", indentation, item);
 338    }
 339 }
 340
 341 void LegacyAsciiSaveProject(File f, Project project)
 342 {
 343    char indentation[128*3];
 344    char path[MAX_LOCATION];
 345
 346    f.Printf("\nECERE Project File : Format Version 0.1b\n");
 347    f.Printf("\nDescription\n%s\n.\n", project.description);
 348    f.Printf("\nLicense\n%s\n.\n", project.license);
 349    f.Printf("\nModule Name = %s\n", project.moduleName);
 350    f.Printf("\n   Configurations\n");
 351    //////////////////////////////////////commonConfig.Save(f, true);
 352    for(cfg : project.configurations)
 353       LegacyProjectConfigSave(cfg, f);
 354
 355    strcpy(indentation, "   ");
 356    path[0] = '\0';
 357    LegacyAsciiSaveNode(project.topNode, f, indentation, path);
 358    // f.Printf("\n");
 359    delete f;
 360 }
 361 */
 362
 363 // *** NEW JSON PROJECT FORMAT ***
 364 public enum ProjectNodeType { file, folder };
 365
 366 // *******************************
 367
 368 define PEEK_RESOLUTION = (18.2 * 10);
 369
 370 // On Windows & UNIX
 371 #define SEPS    "/"
 372 #define SEP     '/'
 373
 374 static byte epjSignature[] = { 'E', 'P', 'J', 0x04, 0x01, 0x12, 0x03, 0x12 };
 375
 376 enum GenMakefilePrintTypes { objects, cObjects, symbols, imports, sources, resources, eCsources };
 377
 378 define WorkspaceExtension = "ews";
 379 define ProjectExtension = "epj";
 380
 381 define stringInFileIncludedFrom = "In file included from ";
 382
 383 void ReplaceSpaces(char * output, char * source)
 384 {
 385    int c, dc;
 386    char ch, pch = 0;
 387
 388    for(c = 0, dc = 0; (ch = source[c]); c++, dc++)
 389    {
 390       if(ch == ' ') output[dc++] = '\\';
 391       if(pch != '$')
 392       {
 393          if(ch == '(' || ch == ')') output[dc++] = '\\';
 394          pch = ch;
 395       }
 396       else if(ch == ')')
 397          pch = 0;
 398       output[dc] = ch;
 399    }
 400    output[dc] = '\0';
 401 }
 402
 403 void ReplaceUnwantedMakeChars(char * output, char * source)
 404 {
 405    int c, dc;
 406    char ch, pch = 0;
 407
 408    for(c = 0, dc = 0; (ch = source[c]); c++, dc++)
 409    {
 410       if(pch != '$')
 411       {
 412          if(ch == '(' || ch == ')') output[dc++] = '\\';
 413          pch = ch;
 414       }
 415       else if(ch == ')')
 416          pch = 0;
 417       if(ch == ' ')
 418          output[dc] = 127;
 419       else
 420          output[dc] = ch;
 421    }
 422    output[dc] = '\0';
 423 }
 424
 425 static void OutputNoSpace(File f, char * source)
 426 {
 427    char * output = new char[strlen(source)+1024];
 428    ReplaceSpaces(output, source);
 429    f.Puts(output);
 430    delete output;
 431 }
 432
 433 enum ListOutputMethod { inPlace, newLine, lineEach };
 434
 435 int OutputFileList(File f, char * name, Array<String> list, Map<String, int> varStringLenDiffs, char * prefix)
 436 {
 437    int numOfBreaks = 0;
 438    const int breakListLength = 1536;
 439    const int breakLineLength = 78; // TODO: turn this into an option.
 440
 441    int c, len, itemCount = 0;
 442    Array<int> breaks { };
 443    if(list.count)
 444    {
 445       int charCount = 0;
 446       MapNode<String, int> mn;
 447       for(c=0; c<list.count; c++)
 448       {
 449          len = strlen(list[c]) + 3;
 450          if(strstr(list[c], "$(") && varStringLenDiffs && varStringLenDiffs.count)
 451          {
 452             for(mn = varStringLenDiffs.root.minimum; mn; mn = mn.next)
 453             {
 454                if(strstr(list[c], mn.key))
 455                   len += mn.value;
 456             }
 457          }
 458          if(charCount + len > breakListLength)
 459          {
 460             breaks.Add(itemCount);
 461             itemCount = 0;
 462             charCount = len;
 463          }
 464          itemCount++;
 465          charCount += len;
 466       }
 467       if(itemCount)
 468          breaks.Add(itemCount);
 469       numOfBreaks = breaks.count;
 470    }
 471
 472    if(numOfBreaks > 1)
 473    {
 474       f.Printf("%s =%s%s", name, prefix ? " " : "", prefix ? prefix : "");
 475       for(c=0; c<numOfBreaks; c++)
 476          f.Printf(" $(%s%d)", name, c+1);
 477       f.Printf("\n");
 478    }
 479    else
 480       f.Printf("%s =%s%s", name, prefix ? " " : "", prefix ? prefix : "");
 481
 482    if(numOfBreaks)
 483    {
 484       int n, offset = 0;
 485
 486       for(c=0; c<numOfBreaks; c++)
 487       {
 488          if(numOfBreaks > 1)
 489             f.Printf("%s%d =", name, c+1);
 490
 491          len = 3;
 492          itemCount = breaks[c];
 493          for(n=offset; n<offset+itemCount; n++)
 494          {
 495             if(false) // TODO: turn this into an option.
 496             {
 497                int itemLen = strlen(list[n]);
 498                if(len > 3 && len + itemLen > breakLineLength)
 499                {
 500                   f.Printf(" \\\n\t%s", list[n]);
 501                   len = 3;
 502                }
 503                else
 504                {
 505                   len += itemLen;
 506                   f.Printf(" %s", list[n]);
 507                }
 508             }
 509             else
 510                f.Printf(" \\\n\t%s", list[n]);
 511          }
 512          offset += itemCount;
 513          f.Printf("\n");
 514       }
 515       list.Free();
 516       list.count = 0;
 517    }
 518    else
 519       f.Printf("\n");
 520    f.Printf("\n");
 521    delete breaks;
 522    return numOfBreaks;
 523 }
 524
 525 void OutputCleanActions(File f, char * name, int parts)
 526 {
 527    if(parts > 1)
 528    {
 529       int c;
 530       for(c=0; c<parts; c++)
 531          f.Printf("\t$(call rmq,$(%s%d))\n", name, c+1);
 532    }
 533    else
 534       f.Printf("\t$(call rmq,$(%s))\n", name);
 535 }
 536
 537 void OutputListOption(File f, char * option, Array<String> list, ListOutputMethod method, bool noSpace)
 538 {
 539    if(list.count)
 540    {
 541       if(method == newLine)
 542          f.Printf(" \\\n\t");
 543       for(item : list)
 544       {
 545          if(method == lineEach)
 546             f.Printf(" \\\n\t");
 547          f.Printf(" -%s", option);
 548          if(noSpace)
 549             OutputNoSpace(f, item);
 550          else
 551             f.Printf("%s", item);
 552       }
 553    }
 554 }
 555
 556 static void OutputLibraries(File f, Array<String> libraries)
 557 {
 558    for(item : libraries)
 559    {
 560       char ext[MAX_EXTENSION];
 561       char temp[MAX_LOCATION];
 562       char * s = item;
 563       bool usedFunction = false;
 564       GetExtension(item, ext);
 565       if(!strcmp(ext, "o") || !strcmp(ext, "a"))
 566          f.Printf(" ");
 567       else
 568       {
 569          if(!strcmp(ext, "so") || !strcmp(ext, "dylib"))
 570          {
 571             if(!strncmp(item, "lib", 3))
 572                strcpy(temp, item + 3);
 573             else
 574                strcpy(temp, item);
 575             StripExtension(temp);
 576             s = temp;
 577          }
 578          f.Printf(" \\\n\t$(call _L,");
 579          usedFunction = true;
 580       }
 581       OutputNoSpace(f, s);
 582       if(usedFunction)
 583          f.Printf(")");
 584    }
 585 }
 586
 587 void CamelCase(char * string)
 588 {
 589    int c, len = strlen(string);
 590    for(c=0; c<len && string[c] >= 'A' && string[c] <= 'Z'; c++)
 591       string[c] = (char)tolower(string[c]);
 592 }
 593
 594 CompilerConfig GetCompilerConfig()
 595 {
 596 #ifndef MAKEFILE_GENERATOR
 597    CompilerConfig compiler = null;
 598    if(ide && ide.workspace)
 599       compiler = ideSettings.GetCompilerConfig(ide.workspace.compiler);
 600    return compiler;
 601 #else
 602    incref defaultCompiler;
 603    return defaultCompiler;
 604 #endif
 605 }
 606
 607 define localTargetType = config && config.options && config.options.targetType ?
 608             config.options.targetType : options && options.targetType ?
 609             options.targetType : TargetTypes::executable;
 610 define localWarnings = config && config.options && config.options.warnings ?
 611             config.options.warnings : options && options.warnings ?
 612             options.warnings : WarningsOption::unset;
 613 define localDebug = config && config.options && config.options.debug ?
 614             config.options.debug : options && options.debug ?
 615             options.debug : SetBool::unset;
 616 define localMemoryGuard = config && config.options && config.options.memoryGuard ?
 617             config.options.memoryGuard : options && options.memoryGuard ?
 618             options.memoryGuard : SetBool::unset;
 619 define localNoLineNumbers = config && config.options && config.options.noLineNumbers ?
 620             config.options.noLineNumbers : options && options.noLineNumbers ?
 621             options.noLineNumbers : SetBool::unset;
 622 define localProfile = config && config.options && config.options.profile ?
 623             config.options.profile : options && options.profile ?
 624             options.profile : SetBool::unset;
 625 define localOptimization = config && config.options && config.options.optimization ?
 626             config.options.optimization : options && options.optimization ?
 627             options.optimization : OptimizationStrategy::none;
 628 define localDefaultNameSpace = config && config.options && config.options.defaultNameSpace ?
 629             config.options.defaultNameSpace : options && options.defaultNameSpace ?
 630             options.defaultNameSpace : null;
 631 define localStrictNameSpaces = config && config.options && config.options.strictNameSpaces ?
 632             config.options.strictNameSpaces : options && options.strictNameSpaces ?
 633             options.strictNameSpaces : SetBool::unset;
 634 // TODO: I would rather have null here, check if it'll be ok, have the property return "" if required
 635 define localTargetFileName = config && config.options && config.options.targetFileName ?
 636             config.options.targetFileName : options && options.targetFileName ?
 637             options.targetFileName : "";
 638 define localTargetDirectory = config && config.options && config.options.targetDirectory && config.options.targetDirectory[0] ?
 639             config.options.targetDirectory : options && options.targetDirectory && options.targetDirectory[0] ?
 640             options.targetDirectory : null;
 641 define settingsTargetDirectory = ideSettings && ideSettings.projectDefaultIntermediateObjDir &&
 642             ideSettings.projectDefaultIntermediateObjDir[0] ?
 643             ideSettings.projectDefaultIntermediateObjDir : defaultObjDirExpression;
 644 define localObjectsDirectory = config && config.options && config.options.objectsDirectory && config.options.objectsDirectory[0] ?
 645             config.options.objectsDirectory : options && options.objectsDirectory && options.objectsDirectory[0] ?
 646             options.objectsDirectory : null;
 647 define settingsObjectsDirectory = ideSettings && ideSettings.projectDefaultIntermediateObjDir &&
 648             ideSettings.projectDefaultIntermediateObjDir[0] ?
 649             ideSettings.projectDefaultIntermediateObjDir : defaultObjDirExpression;
 650 define localConsole = config && config.options && config.options.console ?
 651             config.options.console : options && options.console ?
 652             options.console : SetBool::unset;
 653 define localCompress = config && config.options && config.options.compress ?
 654             config.options.compress : options && options.compress ?
 655             options.compress : SetBool::unset;
 656
 657 define platformTargetType =
 658          configPOs && configPOs.options && configPOs.options.targetType && configPOs.options.targetType != localTargetType ?
 659                configPOs.options.targetType :
 660          projectPOs && projectPOs.options && projectPOs.options.targetType && projectPOs.options.targetType != localTargetType ?
 661                projectPOs.options.targetType : TargetTypes::unset;
 662
 663
 664 // we should have some kind of direct mapping between a platform and it's makefile variable
 665 char * PlatformToMakefileVariable(Platform platform)
 666 {
 667    return platform == win32 ? "WINDOWS" :
 668           platform == tux   ? "LINUX"   :
 669           platform == apple ? "OSX"/*"APPLE"*/ :
 670                               platform;
 671 }
 672
 673 char * TargetTypeToMakefileVariable(TargetTypes targetType)
 674 {
 675    return targetType == executable    ? "executable" :
 676           targetType == sharedLibrary ? "sharedlib"  :
 677           targetType == staticLibrary ? "staticlib"  :
 678                                         "unknown";
 679 }
 680
 681 // Move this to ProjectConfig? null vs Common to consider...
 682 char * GetConfigName(ProjectConfig config)
 683 {
 684    return config ? config.name : "Common";
 685 }
 686
 687 class Project : struct
 688 {
 689    class_no_expansion;  // To use Find on the Container<Project> in Workspace::projects
 690                         // We might want to tweak this default behavior of regular classes ?
 691                         // Expansion/the current default kind of Find matching we want for things like BitmapResource, FontResource (Also regular classes)
 692 public:
 693    float version;
 694    String moduleName;
 695
 696    property ProjectOptions options { get { return options; } set { options = value; } isset { return options && !options.isEmpty; } }
 697    property Array<PlatformOptions> platforms
 698    {
 699       get { return platforms; }
 700       set
 701       {
 702          if(platforms) { platforms.Free(); delete platforms; }
 703          if(value)
 704          {
 705             List<PlatformOptions> empty { };
 706             Iterator<PlatformOptions> it { value };
 707             platforms = value;
 708             for(p : platforms; !p.options || p.options.isEmpty) empty.Add(p);
 709             for(p : empty; it.Find(p)) platforms.Delete(it.pointer);
 710             delete empty;
 711          }
 712       }
 713       isset
 714       {
 715          if(platforms)
 716          {
 717             for(p : platforms)
 718             {
 719                if(p.options && !p.options.isEmpty)
 720                   return true;
 721             }
 722          }
 723          return false;
 724       }
 725    }
 726    List<ProjectConfig> configurations;
 727    LinkList<ProjectNode> files;
 728    String resourcesPath;
 729    LinkList<ProjectNode> resources;
 730
 731    property char * description
 732    {
 733       set { delete description; if(value && value[0]) description = CopyString(value); }
 734       get { return description ? description : ""; }
 735       isset { return description != null && description[0]; }
 736    }
 737
 738    property char * license
 739    {
 740       set { delete license; if(value && value[0]) license = CopyString(value); }
 741       get { return license ? license : ""; }
 742       isset { return license != null && license[0]; }
 743    }
 744
 745    property char * compilerConfigsDir
 746    {
 747       set { delete compilerConfigsDir; if(value && value[0]) compilerConfigsDir = CopyString(value); }
 748       get { return compilerConfigsDir ? compilerConfigsDir : ""; }
 749       isset { return compilerConfigsDir && compilerConfigsDir[0]; }
 750    }
 751
 752 private:
 753    // topNode.name holds the file name (.epj)
 754    ProjectOptions options;
 755    Array<PlatformOptions> platforms;
 756    ProjectNode topNode { type = project, icon = epjFile, files = LinkList<ProjectNode>{ }, project = this };
 757    ProjectNode resNode;
 758
 759    ProjectConfig config;
 760    String filePath;
 761    // This is the file name stripped of the epj extension
 762    // It should NOT be edited, saved or loaded anywhere
 763    String name;
 764
 765    String description;
 766    String license;
 767    String compilerConfigsDir;
 768 #ifndef MAKEFILE_GENERATOR
 769    FileMonitor fileMonitor
 770    {
 771       this, FileChange { modified = true };
 772       bool OnFileNotify(FileChange action, char * param)
 773       {
 774          fileMonitor.StopMonitoring();
 775          if(OnProjectModified(action, param))
 776             fileMonitor.StartMonitoring();
 777          return true;
 778       }
 779    };
 780
 781    bool StartMonitoring()
 782    {
 783       fileMonitor.fileName = filePath;
 784       fileMonitor.StartMonitoring();
 785       return true;
 786    }
 787
 788    bool StopMonitoring()
 789    {
 790       fileMonitor.StopMonitoring();
 791       return true;
 792    }
 793
 794    bool OnProjectModified(FileChange fileChange, char * param)
 795    {
 796       char temp[4096];
 797       sprintf(temp, $"The project %s was modified by another application.\n"
 798             "Would you like to reload it and lose your changes?", name);
 799       if(MessageBox { type = yesNo, master = ide,
 800             text = $"Project has been modified", contents = temp }.Modal() == yes)
 801       {
 802          Project project = LoadProject(filePath);
 803          if(project)
 804          {
 805             ProjectView projectView = ide.projectView;
 806             DataRow prev = topNode.row ? topNode.row.previous : null;
 807             FileMonitor fm = fileMonitor;
 808
 809             if(projectView) projectView.DeleteNode(topNode);
 810
 811             *this = *project;
 812             delete fileMonitor;
 813             fileMonitor = fm;
 814             topNode.project = this;
 815
 816             if(projectView)
 817             {
 818                projectView.AddNode(topNode, null);
 819                topNode.row.Move(prev);
 820             }
 821             eSystem_Delete(project);
 822          }
 823          return true;
 824       }
 825       return true;
 826    }
 827
 828 #endif
 829
 830    // This frees contents without freeing the instance
 831    // For use from destructor and for file monitor reloading
 832    // (To work around JSON loader (LoadProject) always returning a new instance)
 833    void Free()
 834    {
 835       if(platforms) { platforms.Free(); delete platforms; }
 836       if(configurations) { configurations.Free(); delete configurations; }
 837       if(files) { files.Free(); delete files; }
 838       if(resources) { resources.Free(); delete resources; }
 839       delete options;
 840       delete resourcesPath;
 841
 842       delete description;
 843       delete license;
 844       delete compilerConfigsDir;
 845       delete moduleName;
 846       delete filePath;
 847       delete topNode;
 848       delete name;
 849    }
 850
 851    ~Project()
 852    {
 853       /* // THIS IS NOW AUTOMATED WITH A project CHECK IN ProjectNode
 854       topNode.configurations = null;
 855       topNode.platforms = null;
 856       topNode.options = null;
 857       */
 858       Free();
 859    }
 860
 861    property ProjectConfig config
 862    {
 863       set
 864       {
 865          config = value;
 866          delete topNode.info;
 867          topNode.info = CopyString(GetConfigName(config));
 868       }
 869    }
 870    property char * filePath
 871    {
 872       set
 873       {
 874          if(value)
 875          {
 876             char string[MAX_LOCATION];
 877             GetLastDirectory(value, string);
 878             delete topNode.name;
 879             topNode.name = CopyString(string);
 880             StripExtension(string);
 881             delete name;
 882             name = CopyString(string);
 883             StripLastDirectory(value, string);
 884             delete topNode.path;
 885             topNode.path = CopyString(string);
 886             delete filePath;
 887             filePath = CopyString(value);
 888          }
 889       }
 890    }
 891
 892    TargetTypes GetTargetType(ProjectConfig config)
 893    {
 894       TargetTypes targetType = localTargetType;
 895       return targetType;
 896    }
 897
 898    bool GetTargetTypeIsSetByPlatform(ProjectConfig config)
 899    {
 900       Platform platform;
 901       for(platform = (Platform)1; platform < Platform::enumSize; platform++)
 902       {
 903          PlatformOptions projectPOs, configPOs;
 904          MatchProjectAndConfigPlatformOptions(config, platform, &projectPOs, &configPOs);
 905          if(platformTargetType)
 906             return true;
 907       }
 908       return false;
 909    }
 910
 911
 912    char * GetObjDirExpression(ProjectConfig config)
 913    {
 914       // TODO: Support platform options
 915       char * expression = localObjectsDirectory;
 916       if(!expression)
 917          expression = settingsObjectsDirectory;
 918       return expression;
 919    }
 920
 921    DirExpression GetObjDir(CompilerConfig compiler, ProjectConfig config)
 922    {
 923       char * expression = GetObjDirExpression(config);
 924       DirExpression objDir { type = intermediateObjectsDir };
 925       objDir.Evaluate(expression, this, compiler, config);
 926       return objDir;
 927    }
 928
 929    char * GetTargetDirExpression(ProjectConfig config)
 930    {
 931       // TODO: Support platform options
 932       char * expression = localTargetDirectory;
 933       if(!expression)
 934          expression = settingsTargetDirectory;
 935       return expression;
 936    }
 937
 938    DirExpression GetTargetDir(CompilerConfig compiler, ProjectConfig config)
 939    {
 940       char * expression = GetTargetDirExpression(config);
 941       DirExpression targetDir { type = DirExpressionType::targetDir /*intermediateObjectsDir*/};
 942       targetDir.Evaluate(expression, this, compiler, config);
 943       return targetDir;
 944    }
 945
 946    WarningsOption GetWarnings(ProjectConfig config)
 947    {
 948       WarningsOption warnings = localWarnings;
 949       return warnings;
 950    }
 951
 952    bool GetDebug(ProjectConfig config)
 953    {
 954       SetBool debug = localDebug;
 955       return debug == true;
 956    }
 957
 958    bool GetMemoryGuard(ProjectConfig config)
 959    {
 960       SetBool memoryGuard = localMemoryGuard;
 961       return memoryGuard == true;
 962    }
 963
 964    bool GetNoLineNumbers(ProjectConfig config)
 965    {
 966       SetBool noLineNumbers = localNoLineNumbers;
 967       return noLineNumbers == true;
 968    }
 969
 970    bool GetProfile(ProjectConfig config)
 971    {
 972       SetBool profile = localProfile;
 973       return profile == true;
 974    }
 975
 976    OptimizationStrategy GetOptimization(ProjectConfig config)
 977    {
 978       OptimizationStrategy optimization = localOptimization;
 979       return optimization;
 980    }
 981
 982    String GetDefaultNameSpace(ProjectConfig config)
 983    {
 984       String defaultNameSpace = localDefaultNameSpace;
 985       return defaultNameSpace;
 986    }
 987
 988    bool GetStrictNameSpaces(ProjectConfig config)
 989    {
 990       SetBool strictNameSpaces = localStrictNameSpaces;
 991       return strictNameSpaces == true;
 992    }
 993
 994    String GetTargetFileName(ProjectConfig config)
 995    {
 996       String targetFileName = localTargetFileName;
 997       return targetFileName;
 998    }
 999
1000    //String targetDirectory;
1001    //String objectsDirectory;
1002    bool GetConsole(ProjectConfig config)
1003    {
1004       SetBool console = localConsole;
1005       return console == true;
1006    }
1007
1008    bool GetCompress(ProjectConfig config)
1009    {
1010       SetBool compress = localCompress;
1011       return compress == true;
1012    }
1013    //SetBool excludeFromBuild;
1014
1015    bool GetConfigIsInActiveDebugSession(ProjectConfig config)
1016    {
1017 #ifndef MAKEFILE_GENERATOR
1018       return ide.project == this && ide.debugger && ide.debugger.prjConfig == config && ide.debugger.isActive;
1019 #endif
1020    }
1021
1022    bool GetConfigIsInDebugSession(ProjectConfig config)
1023    {
1024 #ifndef MAKEFILE_GENERATOR
1025       return ide.project == this && ide.debugger && ide.debugger.prjConfig == config && ide.debugger.isPrepared;
1026 #endif
1027    }
1028
1029    void SetPath(bool projectsDirs, CompilerConfig compiler, ProjectConfig config)
1030    {
1031 #ifndef MAKEFILE_GENERATOR
1032       ide.SetPath(projectsDirs, compiler, config);
1033 #endif
1034    }
1035
1036 #ifndef MAKEFILE_GENERATOR
1037    bool Save(char * fileName)
1038    {
1039       File f;
1040       /*char output[MAX_LOCATION];
1041        ChangeExtension(fileName, "json", output);
1042       f = FileOpen(output, write);*/
1043       f = FileOpen(fileName, write);
1044       if(f)
1045       {
1046          files = topNode.files;
1047          resources = resNode.files;
1048          resourcesPath = resNode.path;
1049
1050          files.Remove(resNode);
1051          version = 0.2f;
1052
1053          WriteJSONObject(f, class(Project), this, 0);
1054
1055          files.Add(resNode);
1056
1057          files = null;
1058          resources = null;
1059          resourcesPath = null;
1060          delete f;
1061       }
1062       return true;
1063    }
1064 #endif
1065
1066    // This method is only called from Debugger, should be moved to Debugger class?
1067 #ifndef MAKEFILE_GENERATOR
1068    bool GetRelativePath(char * filePath, char * relativePath)
1069    {
1070       ProjectNode node;
1071       char moduleName[MAX_FILENAME];
1072       GetLastDirectory(filePath, moduleName);
1073       // try with workspace dir first?
1074       if((node = topNode.Find(moduleName, false)))
1075       {
1076          strcpy(relativePath, strcmp(node.path, ".") ? node.path : "");
1077          PathCatSlash(relativePath, node.name);
1078          return true;
1079       }
1080       else
1081       {
1082          // Tweak for automatically resolving symbol loader modules
1083          char * sl = strstr(moduleName, ".main.ec");
1084          if(sl && (*sl = 0, !strcmpi(moduleName, name)))
1085          {
1086             char objDir[MAX_LOCATION];
1087             DirExpression objDirExp;
1088             CompilerConfig compiler = ide.debugger.currentCompiler;
1089             ProjectConfig config = ide.debugger.prjConfig;
1090             // This is not perfect, as multiple source files exist for the symbol loader module...
1091             // We try to set it in the debug config object directory.
1092             if(!compiler || !config)
1093             {
1094                // If we're not currently debugging, set a breakpoint in the active compiler/config
1095                compiler = GetCompilerConfig();
1096                config = this.config;
1097                // If the current config is not debuggable, set it in the first debuggable config found
1098                if(config && !config.options.debug)
1099                {
1100                   for(c : configurations; c.options.debug)
1101                   {
1102                      config = c;
1103                      break;
1104                   }
1105                }
1106             }
1107             objDirExp = GetObjDir(compiler, config);
1108             strcpy(objDir, objDirExp.dir);
1109             delete objDirExp;
1110             ChangeCh(objDir, '\\', '/'); // TODO: this is a hack, paths should never include win32 path seperators - fix this in ProjectSettings and ProjectLoad instead
1111             ReplaceSpaces(objDir, objDir);
1112             strcpy(relativePath, objDir);
1113             *sl = '.';
1114             PathCatSlash(relativePath, moduleName);
1115             return true;
1116          }
1117       }
1118       // WARNING: On failure, relative path is uninitialized
1119       return false;
1120    }
1121 #endif
1122
1123    void CatTargetFileName(char * string, CompilerConfig compiler, ProjectConfig config)
1124    {
1125       TargetTypes targetType = GetTargetType(config);
1126       String targetFileName = GetTargetFileName(config);
1127       if(targetType == staticLibrary)
1128       {
1129          PathCatSlash(string, "lib");
1130          strcat(string, targetFileName);
1131       }
1132       else if(compiler.targetPlatform != win32 && targetType == sharedLibrary)
1133       {
1134          PathCatSlash(string, "lib");
1135          strcat(string, targetFileName);
1136       }
1137       else
1138          PathCatSlash(string, targetFileName);
1139
1140       switch(targetType)
1141       {
1142          case executable:
1143             if(compiler.targetPlatform == win32)
1144                strcat(string, ".exe");
1145             break;
1146          case sharedLibrary:
1147             if(compiler.targetPlatform == win32)
1148                strcat(string, ".dll");
1149             else if(compiler.targetPlatform == apple)
1150                strcat(string, ".dylib");
1151             else
1152                strcat(string, ".so");
1153             break;
1154          case staticLibrary:
1155             strcat(string, ".a");
1156             break;
1157       }
1158    }
1159
1160    bool GetProjectCompilerConfigsDir(char * cfDir, bool replaceSpaces, bool makeRelative)
1161    {
1162       bool result = false;
1163       char temp[MAX_LOCATION];
1164       strcpy(cfDir, topNode.path);
1165       if(compilerConfigsDir && compilerConfigsDir[0])
1166       {
1167          PathCatSlash(cfDir, compilerConfigsDir);
1168          result = true;
1169       }
1170       if(makeRelative)
1171       {
1172          strcpy(temp, cfDir);
1173          // Using a relative path makes it less likely to run into spaces issues
1174          // Even with escaped spaces, there still seems to be issues including a config file
1175          // in a path containing spaces
1176
1177          MakePathRelative(temp, topNode.path, cfDir);
1178       }
1179
1180       if(cfDir && cfDir[0] && cfDir[strlen(cfDir)-1] != '/')
1181          strcat(cfDir, "/");
1182       if(replaceSpaces)
1183       {
1184          strcpy(temp, cfDir);
1185          ReplaceSpaces(cfDir, temp);
1186       }
1187       return result;
1188    }
1189
1190    bool GetIDECompilerConfigsDir(char * cfDir, bool replaceSpaces, bool makeRelative)
1191    {
1192       char temp[MAX_LOCATION];
1193       bool result = false;
1194       strcpy(cfDir, topNode.path);
1195       if(ideSettings.compilerConfigsDir && ideSettings.compilerConfigsDir[0])
1196       {
1197          PathCatSlash(cfDir, ideSettings.compilerConfigsDir);
1198          result = true;
1199       }
1200       else
1201       {
1202          // Default to <ProjectDir>/.configs if unset
1203          PathCatSlash(cfDir, ".configs");
1204          result = true;
1205       }
1206       if(makeRelative)
1207       {
1208          strcpy(temp, cfDir);
1209          // Using a relative path makes it less likely to run into spaces issues
1210          // Even with escaped spaces, there still seems to be issues including a config file
1211          // in a path containing spaces
1212          if(IsPathInsideOf(cfDir, topNode.path))
1213             MakePathRelative(temp, topNode.path, cfDir);
1214       }
1215       if(cfDir && cfDir[0] && cfDir[strlen(cfDir)-1] != '/')
1216          strcat(cfDir, "/");
1217       if(replaceSpaces)
1218       {
1219          strcpy(temp, cfDir);
1220          ReplaceSpaces(cfDir, temp);
1221       }
1222       return result;
1223    }
1224
1225    void CatMakeFileName(char * string, ProjectConfig config)
1226    {
1227       char projectName[MAX_LOCATION];
1228       strcpy(projectName, name);
1229       sprintf(string, "%s%s%s.Makefile", projectName, config ? "-" : "", config ? config.name : "");
1230    }
1231
1232 #ifndef MAKEFILE_GENERATOR
1233    void MarkChanges(ProjectNode node)
1234    {
1235       for(cfg : topNode.configurations)
1236       {
1237          ProjectConfig c = null;
1238          for(i : node.configurations; !strcmpi(i.name, cfg.name)) { c = i; break; }
1239
1240          if(c && ((c.options && cfg.options && cfg.options.console != c.options.console) ||
1241                (!c.options || !cfg.options)))
1242             cfg.symbolGenModified = true;
1243
1244          cfg.makingModified = true;
1245       }
1246    }
1247
1248    void ModifiedAllConfigs(bool making, bool compiling, bool linking, bool symbolGen)
1249    {
1250       for(cfg : configurations)
1251       {
1252          if(making)
1253             cfg.makingModified = true;
1254          if(compiling)
1255             cfg.compilingModified = true;
1256          if(linking)
1257             cfg.linkingModified = true;
1258          if(symbolGen)
1259             cfg.symbolGenModified = true;
1260       }
1261       if(compiling || linking)
1262       {
1263          ide.projectView.modifiedDocument = true;
1264          ide.workspace.modified = true;
1265       }
1266    }
1267
1268    void RotateActiveConfig(bool forward)
1269    {
1270       if(configurations.first && configurations.last != configurations.first)
1271       {
1272          Iterator<ProjectConfig> cfg { configurations };
1273          while(forward ? cfg.Next() : cfg.Prev())
1274             if(cfg.data == config)
1275                break;
1276
1277          if(forward)
1278          {
1279             if(!cfg.Next())
1280                cfg.Next();
1281          }
1282          else
1283          {
1284             if(!cfg.Prev())
1285                cfg.Prev();
1286          }
1287
1288          property::config = cfg.data;
1289          ide.workspace.modified = true;
1290          ide.projectView.Update(null);
1291       }
1292    }
1293
1294    void ProcessPipeOutputRaw(DualPipe f)
1295    {
1296       char line[65536];
1297       while(!f.Eof() && !ide.ShouldStopBuild())
1298       {
1299          bool result = true;
1300          double lastTime = GetTime();
1301          bool wait = true;
1302          while(result)
1303          {
1304             if((result = f.Peek()) && (result = f.GetLine(line, sizeof(line)-1)))
1305             {
1306                ide.outputView.buildBox.Logf("%s\n", line);
1307             }
1308             if(GetTime() - lastTime > 1.0 / PEEK_RESOLUTION) break;
1309          }
1310          //printf("Processing Input...\n");
1311          if(app.ProcessInput(true))
1312             wait = false;
1313          app.UpdateDisplay();
1314          if(wait)
1315          {
1316             //printf("Waiting...\n");
1317             app.Wait();
1318          }
1319          //if(!result) Sleep(1.0 / PEEK_RESOLUTION);
1320       }
1321       if(ide.ShouldStopBuild())
1322       {
1323          ide.outputView.buildBox.Logf($"\nBuild cancelled by user.\n", line);
1324          f.Terminate();
1325       }
1326    }
1327
1328    bool ProcessBuildPipeOutput(DualPipe f, DirExpression objDirExp, bool isARun, ProjectNode onlyNode,
1329       CompilerConfig compiler, ProjectConfig config)
1330    {
1331       char line[65536];
1332       bool compiling = false, linking = false, precompiling = false;
1333       int compilingEC = 0;
1334       int numErrors = 0, numWarnings = 0;
1335       bool loggedALine = false;
1336       char * configName = config.name;
1337       int lenMakeCommand = strlen(compiler.makeCommand);
1338
1339       char cppCommand[MAX_LOCATION];
1340       char ccCommand[MAX_LOCATION];
1341       char cxxCommand[MAX_LOCATION];
1342       char ecpCommand[MAX_LOCATION];
1343       char eccCommand[MAX_LOCATION];
1344       char ecsCommand[MAX_LOCATION];
1345       char earCommand[MAX_LOCATION];
1346
1347       char * cc = compiler.ccCommand;
1348       char * cxx = compiler.cxxCommand;
1349       char * cpp = compiler.cppCommand;
1350       sprintf(cppCommand, "%s%s%s%s ",
1351             compiler.ccacheEnabled ? "ccache " : "",
1352             compiler.ccacheEnabled && !compiler.distccEnabled ? " " : "",
1353             compiler.distccEnabled ? "distcc " : "",
1354             compiler.cppCommand);
1355       sprintf(ccCommand, "%s%s%s%s ",
1356             compiler.ccacheEnabled ? "ccache " : "",
1357             compiler.ccacheEnabled && !compiler.distccEnabled ? " " : "",
1358             compiler.distccEnabled ? "distcc " : "",
1359             compiler.ccCommand);
1360       sprintf(cxxCommand, "%s%s%s%s ",
1361             compiler.ccacheEnabled ? "ccache " : "",
1362             compiler.ccacheEnabled && !compiler.distccEnabled ? " " : "",
1363             compiler.distccEnabled ? "distcc " : "",
1364             compiler.cxxCommand);
1365       sprintf(ecpCommand, "%s ", compiler.ecpCommand);
1366       sprintf(eccCommand, "%s ", compiler.eccCommand);
1367       sprintf(ecsCommand, "%s ", compiler.ecsCommand);
1368       sprintf(earCommand, "%s ", compiler.earCommand);
1369
1370       while(!f.Eof() && !ide.ShouldStopBuild())
1371       {
1372          bool result = true;
1373          double lastTime = GetTime();
1374          bool wait = true;
1375          while(result)
1376          {
1377             //printf("Peeking and GetLine...\n");
1378             if((result = f.Peek()) && (result = f.GetLine(line, sizeof(line)-1)))
1379             {
1380                char * inFileIncludedFrom = strstr(line, stringInFileIncludedFrom);
1381                if(strstr(line, compiler.makeCommand) == line && line[lenMakeCommand] == ':')
1382                {
1383                   char * module = strstr(line, "No rule to make target `");
1384                   if(module)
1385                   {
1386                      char * end;
1387                      module = strchr(module, '`') + 1;
1388                      end = strchr(module, '\'');
1389                      if(end)
1390                      {
1391                         *end = '\0';
1392                         ide.outputView.buildBox.Logf($"   %s: No such file or directory\n", module);
1393                         // ide.outputView.buildBox.Logf("error: %s\n   No such file or directory\n", module);
1394                         numErrors++;
1395                      }
1396                   }
1397                   //else
1398                   //{
1399                      //ide.outputView.buildBox.Logf("error: %s\n", line);
1400                      //numErrors++;
1401                   //}
1402                }
1403                else if(strstr(line, "ear ") == line);
1404                else if(strstr(line, "strip ") == line);
1405                else if(strstr(line, ccCommand) == line || strstr(line, cxxCommand) == line || strstr(line, ecpCommand) == line || strstr(line, eccCommand) == line)
1406                {
1407                   char moduleName[MAX_FILENAME];
1408                   byte * tokens[1];
1409                   char * module;
1410                   bool isPrecomp = false;
1411
1412                   if(strstr(line, ccCommand) == line || strstr(line, cxxCommand) == line)
1413                   {
1414                      module = strstr(line, " -c ");
1415                      if(module) module += 4;
1416                   }
1417                   else if(strstr(line, eccCommand) == line)
1418                   {
1419                      module = strstr(line, " -c ");
1420                      if(module) module += 4;
1421                      //module = line + 3;
1422                      // Don't show GCC warnings about generated C code because it does not compile clean yet...
1423                      compilingEC = 3;//2;
1424                   }
1425                   else if(strstr(line, ecpCommand) == line)
1426                   {
1427                      // module = line + 8;
1428                      module = strstr(line, " -c ");
1429                      if(module) module += 4;
1430                      isPrecomp = true;
1431                      compilingEC = 0;
1432                   }
1433
1434                   loggedALine = true;
1435
1436                   if(module)
1437                   {
1438                      if(!compiling && !isPrecomp)
1439                      {
1440                         ide.outputView.buildBox.Logf($"Compiling...\n");
1441                         compiling = true;
1442                      }
1443                      else if(!precompiling && isPrecomp)
1444                      {
1445                         ide.outputView.buildBox.Logf($"Generating symbols...\n");
1446                         precompiling = true;
1447                      }
1448                      // Changed escapeBackSlashes here to handle paths with spaces
1449                      Tokenize(module, 1, tokens, true); // false);
1450                      GetLastDirectory(module, moduleName);
1451                      ide.outputView.buildBox.Logf("%s\n", moduleName);
1452                   }
1453                   else if((module = strstr(line, " -o ")))
1454                   {
1455                      compiling = false;
1456                      precompiling = false;
1457                      linking = true;
1458                      ide.outputView.buildBox.Logf($"Linking...\n");
1459                   }
1460                   else
1461                   {
1462                      ide.outputView.buildBox.Logf("%s\n", line);
1463                      numErrors++;
1464                   }
1465
1466                   if(compilingEC) compilingEC--;
1467                }
1468                else if(strstr(line, "ar rcs") == line)
1469                   ide.outputView.buildBox.Logf($"Building library...\n");
1470                else if(strstr(line, ecsCommand) == line)
1471                   ide.outputView.buildBox.Logf($"Writing symbol loader...\n");
1472                else
1473                {
1474                   if(linking || compiling || precompiling)
1475                   {
1476                      char * colon = strstr(line, ":"); //, * bracket;
1477                      if(colon && (colon[1] == '/' || colon[1] == '\\'))
1478                         colon = strstr(colon + 1, ":");
1479                      if(colon)
1480                      {
1481                         char moduleName[MAX_LOCATION], temp[MAX_LOCATION];
1482                         char * pointer;
1483                         char * error;
1484                         char * start = inFileIncludedFrom ? line + strlen(stringInFileIncludedFrom) : line;
1485                         int len = (int)(colon - start);
1486                         len = Min(len, MAX_LOCATION-1);
1487                         // Don't be mistaken by the drive letter colon
1488                         // Cut module name
1489                         // TODO: need to fix colon - line gives char *
1490                         // warning: incompatible expression colon - line (char *); expected int
1491                         /*
1492                         strncpy(moduleName, line, (int)(colon - line));
1493                         moduleName[colon - line] = '\0';
1494                         */
1495                         strncpy(moduleName, start, len);
1496                         moduleName[len] = '\0';
1497                         // Remove stuff in brackets
1498                         //bracket = strstr(moduleName, "(");
1499                         //if(bracket) *bracket = '\0';
1500
1501                         GetLastDirectory(moduleName, temp);
1502                         if(linking && (!strcmp(temp, "ld") || !strcmp(temp, "ld.exe")))
1503                         {
1504                            numErrors++;
1505                            strcpy(moduleName, $"Linker Error");
1506                         }
1507                         else
1508                         {
1509                            strcpy(temp, topNode.path);
1510                            PathCatSlash(temp, moduleName);
1511                            MakePathRelative(temp, topNode.path, moduleName);
1512                         }
1513                         if(strstr(line, "error:"))
1514                            numErrors ++;
1515                         else
1516                         {
1517                            // Silence warnings for compiled EC
1518                            char * objDir = strstr(moduleName, objDirExp.dir);
1519
1520                            if(linking)
1521                            {
1522                               if((pointer = strstr(line, "undefined"))  ||
1523                                    (pointer = strstr(line, "No such file")) ||
1524                                    (pointer = strstr(line, "token")))
1525                               {
1526                                  strncat(moduleName, colon, pointer - colon);
1527                                  strcat(moduleName, "error: ");
1528                                  colon = pointer;
1529                                  numErrors ++;
1530                               }
1531                            }
1532                            else if((pointer = strstr(line, "No such file")))
1533                            {
1534                               strncat(moduleName, colon, pointer - colon);
1535                               strcat(moduleName, "error: ");
1536                               colon = pointer;
1537                               numErrors ++;
1538                            }
1539                            else if(compilingEC == 1 || (objDir && objDir == moduleName))
1540                               continue;
1541                            else if(strstr(line, "warning:"))
1542                            {
1543                               numWarnings++;
1544                            }
1545                         }
1546                         if(this == ide.workspace.projects.firstIterator.data)
1547                            ide.outputView.buildBox.Logf("   %s%s\n", moduleName, colon);
1548                         else
1549                         {
1550                            char fullModuleName[MAX_LOCATION];
1551                            strcpy(fullModuleName, topNode.path);
1552                            PathCat(fullModuleName, moduleName);
1553                            MakePathRelative(fullModuleName, ide.workspace.projects.firstIterator.data.topNode.path, fullModuleName);
1554                            MakeSystemPath(fullModuleName);
1555                            ide.outputView.buildBox.Logf("   %s%s%s\n", inFileIncludedFrom ? stringInFileIncludedFrom : "", fullModuleName, colon);
1556                         }
1557                      }
1558                      else
1559                      {
1560                         ide.outputView.buildBox.Logf("%s\n", line);
1561                         linking = compiling = precompiling = false;
1562                      }
1563                   }
1564                   else
1565                      ide.outputView.buildBox.Logf("%s\n", line);
1566                }
1567                wait = false;
1568             }
1569             //printf("Done getting line\n");
1570             if(GetTime() - lastTime > 1.0 / PEEK_RESOLUTION) break;
1571          }
1572          //printf("Processing Input...\n");
1573          if(app.ProcessInput(true))
1574             wait = false;
1575          app.UpdateDisplay();
1576          if(wait)
1577          {
1578             //printf("Waiting...\n");
1579             app.Wait();
1580          }
1581          //if(!result) Sleep(1.0 / PEEK_RESOLUTION);
1582       }
1583       if(ide.ShouldStopBuild())
1584       {
1585          ide.outputView.buildBox.Logf($"\nBuild cancelled by user.\n", line);
1586          f.Terminate();
1587       }
1588       else if(loggedALine || !isARun)
1589       {
1590          if(f.GetExitCode() && !numErrors)
1591          {
1592             bool result = f.GetLine(line, sizeof(line)-1);
1593             ide.outputView.buildBox.Logf($"Fatal Error: child process terminated unexpectedly\n");
1594          }
1595          else
1596          {
1597             if(!onlyNode)
1598                ide.outputView.buildBox.Logf("\n%s (%s) - ", GetTargetFileName(config), configName);
1599             if(numErrors)
1600                ide.outputView.buildBox.Logf("%d %s, ", numErrors, (numErrors > 1) ? $"errors" : $"error");
1601             else
1602                ide.outputView.buildBox.Logf($"no error, ");
1603
1604             if(numWarnings)
1605                ide.outputView.buildBox.Logf("%d %s\n", numWarnings, (numWarnings > 1) ? $"warnings" : $"warning");
1606             else
1607                ide.outputView.buildBox.Logf($"no warning\n");
1608          }
1609       }
1610       return numErrors == 0;
1611    }
1612
1613    void ProcessCleanPipeOutput(DualPipe f, CompilerConfig compiler, ProjectConfig config)
1614    {
1615       char line[65536];
1616       int lenMakeCommand = strlen(compiler.makeCommand);
1617       while(!f.Eof())
1618       {
1619          bool result = true;
1620          bool wait = true;
1621          double lastTime = GetTime();
1622          while(result)
1623          {
1624             if((result = f.Peek()) && (result = f.GetLine(line, sizeof(line)-1)))
1625             {
1626                if(strstr(line, compiler.makeCommand) == line && line[lenMakeCommand] == ':');
1627                else if(strstr(line, "del") == line);
1628                else if(strstr(line, "rm") == line);
1629                else if(strstr(line, "Could Not Find") == line);
1630                else
1631                {
1632                   ide.outputView.buildBox.Logf(line);
1633                   ide.outputView.buildBox.Logf("\n");
1634                }
1635                wait = false;
1636             }
1637             if(GetTime() - lastTime > 1.0 / PEEK_RESOLUTION) break;
1638          }
1639          if(app.ProcessInput(true))
1640             wait = false;
1641          app.UpdateDisplay();
1642          if(wait)
1643             app.Wait();
1644          //Sleep(1.0 / PEEK_RESOLUTION);
1645       }
1646    }
1647
1648    bool Build(bool isARun, ProjectNode onlyNode, CompilerConfig compiler, ProjectConfig config)
1649    {
1650       bool result = false;
1651       DualPipe f;
1652       char targetFileName[MAX_LOCATION] = "";
1653       char makeTarget[MAX_LOCATION] = "";
1654       char makeFile[MAX_LOCATION];
1655       char makeFilePath[MAX_LOCATION];
1656       char configName[MAX_LOCATION];
1657       DirExpression objDirExp = GetObjDir(compiler, config);
1658       PathBackup pathBackup { };
1659       bool crossCompiling = (compiler.targetPlatform != GetRuntimePlatform());
1660       char * targetPlatform = crossCompiling ? (char *)compiler.targetPlatform : "";
1661
1662       int numJobs = compiler.numJobs;
1663       char command[MAX_LOCATION];
1664       char * compilerName;
1665
1666       compilerName = CopyString(compiler.name);
1667       CamelCase(compilerName);
1668
1669       strcpy(configName, config ? config.name : "Common");
1670
1671       SetPath(false, compiler, config); //true
1672       CatTargetFileName(targetFileName, compiler, config);
1673
1674       strcpy(makeFilePath, topNode.path);
1675       CatMakeFileName(makeFile, config);
1676       PathCatSlash(makeFilePath, makeFile);
1677
1678       // TODO: TEST ON UNIX IF \" around makeTarget is ok
1679       if(onlyNode)
1680       {
1681          if(compiler.type.isVC)
1682          {
1683             PrintLn("compiling a single file is not yet supported");
1684          }
1685          else
1686          {
1687             int len;
1688             char pushD[MAX_LOCATION];
1689             char cfDir[MAX_LOCATION];
1690             GetIDECompilerConfigsDir(cfDir, true, true);
1691             GetWorkingDir(pushD, sizeof(pushD));
1692             ChangeWorkingDir(topNode.path);
1693             // Create object dir if it does not exist already
1694             if(!FileExists(objDirExp.dir).isDirectory)
1695                Execute("%s CF_DIR=%s%s%s COMPILER=%s objdir -C \"%s\" -f \"%s\"", compiler.makeCommand, cfDir,
1696                   crossCompiling ? " PLATFORM=" : "", targetPlatform, compilerName, topNode.path, makeFilePath);
1697             ChangeWorkingDir(pushD);
1698
1699             PathCatSlash(makeTarget+1, objDirExp.dir);
1700             PathCatSlash(makeTarget+1, onlyNode.name);
1701             StripExtension(makeTarget+1);
1702             strcat(makeTarget+1, ".o");
1703             makeTarget[0] = '\"';
1704             len = strlen(makeTarget);
1705             makeTarget[len++] = '\"';
1706             makeTarget[len++] = '\0';
1707          }
1708       }
1709
1710       if(compiler.type.isVC)
1711       {
1712          bool result = false;
1713          char oldwd[MAX_LOCATION];
1714          GetWorkingDir(oldwd, sizeof(oldwd));
1715          ChangeWorkingDir(topNode.path);
1716
1717          sprintf(command, "%s /useenv /nologo /logcommands %s.sln %s|Win32", compiler.makeCommand, name, config.name);
1718          ide.outputView.buildBox.Logf("command: %s\n", command);
1719          if((f = DualPipeOpen(PipeOpenMode { output = true, error = true, input = true }, command)))
1720          {
1721             ProcessPipeOutputRaw(f);
1722             delete f;
1723             result = true;
1724          }
1725          ChangeWorkingDir(oldwd);
1726       }
1727       else
1728       {
1729          char cfDir[MAX_LOCATION];
1730          GetIDECompilerConfigsDir(cfDir, true, true);
1731          sprintf(command, "%s CF_DIR=\"%s\"%s%s COMPILER=%s -j%d %s%s%s -C \"%s\" -f \"%s\"", compiler.makeCommand, cfDir,
1732                crossCompiling ? " PLATFORM=" : "", targetPlatform,
1733                compilerName, numJobs,
1734                compiler.ccacheEnabled ? "CCACHE=y " : "",
1735                compiler.distccEnabled ? "DISTCC=y " : "",
1736                makeTarget, topNode.path, makeFilePath);
1737          if((f = DualPipeOpen(PipeOpenMode { output = true, error = true, input = true }, command)))
1738          {
1739             result = ProcessBuildPipeOutput(f, objDirExp, isARun, onlyNode, compiler, config);
1740             delete f;
1741          }
1742          else
1743             ide.outputView.buildBox.Logf($"Error executing make (%s) command\n", compiler.makeCommand);
1744       }
1745
1746       delete pathBackup;
1747       delete objDirExp;
1748       delete compilerName;
1749       return result;
1750    }
1751
1752    void Clean(CompilerConfig compiler, ProjectConfig config, bool realclean)
1753    {
1754       char makeFile[MAX_LOCATION];
1755       char makeFilePath[MAX_LOCATION];
1756       char command[MAX_LOCATION];
1757       char * compilerName;
1758       DualPipe f;
1759       PathBackup pathBackup { };
1760       bool crossCompiling = (compiler.targetPlatform != GetRuntimePlatform());
1761       char * targetPlatform = crossCompiling ? (char *)compiler.targetPlatform : "";
1762
1763       compilerName = CopyString(compiler.name);
1764       CamelCase(compilerName);
1765
1766       SetPath(false, compiler, config);
1767
1768       strcpy(makeFilePath, topNode.path);
1769       CatMakeFileName(makeFile, config);
1770       PathCatSlash(makeFilePath, makeFile);
1771
1772       if(compiler.type.isVC)
1773       {
1774          bool result = false;
1775          char oldwd[MAX_LOCATION];
1776          GetWorkingDir(oldwd, sizeof(oldwd));
1777          ChangeWorkingDir(topNode.path);
1778
1779          sprintf(command, "%s /useenv /clean /nologo /logcommands %s.sln %s|Win32", compiler.makeCommand, name, config.name);
1780          ide.outputView.buildBox.Logf("command: %s\n", command);
1781          if((f = DualPipeOpen(PipeOpenMode { output = true, error = true, input = true }, command)))
1782          {
1783             ProcessPipeOutputRaw(f);
1784             delete f;
1785             result = true;
1786          }
1787          ChangeWorkingDir(oldwd);
1788          return result;
1789       }
1790       else
1791       {
1792          char cfDir[MAX_LOCATION];
1793          GetIDECompilerConfigsDir(cfDir, true, true);
1794          sprintf(command, "%s CF_DIR=%s%s%s COMPILER=%s %sclean -C \"%s\" -f \"%s\"", compiler.makeCommand, cfDir,
1795             crossCompiling ? " PLATFORM=" : "", targetPlatform, compilerName, realclean ? "real" : "", topNode.path, makeFilePath);
1796          if((f = DualPipeOpen(PipeOpenMode { output = 1, error = 1, input = 2 }, command)))
1797          {
1798             ide.outputView.buildBox.Tell($"Deleting target and object files...");
1799             ProcessCleanPipeOutput(f, compiler, config);
1800             delete f;
1801
1802             ide.outputView.buildBox.Logf($"Target and object files deleted\n");
1803          }
1804       }
1805
1806       delete pathBackup;
1807       delete compilerName;
1808    }
1809
1810    void Run(char * args, CompilerConfig compiler, ProjectConfig config)
1811    {
1812       String target = new char[maxPathLen];
1813       char oldDirectory[MAX_LOCATION];
1814       DirExpression targetDirExp = GetTargetDir(compiler, config);
1815       PathBackup pathBackup { };
1816
1817       // Build(project, ideMain, true, null);
1818
1819    #if defined(__WIN32__)
1820       strcpy(target, topNode.path);
1821    #else
1822       strcpy(target, "");
1823    #endif
1824       PathCatSlash(target, targetDirExp.dir);
1825       CatTargetFileName(target, compiler, config);
1826       sprintf(target, "%s %s", target, args);
1827       GetWorkingDir(oldDirectory, MAX_LOCATION);
1828
1829       if(strlen(ide.workspace.debugDir))
1830       {
1831          char temp[MAX_LOCATION];
1832          strcpy(temp, topNode.path);
1833          PathCatSlash(temp, ide.workspace.debugDir);
1834          ChangeWorkingDir(temp);
1835       }
1836       else
1837          ChangeWorkingDir(topNode.path);
1838       // ChangeWorkingDir(topNode.path);
1839       SetPath(true, compiler, config);
1840       if(compiler.execPrefixCommand)
1841       {
1842          char * prefixedTarget = new char[strlen(compiler.execPrefixCommand) + strlen(target) + 2];
1843          prefixedTarget[0] = '\0';
1844          strcat(prefixedTarget, compiler.execPrefixCommand);
1845          strcat(prefixedTarget, " ");
1846          strcat(prefixedTarget, target);
1847          Execute(prefixedTarget);
1848          delete prefixedTarget;
1849       }
1850       else
1851          Execute(target);
1852
1853       ChangeWorkingDir(oldDirectory);
1854       delete pathBackup;
1855
1856       delete targetDirExp;
1857       delete target;
1858    }
1859
1860    void Compile(ProjectNode node, CompilerConfig compiler, ProjectConfig config)
1861    {
1862       Build(false, node, compiler, config);
1863    }
1864 #endif
1865
1866    void GetMakefileTargetFileName(TargetTypes targetType, char * fileName, ProjectConfig config)
1867    {
1868       fileName[0] = '\0';
1869       if(targetType == staticLibrary || targetType == sharedLibrary)
1870          strcat(fileName, "$(LP)");
1871       // !!! ReplaceSpaces must be done after all PathCat calls !!!
1872       // ReplaceSpaces(s, GetTargetFileName(config));
1873       strcat(fileName, GetTargetFileName(config));
1874       switch(targetType)
1875       {
1876          case executable:
1877             strcat(fileName, "$(E)");
1878             break;
1879          case sharedLibrary:
1880             strcat(fileName, "$(SO)");
1881             break;
1882          case staticLibrary:
1883             strcat(fileName, "$(A)");
1884             break;
1885       }
1886    }
1887
1888    bool GenerateCrossPlatformCf()
1889    {
1890       bool result = false;
1891       char path[MAX_LOCATION];
1892
1893       if(!GetProjectCompilerConfigsDir(path, false, false))
1894          GetIDECompilerConfigsDir(path, false, false);
1895
1896       if(!FileExists(path).isDirectory)
1897       {
1898          MakeDir(path);
1899          {
1900             char dirName[MAX_FILENAME];
1901             GetLastDirectory(path, dirName);
1902             if(!strcmp(dirName, ".configs"))
1903                FileSetAttribs(path, FileAttribs { isHidden = true });
1904          }
1905       }
1906       PathCatSlash(path, "crossplatform.mk");
1907
1908       if(FileExists(path))
1909          DeleteFile(path);
1910       {
1911          File include = FileOpen(":crossplatform.mk", read);
1912          if(include)
1913          {
1914             File f = FileOpen(path, write);
1915             if(f)
1916             {
1917                for(; !include.Eof(); )
1918                {
1919                   char buffer[4096];
1920                   int count = include.Read(buffer, 1, 4096);
1921                   f.Write(buffer, 1, count);
1922                }
1923                delete f;
1924
1925                result = true;
1926             }
1927             delete include;
1928          }
1929       }
1930       return result;
1931    }
1932
1933    bool GenerateCompilerMk(CompilerConfig compiler)
1934    {
1935       bool result = false;
1936       char path[MAX_LOCATION];
1937       char * name;
1938       char * compilerName;
1939       bool gccCompiler = compiler.ccCommand && (strstr(compiler.ccCommand, "gcc") != null || strstr(compiler.ccCommand, "g++") != null);
1940       Platform platform = compiler.targetPlatform;
1941
1942       compilerName = CopyString(compiler.name);
1943       CamelCase(compilerName);
1944       name = PrintString(platform, "-", compilerName, ".cf");
1945
1946       if(!GetProjectCompilerConfigsDir(path, false, false))
1947          GetIDECompilerConfigsDir(path, false, false);
1948
1949       if(!FileExists(path).isDirectory)
1950       {
1951          MakeDir(path);
1952          {
1953             char dirName[MAX_FILENAME];
1954             GetLastDirectory(path, dirName);
1955             if(!strcmp(dirName, ".configs"))
1956                FileSetAttribs(path, FileAttribs { isHidden = true });
1957          }
1958       }
1959       PathCatSlash(path, name);
1960
1961       if(FileExists(path))
1962          DeleteFile(path);
1963       {
1964          File f = FileOpen(path, write);
1965          if(f)
1966          {
1967             /*
1968             if(compiler.targetPlatform != GetRuntimePlatform())
1969                f.Printf("\nPLATFORM = %s\n", (char *)compiler.targetPlatform);
1970             */
1971
1972             f.Printf("# TOOLCHAIN\n\n");
1973
1974             //f.Printf("SHELL := %s\n", "sh"/*compiler.shellCommand*/); // is this really needed?
1975             f.Printf("CPP := %s\n", compiler.cppCommand);
1976             f.Printf("CC := $(CCACHE_COMPILE) $(DISTCC_COMPILE) %s\n", compiler.ccCommand);
1977             f.Printf("CXX := $(CCACHE_COMPILE) $(DISTCC_COMPILE) %s\n", compiler.cxxCommand);
1978             f.Printf("ECP := %s\n", compiler.ecpCommand);
1979             f.Printf("ECC := %s\n", compiler.eccCommand);
1980             f.Printf("ECS := %s -t $(PLATFORM)\n", compiler.ecsCommand);
1981             f.Printf("EAR := %s\n", compiler.earCommand);
1982
1983             f.Printf("AS := as\n");
1984             f.Printf("LD := ld\n");
1985             f.Printf("AR := ar\n");
1986             f.Printf("STRIP := strip\n");
1987             f.Printf("UPX := upx\n");
1988
1989             f.Printf("\n");
1990             if(compiler.environmentVars && compiler.environmentVars.count)
1991             {
1992                f.Printf("# ENVIRONMENT VARIABLES\n");
1993                for(e : compiler.environmentVars)
1994                {
1995                   f.Printf("export %s := %s\n", e.name, e.string);
1996                }
1997             }
1998
1999             f.Printf("UPXFLAGS = -9\n\n"); // TOFEAT: Compression Level Option? Other UPX Options?
2000
2001             f.Printf("# HARD CODED PLATFORM-SPECIFIC OPTIONS\n");
2002             f.Printf("ifeq \"$(PLATFORM)\" \"linux\"\n"); //, PlatformToMakefileVariable(tux));
2003             f.Printf("LDFLAGS += -Wl,--no-undefined\n");
2004             f.Printf("endif\n\n");
2005
2006             // JF's
2007             f.Printf("ifeq \"$(PLATFORM)\" \"apple\"\n"); //%s\n", PlatformToMakefileVariable(apple));
2008             f.Printf("LDFLAGS += -framework cocoa -framework OpenGL\n");
2009             f.Printf("endif\n");
2010
2011             if(gccCompiler)
2012             {
2013                f.Printf("\nCFLAGS += -fmessage-length=0\n");
2014             }
2015
2016             if(compiler.includeDirs && compiler.includeDirs.count)
2017             {
2018                f.Printf("\nCFLAGS +=");
2019                OutputListOption(f, gccCompiler ? "isystem " : "I", compiler.includeDirs, lineEach, true);
2020                f.Printf("\n");
2021             }
2022             if(compiler.prepDirectives && compiler.prepDirectives.count)
2023             {
2024                f.Printf("\nCFLAGS +=");
2025                OutputListOption(f, "D", compiler.prepDirectives, inPlace, true);
2026                f.Printf("\n");
2027             }
2028             if(compiler.libraryDirs && compiler.libraryDirs.count)
2029             {
2030                f.Printf("\nLDFLAGS +=");
2031                OutputListOption(f, "L", compiler.libraryDirs, lineEach, true);
2032                // We would need a bool option to know whether we want to add to rpath as well...
2033                // OutputListOption(f, "Wl,-rpath ", compiler.libraryDirs, lineEach, true);
2034                f.Printf("\n");
2035             }
2036             if(compiler.excludeLibs && compiler.excludeLibs.count)
2037             {
2038                f.Puts("\nEXCLUDED_LIBS =");
2039                for(l : compiler.excludeLibs)
2040                {
2041                   f.Puts(" ");
2042                   f.Puts(l);
2043                }
2044             }
2045             if(compiler.linkerFlags && compiler.linkerFlags.count)
2046             {
2047                f.Printf("\nLDFLAGS +=");
2048                OutputListOption(f, "Wl,", compiler.linkerFlags, inPlace, true);
2049                f.Printf("\n");
2050             }
2051             f.Printf("\nFORCE_64_BIT = %s", compiler.supportsBitDepth ? "-m64" : "");
2052             f.Printf("\nFORCE_32_BIT = %s", compiler.supportsBitDepth ? "-m32" : "");
2053             f.Printf("\n");
2054
2055             delete f;
2056          }
2057       }
2058       delete name;
2059       delete compilerName;
2060       return result;
2061    }
2062
2063    bool GenerateMakefile(char * altMakefilePath, bool noResources, char * includemkPath, ProjectConfig config)
2064    {
2065       bool result = false;
2066       char filePath[MAX_LOCATION];
2067       char makeFile[MAX_LOCATION];
2068       // PathBackup pathBackup { };
2069       // char oldDirectory[MAX_LOCATION];
2070       File f = null;
2071
2072       if(!altMakefilePath)
2073       {
2074          strcpy(filePath, topNode.path);
2075          CatMakeFileName(makeFile, config);
2076          PathCatSlash(filePath, makeFile);
2077       }
2078
2079       f = FileOpen(altMakefilePath ? altMakefilePath : filePath, write);
2080
2081       /*SetPath(false, compiler, config);
2082       GetWorkingDir(oldDirectory, MAX_LOCATION);
2083       ChangeWorkingDir(topNode.path);*/
2084
2085       if(f)
2086       {
2087          bool test;
2088          int ifCount;
2089          Platform platform;
2090          char targetDir[MAX_LOCATION];
2091          char objDirExpNoSpaces[MAX_LOCATION];
2092          char objDirNoSpaces[MAX_LOCATION];
2093          char resDirNoSpaces[MAX_LOCATION];
2094          char targetDirExpNoSpaces[MAX_LOCATION];
2095          char fixedModuleName[MAX_FILENAME];
2096          char fixedConfigName[MAX_FILENAME];
2097          int c, len;
2098          // Non-zero if we're building eC code
2099          // We'll have to be careful with this when merging configs where eC files can be excluded in some configs and included in others
2100          int numCObjects = 0;
2101          bool containsCXX = false; // True if the project contains a C++ file
2102          bool sameObjTargetDirs;
2103          String objDirExp = GetObjDirExpression(config);
2104          TargetTypes targetType = GetTargetType(config);
2105
2106          char cfDir[MAX_LOCATION];
2107          int objectsParts, eCsourcesParts;
2108          Array<String> listItems { };
2109          Map<String, int> varStringLenDiffs { };
2110          Map<String, NameCollisionInfo> namesInfo { };
2111          bool forceBitDepth = false;
2112
2113          ReplaceSpaces(objDirNoSpaces, objDirExp);
2114          strcpy(targetDir, GetTargetDirExpression(config));
2115          ReplaceSpaces(targetDirExpNoSpaces, targetDir);
2116
2117          strcpy(objDirExpNoSpaces, GetObjDirExpression(config));
2118          ChangeCh(objDirExpNoSpaces, '\\', '/'); // TODO: this is a hack, paths should never include win32 path seperators - fix this in ProjectSettings and ProjectLoad instead
2119          ReplaceSpaces(objDirExpNoSpaces, objDirExpNoSpaces);
2120          ReplaceSpaces(resDirNoSpaces, resNode.path ? resNode.path : "");
2121          ReplaceSpaces(fixedModuleName, moduleName);
2122          ReplaceSpaces(fixedConfigName, GetConfigName(config));
2123          CamelCase(fixedConfigName);
2124
2125          sameObjTargetDirs = !fstrcmp(objDirExpNoSpaces, targetDirExpNoSpaces);
2126
2127          f.Printf(".PHONY: all objdir%s clean realclean\n\n", sameObjTargetDirs ? "" : " targetdir");
2128
2129          f.Printf("# CONTENT\n\n");
2130
2131          f.Printf("MODULE := %s\n", fixedModuleName);
2132          //f.Printf("VERSION = %s\n", version);
2133          f.Printf("CONFIG := %s\n", fixedConfigName);
2134          f.Printf("ifndef COMPILER\n");
2135          f.Printf("COMPILER := default\n");
2136          f.Printf("endif\n");
2137          f.Printf("\n");
2138
2139          if(compilerConfigsDir && compilerConfigsDir[0])
2140          {
2141             strcpy(cfDir, compilerConfigsDir);
2142             if(cfDir && cfDir[0] && cfDir[strlen(cfDir)-1] != '/')
2143                strcat(cfDir, "/");
2144          }
2145          else
2146          {
2147             GetIDECompilerConfigsDir(cfDir, true, true);
2148             // Use CF_DIR environment variable for absolute paths only
2149             if(cfDir[0] == '/' || (cfDir[0] && cfDir[1] == ':'))
2150                strcpy(cfDir, "$(CF_DIR)");
2151          }
2152
2153          f.Printf("_CF_DIR = %s\n", cfDir);
2154          f.Printf("\n");
2155
2156          f.Printf("ifndef DEBUG\n");
2157          f.Printf("OPTIMIZE :=");
2158          switch(GetOptimization(config))
2159          {
2160             case speed:
2161                f.Printf(" -O2");
2162                f.Printf(" -ffast-math");
2163                break;
2164             case size:
2165                f.Printf(" -Os");
2166                break;
2167          }
2168          if(GetDebug(config))
2169             f.Printf(" -g");
2170          f.Printf("\n");
2171          f.Printf("else\n");
2172          f.Printf("OPTIMIZE := -g\n");
2173          f.Printf("NOSTRIP := y\n");
2174          f.Printf("endif\n");
2175
2176          test = GetTargetTypeIsSetByPlatform(config);
2177          if(test)
2178          {
2179             ifCount = 0;
2180             for(platform = (Platform)1; platform < Platform::enumSize; platform++)
2181             {
2182                TargetTypes targetType;
2183                PlatformOptions projectPOs, configPOs;
2184                MatchProjectAndConfigPlatformOptions(config, platform, &projectPOs, &configPOs);
2185                targetType = platformTargetType;
2186                if(targetType)
2187                {
2188                   if(ifCount)
2189                      f.Printf("else\n");
2190                   ifCount++;
2191                   f.Printf("ifeq \"$(PLATFORM)\" \"%s\"\n", (char *)platform); //%s\n", PlatformToMakefileVariable(platform));
2192
2193                   f.Printf("TARGET_TYPE = ");
2194                   f.Printf(TargetTypeToMakefileVariable(targetType));
2195                   f.Printf("\n");
2196                }
2197             }
2198             f.Printf("else\n"); // ifCount should always be > 0
2199          }
2200          f.Printf("TARGET_TYPE = ");
2201          f.Printf(TargetTypeToMakefileVariable(targetType));
2202          f.Printf("\n");
2203          if(test)
2204          {
2205             if(ifCount)
2206             {
2207                for(c = 0; c < ifCount; c++)
2208                   f.Printf("endif\n");
2209             }
2210          }
2211          f.Printf("\n");
2212
2213          f.Printf("ifeq \"$(TARGET_TYPE)\" \"%s\"\n", TargetTypeToMakefileVariable(executable));
2214          f.Printf("CONSOLE = %s\n", GetConsole(config) ? "-mconsole" : "-mwindows");
2215          f.Printf("endif\n\n");
2216
2217          f.Printf("# FLAGS\n\n");
2218
2219          f.Printf("CFLAGS =\n");
2220          f.Printf("CECFLAGS =\n");
2221          f.Printf("ECFLAGS =\n");
2222          f.Printf("OFLAGS =\n");
2223          f.Printf("LDFLAGS =\n");
2224          f.Printf("LIBS =\n");
2225          f.Printf("\n");
2226
2227          f.Printf("# INCLUDES\n\n");
2228
2229          f.Printf("include %s\n", includemkPath ? includemkPath : "$(_CF_DIR)crossplatform.mk");
2230          f.Printf("include $(_CF_DIR)$(PLATFORM)-$(COMPILER).cf\n");
2231          f.Printf("\n");
2232
2233          f.Printf("# VARIABLES\n\n");
2234
2235          f.Printf("OBJ = %s%s\n\n", objDirExpNoSpaces, objDirExpNoSpaces[0] ? "/" : "");
2236
2237          f.Printf("ifdef DEBUG\n");
2238          f.Printf("CFLAGS += -D_DEBUG\n");
2239          f.Printf("endif\n\n");
2240
2241          f.Printf("RES = %s%s\n\n", resDirNoSpaces, resDirNoSpaces[0] ? "/" : "");
2242
2243          // test = GetTargetTypeIsSetByPlatform(config);
2244          {
2245             char target[MAX_LOCATION];
2246             char targetNoSpaces[MAX_LOCATION];
2247          if(test)
2248          {
2249             TargetTypes type;
2250             ifCount = 0;
2251             for(type = (TargetTypes)1; type < TargetTypes::enumSize; type++)
2252             {
2253                if(type != targetType)
2254                {
2255                   if(ifCount)
2256                      f.Printf("else\n");
2257                   ifCount++;
2258                   f.Printf("ifeq \"$(TARGET_TYPE)\" \"%s\"\n", TargetTypeToMakefileVariable(type));
2259
2260                   GetMakefileTargetFileName(type, target, config);
2261                   strcpy(targetNoSpaces, targetDir);
2262                   PathCatSlash(targetNoSpaces, target);
2263                   ReplaceSpaces(targetNoSpaces, targetNoSpaces);
2264                   f.Printf("TARGET = %s\n", targetNoSpaces);
2265                }
2266             }
2267             f.Printf("else\n"); // ifCount should always be > 0
2268          }
2269          GetMakefileTargetFileName(targetType, target, config);
2270          strcpy(targetNoSpaces, targetDir);
2271          PathCatSlash(targetNoSpaces, target);
2272          ReplaceSpaces(targetNoSpaces, targetNoSpaces);
2273          f.Printf("TARGET = %s\n", targetNoSpaces);
2274
2275          if(test)
2276          {
2277             if(ifCount)
2278             {
2279                for(c = 0; c < ifCount; c++)
2280                   f.Printf("endif\n");
2281             }
2282          }
2283          }
2284          f.Printf("\n");
2285
2286          // Use something fixed here, to not cause Makefile differences across compilers...
2287          varStringLenDiffs["$(OBJ)"] = 30; // strlen("obj/memoryGuard.android.gcc-4.6.2") - 6;
2288          // varStringLenDiffs["$(OBJ)"] = strlen(objDirNoSpaces) - 6;
2289
2290          topNode.GenMakefileGetNameCollisionInfo(namesInfo, config);
2291
2292          numCObjects = topNode.GenMakefilePrintNode(f, this, objects, namesInfo, listItems, config, &containsCXX);
2293          if(numCObjects)
2294             listItems.Add(CopyString("$(OBJ)$(MODULE).main$(O)"));
2295          objectsParts = OutputFileList(f, "OBJECTS", listItems, varStringLenDiffs, null);
2296
2297          {
2298             int c;
2299             char * map[4][2] = { { "COBJECTS", "C" }, { "SYMBOLS", "S" }, { "IMPORTS", "I" }, { "BOWLS", "B" } };
2300
2301             topNode.GenMakefilePrintNode(f, this, eCsources, namesInfo, listItems, config, null);
2302             eCsourcesParts = OutputFileList(f, "_ECSOURCES", listItems, varStringLenDiffs, null);
2303
2304             f.Printf("ECSOURCES = $(call shwspace,$(_ECSOURCES))\n");
2305             if(eCsourcesParts > 1)
2306             {
2307                for(c = 1; c <= eCsourcesParts; c++)
2308                   f.Printf("ECSOURCES%d = $(call shwspace,$(_ECSOURCES%d))\n", c, c);
2309             }
2310             f.Printf("\n");
2311
2312             for(c = 0; c < 3; c++)
2313             {
2314                if(eCsourcesParts > 1)
2315                {
2316                   int n;
2317                   f.Printf("%s =", map[c][0]);
2318                   for(n = 1; n <= eCsourcesParts; n++)
2319                      f.Printf(" $(%s%d)", map[c][0], n);
2320                   f.Printf("\n");
2321                   for(n = 1; n <= eCsourcesParts; n++)
2322                      f.Printf("%s%d = $(call shwspace,$(addprefix $(OBJ),$(patsubst %%.ec,%%$(%s),$(notdir $(_ECSOURCES%d)))))\n", map[c][0], n, map[c][1], n);
2323                }
2324                else if(eCsourcesParts == 1)
2325                   f.Printf("%s = $(call shwspace,$(addprefix $(OBJ),$(patsubst %%.ec,%%$(%s),$(notdir $(_ECSOURCES)))))\n", map[c][0], map[c][1]);
2326                f.Printf("\n");
2327             }
2328          }
2329
2330          topNode.GenMakefilePrintNode(f, this, sources, null, listItems, config, null);
2331          OutputFileList(f, "SOURCES", listItems, varStringLenDiffs, "$(ECSOURCES)");
2332
2333          if(!noResources)
2334             resNode.GenMakefilePrintNode(f, this, resources, null, listItems, config, null);
2335          OutputFileList(f, "RESOURCES", listItems, varStringLenDiffs, null);
2336
2337          f.Printf("LIBS += $(SHAREDLIB) $(EXECUTABLE) $(LINKOPT)\n\n");
2338          if((config && config.options && config.options.libraries) ||
2339                (options && options.libraries))
2340          {
2341             f.Printf("ifneq \"$(TARGET_TYPE)\" \"%s\"\n", TargetTypeToMakefileVariable(staticLibrary));
2342             f.Printf("LIBS +=");
2343             if(config && config.options && config.options.libraries)
2344                OutputLibraries(f, config.options.libraries);
2345             else if(options && options.libraries)
2346                OutputLibraries(f, options.libraries);
2347             f.Printf("\n");
2348             f.Printf("endif\n");
2349             f.Printf("\n");
2350          }
2351
2352          if(platforms || (config && config.platforms))
2353          {
2354             ifCount = 0;
2355             //for(platform = firstPlatform; platform <= lastPlatform; platform++)
2356             //for(platform = win32; platform <= apple; platform++)
2357
2358             f.Printf("# PLATFORM-SPECIFIC OPTIONS\n\n");
2359             for(platform = (Platform)1; platform < Platform::enumSize; platform++)
2360             {
2361                PlatformOptions projectPlatformOptions, configPlatformOptions;
2362                MatchProjectAndConfigPlatformOptions(config, platform, &projectPlatformOptions, &configPlatformOptions);
2363
2364                if(projectPlatformOptions || configPlatformOptions)
2365                {
2366                   if(ifCount)
2367                      f.Printf("else\n");
2368                   ifCount++;
2369                   f.Printf("ifeq \"$(PLATFORM)\" \"");
2370                   // f.Printf(PlatformToMakefileVariable(platform));
2371                   f.Printf((char *)platform);
2372                   f.Printf("\"\n\n");
2373
2374                   if((projectPlatformOptions && projectPlatformOptions.options.preprocessorDefinitions && projectPlatformOptions.options.preprocessorDefinitions.count) ||
2375                      (configPlatformOptions && configPlatformOptions.options.preprocessorDefinitions && configPlatformOptions.options.preprocessorDefinitions.count) ||
2376                      (projectPlatformOptions && projectPlatformOptions.options.includeDirs && projectPlatformOptions.options.includeDirs.count) ||
2377                      (configPlatformOptions && configPlatformOptions.options.includeDirs && configPlatformOptions.options.includeDirs.count))
2378                   {
2379                      f.Printf("CFLAGS +=");
2380                      if(projectPlatformOptions && projectPlatformOptions.options.linkerOptions && projectPlatformOptions.options.linkerOptions.count)
2381                      {
2382                         f.Printf(" \\\n\t -Wl");
2383                         for(s : projectPlatformOptions.options.linkerOptions)
2384                            f.Printf(",%s", s);
2385                      }
2386                      if(configPlatformOptions && configPlatformOptions.options.linkerOptions && configPlatformOptions.options.linkerOptions.count)
2387                      {
2388                         f.Printf(" \\\n\t -Wl");
2389                         for(s : configPlatformOptions.options.linkerOptions)
2390                            f.Printf(",%s", s);
2391                      }
2392                      if(projectPlatformOptions && projectPlatformOptions.options.preprocessorDefinitions)
2393                         OutputListOption(f, "D", projectPlatformOptions.options.preprocessorDefinitions, newLine, false);
2394                      if(configPlatformOptions && configPlatformOptions.options.preprocessorDefinitions)
2395                         OutputListOption(f, "D", configPlatformOptions.options.preprocessorDefinitions, newLine, false );
2396                      if(configPlatformOptions && configPlatformOptions.options.includeDirs)
2397                         OutputListOption(f, "I", configPlatformOptions.options.includeDirs, lineEach, true);
2398                      if(projectPlatformOptions && projectPlatformOptions.options.includeDirs)
2399                         OutputListOption(f, "I", projectPlatformOptions.options.includeDirs, lineEach, true);
2400                      f.Printf("\n\n");
2401                   }
2402
2403                   if((projectPlatformOptions && projectPlatformOptions.options.libraryDirs && projectPlatformOptions.options.libraryDirs.count) ||
2404                         (configPlatformOptions && configPlatformOptions.options.libraryDirs && configPlatformOptions.options.libraryDirs.count) ||
2405                         (projectPlatformOptions && projectPlatformOptions.options.libraries && projectPlatformOptions.options.libraries.count) ||
2406                         (configPlatformOptions && configPlatformOptions.options.libraries && configPlatformOptions.options.libraries.count))
2407                   {
2408                      f.Printf("ifneq \"$(TARGET_TYPE)\" \"%s\"\n", TargetTypeToMakefileVariable(staticLibrary));
2409                      if((projectPlatformOptions && projectPlatformOptions.options.libraryDirs && projectPlatformOptions.options.libraryDirs.count) ||
2410                         (configPlatformOptions && configPlatformOptions.options.libraryDirs && configPlatformOptions.options.libraryDirs.count))
2411                      {
2412                         f.Printf("OFLAGS +=");
2413                         if(configPlatformOptions && configPlatformOptions.options.libraryDirs)
2414                            OutputListOption(f, "L", configPlatformOptions.options.libraryDirs, lineEach, true);
2415                         if(projectPlatformOptions && projectPlatformOptions.options.libraryDirs)
2416                            OutputListOption(f, "L", projectPlatformOptions.options.libraryDirs, lineEach, true);
2417                         f.Printf("\n");
2418                      }
2419
2420                      if((configPlatformOptions && configPlatformOptions.options.libraries))
2421                      {
2422                         if(configPlatformOptions.options.libraries.count)
2423                         {
2424                            f.Printf("LIBS +=");
2425                            OutputLibraries(f, configPlatformOptions.options.libraries);
2426                            f.Printf("\n");
2427                         }
2428                      }
2429                      else if(projectPlatformOptions && projectPlatformOptions.options.libraries)
2430                      {
2431                         if(projectPlatformOptions.options.libraries.count)
2432                         {
2433                            f.Printf("LIBS +=");
2434                            OutputLibraries(f, projectPlatformOptions.options.libraries);
2435                            f.Printf("\n");
2436                         }
2437                      }
2438                      f.Printf("endif\n\n");
2439                   }
2440                }
2441             }
2442             if(ifCount)
2443             {
2444                for(c = 0; c < ifCount; c++)
2445                   f.Printf("endif\n");
2446             }
2447             f.Printf("\n");
2448          }
2449
2450          f.Printf("CFLAGS +=");
2451          //if(gccCompiler)
2452          {
2453             f.Printf(" $(OPTIMIZE)");
2454             forceBitDepth = (options && options.buildBitDepth) || numCObjects;
2455             if(forceBitDepth)
2456                f.Printf(" %s",(!options || !options.buildBitDepth || options.buildBitDepth == bits32) ? "$(FORCE_32_BIT)" : "$(FORCE_64_BIT)");
2457             f.Printf(" $(FPIC)");
2458          }
2459          switch(GetWarnings(config))
2460          {
2461             case all: f.Printf(" -Wall"); break;
2462             case none: f.Printf(" -w"); break;
2463          }
2464          if(GetProfile(config))
2465             f.Printf(" -pg");
2466          if(options && options.linkerOptions && options.linkerOptions.count)
2467          {
2468             f.Printf(" \\\n\t -Wl");
2469             for(s : options.linkerOptions)
2470                f.Printf(",%s", s);
2471          }
2472
2473          if(options && options.preprocessorDefinitions)
2474             OutputListOption(f, "D", options.preprocessorDefinitions, newLine, false);
2475          if(config && config.options && config.options.preprocessorDefinitions)
2476             OutputListOption(f, "D", config.options.preprocessorDefinitions, newLine, false);
2477          if(config && config.options && config.options.includeDirs)
2478             OutputListOption(f, "I", config.options.includeDirs, lineEach, true);
2479          if(options && options.includeDirs)
2480             OutputListOption(f, "I", options.includeDirs, lineEach, true);
2481          f.Printf("\n\n");
2482
2483          f.Printf("CECFLAGS += -cpp $(call escspace,$(CPP)) -t $(PLATFORM)");
2484          f.Printf("\n\n");
2485
2486          f.Printf("ECFLAGS +=");
2487          if(GetMemoryGuard(config))
2488             f.Printf(" -memguard");
2489          if(GetStrictNameSpaces(config))
2490             f.Printf(" -strictns");
2491          if(GetNoLineNumbers(config))
2492             f.Printf(" -nolinenumbers");
2493          {
2494             char * s;
2495             if((s = GetDefaultNameSpace(config)) && s[0])
2496                f.Printf(" -defaultns %s", s);
2497          }
2498          f.Printf("\n\n");
2499
2500          f.Printf("ifneq \"$(TARGET_TYPE)\" \"%s\"\n", TargetTypeToMakefileVariable(staticLibrary));
2501          f.Printf("OFLAGS +=");
2502          if(forceBitDepth)
2503             f.Printf((!options || !options.buildBitDepth || options.buildBitDepth == bits32) ? " -m32" : " -m64 \\\n");
2504
2505          if(GetProfile(config))
2506             f.Printf(" -pg");
2507          if(config && config.options && config.options.libraryDirs)
2508             OutputListOption(f, "L", config.options.libraryDirs, lineEach, true);
2509          if(options && options.libraryDirs)
2510             OutputListOption(f, "L", options.libraryDirs, lineEach, true);
2511          f.Printf("\n");
2512          f.Printf("OFLAGS += $(LDFLAGS)\n");
2513          f.Printf("endif\n\n");
2514
2515          f.Printf("# TARGETS\n\n");
2516
2517          f.Printf("all: objdir%s $(TARGET)\n\n", sameObjTargetDirs ? "" : " targetdir");
2518
2519          f.Printf("objdir:\n");
2520             f.Printf("\t$(if $(wildcard $(OBJ)),,$(call mkdirq,$(OBJ)))\n");
2521          //f.Printf("# PRE-BUILD COMMANDS\n");
2522          if(options && options.prebuildCommands)
2523          {
2524             for(s : options.prebuildCommands)
2525                if(s && s[0]) f.Printf("\t%s\n", s);
2526          }
2527          if(config && config.options && config.options.prebuildCommands)
2528          {
2529             for(s : config.options.prebuildCommands)
2530                if(s && s[0]) f.Printf("\t%s\n", s);
2531          }
2532          if(platforms || (config && config.platforms))
2533          {
2534             ifCount = 0;
2535             //f.Printf("# PLATFORM-SPECIFIC PRE-BUILD COMMANDS\n");
2536             for(platform = (Platform)1; platform < Platform::enumSize; platform++)
2537             {
2538                PlatformOptions projectPOs, configPOs;
2539                MatchProjectAndConfigPlatformOptions(config, platform, &projectPOs, &configPOs);
2540
2541                if((projectPOs && projectPOs.options.prebuildCommands && projectPOs.options.prebuildCommands.count) ||
2542                      (configPOs && configPOs.options.prebuildCommands && configPOs.options.prebuildCommands.count))
2543                {
2544                   if(ifCount)
2545                      f.Printf("else\n");
2546                   ifCount++;
2547                   f.Printf("ifdef ");
2548                   f.Printf(PlatformToMakefileVariable(platform));
2549                   f.Printf("\n");
2550
2551                   if(projectPOs && projectPOs.options.prebuildCommands && projectPOs.options.prebuildCommands.count)
2552                   {
2553                      for(s : projectPOs.options.prebuildCommands)
2554                         if(s && s[0]) f.Printf("\t%s\n", s);
2555                   }
2556                   if(configPOs && configPOs.options.prebuildCommands && configPOs.options.prebuildCommands.count)
2557                   {
2558                      for(s : configPOs.options.prebuildCommands)
2559                         if(s && s[0]) f.Printf("\t%s\n", s);
2560                   }
2561                }
2562             }
2563             if(ifCount)
2564             {
2565                int c;
2566                for(c = 0; c < ifCount; c++)
2567                   f.Printf("endif\n");
2568             }
2569          }
2570          f.Printf("\n");
2571
2572          if(!sameObjTargetDirs)
2573          {
2574             f.Printf("targetdir:\n");
2575                f.Printf("\t$(if $(wildcard %s),,$(call mkdirq,%s))\n\n", targetDirExpNoSpaces, targetDirExpNoSpaces);
2576          }
2577
2578          if(numCObjects)
2579          {
2580             // Main Module (Linking) for ECERE C modules
2581             f.Printf("$(OBJ)$(MODULE).main.ec: $(SYMBOLS) $(COBJECTS)\n");
2582             // use of objDirExpNoSpaces used instead of $(OBJ) to prevent problematic joining of arguments in ecs
2583             f.Printf("\t$(ECS)%s $(ECSLIBOPT) $(SYMBOLS) $(IMPORTS) -symbols %s -o $(OBJ)$(MODULE).main.ec\n\n",
2584                GetConsole(config) ? " -console" : "", objDirExpNoSpaces);
2585             // Main Module (Linking) for ECERE C modules
2586             f.Printf("$(OBJ)$(MODULE).main.c: $(OBJ)$(MODULE).main.ec\n");
2587             f.Printf("\t$(ECP) $(CECFLAGS) $(ECFLAGS) $(CFLAGS)"
2588                   " -c $(OBJ)$(MODULE).main.ec -o $(OBJ)$(MODULE).main.sym -symbols $(OBJ)\n");
2589             f.Printf("\t$(ECC) $(CECFLAGS) $(ECFLAGS) $(CFLAGS) $(FVISIBILITY)"
2590                   " -c $(OBJ)$(MODULE).main.ec -o $(OBJ)$(MODULE).main.c -symbols $(OBJ)\n\n");
2591          }
2592
2593          // *** Target ***
2594
2595          // This would not rebuild the target on updated objects
2596          // f.Printf("$(TARGET): $(SOURCES) $(RESOURCES) | objdir $(SYMBOLS) $(OBJECTS)%s\n", sameObjTargetDirs ? "" : " targetdir");
2597
2598          // This should fix it for good!
2599          f.Printf("$(SYMBOLS): | objdir\n");
2600          f.Printf("$(OBJECTS): | objdir\n");
2601
2602          // This alone was breaking the tarball, object directory does not get created first (order-only rules happen last it seems!)
2603          f.Printf("$(TARGET): $(SOURCES) $(RESOURCES) $(SYMBOLS) $(OBJECTS) | objdir%s\n", sameObjTargetDirs ? "" : " targetdir");
2604
2605          f.Printf("ifneq \"$(TARGET_TYPE)\" \"%s\"\n", TargetTypeToMakefileVariable(staticLibrary));
2606          f.Printf("\t$(%s) $(OFLAGS) $(OBJECTS) $(LIBS) %s-o $(TARGET) $(INSTALLNAME)\n", containsCXX ? "CXX" : "CC", containsCXX ? "-lstdc++ " : "");
2607          if(!GetDebug(config))
2608          {
2609             f.Printf("ifndef NOSTRIP\n");
2610             f.Printf("\t$(STRIP) $(STRIPOPT) $(TARGET)\n");
2611             f.Printf("endif\n");
2612
2613             if(GetCompress(config))
2614             {
2615                f.Printf("ifndef WINDOWS\n");
2616                f.Printf("ifeq \"$(TARGET_TYPE)\" \"%s\"\n", TargetTypeToMakefileVariable(executable));
2617                   f.Printf("\t$(UPX) $(UPXFLAGS) $(TARGET)\n");
2618                f.Printf("endif\n");
2619                f.Printf("else\n");
2620                   f.Printf("\t$(UPX) $(UPXFLAGS) $(TARGET)\n");
2621                f.Printf("endif\n");
2622             }
2623          }
2624          if(resNode.files && resNode.files.count && !noResources)
2625             resNode.GenMakefileAddResources(f, resNode.path, config);
2626          f.Printf("else\n");
2627          f.Printf("\t$(AR) rcs $(TARGET) $(OBJECTS) $(LIBS)\n");
2628          f.Printf("endif\n");
2629
2630          //f.Printf("# POST-BUILD COMMANDS\n");
2631          if(options && options.postbuildCommands)
2632          {
2633             for(s : options.postbuildCommands)
2634                if(s && s[0]) f.Printf("\t%s\n", s);
2635          }
2636          if(config && config.options && config.options.postbuildCommands)
2637          {
2638             for(s : config.options.postbuildCommands)
2639                if(s && s[0]) f.Printf("\t%s\n", s);
2640          }
2641          if(platforms || (config && config.platforms))
2642          {
2643             ifCount = 0;
2644             //f.Printf("# PLATFORM-SPECIFIC POST-BUILD COMMANDS\n");
2645             for(platform = (Platform)1; platform < Platform::enumSize; platform++)
2646             {
2647                PlatformOptions projectPOs, configPOs;
2648                MatchProjectAndConfigPlatformOptions(config, platform, &projectPOs, &configPOs);
2649
2650                if((projectPOs && projectPOs.options.postbuildCommands && projectPOs.options.postbuildCommands.count) ||
2651                      (configPOs && configPOs.options.postbuildCommands && configPOs.options.postbuildCommands.count))
2652                {
2653                   if(ifCount)
2654                      f.Printf("else\n");
2655                   ifCount++;
2656                   f.Printf("ifdef ");
2657                   f.Printf(PlatformToMakefileVariable(platform));
2658                   f.Printf("\n");
2659
2660                   if(projectPOs && projectPOs.options.postbuildCommands && projectPOs.options.postbuildCommands.count)
2661                   {
2662                      for(s : projectPOs.options.postbuildCommands)
2663                         if(s && s[0]) f.Printf("\t%s\n", s);
2664                   }
2665                   if(configPOs && configPOs.options.postbuildCommands && configPOs.options.postbuildCommands.count)
2666                   {
2667                      for(s : configPOs.options.postbuildCommands)
2668                         if(s && s[0]) f.Printf("\t%s\n", s);
2669                   }
2670                }
2671             }
2672             if(ifCount)
2673             {
2674                int c;
2675                for(c = 0; c < ifCount; c++)
2676                   f.Printf("endif\n");
2677             }
2678          }
2679          f.Printf("\n");
2680
2681          f.Printf("# SYMBOL RULES\n\n");
2682          {
2683             Map<Platform, bool> excludedPlatforms { };
2684             topNode.GenMakefilePrintSymbolRules(f, this, config, excludedPlatforms);
2685             delete excludedPlatforms;
2686          }
2687
2688          f.Printf("# C OBJECT RULES\n\n");
2689          {
2690             Map<Platform, bool> excludedPlatforms { };
2691             topNode.GenMakefilePrintCObjectRules(f, this, config, excludedPlatforms);
2692             delete excludedPlatforms;
2693          }
2694
2695          f.Printf("# OBJECT RULES\n\n");
2696          // todo call this still but only generate rules whith specific options
2697          // see we-have-file-specific-options in ProjectNode.ec
2698          {
2699             Map<Platform, bool> excludedPlatforms { };
2700             topNode.GenMakefilePrintObjectRules(f, this, namesInfo, config, excludedPlatforms);
2701             delete excludedPlatforms;
2702          }
2703
2704          if(numCObjects)
2705             GenMakefilePrintMainObjectRule(f, config);
2706
2707          f.Printf("clean: objdir%s\n", sameObjTargetDirs ? "" : " targetdir");
2708          f.Printf("\t$(call rmq,%s$(TARGET))\n", numCObjects ? "$(OBJ)$(MODULE).main.c $(OBJ)$(MODULE).main.ec $(OBJ)$(MODULE).main$(I) $(OBJ)$(MODULE).main$(S) " : "");
2709          OutputCleanActions(f, "OBJECTS", objectsParts);
2710          if(numCObjects)
2711          {
2712             OutputCleanActions(f, "COBJECTS", eCsourcesParts);
2713             OutputCleanActions(f, "BOWLS", eCsourcesParts);
2714             OutputCleanActions(f, "IMPORTS", eCsourcesParts);
2715             OutputCleanActions(f, "SYMBOLS", eCsourcesParts);
2716          }
2717          f.Printf("\n");
2718
2719          f.Printf("realclean: clean\n");
2720          f.Printf("\t$(call rmrq,$(OBJ))\n");
2721          if(!sameObjTargetDirs)
2722             f.Printf("\t$(call rmdirq,%s)\n", targetDirExpNoSpaces);
2723          f.Printf("\n");
2724
2725          delete f;
2726
2727          listItems.Free();
2728          delete listItems;
2729          varStringLenDiffs.Free();
2730          delete varStringLenDiffs;
2731          namesInfo.Free();
2732          delete namesInfo;
2733
2734          result = true;
2735       }
2736
2737       // ChangeWorkingDir(oldDirectory);
2738       // delete pathBackup;
2739
2740       if(config)
2741          config.makingModified = false;
2742       return result;
2743    }
2744
2745    void GenMakefilePrintMainObjectRule(File f, ProjectConfig config)
2746    {
2747       char extension[MAX_EXTENSION] = "c";
2748       char modulePath[MAX_LOCATION];
2749       char fixedModuleName[MAX_FILENAME];
2750       DualPipe dep;
2751       char command[2048];
2752       char objDirNoSpaces[MAX_LOCATION];
2753       String objDirExp = GetObjDirExpression(config);
2754
2755       ReplaceSpaces(objDirNoSpaces, objDirExp);
2756       ReplaceSpaces(fixedModuleName, moduleName);
2757
2758       //sprintf(fixedModuleName, "%s.main", fixedPrjName);
2759       //strcat(fixedModuleName, ".main");
2760
2761 #if 0       // TODO: Fix nospaces stuff
2762       // *** Dependency command ***
2763       sprintf(command, "gcc -MT $(OBJ)%s$(O) -MM $(OBJ)%s.c", fixedModuleName, fixedModuleName);
2764
2765       // System Includes (from global settings)
2766       for(item : compiler.dirs[Includes])
2767       {
2768          strcat(command, " -isystem ");
2769          if(strchr(item.name, ' '))
2770          {
2771             strcat(command, "\"");
2772             strcat(command, item);
2773             strcat(command, "\"");
2774          }
2775          else
2776             strcat(command, item);
2777       }
2778
2779       for(item = includeDirs.first; item; item = item.next)
2780       {
2781          strcat(command, " -I");
2782          if(strchr(item.name, ' '))
2783          {
2784             strcat(command, "\"");
2785             strcat(command, item.name);
2786             strcat(command, "\"");
2787          }
2788          else
2789             strcat(command, item.name);
2790       }
2791       for(item = preprocessorDefs.first; item; item = item.next)
2792       {
2793          strcat(command, " -D");
2794          strcat(command, item.name);
2795       }
2796
2797       // Execute it
2798       if((dep = DualPipeOpen(PipeOpenMode { output = 1, error = 1, input = 2 }, command)))
2799       {
2800          char line[1024];
2801          bool result = true;
2802          bool firstLine = true;
2803
2804          // To do some time: auto save external dependencies?
2805          while(!dep.Eof())
2806          {
2807             if(dep.GetLine(line, sizeof(line)-1))
2808             {
2809                if(firstLine)
2810                {
2811                   char * colon = strstr(line, ":");
2812                   if(strstr(line, "No such file") || strstr(line, ",") || (colon && strstr(colon+1, ":")))
2813                   {
2814                      result = false;
2815                      break;
2816                   }
2817                   firstLine = false;
2818                }
2819                f.Puts(line);
2820                f.Puts("\n");
2821             }
2822             if(!result) break;
2823          }
2824          delete dep;
2825
2826          // If we failed to generate dependencies...
2827          if(!result)
2828          {
2829 #endif
2830             f.Printf("$(OBJ)$(MODULE).main$(O): $(OBJ)$(MODULE).main.c\n");
2831 #if 0
2832          }
2833       }
2834 #endif
2835
2836       f.Printf("\t$(CC) $(CFLAGS) $(FVISIBILITY) -c $(OBJ)$(MODULE).main.%s -o $(OBJ)$(MODULE).main$(O)\n\n", extension);
2837    }
2838
2839    void MatchProjectAndConfigPlatformOptions(ProjectConfig config, Platform platform,
2840          PlatformOptions * projectPlatformOptions, PlatformOptions * configPlatformOptions)
2841    {
2842       *projectPlatformOptions = null;
2843       *configPlatformOptions = null;
2844       if(platforms)
2845       {
2846          for(p : platforms)
2847          {
2848             if(!strcmpi(p.name, platform))
2849             {
2850                *projectPlatformOptions = p;
2851                break;
2852             }
2853          }
2854       }
2855       if(config && config.platforms)
2856       {
2857          for(p : config.platforms)
2858          {
2859             if(!strcmpi(p.name, platform))
2860             {
2861                *configPlatformOptions = p;
2862                break;
2863             }
2864          }
2865       }
2866    }
2867 }
2868
2869 Project LegacyBinaryLoadProject(File f, char * filePath)
2870 {
2871    Project project = null;
2872    char signature[sizeof(epjSignature)];
2873
2874    f.Read(signature, sizeof(signature), 1);
2875    if(!strncmp(signature, (char *)epjSignature, sizeof(epjSignature)))
2876    {
2877       char topNodePath[MAX_LOCATION];
2878       /*ProjectConfig newConfig
2879       {
2880          name = CopyString("Default");
2881          makingModified = true;
2882          compilingModified = true;
2883          linkingModified = true;
2884          options = { };
2885       };*/
2886
2887       project = Project { options = { } };
2888       LegacyBinaryLoadNode(project.topNode, f);
2889       delete project.topNode.path;
2890       GetWorkingDir(topNodePath, sizeof(topNodePath)-1);
2891       MakeSlashPath(topNodePath);
2892
2893       PathCatSlash(topNodePath, filePath);
2894       project.filePath = topNodePath;
2895
2896       /* THIS IS ALREADY DONE BY filePath property
2897       StripLastDirectory(topNodePath, topNodePath);
2898       project.topNode.path = CopyString(topNodePath);
2899       */
2900       // Shouldn't this be done BEFORE the StripLastDirectory? project.filePath = topNodePath;
2901
2902       // newConfig.options.defaultNameSpace = "";
2903       /*newConfig.objDir.dir = "obj";
2904       newConfig.targetDir.dir = "";*/
2905
2906       //project.configurations = { [ newConfig ] };
2907       //project.config = newConfig;
2908
2909       // Project Settings
2910       if(!f.Eof())
2911       {
2912          int temp;
2913          int len,c, count;
2914          String targetFileName, targetDirectory, objectsDirectory;
2915
2916          // { executable = 0, sharedLibrary = 1, staticLibrary = 2 };
2917          f.Read(&temp, sizeof(int),1);
2918          switch(temp)
2919          {
2920             case 0: project.options.targetType = executable; break;
2921             case 1: project.options.targetType = sharedLibrary; break;
2922             case 2: project.options.targetType = staticLibrary; break;
2923          }
2924
2925          f.Read(&len, sizeof(int),1);
2926          targetFileName = new char[len+1];
2927          f.Read(targetFileName, sizeof(char), len+1);
2928          project.options.targetFileName = targetFileName;
2929          delete targetFileName;
2930
2931          f.Read(&len, sizeof(int),1);
2932          targetDirectory = new char[len+1];
2933          f.Read(targetDirectory, sizeof(char), len+1);
2934          project.options.targetDirectory = targetDirectory;
2935          delete targetDirectory;
2936
2937          f.Read(&len, sizeof(int),1);
2938          objectsDirectory = new byte[len+1];
2939          f.Read(objectsDirectory, sizeof(char), len+1);
2940          project.options.objectsDirectory = objectsDirectory;
2941          delete objectsDirectory;
2942
2943          f.Read(&temp, sizeof(int),1);
2944          project./*config.*/options.debug = temp ? true : false;
2945          f.Read(&temp, sizeof(int),1);
2946          project./*config.*/options.optimization = temp ? speed : none;
2947          f.Read(&temp, sizeof(int),1);
2948          project./*config.*/options.profile = temp ? true : false;
2949          f.Read(&temp, sizeof(int),1);
2950          project.options.warnings = temp ? all : unset;
2951
2952          f.Read(&count, sizeof(int),1);
2953          if(count)
2954          {
2955             project.options.includeDirs = { };
2956             for(c = 0; c < count; c++)
2957             {
2958                char * name;
2959                f.Read(&len, sizeof(int),1);
2960                name = new char[len+1];
2961                f.Read(name, sizeof(char), len+1);
2962                project.options.includeDirs.Add(name);
2963             }
2964          }
2965
2966          f.Read(&count, sizeof(int),1);
2967          if(count)
2968          {
2969             project.options.libraryDirs = { };
2970             for(c = 0; c < count; c++)
2971             {
2972                char * name;
2973                f.Read(&len, sizeof(int),1);
2974                name = new char[len+1];
2975                f.Read(name, sizeof(char), len+1);
2976                project.options.libraryDirs.Add(name);
2977             }
2978          }
2979
2980          f.Read(&count, sizeof(int),1);
2981          if(count)
2982          {
2983             project.options.libraries = { };
2984             for(c = 0; c < count; c++)
2985             {
2986                char * name;
2987                f.Read(&len, sizeof(int),1);
2988                name = new char[len+1];
2989                f.Read(name, sizeof(char), len+1);
2990                project.options.libraries.Add(name);
2991             }
2992          }
2993
2994          f.Read(&count, sizeof(int),1);
2995          if(count)
2996          {
2997             project.options.preprocessorDefinitions = { };
2998             for(c = 0; c < count; c++)
2999             {
3000                char * name;
3001                f.Read(&len, sizeof(int),1);
3002                name = new char[len+1];
3003                f.Read(name, sizeof(char), len+1);
3004                project.options.preprocessorDefinitions.Add(name);
3005             }
3006          }
3007
3008          f.Read(&temp, sizeof(int),1);
3009          project.options.console = temp ? true : false;
3010       }
3011
3012       for(node : project.topNode.files)
3013       {
3014          if(node.type == resources)
3015          {
3016             project.resNode = node;
3017             break;
3018          }
3019       }
3020    }
3021    else
3022       f.Seek(0, start);
3023    return project;
3024 }
3025
3026 void ProjectConfig::LegacyProjectConfigLoad(File f)
3027 {
3028    delete options;
3029    options = { };
3030    while(!f.Eof())
3031    {
3032       char buffer[65536];
3033       char section[128];
3034       char subSection[128];
3035       char * equal;
3036       int len;
3037       uint pos;
3038
3039       pos = f.Tell();
3040       f.GetLine(buffer, 65536 - 1);
3041       TrimLSpaces(buffer, buffer);
3042       TrimRSpaces(buffer, buffer);
3043       if(strlen(buffer))
3044       {
3045          if(buffer[0] == '-')
3046          {
3047             equal = &buffer[0];
3048             equal[0] = ' ';
3049             TrimLSpaces(equal, equal);
3050             if(!strcmpi(subSection, "LibraryDirs"))
3051             {
3052                if(!options.libraryDirs)
3053                   options.libraryDirs = { [ CopyString(equal) ] };
3054                else
3055                   options.libraryDirs.Add(CopyString(equal));
3056             }
3057             else if(!strcmpi(subSection, "IncludeDirs"))
3058             {
3059                if(!options.includeDirs)
3060                   options.includeDirs = { [ CopyString(equal) ] };
3061                else
3062                   options.includeDirs.Add(CopyString(equal));
3063             }
3064          }
3065          else if(buffer[0] == '+')
3066          {
3067             if(name)
3068             {
3069                f.Seek(pos, start);
3070                break;
3071             }
3072             else
3073             {
3074                equal = &buffer[0];
3075                equal[0] = ' ';
3076                TrimLSpaces(equal, equal);
3077                delete name; name = CopyString(equal); // property::name = equal;
3078             }
3079          }
3080          else if(!strcmpi(buffer, "Compiler Options"))
3081             strcpy(section, buffer);
3082          else if(!strcmpi(buffer, "IncludeDirs"))
3083             strcpy(subSection, buffer);
3084          else if(!strcmpi(buffer, "Linker Options"))
3085             strcpy(section, buffer);
3086          else if(!strcmpi(buffer, "LibraryDirs"))
3087             strcpy(subSection, buffer);
3088          else if(!strcmpi(buffer, "Files") || !strcmpi(buffer, "Resources"))
3089          {
3090             f.Seek(pos, start);
3091             break;
3092          }
3093          else
3094          {
3095             equal = strstr(buffer, "=");
3096             if(equal)
3097             {
3098                equal[0] = '\0';
3099                TrimRSpaces(buffer, buffer);
3100                equal++;
3101                TrimLSpaces(equal, equal);
3102                if(!strcmpi(buffer, "Target Name"))
3103                   options.targetFileName = /*CopyString(*/equal/*)*/;
3104                else if(!strcmpi(buffer, "Target Type"))
3105                {
3106                   if(!strcmpi(equal, "Executable"))
3107                      options.targetType = executable;
3108                   else if(!strcmpi(equal, "Shared"))
3109                      options.targetType = sharedLibrary;
3110                   else if(!strcmpi(equal, "Static"))
3111                      options.targetType = staticLibrary;
3112                   else
3113                      options.targetType = executable;
3114                }
3115                else if(!strcmpi(buffer, "Target Directory"))
3116                   options.targetDirectory = /*CopyString(*/equal/*)*/;
3117                else if(!strcmpi(buffer, "Console"))
3118                   options.console = ParseTrueFalseValue(equal);
3119                else if(!strcmpi(buffer, "Libraries"))
3120                {
3121                   if(!options.libraries) options.libraries = { };
3122                   ParseArrayValue(options.libraries, equal);
3123                }
3124                else if(!strcmpi(buffer, "Intermediate Directory"))
3125                   options.objectsDirectory = /*CopyString(*/equal/*)*/; //objDir.expression = equal;
3126                else if(!strcmpi(buffer, "Debug"))
3127                   options.debug = ParseTrueFalseValue(equal);
3128                else if(!strcmpi(buffer, "Optimize"))
3129                {
3130                   if(!strcmpi(equal, "None"))
3131                      options.optimization = none;
3132                   else if(!strcmpi(equal, "Speed") || !strcmpi(equal, "True"))
3133                      options.optimization = speed;
3134                   else if(!strcmpi(equal, "Size"))
3135                      options.optimization = size;
3136                   else
3137                      options.optimization = none;
3138                }
3139                else if(!strcmpi(buffer, "Compress"))
3140                   options.compress = ParseTrueFalseValue(equal);
3141                else if(!strcmpi(buffer, "Profile"))
3142                   options.profile = ParseTrueFalseValue(equal);
3143                else if(!strcmpi(buffer, "AllWarnings"))
3144                   options.warnings = ParseTrueFalseValue(equal) ? all : unset;
3145                else if(!strcmpi(buffer, "MemoryGuard"))
3146                   options.memoryGuard = ParseTrueFalseValue(equal);
3147                else if(!strcmpi(buffer, "Default Name Space"))
3148                   options.defaultNameSpace = CopyString(equal);
3149                else if(!strcmpi(buffer, "Strict Name Spaces"))
3150                   options.strictNameSpaces = ParseTrueFalseValue(equal);
3151                else if(!strcmpi(buffer, "Preprocessor Definitions"))
3152                {
3153                   if(!options.preprocessorDefinitions) options.preprocessorDefinitions = { };
3154                   ParseArrayValue(options.preprocessorDefinitions, equal);
3155                }
3156             }
3157          }
3158       }
3159    }
3160    if(!options.targetDirectory && options.objectsDirectory)
3161       options.targetDirectory = /*CopyString(*/options.objectsDirectory/*)*/;
3162    //if(!objDir.dir) objDir.dir = "obj";
3163    //if(!targetDir.dir) targetDir.dir = "";
3164    // if(!targetName) property::targetName = "";   // How can a targetFileName be nothing???
3165    // if(!defaultNameSpace) property::defaultNameSpace = "";
3166    makingModified = true;
3167 }
3168
3169 Project LegacyAsciiLoadProject(File f, char * filePath)
3170 {
3171    Project project = null;
3172    ProjectNode node = null;
3173    int pos;
3174    char parentPath[MAX_LOCATION];
3175    char section[128] = "";
3176    char subSection[128] = "";
3177    ProjectNode parent;
3178    bool configurationsPresent = false;
3179
3180    f.Seek(0, start);
3181    while(!f.Eof())
3182    {
3183       char buffer[65536];
3184       //char version[16];
3185       char * equal;
3186       int len;
3187       pos = f.Tell();
3188       f.GetLine(buffer, 65536 - 1);
3189       TrimLSpaces(buffer, buffer);
3190       TrimRSpaces(buffer, buffer);
3191       if(strlen(buffer))
3192       {
3193          if(buffer[0] == '-' || buffer[0] == '=')
3194          {
3195             bool simple = buffer[0] == '-';
3196             equal = &buffer[0];
3197             equal[0] = ' ';
3198             TrimLSpaces(equal, equal);
3199             if(!strcmpi(section, "Target") && !strcmpi(subSection, "LibraryDirs"))
3200             {
3201                if(!project.config.options.libraryDirs)
3202                   project.config.options.libraryDirs = { [ CopyString(equal) ] };
3203                else
3204                   project.config.options.libraryDirs.Add(CopyString(equal));
3205             }
3206             else if(!strcmpi(section, "Target") && !strcmpi(subSection, "IncludeDirs"))
3207             {
3208                if(!project.config.options.includeDirs)
3209                   project.config.options.includeDirs = { [ CopyString(equal) ] };
3210                else
3211                   project.config.options.includeDirs.Add(CopyString(equal));
3212             }
3213             else if(!strcmpi(section, "Target") && (!strcmpi(subSection, "Files") || !strcmpi(subSection, "Resources")))
3214             {
3215                len = strlen(equal);
3216                if(len)
3217                {
3218                   char temp[MAX_LOCATION];
3219                   ProjectNode child { };
3220                   // We don't need to do this anymore, fileName is just a property that sets name & path
3221                   // child.fileName = CopyString(equal);
3222                   if(simple)
3223                   {
3224                      child.name = CopyString(equal);
3225                      child.path = CopyString(parentPath);
3226                   }
3227                   else
3228                   {
3229                      GetLastDirectory(equal, temp);
3230                      child.name = CopyString(temp);
3231                      StripLastDirectory(equal, temp);
3232                      child.path = CopyString(temp);
3233                   }
3234                   child.nodeType = file;
3235                   child.parent = parent;
3236                   child.indent = parent.indent + 1;
3237                   child.type = file;
3238                   child.icon = NodeIcons::SelectFileIcon(child.name);
3239                   parent.files.Add(child);
3240                   node = child;
3241                   //child = null;
3242                }
3243                else
3244                {
3245                   StripLastDirectory(parentPath, parentPath);
3246                   parent = parent.parent;
3247                }
3248             }
3249          }
3250          else if(buffer[0] == '+')
3251          {
3252             equal = &buffer[0];
3253             equal[0] = ' ';
3254             TrimLSpaces(equal, equal);
3255             if(!strcmpi(section, "Target") && (!strcmpi(subSection, "Files") || !strcmpi(subSection, "Resources")))
3256             {
3257                char temp[MAX_LOCATION];
3258                ProjectNode child { };
3259                // NEW: Folders now have a path set like files
3260                child.name = CopyString(equal);
3261                strcpy(temp, parentPath);
3262                PathCatSlash(temp, child.name);
3263                child.path = CopyString(temp);
3264
3265                child.parent = parent;
3266                child.indent = parent.indent + 1;
3267                child.type = folder;
3268                child.nodeType = folder;
3269                child.files = { };
3270                child.icon = folder;
3271                PathCatSlash(parentPath, child.name);
3272                parent.files.Add(child);
3273                parent = child;
3274                node = child;
3275                //child = null;
3276             }
3277             else if(!strcmpi(section, "Configurations"))
3278             {
3279                ProjectConfig newConfig
3280                {
3281                   makingModified = true;
3282                   options = { };
3283                };
3284                f.Seek(pos, start);
3285                LegacyProjectConfigLoad(newConfig, f);
3286                project.configurations.Add(newConfig);
3287             }
3288          }
3289          else if(!strcmpi(buffer, "ECERE Project File"));
3290          else if(!strcmpi(buffer, "Version 0a"))
3291             ; //strcpy(version, "0a");
3292          else if(!strcmpi(buffer, "Version 0.1a"))
3293             ; //strcpy(version, "0.1a");
3294          else if(!strcmpi(buffer, "Configurations"))
3295          {
3296             project.configurations.Free();
3297             project.config = null;
3298             strcpy(section, buffer);
3299             configurationsPresent = true;
3300          }
3301          else if(!strcmpi(buffer, "Target") || !strnicmp(buffer, "Target \"", strlen("Target \"")))
3302          {
3303             ProjectConfig newConfig { name = CopyString("Default"), options = { } };
3304             char topNodePath[MAX_LOCATION];
3305             // newConfig.defaultNameSpace = "";
3306             //newConfig.objDir.dir = "obj";
3307             //newConfig.targetDir.dir = "";
3308             project = Project { /*options = { }*/ };
3309             project.configurations = { [ newConfig ] };
3310             project.config = newConfig;
3311             // if(project.topNode.path) delete project.topNode.path;
3312             GetWorkingDir(topNodePath, sizeof(topNodePath)-1);
3313             MakeSlashPath(topNodePath);
3314             PathCatSlash(topNodePath, filePath);
3315             project.filePath = topNodePath;
3316             parentPath[0] = '\0';
3317             parent = project.topNode;
3318             node = parent;
3319             strcpy(section, "Target");
3320             equal = &buffer[6];
3321             if(equal[0] == ' ')
3322             {
3323                equal++;
3324                if(equal[0] == '\"')
3325                {
3326                   StripQuotes(equal, equal);
3327                   delete project.moduleName; project.moduleName = CopyString(equal);
3328                }
3329             }
3330          }
3331          else if(!strcmpi(buffer, "Compiler Options"));
3332          else if(!strcmpi(buffer, "IncludeDirs"))
3333             strcpy(subSection, buffer);
3334          else if(!strcmpi(buffer, "Linker Options"));
3335          else if(!strcmpi(buffer, "LibraryDirs"))
3336             strcpy(subSection, buffer);
3337          else if(!strcmpi(buffer, "Files"))
3338          {
3339             strcpy(section, "Target");
3340             strcpy(subSection, buffer);
3341          }
3342          else if(!strcmpi(buffer, "Resources"))
3343          {
3344             ProjectNode child { };
3345             parent.files.Add(child);
3346             child.parent = parent;
3347             child.indent = parent.indent + 1;
3348             child.name = CopyString(buffer);
3349             child.path = CopyString("");
3350             child.type = resources;
3351             child.files = { };
3352             child.icon = archiveFile;
3353             project.resNode = child;
3354             parent = child;
3355             node = child;
3356             strcpy(subSection, buffer);
3357          }
3358          else
3359          {
3360             equal = strstr(buffer, "=");
3361             if(equal)
3362             {
3363                equal[0] = '\0';
3364                TrimRSpaces(buffer, buffer);
3365                equal++;
3366                TrimLSpaces(equal, equal);
3367
3368                if(!strcmpi(section, "Target"))
3369                {
3370                   if(!strcmpi(buffer, "Build Exclusions"))
3371                   {
3372                      if(!strcmpi(section, "Target") && !strcmpi(subSection, "Files"))
3373                      {
3374                         /*if(node && node.type != NodeTypes::project)
3375                            ParseListValue(node.buildExclusions, equal);*/
3376                      }
3377                   }
3378                   else if(!strcmpi(buffer, "Path") && !strcmpi(subSection, "Resources"))
3379                   {
3380                      delete project.resNode.path;
3381                      project.resNode.path = CopyString(equal);
3382                      PathCatSlash(parentPath, equal);
3383                   }
3384
3385                   // Config Settings
3386                   else if(!strcmpi(buffer, "Intermediate Directory"))
3387                      project.config.options.objectsDirectory = /*CopyString(*/equal/*)*/; //objDir.expression = equal;
3388                   else if(!strcmpi(buffer, "Debug"))
3389                      project.config.options.debug = ParseTrueFalseValue(equal);
3390                   else if(!strcmpi(buffer, "Optimize"))
3391                   {
3392                      if(!strcmpi(equal, "None"))
3393                         project.config.options.optimization = none;
3394                      else if(!strcmpi(equal, "Speed") || !strcmpi(equal, "True"))
3395                         project.config.options.optimization = speed;
3396                      else if(!strcmpi(equal, "Size"))
3397                         project.config.options.optimization = size;
3398                      else
3399                         project.config.options.optimization = none;
3400                   }
3401                   else if(!strcmpi(buffer, "Profile"))
3402                      project.config.options.profile = ParseTrueFalseValue(equal);
3403                   else if(!strcmpi(buffer, "MemoryGuard"))
3404                      project.config.options.memoryGuard = ParseTrueFalseValue(equal);
3405                   else
3406                   {
3407                      if(!project.options) project.options = { };
3408
3409                      // Project Wide Settings (All configs)
3410                      if(!strcmpi(buffer, "Target Name"))
3411                         project.options.targetFileName = /*CopyString(*/equal/*)*/;
3412                      else if(!strcmpi(buffer, "Target Type"))
3413                      {
3414                         if(!strcmpi(equal, "Executable"))
3415                            project.options.targetType = executable;
3416                         else if(!strcmpi(equal, "Shared"))
3417                            project.options.targetType = sharedLibrary;
3418                         else if(!strcmpi(equal, "Static"))
3419                            project.options.targetType = staticLibrary;
3420                         else
3421                            project.options.targetType = executable;
3422                      }
3423                      else if(!strcmpi(buffer, "Target Directory"))
3424                         project.options.targetDirectory = /*CopyString(*/equal/*)*/;
3425                      else if(!strcmpi(buffer, "Console"))
3426                         project.options.console = ParseTrueFalseValue(equal);
3427                      else if(!strcmpi(buffer, "Libraries"))
3428                      {
3429                         if(!project.options.libraries) project.options.libraries = { };
3430                         ParseArrayValue(project.options.libraries, equal);
3431                      }
3432                      else if(!strcmpi(buffer, "AllWarnings"))
3433                         project.options.warnings = ParseTrueFalseValue(equal) ? all : unset;
3434                      else if(!strcmpi(buffer, "Preprocessor Definitions"))
3435                      {
3436                         if(!strcmpi(section, "Target") && !strcmpi(subSection, "Files"))
3437                         {
3438                            /*if(node && (node.type == NodeTypes::project || (node.type == file && !node.isInResources) || node.type == folder))
3439                               ParseListValue(node.preprocessorDefs, equal);*/
3440                         }
3441                         else
3442                         {
3443                            if(!project.options.preprocessorDefinitions) project.options.preprocessorDefinitions = { };
3444                            ParseArrayValue(project.options.preprocessorDefinitions, equal);
3445                         }
3446                      }
3447                   }
3448                }
3449             }
3450          }
3451       }
3452    }
3453    parent = null;
3454
3455    SplitPlatformLibraries(project);
3456
3457    if(configurationsPresent)
3458       CombineIdenticalConfigOptions(project);
3459    return project;
3460 }
3461
3462 void SplitPlatformLibraries(Project project)
3463 {
3464    if(project && project.configurations)
3465    {
3466       for(cfg : project.configurations)
3467       {
3468          if(cfg.options.libraries && cfg.options.libraries.count)
3469          {
3470             Iterator<String> it { cfg.options.libraries };
3471             while(it.Next())
3472             {
3473                String l = it.data;
3474                char * platformName = strstr(l, ":");
3475                if(platformName)
3476                {
3477                   PlatformOptions platform = null;
3478                   platformName++;
3479                   if(!cfg.platforms) cfg.platforms = { };
3480                   for(p : cfg.platforms)
3481                   {
3482                      if(!strcmpi(platformName, p.name))
3483                      {
3484                         platform = p;
3485                         break;
3486                      }
3487                   }
3488                   if(!platform)
3489                   {
3490                      platform = { name = CopyString(platformName), options = { libraries = { } } };
3491                      cfg.platforms.Add(platform);
3492                   }
3493                   *(platformName-1) = 0;
3494                   platform.options.libraries.Add(CopyString(l));
3495
3496                   cfg.options.libraries.Delete(it.pointer);
3497                   it.pointer = null;
3498                }
3499             }
3500          }
3501       }
3502    }
3503 }
3504
3505 void CombineIdenticalConfigOptions(Project project)
3506 {
3507    if(project && project.configurations && project.configurations.count)
3508    {
3509       DataMember member;
3510       ProjectOptions nullOptions { };
3511       ProjectConfig firstConfig = null;
3512       for(cfg : project.configurations)
3513       {
3514          if(cfg.options.targetType != staticLibrary)
3515          {
3516             firstConfig = cfg;
3517             break;
3518          }
3519       }
3520       if(!firstConfig)
3521          firstConfig = project.configurations.firstIterator.data;
3522
3523       for(member = class(ProjectOptions).membersAndProperties.first; member; member = member.next)
3524       {
3525          if(!member.isProperty)
3526          {
3527             Class type = eSystem_FindClass(__thisModule, member.dataTypeString);
3528             if(type)
3529             {
3530                bool same = true;
3531
3532                for(cfg : project.configurations)
3533                {
3534                   if(cfg != firstConfig)
3535                   {
3536                      if(cfg.options.targetType != staticLibrary)
3537                      {
3538                         int result;
3539
3540                         if(type.type == noHeadClass || type.type == normalClass)
3541                         {
3542                            result = type._vTbl[__ecereVMethodID_class_OnCompare](type,
3543                               *(void **)((byte *)firstConfig.options + member.offset + member._class.offset),
3544                               *(void **)((byte *)cfg.options         + member.offset + member._class.offset));
3545                         }
3546                         else
3547                         {
3548                            result = type._vTbl[__ecereVMethodID_class_OnCompare](type,
3549                               (byte *)firstConfig.options + member.offset + member._class.offset,
3550                               (byte *)cfg.options         + member.offset + member._class.offset);
3551                         }
3552                         if(result)
3553                         {
3554                            same = false;
3555                            break;
3556                         }
3557                      }
3558                   }
3559                }
3560                if(same)
3561                {
3562                   if(type.type == noHeadClass || type.type == normalClass)
3563                   {
3564                      if(!type._vTbl[__ecereVMethodID_class_OnCompare](type,
3565                         *(void **)((byte *)firstConfig.options + member.offset + member._class.offset),
3566                         *(void **)((byte *)nullOptions         + member.offset + member._class.offset)))
3567                         continue;
3568                   }
3569                   else
3570                   {
3571                      if(!type._vTbl[__ecereVMethodID_class_OnCompare](type,
3572                         (byte *)firstConfig.options + member.offset + member._class.offset,
3573                         (byte *)nullOptions         + member.offset + member._class.offset))
3574                         continue;
3575                   }
3576
3577                   if(!project.options) project.options = { };
3578
3579                   /*if(type.type == noHeadClass || type.type == normalClass)
3580                   {
3581                      type._vTbl[__ecereVMethodID_class_OnCopy](type,
3582                         (byte *)project.options + member.offset + member._class.offset,
3583                         *(void **)((byte *)firstConfig.options + member.offset + member._class.offset));
3584                   }
3585                   else
3586                   {
3587                      void * address = (byte *)firstConfig.options + member.offset + member._class.offset;
3588                      // TOFIX: ListBox::SetData / OnCopy mess
3589                      type._vTbl[__ecereVMethodID_class_OnCopy](type,
3590                         (byte *)project.options + member.offset + member._class.offset,
3591                         (type.typeSize > 4) ? address :
3592                            ((type.typeSize == 4) ? (void *)*(uint32 *)address :
3593                               ((type.typeSize == 2) ? (void *)*(uint16*)address :
3594                                  (void *)*(byte *)address )));
3595                   }*/
3596                   memcpy(
3597                      (byte *)project.options + member.offset + member._class.offset,
3598                      (byte *)firstConfig.options + member.offset + member._class.offset, type.typeSize);
3599
3600                   for(cfg : project.configurations)
3601                   {
3602                      if(cfg.options.targetType == staticLibrary)
3603                      {
3604                         int result;
3605
3606                         if(type.type == noHeadClass || type.type == normalClass)
3607                         {
3608                            result = type._vTbl[__ecereVMethodID_class_OnCompare](type,
3609                               *(void **)((byte *)firstConfig.options + member.offset + member._class.offset),
3610                               *(void **)((byte *)cfg.options         + member.offset + member._class.offset));
3611                         }
3612                         else
3613                         {
3614                            result = type._vTbl[__ecereVMethodID_class_OnCompare](type,
3615                               (byte *)firstConfig.options + member.offset + member._class.offset,
3616                               (byte *)cfg.options         + member.offset + member._class.offset);
3617                         }
3618                         if(result)
3619                            continue;
3620                      }
3621                      if(cfg != firstConfig)
3622                      {
3623                         if(type.type == noHeadClass || type.type == normalClass)
3624                         {
3625                            type._vTbl[__ecereVMethodID_class_OnFree](type,
3626                               *(void **)((byte *)cfg.options + member.offset + member._class.offset));
3627                         }
3628                         else
3629                         {
3630                            type._vTbl[__ecereVMethodID_class_OnFree](type,
3631                               (byte *)cfg.options + member.offset + member._class.offset);
3632                         }
3633                         memset((byte *)cfg.options + member.offset + member._class.offset, 0, type.typeSize);
3634                      }
3635                   }
3636                   memset((byte *)firstConfig.options + member.offset + member._class.offset, 0, type.typeSize);
3637                }
3638             }
3639          }
3640       }
3641       delete nullOptions;
3642
3643       // Compare Platform Specific Settings
3644       {
3645          bool same = true;
3646          for(cfg : project.configurations)
3647          {
3648             if(cfg != firstConfig && cfg.options.targetType != staticLibrary && (firstConfig.platforms || cfg.platforms) &&
3649                ((!firstConfig.platforms && cfg.platforms) || firstConfig.platforms.OnCompare(cfg.platforms)))
3650             {
3651                same = false;
3652                break;
3653             }
3654          }
3655          if(same && firstConfig.platforms)
3656          {
3657             for(cfg : project.configurations)
3658             {
3659                if(cfg.options.targetType == staticLibrary && firstConfig.platforms.OnCompare(cfg.platforms))
3660                   continue;
3661                if(cfg != firstConfig)
3662                {
3663                   cfg.platforms.Free();
3664                   delete cfg.platforms;
3665                }
3666             }
3667             project.platforms = firstConfig.platforms;
3668             firstConfig.platforms = null;
3669          }
3670       }
3671
3672       // Static libraries can't contain libraries
3673       for(cfg : project.configurations)
3674       {
3675          if(cfg.options.targetType == staticLibrary)
3676          {
3677             if(!cfg.options.libraries) cfg.options.libraries = { };
3678             cfg.options.libraries.Free();
3679          }
3680       }
3681    }
3682 }
3683
3684 Project LoadProject(char * filePath)
3685 {
3686    Project project = null;
3687    File f = FileOpen(filePath, read);
3688    if(f)
3689    {
3690       project = LegacyBinaryLoadProject(f, filePath);
3691       if(!project)
3692       {
3693          JSONParser parser { f = f };
3694          JSONResult result = parser.GetObject(class(Project), &project);
3695          if(project)
3696          {
3697             char insidePath[MAX_LOCATION];
3698
3699             delete project.topNode.files;
3700             if(!project.files) project.files = { };
3701             project.topNode.files = project.files;
3702             project.resNode = project.topNode.Add(project, "Resources", project.topNode.files.last, resources, archiveFile, false);
3703             delete project.resNode.path;
3704             project.resNode.path = project.resourcesPath;
3705             project.resourcesPath = null;
3706             project.resNode.nodeType = (ProjectNodeType)-1;
3707             delete project.resNode.files;
3708             project.resNode.files = project.resources;
3709             project.files = null;
3710             project.resources = null;
3711             if(!project.configurations) project.configurations = { };
3712
3713             {
3714                char topNodePath[MAX_LOCATION];
3715                GetWorkingDir(topNodePath, sizeof(topNodePath)-1);
3716                MakeSlashPath(topNodePath);
3717                PathCatSlash(topNodePath, filePath);
3718                project.filePath = topNodePath;//filePath;
3719             }
3720
3721             project.topNode.FixupNode(insidePath);
3722          }
3723          delete parser;
3724       }
3725       if(!project)
3726          project = LegacyAsciiLoadProject(f, filePath);
3727
3728       delete f;
3729
3730       if(project)
3731       {
3732          if(!project.options) project.options = { };
3733          if(!project.config && project.configurations)
3734             project.config = project.configurations.firstIterator.data;
3735
3736          if(!project.resNode)
3737          {
3738             project.resNode = project.topNode.Add(project, "Resources", project.topNode.files.last, resources, archiveFile, false);
3739          }
3740
3741          if(!project.moduleName)
3742             project.moduleName = CopyString(project.name);
3743          if(project.config &&
3744             (!project.options || !project.options.targetFileName || !project.options.targetFileName[0]) &&
3745             (!project.config.options.targetFileName || !project.config.options.targetFileName[0]))
3746          {
3747             //delete project.config.options.targetFileName;
3748
3749             project.options.targetFileName = /*CopyString(*/project.moduleName/*)*/;
3750             project.config.options.optimization = none;
3751             project.config.options.debug = true;
3752             //project.config.options.warnings = unset;
3753             project.config.options.memoryGuard = false;
3754             project.config.compilingModified = true;
3755             project.config.linkingModified = true;
3756          }
3757          else if(!project.topNode.name && project.config)
3758          {
3759             project.topNode.name = CopyString(project.config.options.targetFileName);
3760          }
3761
3762          /* // THIS IS NOW AUTOMATED WITH A project CHECK IN ProjectNode
3763          project.topNode.configurations = project.configurations;
3764          project.topNode.platforms = project.platforms;
3765          project.topNode.options = project.options;*/
3766       }
3767    }
3768    return project;
3769 }