Support --output-sync on MS-Windows.
[libreoffice:gnu-make-lo.git] / load.c
1 /* Loading dynamic objects for GNU Make.
2 Copyright (C) 2012 Free Software Foundation, Inc.
3 This file is part of GNU Make.
4
5 GNU Make is free software; you can redistribute it and/or modify it under the
6 terms of the GNU General Public License as published by the Free Software
7 Foundation; either version 3 of the License, or (at your option) any later
8 version.
9
10 GNU Make is distributed in the hope that it will be useful, but WITHOUT ANY
11 WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
12 A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
13
14 You should have received a copy of the GNU General Public License along with
15 this program.  If not, see <http://www.gnu.org/licenses/>.  */
16
17 #include "makeint.h"
18
19 #if MAKE_LOAD
20
21 #include <string.h>
22 #include <ctype.h>
23 #include <stdlib.h>
24 #include <dlfcn.h>
25 #include <errno.h>
26
27 #define SYMBOL_EXTENSION        "_gmk_setup"
28
29 static void *global_dl = NULL;
30
31 #include "debug.h"
32 #include "filedef.h"
33 #include "variable.h"
34
35 static int
36 init_symbol (const gmk_floc *flocp, const char *ldname, load_func_t symp)
37 {
38   int r;
39   const char *p;
40   int nmlen = strlen (ldname);
41   char *loaded = allocated_variable_expand("$(.LOADED)");
42
43   /* If it's already been loaded don't do it again.  */
44   p = strstr (loaded, ldname);
45   r = p && (p==loaded || p[-1]==' ') && (p[nmlen]=='\0' || p[nmlen]==' ');
46   free (loaded);
47   if (r)
48     return 1;
49
50   /* Now invoke the symbol.  */
51   r = (*symp) (flocp);
52
53   /* If it succeeded, add the symbol to the loaded variable.  */
54   if (r > 0)
55     do_variable_definition (flocp, ".LOADED", ldname, o_default, f_append, 0);
56
57   return r;
58 }
59
60 int
61 load_file (const gmk_floc *flocp, const char **ldname, int noerror)
62 {
63   load_func_t symp;
64   const char *fp;
65   char *symname = NULL;
66   char *new = alloca (strlen (*ldname) + CSTRLEN (SYMBOL_EXTENSION) + 1);
67
68   if (! global_dl)
69     {
70       global_dl = dlopen (NULL, RTLD_NOW|RTLD_GLOBAL);
71       if (! global_dl)
72         fatal (flocp, _("Failed to open global symbol table: %s"), dlerror());
73     }
74
75   /* If a symbol name was provided, use it.  */
76   fp = strchr (*ldname, '(');
77   if (fp)
78     {
79       const char *ep;
80
81       /* There's an open paren, so see if there's a close paren: if so use
82          that as the symbol name.  We can't have whitespace: it would have
83          been chopped up before this function is called.  */
84       ep = strchr (fp+1, ')');
85       if (ep && ep[1] == '\0')
86         {
87           int l = fp - *ldname;;
88
89           ++fp;
90           if (fp == ep)
91             fatal (flocp, _("Empty symbol name for load: %s"), *ldname);
92
93           /* Make a copy of the ldname part.  */
94           memcpy (new, *ldname, l);
95           new[l] = '\0';
96           *ldname = new;
97
98           /* Make a copy of the symbol name part.  */
99           symname = new + l + 1;
100           memcpy (symname, fp, ep - fp);
101           symname[ep - fp] = '\0';
102         }
103     }
104
105   /* Add this name to the string cache so it can be reused later.  */
106   *ldname = strcache_add (*ldname);
107
108   /* If we didn't find a symbol name yet, construct it from the ldname.  */
109   if (! symname)
110     {
111       char *p = new;
112
113       fp = strrchr (*ldname, '/');
114       if (!fp)
115         fp = *ldname;
116       else
117         ++fp;
118       while (isalnum (*fp) || *fp == '_')
119         *(p++) = *(fp++);
120       strcpy (p, SYMBOL_EXTENSION);
121       symname = new;
122     }
123
124   DB (DB_VERBOSE, (_("Loading symbol %s from %s\n"), symname, *ldname));
125
126   /* See if it's already defined.  */
127   symp = (load_func_t) dlsym (global_dl, symname);
128   if (! symp) {
129     void *dlp = NULL;
130
131     /* If the path has no "/", try the current directory first.  */
132     if (! strchr (*ldname, '/'))
133       dlp = dlopen (concat (2, "./", *ldname), RTLD_LAZY|RTLD_GLOBAL);
134
135     /* If we haven't opened it yet, try the default search path.  */
136     if (! dlp)
137       dlp = dlopen (*ldname, RTLD_LAZY|RTLD_GLOBAL);
138
139     /* Still no?  Then fail.  */
140     if (! dlp)
141       {
142         if (noerror)
143           DB (DB_BASIC, ("%s", dlerror()));
144         else
145           error (flocp, "%s", dlerror());
146         return 0;
147       }
148
149     symp = dlsym (dlp, symname);
150     if (! symp)
151       fatal (flocp, _("Failed to load symbol %s from %s: %s"),
152              symname, *ldname, dlerror());
153   }
154
155   /* Invoke the symbol to initialize the loaded object.  */
156   return init_symbol(flocp, *ldname, symp);
157 }
158
159 #else
160
161 int
162 load_file (const gmk_floc *flocp, const char **ldname, int noerror)
163 {
164   if (! noerror)
165     fatal (flocp, _("The 'load' operation is not supported on this platform."));
166
167   return 0;
168 }
169
170 #endif  /* MAKE_LOAD */