619 lines
25 KiB
C++
619 lines
25 KiB
C++
/*
|
|
* Copyright (C) 2020-2022 Roy Qu (royqh1979@gmail.com)
|
|
*
|
|
* This program is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program. If not, see <https://www.gnu.org/licenses/>.
|
|
*/
|
|
#include "projectcompiler.h"
|
|
#include "../project.h"
|
|
#include "compilermanager.h"
|
|
#include "../systemconsts.h"
|
|
#include "qt_utils/charsetinfo.h"
|
|
#include "../editor.h"
|
|
#include "qt_utils/utils.h"
|
|
#include "utils.h"
|
|
#include "utils/escape.h"
|
|
#include "utils/parsearg.h"
|
|
|
|
#include <QDir>
|
|
|
|
ProjectCompiler::ProjectCompiler(std::shared_ptr<Project> project):
|
|
Compiler("",false),
|
|
mOnlyClean(false)
|
|
{
|
|
setProject(project);
|
|
}
|
|
|
|
void ProjectCompiler::buildMakeFile()
|
|
{
|
|
//we are using custom make file, don't overwrite it
|
|
if (mProject->options().useCustomMakefile && !mProject->options().customMakefile.isEmpty())
|
|
return;
|
|
switch(mProject->options().type) {
|
|
case ProjectType::StaticLib:
|
|
createStaticMakeFile();
|
|
break;
|
|
case ProjectType::DynamicLib:
|
|
createDynamicMakeFile();
|
|
break;
|
|
default:
|
|
createStandardMakeFile();
|
|
}
|
|
}
|
|
|
|
void ProjectCompiler::createStandardMakeFile()
|
|
{
|
|
QFile file(mProject->makeFileName());
|
|
newMakeFile(file);
|
|
QString executable = extractRelativePath(mProject->makeFileName(), mProject->executable());
|
|
QString exeTarget = escapeFilenameForMakefileTarget(executable);
|
|
QString exeCommand = escapeArgumentForMakefileRecipe(executable, false);
|
|
writeln(file, exeTarget + ": $(OBJ)\n");
|
|
if (!mOnlyCheckSyntax) {
|
|
if (mProject->options().isCpp) {
|
|
writeln(file, "\t$(CXX) $(LINKOBJ) -o " + exeCommand + " $(LIBS)");
|
|
} else
|
|
writeln(file, "\t$(CC) $(LINKOBJ) -o " + exeCommand + " $(LIBS)");
|
|
}
|
|
writeMakeObjFilesRules(file);
|
|
}
|
|
|
|
void ProjectCompiler::createStaticMakeFile()
|
|
{
|
|
QFile file(mProject->makeFileName());
|
|
newMakeFile(file);
|
|
QString executable = extractRelativePath(mProject->makeFileName(), mProject->executable());
|
|
QString exeTarget = escapeFilenameForMakefileTarget(executable);
|
|
QString exeCommand = escapeArgumentForMakefileRecipe(executable, false);
|
|
writeln(file, exeTarget + ": $(OBJ)");
|
|
writeln(file, "\tar r " + exeCommand + " $(LINKOBJ)");
|
|
writeln(file, "\tranlib " + exeCommand);
|
|
writeMakeObjFilesRules(file);
|
|
}
|
|
|
|
void ProjectCompiler::createDynamicMakeFile()
|
|
{
|
|
QFile file(mProject->makeFileName());
|
|
newMakeFile(file);
|
|
QString executable = extractRelativePath(mProject->makeFileName(), mProject->executable());
|
|
QString exeTarget = escapeFilenameForMakefileTarget(executable);
|
|
QString exeCommand = escapeArgumentForMakefileRecipe(executable, false);
|
|
writeln(file, exeTarget + ": $(OBJ)");
|
|
if (mProject->options().isCpp) {
|
|
writeln(file, "\t$(CXX) -mdll $(LINKOBJ) -o " + exeCommand + " $(LIBS) -Wl,--output-def,$(DEF),--out-implib,$(STATIC)");
|
|
} else {
|
|
writeln(file, "\t$(CC) -mdll $(LINKOBJ) -o " + exeCommand + " $(LIBS) -Wl,--output-def,$(DEF),--out-implib,$(STATIC)");
|
|
}
|
|
writeMakeObjFilesRules(file);
|
|
}
|
|
|
|
void ProjectCompiler::newMakeFile(QFile& file)
|
|
{
|
|
// Create OBJ output directory
|
|
if (!mProject->options().objectOutput.isEmpty()) {
|
|
QDir(mProject->directory()).mkpath(mProject->options().objectOutput);
|
|
}
|
|
// Create executable output directory
|
|
if (!mProject->options().exeOutput.isEmpty()) {
|
|
QDir(mProject->directory()).mkpath(mProject->options().exeOutput);
|
|
}
|
|
// Write more information to the log file than before
|
|
log(tr("Building makefile..."));
|
|
log("--------");
|
|
log(tr("- Filename: %1").arg(mProject->makeFileName()));
|
|
|
|
// Create the actual file
|
|
if (!file.open(QFile::WriteOnly | QFile::Truncate))
|
|
throw CompileError(tr("Can't open '%1' for write!").arg(mProject->makeFileName()));
|
|
|
|
// Write header
|
|
writeMakeHeader(file);
|
|
|
|
// Writes definition list
|
|
writeMakeDefines(file);
|
|
|
|
// Write PHONY and all targets
|
|
writeMakeTarget(file);
|
|
|
|
// Write list of includes
|
|
writeMakeIncludes(file);
|
|
|
|
// Write clean command
|
|
writeMakeClean(file);
|
|
|
|
// PCH
|
|
if (mProject->options().usePrecompiledHeader
|
|
&& fileExists(mProject->options().precompiledHeader)) {
|
|
QString pchH = extractRelativePath(mProject->makeFileName(), mProject->options().precompiledHeader);
|
|
QString pchHCommand = escapeArgumentForMakefileRecipe(pchH, false);
|
|
QString pch = extractRelativePath(mProject->makeFileName(), mProject->options().precompiledHeader + "." GCH_EXT);
|
|
QString pchTarget = escapeFilenameForMakefileTarget(pch);
|
|
QString pchCommand = escapeArgumentForMakefileRecipe(pch, false);
|
|
writeln(file, pchTarget + ": $(PCH_H)");
|
|
writeln(file, "\t$(CXX) -c " + pchHCommand + " -o " + pchCommand + " $(CXXFLAGS)");
|
|
writeln(file);
|
|
}
|
|
}
|
|
|
|
void ProjectCompiler::writeMakeHeader(QFile &file)
|
|
{
|
|
writeln(file,"# Project: " + mProject->name());
|
|
writeln(file,QString("# Makefile created by Red Panda C++ ") + REDPANDA_CPP_VERSION);
|
|
writeln(file);
|
|
}
|
|
|
|
void ProjectCompiler::writeMakeDefines(QFile &file)
|
|
{
|
|
// Get list of object files
|
|
QStringList Objects;
|
|
QStringList LinkObjects;
|
|
QStringList cleanObjects;
|
|
|
|
// Create a list of object files
|
|
foreach(const PProjectUnit &unit, mProject->unitList()) {
|
|
if (!unit->compile() && !unit->link())
|
|
continue;
|
|
|
|
// Only process source files
|
|
QString RelativeName = extractRelativePath(mProject->directory(), unit->fileName());
|
|
FileType fileType = getFileType(RelativeName);
|
|
|
|
if (fileType == FileType::CSource || fileType == FileType::CppSource
|
|
|| fileType==FileType::GAS) {
|
|
if (!mProject->options().objectOutput.isEmpty()) {
|
|
// ofile = C:\MyProgram\obj\main.o
|
|
QString fullObjFile = includeTrailingPathDelimiter(mProject->options().objectOutput)
|
|
+ extractFileName(unit->fileName());
|
|
QString relativeObjFile = extractRelativePath(mProject->directory(), changeFileExt(fullObjFile, OBJ_EXT));
|
|
Objects << relativeObjFile;
|
|
cleanObjects << localizePath(relativeObjFile);
|
|
if (unit->link()) {
|
|
LinkObjects << relativeObjFile;
|
|
}
|
|
} else {
|
|
Objects << changeFileExt(RelativeName, OBJ_EXT);
|
|
cleanObjects << localizePath(changeFileExt(RelativeName, OBJ_EXT));
|
|
if (unit->link())
|
|
LinkObjects << changeFileExt(RelativeName, OBJ_EXT);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Get windres file
|
|
QString objResFile;
|
|
QString cleanRes;
|
|
#ifdef Q_OS_WIN
|
|
if (!mProject->options().privateResource.isEmpty()) {
|
|
if (!mProject->options().objectOutput.isEmpty()) {
|
|
QString fullResFile = includeTrailingPathDelimiter(mProject->options().objectOutput) +
|
|
changeFileExt(mProject->options().privateResource, RES_EXT);
|
|
|
|
QString relativeResFile = extractRelativePath(mProject->directory(), fullResFile);
|
|
objResFile = relativeResFile;
|
|
cleanRes = localizePath(changeFileExt(relativeResFile, RES_EXT));
|
|
} else {
|
|
objResFile = changeFileExt(mProject->options().privateResource, RES_EXT);
|
|
cleanRes = localizePath(changeFileExt(mProject->options().privateResource, RES_EXT));
|
|
}
|
|
}
|
|
#endif
|
|
|
|
// Mention progress in the logs
|
|
if (!objResFile.isEmpty()) {
|
|
QString absolutePath = generateAbsolutePath(mProject->directory(),objResFile);
|
|
QString escaped = escapeArgumentForPlatformShell(absolutePath, false);
|
|
log(tr("- Resource File: %1").arg(escaped));
|
|
}
|
|
log("");
|
|
|
|
QString cxx = extractFileName(compilerSet()->cppCompiler());
|
|
QString cc = extractFileName(compilerSet()->CCompiler());
|
|
#ifdef Q_OS_WIN
|
|
QString windres = extractFileName(compilerSet()->resourceCompiler());
|
|
#endif
|
|
|
|
// Get list of applicable flags
|
|
QStringList cCompileArguments = getCCompileArguments(false);
|
|
QStringList cxxCompileArguments = getCppCompileArguments(false);
|
|
if (cCompileArguments.contains("-g3")) {
|
|
cCompileArguments << "-D__DEBUG__";
|
|
cxxCompileArguments << "-D__DEBUG__";
|
|
}
|
|
QStringList libraryArguments = getLibraryArguments(FileType::Project);
|
|
QStringList cIncludeArguments = getCIncludeArguments();
|
|
QStringList cxxIncludeArguments = getCppIncludeArguments();
|
|
#ifdef Q_OS_WIN
|
|
QStringList resourceArguments = parseArguments(mProject->options().resourceCmd, devCppMacroVariables(), true);
|
|
#endif
|
|
|
|
QString executable = extractRelativePath(mProject->makeFileName(), mProject->executable());
|
|
QString cleanExe = localizePath(executable);
|
|
QString pchH = extractRelativePath(mProject->makeFileName(), mProject->options().precompiledHeader);
|
|
QString pch = extractRelativePath(mProject->makeFileName(), mProject->options().precompiledHeader + "." GCH_EXT);
|
|
|
|
// programs
|
|
writeln(file, "CXX = " + escapeArgumentForMakefileVariableValue(cxx, true));
|
|
writeln(file, "CC = " + escapeArgumentForMakefileVariableValue(cc, true));
|
|
#ifdef Q_OS_WIN
|
|
writeln(file, "WINDRES = " + escapeArgumentForMakefileVariableValue(windres, true));
|
|
#endif
|
|
writeln(file, "RM = " CLEAN_PROGRAM);
|
|
|
|
// compiler flags
|
|
writeln(file, "LIBS = " + escapeArgumentsForMakefileVariableValue(libraryArguments));
|
|
writeln(file, "INCS = " + escapeArgumentsForMakefileVariableValue(cIncludeArguments));
|
|
writeln(file, "CXXINCS = " + escapeArgumentsForMakefileVariableValue(cxxIncludeArguments));
|
|
writeln(file, "CXXFLAGS = $(CXXINCS) " + escapeArgumentsForMakefileVariableValue(cxxCompileArguments));
|
|
writeln(file, "CFLAGS = $(INCS) " + escapeArgumentsForMakefileVariableValue(cCompileArguments));
|
|
#ifdef Q_OS_WIN
|
|
writeln(file, "WINDRESFLAGS = " + escapeArgumentsForMakefileVariableValue(resourceArguments));
|
|
#endif
|
|
|
|
// objects referenced in prerequisites
|
|
// do not use them in targets or command arguments, they have different escaping rules
|
|
if (!objResFile.isEmpty()) {
|
|
writeln(file, "RES = " + escapeFilenameForMakefilePrerequisite(objResFile));
|
|
writeln(file, "OBJ = " + escapeFilenamesForMakefilePrerequisite(Objects) + " $(RES)");
|
|
} else {
|
|
writeln(file, "OBJ = " + escapeFilenamesForMakefilePrerequisite(Objects));
|
|
};
|
|
writeln(file, "BIN = " + escapeFilenameForMakefilePrerequisite(executable));
|
|
if (mProject->options().usePrecompiledHeader
|
|
&& fileExists(mProject->options().precompiledHeader)){
|
|
writeln(file, "PCH_H = " + escapeFilenameForMakefilePrerequisite(pchH));
|
|
writeln(file, "PCH = " + escapeFilenameForMakefilePrerequisite(pch));
|
|
}
|
|
|
|
// object referenced in command arguments
|
|
// use them in targets or prerequisites, they have different escaping rules
|
|
if (!objResFile.isEmpty()) {
|
|
writeln(file, "LINKOBJ = " + escapeArgumentsForMakefileVariableValue(LinkObjects) + " " + escapeArgumentForMakefileVariableValue(objResFile, false));
|
|
writeln(file, "CLEANOBJ = " + escapeArgumentsForMakefileVariableValue(cleanObjects) + " " + escapeArgumentForMakefileVariableValue(cleanRes, false) + " " + escapeArgumentForMakefileVariableValue(cleanExe, false));
|
|
} else {
|
|
writeln(file, "LINKOBJ = " + escapeArgumentsForMakefileVariableValue(LinkObjects));
|
|
writeln(file, "CLEANOBJ = " + escapeArgumentsForMakefileVariableValue(cleanObjects) + " " + escapeArgumentForMakefileVariableValue(cleanExe, false));
|
|
};
|
|
|
|
// This needs to be put in before the clean command.
|
|
if (mProject->options().type == ProjectType::DynamicLib) {
|
|
QString outputFileDir = extractFilePath(mProject->executable());
|
|
QString outputFilename = extractFileName(mProject->executable());
|
|
QString libOutputFile;
|
|
if (!outputFilename.startsWith("lib")) {
|
|
libOutputFile = includeTrailingPathDelimiter(outputFileDir) + "lib" + outputFilename;
|
|
} else {
|
|
libOutputFile = includeTrailingPathDelimiter(outputFileDir) + outputFilename;
|
|
}
|
|
if (QFileInfo(libOutputFile).absoluteFilePath()
|
|
== mProject->directory())
|
|
libOutputFile = extractFileName(libOutputFile);
|
|
else
|
|
libOutputFile = extractRelativePath(mProject->makeFileName(), libOutputFile);
|
|
|
|
QString defFile = localizePath(changeFileExt(libOutputFile, DEF_EXT));
|
|
QString staticFile = localizePath(changeFileExt(libOutputFile, LIB_EXT));
|
|
|
|
writeln(file,"DEF = " + escapeArgumentForMakefileVariableValue(defFile, false));
|
|
writeln(file,"STATIC = " + escapeArgumentForMakefileVariableValue(staticFile, false));
|
|
}
|
|
writeln(file);
|
|
}
|
|
|
|
void ProjectCompiler::writeMakeTarget(QFile &file)
|
|
{
|
|
writeln(file, ".PHONY: all all-before all-after clean clean-custom");
|
|
writeln(file);
|
|
writeln(file, "all: all-before $(BIN) all-after");
|
|
writeln(file);
|
|
|
|
}
|
|
|
|
void ProjectCompiler::writeMakeIncludes(QFile &file)
|
|
{
|
|
foreach(const QString& s, mProject->options().makeIncludes) {
|
|
writeln(file, "include " + escapeFilenameForMakefileInclude(s));
|
|
}
|
|
if (!mProject->options().makeIncludes.isEmpty()) {
|
|
writeln(file);
|
|
}
|
|
}
|
|
|
|
void ProjectCompiler::writeMakeClean(QFile &file)
|
|
{
|
|
writeln(file, "clean: clean-custom");
|
|
QString target="$(CLEANOBJ)";
|
|
if (mProject->options().usePrecompiledHeader
|
|
&& fileExists(mProject->options().precompiledHeader)) {
|
|
QString pch = extractRelativePath(mProject->makeFileName(), mProject->options().precompiledHeader + "." GCH_EXT);
|
|
target += ' ' + escapeArgumentForMakefileRecipe(pch, false);
|
|
}
|
|
|
|
if (mProject->options().type == ProjectType::DynamicLib) {
|
|
target +=" $(DEF) $(STATIC)";
|
|
}
|
|
writeln(file, QString("\t-$(RM) %1 > %2 2>&1").arg(target,NULL_FILE));
|
|
writeln(file);
|
|
}
|
|
|
|
void ProjectCompiler::writeMakeObjFilesRules(QFile &file)
|
|
{
|
|
PCppParser parser = mProject->cppParser();
|
|
QString precompileStr;
|
|
|
|
QList<PProjectUnit> projectUnits=mProject->unitList();
|
|
foreach(const PProjectUnit &unit, projectUnits) {
|
|
if (!unit->compile())
|
|
continue;
|
|
FileType fileType = getFileType(unit->fileName());
|
|
// Only process source files
|
|
if (fileType!=FileType::CSource && fileType!=FileType::CppSource
|
|
&& fileType!=FileType::GAS)
|
|
continue;
|
|
|
|
QString shortFileName = extractRelativePath(mProject->makeFileName(),unit->fileName());
|
|
|
|
writeln(file);
|
|
QString objStr = escapeFilenameForMakefilePrerequisite(shortFileName);
|
|
// if we have scanned it, use scanned info
|
|
if (parser && parser->fileScanned(unit->fileName())) {
|
|
QSet<QString> fileIncludes = parser->getIncludedFiles(unit->fileName());
|
|
foreach(const PProjectUnit &unit2, projectUnits) {
|
|
if (unit2==unit)
|
|
continue;
|
|
if (fileIncludes.contains(unit2->fileName())) {
|
|
if (mProject->options().usePrecompiledHeader &&
|
|
unit2->fileName() == mProject->options().precompiledHeader)
|
|
precompileStr = " $(PCH) ";
|
|
else {
|
|
QString prereq = extractRelativePath(mProject->makeFileName(), unit2->fileName());
|
|
objStr = objStr + ' ' + escapeFilenameForMakefilePrerequisite(prereq);
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
foreach(const PProjectUnit &unit2, projectUnits) {
|
|
FileType fileType = getFileType(unit2->fileName());
|
|
if (fileType == FileType::CHeader || fileType==FileType::CppHeader) {
|
|
QString prereq = extractRelativePath(mProject->makeFileName(), unit2->fileName());
|
|
objStr = objStr + ' ' + escapeFilenameForMakefilePrerequisite(prereq);
|
|
}
|
|
}
|
|
}
|
|
QString objFileNameTarget;
|
|
QString objFileNameCommand;
|
|
if (!mProject->options().objectOutput.isEmpty()) {
|
|
QString fullObjname = includeTrailingPathDelimiter(mProject->options().objectOutput) +
|
|
extractFileName(unit->fileName());
|
|
QString objectFile = extractRelativePath(mProject->makeFileName(), changeFileExt(fullObjname, OBJ_EXT));
|
|
objFileNameTarget = escapeFilenameForMakefileTarget(objectFile);
|
|
objFileNameCommand = escapeArgumentForMakefileRecipe(objectFile, false);
|
|
} else {
|
|
QString objectFile = changeFileExt(shortFileName, OBJ_EXT);
|
|
objFileNameTarget = escapeFilenameForMakefileTarget(objectFile);
|
|
objFileNameCommand = escapeArgumentForMakefileRecipe(objectFile, false);
|
|
}
|
|
|
|
objStr = objFileNameTarget + ": " + objStr + precompileStr;
|
|
|
|
writeln(file,objStr);
|
|
|
|
// Write custom build command
|
|
if (unit->overrideBuildCmd() && !unit->buildCmd().isEmpty()) {
|
|
QString BuildCmd = unit->buildCmd();
|
|
BuildCmd.replace("<CRTAB>", "\n\t");
|
|
writeln(file, '\t' + BuildCmd);
|
|
// Or roll our own
|
|
} else {
|
|
QString encodingStr;
|
|
if (compilerSet()->compilerType() != CompilerType::Clang && mProject->options().addCharset) {
|
|
QByteArray defaultSystemEncoding=pCharsetInfoManager->getDefaultSystemEncoding();
|
|
QByteArray encoding = mProject->options().execEncoding;
|
|
QByteArray targetEncoding;
|
|
QByteArray sourceEncoding;
|
|
if ( encoding == ENCODING_SYSTEM_DEFAULT || encoding.isEmpty()) {
|
|
targetEncoding = defaultSystemEncoding;
|
|
} else if (encoding == ENCODING_UTF8_BOM) {
|
|
targetEncoding = "UTF-8";
|
|
} else if (encoding == ENCODING_UTF16_BOM) {
|
|
targetEncoding = "UTF-16";
|
|
} else if (encoding == ENCODING_UTF32_BOM) {
|
|
targetEncoding = "UTF-32";
|
|
} else {
|
|
targetEncoding = encoding;
|
|
}
|
|
|
|
if (unit->realEncoding().isEmpty()) {
|
|
if (unit->encoding() == ENCODING_AUTO_DETECT) {
|
|
Editor* editor = mProject->unitEditor(unit);
|
|
if (editor && editor->fileEncoding()!=ENCODING_ASCII
|
|
&& editor->fileEncoding()!=targetEncoding) {
|
|
sourceEncoding = editor->fileEncoding();
|
|
} else {
|
|
sourceEncoding = targetEncoding;
|
|
}
|
|
} else if (unit->encoding()==ENCODING_PROJECT) {
|
|
sourceEncoding=mProject->options().encoding;
|
|
} else if (unit->encoding()==ENCODING_SYSTEM_DEFAULT) {
|
|
sourceEncoding = defaultSystemEncoding;
|
|
} else if (unit->encoding()!=ENCODING_ASCII && !unit->encoding().isEmpty()) {
|
|
sourceEncoding = unit->encoding();
|
|
} else {
|
|
sourceEncoding = targetEncoding;
|
|
}
|
|
} else if (unit->realEncoding()==ENCODING_ASCII) {
|
|
sourceEncoding = targetEncoding;
|
|
} else {
|
|
sourceEncoding = unit->realEncoding();
|
|
}
|
|
if (sourceEncoding==ENCODING_SYSTEM_DEFAULT)
|
|
sourceEncoding = defaultSystemEncoding;
|
|
|
|
if (sourceEncoding!=targetEncoding) {
|
|
encodingStr = QString(" -finput-charset=%1 -fexec-charset=%2")
|
|
.arg(QString(sourceEncoding),
|
|
QString(targetEncoding));
|
|
}
|
|
}
|
|
|
|
if (fileType==FileType::CSource || fileType==FileType::CppSource) {
|
|
if (unit->compileCpp())
|
|
writeln(file, "\t$(CXX) -c " + escapeArgumentForMakefileRecipe(shortFileName, false) + " -o " + objFileNameCommand + " $(CXXFLAGS) " + encodingStr);
|
|
else
|
|
writeln(file, "\t$(CC) -c " + escapeArgumentForMakefileRecipe(shortFileName, false) + " -o " + objFileNameCommand + " $(CFLAGS) " + encodingStr);
|
|
} else if (fileType==FileType::GAS) {
|
|
writeln(file, "\t$(CC) -c " + escapeArgumentForMakefileRecipe(shortFileName, false) + " -o " + objFileNameCommand + " $(CFLAGS) " + encodingStr);
|
|
}
|
|
}
|
|
}
|
|
|
|
#ifdef Q_OS_WIN
|
|
if (!mProject->options().privateResource.isEmpty()) {
|
|
// Concatenate all resource include directories
|
|
QString ResIncludes(" ");
|
|
for (int i=0;i<mProject->options().resourceIncludes.count();i++) {
|
|
QString filename = mProject->options().resourceIncludes[i];
|
|
if (!filename.isEmpty())
|
|
ResIncludes += " --include-dir " + escapeArgumentForMakefileRecipe(filename, false);
|
|
}
|
|
|
|
QString resFiles;
|
|
// Concatenate all resource filenames (not created when syntax checking)
|
|
foreach(const PProjectUnit& unit, mProject->unitList()) {
|
|
if (getFileType(unit->fileName())!=FileType::WindowsResourceSource)
|
|
continue;
|
|
if (fileExists(unit->fileName())) {
|
|
QString ResFile = extractRelativePath(mProject->makeFileName(), unit->fileName());
|
|
resFiles = resFiles + escapeFilenameForMakefilePrerequisite(ResFile) + ' ';
|
|
}
|
|
}
|
|
|
|
// Determine resource output file
|
|
QString fullName;
|
|
if (!mProject->options().objectOutput.isEmpty()) {
|
|
fullName = includeTrailingPathDelimiter(mProject->options().objectOutput) +
|
|
changeFileExt(mProject->options().privateResource, RES_EXT);
|
|
} else {
|
|
fullName = changeFileExt(mProject->options().privateResource, RES_EXT);
|
|
}
|
|
QString objFile = extractRelativePath(mProject->filename(), fullName);
|
|
QString objFileNameCommand = escapeArgumentForMakefileRecipe(objFile, false);
|
|
QString objFileNameTarget = escapeFilenameForMakefileTarget(objFile);
|
|
QString privRes = extractRelativePath(mProject->filename(), mProject->options().privateResource);
|
|
QString privResNameCommand = escapeArgumentForMakefileRecipe(privRes, false);
|
|
QString privResNamePrereq = escapeFilenameForMakefilePrerequisite(privRes);
|
|
|
|
// Build final cmd
|
|
QString windresArgs;
|
|
|
|
if (mProject->getCompileOption(CC_CMD_OPT_POINTER_SIZE)=="32")
|
|
windresArgs = " -F pe-i386";
|
|
|
|
writeln(file);
|
|
writeln(file, objFileNameTarget + ": " + privResNamePrereq + ' ' + resFiles);
|
|
writeln(file, "\t$(WINDRES) -i " + privResNameCommand + windresArgs + " --input-format=rc -o " + objFileNameCommand + " -O coff $(WINDRESFLAGS)"
|
|
+ ResIncludes);
|
|
writeln(file);
|
|
}
|
|
#endif
|
|
}
|
|
|
|
void ProjectCompiler::writeln(QFile &file, const QString &s)
|
|
{
|
|
if (!s.isEmpty())
|
|
file.write(s.toLocal8Bit());
|
|
file.write("\n");
|
|
}
|
|
|
|
bool ProjectCompiler::onlyClean() const
|
|
{
|
|
return mOnlyClean;
|
|
}
|
|
|
|
void ProjectCompiler::setOnlyClean(bool newOnlyClean)
|
|
{
|
|
mOnlyClean = newOnlyClean;
|
|
}
|
|
|
|
bool ProjectCompiler::prepareForRebuild()
|
|
{
|
|
//we use make argument to clean
|
|
return true;
|
|
}
|
|
|
|
bool ProjectCompiler::prepareForCompile()
|
|
{
|
|
if (!mProject)
|
|
return false;
|
|
//initProgressForm();
|
|
log(tr("Compiling project changes..."));
|
|
log("--------");
|
|
log(tr("- Project Filename: %1").arg(mProject->filename()));
|
|
log(tr("- Compiler Set Name: %1").arg(compilerSet()->name()));
|
|
log("");
|
|
|
|
buildMakeFile();
|
|
|
|
mCompiler = compilerSet()->make();
|
|
|
|
if (!fileExists(mCompiler)) {
|
|
throw CompileError(
|
|
tr("Make program '%1' doesn't exists!").arg(mCompiler)
|
|
+"<br />"
|
|
+tr("Please check the \"program\" page of compiler settings."));
|
|
}
|
|
|
|
QString parallelParam;
|
|
if (mProject->options().allowParallelBuilding) {
|
|
if (mProject->options().parellelBuildingJobs==0) {
|
|
parallelParam = "--jobs";
|
|
} else {
|
|
parallelParam = QString("-j%1").arg(mProject->options().parellelBuildingJobs);
|
|
}
|
|
} else {
|
|
parallelParam = "-j1";
|
|
}
|
|
|
|
QString makefile = extractRelativePath(mProject->directory(), mProject->makeFileName());
|
|
QStringList cleanArgs{
|
|
"-f",
|
|
makefile,
|
|
"clean",
|
|
};
|
|
QStringList makeAllArgs{
|
|
parallelParam,
|
|
"-f",
|
|
makefile,
|
|
"all",
|
|
};
|
|
if (mOnlyClean) {
|
|
mArguments = cleanArgs;
|
|
} else if (mRebuild) {
|
|
mArguments = cleanArgs;
|
|
mExtraCompilersList << mCompiler;
|
|
mExtraOutputFilesList << "";
|
|
mExtraArgumentsList << makeAllArgs;
|
|
} else {
|
|
mArguments = makeAllArgs;
|
|
}
|
|
mDirectory = mProject->directory();
|
|
|
|
log(tr("Processing makefile:"));
|
|
log("--------");
|
|
log(tr("- makefile processer: %1").arg(mCompiler));
|
|
QString command = escapeCommandForLog(mCompiler, mArguments);
|
|
log(tr("- Command: %1").arg(command));
|
|
log("");
|
|
|
|
return true;
|
|
}
|