]> git.donarmstrong.com Git - lilypond.git/blob - lily/relocate.cc
Release: bump VERSION_DEVEL.
[lilypond.git] / lily / relocate.cc
1 /*
2   This file is part of LilyPond, the GNU music typesetter.
3
4   Copyright (C) 2005--2014 Han-Wen Nienhuys <hanwen@xs4all.nl>
5
6   LilyPond is free software: you can redistribute it and/or modify
7   it under the terms of the GNU General Public License as published by
8   the Free Software Foundation, either version 3 of the License, or
9   (at your option) any later version.
10
11   LilyPond is distributed in the hope that it will be useful,
12   but WITHOUT ANY WARRANTY; without even the implied warranty of
13   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14   GNU General Public License for more details.
15
16   You should have received a copy of the GNU General Public License
17   along with LilyPond.  If not, see <http://www.gnu.org/licenses/>.
18 */
19
20 #include "relocate.hh"
21
22 #include "config.hh"
23
24 /* TODO: autoconf support */
25
26 #include <sys/types.h>
27 #include <dirent.h>
28
29 #if HAVE_GETTEXT
30 #include <libintl.h>
31 #endif
32
33 #include "file-name.hh"
34 #include "file-path.hh"
35 #include "international.hh"
36 #include "lily-guile.hh"
37 #include "lily-version.hh"
38 #include "main.hh"
39 #include "version.hh"
40 #include "warn.hh"
41
42 #define FRAMEWORKDIR ".."
43
44 int
45 sane_putenv (char const *key, const string &value, bool overwrite)
46 {
47   if (overwrite || !getenv (key))
48     {
49       string combine = string (key) + "=" + value;
50       char *s = strdup (combine.c_str ());
51
52       debug_output (_f ("Setting %s to %s", key, value.c_str ())
53                     + "\n");
54
55       int retval = putenv (s);
56       /*
57         unfortunately, we can't portably free S here,
58         due to various bugs in glibc prior to 2.1.1
59       */
60       return retval;
61     }
62
63   return -1;
64 }
65
66 static int
67 set_env_file (char const *key, const string &value, bool overwrite = false)
68 {
69   if (is_file (value))
70     return sane_putenv (key, value, overwrite);
71   else if (is_loglevel (LOG_DEBUG))
72     // this warning should only be printed in debug mode!
73     warning (_f ("no such file: %s for %s", value, key));
74   return -1;
75 }
76
77 static int
78 set_env_dir (char const *key, const string &value)
79 {
80   if (is_dir (value))
81     return sane_putenv (key, value, false);
82   else if (is_loglevel (LOG_DEBUG))
83     // this warning should only be printed in debug mode!
84     warning (_f ("no such directory: %s for %s", value, key));
85   return -1;
86 }
87
88 static int
89 prepend_env_path (char const *key, string value)
90 {
91   if (is_dir (value))
92     {
93       debug_output (_f ("%s=%s (prepend)\n", key, value.c_str ()), false);
94
95       if (char const *cur = getenv (key))
96         value += to_string (PATHSEP) + cur;
97
98       return sane_putenv (key, value.c_str (), true);
99     }
100   else if (is_loglevel (LOG_DEBUG))
101     // this warning should only be printed in debug mode
102     warning (_f ("no such directory: %s for %s", value, key));
103   return -1;
104 }
105
106 #ifdef __MINGW32__
107 #include <winbase.h>
108 #endif
109
110 static void
111 prefix_relocation (const string &prefix)
112 {
113   string bindir = prefix + "/bin";
114   string datadir = prefix + "/share";
115   string localedir = datadir + "/locale";
116   string package_datadir = datadir + "/lilypond/";
117   string old_lilypond_datadir = lilypond_datadir;
118
119   if (is_dir (package_datadir + "/" + TOPLEVEL_VERSION))
120     lilypond_datadir = package_datadir + "/" + TOPLEVEL_VERSION;
121   else if (is_dir (package_datadir + "/current"))
122     lilypond_datadir = package_datadir + "/current";
123   else
124     warning (_f ("not relocating, no %s/ or current/ found under %s",
125                  TOPLEVEL_VERSION, package_datadir.c_str ()));
126
127 #if HAVE_GETTEXT
128   if (is_dir (localedir))
129     bindtextdomain ("lilypond", localedir.c_str ());
130 #endif
131
132   prepend_env_path ("PATH", bindir);
133
134   debug_output (_f ("Relocation: compile datadir=%s, new datadir=%s",
135                     old_lilypond_datadir.c_str (),
136                     lilypond_datadir.c_str ()));
137 }
138
139 /*
140   UGH : this is a complete mess.
141 */
142
143 static void
144 framework_relocation (const string &prefix)
145 {
146   debug_output (_f ("Relocation: framework_prefix=%s", prefix));
147
148   sane_putenv ("INSTALLER_PREFIX", prefix, true);
149
150   read_relocation_dir (prefix + "/etc/relocate/");
151
152   string bindir = prefix + "/bin";
153
154   prepend_env_path ("PATH", bindir);
155 }
156
157 /*
158   UGH : this is a complete mess.
159 */
160 void
161 setup_paths (char const *argv0_ptr)
162 {
163   File_name argv0_filename (argv0_ptr);
164
165   if (relocate_binary)
166     {
167       string prefix_directory;
168       string argv0_abs;
169       if (argv0_filename.is_absolute ())
170         {
171           argv0_abs = argv0_filename.to_string ();
172           debug_output (_f ("Relocation: is absolute: argv0=%s\n", argv0_ptr));
173         }
174       else if (argv0_filename.dir_.length ())
175         {
176           argv0_abs = get_working_directory ()
177                       + "/" + string (argv0_filename.to_string ());
178           debug_output (_f ("Relocation : from cwd: argv0=%s\n", argv0_ptr));
179         }
180       else
181         {
182           /* Find absolute ARGV0 name, using PATH.  */
183           File_path path;
184           path.parse_path (getenv ("PATH"));
185
186 #ifndef __MINGW32__
187           argv0_abs = path.find (argv0_filename.to_string ());
188 #else /* __MINGW32__ */
189           path.prepend (get_working_directory ());
190           char const *ext[] = {"exe", "", 0 };
191           argv0_abs = path.find (argv0_filename.to_string (), ext);
192 #endif /* __MINGW32__ */
193
194           debug_output (_f ("Relocation: from PATH=%s\nargv0=%s\n",
195                             path.to_string ().c_str (), argv0_ptr), true);
196
197           if (argv0_abs.empty ())
198             programming_error ("cannot find absolute argv0");
199         }
200
201       string bindir = dir_name (argv0_abs);
202       string argv0_prefix = dir_name (bindir);
203       string compile_prefix = dir_name (dir_name (dir_name (lilypond_datadir)));
204       if (argv0_prefix != compile_prefix)
205         {
206           prefix_relocation (argv0_prefix);
207           prefix_directory = argv0_prefix;
208         }
209       if (argv0_prefix != compile_prefix || string (FRAMEWORKDIR) != "..")
210         {
211           framework_relocation (bindir + "/" + FRAMEWORKDIR);
212           prefix_directory = bindir + "/" + FRAMEWORKDIR;
213         }
214
215       lilypond_datadir = prefix_directory
216                          + "/share/lilypond/" TOPLEVEL_VERSION;
217     }
218
219   if (getenv ("LILYPONDPREFIX"))
220     error (_ ("LILYPONDPREFIX is obsolete, use LILYPOND_DATADIR"));
221
222   if (char const *env = getenv ("LILYPOND_DATADIR"))
223     {
224       /* Normalize file name.  */
225       lilypond_datadir = File_name (env).to_string ();
226     }
227
228   /* When running from build dir, a full LILYPOND_DATADIR is set-up at
229      $(OUTBASE)/{share, lib}/lilypond/current.  Configure lily using
230      ./configure --prefix=$(pwd)/out */
231   string build_datadir_current = dir_name (lilypond_datadir) + "/current";
232   if (!is_dir (lilypond_datadir.c_str ())
233       && is_dir (build_datadir_current.c_str ()))
234     lilypond_datadir = build_datadir_current;
235
236   lilypond_datadir = File_name (lilypond_datadir).canonicalized ().to_string ();
237
238   global_path.append ("");
239
240   /* Adding mf/out make lilypond unchanged source directory, when setting
241      LILYPONDPREFIX to lilypond-x.y.z */
242   char const *suffixes[] = {"ly", "ps", "scm", 0 };
243
244   vector<string> dirs;
245   for (char const **s = suffixes; *s; s++)
246     {
247       string path = lilypond_datadir + to_string ('/') + string (*s);
248       dirs.push_back (path);
249     }
250
251   dirs.push_back (lilypond_datadir + "/fonts/otf/");
252   dirs.push_back (lilypond_datadir + "/fonts/type1/");
253   dirs.push_back (lilypond_datadir + "/fonts/svg/");
254
255   for (vsize i = 0; i < dirs.size (); i++)
256     global_path.prepend (dirs[i]);
257 }
258
259 string
260 expand_environment_variables (const string &orig)
261 {
262   char const *start_ptr = orig.c_str ();
263   char const *ptr = orig.c_str ();
264   size_t len = orig.length ();
265
266   string out;
267   while (ptr < start_ptr + len)
268     {
269       char const *dollar = strchr (ptr, '$');
270
271       if (dollar != NULL)
272         {
273           char const *start_var = dollar + 1;
274           char const *end_var = start_var;
275           char const *start_next = end_var;
276
277           out += string (ptr, dollar - ptr);
278           ptr = dollar;
279
280           if (*start_var == '{')
281             {
282               start_var++;
283
284               end_var = strchr (start_var, '}');
285
286               if (end_var == NULL)
287                 {
288                   end_var = start_var + len;
289                   start_next = end_var;
290                 }
291               else
292                 {
293                   start_next = end_var + 1;
294                 }
295             }
296           else
297             {
298               /*
299                 Hmm. what to do for $1 , $~ etc.?
300               */
301               do
302                 {
303                   end_var++;
304                 }
305               while (isalnum (*end_var) || *end_var == '_');
306               start_next = end_var;
307             }
308
309           if (start_var < end_var)
310             {
311               string var_name (start_var, end_var - start_var);
312               char const *value = getenv (var_name.c_str ());
313               if (value != NULL)
314                 out += string (value);
315
316               ptr = start_next;
317             }
318         }
319       else
320         break;
321
322     }
323
324   out += ptr;
325
326   return out;
327 }
328
329 // Ugh - very inefficient, but safer than fgets.
330 static string
331 read_line (FILE *f)
332 {
333   string out;
334
335   int c = 0;
336   while ((c = fgetc (f)) != EOF && c != '\n')
337     out += char (c);
338
339   return out;
340 }
341
342 void
343 read_relocation_file (const string &filename)
344 {
345   debug_output (_f ("Relocation file: %s", filename.c_str ()) + "\n");
346   char const *cname = filename.c_str ();
347   FILE *f = fopen (cname, "r");
348   if (!f)
349     error (_f ("cannot open file: `%s'", cname));
350
351   while (!feof (f))
352     {
353       string line = read_line (f);
354       size_t idx = line.find (' ');
355       if (idx == NPOS)
356         continue;
357
358       string command = line.substr (0, idx);
359       line = line.substr (idx + 1);
360
361       if (idx == NPOS)
362         continue;
363       idx = line.find ('=');
364
365       string variable = line.substr (0, idx);
366       string value = line.substr (idx + 1);
367
368       value = expand_environment_variables (value);
369
370       if (command == "set")
371         sane_putenv (variable.c_str (), value, true);
372       else if (command == "setdir")
373         set_env_dir (variable.c_str (), value);
374       else if (command == "setfile")
375         set_env_file (variable.c_str (), value);
376       else if (command == "prependdir")
377         prepend_env_path (variable.c_str (), value);
378       else
379         error (_f ("Unknown relocation command %s", command));
380     }
381
382   fclose (f);
383 }
384
385 void
386 read_relocation_dir (const string &dirname)
387 {
388   if (DIR *dir = opendir (dirname.c_str ()))
389     while (struct dirent *ent = readdir (dir))
390       {
391         File_name name (ent->d_name);
392         if (name.ext_ == "reloc")
393           read_relocation_file (dirname + "/" + name.to_string ());
394       }
395 }