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