X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=lily%2Frelocate.cc;h=2adfb6f2f75c759d9b96b3d36fa383470c5975bd;hb=47db9a3883d726ca53e2133a3b2298f78dd6a32e;hp=6bfbc8ae5797ff2433fbfd1981ca66ec8887689a;hpb=2dbaada733947bf4ac7c104f56b6090ee04a425d;p=lilypond.git diff --git a/lily/relocate.cc b/lily/relocate.cc index 6bfbc8ae57..2adfb6f2f7 100644 --- a/lily/relocate.cc +++ b/lily/relocate.cc @@ -1,16 +1,31 @@ /* - relocate.cc -- implement relocation based on argv0 + This file is part of LilyPond, the GNU music typesetter. - source file of the GNU LilyPond music typesetter + Copyright (C) 2005--2015 Han-Wen Nienhuys - (c) 2005--2006 Han-Wen Nienhuys + LilyPond 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. + LilyPond 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 LilyPond. If not, see . */ #include "relocate.hh" #include "config.hh" +/* TODO: autoconf support */ + +#include +#include + #if HAVE_GETTEXT #include #endif @@ -26,36 +41,46 @@ #define FRAMEWORKDIR ".." - int -sane_putenv (char const *key, string value, bool overwrite) +sane_putenv (char const *key, const string &value, bool overwrite) { if (overwrite || !getenv (key)) { string combine = string (key) + "=" + value; char *s = strdup (combine.c_str ()); - return putenv (s); + + debug_output (_f ("Setting %s to %s", key, value.c_str ()) + + "\n"); + + int retval = putenv (s); + /* + unfortunately, we can't portably free S here, + due to various bugs in glibc prior to 2.1.1 + */ + return retval; } - + return -1; } static int -set_env_file (char const *key, string value, bool overwrite = false) +set_env_file (char const *key, const string &value, bool overwrite = false) { if (is_file (value)) return sane_putenv (key, value, overwrite); - else if (be_verbose_global) + else if (is_loglevel (LOG_DEBUG)) + // this warning should only be printed in debug mode! warning (_f ("no such file: %s for %s", value, key)); return -1; } static int -set_env_dir (char const *key, string value) +set_env_dir (char const *key, const string &value) { if (is_dir (value)) return sane_putenv (key, value, false); - else if (be_verbose_global) + else if (is_loglevel (LOG_DEBUG)) + // this warning should only be printed in debug mode! warning (_f ("no such directory: %s for %s", value, key)); return -1; } @@ -65,15 +90,15 @@ prepend_env_path (char const *key, string value) { if (is_dir (value)) { - if (be_verbose_global) - progress_indication (_f ("%s=%s (prepend)\n", key, value.c_str ())); + debug_output (_f ("%s=%s (prepend)\n", key, value.c_str ()), false); if (char const *cur = getenv (key)) - value += to_string (PATHSEP) + cur; + value += to_string (PATHSEP) + cur; return sane_putenv (key, value.c_str (), true); } - else if (be_verbose_global) + else if (is_loglevel (LOG_DEBUG)) + // this warning should only be printed in debug mode warning (_f ("no such directory: %s for %s", value, key)); return -1; } @@ -82,23 +107,22 @@ prepend_env_path (char const *key, string value) #include #endif -void -prefix_relocation (string prefix) +static void +prefix_relocation (const string &prefix) { - if (be_verbose_global) - warning (_f ("Relocation: compile prefix=%s, new prefix=%s", - prefix_directory, - prefix.c_str ())); - string bindir = prefix + "/bin"; string datadir = prefix + "/share"; string localedir = datadir + "/locale"; - string lilypond_datadir = datadir + "/lilypond/"; + string package_datadir = datadir + "/lilypond/"; + string old_lilypond_datadir = lilypond_datadir; - if (is_dir (lilypond_datadir + "/" + TOPLEVEL_VERSION)) - prefix_directory = lilypond_datadir + "/" + TOPLEVEL_VERSION; - else if (is_dir (lilypond_datadir + "/current")) - prefix_directory = lilypond_datadir + "/current"; + if (is_dir (package_datadir + "/" + TOPLEVEL_VERSION)) + lilypond_datadir = package_datadir + "/" + TOPLEVEL_VERSION; + else if (is_dir (package_datadir + "/current")) + lilypond_datadir = package_datadir + "/current"; + else + warning (_f ("not relocating, no %s/ or current/ found under %s", + TOPLEVEL_VERSION, package_datadir.c_str ())); #if HAVE_GETTEXT if (is_dir (localedir)) @@ -106,174 +130,266 @@ prefix_relocation (string prefix) #endif prepend_env_path ("PATH", bindir); + + debug_output (_f ("Relocation: compile datadir=%s, new datadir=%s", + old_lilypond_datadir.c_str (), + lilypond_datadir.c_str ())); } -void -framework_relocation (string prefix) +/* + UGH : this is a complete mess. +*/ + +static void +framework_relocation (const string &prefix) { - if (be_verbose_global) - warning (_f ("Relocation: framework_prefix=%s", prefix)); + debug_output (_f ("Relocation: framework_prefix=%s", prefix)); - string bindir = prefix + "/bin"; - string datadir = prefix + "/share"; - string libdir = prefix + "/lib"; - string sysconfdir = prefix + "/etc"; + sane_putenv ("INSTALLER_PREFIX", prefix, true); - /* need otherwise dynamic .so's aren't found. */ - prepend_env_path ("DYLD_LIBRARY_PATH", libdir); - - set_env_file ("FONTCONFIG_FILE", sysconfdir + "/fonts/fonts.conf", true); - set_env_dir ("FONTCONFIG_PATH", sysconfdir + "/fonts"); + read_relocation_dir (prefix + "/etc/relocate/"); -#ifdef __MINGW32__ - char font_dir[PATH_MAX]; - ExpandEnvironmentStrings ("%windir%/fonts", font_dir, sizeof (font_dir)); - prepend_env_path ("GS_FONTPATH", font_dir); -#endif + string bindir = prefix + "/bin"; - string gs_version = -#ifdef GHOSTSCRIPT_VERSION - GHOSTSCRIPT_VERSION -#else - "ghostscript-version-undefined" -#endif - ; - - if (char const *cur = getenv ("LILYPOND_GS_VERSION")) - gs_version = cur; - - prepend_env_path ("GS_FONTPATH", datadir + "/ghostscript/" + gs_version + "/fonts"); - prepend_env_path ("GS_LIB", datadir + "/ghostscript/" + gs_version + "/Resource"); - prepend_env_path ("GS_LIB", datadir + "/ghostscript/" + gs_version + "/lib"); - - prepend_env_path ("GS_FONTPATH", datadir + "/gs/fonts"); - prepend_env_path ("GS_LIB", datadir + "/gs/Resource"); - prepend_env_path ("GS_LIB", datadir + "/gs/lib"); - - prepend_env_path ("GUILE_LOAD_PATH", datadir - + to_string ("/guile/%d.%d", - SCM_MAJOR_VERSION, SCM_MINOR_VERSION)); - - set_env_file ("PANGO_RC_FILE", sysconfdir + "/pango/pangorc"); - set_env_dir ("PANGO_PREFIX", prefix); - prepend_env_path ("PATH", bindir); } +/* + UGH : this is a complete mess. +*/ void setup_paths (char const *argv0_ptr) { File_name argv0_filename (argv0_ptr); - - prefix_directory = LILYPOND_DATADIR; - if (relocate_binary - && getenv ("LILYPOND_RELOCATE_PREFIX")) - { - string prefix = getenv ("LILYPOND_RELOCATE_PREFIX"); -#ifdef __MINGW32__ - /* Normalize file name. */ - prefix = File_name (prefix).to_string (); -#endif /* __MINGW32__ */ - prefix_relocation (prefix); - string bindir = prefix + "/bin"; - framework_relocation (bindir); - } - else if (relocate_binary) + + if (relocate_binary) { + string prefix_directory; string argv0_abs; if (argv0_filename.is_absolute ()) - { - argv0_abs = argv0_filename.to_string (); - if (be_verbose_global) - warning (_f ("Relocation: is absolute: argv0=%s", argv0_ptr)); - } + { + argv0_abs = argv0_filename.to_string (); + debug_output (_f ("Relocation: is absolute: argv0=%s\n", argv0_ptr)); + } else if (argv0_filename.dir_.length ()) - { - argv0_abs = get_working_directory () - + "/" + string (argv0_filename.to_string ()); - if (be_verbose_global) - warning (_f ("Relocation: from cwd: argv0=%s", argv0_ptr)); - } + { + argv0_abs = get_working_directory () + + "/" + string (argv0_filename.to_string ()); + debug_output (_f ("Relocation : from cwd: argv0=%s\n", argv0_ptr)); + } else - { - /* Find absolute ARGV0 name, using PATH. */ - File_path path; - path.parse_path (getenv ("PATH")); - - if (be_verbose_global) - warning (_f ("Relocation: from PATH=%s\nargv0=%s", - path.to_string ().c_str (), argv0_ptr)); + { + /* Find absolute ARGV0 name, using PATH. */ + File_path path; + path.parse_path (getenv ("PATH")); #ifndef __MINGW32__ - argv0_abs = path.find (argv0_filename.to_string ()); + argv0_abs = path.find (argv0_filename.to_string ()); #else /* __MINGW32__ */ - char const *ext[] = {"exe", "", 0 }; - argv0_abs = path.find (argv0_filename.to_string (), ext); + path.prepend (get_working_directory ()); + char const *ext[] = {"exe", "", 0 }; + argv0_abs = path.find (argv0_filename.to_string (), ext); #endif /* __MINGW32__ */ - if (argv0_abs.empty ()) - programming_error ("can't find absolute argv0."); - } + debug_output (_f ("Relocation: from PATH=%s\nargv0=%s\n", + path.to_string ().c_str (), argv0_ptr), true); + + if (argv0_abs.empty ()) + programming_error ("cannot find absolute argv0"); + } string bindir = dir_name (argv0_abs); string argv0_prefix = dir_name (bindir); - string compile_prefix = dir_name (dir_name (dir_name (prefix_directory))); + string compile_prefix = dir_name (dir_name (dir_name (lilypond_datadir))); if (argv0_prefix != compile_prefix) - prefix_relocation (argv0_prefix); + { + prefix_relocation (argv0_prefix); + prefix_directory = argv0_prefix; + } if (argv0_prefix != compile_prefix || string (FRAMEWORKDIR) != "..") - framework_relocation (bindir + "/" + FRAMEWORKDIR); + { + framework_relocation (bindir + "/" + FRAMEWORKDIR); + prefix_directory = bindir + "/" + FRAMEWORKDIR; + } + + lilypond_datadir = prefix_directory + + "/share/lilypond/" TOPLEVEL_VERSION; } - /* FIXME: use LILYPOND_DATADIR. */ - if (char const *env = getenv ("LILYPONDPREFIX")) - { + if (getenv ("LILYPONDPREFIX")) + error (_ ("LILYPONDPREFIX is obsolete, use LILYPOND_DATADIR")); -#ifdef __MINGW32__ + if (char const *env = getenv ("LILYPOND_DATADIR")) + { /* Normalize file name. */ - prefix_directory = File_name (env).to_string (); -#else - prefix_directory = env; -#endif + lilypond_datadir = File_name (env).to_string (); } - global_path.append (""); - - - /* - When running from build dir, a full LILYPOND_PREFIX is set-up at + /* When running from build dir, a full LILYPOND_DATADIR is set-up at + $(OUTBASE)/{share, lib}/lilypond/current. Configure lily using + ./configure --prefix=$(pwd)/out */ + string build_datadir_current = dir_name (lilypond_datadir) + "/current"; + if (!is_dir (lilypond_datadir.c_str ()) + && is_dir (build_datadir_current.c_str ())) + lilypond_datadir = build_datadir_current; - $(OUTBASE)/share/lilypond/TOPLEVEL_VERSION + lilypond_datadir = File_name (lilypond_datadir).canonicalized ().to_string (); - This historical hack will allow the shorthand - - LILYPONDPREFIX=out lily/out/lilypond ... + global_path.append (""); - */ - - string build_prefix_current = prefix_directory + "/share/lilypond/" "current"; - string build_prefix_version = prefix_directory + "/share/lilypond/" TOPLEVEL_VERSION; - if (is_dir (build_prefix_version.c_str ())) - prefix_directory = build_prefix_version; - else if (is_dir (build_prefix_current.c_str ())) - prefix_directory = build_prefix_current; - /* Adding mf/out make lilypond unchanged source directory, when setting LILYPONDPREFIX to lilypond-x.y.z */ char const *suffixes[] = {"ly", "ps", "scm", 0 }; - vector dirs; for (char const **s = suffixes; *s; s++) { - string path = prefix_directory + to_string ('/') + string (*s); + string path = lilypond_datadir + to_string ('/') + string (*s); dirs.push_back (path); } + dirs.push_back (lilypond_datadir + "/fonts/otf/"); + dirs.push_back (lilypond_datadir + "/fonts/type1/"); + dirs.push_back (lilypond_datadir + "/fonts/svg/"); - dirs.push_back (prefix_directory + "/fonts/otf/"); - dirs.push_back (prefix_directory + "/fonts/type1/"); - dirs.push_back (prefix_directory + "/fonts/svg/"); - for (vsize i = 0; i < dirs.size (); i++) global_path.prepend (dirs[i]); } + +string +expand_environment_variables (const string &orig) +{ + char const *start_ptr = orig.c_str (); + char const *ptr = orig.c_str (); + size_t len = orig.length (); + + string out; + while (ptr < start_ptr + len) + { + char const *dollar = strchr (ptr, '$'); + + if (dollar != NULL) + { + char const *start_var = dollar + 1; + char const *end_var = start_var; + char const *start_next = end_var; + + out += string (ptr, dollar - ptr); + ptr = dollar; + + if (*start_var == '{') + { + start_var++; + + end_var = strchr (start_var, '}'); + + if (end_var == NULL) + { + end_var = start_var + len; + start_next = end_var; + } + else + { + start_next = end_var + 1; + } + } + else + { + /* + Hmm. what to do for $1 , $~ etc.? + */ + do + { + end_var++; + } + while (isalnum (*end_var) || *end_var == '_'); + start_next = end_var; + } + + if (start_var < end_var) + { + string var_name (start_var, end_var - start_var); + char const *value = getenv (var_name.c_str ()); + if (value != NULL) + out += string (value); + + ptr = start_next; + } + } + else + break; + + } + + out += ptr; + + return out; +} + +// Ugh - very inefficient, but safer than fgets. +static string +read_line (FILE *f) +{ + string out; + + int c = 0; + while ((c = fgetc (f)) != EOF && c != '\n') + out += char (c); + + return out; +} + +void +read_relocation_file (const string &filename) +{ + debug_output (_f ("Relocation file: %s", filename.c_str ()) + "\n"); + char const *cname = filename.c_str (); + FILE *f = fopen (cname, "r"); + if (!f) + error (_f ("cannot open file: `%s'", cname)); + + while (!feof (f)) + { + string line = read_line (f); + size_t idx = line.find (' '); + if (idx == NPOS) + continue; + + string command = line.substr (0, idx); + line = line.substr (idx + 1); + + if (idx == NPOS) + continue; + idx = line.find ('='); + + string variable = line.substr (0, idx); + string value = line.substr (idx + 1); + + value = expand_environment_variables (value); + + if (command == "set") + sane_putenv (variable.c_str (), value, true); + else if (command == "setdir") + set_env_dir (variable.c_str (), value); + else if (command == "setfile") + set_env_file (variable.c_str (), value); + else if (command == "prependdir") + prepend_env_path (variable.c_str (), value); + else + error (_f ("Unknown relocation command %s", command)); + } + + fclose (f); +} + +void +read_relocation_dir (const string &dirname) +{ + if (DIR *dir = opendir (dirname.c_str ())) + while (struct dirent *ent = readdir (dir)) + { + File_name name (ent->d_name); + if (name.ext_ == "reloc") + read_relocation_file (dirname + "/" + name.to_string ()); + } +}