nexmon – Blame information for rev 1

Subversion Repositories:
Rev:
Rev Author Line No. Line
1 office 1 /*
2 * Copyright © 2011 Canonical Limited
3 *
4 * This library is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU Lesser General Public License as
6 * published by the Free Software Foundation; either version 2 of the
7 * licence, or (at your option) any later version.
8 *
9 * This library is distributed in the hope that it will be useful, but
10 * WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
13 *
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with this library; if not, see <http://www.gnu.org/licenses/>.
16 *
17 * Author: Ryan Lortie <desrt@desrt.ca>
18 */
19  
20 #include "config.h"
21  
22 #include "glib-init.h"
23  
24 #include "glib-private.h"
25 #include "gtypes.h"
26 #include "gutils.h" /* for GDebugKey */
27 #include "gconstructor.h"
28 #include "gmem.h" /* for g_mem_gc_friendly */
29  
30 #include <string.h>
31 #include <stdlib.h>
32 #include <stdio.h>
33 #include <ctype.h>
34  
35 /* This seems as good a place as any to make static assertions about platform
36 * assumptions we make throughout GLib. */
37  
38 /* We do not support 36-bit bytes or other historical curiosities. */
39 G_STATIC_ASSERT (CHAR_BIT == 8);
40  
41 /* We assume that data pointers are the same size as function pointers... */
42 G_STATIC_ASSERT (sizeof (gpointer) == sizeof (GFunc));
43 G_STATIC_ASSERT (_g_alignof (gpointer) == _g_alignof (GFunc));
44 /* ... and that all function pointers are the same size. */
45 G_STATIC_ASSERT (sizeof (GFunc) == sizeof (GCompareDataFunc));
46 G_STATIC_ASSERT (_g_alignof (GFunc) == _g_alignof (GCompareDataFunc));
47  
48 /**
49 * g_mem_gc_friendly:
50 *
51 * This variable is %TRUE if the `G_DEBUG` environment variable
52 * includes the key `gc-friendly`.
53 */
54 #ifdef ENABLE_GC_FRIENDLY_DEFAULT
55 gboolean g_mem_gc_friendly = TRUE;
56 #else
57 gboolean g_mem_gc_friendly = FALSE;
58 #endif
59 GLogLevelFlags g_log_msg_prefix = G_LOG_LEVEL_ERROR | G_LOG_LEVEL_WARNING |
60 G_LOG_LEVEL_CRITICAL | G_LOG_LEVEL_DEBUG;
61 GLogLevelFlags g_log_always_fatal = G_LOG_FATAL_MASK;
62  
63 static gboolean
64 debug_key_matches (const gchar *key,
65 const gchar *token,
66 guint length)
67 {
68 /* may not call GLib functions: see note in g_parse_debug_string() */
69 for (; length; length--, key++, token++)
70 {
71 char k = (*key == '_') ? '-' : tolower (*key );
72 char t = (*token == '_') ? '-' : tolower (*token);
73  
74 if (k != t)
75 return FALSE;
76 }
77  
78 return *key == '\0';
79 }
80  
81 /**
82 * g_parse_debug_string:
83 * @string: (allow-none): a list of debug options separated by colons, spaces, or
84 * commas, or %NULL.
85 * @keys: (array length=nkeys): pointer to an array of #GDebugKey which associate
86 * strings with bit flags.
87 * @nkeys: the number of #GDebugKeys in the array.
88 *
89 * Parses a string containing debugging options
90 * into a %guint containing bit flags. This is used
91 * within GDK and GTK+ to parse the debug options passed on the
92 * command line or through environment variables.
93 *
94 * If @string is equal to "all", all flags are set. Any flags
95 * specified along with "all" in @string are inverted; thus,
96 * "all,foo,bar" or "foo,bar,all" sets all flags except those
97 * corresponding to "foo" and "bar".
98 *
99 * If @string is equal to "help", all the available keys in @keys
100 * are printed out to standard error.
101 *
102 * Returns: the combined set of bit flags.
103 */
104 guint
105 g_parse_debug_string (const gchar *string,
106 const GDebugKey *keys,
107 guint nkeys)
108 {
109 guint i;
110 guint result = 0;
111  
112 if (string == NULL)
113 return 0;
114  
115 /* this function is used during the initialisation of gmessages, gmem
116 * and gslice, so it may not do anything that causes memory to be
117 * allocated or risks messages being emitted.
118 *
119 * this means, more or less, that this code may not call anything
120 * inside GLib.
121 */
122  
123 if (!strcasecmp (string, "help"))
124 {
125 /* using stdio directly for the reason stated above */
126 fprintf (stderr, "Supported debug values:");
127 for (i = 0; i < nkeys; i++)
128 fprintf (stderr, " %s", keys[i].key);
129 fprintf (stderr, " all help\n");
130 }
131 else
132 {
133 const gchar *p = string;
134 const gchar *q;
135 gboolean invert = FALSE;
136  
137 while (*p)
138 {
139 q = strpbrk (p, ":;, \t");
140 if (!q)
141 q = p + strlen (p);
142  
143 if (debug_key_matches ("all", p, q - p))
144 {
145 invert = TRUE;
146 }
147 else
148 {
149 for (i = 0; i < nkeys; i++)
150 if (debug_key_matches (keys[i].key, p, q - p))
151 result |= keys[i].value;
152 }
153  
154 p = q;
155 if (*p)
156 p++;
157 }
158  
159 if (invert)
160 {
161 guint all_flags = 0;
162  
163 for (i = 0; i < nkeys; i++)
164 all_flags |= keys[i].value;
165  
166 result = all_flags & (~result);
167 }
168 }
169  
170 return result;
171 }
172  
173 static guint
174 g_parse_debug_envvar (const gchar *envvar,
175 const GDebugKey *keys,
176 gint n_keys,
177 guint default_value)
178 {
179 const gchar *value;
180  
181 #ifdef OS_WIN32
182 /* "fatal-warnings,fatal-criticals,all,help" is pretty short */
183 gchar buffer[100];
184  
185 if (GetEnvironmentVariable (envvar, buffer, 100) < 100)
186 value = buffer;
187 else
188 return 0;
189 #else
190 value = getenv (envvar);
191 #endif
192  
193 if (value == NULL)
194 return default_value;
195  
196 return g_parse_debug_string (value, keys, n_keys);
197 }
198  
199 static void
200 g_messages_prefixed_init (void)
201 {
202 const GDebugKey keys[] = {
203 { "error", G_LOG_LEVEL_ERROR },
204 { "critical", G_LOG_LEVEL_CRITICAL },
205 { "warning", G_LOG_LEVEL_WARNING },
206 { "message", G_LOG_LEVEL_MESSAGE },
207 { "info", G_LOG_LEVEL_INFO },
208 { "debug", G_LOG_LEVEL_DEBUG }
209 };
210  
211 g_log_msg_prefix = g_parse_debug_envvar ("G_MESSAGES_PREFIXED", keys, G_N_ELEMENTS (keys), g_log_msg_prefix);
212 }
213  
214 static void
215 g_debug_init (void)
216 {
217 const GDebugKey keys[] = {
218 { "gc-friendly", 1 },
219 {"fatal-warnings", G_LOG_LEVEL_WARNING | G_LOG_LEVEL_CRITICAL },
220 {"fatal-criticals", G_LOG_LEVEL_CRITICAL }
221 };
222 GLogLevelFlags flags;
223  
224 flags = g_parse_debug_envvar ("G_DEBUG", keys, G_N_ELEMENTS (keys), 0);
225  
226 g_log_always_fatal |= flags & G_LOG_LEVEL_MASK;
227  
228 g_mem_gc_friendly = flags & 1;
229 }
230  
231 void
232 glib_init (void)
233 {
234 static gboolean glib_inited;
235  
236 if (glib_inited)
237 return;
238  
239 glib_inited = TRUE;
240  
241 g_messages_prefixed_init ();
242 g_debug_init ();
243 g_quark_init ();
244 }
245  
246 #if defined (G_OS_WIN32)
247  
248 BOOL WINAPI DllMain (HINSTANCE hinstDLL,
249 DWORD fdwReason,
250 LPVOID lpvReserved);
251  
252 HMODULE glib_dll;
253  
254 BOOL WINAPI
255 DllMain (HINSTANCE hinstDLL,
256 DWORD fdwReason,
257 LPVOID lpvReserved)
258 {
259 switch (fdwReason)
260 {
261 case DLL_PROCESS_ATTACH:
262 glib_dll = hinstDLL;
263 g_clock_win32_init ();
264 #ifdef THREADS_WIN32
265 g_thread_win32_init ();
266 #endif
267 glib_init ();
268 break;
269  
270 case DLL_THREAD_DETACH:
271 #ifdef THREADS_WIN32
272 g_thread_win32_thread_detach ();
273 #endif
274 break;
275  
276 case DLL_PROCESS_DETACH:
277 #ifdef THREADS_WIN32
278 if (lpvReserved == NULL)
279 g_thread_win32_process_detach ();
280 #endif
281 break;
282  
283 default:
284 /* do nothing */
285 ;
286 }
287  
288 return TRUE;
289 }
290  
291 #elif defined (G_HAS_CONSTRUCTORS)
292  
293 #ifdef G_DEFINE_CONSTRUCTOR_NEEDS_PRAGMA
294 #pragma G_DEFINE_CONSTRUCTOR_PRAGMA_ARGS(glib_init_ctor)
295 #endif
296 G_DEFINE_CONSTRUCTOR(glib_init_ctor)
297  
298 static void
299 glib_init_ctor (void)
300 {
301 glib_init ();
302 }
303  
304 #else
305 # error Your platform/compiler is missing constructor support
306 #endif