comparison src/knownplugins.cpp @ 37:3ccc384c0161

Merge from branch plugin-path-config

 /* -*- c-basic-offset: 4 indent-tabs-mode: nil -*-  vi:set ts=8 sts=4 sw=4: */
 /*
-  Copyright (c) 2016 Queen Mary, University of London
+  Copyright (c) 2016-2018 Queen Mary, University of London
 
   Permission is hereby granted, free of charge, to any person
   obtaining a copy of this software and associated documentation
   files (the "Software"), to deal in the Software without
   restriction, including without limitation the rights to use, copy,

   dealings in this Software without prior written authorization.
 */
 
 #include "knownplugins.h"
 
-#include <sstream>
+#include <iostream>
 
 using namespace std;
 
 #if defined(_WIN32)
+#include <windows.h>
 #define PATH_SEPARATOR ';'
 #else
 #define PATH_SEPARATOR ':'
 #endif
 
-KnownPlugins::KnownPlugins(string helperExecutableName,
-                           PluginCandidates::LogCallback *cb) :
-    m_candidates(helperExecutableName),
-    m_helperExecutableName(helperExecutableName)
-{
-    m_candidates.setLogCallback(cb);
-    
-    m_known = {
-        {
-            VampPlugin,
-            {
-                "vamp",
-                expandConventionalPath(VampPlugin, "VAMP_PATH"),
-                "vampGetPluginDescriptor"
-            },
-        }, {
-            LADSPAPlugin,
-            {
-                "ladspa",
-                expandConventionalPath(LADSPAPlugin, "LADSPA_PATH"),
-                "ladspa_descriptor"
-            },
-        }, {
-            DSSIPlugin,
-            {
-                "dssi",
-                expandConventionalPath(DSSIPlugin, "DSSI_PATH"),
-                "dssi_descriptor"
-            }
-        }
+static bool
+getEnvUtf8(std::string variable, std::string &value)
+{
+    value = "";
+    
+#ifdef _WIN32
+    int wvarlen = MultiByteToWideChar(CP_UTF8, 0,
+                                      variable.c_str(), int(variable.length()),
+                                      0, 0);
+    if (wvarlen < 0) {
+        cerr << "WARNING: Unable to convert environment variable name "
+             << variable << " to wide characters" << endl;
+        return false;
+    }
+    
+    wchar_t *wvarbuf = new wchar_t[wvarlen + 1];
+    (void)MultiByteToWideChar(CP_UTF8, 0,
+                              variable.c_str(), int(variable.length()),
+                              wvarbuf, wvarlen);
+    wvarbuf[wvarlen] = L'\0';
+    
+    wchar_t *wvalue = _wgetenv(wvarbuf);
+
+    delete[] wvarbuf;
+
+    if (!wvalue) {
+        return false;
+    }
+
+    int wvallen = int(wcslen(wvalue));
+    int vallen = WideCharToMultiByte(CP_UTF8, 0,
+                                     wvalue, wvallen,
+                                     0, 0, 0, 0);
+    if (vallen < 0) {
+        cerr << "WARNING: Unable to convert environment value to UTF-8" << endl;
+        return false;
+    }
+
+    char *val = new char[vallen + 1];
+    (void)WideCharToMultiByte(CP_UTF8, 0,
+                              wvalue, wvallen,
+                              val, vallen, 0, 0);
+    val[vallen] = '\0';
+
+    value = val;
+
+    delete[] val;
+    return true;
+
+#else
+
+    char *val = getenv(variable.c_str());
+    if (!val) {
+        return false;
+    }
+
+    value = val;
+    return true;
+    
+#endif
+}
+
+KnownPlugins::KnownPlugins(BinaryFormat format) :
+    m_format(format)
+{
+    string variableSuffix = "";
+    if (m_format == FormatNonNative32Bit) {
+        variableSuffix = "_32";
+    }
+    
+    m_known[VampPlugin] = {
+        "vamp",
+        "VAMP_PATH" + variableSuffix,
+        {}, {},
+        "vampGetPluginDescriptor"
     };
+    
+    m_known[LADSPAPlugin] = {
+        "ladspa",
+        "LADSPA_PATH" + variableSuffix,
+        {}, {},
+        "ladspa_descriptor"
+    };
+
+    m_known[DSSIPlugin] = {
+        "dssi",
+        "DSSI_PATH" + variableSuffix,
+        {}, {},
+        "dssi_descriptor"
+    };
+
+    for (auto &k: m_known) {
+        k.second.defaultPath = expandPathString(getDefaultPathString(k.first));
+        k.second.path = expandConventionalPath(k.first, k.second.variable);
+    }
+}
+
+vector<KnownPlugins::PluginType>
+KnownPlugins::getKnownPluginTypes() const
+{
+    vector<PluginType> kt;
 
     for (const auto &k: m_known) {
-        m_candidates.scan(k.second.tag, k.second.path, k.second.descriptor);
-    }
-}
-
-bool
-KnownPlugins::is32bit() const
-{
-    return m_helperExecutableName.find("-32") != std::string::npos;
+        kt.push_back(k.first);
+    }
+
+    return kt;
 }
 
 string
-KnownPlugins::getDefaultPath(PluginType type)
+KnownPlugins::getUnexpandedDefaultPathString(PluginType type)
 {
     switch (type) {
 
 #if defined(_WIN32)
 

     }
 
     throw logic_error("unknown or unhandled plugin type");
 }
 
+string
+KnownPlugins::getDefaultPathString(PluginType type)
+{
+    string path = getUnexpandedDefaultPathString(type);
+
+    if (path == "") {
+        return path;
+    }
+
+    string home;
+    if (getEnvUtf8("HOME", home)) {
+        string::size_type f;
+        while ((f = path.find("$HOME")) != string::npos &&
+               f < path.length()) {
+            path.replace(f, 5, home);
+        }
+    }
+
+#ifdef _WIN32
+    string pfiles, pfiles32;
+    if (!getEnvUtf8("ProgramFiles", pfiles)) {
+        pfiles = "C:\\Program Files";
+    }
+    if (!getEnvUtf8("ProgramFiles(x86)", pfiles32)) {
+        pfiles32 = "C:\\Program Files (x86)";
+    }
+    
+    string::size_type f;
+    while ((f = path.find("%ProgramFiles%")) != string::npos &&
+           f < path.length()) {
+        if (m_format == FormatNonNative32Bit) {
+            path.replace(f, 14, pfiles32);
+        } else {
+            path.replace(f, 14, pfiles);
+        }
+    }
+#endif
+
+    return path;
+}
+
 vector<string>
-KnownPlugins::expandConventionalPath(PluginType type, string var)
+KnownPlugins::expandPathString(string path)
 {
     vector<string> pathList;
-    string path;
-
-    char *cpath = getenv(var.c_str());
-    if (cpath) path = cpath;
-
-#ifdef _WIN32
-    bool is32 = is32bit();
-#endif
-
-    if (path == "") {
-
-        path = getDefaultPath(type);
-
-        if (path != "") {
-
-            char *home = getenv("HOME");
-            if (home) {
-                string::size_type f;
-                while ((f = path.find("$HOME")) != string::npos &&
-                       f < path.length()) {
-                    path.replace(f, 5, home);
-                }
-            }
-
-#ifdef _WIN32
-            const char *pfiles = 0;
-            if (is32) {
-                pfiles = getenv("ProgramFiles(x86)");
-            }
-            if (!pfiles) {
-                pfiles = getenv("ProgramFiles");
-            }
-            if (!pfiles) {
-                if (is32) {
-                    pfiles = "C:\\Program Files (x86)";
-                } else {
-                    pfiles = "C:\\Program Files";
-                }
-            }
-            string::size_type f;
-            while ((f = path.find("%ProgramFiles%")) != string::npos &&
-                   f < path.length()) {
-                path.replace(f, 14, pfiles);
-            }
-#endif
-        }
-    }
 
     string::size_type index = 0, newindex = 0;
 
     while ((newindex = path.find(PATH_SEPARATOR, index)) < path.size()) {
         pathList.push_back(path.substr(index, newindex - index).c_str());

     pathList.push_back(path.substr(index));
 
     return pathList;
 }
 
-string
-KnownPlugins::getFailureReport() const
-{
-    vector<PluginCandidates::FailureRec> failures;
-
-    for (auto t: getKnownPluginTypes()) {
-        auto ff = m_candidates.getFailedLibrariesFor(getTagFor(t));
-        failures.insert(failures.end(), ff.begin(), ff.end());
-    }
-
-    if (failures.empty()) return "";
-
-    int n = int(failures.size());
-    int i = 0;
-
-    ostringstream os;
-    
-    os << "<ul>";
-    for (auto f: failures) {
-        os << "<li>" + f.library;
-        if (f.message != "") {
-            os << "<br><i>" + f.message + "</i>";
-        } else {
-            os << "<br><i>unknown error</i>";
-        }
-        os << "</li>";
-
-        if (n > 10) {
-            if (++i == 5) {
-                os << "<li>(... and " << (n - i) << " further failures)</li>";
-                break;
-            }
-        }
-    }
-    os << "</ul>";
-
-    return os.str();
-}
+vector<string>
+KnownPlugins::expandConventionalPath(PluginType type, string var)
+{
+    string path;
+
+    if (!getEnvUtf8(var, path)) {
+        path = getDefaultPathString(type);
+    }
+
+    return expandPathString(path);
+}