void EnabledModuleList::addModule (const File& moduleManifestFile, bool copyLocally)
{
ModuleDescription info (moduleManifestFile);
if (info.isValid())
{
const String moduleID (info.getID());
if (! isModuleEnabled (moduleID))
{
ValueTree module (Ids::MODULES);
module.setProperty (Ids::ID, moduleID, nullptr);
state.addChild (module, -1, getUndoManager());
sortAlphabetically();
shouldShowAllModuleFilesInProject (moduleID) = true;
shouldCopyModuleFilesLocally (moduleID) = copyLocally;
RelativePath path (moduleManifestFile.getParentDirectory().getParentDirectory(),
project.getProjectFolder(), RelativePath::projectFolder);
for (Project::ExporterIterator exporter (project); exporter.next();)
exporter->getPathForModuleValue (moduleID) = path.toUnixStyle();
}
}
}
void LibraryModule::createLocalHeaderWrapper (ProjectSaver& projectSaver, const File& originalHeader, const File& localHeader) const
{
Project& project = projectSaver.project;
MemoryOutputStream out;
out << "// This is an auto-generated file to redirect any included" << newLine
<< "// module headers to the correct external folder." << newLine
<< newLine;
StringArray paths, guards;
for (Project::ExporterIterator exporter (project); exporter.next();)
{
const RelativePath headerFromProject (exporter->getModuleFolderRelativeToProject (getID(), projectSaver)
.getChildFile (originalHeader.getFileName()));
const RelativePath fileFromHere (headerFromProject.rebased (project.getProjectFolder(),
localHeader.getParentDirectory(), RelativePath::unknown));
paths.add (fileFromHere.toUnixStyle().quoted());
guards.add ("defined (" + exporter->getExporterIdentifierMacro() + ")");
}
writeGuardedInclude (out, paths, guards);
out << newLine;
projectSaver.replaceFileIfDifferent (localHeader, out);
}
void AssetTree::Item::setFile (const RelativePath& file)
{
jassert (file.getRoot() == RelativePath::projectFolder);
jassert (isFile());
data.setProperty (Slugs::path, file.toUnixStyle(), nullptr);
data.setProperty (Slugs::name, file.getFileName(), nullptr);
}
void Project::Item::setFile (const RelativePath& file)
{
jassert (file.getRoot() == RelativePath::projectFolder);
jassert (isFile());
state.setProperty (Ids::file, file.toUnixStyle(), getUndoManager());
state.setProperty (Ids::name, file.getFileName(), getUndoManager());
}
void LibraryModule::addSettingsForModuleToExporter (ProjectExporter& exporter, ProjectSaver& projectSaver) const
{
Project& project = exporter.getProject();
RelativePath modulePath = exporter.getModuleFolderRelativeToProject (getID());
exporter.addToExtraSearchPaths (modulePath.getParentDirectory());
const String extraInternalSearchPaths (moduleInfo.getExtraSearchPaths().trim());
if (extraInternalSearchPaths.isNotEmpty())
{
StringArray paths;
paths.addTokens (extraInternalSearchPaths, true);
for (int i = 0; i < paths.size(); ++i)
exporter.addToExtraSearchPaths (modulePath.getChildFile (paths.getReference(i)));
}
{
const String extraDefs (moduleInfo.getPreprocessorDefs().trim());
if (extraDefs.isNotEmpty())
exporter.getExporterPreprocessorDefs() = exporter.getExporterPreprocessorDefsString() + "\n" + extraDefs;
}
{
Array<File> compiled;
const File localModuleFolder = project.getModules().shouldCopyModuleFilesLocally (getID()).getValue()
? project.getLocalModuleFolder (getID())
: moduleInfo.getFolder();
findAndAddCompiledUnits (exporter, &projectSaver, compiled);
if (project.getModules().shouldShowAllModuleFilesInProject (getID()).getValue())
addBrowseableCode (exporter, compiled, localModuleFolder);
}
if (exporter.isXcode())
{
XCodeProjectExporter& xcodeExporter = dynamic_cast<XCodeProjectExporter&> (exporter);
if (project.isAUPluginHost())
xcodeExporter.xcodeFrameworks.addTokens ("AudioUnit CoreAudioKit", false);
const String frameworks (moduleInfo.moduleInfo [xcodeExporter.isOSX() ? "OSXFrameworks" : "iOSFrameworks"].toString());
xcodeExporter.xcodeFrameworks.addTokens (frameworks, ", ", StringRef());
parseAndAddLibs (xcodeExporter.xcodeLibs, moduleInfo.moduleInfo [exporter.isOSX() ? "OSXLibs" : "iOSLibs"].toString());
}
else if (exporter.isLinux())
{
parseAndAddLibs (exporter.linuxLibs, moduleInfo.moduleInfo ["linuxLibs"].toString());
}
else if (exporter.isCodeBlocks() && exporter.isWindows())
{
parseAndAddLibs (exporter.mingwLibs, moduleInfo.moduleInfo ["mingwLibs"].toString());
}
}
void LibraryModule::addBrowseableCode (ProjectExporter& exporter, const Array<File>& compiled, const File& localModuleFolder) const
{
if (sourceFiles.isEmpty())
findBrowseableFiles (localModuleFolder, sourceFiles);
Project::Item sourceGroup (Project::Item::createGroup (exporter.getProject(), getID(), "__mainsourcegroup" + getID(), false));
const RelativePath moduleFromProject (exporter.getModuleFolderRelativeToProject (getID()));
auto moduleHeader = moduleInfo.getHeader();
for (auto& sourceFile : sourceFiles)
{
auto pathWithinModule = FileHelpers::getRelativePathFrom (sourceFile, localModuleFolder);
// (Note: in exporters like MSVC we have to avoid adding the same file twice, even if one of those instances
// is flagged as being excluded from the build, because this overrides the other and it fails to compile)
if ((exporter.canCopeWithDuplicateFiles() || ! compiled.contains (sourceFile)) && sourceFile != moduleHeader)
addFileWithGroups (sourceGroup,
moduleFromProject.getChildFile (pathWithinModule),
pathWithinModule);
}
sourceGroup.sortAlphabetically (true, true);
sourceGroup.addFileAtIndex (moduleHeader, -1, false);
exporter.getModulesGroup().state.addChild (sourceGroup.state.createCopy(), -1, nullptr);
}
void ProjectExporter::addToExtraSearchPaths (const RelativePath& pathFromProjectFolder)
{
RelativePath localPath (rebaseFromProjectFolderToBuildTarget (pathFromProjectFolder));
const String path (isVisualStudio() ? localPath.toWindowsStyle() : localPath.toUnixStyle());
extraSearchPaths.addIfNotAlreadyThere (path, false);
}
void LibraryModule::addBrowsableCode (ProjectExporter& exporter, ProjectSaver& projectSaver,
const Array<File>& compiled, const File& localModuleFolder) const
{
if (sourceFiles.size() == 0)
findBrowseableFiles (localModuleFolder, sourceFiles);
Project::Item sourceGroup (Project::Item::createGroup (exporter.getProject(), getID(), "__mainsourcegroup" + getID()));
const RelativePath moduleFromProject (exporter.getModuleFolderRelativeToProject (getID(), projectSaver));
for (int i = 0; i < sourceFiles.size(); ++i)
{
const String pathWithinModule (FileHelpers::getRelativePathFrom (sourceFiles.getReference(i), localModuleFolder));
// (Note: in exporters like MSVC we have to avoid adding the same file twice, even if one of those instances
// is flagged as being excluded from the build, because this overrides the other and it fails to compile)
if (exporter.canCopeWithDuplicateFiles() || ! compiled.contains (sourceFiles.getReference(i)))
addFileWithGroups (sourceGroup,
moduleFromProject.getChildFile (pathWithinModule),
pathWithinModule);
}
sourceGroup.addFile (localModuleFolder.getChildFile (FileHelpers::getRelativePathFrom (moduleInfo.manifestFile,
moduleInfo.getFolder())), -1, false);
sourceGroup.addFile (getModuleHeaderFile (localModuleFolder), -1, false);
exporter.getModulesGroup().state.addChild (sourceGroup.state.createCopy(), -1, nullptr);
}
void ProjectExporter::addToExtraSearchPaths (const RelativePath& pathFromProjectFolder, int index)
{
RelativePath localPath (rebaseFromProjectFolderToBuildTarget (pathFromProjectFolder));
const String path (isVisualStudio() ? localPath.toWindowsStyle() : localPath.toUnixStyle());
if (! extraSearchPaths.contains (path))
extraSearchPaths.insert (index, path);
}
void ProjectExporter::addAAXFoldersToPath()
{
const String aaxFolder = getAAXPathValue().toString();
if (aaxFolder.isNotEmpty())
{
const RelativePath aaxFolderPath (getAAXPathValue().toString(), RelativePath::projectFolder);
addToExtraSearchPaths (aaxFolderPath);
addToExtraSearchPaths (aaxFolderPath.getChildFile ("Interfaces"));
addToExtraSearchPaths (aaxFolderPath.getChildFile ("Interfaces").getChildFile ("ACF"));
}
}
/*static*/ status_t
FSUtils::OpenSubDirectory(const BDirectory& baseDirectory,
const RelativePath& path, bool create, BDirectory& _directory)
{
// get a string for the path
BString pathString = path.ToString();
if (pathString.IsEmpty())
RETURN_ERROR(B_NO_MEMORY);
// If creating is not allowed, just try to open it.
if (!create)
RETURN_ERROR(_directory.SetTo(&baseDirectory, pathString));
// get an absolute path and create the subdirectory
BPath absolutePath;
status_t error = absolutePath.SetTo(&baseDirectory, pathString);
if (error != B_OK) {
ERROR("Volume::OpenSubDirectory(): failed to get absolute path "
"for subdirectory \"%s\": %s\n", pathString.String(),
strerror(error));
RETURN_ERROR(error);
}
error = create_directory(absolutePath.Path(),
S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH);
if (error != B_OK) {
ERROR("Volume::OpenSubDirectory(): failed to create "
"subdirectory \"%s\": %s\n", pathString.String(),
strerror(error));
RETURN_ERROR(error);
}
RETURN_ERROR(_directory.SetTo(&baseDirectory, pathString));
}
RelativePath ProjectExporter::getLegacyModulePath (const String& moduleID) const
{
if (project.getModules().state.getChildWithProperty (Ids::ID, moduleID) ["useLocalCopy"])
return RelativePath (project.getRelativePathForFile (project.getGeneratedCodeFolder()
.getChildFile ("modules")
.getChildFile (moduleID)), RelativePath::projectFolder);
String oldJucePath (getLegacyModulePath());
if (oldJucePath.isEmpty())
return RelativePath();
RelativePath p (oldJucePath, RelativePath::projectFolder);
if (p.getFileName() != "modules")
p = p.getChildFile ("modules");
return p.getChildFile (moduleID);
}
/** put the basic write operation into the buffer (bb) to be journaled */
static void prepBasicWrite_inlock(AlignedBuilder&bb, const WriteIntent *i, RelativePath& lastDbPath) {
size_t ofs = 1;
MongoMMF *mmf = findMMF_inlock(i->start(), /*out*/ofs);
if( unlikely(!mmf->willNeedRemap()) ) {
// tag this mmf as needed a remap of its private view later.
// usually it will already be dirty/already set, so we do the if above first
// to avoid possibility of cpu cache line contention
mmf->willNeedRemap() = true;
}
// since we have already looked up the mmf, we go ahead and remember the write view location
// so we don't have to find the MongoMMF again later in WRITETODATAFILES()
//
// this was for WRITETODATAFILES_Impl2 so commented out now
//
/*
dassert( i->w_ptr == 0 );
i->w_ptr = ((char*)mmf->view_write()) + ofs;
*/
JEntry e;
e.len = min(i->length(), (unsigned)(mmf->length() - ofs)); //dont write past end of file
assert( ofs <= 0x80000000 );
e.ofs = (unsigned) ofs;
e.setFileNo( mmf->fileSuffixNo() );
if( mmf->relativePath() == local ) {
e.setLocalDbContextBit();
}
else if( mmf->relativePath() != lastDbPath ) {
lastDbPath = mmf->relativePath();
JDbContext c;
bb.appendStruct(c);
bb.appendStr(lastDbPath.toString());
}
bb.appendStruct(e);
#if defined(_EXPERIMENTAL)
i->ofsInJournalBuffer = bb.len();
#endif
bb.appendBuf(i->start(), e.len);
if (unlikely(e.len != (unsigned)i->length())) {
log() << "journal info splitting prepBasicWrite at boundary" << endl;
// This only happens if we write to the last byte in a file and
// the fist byte in another file that is mapped adjacently. I
// think most OSs leave at least a one page gap between
// mappings, but better to be safe.
WriteIntent next ((char*)i->start() + e.len, i->length() - e.len);
prepBasicWrite_inlock(bb, &next, lastDbPath);
}
}
String ProjectExporter::getIncludePathForFileInJuceFolder (const String& pathFromJuceFolder, const File& targetIncludeFile) const
{
String juceFolderPath (getJuceFolder().toString());
if (juceFolderPath.startsWithChar ('<'))
{
juceFolderPath = FileHelpers::unixStylePath (File::addTrailingSeparator (juceFolderPath.substring (1).dropLastCharacters(1)));
if (juceFolderPath == "/")
juceFolderPath = String::empty;
return "<" + juceFolderPath + pathFromJuceFolder + ">";
}
else
{
const RelativePath juceFromProject (juceFolderPath, RelativePath::projectFolder);
const RelativePath fileFromProject (juceFromProject.getChildFile (pathFromJuceFolder));
const RelativePath fileFromHere (fileFromProject.rebased (project.getFile().getParentDirectory(),
targetIncludeFile.getParentDirectory(), RelativePath::unknown));
return fileFromHere.toUnixStyle().quoted();
}
}
bool Project::Item::addRelativeFile (const RelativePath& file, int insertIndex, bool shouldCompile)
{
Item item (project, ValueTree (Tags::file));
item.initialiseMissingProperties();
item.getNameValue() = file.getFileName();
item.getShouldCompileValue() = shouldCompile;
item.getShouldAddToResourceValue() = project.shouldBeAddedToBinaryResourcesByDefault (file);
if (canContain (item))
{
item.setFile (file);
addChild (item, insertIndex);
return true;
}
return false;
}
void output (void){
cout << solve.makeRelative(k1, k2);
}
bool Project::Item::containsChildForFile (const RelativePath& file) const
{
return state.getChildWithProperty (Ids::file, file.toUnixStyle()).isValid();
}
RelativePath ProjectExporter::rebaseFromProjectFolderToBuildTarget (const RelativePath& path) const
{
return path.rebased (project.getProjectFolder(), getTargetFolder(), RelativePath::buildTargetFolder);
}
bool ProjectExporter::shouldFileBeCompiledByDefault (const RelativePath& file) const
{
return file.hasFileExtension (cOrCppFileExtensions)
|| file.hasFileExtension (asmFileExtensions);
}
bool ProjectExporter::shouldFileBeCompiledByDefault (const RelativePath& file) const
{
return file.hasFileExtension ("cpp;cc;c;cxx;s");
}
