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");
2019             f.Printf("\n");
2020
2021             if(compiler.gccPrefix && compiler.gccPrefix[0])
2022             {
2023                f.Printf("GCC_PREFIX := %s\n", compiler.gccPrefix);
2024                f.Printf("\n");
2025             }
2026             if(compiler.sysroot && compiler.sysroot[0])
2027             {
2028                f.Printf("SYSROOT := %s\n", compiler.sysroot);
2029                f.Printf("_SYSROOT := $(space)--sysroot=$(SYSROOT)\n");
2030                f.Printf("\n");
2031             }
2032
2033             //f.Printf("SHELL := %s\n", "sh"/*compiler.shellCommand*/); // is this really needed?
2034             f.Printf("CPP := $(GCC_PREFIX)%s$(_SYSROOT)\n", compiler.cppCommand);
2035             f.Printf("CC := $(CCACHE_COMPILE) $(DISTCC_COMPILE) $(GCC_PREFIX)%s$(_SYSROOT)\n", compiler.ccCommand);
2036             f.Printf("CXX := $(CCACHE_COMPILE) $(DISTCC_COMPILE) $(GCC_PREFIX)%s$(_SYSROOT)\n", compiler.cxxCommand);
2037             f.Printf("ECP := %s\n", compiler.ecpCommand);
2038             f.Printf("ECC := %s\n", compiler.eccCommand);
2039             f.Printf("ECS := %s -t $(TARGET_PLATFORM)\n", compiler.ecsCommand);
2040             f.Printf("EAR := %s\n", compiler.earCommand);
2041
2042             f.Printf("AS := $(GCC_PREFIX)as\n");
2043             f.Printf("LD := $(GCC_PREFIX)ld\n");
2044             f.Printf("AR := $(GCC_PREFIX)ar\n");
2045             f.Printf("STRIP := $(GCC_PREFIX)strip\n");
2046             f.Printf("UPX := upx\n");
2047             f.Printf("\n");
2048
2049             if(compiler.environmentVars && compiler.environmentVars.count)
2050             {
2051                f.Printf("# ENVIRONMENT VARIABLES\n");
2052                for(e : compiler.environmentVars)
2053                {
2054                   f.Printf("export %s := %s\n", e.name, e.string);
2055                }
2056             }
2057
2058             f.Printf("UPXFLAGS = -9\n"); // TOFEAT: Compression Level Option? Other UPX Options?
2059             f.Printf("\n");
2060
2061             f.Printf("# HARD CODED TARGET_PLATFORM-SPECIFIC OPTIONS\n");
2062             f.Printf("ifdef %s\n", PlatformToMakefileTargetVariable(tux));
2063             f.Printf("LDFLAGS += -Wl,--no-undefined\n");
2064             f.Printf("endif\n");
2065             f.Printf("\n");
2066
2067             // JF's
2068             f.Printf("ifdef %s\n", PlatformToMakefileTargetVariable(apple));
2069             f.Printf("LDFLAGS += -framework cocoa -framework OpenGL\n");
2070             f.Printf("endif\n");
2071
2072             if(gccCompiler)
2073             {
2074                f.Printf("\nCFLAGS += -fmessage-length=0\n");
2075             }
2076
2077             if(compiler.includeDirs && compiler.includeDirs.count)
2078             {
2079                f.Printf("\nCFLAGS +=");
2080                OutputListOption(f, gccCompiler ? "isystem " : "I", compiler.includeDirs, lineEach, true);
2081                f.Printf("\n");
2082             }
2083             if(compiler.prepDirectives && compiler.prepDirectives.count)
2084             {
2085                f.Printf("\nCFLAGS +=");
2086                OutputListOption(f, "D", compiler.prepDirectives, inPlace, true);
2087                f.Printf("\n");
2088             }
2089             if(compiler.libraryDirs && compiler.libraryDirs.count)
2090             {
2091                f.Printf("\nLDFLAGS +=");
2092                OutputListOption(f, "L", compiler.libraryDirs, lineEach, true);
2093                // We would need a bool option to know whether we want to add to rpath as well...
2094                // OutputListOption(f, "Wl,-rpath ", compiler.libraryDirs, lineEach, true);
2095                f.Printf("\n");
2096             }
2097             if(compiler.excludeLibs && compiler.excludeLibs.count)
2098             {
2099                f.Puts("\nEXCLUDED_LIBS =");
2100                for(l : compiler.excludeLibs)
2101                {
2102                   f.Puts(" ");
2103                   f.Puts(l);
2104                }
2105             }
2106             if(compiler.linkerFlags && compiler.linkerFlags.count)
2107             {
2108                f.Printf("\nLDFLAGS +=");
2109                OutputListOption(f, "Wl,", compiler.linkerFlags, inPlace, true);
2110                f.Printf("\n");
2111             }
2112             f.Printf("\nFORCE_64_BIT = %s", compiler.supportsBitDepth ? "-m64" : "");
2113             f.Printf("\nFORCE_32_BIT = %s", compiler.supportsBitDepth ? "-m32" : "");
2114             f.Printf("\n");
2115
2116             delete f;
2117          }
2118       }
2119       delete name;
2120       delete compilerName;
2121       return result;
2122    }
2123
2124    bool GenerateMakefile(char * altMakefilePath, bool noResources, char * includemkPath, ProjectConfig config)
2125    {
2126       bool result = false;
2127       char filePath[MAX_LOCATION];
2128       char makeFile[MAX_LOCATION];
2129       // PathBackup pathBackup { };
2130       // char oldDirectory[MAX_LOCATION];
2131       File f = null;
2132
2133       if(!altMakefilePath)
2134       {
2135          strcpy(filePath, topNode.path);
2136          CatMakeFileName(makeFile, config);
2137          PathCatSlash(filePath, makeFile);
2138       }
2139
2140       f = FileOpen(altMakefilePath ? altMakefilePath : filePath, write);
2141
2142       /*SetPath(false, compiler, config);
2143       GetWorkingDir(oldDirectory, MAX_LOCATION);
2144       ChangeWorkingDir(topNode.path);*/
2145
2146       if(f)
2147       {
2148          bool test;
2149          int ifCount;
2150          Platform platform;
2151          char targetDir[MAX_LOCATION];
2152          char objDirExpNoSpaces[MAX_LOCATION];
2153          char objDirNoSpaces[MAX_LOCATION];
2154          char resDirNoSpaces[MAX_LOCATION];
2155          char targetDirExpNoSpaces[MAX_LOCATION];
2156          char fixedModuleName[MAX_FILENAME];
2157          char fixedConfigName[MAX_FILENAME];
2158          int c, len;
2159          // Non-zero if we're building eC code
2160          // We'll have to be careful with this when merging configs where eC files can be excluded in some configs and included in others
2161          int numCObjects = 0;
2162          bool containsCXX = false; // True if the project contains a C++ file
2163          bool sameObjTargetDirs;
2164          String objDirExp = GetObjDirExpression(config);
2165          TargetTypes targetType = GetTargetType(config);
2166
2167          char cfDir[MAX_LOCATION];
2168          int objectsParts, eCsourcesParts;
2169          Array<String> listItems { };
2170          Map<String, int> varStringLenDiffs { };
2171          Map<String, NameCollisionInfo> namesInfo { };
2172          bool forceBitDepth = false;
2173
2174          ReplaceSpaces(objDirNoSpaces, objDirExp);
2175          strcpy(targetDir, GetTargetDirExpression(config));
2176          ReplaceSpaces(targetDirExpNoSpaces, targetDir);
2177
2178          strcpy(objDirExpNoSpaces, GetObjDirExpression(config));
2179          ChangeCh(objDirExpNoSpaces, '\\', '/'); // TODO: this is a hack, paths should never include win32 path seperators - fix this in ProjectSettings and ProjectLoad instead
2180          ReplaceSpaces(objDirExpNoSpaces, objDirExpNoSpaces);
2181          ReplaceSpaces(resDirNoSpaces, resNode.path ? resNode.path : "");
2182          ReplaceSpaces(fixedModuleName, moduleName);
2183          ReplaceSpaces(fixedConfigName, GetConfigName(config));
2184          CamelCase(fixedConfigName);
2185
2186          sameObjTargetDirs = !fstrcmp(objDirExpNoSpaces, targetDirExpNoSpaces);
2187
2188          f.Printf(".PHONY: all objdir%s clean realclean\n\n", sameObjTargetDirs ? "" : " targetdir");
2189
2190          f.Printf("# CONTENT\n\n");
2191
2192          f.Printf("MODULE := %s\n", fixedModuleName);
2193          //f.Printf("VERSION = %s\n", version);
2194          f.Printf("CONFIG := %s\n", fixedConfigName);
2195          f.Printf("ifndef COMPILER\n");
2196          f.Printf("COMPILER := default\n");
2197          f.Printf("endif\n");
2198          f.Printf("\n");
2199
2200          if(compilerConfigsDir && compilerConfigsDir[0])
2201          {
2202             strcpy(cfDir, compilerConfigsDir);
2203             if(cfDir && cfDir[0] && cfDir[strlen(cfDir)-1] != '/')
2204                strcat(cfDir, "/");
2205          }
2206          else
2207          {
2208             GetIDECompilerConfigsDir(cfDir, true, true);
2209             // Use CF_DIR environment variable for absolute paths only
2210             if(cfDir[0] == '/' || (cfDir[0] && cfDir[1] == ':'))
2211                strcpy(cfDir, "$(CF_DIR)");
2212          }
2213
2214          f.Printf("_CF_DIR = %s\n", cfDir);
2215          f.Printf("\n");
2216
2217          f.Printf("ifndef DEBUG\n");
2218          f.Printf("OPTIMIZE :=");
2219          switch(GetOptimization(config))
2220          {
2221             case speed:
2222                f.Printf(" -O2");
2223                f.Printf(" -ffast-math");
2224                break;
2225             case size:
2226                f.Printf(" -Os");
2227                break;
2228          }
2229          if(GetDebug(config))
2230             f.Printf(" -g");
2231          f.Printf("\n");
2232          f.Printf("else\n");
2233          f.Printf("OPTIMIZE := -g\n");
2234          f.Printf("NOSTRIP := y\n");
2235          f.Printf("endif\n");
2236
2237          test = GetTargetTypeIsSetByPlatform(config);
2238          if(test)
2239          {
2240             ifCount = 0;
2241             for(platform = (Platform)1; platform < Platform::enumSize; platform++)
2242             {
2243                TargetTypes targetType;
2244                PlatformOptions projectPOs, configPOs;
2245                MatchProjectAndConfigPlatformOptions(config, platform, &projectPOs, &configPOs);
2246                targetType = platformTargetType;
2247                if(targetType)
2248                {
2249                   if(ifCount)
2250                      f.Printf("else\n");
2251                   ifCount++;
2252                   f.Printf("ifdef %s\n", PlatformToMakefileTargetVariable(platform));
2253
2254                   f.Printf("TARGET_TYPE = ");
2255                   f.Printf(TargetTypeToMakefileVariable(targetType));
2256                   f.Printf("\n");
2257                }
2258             }
2259             f.Printf("else\n"); // ifCount should always be > 0
2260          }
2261          f.Printf("TARGET_TYPE = ");
2262          f.Printf(TargetTypeToMakefileVariable(targetType));
2263          f.Printf("\n");
2264          if(test)
2265          {
2266             if(ifCount)
2267             {
2268                for(c = 0; c < ifCount; c++)
2269                   f.Printf("endif\n");
2270             }
2271          }
2272          f.Printf("\n");
2273
2274          f.Printf("ifeq \"$(TARGET_TYPE)\" \"%s\"\n", TargetTypeToMakefileVariable(executable));
2275          f.Printf("CONSOLE = %s\n", GetConsole(config) ? "-mconsole" : "-mwindows");
2276          f.Printf("endif\n\n");
2277
2278          f.Printf("# FLAGS\n\n");
2279
2280          f.Printf("CFLAGS =\n");
2281          f.Printf("CECFLAGS =\n");
2282          f.Printf("ECFLAGS =\n");
2283          f.Printf("OFLAGS =\n");
2284          f.Printf("LDFLAGS =\n");
2285          f.Printf("LIBS =\n");
2286          f.Printf("\n");
2287
2288          f.Printf("# INCLUDES\n\n");
2289
2290          f.Printf("include %s\n", includemkPath ? includemkPath : "$(_CF_DIR)crossplatform.mk");
2291          f.Printf("include $(_CF_DIR)$(TARGET_PLATFORM)-$(COMPILER).cf\n");
2292          f.Printf("\n");
2293
2294          f.Printf("# VARIABLES\n\n");
2295
2296          f.Printf("OBJ = %s%s\n\n", objDirExpNoSpaces, objDirExpNoSpaces[0] ? "/" : "");
2297
2298          f.Printf("ifdef DEBUG\n");
2299          f.Printf("CFLAGS += -D_DEBUG\n");
2300          f.Printf("endif\n\n");
2301
2302          f.Printf("RES = %s%s\n\n", resDirNoSpaces, resDirNoSpaces[0] ? "/" : "");
2303
2304          // test = GetTargetTypeIsSetByPlatform(config);
2305          {
2306             char target[MAX_LOCATION];
2307             char targetNoSpaces[MAX_LOCATION];
2308          if(test)
2309          {
2310             TargetTypes type;
2311             ifCount = 0;
2312             for(type = (TargetTypes)1; type < TargetTypes::enumSize; type++)
2313             {
2314                if(type != targetType)
2315                {
2316                   if(ifCount)
2317                      f.Printf("else\n");
2318                   ifCount++;
2319                   f.Printf("ifeq \"$(TARGET_TYPE)\" \"%s\"\n", TargetTypeToMakefileVariable(type));
2320
2321                   GetMakefileTargetFileName(type, target, config);
2322                   strcpy(targetNoSpaces, targetDir);
2323                   PathCatSlash(targetNoSpaces, target);
2324                   ReplaceSpaces(targetNoSpaces, targetNoSpaces);
2325                   f.Printf("TARGET = %s\n", targetNoSpaces);
2326                }
2327             }
2328             f.Printf("else\n"); // ifCount should always be > 0
2329          }
2330          GetMakefileTargetFileName(targetType, target, config);
2331          strcpy(targetNoSpaces, targetDir);
2332          PathCatSlash(targetNoSpaces, target);
2333          ReplaceSpaces(targetNoSpaces, targetNoSpaces);
2334          f.Printf("TARGET = %s\n", targetNoSpaces);
2335
2336          if(test)
2337          {
2338             if(ifCount)
2339             {
2340                for(c = 0; c < ifCount; c++)
2341                   f.Printf("endif\n");
2342             }
2343          }
2344          }
2345          f.Printf("\n");
2346
2347          // Use something fixed here, to not cause Makefile differences across compilers...
2348          varStringLenDiffs["$(OBJ)"] = 30; // strlen("obj/memoryGuard.android.gcc-4.6.2") - 6;
2349          // varStringLenDiffs["$(OBJ)"] = strlen(objDirNoSpaces) - 6;
2350
2351          topNode.GenMakefileGetNameCollisionInfo(namesInfo, config);
2352
2353          numCObjects = topNode.GenMakefilePrintNode(f, this, objects, namesInfo, listItems, config, &containsCXX);
2354          if(numCObjects)
2355             listItems.Add(CopyString("$(OBJ)$(MODULE).main$(O)"));
2356          objectsParts = OutputFileList(f, "OBJECTS", listItems, varStringLenDiffs, null);
2357
2358          {
2359             int c;
2360             char * map[4][2] = { { "COBJECTS", "C" }, { "SYMBOLS", "S" }, { "IMPORTS", "I" }, { "BOWLS", "B" } };
2361
2362             topNode.GenMakefilePrintNode(f, this, eCsources, namesInfo, listItems, config, null);
2363             eCsourcesParts = OutputFileList(f, "_ECSOURCES", listItems, varStringLenDiffs, null);
2364
2365             f.Printf("ECSOURCES = $(call shwspace,$(_ECSOURCES))\n");
2366             if(eCsourcesParts > 1)
2367             {
2368                for(c = 1; c <= eCsourcesParts; c++)
2369                   f.Printf("ECSOURCES%d = $(call shwspace,$(_ECSOURCES%d))\n", c, c);
2370             }
2371             f.Printf("\n");
2372
2373             for(c = 0; c < 3; c++)
2374             {
2375                if(eCsourcesParts > 1)
2376                {
2377                   int n;
2378                   f.Printf("%s =", map[c][0]);
2379                   for(n = 1; n <= eCsourcesParts; n++)
2380                      f.Printf(" $(%s%d)", map[c][0], n);
2381                   f.Printf("\n");
2382                   for(n = 1; n <= eCsourcesParts; n++)
2383                      f.Printf("%s%d = $(call shwspace,$(addprefix $(OBJ),$(patsubst %%.ec,%%$(%s),$(notdir $(_ECSOURCES%d)))))\n", map[c][0], n, map[c][1], n);
2384                }
2385                else if(eCsourcesParts == 1)
2386                   f.Printf("%s = $(call shwspace,$(addprefix $(OBJ),$(patsubst %%.ec,%%$(%s),$(notdir $(_ECSOURCES)))))\n", map[c][0], map[c][1]);
2387                f.Printf("\n");
2388             }
2389          }
2390
2391          topNode.GenMakefilePrintNode(f, this, sources, null, listItems, config, null);
2392          OutputFileList(f, "SOURCES", listItems, varStringLenDiffs, "$(ECSOURCES)");
2393
2394          if(!noResources)
2395             resNode.GenMakefilePrintNode(f, this, resources, null, listItems, config, null);
2396          OutputFileList(f, "RESOURCES", listItems, varStringLenDiffs, null);
2397
2398          f.Printf("LIBS += $(SHAREDLIB) $(EXECUTABLE) $(LINKOPT)\n\n");
2399          if((config && config.options && config.options.libraries) ||
2400                (options && options.libraries))
2401          {
2402             f.Printf("ifneq \"$(TARGET_TYPE)\" \"%s\"\n", TargetTypeToMakefileVariable(staticLibrary));
2403             f.Printf("LIBS +=");
2404             if(config && config.options && config.options.libraries)
2405                OutputLibraries(f, config.options.libraries);
2406             else if(options && options.libraries)
2407                OutputLibraries(f, options.libraries);
2408             f.Printf("\n");
2409             f.Printf("endif\n");
2410             f.Printf("\n");
2411          }
2412
2413          if(platforms || (config && config.platforms))
2414          {
2415             ifCount = 0;
2416             //for(platform = firstPlatform; platform <= lastPlatform; platform++)
2417             //for(platform = win32; platform <= apple; platform++)
2418
2419             f.Printf("# TARGET_PLATFORM-SPECIFIC OPTIONS\n\n");
2420             for(platform = (Platform)1; platform < Platform::enumSize; platform++)
2421             {
2422                PlatformOptions projectPlatformOptions, configPlatformOptions;
2423                MatchProjectAndConfigPlatformOptions(config, platform, &projectPlatformOptions, &configPlatformOptions);
2424
2425                if(projectPlatformOptions || configPlatformOptions)
2426                {
2427                   if(ifCount)
2428                      f.Printf("else\n");
2429                   ifCount++;
2430                   f.Printf("ifdef %s\n", PlatformToMakefileTargetVariable(platform));
2431                   f.Printf("\n");
2432
2433                   if((projectPlatformOptions && projectPlatformOptions.options.preprocessorDefinitions && projectPlatformOptions.options.preprocessorDefinitions.count) ||
2434                      (configPlatformOptions && configPlatformOptions.options.preprocessorDefinitions && configPlatformOptions.options.preprocessorDefinitions.count) ||
2435                      (projectPlatformOptions && projectPlatformOptions.options.includeDirs && projectPlatformOptions.options.includeDirs.count) ||
2436                      (configPlatformOptions && configPlatformOptions.options.includeDirs && configPlatformOptions.options.includeDirs.count))
2437                   {
2438                      f.Printf("CFLAGS +=");
2439                      if(projectPlatformOptions && projectPlatformOptions.options.linkerOptions && projectPlatformOptions.options.linkerOptions.count)
2440                      {
2441                         f.Printf(" \\\n\t -Wl");
2442                         for(s : projectPlatformOptions.options.linkerOptions)
2443                            f.Printf(",%s", s);
2444                      }
2445                      if(configPlatformOptions && configPlatformOptions.options.linkerOptions && configPlatformOptions.options.linkerOptions.count)
2446                      {
2447                         f.Printf(" \\\n\t -Wl");
2448                         for(s : configPlatformOptions.options.linkerOptions)
2449                            f.Printf(",%s", s);
2450                      }
2451                      if(projectPlatformOptions && projectPlatformOptions.options.preprocessorDefinitions)
2452                         OutputListOption(f, "D", projectPlatformOptions.options.preprocessorDefinitions, newLine, false);
2453                      if(configPlatformOptions && configPlatformOptions.options.preprocessorDefinitions)
2454                         OutputListOption(f, "D", configPlatformOptions.options.preprocessorDefinitions, newLine, false );
2455                      if(configPlatformOptions && configPlatformOptions.options.includeDirs)
2456                         OutputListOption(f, "I", configPlatformOptions.options.includeDirs, lineEach, true);
2457                      if(projectPlatformOptions && projectPlatformOptions.options.includeDirs)
2458                         OutputListOption(f, "I", projectPlatformOptions.options.includeDirs, lineEach, true);
2459                      f.Printf("\n\n");
2460                   }
2461
2462                   if((projectPlatformOptions && projectPlatformOptions.options.libraryDirs && projectPlatformOptions.options.libraryDirs.count) ||
2463                         (configPlatformOptions && configPlatformOptions.options.libraryDirs && configPlatformOptions.options.libraryDirs.count) ||
2464                         (projectPlatformOptions && projectPlatformOptions.options.libraries && projectPlatformOptions.options.libraries.count) ||
2465                         (configPlatformOptions && configPlatformOptions.options.libraries && configPlatformOptions.options.libraries.count))
2466                   {
2467                      f.Printf("ifneq \"$(TARGET_TYPE)\" \"%s\"\n", TargetTypeToMakefileVariable(staticLibrary));
2468                      if((projectPlatformOptions && projectPlatformOptions.options.libraryDirs && projectPlatformOptions.options.libraryDirs.count) ||
2469                         (configPlatformOptions && configPlatformOptions.options.libraryDirs && configPlatformOptions.options.libraryDirs.count))
2470                      {
2471                         f.Printf("OFLAGS +=");
2472                         if(configPlatformOptions && configPlatformOptions.options.libraryDirs)
2473                            OutputListOption(f, "L", configPlatformOptions.options.libraryDirs, lineEach, true);
2474                         if(projectPlatformOptions && projectPlatformOptions.options.libraryDirs)
2475                            OutputListOption(f, "L", projectPlatformOptions.options.libraryDirs, lineEach, true);
2476                         f.Printf("\n");
2477                      }
2478
2479                      if((configPlatformOptions && configPlatformOptions.options.libraries))
2480                      {
2481                         if(configPlatformOptions.options.libraries.count)
2482                         {
2483                            f.Printf("LIBS +=");
2484                            OutputLibraries(f, configPlatformOptions.options.libraries);
2485                            f.Printf("\n");
2486                         }
2487                      }
2488                      else if(projectPlatformOptions && projectPlatformOptions.options.libraries)
2489                      {
2490                         if(projectPlatformOptions.options.libraries.count)
2491                         {
2492                            f.Printf("LIBS +=");
2493                            OutputLibraries(f, projectPlatformOptions.options.libraries);
2494                            f.Printf("\n");
2495                         }
2496                      }
2497                      f.Printf("endif\n\n");
2498                   }
2499                }
2500             }
2501             if(ifCount)
2502             {
2503                for(c = 0; c < ifCount; c++)
2504                   f.Printf("endif\n");
2505             }
2506             f.Printf("\n");
2507          }
2508
2509          f.Printf("CFLAGS +=");
2510          //if(gccCompiler)
2511          {
2512             f.Printf(" $(OPTIMIZE)");
2513             forceBitDepth = (options && options.buildBitDepth) || numCObjects;
2514             if(forceBitDepth)
2515                f.Printf(" %s",(!options || !options.buildBitDepth || options.buildBitDepth == bits32) ? "$(FORCE_32_BIT)" : "$(FORCE_64_BIT)");
2516             f.Printf(" $(FPIC)");
2517          }
2518          switch(GetWarnings(config))
2519          {
2520             case all: f.Printf(" -Wall"); break;
2521             case none: f.Printf(" -w"); break;
2522          }
2523          if(GetProfile(config))
2524             f.Printf(" -pg");
2525          if(options && options.linkerOptions && options.linkerOptions.count)
2526          {
2527             f.Printf(" \\\n\t -Wl");
2528             for(s : options.linkerOptions)
2529                f.Printf(",%s", s);
2530          }
2531
2532          if(options && options.preprocessorDefinitions)
2533             OutputListOption(f, "D", options.preprocessorDefinitions, newLine, false);
2534          if(config && config.options && config.options.preprocessorDefinitions)
2535             OutputListOption(f, "D", config.options.preprocessorDefinitions, newLine, false);
2536          if(config && config.options && config.options.includeDirs)
2537             OutputListOption(f, "I", config.options.includeDirs, lineEach, true);
2538          if(options && options.includeDirs)
2539             OutputListOption(f, "I", options.includeDirs, lineEach, true);
2540          f.Printf("\n\n");
2541
2542          f.Printf("CECFLAGS += -cpp $(call escspace,$(CPP)) -t $(TARGET_PLATFORM)");
2543          f.Printf("\n\n");
2544
2545          f.Printf("ECFLAGS +=");
2546          if(GetMemoryGuard(config))
2547             f.Printf(" -memguard");
2548          if(GetStrictNameSpaces(config))
2549             f.Printf(" -strictns");
2550          if(GetNoLineNumbers(config))
2551             f.Printf(" -nolinenumbers");
2552          {
2553             char * s;
2554             if((s = GetDefaultNameSpace(config)) && s[0])
2555                f.Printf(" -defaultns %s", s);
2556          }
2557          f.Printf("\n\n");
2558
2559          f.Printf("ifneq \"$(TARGET_TYPE)\" \"%s\"\n", TargetTypeToMakefileVariable(staticLibrary));
2560          f.Printf("OFLAGS +=");
2561          if(forceBitDepth)
2562             f.Printf((!options || !options.buildBitDepth || options.buildBitDepth == bits32) ? " -m32" : " -m64 \\\n");
2563
2564          if(GetProfile(config))
2565             f.Printf(" -pg");
2566          if(config && config.options && config.options.libraryDirs)
2567             OutputListOption(f, "L", config.options.libraryDirs, lineEach, true);
2568          if(options && options.libraryDirs)
2569             OutputListOption(f, "L", options.libraryDirs, lineEach, true);
2570          f.Printf("\n");
2571          f.Printf("OFLAGS += $(LDFLAGS)\n");
2572          f.Printf("endif\n\n");
2573
2574          f.Printf("# TARGETS\n\n");
2575
2576          f.Printf("all: objdir%s $(TARGET)\n\n", sameObjTargetDirs ? "" : " targetdir");
2577
2578          f.Printf("objdir:\n");
2579             f.Printf("\t$(if $(wildcard $(OBJ)),,$(call mkdirq,$(OBJ)))\n");
2580          //f.Printf("# PRE-BUILD COMMANDS\n");
2581          if(options && options.prebuildCommands)
2582          {
2583             for(s : options.prebuildCommands)
2584                if(s && s[0]) f.Printf("\t%s\n", s);
2585          }
2586          if(config && config.options && config.options.prebuildCommands)
2587          {
2588             for(s : config.options.prebuildCommands)
2589                if(s && s[0]) f.Printf("\t%s\n", s);
2590          }
2591          if(platforms || (config && config.platforms))
2592          {
2593             ifCount = 0;
2594             //f.Printf("# TARGET_PLATFORM-SPECIFIC PRE-BUILD COMMANDS\n");
2595             for(platform = (Platform)1; platform < Platform::enumSize; platform++)
2596             {
2597                PlatformOptions projectPOs, configPOs;
2598                MatchProjectAndConfigPlatformOptions(config, platform, &projectPOs, &configPOs);
2599
2600                if((projectPOs && projectPOs.options.prebuildCommands && projectPOs.options.prebuildCommands.count) ||
2601                      (configPOs && configPOs.options.prebuildCommands && configPOs.options.prebuildCommands.count))
2602                {
2603                   if(ifCount)
2604                      f.Printf("else\n");
2605                   ifCount++;
2606                   f.Printf("ifdef ");
2607                   f.Printf(PlatformToMakefileVariable(platform));
2608                   f.Printf("\n");
2609
2610                   if(projectPOs && projectPOs.options.prebuildCommands && projectPOs.options.prebuildCommands.count)
2611                   {
2612                      for(s : projectPOs.options.prebuildCommands)
2613                         if(s && s[0]) f.Printf("\t%s\n", s);
2614                   }
2615                   if(configPOs && configPOs.options.prebuildCommands && configPOs.options.prebuildCommands.count)
2616                   {
2617                      for(s : configPOs.options.prebuildCommands)
2618                         if(s && s[0]) f.Printf("\t%s\n", s);
2619                   }
2620                }
2621             }
2622             if(ifCount)
2623             {
2624                int c;
2625                for(c = 0; c < ifCount; c++)
2626                   f.Printf("endif\n");
2627             }
2628          }
2629          f.Printf("\n");
2630
2631          if(!sameObjTargetDirs)
2632          {
2633             f.Printf("targetdir:\n");
2634                f.Printf("\t$(if $(wildcard %s),,$(call mkdirq,%s))\n\n", targetDirExpNoSpaces, targetDirExpNoSpaces);
2635          }
2636
2637          if(numCObjects)
2638          {
2639             // Main Module (Linking) for ECERE C modules
2640             f.Printf("$(OBJ)$(MODULE).main.ec: $(SYMBOLS) $(COBJECTS)\n");
2641             // use of objDirExpNoSpaces used instead of $(OBJ) to prevent problematic joining of arguments in ecs
2642             f.Printf("\t$(ECS)%s $(ECSLIBOPT) $(SYMBOLS) $(IMPORTS) -symbols %s -o $(OBJ)$(MODULE).main.ec\n\n",
2643                GetConsole(config) ? " -console" : "", objDirExpNoSpaces);
2644             // Main Module (Linking) for ECERE C modules
2645             f.Printf("$(OBJ)$(MODULE).main.c: $(OBJ)$(MODULE).main.ec\n");
2646             f.Printf("\t$(ECP) $(CECFLAGS) $(ECFLAGS) $(CFLAGS)"
2647                   " -c $(OBJ)$(MODULE).main.ec -o $(OBJ)$(MODULE).main.sym -symbols $(OBJ)\n");
2648             f.Printf("\t$(ECC) $(CECFLAGS) $(ECFLAGS) $(CFLAGS) $(FVISIBILITY)"
2649                   " -c $(OBJ)$(MODULE).main.ec -o $(OBJ)$(MODULE).main.c -symbols $(OBJ)\n\n");
2650          }
2651
2652          // *** Target ***
2653
2654          // This would not rebuild the target on updated objects
2655          // f.Printf("$(TARGET): $(SOURCES) $(RESOURCES) | objdir $(SYMBOLS) $(OBJECTS)%s\n", sameObjTargetDirs ? "" : " targetdir");
2656
2657          // This should fix it for good!
2658          f.Printf("$(SYMBOLS): | objdir\n");
2659          f.Printf("$(OBJECTS): | objdir\n");
2660
2661          // This alone was breaking the tarball, object directory does not get created first (order-only rules happen last it seems!)
2662          f.Printf("$(TARGET): $(SOURCES) $(RESOURCES) $(SYMBOLS) $(OBJECTS) | objdir%s\n", sameObjTargetDirs ? "" : " targetdir");
2663
2664          f.Printf("ifneq \"$(TARGET_TYPE)\" \"%s\"\n", TargetTypeToMakefileVariable(staticLibrary));
2665          f.Printf("\t$(%s) $(OFLAGS) $(OBJECTS) $(LIBS) %s-o $(TARGET) $(INSTALLNAME)\n", containsCXX ? "CXX" : "CC", containsCXX ? "-lstdc++ " : "");
2666          if(!GetDebug(config))
2667          {
2668             f.Printf("ifndef NOSTRIP\n");
2669             f.Printf("\t$(STRIP) $(STRIPOPT) $(TARGET)\n");
2670             f.Printf("endif\n");
2671
2672             if(GetCompress(config))
2673             {
2674                f.Printf("ifndef WINDOWS\n");
2675                f.Printf("ifeq \"$(TARGET_TYPE)\" \"%s\"\n", TargetTypeToMakefileVariable(executable));
2676                   f.Printf("\t$(UPX) $(UPXFLAGS) $(TARGET)\n");
2677                f.Printf("endif\n");
2678                f.Printf("else\n");
2679                   f.Printf("\t$(UPX) $(UPXFLAGS) $(TARGET)\n");
2680                f.Printf("endif\n");
2681             }
2682          }
2683          if(resNode.files && resNode.files.count && !noResources)
2684             resNode.GenMakefileAddResources(f, resNode.path, config);
2685          f.Printf("else\n");
2686          f.Printf("\t$(AR) rcs $(TARGET) $(OBJECTS) $(LIBS)\n");
2687          f.Printf("endif\n");
2688
2689          //f.Printf("# POST-BUILD COMMANDS\n");
2690          if(options && options.postbuildCommands)
2691          {
2692             for(s : options.postbuildCommands)
2693                if(s && s[0]) f.Printf("\t%s\n", s);
2694          }
2695          if(config && config.options && config.options.postbuildCommands)
2696          {
2697             for(s : config.options.postbuildCommands)
2698                if(s && s[0]) f.Printf("\t%s\n", s);
2699          }
2700          if(platforms || (config && config.platforms))
2701          {
2702             ifCount = 0;
2703             //f.Printf("# TARGET_PLATFORM-SPECIFIC POST-BUILD COMMANDS\n");
2704             for(platform = (Platform)1; platform < Platform::enumSize; platform++)
2705             {
2706                PlatformOptions projectPOs, configPOs;
2707                MatchProjectAndConfigPlatformOptions(config, platform, &projectPOs, &configPOs);
2708
2709                if((projectPOs && projectPOs.options.postbuildCommands && projectPOs.options.postbuildCommands.count) ||
2710                      (configPOs && configPOs.options.postbuildCommands && configPOs.options.postbuildCommands.count))
2711                {
2712                   if(ifCount)
2713                      f.Printf("else\n");
2714                   ifCount++;
2715                   f.Printf("ifdef ");
2716                   f.Printf(PlatformToMakefileVariable(platform));
2717                   f.Printf("\n");
2718
2719                   if(projectPOs && projectPOs.options.postbuildCommands && projectPOs.options.postbuildCommands.count)
2720                   {
2721                      for(s : projectPOs.options.postbuildCommands)
2722                         if(s && s[0]) f.Printf("\t%s\n", s);
2723                   }
2724                   if(configPOs && configPOs.options.postbuildCommands && configPOs.options.postbuildCommands.count)
2725                   {
2726                      for(s : configPOs.options.postbuildCommands)
2727                         if(s && s[0]) f.Printf("\t%s\n", s);
2728                   }
2729                }
2730             }
2731             if(ifCount)
2732             {
2733                int c;
2734                for(c = 0; c < ifCount; c++)
2735                   f.Printf("endif\n");
2736             }
2737          }
2738          f.Printf("\n");
2739
2740          f.Printf("# SYMBOL RULES\n\n");
2741          {
2742             Map<Platform, bool> excludedPlatforms { };
2743             topNode.GenMakefilePrintSymbolRules(f, this, config, excludedPlatforms);
2744             delete excludedPlatforms;
2745          }
2746
2747          f.Printf("# C OBJECT RULES\n\n");
2748          {
2749             Map<Platform, bool> excludedPlatforms { };
2750             topNode.GenMakefilePrintCObjectRules(f, this, config, excludedPlatforms);
2751             delete excludedPlatforms;
2752          }
2753
2754          f.Printf("# OBJECT RULES\n\n");
2755          // todo call this still but only generate rules whith specific options
2756          // see we-have-file-specific-options in ProjectNode.ec
2757          {
2758             Map<Platform, bool> excludedPlatforms { };
2759             topNode.GenMakefilePrintObjectRules(f, this, namesInfo, config, excludedPlatforms);
2760             delete excludedPlatforms;
2761          }
2762
2763          if(numCObjects)
2764             GenMakefilePrintMainObjectRule(f, config);
2765
2766          f.Printf("clean: objdir%s\n", sameObjTargetDirs ? "" : " targetdir");
2767          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) " : "");
2768          OutputCleanActions(f, "OBJECTS", objectsParts);
2769          if(numCObjects)
2770          {
2771             OutputCleanActions(f, "COBJECTS", eCsourcesParts);
2772             OutputCleanActions(f, "BOWLS", eCsourcesParts);
2773             OutputCleanActions(f, "IMPORTS", eCsourcesParts);
2774             OutputCleanActions(f, "SYMBOLS", eCsourcesParts);
2775          }
2776          f.Printf("\n");
2777
2778          f.Printf("realclean: clean\n");
2779          f.Printf("\t$(call rmrq,$(OBJ))\n");
2780          if(!sameObjTargetDirs)
2781             f.Printf("\t$(call rmdirq,%s)\n", targetDirExpNoSpaces);
2782          f.Printf("\n");
2783
2784          delete f;
2785
2786          listItems.Free();
2787          delete listItems;
2788          varStringLenDiffs.Free();
2789          delete varStringLenDiffs;
2790          namesInfo.Free();
2791          delete namesInfo;
2792
2793          result = true;
2794       }
2795
2796       // ChangeWorkingDir(oldDirectory);
2797       // delete pathBackup;
2798
2799       if(config)
2800          config.makingModified = false;
2801       return result;
2802    }
2803
2804    void GenMakefilePrintMainObjectRule(File f, ProjectConfig config)
2805    {
2806       char extension[MAX_EXTENSION] = "c";
2807       char modulePath[MAX_LOCATION];
2808       char fixedModuleName[MAX_FILENAME];
2809       DualPipe dep;
2810       char command[2048];
2811       char objDirNoSpaces[MAX_LOCATION];
2812       String objDirExp = GetObjDirExpression(config);
2813
2814       ReplaceSpaces(objDirNoSpaces, objDirExp);
2815       ReplaceSpaces(fixedModuleName, moduleName);
2816
2817       //sprintf(fixedModuleName, "%s.main", fixedPrjName);
2818       //strcat(fixedModuleName, ".main");
2819
2820 #if 0       // TODO: Fix nospaces stuff
2821       // *** Dependency command ***
2822       sprintf(command, "gcc -MT $(OBJ)%s$(O) -MM $(OBJ)%s.c", fixedModuleName, fixedModuleName);
2823
2824       // System Includes (from global settings)
2825       for(item : compiler.dirs[Includes])
2826       {
2827          strcat(command, " -isystem ");
2828          if(strchr(item.name, ' '))
2829          {
2830             strcat(command, "\"");
2831             strcat(command, item);
2832             strcat(command, "\"");
2833          }
2834          else
2835             strcat(command, item);
2836       }
2837
2838       for(item = includeDirs.first; item; item = item.next)
2839       {
2840          strcat(command, " -I");
2841          if(strchr(item.name, ' '))
2842          {
2843             strcat(command, "\"");
2844             strcat(command, item.name);
2845             strcat(command, "\"");
2846          }
2847          else
2848             strcat(command, item.name);
2849       }
2850       for(item = preprocessorDefs.first; item; item = item.next)
2851       {
2852          strcat(command, " -D");
2853          strcat(command, item.name);
2854       }
2855
2856       // Execute it
2857       if((dep = DualPipeOpen(PipeOpenMode { output = 1, error = 1, input = 2 }, command)))
2858       {
2859          char line[1024];
2860          bool result = true;
2861          bool firstLine = true;
2862
2863          // To do some time: auto save external dependencies?
2864          while(!dep.Eof())
2865          {
2866             if(dep.GetLine(line, sizeof(line)-1))
2867             {
2868                if(firstLine)
2869                {
2870                   char * colon = strstr(line, ":");
2871                   if(strstr(line, "No such file") || strstr(line, ",") || (colon && strstr(colon+1, ":")))
2872                   {
2873                      result = false;
2874                      break;
2875                   }
2876                   firstLine = false;
2877                }
2878                f.Puts(line);
2879                f.Puts("\n");
2880             }
2881             if(!result) break;
2882          }
2883          delete dep;
2884
2885          // If we failed to generate dependencies...
2886          if(!result)
2887          {
2888 #endif
2889             f.Printf("$(OBJ)$(MODULE).main$(O): $(OBJ)$(MODULE).main.c\n");
2890 #if 0
2891          }
2892       }
2893 #endif
2894
2895       f.Printf("\t$(CC) $(CFLAGS) $(FVISIBILITY) -c $(OBJ)$(MODULE).main.%s -o $(OBJ)$(MODULE).main$(O)\n\n", extension);
2896    }
2897
2898    void MatchProjectAndConfigPlatformOptions(ProjectConfig config, Platform platform,
2899          PlatformOptions * projectPlatformOptions, PlatformOptions * configPlatformOptions)
2900    {
2901       *projectPlatformOptions = null;
2902       *configPlatformOptions = null;
2903       if(platforms)
2904       {
2905          for(p : platforms)
2906          {
2907             if(!strcmpi(p.name, platform))
2908             {
2909                *projectPlatformOptions = p;
2910                break;
2911             }
2912          }
2913       }
2914       if(config && config.platforms)
2915       {
2916          for(p : config.platforms)
2917          {
2918             if(!strcmpi(p.name, platform))
2919             {
2920                *configPlatformOptions = p;
2921                break;
2922             }
2923          }
2924       }
2925    }
2926 }
2927
2928 Project LegacyBinaryLoadProject(File f, char * filePath)
2929 {
2930    Project project = null;
2931    char signature[sizeof(epjSignature)];
2932
2933    f.Read(signature, sizeof(signature), 1);
2934    if(!strncmp(signature, (char *)epjSignature, sizeof(epjSignature)))
2935    {
2936       char topNodePath[MAX_LOCATION];
2937       /*ProjectConfig newConfig
2938       {
2939          name = CopyString("Default");
2940          makingModified = true;
2941          compilingModified = true;
2942          linkingModified = true;
2943          options = { };
2944       };*/
2945
2946       project = Project { options = { } };
2947       LegacyBinaryLoadNode(project.topNode, f);
2948       delete project.topNode.path;
2949       GetWorkingDir(topNodePath, sizeof(topNodePath)-1);
2950       MakeSlashPath(topNodePath);
2951
2952       PathCatSlash(topNodePath, filePath);
2953       project.filePath = topNodePath;
2954
2955       /* THIS IS ALREADY DONE BY filePath property
2956       StripLastDirectory(topNodePath, topNodePath);
2957       project.topNode.path = CopyString(topNodePath);
2958       */
2959       // Shouldn't this be done BEFORE the StripLastDirectory? project.filePath = topNodePath;
2960
2961       // newConfig.options.defaultNameSpace = "";
2962       /*newConfig.objDir.dir = "obj";
2963       newConfig.targetDir.dir = "";*/
2964
2965       //project.configurations = { [ newConfig ] };
2966       //project.config = newConfig;
2967
2968       // Project Settings
2969       if(!f.Eof())
2970       {
2971          int temp;
2972          int len,c, count;
2973          String targetFileName, targetDirectory, objectsDirectory;
2974
2975          // { executable = 0, sharedLibrary = 1, staticLibrary = 2 };
2976          f.Read(&temp, sizeof(int),1);
2977          switch(temp)
2978          {
2979             case 0: project.options.targetType = executable; break;
2980             case 1: project.options.targetType = sharedLibrary; break;
2981             case 2: project.options.targetType = staticLibrary; break;
2982          }
2983
2984          f.Read(&len, sizeof(int),1);
2985          targetFileName = new char[len+1];
2986          f.Read(targetFileName, sizeof(char), len+1);
2987          project.options.targetFileName = targetFileName;
2988          delete targetFileName;
2989
2990          f.Read(&len, sizeof(int),1);
2991          targetDirectory = new char[len+1];
2992          f.Read(targetDirectory, sizeof(char), len+1);
2993          project.options.targetDirectory = targetDirectory;
2994          delete targetDirectory;
2995
2996          f.Read(&len, sizeof(int),1);
2997          objectsDirectory = new byte[len+1];
2998          f.Read(objectsDirectory, sizeof(char), len+1);
2999          project.options.objectsDirectory = objectsDirectory;
3000          delete objectsDirectory;
3001
3002          f.Read(&temp, sizeof(int),1);
3003          project./*config.*/options.debug = temp ? true : false;
3004          f.Read(&temp, sizeof(int),1);
3005          project./*config.*/options.optimization = temp ? speed : none;
3006          f.Read(&temp, sizeof(int),1);
3007          project./*config.*/options.profile = temp ? true : false;
3008          f.Read(&temp, sizeof(int),1);
3009          project.options.warnings = temp ? all : unset;
3010
3011          f.Read(&count, sizeof(int),1);
3012          if(count)
3013          {
3014             project.options.includeDirs = { };
3015             for(c = 0; c < count; c++)
3016             {
3017                char * name;
3018                f.Read(&len, sizeof(int),1);
3019                name = new char[len+1];
3020                f.Read(name, sizeof(char), len+1);
3021                project.options.includeDirs.Add(name);
3022             }
3023          }
3024
3025          f.Read(&count, sizeof(int),1);
3026          if(count)
3027          {
3028             project.options.libraryDirs = { };
3029             for(c = 0; c < count; c++)
3030             {
3031                char * name;
3032                f.Read(&len, sizeof(int),1);
3033                name = new char[len+1];
3034                f.Read(name, sizeof(char), len+1);
3035                project.options.libraryDirs.Add(name);
3036             }
3037          }
3038
3039          f.Read(&count, sizeof(int),1);
3040          if(count)
3041          {
3042             project.options.libraries = { };
3043             for(c = 0; c < count; c++)
3044             {
3045                char * name;
3046                f.Read(&len, sizeof(int),1);
3047                name = new char[len+1];
3048                f.Read(name, sizeof(char), len+1);
3049                project.options.libraries.Add(name);
3050             }
3051          }
3052
3053          f.Read(&count, sizeof(int),1);
3054          if(count)
3055          {
3056             project.options.preprocessorDefinitions = { };
3057             for(c = 0; c < count; c++)
3058             {
3059                char * name;
3060                f.Read(&len, sizeof(int),1);
3061                name = new char[len+1];
3062                f.Read(name, sizeof(char), len+1);
3063                project.options.preprocessorDefinitions.Add(name);
3064             }
3065          }
3066
3067          f.Read(&temp, sizeof(int),1);
3068          project.options.console = temp ? true : false;
3069       }
3070
3071       for(node : project.topNode.files)
3072       {
3073          if(node.type == resources)
3074          {
3075             project.resNode = node;
3076             break;
3077          }
3078       }
3079    }
3080    else
3081       f.Seek(0, start);
3082    return project;
3083 }
3084
3085 void ProjectConfig::LegacyProjectConfigLoad(File f)
3086 {
3087    delete options;
3088    options = { };
3089    while(!f.Eof())
3090    {
3091       char buffer[65536];
3092       char section[128];
3093       char subSection[128];
3094       char * equal;
3095       int len;
3096       uint pos;
3097
3098       pos = f.Tell();
3099       f.GetLine(buffer, 65536 - 1);
3100       TrimLSpaces(buffer, buffer);
3101       TrimRSpaces(buffer, buffer);
3102       if(strlen(buffer))
3103       {
3104          if(buffer[0] == '-')
3105          {
3106             equal = &buffer[0];
3107             equal[0] = ' ';
3108             TrimLSpaces(equal, equal);
3109             if(!strcmpi(subSection, "LibraryDirs"))
3110             {
3111                if(!options.libraryDirs)
3112                   options.libraryDirs = { [ CopyString(equal) ] };
3113                else
3114                   options.libraryDirs.Add(CopyString(equal));
3115             }
3116             else if(!strcmpi(subSection, "IncludeDirs"))
3117             {
3118                if(!options.includeDirs)
3119                   options.includeDirs = { [ CopyString(equal) ] };
3120                else
3121                   options.includeDirs.Add(CopyString(equal));
3122             }
3123          }
3124          else if(buffer[0] == '+')
3125          {
3126             if(name)
3127             {
3128                f.Seek(pos, start);
3129                break;
3130             }
3131             else
3132             {
3133                equal = &buffer[0];
3134                equal[0] = ' ';
3135                TrimLSpaces(equal, equal);
3136                delete name; name = CopyString(equal); // property::name = equal;
3137             }
3138          }
3139          else if(!strcmpi(buffer, "Compiler Options"))
3140             strcpy(section, buffer);
3141          else if(!strcmpi(buffer, "IncludeDirs"))
3142             strcpy(subSection, buffer);
3143          else if(!strcmpi(buffer, "Linker Options"))
3144             strcpy(section, buffer);
3145          else if(!strcmpi(buffer, "LibraryDirs"))
3146             strcpy(subSection, buffer);
3147          else if(!strcmpi(buffer, "Files") || !strcmpi(buffer, "Resources"))
3148          {
3149             f.Seek(pos, start);
3150             break;
3151          }
3152          else
3153          {
3154             equal = strstr(buffer, "=");
3155             if(equal)
3156             {
3157                equal[0] = '\0';
3158                TrimRSpaces(buffer, buffer);
3159                equal++;
3160                TrimLSpaces(equal, equal);
3161                if(!strcmpi(buffer, "Target Name"))
3162                   options.targetFileName = /*CopyString(*/equal/*)*/;
3163                else if(!strcmpi(buffer, "Target Type"))
3164                {
3165                   if(!strcmpi(equal, "Executable"))
3166                      options.targetType = executable;
3167                   else if(!strcmpi(equal, "Shared"))
3168                      options.targetType = sharedLibrary;
3169                   else if(!strcmpi(equal, "Static"))
3170                      options.targetType = staticLibrary;
3171                   else
3172                      options.targetType = executable;
3173                }
3174                else if(!strcmpi(buffer, "Target Directory"))
3175                   options.targetDirectory = /*CopyString(*/equal/*)*/;
3176                else if(!strcmpi(buffer, "Console"))
3177                   options.console = ParseTrueFalseValue(equal);
3178                else if(!strcmpi(buffer, "Libraries"))
3179                {
3180                   if(!options.libraries) options.libraries = { };
3181                   ParseArrayValue(options.libraries, equal);
3182                }
3183                else if(!strcmpi(buffer, "Intermediate Directory"))
3184                   options.objectsDirectory = /*CopyString(*/equal/*)*/; //objDir.expression = equal;
3185                else if(!strcmpi(buffer, "Debug"))
3186                   options.debug = ParseTrueFalseValue(equal);
3187                else if(!strcmpi(buffer, "Optimize"))
3188                {
3189                   if(!strcmpi(equal, "None"))
3190                      options.optimization = none;
3191                   else if(!strcmpi(equal, "Speed") || !strcmpi(equal, "True"))
3192                      options.optimization = speed;
3193                   else if(!strcmpi(equal, "Size"))
3194                      options.optimization = size;
3195                   else
3196                      options.optimization = none;
3197                }
3198                else if(!strcmpi(buffer, "Compress"))
3199                   options.compress = ParseTrueFalseValue(equal);
3200                else if(!strcmpi(buffer, "Profile"))
3201                   options.profile = ParseTrueFalseValue(equal);
3202                else if(!strcmpi(buffer, "AllWarnings"))
3203                   options.warnings = ParseTrueFalseValue(equal) ? all : unset;
3204                else if(!strcmpi(buffer, "MemoryGuard"))
3205                   options.memoryGuard = ParseTrueFalseValue(equal);
3206                else if(!strcmpi(buffer, "Default Name Space"))
3207                   options.defaultNameSpace = CopyString(equal);
3208                else if(!strcmpi(buffer, "Strict Name Spaces"))
3209                   options.strictNameSpaces = ParseTrueFalseValue(equal);
3210                else if(!strcmpi(buffer, "Preprocessor Definitions"))
3211                {
3212                   if(!options.preprocessorDefinitions) options.preprocessorDefinitions = { };
3213                   ParseArrayValue(options.preprocessorDefinitions, equal);
3214                }
3215             }
3216          }
3217       }
3218    }
3219    if(!options.targetDirectory && options.objectsDirectory)
3220       options.targetDirectory = /*CopyString(*/options.objectsDirectory/*)*/;
3221    //if(!objDir.dir) objDir.dir = "obj";
3222    //if(!targetDir.dir) targetDir.dir = "";
3223    // if(!targetName) property::targetName = "";   // How can a targetFileName be nothing???
3224    // if(!defaultNameSpace) property::defaultNameSpace = "";
3225    makingModified = true;
3226 }
3227
3228 Project LegacyAsciiLoadProject(File f, char * filePath)
3229 {
3230    Project project = null;
3231    ProjectNode node = null;
3232    int pos;
3233    char parentPath[MAX_LOCATION];
3234    char section[128] = "";
3235    char subSection[128] = "";
3236    ProjectNode parent;
3237    bool configurationsPresent = false;
3238
3239    f.Seek(0, start);
3240    while(!f.Eof())
3241    {
3242       char buffer[65536];
3243       //char version[16];
3244       char * equal;
3245       int len;
3246       pos = f.Tell();
3247       f.GetLine(buffer, 65536 - 1);
3248       TrimLSpaces(buffer, buffer);
3249       TrimRSpaces(buffer, buffer);
3250       if(strlen(buffer))
3251       {
3252          if(buffer[0] == '-' || buffer[0] == '=')
3253          {
3254             bool simple = buffer[0] == '-';
3255             equal = &buffer[0];
3256             equal[0] = ' ';
3257             TrimLSpaces(equal, equal);
3258             if(!strcmpi(section, "Target") && !strcmpi(subSection, "LibraryDirs"))
3259             {
3260                if(!project.config.options.libraryDirs)
3261                   project.config.options.libraryDirs = { [ CopyString(equal) ] };
3262                else
3263                   project.config.options.libraryDirs.Add(CopyString(equal));
3264             }
3265             else if(!strcmpi(section, "Target") && !strcmpi(subSection, "IncludeDirs"))
3266             {
3267                if(!project.config.options.includeDirs)
3268                   project.config.options.includeDirs = { [ CopyString(equal) ] };
3269                else
3270                   project.config.options.includeDirs.Add(CopyString(equal));
3271             }
3272             else if(!strcmpi(section, "Target") && (!strcmpi(subSection, "Files") || !strcmpi(subSection, "Resources")))
3273             {
3274                len = strlen(equal);
3275                if(len)
3276                {
3277                   char temp[MAX_LOCATION];
3278                   ProjectNode child { };
3279                   // We don't need to do this anymore, fileName is just a property that sets name & path
3280                   // child.fileName = CopyString(equal);
3281                   if(simple)
3282                   {
3283                      child.name = CopyString(equal);
3284                      child.path = CopyString(parentPath);
3285                   }
3286                   else
3287                   {
3288                      GetLastDirectory(equal, temp);
3289                      child.name = CopyString(temp);
3290                      StripLastDirectory(equal, temp);
3291                      child.path = CopyString(temp);
3292                   }
3293                   child.nodeType = file;
3294                   child.parent = parent;
3295                   child.indent = parent.indent + 1;
3296                   child.type = file;
3297                   child.icon = NodeIcons::SelectFileIcon(child.name);
3298                   parent.files.Add(child);
3299                   node = child;
3300                   //child = null;
3301                }
3302                else
3303                {
3304                   StripLastDirectory(parentPath, parentPath);
3305                   parent = parent.parent;
3306                }
3307             }
3308          }
3309          else if(buffer[0] == '+')
3310          {
3311             equal = &buffer[0];
3312             equal[0] = ' ';
3313             TrimLSpaces(equal, equal);
3314             if(!strcmpi(section, "Target") && (!strcmpi(subSection, "Files") || !strcmpi(subSection, "Resources")))
3315             {
3316                char temp[MAX_LOCATION];
3317                ProjectNode child { };
3318                // NEW: Folders now have a path set like files
3319                child.name = CopyString(equal);
3320                strcpy(temp, parentPath);
3321                PathCatSlash(temp, child.name);
3322                child.path = CopyString(temp);
3323
3324                child.parent = parent;
3325                child.indent = parent.indent + 1;
3326                child.type = folder;
3327                child.nodeType = folder;
3328                child.files = { };
3329                child.icon = folder;
3330                PathCatSlash(parentPath, child.name);
3331                parent.files.Add(child);
3332                parent = child;
3333                node = child;
3334                //child = null;
3335             }
3336             else if(!strcmpi(section, "Configurations"))
3337             {
3338                ProjectConfig newConfig
3339                {
3340                   makingModified = true;
3341                   options = { };
3342                };
3343                f.Seek(pos, start);
3344                LegacyProjectConfigLoad(newConfig, f);
3345                project.configurations.Add(newConfig);
3346             }
3347          }
3348          else if(!strcmpi(buffer, "ECERE Project File"));
3349          else if(!strcmpi(buffer, "Version 0a"))
3350             ; //strcpy(version, "0a");
3351          else if(!strcmpi(buffer, "Version 0.1a"))
3352             ; //strcpy(version, "0.1a");
3353          else if(!strcmpi(buffer, "Configurations"))
3354          {
3355             project.configurations.Free();
3356             project.config = null;
3357             strcpy(section, buffer);
3358             configurationsPresent = true;
3359          }
3360          else if(!strcmpi(buffer, "Target") || !strnicmp(buffer, "Target \"", strlen("Target \"")))
3361          {
3362             ProjectConfig newConfig { name = CopyString("Default"), options = { } };
3363             char topNodePath[MAX_LOCATION];
3364             // newConfig.defaultNameSpace = "";
3365             //newConfig.objDir.dir = "obj";
3366             //newConfig.targetDir.dir = "";
3367             project = Project { /*options = { }*/ };
3368             project.configurations = { [ newConfig ] };
3369             project.config = newConfig;
3370             // if(project.topNode.path) delete project.topNode.path;
3371             GetWorkingDir(topNodePath, sizeof(topNodePath)-1);
3372             MakeSlashPath(topNodePath);
3373             PathCatSlash(topNodePath, filePath);
3374             project.filePath = topNodePath;
3375             parentPath[0] = '\0';
3376             parent = project.topNode;
3377             node = parent;
3378             strcpy(section, "Target");
3379             equal = &buffer[6];
3380             if(equal[0] == ' ')
3381             {
3382                equal++;
3383                if(equal[0] == '\"')
3384                {
3385                   StripQuotes(equal, equal);
3386                   delete project.moduleName; project.moduleName = CopyString(equal);
3387                }
3388             }
3389          }
3390          else if(!strcmpi(buffer, "Compiler Options"));
3391          else if(!strcmpi(buffer, "IncludeDirs"))
3392             strcpy(subSection, buffer);
3393          else if(!strcmpi(buffer, "Linker Options"));
3394          else if(!strcmpi(buffer, "LibraryDirs"))
3395             strcpy(subSection, buffer);
3396          else if(!strcmpi(buffer, "Files"))
3397          {
3398             strcpy(section, "Target");
3399             strcpy(subSection, buffer);
3400          }
3401          else if(!strcmpi(buffer, "Resources"))
3402          {
3403             ProjectNode child { };
3404             parent.files.Add(child);
3405             child.parent = parent;
3406             child.indent = parent.indent + 1;
3407             child.name = CopyString(buffer);
3408             child.path = CopyString("");
3409             child.type = resources;
3410             child.files = { };
3411             child.icon = archiveFile;
3412             project.resNode = child;
3413             parent = child;
3414             node = child;
3415             strcpy(subSection, buffer);
3416          }
3417          else
3418          {
3419             equal = strstr(buffer, "=");
3420             if(equal)
3421             {
3422                equal[0] = '\0';
3423                TrimRSpaces(buffer, buffer);
3424                equal++;
3425                TrimLSpaces(equal, equal);
3426
3427                if(!strcmpi(section, "Target"))
3428                {
3429                   if(!strcmpi(buffer, "Build Exclusions"))
3430                   {
3431                      if(!strcmpi(section, "Target") && !strcmpi(subSection, "Files"))
3432                      {
3433                         /*if(node && node.type != NodeTypes::project)
3434                            ParseListValue(node.buildExclusions, equal);*/
3435                      }
3436                   }
3437                   else if(!strcmpi(buffer, "Path") && !strcmpi(subSection, "Resources"))
3438                   {
3439                      delete project.resNode.path;
3440                      project.resNode.path = CopyString(equal);
3441                      PathCatSlash(parentPath, equal);
3442                   }
3443
3444                   // Config Settings
3445                   else if(!strcmpi(buffer, "Intermediate Directory"))
3446                      project.config.options.objectsDirectory = /*CopyString(*/equal/*)*/; //objDir.expression = equal;
3447                   else if(!strcmpi(buffer, "Debug"))
3448                      project.config.options.debug = ParseTrueFalseValue(equal);
3449                   else if(!strcmpi(buffer, "Optimize"))
3450                   {
3451                      if(!strcmpi(equal, "None"))
3452                         project.config.options.optimization = none;
3453                      else if(!strcmpi(equal, "Speed") || !strcmpi(equal, "True"))
3454                         project.config.options.optimization = speed;
3455                      else if(!strcmpi(equal, "Size"))
3456                         project.config.options.optimization = size;
3457                      else
3458                         project.config.options.optimization = none;
3459                   }
3460                   else if(!strcmpi(buffer, "Profile"))
3461                      project.config.options.profile = ParseTrueFalseValue(equal);
3462                   else if(!strcmpi(buffer, "MemoryGuard"))
3463                      project.config.options.memoryGuard = ParseTrueFalseValue(equal);
3464                   else
3465                   {
3466                      if(!project.options) project.options = { };
3467
3468                      // Project Wide Settings (All configs)
3469                      if(!strcmpi(buffer, "Target Name"))
3470                         project.options.targetFileName = /*CopyString(*/equal/*)*/;
3471                      else if(!strcmpi(buffer, "Target Type"))
3472                      {
3473                         if(!strcmpi(equal, "Executable"))
3474                            project.options.targetType = executable;
3475                         else if(!strcmpi(equal, "Shared"))
3476                            project.options.targetType = sharedLibrary;
3477                         else if(!strcmpi(equal, "Static"))
3478                            project.options.targetType = staticLibrary;
3479                         else
3480                            project.options.targetType = executable;
3481                      }
3482                      else if(!strcmpi(buffer, "Target Directory"))
3483                         project.options.targetDirectory = /*CopyString(*/equal/*)*/;
3484                      else if(!strcmpi(buffer, "Console"))
3485                         project.options.console = ParseTrueFalseValue(equal);
3486                      else if(!strcmpi(buffer, "Libraries"))
3487                      {
3488                         if(!project.options.libraries) project.options.libraries = { };
3489                         ParseArrayValue(project.options.libraries, equal);
3490                      }
3491                      else if(!strcmpi(buffer, "AllWarnings"))
3492                         project.options.warnings = ParseTrueFalseValue(equal) ? all : unset;
3493                      else if(!strcmpi(buffer, "Preprocessor Definitions"))
3494                      {
3495                         if(!strcmpi(section, "Target") && !strcmpi(subSection, "Files"))
3496                         {
3497                            /*if(node && (node.type == NodeTypes::project || (node.type == file && !node.isInResources) || node.type == folder))
3498                               ParseListValue(node.preprocessorDefs, equal);*/
3499                         }
3500                         else
3501                         {
3502                            if(!project.options.preprocessorDefinitions) project.options.preprocessorDefinitions = { };
3503                            ParseArrayValue(project.options.preprocessorDefinitions, equal);
3504                         }
3505                      }
3506                   }
3507                }
3508             }
3509          }
3510       }
3511    }
3512    parent = null;
3513
3514    SplitPlatformLibraries(project);
3515
3516    if(configurationsPresent)
3517       CombineIdenticalConfigOptions(project);
3518    return project;
3519 }
3520
3521 void SplitPlatformLibraries(Project project)
3522 {
3523    if(project && project.configurations)
3524    {
3525       for(cfg : project.configurations)
3526       {
3527          if(cfg.options.libraries && cfg.options.libraries.count)
3528          {
3529             Iterator<String> it { cfg.options.libraries };
3530             while(it.Next())
3531             {
3532                String l = it.data;
3533                char * platformName = strstr(l, ":");
3534                if(platformName)
3535                {
3536                   PlatformOptions platform = null;
3537                   platformName++;
3538                   if(!cfg.platforms) cfg.platforms = { };
3539                   for(p : cfg.platforms)
3540                   {
3541                      if(!strcmpi(platformName, p.name))
3542                      {
3543                         platform = p;
3544                         break;
3545                      }
3546                   }
3547                   if(!platform)
3548                   {
3549                      platform = { name = CopyString(platformName), options = { libraries = { } } };
3550                      cfg.platforms.Add(platform);
3551                   }
3552                   *(platformName-1) = 0;
3553                   platform.options.libraries.Add(CopyString(l));
3554
3555                   cfg.options.libraries.Delete(it.pointer);
3556                   it.pointer = null;
3557                }
3558             }
3559          }
3560       }
3561    }
3562 }
3563
3564 void CombineIdenticalConfigOptions(Project project)
3565 {
3566    if(project && project.configurations && project.configurations.count)
3567    {
3568       DataMember member;
3569       ProjectOptions nullOptions { };
3570       ProjectConfig firstConfig = null;
3571       for(cfg : project.configurations)
3572       {
3573          if(cfg.options.targetType != staticLibrary)
3574          {
3575             firstConfig = cfg;
3576             break;
3577          }
3578       }
3579       if(!firstConfig)
3580          firstConfig = project.configurations.firstIterator.data;
3581
3582       for(member = class(ProjectOptions).membersAndProperties.first; member; member = member.next)
3583       {
3584          if(!member.isProperty)
3585          {
3586             Class type = eSystem_FindClass(__thisModule, member.dataTypeString);
3587             if(type)
3588             {
3589                bool same = true;
3590
3591                for(cfg : project.configurations)
3592                {
3593                   if(cfg != firstConfig)
3594                   {
3595                      if(cfg.options.targetType != staticLibrary)
3596                      {
3597                         int result;
3598
3599                         if(type.type == noHeadClass || type.type == normalClass)
3600                         {
3601                            result = type._vTbl[__ecereVMethodID_class_OnCompare](type,
3602                               *(void **)((byte *)firstConfig.options + member.offset + member._class.offset),
3603                               *(void **)((byte *)cfg.options         + member.offset + member._class.offset));
3604                         }
3605                         else
3606                         {
3607                            result = type._vTbl[__ecereVMethodID_class_OnCompare](type,
3608                               (byte *)firstConfig.options + member.offset + member._class.offset,
3609                               (byte *)cfg.options         + member.offset + member._class.offset);
3610                         }
3611                         if(result)
3612                         {
3613                            same = false;
3614                            break;
3615                         }
3616                      }
3617                   }
3618                }
3619                if(same)
3620                {
3621                   if(type.type == noHeadClass || type.type == normalClass)
3622                   {
3623                      if(!type._vTbl[__ecereVMethodID_class_OnCompare](type,
3624                         *(void **)((byte *)firstConfig.options + member.offset + member._class.offset),
3625                         *(void **)((byte *)nullOptions         + member.offset + member._class.offset)))
3626                         continue;
3627                   }
3628                   else
3629                   {
3630                      if(!type._vTbl[__ecereVMethodID_class_OnCompare](type,
3631                         (byte *)firstConfig.options + member.offset + member._class.offset,
3632                         (byte *)nullOptions         + member.offset + member._class.offset))
3633                         continue;
3634                   }
3635
3636                   if(!project.options) project.options = { };
3637
3638                   /*if(type.type == noHeadClass || type.type == normalClass)
3639                   {
3640                      type._vTbl[__ecereVMethodID_class_OnCopy](type,
3641                         (byte *)project.options + member.offset + member._class.offset,
3642                         *(void **)((byte *)firstConfig.options + member.offset + member._class.offset));
3643                   }
3644                   else
3645                   {
3646                      void * address = (byte *)firstConfig.options + member.offset + member._class.offset;
3647                      // TOFIX: ListBox::SetData / OnCopy mess
3648                      type._vTbl[__ecereVMethodID_class_OnCopy](type,
3649                         (byte *)project.options + member.offset + member._class.offset,
3650                         (type.typeSize > 4) ? address :
3651                            ((type.typeSize == 4) ? (void *)*(uint32 *)address :
3652                               ((type.typeSize == 2) ? (void *)*(uint16*)address :
3653                                  (void *)*(byte *)address )));
3654                   }*/
3655                   memcpy(
3656                      (byte *)project.options + member.offset + member._class.offset,
3657                      (byte *)firstConfig.options + member.offset + member._class.offset, type.typeSize);
3658
3659                   for(cfg : project.configurations)
3660                   {
3661                      if(cfg.options.targetType == staticLibrary)
3662                      {
3663                         int result;
3664
3665                         if(type.type == noHeadClass || type.type == normalClass)
3666                         {
3667                            result = type._vTbl[__ecereVMethodID_class_OnCompare](type,
3668                               *(void **)((byte *)firstConfig.options + member.offset + member._class.offset),
3669                               *(void **)((byte *)cfg.options         + member.offset + member._class.offset));
3670                         }
3671                         else
3672                         {
3673                            result = type._vTbl[__ecereVMethodID_class_OnCompare](type,
3674                               (byte *)firstConfig.options + member.offset + member._class.offset,
3675                               (byte *)cfg.options         + member.offset + member._class.offset);
3676                         }
3677                         if(result)
3678                            continue;
3679                      }
3680                      if(cfg != firstConfig)
3681                      {
3682                         if(type.type == noHeadClass || type.type == normalClass)
3683                         {
3684                            type._vTbl[__ecereVMethodID_class_OnFree](type,
3685                               *(void **)((byte *)cfg.options + member.offset + member._class.offset));
3686                         }
3687                         else
3688                         {
3689                            type._vTbl[__ecereVMethodID_class_OnFree](type,
3690                               (byte *)cfg.options + member.offset + member._class.offset);
3691                         }
3692                         memset((byte *)cfg.options + member.offset + member._class.offset, 0, type.typeSize);
3693                      }
3694                   }
3695                   memset((byte *)firstConfig.options + member.offset + member._class.offset, 0, type.typeSize);
3696                }
3697             }
3698          }
3699       }
3700       delete nullOptions;
3701
3702       // Compare Platform Specific Settings
3703       {
3704          bool same = true;
3705          for(cfg : project.configurations)
3706          {
3707             if(cfg != firstConfig && cfg.options.targetType != staticLibrary && (firstConfig.platforms || cfg.platforms) &&
3708                ((!firstConfig.platforms && cfg.platforms) || firstConfig.platforms.OnCompare(cfg.platforms)))
3709             {
3710                same = false;
3711                break;
3712             }
3713          }
3714          if(same && firstConfig.platforms)
3715          {
3716             for(cfg : project.configurations)
3717             {
3718                if(cfg.options.targetType == staticLibrary && firstConfig.platforms.OnCompare(cfg.platforms))
3719                   continue;
3720                if(cfg != firstConfig)
3721                {
3722                   cfg.platforms.Free();
3723                   delete cfg.platforms;
3724                }
3725             }
3726             project.platforms = firstConfig.platforms;
3727             firstConfig.platforms = null;
3728          }
3729       }
3730
3731       // Static libraries can't contain libraries
3732       for(cfg : project.configurations)
3733       {
3734          if(cfg.options.targetType == staticLibrary)
3735          {
3736             if(!cfg.options.libraries) cfg.options.libraries = { };
3737             cfg.options.libraries.Free();
3738          }
3739       }
3740    }
3741 }
3742
3743 Project LoadProject(char * filePath)
3744 {
3745    Project project = null;
3746    File f = FileOpen(filePath, read);
3747    if(f)
3748    {
3749       project = LegacyBinaryLoadProject(f, filePath);
3750       if(!project)
3751       {
3752          JSONParser parser { f = f };
3753          JSONResult result = parser.GetObject(class(Project), &project);
3754          if(project)
3755          {
3756             char insidePath[MAX_LOCATION];
3757
3758             delete project.topNode.files;
3759             if(!project.files) project.files = { };
3760             project.topNode.files = project.files;
3761             project.resNode = project.topNode.Add(project, "Resources", project.topNode.files.last, resources, archiveFile, false);
3762             delete project.resNode.path;
3763             project.resNode.path = project.resourcesPath;
3764             project.resourcesPath = null;
3765             project.resNode.nodeType = (ProjectNodeType)-1;
3766             delete project.resNode.files;
3767             project.resNode.files = project.resources;
3768             project.files = null;
3769             project.resources = null;
3770             if(!project.configurations) project.configurations = { };
3771
3772             {
3773                char topNodePath[MAX_LOCATION];
3774                GetWorkingDir(topNodePath, sizeof(topNodePath)-1);
3775                MakeSlashPath(topNodePath);
3776                PathCatSlash(topNodePath, filePath);
3777                project.filePath = topNodePath;//filePath;
3778             }
3779
3780             project.topNode.FixupNode(insidePath);
3781          }
3782          delete parser;
3783       }
3784       if(!project)
3785          project = LegacyAsciiLoadProject(f, filePath);
3786
3787       delete f;
3788
3789       if(project)
3790       {
3791          if(!project.options) project.options = { };
3792          if(!project.config && project.configurations)
3793             project.config = project.configurations.firstIterator.data;
3794
3795          if(!project.resNode)
3796          {
3797             project.resNode = project.topNode.Add(project, "Resources", project.topNode.files.last, resources, archiveFile, false);
3798          }
3799
3800          if(!project.moduleName)
3801             project.moduleName = CopyString(project.name);
3802          if(project.config &&
3803             (!project.options || !project.options.targetFileName || !project.options.targetFileName[0]) &&
3804             (!project.config.options.targetFileName || !project.config.options.targetFileName[0]))
3805          {
3806             //delete project.config.options.targetFileName;
3807
3808             project.options.targetFileName = /*CopyString(*/project.moduleName/*)*/;
3809             project.config.options.optimization = none;
3810             project.config.options.debug = true;
3811             //project.config.options.warnings = unset;
3812             project.config.options.memoryGuard = false;
3813             project.config.compilingModified = true;
3814             project.config.linkingModified = true;
3815          }
3816          else if(!project.topNode.name && project.config)
3817          {
3818             project.topNode.name = CopyString(project.config.options.targetFileName);
3819          }
3820
3821          /* // THIS IS NOW AUTOMATED WITH A project CHECK IN ProjectNode
3822          project.topNode.configurations = project.configurations;
3823          project.topNode.platforms = project.platforms;
3824          project.topNode.options = project.options;*/
3825       }
3826    }
3827    return project;
3828 }