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

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