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 ecpCommand[MAX_LOCATION];
1351       char eccCommand[MAX_LOCATION];
1352       char ecsCommand[MAX_LOCATION];
1353       char earCommand[MAX_LOCATION];
1354
1355       char * cc = compiler.ccCommand;
1356       char * cxx = compiler.cxxCommand;
1357       char * cpp = compiler.cppCommand;
1358       sprintf(cppCommand, "%s%s%s%s ",
1359             compiler.ccacheEnabled ? "ccache " : "",
1360             compiler.ccacheEnabled && !compiler.distccEnabled ? " " : "",
1361             compiler.distccEnabled ? "distcc " : "",
1362             compiler.cppCommand);
1363       sprintf(ccCommand, "%s%s%s%s ",
1364             compiler.ccacheEnabled ? "ccache " : "",
1365             compiler.ccacheEnabled && !compiler.distccEnabled ? " " : "",
1366             compiler.distccEnabled ? "distcc " : "",
1367             compiler.ccCommand);
1368       sprintf(cxxCommand, "%s%s%s%s ",
1369             compiler.ccacheEnabled ? "ccache " : "",
1370             compiler.ccacheEnabled && !compiler.distccEnabled ? " " : "",
1371             compiler.distccEnabled ? "distcc " : "",
1372             compiler.cxxCommand);
1373       sprintf(ecpCommand, "%s ", compiler.ecpCommand);
1374       sprintf(eccCommand, "%s ", compiler.eccCommand);
1375       sprintf(ecsCommand, "%s ", compiler.ecsCommand);
1376       sprintf(earCommand, "%s ", compiler.earCommand);
1377
1378       while(!f.Eof() && !ide.ShouldStopBuild())
1379       {
1380          bool result = true;
1381          double lastTime = GetTime();
1382          bool wait = true;
1383          while(result)
1384          {
1385             //printf("Peeking and GetLine...\n");
1386             if((result = f.Peek()) && (result = f.GetLine(line, sizeof(line)-1)))
1387             {
1388                char * inFileIncludedFrom = strstr(line, stringInFileIncludedFrom);
1389                if(strstr(line, compiler.makeCommand) == line && line[lenMakeCommand] == ':')
1390                {
1391                   char * module = strstr(line, "No rule to make target `");
1392                   if(module)
1393                   {
1394                      char * end;
1395                      module = strchr(module, '`') + 1;
1396                      end = strchr(module, '\'');
1397                      if(end)
1398                      {
1399                         *end = '\0';
1400                         ide.outputView.buildBox.Logf($"   %s: No such file or directory\n", module);
1401                         // ide.outputView.buildBox.Logf("error: %s\n   No such file or directory\n", module);
1402                         numErrors++;
1403                      }
1404                   }
1405                   //else
1406                   //{
1407                      //ide.outputView.buildBox.Logf("error: %s\n", line);
1408                      //numErrors++;
1409                   //}
1410                }
1411                else if(strstr(line, "ear ") == line);
1412                else if(strstr(line, "strip ") == line);
1413                else if(strstr(line, ccCommand) == line || strstr(line, cxxCommand) == line || strstr(line, ecpCommand) == line || strstr(line, eccCommand) == line)
1414                {
1415                   char moduleName[MAX_FILENAME];
1416                   byte * tokens[1];
1417                   char * module;
1418                   bool isPrecomp = false;
1419
1420                   if(strstr(line, ccCommand) == line || strstr(line, cxxCommand) == line)
1421                   {
1422                      module = strstr(line, " -c ");
1423                      if(module) module += 4;
1424                   }
1425                   else if(strstr(line, eccCommand) == line)
1426                   {
1427                      module = strstr(line, " -c ");
1428                      if(module) module += 4;
1429                      //module = line + 3;
1430                      // Don't show GCC warnings about generated C code because it does not compile clean yet...
1431                      compilingEC = 3;//2;
1432                   }
1433                   else if(strstr(line, ecpCommand) == line)
1434                   {
1435                      // module = line + 8;
1436                      module = strstr(line, " -c ");
1437                      if(module) module += 4;
1438                      isPrecomp = true;
1439                      compilingEC = 0;
1440                   }
1441
1442                   loggedALine = true;
1443
1444                   if(module)
1445                   {
1446                      if(!compiling && !isPrecomp)
1447                      {
1448                         ide.outputView.buildBox.Logf($"Compiling...\n");
1449                         compiling = true;
1450                      }
1451                      else if(!precompiling && isPrecomp)
1452                      {
1453                         ide.outputView.buildBox.Logf($"Generating symbols...\n");
1454                         precompiling = true;
1455                      }
1456                      // Changed escapeBackSlashes here to handle paths with spaces
1457                      Tokenize(module, 1, tokens, true); // false);
1458                      GetLastDirectory(module, moduleName);
1459                      ide.outputView.buildBox.Logf("%s\n", moduleName);
1460                   }
1461                   else if((module = strstr(line, " -o ")))
1462                   {
1463                      compiling = false;
1464                      precompiling = false;
1465                      linking = true;
1466                      ide.outputView.buildBox.Logf($"Linking...\n");
1467                   }
1468                   else
1469                   {
1470                      ide.outputView.buildBox.Logf("%s\n", line);
1471                      numErrors++;
1472                   }
1473
1474                   if(compilingEC) compilingEC--;
1475                }
1476                else if(strstr(line, "ar rcs") == line)
1477                   ide.outputView.buildBox.Logf($"Building library...\n");
1478                else if(strstr(line, ecsCommand) == line)
1479                   ide.outputView.buildBox.Logf($"Writing symbol loader...\n");
1480                else
1481                {
1482                   if(linking || compiling || precompiling)
1483                   {
1484                      char * colon = strstr(line, ":"); //, * bracket;
1485                      if(colon && (colon[1] == '/' || colon[1] == '\\'))
1486                         colon = strstr(colon + 1, ":");
1487                      if(colon)
1488                      {
1489                         char moduleName[MAX_LOCATION], temp[MAX_LOCATION];
1490                         char * pointer;
1491                         char * error;
1492                         char * start = inFileIncludedFrom ? line + strlen(stringInFileIncludedFrom) : line;
1493                         int len = (int)(colon - start);
1494                         len = Min(len, MAX_LOCATION-1);
1495                         // Don't be mistaken by the drive letter colon
1496                         // Cut module name
1497                         // TODO: need to fix colon - line gives char *
1498                         // warning: incompatible expression colon - line (char *); expected int
1499                         /*
1500                         strncpy(moduleName, line, (int)(colon - line));
1501                         moduleName[colon - line] = '\0';
1502                         */
1503                         strncpy(moduleName, start, len);
1504                         moduleName[len] = '\0';
1505                         // Remove stuff in brackets
1506                         //bracket = strstr(moduleName, "(");
1507                         //if(bracket) *bracket = '\0';
1508
1509                         GetLastDirectory(moduleName, temp);
1510                         if(linking && (!strcmp(temp, "ld") || !strcmp(temp, "ld.exe")))
1511                         {
1512                            numErrors++;
1513                            strcpy(moduleName, $"Linker Error");
1514                         }
1515                         else
1516                         {
1517                            strcpy(temp, topNode.path);
1518                            PathCatSlash(temp, moduleName);
1519                            MakePathRelative(temp, topNode.path, moduleName);
1520                         }
1521                         if(strstr(line, "error:"))
1522                            numErrors ++;
1523                         else
1524                         {
1525                            // Silence warnings for compiled EC
1526                            char * objDir = strstr(moduleName, objDirExp.dir);
1527
1528                            if(linking)
1529                            {
1530                               if((pointer = strstr(line, "undefined"))  ||
1531                                    (pointer = strstr(line, "No such file")) ||
1532                                    (pointer = strstr(line, "token")))
1533                               {
1534                                  strncat(moduleName, colon, pointer - colon);
1535                                  strcat(moduleName, "error: ");
1536                                  colon = pointer;
1537                                  numErrors ++;
1538                               }
1539                            }
1540                            else if((pointer = strstr(line, "No such file")))
1541                            {
1542                               strncat(moduleName, colon, pointer - colon);
1543                               strcat(moduleName, "error: ");
1544                               colon = pointer;
1545                               numErrors ++;
1546                            }
1547                            else if(compilingEC == 1 || (objDir && objDir == moduleName))
1548                               continue;
1549                            else if(strstr(line, "warning:"))
1550                            {
1551                               numWarnings++;
1552                            }
1553                         }
1554                         if(this == ide.workspace.projects.firstIterator.data)
1555                            ide.outputView.buildBox.Logf("   %s%s\n", moduleName, colon);
1556                         else
1557                         {
1558                            char fullModuleName[MAX_LOCATION];
1559                            strcpy(fullModuleName, topNode.path);
1560                            PathCat(fullModuleName, moduleName);
1561                            MakePathRelative(fullModuleName, ide.workspace.projects.firstIterator.data.topNode.path, fullModuleName);
1562                            MakeSystemPath(fullModuleName);
1563                            ide.outputView.buildBox.Logf("   %s%s%s\n", inFileIncludedFrom ? stringInFileIncludedFrom : "", fullModuleName, colon);
1564                         }
1565                      }
1566                      else
1567                      {
1568                         ide.outputView.buildBox.Logf("%s\n", line);
1569                         linking = compiling = precompiling = false;
1570                      }
1571                   }
1572                   else
1573                      ide.outputView.buildBox.Logf("%s\n", line);
1574                }
1575                wait = false;
1576             }
1577             //printf("Done getting line\n");
1578             if(GetTime() - lastTime > 1.0 / PEEK_RESOLUTION) break;
1579          }
1580          //printf("Processing Input...\n");
1581          if(app.ProcessInput(true))
1582             wait = false;
1583          app.UpdateDisplay();
1584          if(wait)
1585          {
1586             //printf("Waiting...\n");
1587             app.Wait();
1588          }
1589          //if(!result) Sleep(1.0 / PEEK_RESOLUTION);
1590       }
1591       if(ide.ShouldStopBuild())
1592       {
1593          ide.outputView.buildBox.Logf($"\nBuild cancelled by user.\n", line);
1594          f.Terminate();
1595       }
1596       else if(loggedALine || !isARun)
1597       {
1598          if(f.GetExitCode() && !numErrors)
1599          {
1600             bool result = f.GetLine(line, sizeof(line)-1);
1601             ide.outputView.buildBox.Logf($"Fatal Error: child process terminated unexpectedly\n");
1602          }
1603          else
1604          {
1605             if(!onlyNode)
1606                ide.outputView.buildBox.Logf("\n%s (%s) - ", GetTargetFileName(config), configName);
1607             if(numErrors)
1608                ide.outputView.buildBox.Logf("%d %s, ", numErrors, (numErrors > 1) ? $"errors" : $"error");
1609             else
1610                ide.outputView.buildBox.Logf($"no error, ");
1611
1612             if(numWarnings)
1613                ide.outputView.buildBox.Logf("%d %s\n", numWarnings, (numWarnings > 1) ? $"warnings" : $"warning");
1614             else
1615                ide.outputView.buildBox.Logf($"no warning\n");
1616          }
1617       }
1618       return numErrors == 0;
1619    }
1620
1621    void ProcessCleanPipeOutput(DualPipe f, CompilerConfig compiler, ProjectConfig config)
1622    {
1623       char line[65536];
1624       int lenMakeCommand = strlen(compiler.makeCommand);
1625       while(!f.Eof())
1626       {
1627          bool result = true;
1628          bool wait = true;
1629          double lastTime = GetTime();
1630          while(result)
1631          {
1632             if((result = f.Peek()) && (result = f.GetLine(line, sizeof(line)-1)))
1633             {
1634                if(strstr(line, compiler.makeCommand) == line && line[lenMakeCommand] == ':');
1635                else if(strstr(line, "del") == line);
1636                else if(strstr(line, "rm") == line);
1637                else if(strstr(line, "Could Not Find") == line);
1638                else
1639                {
1640                   ide.outputView.buildBox.Logf(line);
1641                   ide.outputView.buildBox.Logf("\n");
1642                }
1643                wait = false;
1644             }
1645             if(GetTime() - lastTime > 1.0 / PEEK_RESOLUTION) break;
1646          }
1647          if(app.ProcessInput(true))
1648             wait = false;
1649          app.UpdateDisplay();
1650          if(wait)
1651             app.Wait();
1652          //Sleep(1.0 / PEEK_RESOLUTION);
1653       }
1654    }
1655
1656    bool Build(bool isARun, ProjectNode onlyNode, CompilerConfig compiler, ProjectConfig config)
1657    {
1658       bool result = false;
1659       DualPipe f;
1660       char targetFileName[MAX_LOCATION] = "";
1661       char makeTarget[MAX_LOCATION] = "";
1662       char makeFile[MAX_LOCATION];
1663       char makeFilePath[MAX_LOCATION];
1664       char configName[MAX_LOCATION];
1665       DirExpression objDirExp = GetObjDir(compiler, config);
1666       PathBackup pathBackup { };
1667       bool crossCompiling = (compiler.targetPlatform != GetRuntimePlatform());
1668       char * targetPlatform = crossCompiling ? (char *)compiler.targetPlatform : "";
1669
1670       int numJobs = compiler.numJobs;
1671       char command[MAX_LOCATION];
1672       char * compilerName;
1673
1674       compilerName = CopyString(compiler.name);
1675       CamelCase(compilerName);
1676
1677       strcpy(configName, config ? config.name : "Common");
1678
1679       SetPath(false, compiler, config); //true
1680       CatTargetFileName(targetFileName, compiler, config);
1681
1682       strcpy(makeFilePath, topNode.path);
1683       CatMakeFileName(makeFile, config);
1684       PathCatSlash(makeFilePath, makeFile);
1685
1686       // TODO: TEST ON UNIX IF \" around makeTarget is ok
1687       if(onlyNode)
1688       {
1689          if(compiler.type.isVC)
1690          {
1691             PrintLn("compiling a single file is not yet supported");
1692          }
1693          else
1694          {
1695             int len;
1696             char pushD[MAX_LOCATION];
1697             char cfDir[MAX_LOCATION];
1698             GetIDECompilerConfigsDir(cfDir, true, true);
1699             GetWorkingDir(pushD, sizeof(pushD));
1700             ChangeWorkingDir(topNode.path);
1701             // Create object dir if it does not exist already
1702             if(!FileExists(objDirExp.dir).isDirectory)
1703             {
1704                sprintf(command, "%s CF_DIR=\"%s\"%s%s COMPILER=%s objdir -C \"%s\" -f \"%s\"",
1705                      compiler.makeCommand, cfDir,
1706                      crossCompiling ? " TARGET_PLATFORM=" : "", targetPlatform,
1707                      compilerName, topNode.path, makeFilePath);
1708 #ifdef _DEBUG
1709                PrintLn(command);
1710                ide.outputView.buildBox.Logf("command: %s\n", command);
1711 #endif
1712                Execute(command);
1713             }
1714
1715             ChangeWorkingDir(pushD);
1716
1717             PathCatSlash(makeTarget+1, objDirExp.dir);
1718             PathCatSlash(makeTarget+1, onlyNode.name);
1719             StripExtension(makeTarget+1);
1720             strcat(makeTarget+1, ".o");
1721             makeTarget[0] = '\"';
1722             len = strlen(makeTarget);
1723             makeTarget[len++] = '\"';
1724             makeTarget[len++] = '\0';
1725          }
1726       }
1727
1728       if(compiler.type.isVC)
1729       {
1730          bool result = false;
1731          char oldwd[MAX_LOCATION];
1732          GetWorkingDir(oldwd, sizeof(oldwd));
1733          ChangeWorkingDir(topNode.path);
1734
1735          sprintf(command, "%s /useenv /nologo /logcommands %s.sln %s|Win32", compiler.makeCommand, name, config.name);
1736          ide.outputView.buildBox.Logf("command: %s\n", command);
1737 #ifdef _DEBUG
1738          PrintLn(command);
1739          ide.outputView.buildBox.Logf("command: %s\n", command);
1740 #endif
1741          if((f = DualPipeOpen(PipeOpenMode { output = true, error = true, input = true }, command)))
1742          {
1743             ProcessPipeOutputRaw(f);
1744             delete f;
1745             result = true;
1746          }
1747          ChangeWorkingDir(oldwd);
1748       }
1749       else
1750       {
1751          char cfDir[MAX_LOCATION];
1752          GetIDECompilerConfigsDir(cfDir, true, true);
1753          sprintf(command, "%s CF_DIR=\"%s\"%s%s COMPILER=%s -j%d %s%s%s -C \"%s\" -f \"%s\"",
1754                compiler.makeCommand, cfDir,
1755                crossCompiling ? " TARGET_PLATFORM=" : "", targetPlatform,
1756                compilerName, numJobs,
1757                compiler.ccacheEnabled ? "CCACHE=y " : "",
1758                compiler.distccEnabled ? "DISTCC=y " : "",
1759                makeTarget, topNode.path, makeFilePath);
1760 #ifdef _DEBUG
1761          PrintLn(command);
1762          ide.outputView.buildBox.Logf("command: %s\n", command);
1763 #endif
1764          if((f = DualPipeOpen(PipeOpenMode { output = true, error = true, input = true }, command)))
1765          {
1766             result = ProcessBuildPipeOutput(f, objDirExp, isARun, onlyNode, compiler, config);
1767             delete f;
1768          }
1769          else
1770          {
1771             ide.outputView.buildBox.Logf($"Error executing make (%s) command\n", compiler.makeCommand);
1772 #ifndef _DEBUG
1773             ide.outputView.buildBox.Logf("command: %s\n", command);
1774 #endif
1775          }
1776       }
1777
1778       delete pathBackup;
1779       delete objDirExp;
1780       delete compilerName;
1781       return result;
1782    }
1783
1784    void Clean(CompilerConfig compiler, ProjectConfig config, bool realclean)
1785    {
1786       char makeFile[MAX_LOCATION];
1787       char makeFilePath[MAX_LOCATION];
1788       char command[MAX_LOCATION];
1789       char * compilerName;
1790       DualPipe f;
1791       PathBackup pathBackup { };
1792       bool crossCompiling = (compiler.targetPlatform != GetRuntimePlatform());
1793       char * targetPlatform = crossCompiling ? (char *)compiler.targetPlatform : "";
1794
1795       compilerName = CopyString(compiler.name);
1796       CamelCase(compilerName);
1797
1798       SetPath(false, compiler, config);
1799
1800       strcpy(makeFilePath, topNode.path);
1801       CatMakeFileName(makeFile, config);
1802       PathCatSlash(makeFilePath, makeFile);
1803
1804       if(compiler.type.isVC)
1805       {
1806          bool result = false;
1807          char oldwd[MAX_LOCATION];
1808          GetWorkingDir(oldwd, sizeof(oldwd));
1809          ChangeWorkingDir(topNode.path);
1810
1811          sprintf(command, "%s /useenv /clean /nologo /logcommands %s.sln %s|Win32", compiler.makeCommand, name, config.name);
1812          ide.outputView.buildBox.Logf("command: %s\n", command);
1813 #ifdef _DEBUG
1814          PrintLn(command);
1815          ide.outputView.buildBox.Logf("command: %s\n", command);
1816 #endif
1817          if((f = DualPipeOpen(PipeOpenMode { output = true, error = true, input = true }, command)))
1818          {
1819             ProcessPipeOutputRaw(f);
1820             delete f;
1821             result = true;
1822          }
1823          ChangeWorkingDir(oldwd);
1824          return result;
1825       }
1826       else
1827       {
1828          char cfDir[MAX_LOCATION];
1829          GetIDECompilerConfigsDir(cfDir, true, true);
1830          sprintf(command, "%s CF_DIR=\"%s\"%s%s COMPILER=%s %sclean -C \"%s\" -f \"%s\"",
1831                compiler.makeCommand, cfDir,
1832                crossCompiling ? " TARGET_PLATFORM=" : "", targetPlatform,
1833                compilerName, realclean ? "real" : "", topNode.path, makeFilePath);
1834 #ifdef _DEBUG
1835          PrintLn(command);
1836          ide.outputView.buildBox.Logf("command: %s\n", command);
1837 #endif
1838          if((f = DualPipeOpen(PipeOpenMode { output = 1, error = 1, input = 2 }, command)))
1839          {
1840             ide.outputView.buildBox.Tell($"Deleting target and object files...");
1841             ProcessCleanPipeOutput(f, compiler, config);
1842             delete f;
1843
1844             ide.outputView.buildBox.Logf($"Target and object files deleted\n");
1845          }
1846       }
1847
1848       delete pathBackup;
1849       delete compilerName;
1850    }
1851
1852    void Run(char * args, CompilerConfig compiler, ProjectConfig config)
1853    {
1854       String target = new char[maxPathLen];
1855       char oldDirectory[MAX_LOCATION];
1856       DirExpression targetDirExp = GetTargetDir(compiler, config);
1857       PathBackup pathBackup { };
1858
1859       // Build(project, ideMain, true, null);
1860
1861    #if defined(__WIN32__)
1862       strcpy(target, topNode.path);
1863    #else
1864       strcpy(target, "");
1865    #endif
1866       PathCatSlash(target, targetDirExp.dir);
1867       CatTargetFileName(target, compiler, config);
1868       sprintf(target, "%s %s", target, args);
1869       GetWorkingDir(oldDirectory, MAX_LOCATION);
1870
1871       if(strlen(ide.workspace.debugDir))
1872       {
1873          char temp[MAX_LOCATION];
1874          strcpy(temp, topNode.path);
1875          PathCatSlash(temp, ide.workspace.debugDir);
1876          ChangeWorkingDir(temp);
1877       }
1878       else
1879          ChangeWorkingDir(topNode.path);
1880       // ChangeWorkingDir(topNode.path);
1881       SetPath(true, compiler, config);
1882       if(compiler.execPrefixCommand)
1883       {
1884          char * prefixedTarget = new char[strlen(compiler.execPrefixCommand) + strlen(target) + 2];
1885          prefixedTarget[0] = '\0';
1886          strcat(prefixedTarget, compiler.execPrefixCommand);
1887          strcat(prefixedTarget, " ");
1888          strcat(prefixedTarget, target);
1889          Execute(prefixedTarget);
1890          delete prefixedTarget;
1891       }
1892       else
1893          Execute(target);
1894
1895       ChangeWorkingDir(oldDirectory);
1896       delete pathBackup;
1897
1898       delete targetDirExp;
1899       delete target;
1900    }
1901
1902    void Compile(ProjectNode node, CompilerConfig compiler, ProjectConfig config)
1903    {
1904       Build(false, node, compiler, config);
1905    }
1906 #endif
1907
1908    void GetMakefileTargetFileName(TargetTypes targetType, char * fileName, ProjectConfig config)
1909    {
1910       fileName[0] = '\0';
1911       if(targetType == staticLibrary || targetType == sharedLibrary)
1912          strcat(fileName, "$(LP)");
1913       // !!! ReplaceSpaces must be done after all PathCat calls !!!
1914       // ReplaceSpaces(s, GetTargetFileName(config));
1915       strcat(fileName, GetTargetFileName(config));
1916       switch(targetType)
1917       {
1918          case executable:
1919             strcat(fileName, "$(E)");
1920             break;
1921          case sharedLibrary:
1922             strcat(fileName, "$(SO)");
1923             break;
1924          case staticLibrary:
1925             strcat(fileName, "$(A)");
1926             break;
1927       }
1928    }
1929
1930    bool GenerateCrossPlatformMk()
1931    {
1932       bool result = false;
1933       char path[MAX_LOCATION];
1934
1935       if(!GetProjectCompilerConfigsDir(path, false, false))
1936          GetIDECompilerConfigsDir(path, false, false);
1937
1938       if(!FileExists(path).isDirectory)
1939       {
1940          MakeDir(path);
1941          {
1942             char dirName[MAX_FILENAME];
1943             GetLastDirectory(path, dirName);
1944             if(!strcmp(dirName, ".configs"))
1945                FileSetAttribs(path, FileAttribs { isHidden = true });
1946          }
1947       }
1948       PathCatSlash(path, "crossplatform.mk");
1949
1950       if(FileExists(path))
1951          DeleteFile(path);
1952       {
1953          File include = FileOpen(":crossplatform.mk", read);
1954          if(include)
1955          {
1956             File f = FileOpen(path, write);
1957             if(f)
1958             {
1959                for(; !include.Eof(); )
1960                {
1961                   char buffer[4096];
1962                   int count = include.Read(buffer, 1, 4096);
1963                   f.Write(buffer, 1, count);
1964                }
1965                delete f;
1966
1967                result = true;
1968             }
1969             delete include;
1970          }
1971       }
1972       return result;
1973    }
1974
1975    bool GenerateCompilerCf(CompilerConfig compiler)
1976    {
1977       bool result = false;
1978       char path[MAX_LOCATION];
1979       char * name;
1980       char * compilerName;
1981       bool gccCompiler = compiler.ccCommand && (strstr(compiler.ccCommand, "gcc") != null || strstr(compiler.ccCommand, "g++") != null);
1982       Platform platform = compiler.targetPlatform;
1983
1984       compilerName = CopyString(compiler.name);
1985       CamelCase(compilerName);
1986       name = PrintString(platform, "-", compilerName, ".cf");
1987
1988       if(!GetProjectCompilerConfigsDir(path, false, false))
1989          GetIDECompilerConfigsDir(path, false, false);
1990
1991       if(!FileExists(path).isDirectory)
1992       {
1993          MakeDir(path);
1994          {
1995             char dirName[MAX_FILENAME];
1996             GetLastDirectory(path, dirName);
1997             if(!strcmp(dirName, ".configs"))
1998                FileSetAttribs(path, FileAttribs { isHidden = true });
1999          }
2000       }
2001       PathCatSlash(path, name);
2002
2003       if(FileExists(path))
2004          DeleteFile(path);
2005       {
2006          File f = FileOpen(path, write);
2007          if(f)
2008          {
2009             f.Printf("# TOOLCHAIN\n\n");
2010
2011             //f.Printf("SHELL := %s\n", "sh"/*compiler.shellCommand*/); // is this really needed?
2012             f.Printf("CPP := %s\n", compiler.cppCommand);
2013             f.Printf("CC := $(CCACHE_COMPILE) $(DISTCC_COMPILE) %s\n", compiler.ccCommand);
2014             f.Printf("CXX := $(CCACHE_COMPILE) $(DISTCC_COMPILE) %s\n", compiler.cxxCommand);
2015             f.Printf("ECP := %s\n", compiler.ecpCommand);
2016             f.Printf("ECC := %s\n", compiler.eccCommand);
2017             f.Printf("ECS := %s -t $(TARGET_PLATFORM)\n", compiler.ecsCommand);
2018             f.Printf("EAR := %s\n", compiler.earCommand);
2019
2020             f.Printf("AS := as\n");
2021             f.Printf("LD := ld\n");
2022             f.Printf("AR := ar\n");
2023             f.Printf("STRIP := strip\n");
2024             f.Printf("UPX := upx\n");
2025
2026             f.Printf("\n");
2027             if(compiler.environmentVars && compiler.environmentVars.count)
2028             {
2029                f.Printf("# ENVIRONMENT VARIABLES\n");
2030                for(e : compiler.environmentVars)
2031                {
2032                   f.Printf("export %s := %s\n", e.name, e.string);
2033                }
2034             }
2035
2036             f.Printf("UPXFLAGS = -9\n\n"); // TOFEAT: Compression Level Option? Other UPX Options?
2037
2038             f.Printf("# HARD CODED TARGET_PLATFORM-SPECIFIC OPTIONS\n");
2039             f.Printf("ifdef %s\n", PlatformToMakefileTargetVariable(tux));
2040             f.Printf("LDFLAGS += -Wl,--no-undefined\n");
2041             f.Printf("endif\n\n");
2042
2043             // JF's
2044             f.Printf("ifdef %s\n", PlatformToMakefileTargetVariable(apple));
2045             f.Printf("LDFLAGS += -framework cocoa -framework OpenGL\n");
2046             f.Printf("endif\n");
2047
2048             if(gccCompiler)
2049             {
2050                f.Printf("\nCFLAGS += -fmessage-length=0\n");
2051             }
2052
2053             if(compiler.includeDirs && compiler.includeDirs.count)
2054             {
2055                f.Printf("\nCFLAGS +=");
2056                OutputListOption(f, gccCompiler ? "isystem " : "I", compiler.includeDirs, lineEach, true);
2057                f.Printf("\n");
2058             }
2059             if(compiler.prepDirectives && compiler.prepDirectives.count)
2060             {
2061                f.Printf("\nCFLAGS +=");
2062                OutputListOption(f, "D", compiler.prepDirectives, inPlace, true);
2063                f.Printf("\n");
2064             }
2065             if(compiler.libraryDirs && compiler.libraryDirs.count)
2066             {
2067                f.Printf("\nLDFLAGS +=");
2068                OutputListOption(f, "L", compiler.libraryDirs, lineEach, true);
2069                // We would need a bool option to know whether we want to add to rpath as well...
2070                // OutputListOption(f, "Wl,-rpath ", compiler.libraryDirs, lineEach, true);
2071                f.Printf("\n");
2072             }
2073             if(compiler.excludeLibs && compiler.excludeLibs.count)
2074             {
2075                f.Puts("\nEXCLUDED_LIBS =");
2076                for(l : compiler.excludeLibs)
2077                {
2078                   f.Puts(" ");
2079                   f.Puts(l);
2080                }
2081             }
2082             if(compiler.linkerFlags && compiler.linkerFlags.count)
2083             {
2084                f.Printf("\nLDFLAGS +=");
2085                OutputListOption(f, "Wl,", compiler.linkerFlags, inPlace, true);
2086                f.Printf("\n");
2087             }
2088             f.Printf("\nFORCE_64_BIT = %s", compiler.supportsBitDepth ? "-m64" : "");
2089             f.Printf("\nFORCE_32_BIT = %s", compiler.supportsBitDepth ? "-m32" : "");
2090             f.Printf("\n");
2091
2092             delete f;
2093          }
2094       }
2095       delete name;
2096       delete compilerName;
2097       return result;
2098    }
2099
2100    bool GenerateMakefile(char * altMakefilePath, bool noResources, char * includemkPath, ProjectConfig config)
2101    {
2102       bool result = false;
2103       char filePath[MAX_LOCATION];
2104       char makeFile[MAX_LOCATION];
2105       // PathBackup pathBackup { };
2106       // char oldDirectory[MAX_LOCATION];
2107       File f = null;
2108
2109       if(!altMakefilePath)
2110       {
2111          strcpy(filePath, topNode.path);
2112          CatMakeFileName(makeFile, config);
2113          PathCatSlash(filePath, makeFile);
2114       }
2115
2116       f = FileOpen(altMakefilePath ? altMakefilePath : filePath, write);
2117
2118       /*SetPath(false, compiler, config);
2119       GetWorkingDir(oldDirectory, MAX_LOCATION);
2120       ChangeWorkingDir(topNode.path);*/
2121
2122       if(f)
2123       {
2124          bool test;
2125          int ifCount;
2126          Platform platform;
2127          char targetDir[MAX_LOCATION];
2128          char objDirExpNoSpaces[MAX_LOCATION];
2129          char objDirNoSpaces[MAX_LOCATION];
2130          char resDirNoSpaces[MAX_LOCATION];
2131          char targetDirExpNoSpaces[MAX_LOCATION];
2132          char fixedModuleName[MAX_FILENAME];
2133          char fixedConfigName[MAX_FILENAME];
2134          int c, len;
2135          // Non-zero if we're building eC code
2136          // We'll have to be careful with this when merging configs where eC files can be excluded in some configs and included in others
2137          int numCObjects = 0;
2138          bool containsCXX = false; // True if the project contains a C++ file
2139          bool sameObjTargetDirs;
2140          String objDirExp = GetObjDirExpression(config);
2141          TargetTypes targetType = GetTargetType(config);
2142
2143          char cfDir[MAX_LOCATION];
2144          int objectsParts, eCsourcesParts;
2145          Array<String> listItems { };
2146          Map<String, int> varStringLenDiffs { };
2147          Map<String, NameCollisionInfo> namesInfo { };
2148          bool forceBitDepth = false;
2149
2150          ReplaceSpaces(objDirNoSpaces, objDirExp);
2151          strcpy(targetDir, GetTargetDirExpression(config));
2152          ReplaceSpaces(targetDirExpNoSpaces, targetDir);
2153
2154          strcpy(objDirExpNoSpaces, GetObjDirExpression(config));
2155          ChangeCh(objDirExpNoSpaces, '\\', '/'); // TODO: this is a hack, paths should never include win32 path seperators - fix this in ProjectSettings and ProjectLoad instead
2156          ReplaceSpaces(objDirExpNoSpaces, objDirExpNoSpaces);
2157          ReplaceSpaces(resDirNoSpaces, resNode.path ? resNode.path : "");
2158          ReplaceSpaces(fixedModuleName, moduleName);
2159          ReplaceSpaces(fixedConfigName, GetConfigName(config));
2160          CamelCase(fixedConfigName);
2161
2162          sameObjTargetDirs = !fstrcmp(objDirExpNoSpaces, targetDirExpNoSpaces);
2163
2164          f.Printf(".PHONY: all objdir%s clean realclean\n\n", sameObjTargetDirs ? "" : " targetdir");
2165
2166          f.Printf("# CONTENT\n\n");
2167
2168          f.Printf("MODULE := %s\n", fixedModuleName);
2169          //f.Printf("VERSION = %s\n", version);
2170          f.Printf("CONFIG := %s\n", fixedConfigName);
2171          f.Printf("ifndef COMPILER\n");
2172          f.Printf("COMPILER := default\n");
2173          f.Printf("endif\n");
2174          f.Printf("\n");
2175
2176          if(compilerConfigsDir && compilerConfigsDir[0])
2177          {
2178             strcpy(cfDir, compilerConfigsDir);
2179             if(cfDir && cfDir[0] && cfDir[strlen(cfDir)-1] != '/')
2180                strcat(cfDir, "/");
2181          }
2182          else
2183          {
2184             GetIDECompilerConfigsDir(cfDir, true, true);
2185             // Use CF_DIR environment variable for absolute paths only
2186             if(cfDir[0] == '/' || (cfDir[0] && cfDir[1] == ':'))
2187                strcpy(cfDir, "$(CF_DIR)");
2188          }
2189
2190          f.Printf("_CF_DIR = %s\n", cfDir);
2191          f.Printf("\n");
2192
2193          f.Printf("ifndef DEBUG\n");
2194          f.Printf("OPTIMIZE :=");
2195          switch(GetOptimization(config))
2196          {
2197             case speed:
2198                f.Printf(" -O2");
2199                f.Printf(" -ffast-math");
2200                break;
2201             case size:
2202                f.Printf(" -Os");
2203                break;
2204          }
2205          if(GetDebug(config))
2206             f.Printf(" -g");
2207          f.Printf("\n");
2208          f.Printf("else\n");
2209          f.Printf("OPTIMIZE := -g\n");
2210          f.Printf("NOSTRIP := y\n");
2211          f.Printf("endif\n");
2212
2213          test = GetTargetTypeIsSetByPlatform(config);
2214          if(test)
2215          {
2216             ifCount = 0;
2217             for(platform = (Platform)1; platform < Platform::enumSize; platform++)
2218             {
2219                TargetTypes targetType;
2220                PlatformOptions projectPOs, configPOs;
2221                MatchProjectAndConfigPlatformOptions(config, platform, &projectPOs, &configPOs);
2222                targetType = platformTargetType;
2223                if(targetType)
2224                {
2225                   if(ifCount)
2226                      f.Printf("else\n");
2227                   ifCount++;
2228                   f.Printf("ifdef %s\n", PlatformToMakefileTargetVariable(platform));
2229
2230                   f.Printf("TARGET_TYPE = ");
2231                   f.Printf(TargetTypeToMakefileVariable(targetType));
2232                   f.Printf("\n");
2233                }
2234             }
2235             f.Printf("else\n"); // ifCount should always be > 0
2236          }
2237          f.Printf("TARGET_TYPE = ");
2238          f.Printf(TargetTypeToMakefileVariable(targetType));
2239          f.Printf("\n");
2240          if(test)
2241          {
2242             if(ifCount)
2243             {
2244                for(c = 0; c < ifCount; c++)
2245                   f.Printf("endif\n");
2246             }
2247          }
2248          f.Printf("\n");
2249
2250          f.Printf("ifeq \"$(TARGET_TYPE)\" \"%s\"\n", TargetTypeToMakefileVariable(executable));
2251          f.Printf("CONSOLE = %s\n", GetConsole(config) ? "-mconsole" : "-mwindows");
2252          f.Printf("endif\n\n");
2253
2254          f.Printf("# FLAGS\n\n");
2255
2256          f.Printf("CFLAGS =\n");
2257          f.Printf("CECFLAGS =\n");
2258          f.Printf("ECFLAGS =\n");
2259          f.Printf("OFLAGS =\n");
2260          f.Printf("LDFLAGS =\n");
2261          f.Printf("LIBS =\n");
2262          f.Printf("\n");
2263
2264          f.Printf("# INCLUDES\n\n");
2265
2266          f.Printf("include %s\n", includemkPath ? includemkPath : "$(_CF_DIR)crossplatform.mk");
2267          f.Printf("include $(_CF_DIR)$(TARGET_PLATFORM)-$(COMPILER).cf\n");
2268          f.Printf("\n");
2269
2270          f.Printf("# VARIABLES\n\n");
2271
2272          f.Printf("OBJ = %s%s\n\n", objDirExpNoSpaces, objDirExpNoSpaces[0] ? "/" : "");
2273
2274          f.Printf("ifdef DEBUG\n");
2275          f.Printf("CFLAGS += -D_DEBUG\n");
2276          f.Printf("endif\n\n");
2277
2278          f.Printf("RES = %s%s\n\n", resDirNoSpaces, resDirNoSpaces[0] ? "/" : "");
2279
2280          // test = GetTargetTypeIsSetByPlatform(config);
2281          {
2282             char target[MAX_LOCATION];
2283             char targetNoSpaces[MAX_LOCATION];
2284          if(test)
2285          {
2286             TargetTypes type;
2287             ifCount = 0;
2288             for(type = (TargetTypes)1; type < TargetTypes::enumSize; type++)
2289             {
2290                if(type != targetType)
2291                {
2292                   if(ifCount)
2293                      f.Printf("else\n");
2294                   ifCount++;
2295                   f.Printf("ifeq \"$(TARGET_TYPE)\" \"%s\"\n", TargetTypeToMakefileVariable(type));
2296
2297                   GetMakefileTargetFileName(type, target, config);
2298                   strcpy(targetNoSpaces, targetDir);
2299                   PathCatSlash(targetNoSpaces, target);
2300                   ReplaceSpaces(targetNoSpaces, targetNoSpaces);
2301                   f.Printf("TARGET = %s\n", targetNoSpaces);
2302                }
2303             }
2304             f.Printf("else\n"); // ifCount should always be > 0
2305          }
2306          GetMakefileTargetFileName(targetType, target, config);
2307          strcpy(targetNoSpaces, targetDir);
2308          PathCatSlash(targetNoSpaces, target);
2309          ReplaceSpaces(targetNoSpaces, targetNoSpaces);
2310          f.Printf("TARGET = %s\n", targetNoSpaces);
2311
2312          if(test)
2313          {
2314             if(ifCount)
2315             {
2316                for(c = 0; c < ifCount; c++)
2317                   f.Printf("endif\n");
2318             }
2319          }
2320          }
2321          f.Printf("\n");
2322
2323          // Use something fixed here, to not cause Makefile differences across compilers...
2324          varStringLenDiffs["$(OBJ)"] = 30; // strlen("obj/memoryGuard.android.gcc-4.6.2") - 6;
2325          // varStringLenDiffs["$(OBJ)"] = strlen(objDirNoSpaces) - 6;
2326
2327          topNode.GenMakefileGetNameCollisionInfo(namesInfo, config);
2328
2329          numCObjects = topNode.GenMakefilePrintNode(f, this, objects, namesInfo, listItems, config, &containsCXX);
2330          if(numCObjects)
2331             listItems.Add(CopyString("$(OBJ)$(MODULE).main$(O)"));
2332          objectsParts = OutputFileList(f, "OBJECTS", listItems, varStringLenDiffs, null);
2333
2334          {
2335             int c;
2336             char * map[4][2] = { { "COBJECTS", "C" }, { "SYMBOLS", "S" }, { "IMPORTS", "I" }, { "BOWLS", "B" } };
2337
2338             topNode.GenMakefilePrintNode(f, this, eCsources, namesInfo, listItems, config, null);
2339             eCsourcesParts = OutputFileList(f, "_ECSOURCES", listItems, varStringLenDiffs, null);
2340
2341             f.Printf("ECSOURCES = $(call shwspace,$(_ECSOURCES))\n");
2342             if(eCsourcesParts > 1)
2343             {
2344                for(c = 1; c <= eCsourcesParts; c++)
2345                   f.Printf("ECSOURCES%d = $(call shwspace,$(_ECSOURCES%d))\n", c, c);
2346             }
2347             f.Printf("\n");
2348
2349             for(c = 0; c < 3; c++)
2350             {
2351                if(eCsourcesParts > 1)
2352                {
2353                   int n;
2354                   f.Printf("%s =", map[c][0]);
2355                   for(n = 1; n <= eCsourcesParts; n++)
2356                      f.Printf(" $(%s%d)", map[c][0], n);
2357                   f.Printf("\n");
2358                   for(n = 1; n <= eCsourcesParts; n++)
2359                      f.Printf("%s%d = $(call shwspace,$(addprefix $(OBJ),$(patsubst %%.ec,%%$(%s),$(notdir $(_ECSOURCES%d)))))\n", map[c][0], n, map[c][1], n);
2360                }
2361                else if(eCsourcesParts == 1)
2362                   f.Printf("%s = $(call shwspace,$(addprefix $(OBJ),$(patsubst %%.ec,%%$(%s),$(notdir $(_ECSOURCES)))))\n", map[c][0], map[c][1]);
2363                f.Printf("\n");
2364             }
2365          }
2366
2367          topNode.GenMakefilePrintNode(f, this, sources, null, listItems, config, null);
2368          OutputFileList(f, "SOURCES", listItems, varStringLenDiffs, "$(ECSOURCES)");
2369
2370          if(!noResources)
2371             resNode.GenMakefilePrintNode(f, this, resources, null, listItems, config, null);
2372          OutputFileList(f, "RESOURCES", listItems, varStringLenDiffs, null);
2373
2374          f.Printf("LIBS += $(SHAREDLIB) $(EXECUTABLE) $(LINKOPT)\n\n");
2375          if((config && config.options && config.options.libraries) ||
2376                (options && options.libraries))
2377          {
2378             f.Printf("ifneq \"$(TARGET_TYPE)\" \"%s\"\n", TargetTypeToMakefileVariable(staticLibrary));
2379             f.Printf("LIBS +=");
2380             if(config && config.options && config.options.libraries)
2381                OutputLibraries(f, config.options.libraries);
2382             else if(options && options.libraries)
2383                OutputLibraries(f, options.libraries);
2384             f.Printf("\n");
2385             f.Printf("endif\n");
2386             f.Printf("\n");
2387          }
2388
2389          if(platforms || (config && config.platforms))
2390          {
2391             ifCount = 0;
2392             //for(platform = firstPlatform; platform <= lastPlatform; platform++)
2393             //for(platform = win32; platform <= apple; platform++)
2394
2395             f.Printf("# TARGET_PLATFORM-SPECIFIC OPTIONS\n\n");
2396             for(platform = (Platform)1; platform < Platform::enumSize; platform++)
2397             {
2398                PlatformOptions projectPlatformOptions, configPlatformOptions;
2399                MatchProjectAndConfigPlatformOptions(config, platform, &projectPlatformOptions, &configPlatformOptions);
2400
2401                if(projectPlatformOptions || configPlatformOptions)
2402                {
2403                   if(ifCount)
2404                      f.Printf("else\n");
2405                   ifCount++;
2406                   f.Printf("ifdef %s\n", PlatformToMakefileTargetVariable(platform));
2407                   f.Printf("\n");
2408
2409                   if((projectPlatformOptions && projectPlatformOptions.options.preprocessorDefinitions && projectPlatformOptions.options.preprocessorDefinitions.count) ||
2410                      (configPlatformOptions && configPlatformOptions.options.preprocessorDefinitions && configPlatformOptions.options.preprocessorDefinitions.count) ||
2411                      (projectPlatformOptions && projectPlatformOptions.options.includeDirs && projectPlatformOptions.options.includeDirs.count) ||
2412                      (configPlatformOptions && configPlatformOptions.options.includeDirs && configPlatformOptions.options.includeDirs.count))
2413                   {
2414                      f.Printf("CFLAGS +=");
2415                      if(projectPlatformOptions && projectPlatformOptions.options.linkerOptions && projectPlatformOptions.options.linkerOptions.count)
2416                      {
2417                         f.Printf(" \\\n\t -Wl");
2418                         for(s : projectPlatformOptions.options.linkerOptions)
2419                            f.Printf(",%s", s);
2420                      }
2421                      if(configPlatformOptions && configPlatformOptions.options.linkerOptions && configPlatformOptions.options.linkerOptions.count)
2422                      {
2423                         f.Printf(" \\\n\t -Wl");
2424                         for(s : configPlatformOptions.options.linkerOptions)
2425                            f.Printf(",%s", s);
2426                      }
2427                      if(projectPlatformOptions && projectPlatformOptions.options.preprocessorDefinitions)
2428                         OutputListOption(f, "D", projectPlatformOptions.options.preprocessorDefinitions, newLine, false);
2429                      if(configPlatformOptions && configPlatformOptions.options.preprocessorDefinitions)
2430                         OutputListOption(f, "D", configPlatformOptions.options.preprocessorDefinitions, newLine, false );
2431                      if(configPlatformOptions && configPlatformOptions.options.includeDirs)
2432                         OutputListOption(f, "I", configPlatformOptions.options.includeDirs, lineEach, true);
2433                      if(projectPlatformOptions && projectPlatformOptions.options.includeDirs)
2434                         OutputListOption(f, "I", projectPlatformOptions.options.includeDirs, lineEach, true);
2435                      f.Printf("\n\n");
2436                   }
2437
2438                   if((projectPlatformOptions && projectPlatformOptions.options.libraryDirs && projectPlatformOptions.options.libraryDirs.count) ||
2439                         (configPlatformOptions && configPlatformOptions.options.libraryDirs && configPlatformOptions.options.libraryDirs.count) ||
2440                         (projectPlatformOptions && projectPlatformOptions.options.libraries && projectPlatformOptions.options.libraries.count) ||
2441                         (configPlatformOptions && configPlatformOptions.options.libraries && configPlatformOptions.options.libraries.count))
2442                   {
2443                      f.Printf("ifneq \"$(TARGET_TYPE)\" \"%s\"\n", TargetTypeToMakefileVariable(staticLibrary));
2444                      if((projectPlatformOptions && projectPlatformOptions.options.libraryDirs && projectPlatformOptions.options.libraryDirs.count) ||
2445                         (configPlatformOptions && configPlatformOptions.options.libraryDirs && configPlatformOptions.options.libraryDirs.count))
2446                      {
2447                         f.Printf("OFLAGS +=");
2448                         if(configPlatformOptions && configPlatformOptions.options.libraryDirs)
2449                            OutputListOption(f, "L", configPlatformOptions.options.libraryDirs, lineEach, true);
2450                         if(projectPlatformOptions && projectPlatformOptions.options.libraryDirs)
2451                            OutputListOption(f, "L", projectPlatformOptions.options.libraryDirs, lineEach, true);
2452                         f.Printf("\n");
2453                      }
2454
2455                      if((configPlatformOptions && configPlatformOptions.options.libraries))
2456                      {
2457                         if(configPlatformOptions.options.libraries.count)
2458                         {
2459                            f.Printf("LIBS +=");
2460                            OutputLibraries(f, configPlatformOptions.options.libraries);
2461                            f.Printf("\n");
2462                         }
2463                      }
2464                      else if(projectPlatformOptions && projectPlatformOptions.options.libraries)
2465                      {
2466                         if(projectPlatformOptions.options.libraries.count)
2467                         {
2468                            f.Printf("LIBS +=");
2469                            OutputLibraries(f, projectPlatformOptions.options.libraries);
2470                            f.Printf("\n");
2471                         }
2472                      }
2473                      f.Printf("endif\n\n");
2474                   }
2475                }
2476             }
2477             if(ifCount)
2478             {
2479                for(c = 0; c < ifCount; c++)
2480                   f.Printf("endif\n");
2481             }
2482             f.Printf("\n");
2483          }
2484
2485          f.Printf("CFLAGS +=");
2486          //if(gccCompiler)
2487          {
2488             f.Printf(" $(OPTIMIZE)");
2489             forceBitDepth = (options && options.buildBitDepth) || numCObjects;
2490             if(forceBitDepth)
2491                f.Printf(" %s",(!options || !options.buildBitDepth || options.buildBitDepth == bits32) ? "$(FORCE_32_BIT)" : "$(FORCE_64_BIT)");
2492             f.Printf(" $(FPIC)");
2493          }
2494          switch(GetWarnings(config))
2495          {
2496             case all: f.Printf(" -Wall"); break;
2497             case none: f.Printf(" -w"); break;
2498          }
2499          if(GetProfile(config))
2500             f.Printf(" -pg");
2501          if(options && options.linkerOptions && options.linkerOptions.count)
2502          {
2503             f.Printf(" \\\n\t -Wl");
2504             for(s : options.linkerOptions)
2505                f.Printf(",%s", s);
2506          }
2507
2508          if(options && options.preprocessorDefinitions)
2509             OutputListOption(f, "D", options.preprocessorDefinitions, newLine, false);
2510          if(config && config.options && config.options.preprocessorDefinitions)
2511             OutputListOption(f, "D", config.options.preprocessorDefinitions, newLine, false);
2512          if(config && config.options && config.options.includeDirs)
2513             OutputListOption(f, "I", config.options.includeDirs, lineEach, true);
2514          if(options && options.includeDirs)
2515             OutputListOption(f, "I", options.includeDirs, lineEach, true);
2516          f.Printf("\n\n");
2517
2518          f.Printf("CECFLAGS += -cpp $(call escspace,$(CPP)) -t $(TARGET_PLATFORM)");
2519          f.Printf("\n\n");
2520
2521          f.Printf("ECFLAGS +=");
2522          if(GetMemoryGuard(config))
2523             f.Printf(" -memguard");
2524          if(GetStrictNameSpaces(config))
2525             f.Printf(" -strictns");
2526          if(GetNoLineNumbers(config))
2527             f.Printf(" -nolinenumbers");
2528          {
2529             char * s;
2530             if((s = GetDefaultNameSpace(config)) && s[0])
2531                f.Printf(" -defaultns %s", s);
2532          }
2533          f.Printf("\n\n");
2534
2535          f.Printf("ifneq \"$(TARGET_TYPE)\" \"%s\"\n", TargetTypeToMakefileVariable(staticLibrary));
2536          f.Printf("OFLAGS +=");
2537          if(forceBitDepth)
2538             f.Printf((!options || !options.buildBitDepth || options.buildBitDepth == bits32) ? " -m32" : " -m64 \\\n");
2539
2540          if(GetProfile(config))
2541             f.Printf(" -pg");
2542          if(config && config.options && config.options.libraryDirs)
2543             OutputListOption(f, "L", config.options.libraryDirs, lineEach, true);
2544          if(options && options.libraryDirs)
2545             OutputListOption(f, "L", options.libraryDirs, lineEach, true);
2546          f.Printf("\n");
2547          f.Printf("OFLAGS += $(LDFLAGS)\n");
2548          f.Printf("endif\n\n");
2549
2550          f.Printf("# TARGETS\n\n");
2551
2552          f.Printf("all: objdir%s $(TARGET)\n\n", sameObjTargetDirs ? "" : " targetdir");
2553
2554          f.Printf("objdir:\n");
2555             f.Printf("\t$(if $(wildcard $(OBJ)),,$(call mkdirq,$(OBJ)))\n");
2556          //f.Printf("# PRE-BUILD COMMANDS\n");
2557          if(options && options.prebuildCommands)
2558          {
2559             for(s : options.prebuildCommands)
2560                if(s && s[0]) f.Printf("\t%s\n", s);
2561          }
2562          if(config && config.options && config.options.prebuildCommands)
2563          {
2564             for(s : config.options.prebuildCommands)
2565                if(s && s[0]) f.Printf("\t%s\n", s);
2566          }
2567          if(platforms || (config && config.platforms))
2568          {
2569             ifCount = 0;
2570             //f.Printf("# TARGET_PLATFORM-SPECIFIC PRE-BUILD COMMANDS\n");
2571             for(platform = (Platform)1; platform < Platform::enumSize; platform++)
2572             {
2573                PlatformOptions projectPOs, configPOs;
2574                MatchProjectAndConfigPlatformOptions(config, platform, &projectPOs, &configPOs);
2575
2576                if((projectPOs && projectPOs.options.prebuildCommands && projectPOs.options.prebuildCommands.count) ||
2577                      (configPOs && configPOs.options.prebuildCommands && configPOs.options.prebuildCommands.count))
2578                {
2579                   if(ifCount)
2580                      f.Printf("else\n");
2581                   ifCount++;
2582                   f.Printf("ifdef ");
2583                   f.Printf(PlatformToMakefileVariable(platform));
2584                   f.Printf("\n");
2585
2586                   if(projectPOs && projectPOs.options.prebuildCommands && projectPOs.options.prebuildCommands.count)
2587                   {
2588                      for(s : projectPOs.options.prebuildCommands)
2589                         if(s && s[0]) f.Printf("\t%s\n", s);
2590                   }
2591                   if(configPOs && configPOs.options.prebuildCommands && configPOs.options.prebuildCommands.count)
2592                   {
2593                      for(s : configPOs.options.prebuildCommands)
2594                         if(s && s[0]) f.Printf("\t%s\n", s);
2595                   }
2596                }
2597             }
2598             if(ifCount)
2599             {
2600                int c;
2601                for(c = 0; c < ifCount; c++)
2602                   f.Printf("endif\n");
2603             }
2604          }
2605          f.Printf("\n");
2606
2607          if(!sameObjTargetDirs)
2608          {
2609             f.Printf("targetdir:\n");
2610                f.Printf("\t$(if $(wildcard %s),,$(call mkdirq,%s))\n\n", targetDirExpNoSpaces, targetDirExpNoSpaces);
2611          }
2612
2613          if(numCObjects)
2614          {
2615             // Main Module (Linking) for ECERE C modules
2616             f.Printf("$(OBJ)$(MODULE).main.ec: $(SYMBOLS) $(COBJECTS)\n");
2617             // use of objDirExpNoSpaces used instead of $(OBJ) to prevent problematic joining of arguments in ecs
2618             f.Printf("\t$(ECS)%s $(ECSLIBOPT) $(SYMBOLS) $(IMPORTS) -symbols %s -o $(OBJ)$(MODULE).main.ec\n\n",
2619                GetConsole(config) ? " -console" : "", objDirExpNoSpaces);
2620             // Main Module (Linking) for ECERE C modules
2621             f.Printf("$(OBJ)$(MODULE).main.c: $(OBJ)$(MODULE).main.ec\n");
2622             f.Printf("\t$(ECP) $(CECFLAGS) $(ECFLAGS) $(CFLAGS)"
2623                   " -c $(OBJ)$(MODULE).main.ec -o $(OBJ)$(MODULE).main.sym -symbols $(OBJ)\n");
2624             f.Printf("\t$(ECC) $(CECFLAGS) $(ECFLAGS) $(CFLAGS) $(FVISIBILITY)"
2625                   " -c $(OBJ)$(MODULE).main.ec -o $(OBJ)$(MODULE).main.c -symbols $(OBJ)\n\n");
2626          }
2627
2628          // *** Target ***
2629
2630          // This would not rebuild the target on updated objects
2631          // f.Printf("$(TARGET): $(SOURCES) $(RESOURCES) | objdir $(SYMBOLS) $(OBJECTS)%s\n", sameObjTargetDirs ? "" : " targetdir");
2632
2633          // This should fix it for good!
2634          f.Printf("$(SYMBOLS): | objdir\n");
2635          f.Printf("$(OBJECTS): | objdir\n");
2636
2637          // This alone was breaking the tarball, object directory does not get created first (order-only rules happen last it seems!)
2638          f.Printf("$(TARGET): $(SOURCES) $(RESOURCES) $(SYMBOLS) $(OBJECTS) | objdir%s\n", sameObjTargetDirs ? "" : " targetdir");
2639
2640          f.Printf("ifneq \"$(TARGET_TYPE)\" \"%s\"\n", TargetTypeToMakefileVariable(staticLibrary));
2641          f.Printf("\t$(%s) $(OFLAGS) $(OBJECTS) $(LIBS) %s-o $(TARGET) $(INSTALLNAME)\n", containsCXX ? "CXX" : "CC", containsCXX ? "-lstdc++ " : "");
2642          if(!GetDebug(config))
2643          {
2644             f.Printf("ifndef NOSTRIP\n");
2645             f.Printf("\t$(STRIP) $(STRIPOPT) $(TARGET)\n");
2646             f.Printf("endif\n");
2647
2648             if(GetCompress(config))
2649             {
2650                f.Printf("ifndef WINDOWS\n");
2651                f.Printf("ifeq \"$(TARGET_TYPE)\" \"%s\"\n", TargetTypeToMakefileVariable(executable));
2652                   f.Printf("\t$(UPX) $(UPXFLAGS) $(TARGET)\n");
2653                f.Printf("endif\n");
2654                f.Printf("else\n");
2655                   f.Printf("\t$(UPX) $(UPXFLAGS) $(TARGET)\n");
2656                f.Printf("endif\n");
2657             }
2658          }
2659          if(resNode.files && resNode.files.count && !noResources)
2660             resNode.GenMakefileAddResources(f, resNode.path, config);
2661          f.Printf("else\n");
2662          f.Printf("\t$(AR) rcs $(TARGET) $(OBJECTS) $(LIBS)\n");
2663          f.Printf("endif\n");
2664
2665          //f.Printf("# POST-BUILD COMMANDS\n");
2666          if(options && options.postbuildCommands)
2667          {
2668             for(s : options.postbuildCommands)
2669                if(s && s[0]) f.Printf("\t%s\n", s);
2670          }
2671          if(config && config.options && config.options.postbuildCommands)
2672          {
2673             for(s : config.options.postbuildCommands)
2674                if(s && s[0]) f.Printf("\t%s\n", s);
2675          }
2676          if(platforms || (config && config.platforms))
2677          {
2678             ifCount = 0;
2679             //f.Printf("# TARGET_PLATFORM-SPECIFIC POST-BUILD COMMANDS\n");
2680             for(platform = (Platform)1; platform < Platform::enumSize; platform++)
2681             {
2682                PlatformOptions projectPOs, configPOs;
2683                MatchProjectAndConfigPlatformOptions(config, platform, &projectPOs, &configPOs);
2684
2685                if((projectPOs && projectPOs.options.postbuildCommands && projectPOs.options.postbuildCommands.count) ||
2686                      (configPOs && configPOs.options.postbuildCommands && configPOs.options.postbuildCommands.count))
2687                {
2688                   if(ifCount)
2689                      f.Printf("else\n");
2690                   ifCount++;
2691                   f.Printf("ifdef ");
2692                   f.Printf(PlatformToMakefileVariable(platform));
2693                   f.Printf("\n");
2694
2695                   if(projectPOs && projectPOs.options.postbuildCommands && projectPOs.options.postbuildCommands.count)
2696                   {
2697                      for(s : projectPOs.options.postbuildCommands)
2698                         if(s && s[0]) f.Printf("\t%s\n", s);
2699                   }
2700                   if(configPOs && configPOs.options.postbuildCommands && configPOs.options.postbuildCommands.count)
2701                   {
2702                      for(s : configPOs.options.postbuildCommands)
2703                         if(s && s[0]) f.Printf("\t%s\n", s);
2704                   }
2705                }
2706             }
2707             if(ifCount)
2708             {
2709                int c;
2710                for(c = 0; c < ifCount; c++)
2711                   f.Printf("endif\n");
2712             }
2713          }
2714          f.Printf("\n");
2715
2716          f.Printf("# SYMBOL RULES\n\n");
2717          {
2718             Map<Platform, bool> excludedPlatforms { };
2719             topNode.GenMakefilePrintSymbolRules(f, this, config, excludedPlatforms);
2720             delete excludedPlatforms;
2721          }
2722
2723          f.Printf("# C OBJECT RULES\n\n");
2724          {
2725             Map<Platform, bool> excludedPlatforms { };
2726             topNode.GenMakefilePrintCObjectRules(f, this, config, excludedPlatforms);
2727             delete excludedPlatforms;
2728          }
2729
2730          f.Printf("# OBJECT RULES\n\n");
2731          // todo call this still but only generate rules whith specific options
2732          // see we-have-file-specific-options in ProjectNode.ec
2733          {
2734             Map<Platform, bool> excludedPlatforms { };
2735             topNode.GenMakefilePrintObjectRules(f, this, namesInfo, config, excludedPlatforms);
2736             delete excludedPlatforms;
2737          }
2738
2739          if(numCObjects)
2740             GenMakefilePrintMainObjectRule(f, config);
2741
2742          f.Printf("clean: objdir%s\n", sameObjTargetDirs ? "" : " targetdir");
2743          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) " : "");
2744          OutputCleanActions(f, "OBJECTS", objectsParts);
2745          if(numCObjects)
2746          {
2747             OutputCleanActions(f, "COBJECTS", eCsourcesParts);
2748             OutputCleanActions(f, "BOWLS", eCsourcesParts);
2749             OutputCleanActions(f, "IMPORTS", eCsourcesParts);
2750             OutputCleanActions(f, "SYMBOLS", eCsourcesParts);
2751          }
2752          f.Printf("\n");
2753
2754          f.Printf("realclean: clean\n");
2755          f.Printf("\t$(call rmrq,$(OBJ))\n");
2756          if(!sameObjTargetDirs)
2757             f.Printf("\t$(call rmdirq,%s)\n", targetDirExpNoSpaces);
2758          f.Printf("\n");
2759
2760          delete f;
2761
2762          listItems.Free();
2763          delete listItems;
2764          varStringLenDiffs.Free();
2765          delete varStringLenDiffs;
2766          namesInfo.Free();
2767          delete namesInfo;
2768
2769          result = true;
2770       }
2771
2772       // ChangeWorkingDir(oldDirectory);
2773       // delete pathBackup;
2774
2775       if(config)
2776          config.makingModified = false;
2777       return result;
2778    }
2779
2780    void GenMakefilePrintMainObjectRule(File f, ProjectConfig config)
2781    {
2782       char extension[MAX_EXTENSION] = "c";
2783       char modulePath[MAX_LOCATION];
2784       char fixedModuleName[MAX_FILENAME];
2785       DualPipe dep;
2786       char command[2048];
2787       char objDirNoSpaces[MAX_LOCATION];
2788       String objDirExp = GetObjDirExpression(config);
2789
2790       ReplaceSpaces(objDirNoSpaces, objDirExp);
2791       ReplaceSpaces(fixedModuleName, moduleName);
2792
2793       //sprintf(fixedModuleName, "%s.main", fixedPrjName);
2794       //strcat(fixedModuleName, ".main");
2795
2796 #if 0       // TODO: Fix nospaces stuff
2797       // *** Dependency command ***
2798       sprintf(command, "gcc -MT $(OBJ)%s$(O) -MM $(OBJ)%s.c", fixedModuleName, fixedModuleName);
2799
2800       // System Includes (from global settings)
2801       for(item : compiler.dirs[Includes])
2802       {
2803          strcat(command, " -isystem ");
2804          if(strchr(item.name, ' '))
2805          {
2806             strcat(command, "\"");
2807             strcat(command, item);
2808             strcat(command, "\"");
2809          }
2810          else
2811             strcat(command, item);
2812       }
2813
2814       for(item = includeDirs.first; item; item = item.next)
2815       {
2816          strcat(command, " -I");
2817          if(strchr(item.name, ' '))
2818          {
2819             strcat(command, "\"");
2820             strcat(command, item.name);
2821             strcat(command, "\"");
2822          }
2823          else
2824             strcat(command, item.name);
2825       }
2826       for(item = preprocessorDefs.first; item; item = item.next)
2827       {
2828          strcat(command, " -D");
2829          strcat(command, item.name);
2830       }
2831
2832       // Execute it
2833       if((dep = DualPipeOpen(PipeOpenMode { output = 1, error = 1, input = 2 }, command)))
2834       {
2835          char line[1024];
2836          bool result = true;
2837          bool firstLine = true;
2838
2839          // To do some time: auto save external dependencies?
2840          while(!dep.Eof())
2841          {
2842             if(dep.GetLine(line, sizeof(line)-1))
2843             {
2844                if(firstLine)
2845                {
2846                   char * colon = strstr(line, ":");
2847                   if(strstr(line, "No such file") || strstr(line, ",") || (colon && strstr(colon+1, ":")))
2848                   {
2849                      result = false;
2850                      break;
2851                   }
2852                   firstLine = false;
2853                }
2854                f.Puts(line);
2855                f.Puts("\n");
2856             }
2857             if(!result) break;
2858          }
2859          delete dep;
2860
2861          // If we failed to generate dependencies...
2862          if(!result)
2863          {
2864 #endif
2865             f.Printf("$(OBJ)$(MODULE).main$(O): $(OBJ)$(MODULE).main.c\n");
2866 #if 0
2867          }
2868       }
2869 #endif
2870
2871       f.Printf("\t$(CC) $(CFLAGS) $(FVISIBILITY) -c $(OBJ)$(MODULE).main.%s -o $(OBJ)$(MODULE).main$(O)\n\n", extension);
2872    }
2873
2874    void MatchProjectAndConfigPlatformOptions(ProjectConfig config, Platform platform,
2875          PlatformOptions * projectPlatformOptions, PlatformOptions * configPlatformOptions)
2876    {
2877       *projectPlatformOptions = null;
2878       *configPlatformOptions = null;
2879       if(platforms)
2880       {
2881          for(p : platforms)
2882          {
2883             if(!strcmpi(p.name, platform))
2884             {
2885                *projectPlatformOptions = p;
2886                break;
2887             }
2888          }
2889       }
2890       if(config && config.platforms)
2891       {
2892          for(p : config.platforms)
2893          {
2894             if(!strcmpi(p.name, platform))
2895             {
2896                *configPlatformOptions = p;
2897                break;
2898             }
2899          }
2900       }
2901    }
2902 }
2903
2904 Project LegacyBinaryLoadProject(File f, char * filePath)
2905 {
2906    Project project = null;
2907    char signature[sizeof(epjSignature)];
2908
2909    f.Read(signature, sizeof(signature), 1);
2910    if(!strncmp(signature, (char *)epjSignature, sizeof(epjSignature)))
2911    {
2912       char topNodePath[MAX_LOCATION];
2913       /*ProjectConfig newConfig
2914       {
2915          name = CopyString("Default");
2916          makingModified = true;
2917          compilingModified = true;
2918          linkingModified = true;
2919          options = { };
2920       };*/
2921
2922       project = Project { options = { } };
2923       LegacyBinaryLoadNode(project.topNode, f);
2924       delete project.topNode.path;
2925       GetWorkingDir(topNodePath, sizeof(topNodePath)-1);
2926       MakeSlashPath(topNodePath);
2927
2928       PathCatSlash(topNodePath, filePath);
2929       project.filePath = topNodePath;
2930
2931       /* THIS IS ALREADY DONE BY filePath property
2932       StripLastDirectory(topNodePath, topNodePath);
2933       project.topNode.path = CopyString(topNodePath);
2934       */
2935       // Shouldn't this be done BEFORE the StripLastDirectory? project.filePath = topNodePath;
2936
2937       // newConfig.options.defaultNameSpace = "";
2938       /*newConfig.objDir.dir = "obj";
2939       newConfig.targetDir.dir = "";*/
2940
2941       //project.configurations = { [ newConfig ] };
2942       //project.config = newConfig;
2943
2944       // Project Settings
2945       if(!f.Eof())
2946       {
2947          int temp;
2948          int len,c, count;
2949          String targetFileName, targetDirectory, objectsDirectory;
2950
2951          // { executable = 0, sharedLibrary = 1, staticLibrary = 2 };
2952          f.Read(&temp, sizeof(int),1);
2953          switch(temp)
2954          {
2955             case 0: project.options.targetType = executable; break;
2956             case 1: project.options.targetType = sharedLibrary; break;
2957             case 2: project.options.targetType = staticLibrary; break;
2958          }
2959
2960          f.Read(&len, sizeof(int),1);
2961          targetFileName = new char[len+1];
2962          f.Read(targetFileName, sizeof(char), len+1);
2963          project.options.targetFileName = targetFileName;
2964          delete targetFileName;
2965
2966          f.Read(&len, sizeof(int),1);
2967          targetDirectory = new char[len+1];
2968          f.Read(targetDirectory, sizeof(char), len+1);
2969          project.options.targetDirectory = targetDirectory;
2970          delete targetDirectory;
2971
2972          f.Read(&len, sizeof(int),1);
2973          objectsDirectory = new byte[len+1];
2974          f.Read(objectsDirectory, sizeof(char), len+1);
2975          project.options.objectsDirectory = objectsDirectory;
2976          delete objectsDirectory;
2977
2978          f.Read(&temp, sizeof(int),1);
2979          project./*config.*/options.debug = temp ? true : false;
2980          f.Read(&temp, sizeof(int),1);
2981          project./*config.*/options.optimization = temp ? speed : none;
2982          f.Read(&temp, sizeof(int),1);
2983          project./*config.*/options.profile = temp ? true : false;
2984          f.Read(&temp, sizeof(int),1);
2985          project.options.warnings = temp ? all : unset;
2986
2987          f.Read(&count, sizeof(int),1);
2988          if(count)
2989          {
2990             project.options.includeDirs = { };
2991             for(c = 0; c < count; c++)
2992             {
2993                char * name;
2994                f.Read(&len, sizeof(int),1);
2995                name = new char[len+1];
2996                f.Read(name, sizeof(char), len+1);
2997                project.options.includeDirs.Add(name);
2998             }
2999          }
3000
3001          f.Read(&count, sizeof(int),1);
3002          if(count)
3003          {
3004             project.options.libraryDirs = { };
3005             for(c = 0; c < count; c++)
3006             {
3007                char * name;
3008                f.Read(&len, sizeof(int),1);
3009                name = new char[len+1];
3010                f.Read(name, sizeof(char), len+1);
3011                project.options.libraryDirs.Add(name);
3012             }
3013          }
3014
3015          f.Read(&count, sizeof(int),1);
3016          if(count)
3017          {
3018             project.options.libraries = { };
3019             for(c = 0; c < count; c++)
3020             {
3021                char * name;
3022                f.Read(&len, sizeof(int),1);
3023                name = new char[len+1];
3024                f.Read(name, sizeof(char), len+1);
3025                project.options.libraries.Add(name);
3026             }
3027          }
3028
3029          f.Read(&count, sizeof(int),1);
3030          if(count)
3031          {
3032             project.options.preprocessorDefinitions = { };
3033             for(c = 0; c < count; c++)
3034             {
3035                char * name;
3036                f.Read(&len, sizeof(int),1);
3037                name = new char[len+1];
3038                f.Read(name, sizeof(char), len+1);
3039                project.options.preprocessorDefinitions.Add(name);
3040             }
3041          }
3042
3043          f.Read(&temp, sizeof(int),1);
3044          project.options.console = temp ? true : false;
3045       }
3046
3047       for(node : project.topNode.files)
3048       {
3049          if(node.type == resources)
3050          {
3051             project.resNode = node;
3052             break;
3053          }
3054       }
3055    }
3056    else
3057       f.Seek(0, start);
3058    return project;
3059 }
3060
3061 void ProjectConfig::LegacyProjectConfigLoad(File f)
3062 {
3063    delete options;
3064    options = { };
3065    while(!f.Eof())
3066    {
3067       char buffer[65536];
3068       char section[128];
3069       char subSection[128];
3070       char * equal;
3071       int len;
3072       uint pos;
3073
3074       pos = f.Tell();
3075       f.GetLine(buffer, 65536 - 1);
3076       TrimLSpaces(buffer, buffer);
3077       TrimRSpaces(buffer, buffer);
3078       if(strlen(buffer))
3079       {
3080          if(buffer[0] == '-')
3081          {
3082             equal = &buffer[0];
3083             equal[0] = ' ';
3084             TrimLSpaces(equal, equal);
3085             if(!strcmpi(subSection, "LibraryDirs"))
3086             {
3087                if(!options.libraryDirs)
3088                   options.libraryDirs = { [ CopyString(equal) ] };
3089                else
3090                   options.libraryDirs.Add(CopyString(equal));
3091             }
3092             else if(!strcmpi(subSection, "IncludeDirs"))
3093             {
3094                if(!options.includeDirs)
3095                   options.includeDirs = { [ CopyString(equal) ] };
3096                else
3097                   options.includeDirs.Add(CopyString(equal));
3098             }
3099          }
3100          else if(buffer[0] == '+')
3101          {
3102             if(name)
3103             {
3104                f.Seek(pos, start);
3105                break;
3106             }
3107             else
3108             {
3109                equal = &buffer[0];
3110                equal[0] = ' ';
3111                TrimLSpaces(equal, equal);
3112                delete name; name = CopyString(equal); // property::name = equal;
3113             }
3114          }
3115          else if(!strcmpi(buffer, "Compiler Options"))
3116             strcpy(section, buffer);
3117          else if(!strcmpi(buffer, "IncludeDirs"))
3118             strcpy(subSection, buffer);
3119          else if(!strcmpi(buffer, "Linker Options"))
3120             strcpy(section, buffer);
3121          else if(!strcmpi(buffer, "LibraryDirs"))
3122             strcpy(subSection, buffer);
3123          else if(!strcmpi(buffer, "Files") || !strcmpi(buffer, "Resources"))
3124          {
3125             f.Seek(pos, start);
3126             break;
3127          }
3128          else
3129          {
3130             equal = strstr(buffer, "=");
3131             if(equal)
3132             {
3133                equal[0] = '\0';
3134                TrimRSpaces(buffer, buffer);
3135                equal++;
3136                TrimLSpaces(equal, equal);
3137                if(!strcmpi(buffer, "Target Name"))
3138                   options.targetFileName = /*CopyString(*/equal/*)*/;
3139                else if(!strcmpi(buffer, "Target Type"))
3140                {
3141                   if(!strcmpi(equal, "Executable"))
3142                      options.targetType = executable;
3143                   else if(!strcmpi(equal, "Shared"))
3144                      options.targetType = sharedLibrary;
3145                   else if(!strcmpi(equal, "Static"))
3146                      options.targetType = staticLibrary;
3147                   else
3148                      options.targetType = executable;
3149                }
3150                else if(!strcmpi(buffer, "Target Directory"))
3151                   options.targetDirectory = /*CopyString(*/equal/*)*/;
3152                else if(!strcmpi(buffer, "Console"))
3153                   options.console = ParseTrueFalseValue(equal);
3154                else if(!strcmpi(buffer, "Libraries"))
3155                {
3156                   if(!options.libraries) options.libraries = { };
3157                   ParseArrayValue(options.libraries, equal);
3158                }
3159                else if(!strcmpi(buffer, "Intermediate Directory"))
3160                   options.objectsDirectory = /*CopyString(*/equal/*)*/; //objDir.expression = equal;
3161                else if(!strcmpi(buffer, "Debug"))
3162                   options.debug = ParseTrueFalseValue(equal);
3163                else if(!strcmpi(buffer, "Optimize"))
3164                {
3165                   if(!strcmpi(equal, "None"))
3166                      options.optimization = none;
3167                   else if(!strcmpi(equal, "Speed") || !strcmpi(equal, "True"))
3168                      options.optimization = speed;
3169                   else if(!strcmpi(equal, "Size"))
3170                      options.optimization = size;
3171                   else
3172                      options.optimization = none;
3173                }
3174                else if(!strcmpi(buffer, "Compress"))
3175                   options.compress = ParseTrueFalseValue(equal);
3176                else if(!strcmpi(buffer, "Profile"))
3177                   options.profile = ParseTrueFalseValue(equal);
3178                else if(!strcmpi(buffer, "AllWarnings"))
3179                   options.warnings = ParseTrueFalseValue(equal) ? all : unset;
3180                else if(!strcmpi(buffer, "MemoryGuard"))
3181                   options.memoryGuard = ParseTrueFalseValue(equal);
3182                else if(!strcmpi(buffer, "Default Name Space"))
3183                   options.defaultNameSpace = CopyString(equal);
3184                else if(!strcmpi(buffer, "Strict Name Spaces"))
3185                   options.strictNameSpaces = ParseTrueFalseValue(equal);
3186                else if(!strcmpi(buffer, "Preprocessor Definitions"))
3187                {
3188                   if(!options.preprocessorDefinitions) options.preprocessorDefinitions = { };
3189                   ParseArrayValue(options.preprocessorDefinitions, equal);
3190                }
3191             }
3192          }
3193       }
3194    }
3195    if(!options.targetDirectory && options.objectsDirectory)
3196       options.targetDirectory = /*CopyString(*/options.objectsDirectory/*)*/;
3197    //if(!objDir.dir) objDir.dir = "obj";
3198    //if(!targetDir.dir) targetDir.dir = "";
3199    // if(!targetName) property::targetName = "";   // How can a targetFileName be nothing???
3200    // if(!defaultNameSpace) property::defaultNameSpace = "";
3201    makingModified = true;
3202 }
3203
3204 Project LegacyAsciiLoadProject(File f, char * filePath)
3205 {
3206    Project project = null;
3207    ProjectNode node = null;
3208    int pos;
3209    char parentPath[MAX_LOCATION];
3210    char section[128] = "";
3211    char subSection[128] = "";
3212    ProjectNode parent;
3213    bool configurationsPresent = false;
3214
3215    f.Seek(0, start);
3216    while(!f.Eof())
3217    {
3218       char buffer[65536];
3219       //char version[16];
3220       char * equal;
3221       int len;
3222       pos = f.Tell();
3223       f.GetLine(buffer, 65536 - 1);
3224       TrimLSpaces(buffer, buffer);
3225       TrimRSpaces(buffer, buffer);
3226       if(strlen(buffer))
3227       {
3228          if(buffer[0] == '-' || buffer[0] == '=')
3229          {
3230             bool simple = buffer[0] == '-';
3231             equal = &buffer[0];
3232             equal[0] = ' ';
3233             TrimLSpaces(equal, equal);
3234             if(!strcmpi(section, "Target") && !strcmpi(subSection, "LibraryDirs"))
3235             {
3236                if(!project.config.options.libraryDirs)
3237                   project.config.options.libraryDirs = { [ CopyString(equal) ] };
3238                else
3239                   project.config.options.libraryDirs.Add(CopyString(equal));
3240             }
3241             else if(!strcmpi(section, "Target") && !strcmpi(subSection, "IncludeDirs"))
3242             {
3243                if(!project.config.options.includeDirs)
3244                   project.config.options.includeDirs = { [ CopyString(equal) ] };
3245                else
3246                   project.config.options.includeDirs.Add(CopyString(equal));
3247             }
3248             else if(!strcmpi(section, "Target") && (!strcmpi(subSection, "Files") || !strcmpi(subSection, "Resources")))
3249             {
3250                len = strlen(equal);
3251                if(len)
3252                {
3253                   char temp[MAX_LOCATION];
3254                   ProjectNode child { };
3255                   // We don't need to do this anymore, fileName is just a property that sets name & path
3256                   // child.fileName = CopyString(equal);
3257                   if(simple)
3258                   {
3259                      child.name = CopyString(equal);
3260                      child.path = CopyString(parentPath);
3261                   }
3262                   else
3263                   {
3264                      GetLastDirectory(equal, temp);
3265                      child.name = CopyString(temp);
3266                      StripLastDirectory(equal, temp);
3267                      child.path = CopyString(temp);
3268                   }
3269                   child.nodeType = file;
3270                   child.parent = parent;
3271                   child.indent = parent.indent + 1;
3272                   child.type = file;
3273                   child.icon = NodeIcons::SelectFileIcon(child.name);
3274                   parent.files.Add(child);
3275                   node = child;
3276                   //child = null;
3277                }
3278                else
3279                {
3280                   StripLastDirectory(parentPath, parentPath);
3281                   parent = parent.parent;
3282                }
3283             }
3284          }
3285          else if(buffer[0] == '+')
3286          {
3287             equal = &buffer[0];
3288             equal[0] = ' ';
3289             TrimLSpaces(equal, equal);
3290             if(!strcmpi(section, "Target") && (!strcmpi(subSection, "Files") || !strcmpi(subSection, "Resources")))
3291             {
3292                char temp[MAX_LOCATION];
3293                ProjectNode child { };
3294                // NEW: Folders now have a path set like files
3295                child.name = CopyString(equal);
3296                strcpy(temp, parentPath);
3297                PathCatSlash(temp, child.name);
3298                child.path = CopyString(temp);
3299
3300                child.parent = parent;
3301                child.indent = parent.indent + 1;
3302                child.type = folder;
3303                child.nodeType = folder;
3304                child.files = { };
3305                child.icon = folder;
3306                PathCatSlash(parentPath, child.name);
3307                parent.files.Add(child);
3308                parent = child;
3309                node = child;
3310                //child = null;
3311             }
3312             else if(!strcmpi(section, "Configurations"))
3313             {
3314                ProjectConfig newConfig
3315                {
3316                   makingModified = true;
3317                   options = { };
3318                };
3319                f.Seek(pos, start);
3320                LegacyProjectConfigLoad(newConfig, f);
3321                project.configurations.Add(newConfig);
3322             }
3323          }
3324          else if(!strcmpi(buffer, "ECERE Project File"));
3325          else if(!strcmpi(buffer, "Version 0a"))
3326             ; //strcpy(version, "0a");
3327          else if(!strcmpi(buffer, "Version 0.1a"))
3328             ; //strcpy(version, "0.1a");
3329          else if(!strcmpi(buffer, "Configurations"))
3330          {
3331             project.configurations.Free();
3332             project.config = null;
3333             strcpy(section, buffer);
3334             configurationsPresent = true;
3335          }
3336          else if(!strcmpi(buffer, "Target") || !strnicmp(buffer, "Target \"", strlen("Target \"")))
3337          {
3338             ProjectConfig newConfig { name = CopyString("Default"), options = { } };
3339             char topNodePath[MAX_LOCATION];
3340             // newConfig.defaultNameSpace = "";
3341             //newConfig.objDir.dir = "obj";
3342             //newConfig.targetDir.dir = "";
3343             project = Project { /*options = { }*/ };
3344             project.configurations = { [ newConfig ] };
3345             project.config = newConfig;
3346             // if(project.topNode.path) delete project.topNode.path;
3347             GetWorkingDir(topNodePath, sizeof(topNodePath)-1);
3348             MakeSlashPath(topNodePath);
3349             PathCatSlash(topNodePath, filePath);
3350             project.filePath = topNodePath;
3351             parentPath[0] = '\0';
3352             parent = project.topNode;
3353             node = parent;
3354             strcpy(section, "Target");
3355             equal = &buffer[6];
3356             if(equal[0] == ' ')
3357             {
3358                equal++;
3359                if(equal[0] == '\"')
3360                {
3361                   StripQuotes(equal, equal);
3362                   delete project.moduleName; project.moduleName = CopyString(equal);
3363                }
3364             }
3365          }
3366          else if(!strcmpi(buffer, "Compiler Options"));
3367          else if(!strcmpi(buffer, "IncludeDirs"))
3368             strcpy(subSection, buffer);
3369          else if(!strcmpi(buffer, "Linker Options"));
3370          else if(!strcmpi(buffer, "LibraryDirs"))
3371             strcpy(subSection, buffer);
3372          else if(!strcmpi(buffer, "Files"))
3373          {
3374             strcpy(section, "Target");
3375             strcpy(subSection, buffer);
3376          }
3377          else if(!strcmpi(buffer, "Resources"))
3378          {
3379             ProjectNode child { };
3380             parent.files.Add(child);
3381             child.parent = parent;
3382             child.indent = parent.indent + 1;
3383             child.name = CopyString(buffer);
3384             child.path = CopyString("");
3385             child.type = resources;
3386             child.files = { };
3387             child.icon = archiveFile;
3388             project.resNode = child;
3389             parent = child;
3390             node = child;
3391             strcpy(subSection, buffer);
3392          }
3393          else
3394          {
3395             equal = strstr(buffer, "=");
3396             if(equal)
3397             {
3398                equal[0] = '\0';
3399                TrimRSpaces(buffer, buffer);
3400                equal++;
3401                TrimLSpaces(equal, equal);
3402
3403                if(!strcmpi(section, "Target"))
3404                {
3405                   if(!strcmpi(buffer, "Build Exclusions"))
3406                   {
3407                      if(!strcmpi(section, "Target") && !strcmpi(subSection, "Files"))
3408                      {
3409                         /*if(node && node.type != NodeTypes::project)
3410                            ParseListValue(node.buildExclusions, equal);*/
3411                      }
3412                   }
3413                   else if(!strcmpi(buffer, "Path") && !strcmpi(subSection, "Resources"))
3414                   {
3415                      delete project.resNode.path;
3416                      project.resNode.path = CopyString(equal);
3417                      PathCatSlash(parentPath, equal);
3418                   }
3419
3420                   // Config Settings
3421                   else if(!strcmpi(buffer, "Intermediate Directory"))
3422                      project.config.options.objectsDirectory = /*CopyString(*/equal/*)*/; //objDir.expression = equal;
3423                   else if(!strcmpi(buffer, "Debug"))
3424                      project.config.options.debug = ParseTrueFalseValue(equal);
3425                   else if(!strcmpi(buffer, "Optimize"))
3426                   {
3427                      if(!strcmpi(equal, "None"))
3428                         project.config.options.optimization = none;
3429                      else if(!strcmpi(equal, "Speed") || !strcmpi(equal, "True"))
3430                         project.config.options.optimization = speed;
3431                      else if(!strcmpi(equal, "Size"))
3432                         project.config.options.optimization = size;
3433                      else
3434                         project.config.options.optimization = none;
3435                   }
3436                   else if(!strcmpi(buffer, "Profile"))
3437                      project.config.options.profile = ParseTrueFalseValue(equal);
3438                   else if(!strcmpi(buffer, "MemoryGuard"))
3439                      project.config.options.memoryGuard = ParseTrueFalseValue(equal);
3440                   else
3441                   {
3442                      if(!project.options) project.options = { };
3443
3444                      // Project Wide Settings (All configs)
3445                      if(!strcmpi(buffer, "Target Name"))
3446                         project.options.targetFileName = /*CopyString(*/equal/*)*/;
3447                      else if(!strcmpi(buffer, "Target Type"))
3448                      {
3449                         if(!strcmpi(equal, "Executable"))
3450                            project.options.targetType = executable;
3451                         else if(!strcmpi(equal, "Shared"))
3452                            project.options.targetType = sharedLibrary;
3453                         else if(!strcmpi(equal, "Static"))
3454                            project.options.targetType = staticLibrary;
3455                         else
3456                            project.options.targetType = executable;
3457                      }
3458                      else if(!strcmpi(buffer, "Target Directory"))
3459                         project.options.targetDirectory = /*CopyString(*/equal/*)*/;
3460                      else if(!strcmpi(buffer, "Console"))
3461                         project.options.console = ParseTrueFalseValue(equal);
3462                      else if(!strcmpi(buffer, "Libraries"))
3463                      {
3464                         if(!project.options.libraries) project.options.libraries = { };
3465                         ParseArrayValue(project.options.libraries, equal);
3466                      }
3467                      else if(!strcmpi(buffer, "AllWarnings"))
3468                         project.options.warnings = ParseTrueFalseValue(equal) ? all : unset;
3469                      else if(!strcmpi(buffer, "Preprocessor Definitions"))
3470                      {
3471                         if(!strcmpi(section, "Target") && !strcmpi(subSection, "Files"))
3472                         {
3473                            /*if(node && (node.type == NodeTypes::project || (node.type == file && !node.isInResources) || node.type == folder))
3474                               ParseListValue(node.preprocessorDefs, equal);*/
3475                         }
3476                         else
3477                         {
3478                            if(!project.options.preprocessorDefinitions) project.options.preprocessorDefinitions = { };
3479                            ParseArrayValue(project.options.preprocessorDefinitions, equal);
3480                         }
3481                      }
3482                   }
3483                }
3484             }
3485          }
3486       }
3487    }
3488    parent = null;
3489
3490    SplitPlatformLibraries(project);
3491
3492    if(configurationsPresent)
3493       CombineIdenticalConfigOptions(project);
3494    return project;
3495 }
3496
3497 void SplitPlatformLibraries(Project project)
3498 {
3499    if(project && project.configurations)
3500    {
3501       for(cfg : project.configurations)
3502       {
3503          if(cfg.options.libraries && cfg.options.libraries.count)
3504          {
3505             Iterator<String> it { cfg.options.libraries };
3506             while(it.Next())
3507             {
3508                String l = it.data;
3509                char * platformName = strstr(l, ":");
3510                if(platformName)
3511                {
3512                   PlatformOptions platform = null;
3513                   platformName++;
3514                   if(!cfg.platforms) cfg.platforms = { };
3515                   for(p : cfg.platforms)
3516                   {
3517                      if(!strcmpi(platformName, p.name))
3518                      {
3519                         platform = p;
3520                         break;
3521                      }
3522                   }
3523                   if(!platform)
3524                   {
3525                      platform = { name = CopyString(platformName), options = { libraries = { } } };
3526                      cfg.platforms.Add(platform);
3527                   }
3528                   *(platformName-1) = 0;
3529                   platform.options.libraries.Add(CopyString(l));
3530
3531                   cfg.options.libraries.Delete(it.pointer);
3532                   it.pointer = null;
3533                }
3534             }
3535          }
3536       }
3537    }
3538 }
3539
3540 void CombineIdenticalConfigOptions(Project project)
3541 {
3542    if(project && project.configurations && project.configurations.count)
3543    {
3544       DataMember member;
3545       ProjectOptions nullOptions { };
3546       ProjectConfig firstConfig = null;
3547       for(cfg : project.configurations)
3548       {
3549          if(cfg.options.targetType != staticLibrary)
3550          {
3551             firstConfig = cfg;
3552             break;
3553          }
3554       }
3555       if(!firstConfig)
3556          firstConfig = project.configurations.firstIterator.data;
3557
3558       for(member = class(ProjectOptions).membersAndProperties.first; member; member = member.next)
3559       {
3560          if(!member.isProperty)
3561          {
3562             Class type = eSystem_FindClass(__thisModule, member.dataTypeString);
3563             if(type)
3564             {
3565                bool same = true;
3566
3567                for(cfg : project.configurations)
3568                {
3569                   if(cfg != firstConfig)
3570                   {
3571                      if(cfg.options.targetType != staticLibrary)
3572                      {
3573                         int result;
3574
3575                         if(type.type == noHeadClass || type.type == normalClass)
3576                         {
3577                            result = type._vTbl[__ecereVMethodID_class_OnCompare](type,
3578                               *(void **)((byte *)firstConfig.options + member.offset + member._class.offset),
3579                               *(void **)((byte *)cfg.options         + member.offset + member._class.offset));
3580                         }
3581                         else
3582                         {
3583                            result = type._vTbl[__ecereVMethodID_class_OnCompare](type,
3584                               (byte *)firstConfig.options + member.offset + member._class.offset,
3585                               (byte *)cfg.options         + member.offset + member._class.offset);
3586                         }
3587                         if(result)
3588                         {
3589                            same = false;
3590                            break;
3591                         }
3592                      }
3593                   }
3594                }
3595                if(same)
3596                {
3597                   if(type.type == noHeadClass || type.type == normalClass)
3598                   {
3599                      if(!type._vTbl[__ecereVMethodID_class_OnCompare](type,
3600                         *(void **)((byte *)firstConfig.options + member.offset + member._class.offset),
3601                         *(void **)((byte *)nullOptions         + member.offset + member._class.offset)))
3602                         continue;
3603                   }
3604                   else
3605                   {
3606                      if(!type._vTbl[__ecereVMethodID_class_OnCompare](type,
3607                         (byte *)firstConfig.options + member.offset + member._class.offset,
3608                         (byte *)nullOptions         + member.offset + member._class.offset))
3609                         continue;
3610                   }
3611
3612                   if(!project.options) project.options = { };
3613
3614                   /*if(type.type == noHeadClass || type.type == normalClass)
3615                   {
3616                      type._vTbl[__ecereVMethodID_class_OnCopy](type,
3617                         (byte *)project.options + member.offset + member._class.offset,
3618                         *(void **)((byte *)firstConfig.options + member.offset + member._class.offset));
3619                   }
3620                   else
3621                   {
3622                      void * address = (byte *)firstConfig.options + member.offset + member._class.offset;
3623                      // TOFIX: ListBox::SetData / OnCopy mess
3624                      type._vTbl[__ecereVMethodID_class_OnCopy](type,
3625                         (byte *)project.options + member.offset + member._class.offset,
3626                         (type.typeSize > 4) ? address :
3627                            ((type.typeSize == 4) ? (void *)*(uint32 *)address :
3628                               ((type.typeSize == 2) ? (void *)*(uint16*)address :
3629                                  (void *)*(byte *)address )));
3630                   }*/
3631                   memcpy(
3632                      (byte *)project.options + member.offset + member._class.offset,
3633                      (byte *)firstConfig.options + member.offset + member._class.offset, type.typeSize);
3634
3635                   for(cfg : project.configurations)
3636                   {
3637                      if(cfg.options.targetType == staticLibrary)
3638                      {
3639                         int result;
3640
3641                         if(type.type == noHeadClass || type.type == normalClass)
3642                         {
3643                            result = type._vTbl[__ecereVMethodID_class_OnCompare](type,
3644                               *(void **)((byte *)firstConfig.options + member.offset + member._class.offset),
3645                               *(void **)((byte *)cfg.options         + member.offset + member._class.offset));
3646                         }
3647                         else
3648                         {
3649                            result = type._vTbl[__ecereVMethodID_class_OnCompare](type,
3650                               (byte *)firstConfig.options + member.offset + member._class.offset,
3651                               (byte *)cfg.options         + member.offset + member._class.offset);
3652                         }
3653                         if(result)
3654                            continue;
3655                      }
3656                      if(cfg != firstConfig)
3657                      {
3658                         if(type.type == noHeadClass || type.type == normalClass)
3659                         {
3660                            type._vTbl[__ecereVMethodID_class_OnFree](type,
3661                               *(void **)((byte *)cfg.options + member.offset + member._class.offset));
3662                         }
3663                         else
3664                         {
3665                            type._vTbl[__ecereVMethodID_class_OnFree](type,
3666                               (byte *)cfg.options + member.offset + member._class.offset);
3667                         }
3668                         memset((byte *)cfg.options + member.offset + member._class.offset, 0, type.typeSize);
3669                      }
3670                   }
3671                   memset((byte *)firstConfig.options + member.offset + member._class.offset, 0, type.typeSize);
3672                }
3673             }
3674          }
3675       }
3676       delete nullOptions;
3677
3678       // Compare Platform Specific Settings
3679       {
3680          bool same = true;
3681          for(cfg : project.configurations)
3682          {
3683             if(cfg != firstConfig && cfg.options.targetType != staticLibrary && (firstConfig.platforms || cfg.platforms) &&
3684                ((!firstConfig.platforms && cfg.platforms) || firstConfig.platforms.OnCompare(cfg.platforms)))
3685             {
3686                same = false;
3687                break;
3688             }
3689          }
3690          if(same && firstConfig.platforms)
3691          {
3692             for(cfg : project.configurations)
3693             {
3694                if(cfg.options.targetType == staticLibrary && firstConfig.platforms.OnCompare(cfg.platforms))
3695                   continue;
3696                if(cfg != firstConfig)
3697                {
3698                   cfg.platforms.Free();
3699                   delete cfg.platforms;
3700                }
3701             }
3702             project.platforms = firstConfig.platforms;
3703             firstConfig.platforms = null;
3704          }
3705       }
3706
3707       // Static libraries can't contain libraries
3708       for(cfg : project.configurations)
3709       {
3710          if(cfg.options.targetType == staticLibrary)
3711          {
3712             if(!cfg.options.libraries) cfg.options.libraries = { };
3713             cfg.options.libraries.Free();
3714          }
3715       }
3716    }
3717 }
3718
3719 Project LoadProject(char * filePath)
3720 {
3721    Project project = null;
3722    File f = FileOpen(filePath, read);
3723    if(f)
3724    {
3725       project = LegacyBinaryLoadProject(f, filePath);
3726       if(!project)
3727       {
3728          JSONParser parser { f = f };
3729          JSONResult result = parser.GetObject(class(Project), &project);
3730          if(project)
3731          {
3732             char insidePath[MAX_LOCATION];
3733
3734             delete project.topNode.files;
3735             if(!project.files) project.files = { };
3736             project.topNode.files = project.files;
3737             project.resNode = project.topNode.Add(project, "Resources", project.topNode.files.last, resources, archiveFile, false);
3738             delete project.resNode.path;
3739             project.resNode.path = project.resourcesPath;
3740             project.resourcesPath = null;
3741             project.resNode.nodeType = (ProjectNodeType)-1;
3742             delete project.resNode.files;
3743             project.resNode.files = project.resources;
3744             project.files = null;
3745             project.resources = null;
3746             if(!project.configurations) project.configurations = { };
3747
3748             {
3749                char topNodePath[MAX_LOCATION];
3750                GetWorkingDir(topNodePath, sizeof(topNodePath)-1);
3751                MakeSlashPath(topNodePath);
3752                PathCatSlash(topNodePath, filePath);
3753                project.filePath = topNodePath;//filePath;
3754             }
3755
3756             project.topNode.FixupNode(insidePath);
3757          }
3758          delete parser;
3759       }
3760       if(!project)
3761          project = LegacyAsciiLoadProject(f, filePath);
3762
3763       delete f;
3764
3765       if(project)
3766       {
3767          if(!project.options) project.options = { };
3768          if(!project.config && project.configurations)
3769             project.config = project.configurations.firstIterator.data;
3770
3771          if(!project.resNode)
3772          {
3773             project.resNode = project.topNode.Add(project, "Resources", project.topNode.files.last, resources, archiveFile, false);
3774          }
3775
3776          if(!project.moduleName)
3777             project.moduleName = CopyString(project.name);
3778          if(project.config &&
3779             (!project.options || !project.options.targetFileName || !project.options.targetFileName[0]) &&
3780             (!project.config.options.targetFileName || !project.config.options.targetFileName[0]))
3781          {
3782             //delete project.config.options.targetFileName;
3783
3784             project.options.targetFileName = /*CopyString(*/project.moduleName/*)*/;
3785             project.config.options.optimization = none;
3786             project.config.options.debug = true;
3787             //project.config.options.warnings = unset;
3788             project.config.options.memoryGuard = false;
3789             project.config.compilingModified = true;
3790             project.config.linkingModified = true;
3791          }
3792          else if(!project.topNode.name && project.config)
3793          {
3794             project.topNode.name = CopyString(project.config.options.targetFileName);
3795          }
3796
3797          /* // THIS IS NOW AUTOMATED WITH A project CHECK IN ProjectNode
3798          project.topNode.configurations = project.configurations;
3799          project.topNode.platforms = project.platforms;
3800          project.topNode.options = project.options;*/
3801       }
3802    }
3803    return project;
3804 }