Navigation

← Previous Changeset
Next Changeset →

Changeset 208

Timestamp:

01/02/07 03:58:08 (2 years ago)

Author:

aldacron

Message:

[DerelictUtil?]
* consolidated linux/Unix code into one version statement to eliminate duplicate code

Files:

trunk/DerelictUtil/derelict/util/loader.d (modified) (4 diffs)

Legend:

: Unmodified
: Added
: Removed
: Modified
: Copied
: Moved

trunk/DerelictUtil/derelict/util/loader.d

r193	r208
38	38	}
39	39
	40	version(linux)
	41	{
	42	version = Nix;
	43	}
	44	else version(Unix)
	45	{
	46	version = Nix;
	47	}
40	48
41	49	version (DerelictUseStdLoader) {
42		import std.loader;
43
44		//==============================================================================
45		class SharedLib
46		{
47		public:
48		char[] name()
49		{
50		return _name;
51		}
52
53		private:
54		~~char[]~~ _name;
55
56		~~void* delegate(in char[] symbolName)~~ getSymbolDg;
57		~~Object~~ theLib;
58
59		private void unload() {
60		if (theLib) {
61		delete theLib;
62		theLib = null;
63		getSymbolDg = null;
64		}
65		}
66
67
68		void* getSymbol(char[] symName) {
69		if (theLib !is null) return getSymbolDg(symName);
70		else return null;
71		}
72
73
74		~~this(Object theLib, void* delegate(in char[])~~ getSymbolDg, char[] name)
75		in {
76		assert (theLib !is null);
77		assert (getSymbolDg !is null);
78		}
79		body {
80		this.theLib = theLib;
81		this.getSymbolDg = getSymbolDg;
82		this._name = name;
83		}
84		}
85		//==============================================================================
86		SharedLib Derelict_LoadSharedLib(char[] libName)
87		in
88		{
89		assert(libName !is null);
90		}
91		body
92		{
93		try {
94		auto ExeModule exeMod = new ExeModule(libName);
95		auto res = new SharedLib(exeMod, &exeMod.getSymbol, libName);
96		~~exeMod = null;~~ // fool the auto
97		return res;
98		}
99		catch (ExeModuleException exc) {
100		throw new SharedLibLoadException(libName);
101		}
102		}
103
104		//==============================================================================
105		SharedLib Derelict_LoadSharedLib(char[][] libNames)
106		in
107		{
108		assert(libNames !is null);
109		}
110		body
111		{
112		SharedLibLoadException exception = null;
113		SharedLib lib = null;
114
115		foreach(char[] libName; libNames)
116		{
117		try
118		{
119		lib = Derelict_LoadSharedLib(libName);
120		}
121		catch(SharedLibLoadException slle)
122		{
123		exception = slle;
124		}
125		}
126		if(lib is null)
127		throw exception;
128
129		return lib;
130		}
131
132		//==============================================================================
133		void Derelict_UnloadSharedLib(SharedLib lib)
134		{
135		if(lib !is null) lib.unload();
136		}
137		//==============================================================================
138		void* Derelict_GetProc(SharedLib lib, char[] procName)
139		in
140		{
141		assert(lib !is null);
142		assert(procName !is null);
143		}
144		body
145		{
146		void* proc = lib.getSymbol(procName);
147		if (proc is null) {
148		Derelict_HandleMissingProc(lib._name, procName);
149		}
150		return proc;
151		}
152		//==============================================================================
153		}
	50	import std.loader;
	51
	52	//==============================================================================
	53	class SharedLib
	54	{
	55	public:
	56	char[] name()
	57	{
	58	return _name;
	59	}
	60
	61	private:
	62	char[] _name;
	63
	64	void* delegate(in char[] symbolName) getSymbolDg;
	65	Object theLib;
	66
	67	private void unload() {
	68	if (theLib) {
	69	delete theLib;
	70	theLib = null;
	71	getSymbolDg = null;
	72	}
	73	}
	74
	75
	76	void* getSymbol(char[] symName) {
	77	if (theLib !is null) return getSymbolDg(symName);
	78	else return null;
	79	}
	80
	81
	82	this(Object theLib, void* delegate(in char[]) getSymbolDg, char[] name)
	83	in {
	84	assert (theLib !is null);
	85	assert (getSymbolDg !is null);
	86	}
	87	body {
	88	this.theLib = theLib;
	89	this.getSymbolDg = getSymbolDg;
	90	this._name = name;
	91	}
	92	}
	93	//==============================================================================
	94	SharedLib Derelict_LoadSharedLib(char[] libName)
	95	in
	96	{
	97	assert(libName !is null);
	98	}
	99	body
	100	{
	101	try {
	102	auto ExeModule exeMod = new ExeModule(libName);
	103	auto res = new SharedLib(exeMod, &exeMod.getSymbol, libName);
	104	exeMod = null; // fool the auto
	105	return res;
	106	}
	107	catch (ExeModuleException exc) {
	108	throw new SharedLibLoadException(libName);
	109	}
	110	}
	111
	112	//==============================================================================
	113	SharedLib Derelict_LoadSharedLib(char[][] libNames)
	114	in
	115	{
	116	assert(libNames !is null);
	117	}
	118	body
	119	{
	120	SharedLibLoadException exception = null;
	121	SharedLib lib = null;
	122
	123	foreach(char[] libName; libNames)
	124	{
	125	try
	126	{
	127	lib = Derelict_LoadSharedLib(libName);
	128	}
	129	catch(SharedLibLoadException slle)
	130	{
	131	exception = slle;
	132	}
	133	}
	134	if(lib is null)
	135	throw exception;
	136
	137	return lib;
	138	}
	139
	140	//==============================================================================
	141	void Derelict_UnloadSharedLib(SharedLib lib)
	142	{
	143	if(lib !is null) lib.unload();
	144	}
	145	//==============================================================================
	146	void* Derelict_GetProc(SharedLib lib, char[] procName)
	147	in
	148	{
	149	assert(lib !is null);
	150	assert(procName !is null);
	151	}
	152	body
	153	{
	154	void* proc = lib.getSymbol(procName);
	155	if (proc is null) {
	156	Derelict_HandleMissingProc(lib._name, procName);
	157	}
	158	return proc;
	159	}
	160	//==============================================================================
	161	}
154	162	//==============================================================================
155	163	else {
156		private alias void* SharedLibHandle;
157
158		//==============================================================================
159		class SharedLib
160		{
161		public:
162		char[] name()
163		{
164		return _name;
165		}
166
167		private:
168		SharedLibHandle _handle;
169		char[] _name;
170
171		this(SharedLibHandle handle, char[] name)
172		{
173		_handle = handle;
174		_name = name;
175		}
176		}
177		//==============================================================================
178		SharedLib Derelict_LoadSharedLib(char[] libName)
179		in
180		{
181		assert(libName !is null);
182		}
183		body
184		{
185		return Platform_LoadSharedLib(libName);
186		}
187
188		//==============================================================================
189		SharedLib Derelict_LoadSharedLib(char[][] libNames)
190		in
191		{
192		assert(libNames !is null);
193		}
194		body
195		{
196		SharedLibLoadException exception = null;
197		SharedLib lib = null;
198
199		foreach(char[] libName; libNames)
200		{
201		try
202		{
203		lib = Derelict_LoadSharedLib(libName);
204		}
205		catch(SharedLibLoadException slle)
206		{
207		exception = slle;
208		}
209		}
210		if(lib is null)
211		throw exception;
212
213		return lib;
214		}
215
216		//==============================================================================
217		void Derelict_UnloadSharedLib(SharedLib lib)
218		{
219		if(lib !is null && lib._handle !is null)
220		Platform_UnloadSharedLib(lib);
221		}
222		//==============================================================================
223		void* Derelict_GetProc(SharedLib lib, char[] procName)
224		in
225		{
226		assert(lib !is null);
227		assert(procName !is null);
228		}
229		body
230		{
231		if(lib._handle is null)
232		throw new InvalidSharedLibHandleException(lib._name);
233		return Platform_GetProc(lib, procName);
234		}
235		//==============================================================================
236		version(Windows)
237		{
238		private import std.c.windows.windows;
239
240		SharedLib Platform_LoadSharedLib(char[] libName)
241		{
242		HMODULE hlib = LoadLibraryA(toStringz(libName));
243		if(null is hlib)
244		throw new SharedLibLoadException(libName);
245
246		return new SharedLib(hlib, libName);
247		}
248
249		void Platform_UnloadSharedLib(SharedLib lib)
250		{
251		FreeLibrary(cast(HMODULE)lib._handle);
252		lib._handle = null;
253		}
254
255		void* Platform_GetProc(SharedLib lib, char[] procName)
256		{
257		void* proc = GetProcAddress(cast(HMODULE)lib._handle, toStringz(procName));
258		if(null is proc)
259		Derelict_HandleMissingProc(lib._name, procName);
260
261		return proc;
262		}
263
264		}
265		else version(linux)
266		{
267		private import std.c.linux.linux;
268
269		SharedLib Platform_LoadSharedLib(char[] libName)
270		{
271		void* hlib = dlopen(toStringz(libName), RTLD_NOW);
272		if(null is hlib)
273		throw new SharedLibLoadException("Failed to load shared library " ~ libName);
274
275		return new SharedLib(hlib, libName);
276		}
277
278		void Platform_UnloadSharedLib(SharedLib lib)
279		{
280		dlclose(lib._handle);
281		lib._handle = null;
282		}
283
284		void* Platform_GetProc(SharedLib lib, char[] procName)
285		{
286		void* proc = dlsym(lib._handle, toStringz(procName));
287		if(null is proc)
288		Derelict_HandleMissingProc(lib._name, procName);
289
290		return proc;
291		}
292		}
293		else version(Unix)
294		{
295		extern(C)
296		{
297		/* From <dlfcn.h>
298		* See http://www.opengroup.org/onlinepubs/007908799/xsh/dlsym.html
299		*/
300
301		const int RTLD_NOW = 2;
302
303		void dlopen(char file, int mode);
304		int dlclose(void* handle);
305		void dlsym(void handle, char* name);
306		char* dlerror();
307		}
308
309		SharedLib Platform_LoadSharedLib(char[] libName)
310		{
311		void *hlib = dlopen(toStringz(libName), RTLD_NOW);
312		if(null is hlib)
313		throw new SharedLibLoadException("Failed to load shared library " ~ libName);
314
315		return new SharedLib(hlib, libName);
316		}
317
318		void Platform_UnloadSharedLib(SharedLib lib)
319		{
320		dlclose(lib._handle);
321		lib._handle = null;
322		}
323
324		void* Platform_GetProc(SharedLib lib, char[] procName)
325		{
326		void *proc = dlsym(lib._handle, toStringz(procName));
327		if(null is proc)
328		Derelict_HandleMissingProc(lib._name, procName);
329
330		return proc;
331		}
332		}
333		else
334		{
335		static assert(0);
336		}
	164	private alias void* SharedLibHandle;
	165
	166	//==============================================================================
	167	class SharedLib
	168	{
	169	public:
	170	char[] name()
	171	{
	172	return _name;
	173	}
	174
	175	private:
	176	SharedLibHandle _handle;
	177	char[] _name;
	178
	179	this(SharedLibHandle handle, char[] name)
	180	{
	181	_handle = handle;
	182	_name = name;
	183	}
	184	}
	185	//==============================================================================
	186	SharedLib Derelict_LoadSharedLib(char[] libName)
	187	in
	188	{
	189	assert(libName !is null);
	190	}
	191	body
	192	{
	193	return Platform_LoadSharedLib(libName);
	194	}
	195
	196	//==============================================================================
	197	SharedLib Derelict_LoadSharedLib(char[][] libNames)
	198	in
	199	{
	200	assert(libNames !is null);
	201	}
	202	body
	203	{
	204	SharedLibLoadException exception = null;
	205	SharedLib lib = null;
	206
	207	foreach(char[] libName; libNames)
	208	{
	209	try
	210	{
	211	lib = Derelict_LoadSharedLib(libName);
	212	}
	213	catch(SharedLibLoadException slle)
	214	{
	215	exception = slle;
	216	}
	217	}
	218	if(lib is null)
	219	throw exception;
	220
	221	return lib;
	222	}
	223
	224	//==============================================================================
	225	void Derelict_UnloadSharedLib(SharedLib lib)
	226	{
	227	if(lib !is null && lib._handle !is null)
	228	Platform_UnloadSharedLib(lib);
	229	}
	230	//==============================================================================
	231	void* Derelict_GetProc(SharedLib lib, char[] procName)
	232	in
	233	{
	234	assert(lib !is null);
	235	assert(procName !is null);
	236	}
	237	body
	238	{
	239	if(lib._handle is null)
	240	throw new InvalidSharedLibHandleException(lib._name);
	241	return Platform_GetProc(lib, procName);
	242	}
	243	//==============================================================================
	244	version(Windows)
	245	{
	246	private import std.c.windows.windows;
	247
	248	SharedLib Platform_LoadSharedLib(char[] libName)
	249	{
	250	HMODULE hlib = LoadLibraryA(toStringz(libName));
	251	if(null is hlib)
	252	throw new SharedLibLoadException(libName);
	253
	254	return new SharedLib(hlib, libName);
	255	}
	256
	257	void Platform_UnloadSharedLib(SharedLib lib)
	258	{
	259	FreeLibrary(cast(HMODULE)lib._handle);
	260	lib._handle = null;
	261	}
	262
	263	void* Platform_GetProc(SharedLib lib, char[] procName)
	264	{
	265	void* proc = GetProcAddress(cast(HMODULE)lib._handle, toStringz(procName));
	266	if(null is proc)
	267	Derelict_HandleMissingProc(lib._name, procName);
	268
	269	return proc;
	270	}
	271
	272	}
	273	else version(Nix)
	274	{
	275	version(linux)
	276	{
	277	private import std.c.linux.linux;
	278	}
	279	else
	280	{
	281	extern(C)
	282	{
	283	/* From <dlfcn.h>
	284	* See http://www.opengroup.org/onlinepubs/007908799/xsh/dlsym.html
	285	*/
	286
	287	const int RTLD_NOW = 2;
	288
	289	void dlopen(char file, int mode);
	290	int dlclose(void* handle);
	291	void dlsym(void handle, char* name);
	292	char* dlerror();
	293	}
	294	}
	295
	296	SharedLib Platform_LoadSharedLib(char[] libName)
	297	{
	298	void* hlib = dlopen(toStringz(libName), RTLD_NOW);
	299	if(null is hlib)
	300	throw new SharedLibLoadException("Failed to load shared library " ~ libName);
	301
	302	return new SharedLib(hlib, libName);
	303	}
	304
	305	void Platform_UnloadSharedLib(SharedLib lib)
	306	{
	307	dlclose(lib._handle);
	308	lib._handle = null;
	309	}
	310
	311	void* Platform_GetProc(SharedLib lib, char[] procName)
	312	{
	313	void* proc = dlsym(lib._handle, toStringz(procName));
	314	if(null is proc)
	315	Derelict_HandleMissingProc(lib._name, procName);
	316
	317	return proc;
	318	}
	319	}
	320	else
	321	{
	322	static assert(0);
	323	}
337	324	}
338	325
…	…
340	327
341	328	struct GenericLoader {
342		void setup(char[] winLibs, char[] linLibs, char[] macLibs, void function(SharedLib) userLoad, char[] versionStr = "") {
343		assert (userLoad !is null);
344		this.winLibs = winLibs;
345		this.linLibs = linLibs;
346		this.macLibs = macLibs;
347		this.userLoad = userLoad;
348		this.versionStr = versionStr;
349		}
350
351		void load(char[] libNameString = null)
352		{
353		if (myLib !is null) {
354		return;
355		}
356
357		// make sure the lib will be unloaded at progam termination
358		registeredLoaders ~= this;
359
360
361		if (libNameString is null) {
362		version (Windows) {
363		libNameString = winLibs;
364		}
365		else version (linux) {
366		libNameString = linLibs;
367		}
368		}
369
370		char[][] libNames = libNameString.split(",");
371		foreach (inout char[] l; libNames) {
372		l = l.strip();
373		}
374
375		myLib = Derelict_LoadSharedLib(libNames);
376		userLoad(myLib);
377		}
378
379		char[] versionString()
380		{
381		return versionStr;
382		}
383
384		void unload()
385		{
386		if (myLib !is null) {
387		Derelict_UnloadSharedLib(myLib);
388		myLib = null;
389		}
390		}
391
392		static ~this()
393		{
394		foreach (x; registeredLoaders) {
395		x.unload();
396		}
397		}
398
399		private {
400		~~static GenericLoader*[]~~ registeredLoaders;
401
402		SharedLib myLib;
403		char[] winLibs;
404		char[] linLibs;
405		char[] macLibs;
406		char[] versionStr = "";
407
408		void function(SharedLib) userLoad;
409		}
	329	void setup(char[] winLibs, char[] linLibs, char[] macLibs, void function(SharedLib) userLoad, char[] versionStr = "") {
	330	assert (userLoad !is null);
	331	this.winLibs = winLibs;
	332	this.linLibs = linLibs;
	333	this.macLibs = macLibs;
	334	this.userLoad = userLoad;
	335	this.versionStr = versionStr;
	336	}
	337
	338	void load(char[] libNameString = null)
	339	{
	340	if (myLib !is null) {
	341	return;
	342	}
	343
	344	// make sure the lib will be unloaded at progam termination
	345	registeredLoaders ~= this;
	346
	347
	348	if (libNameString is null) {
	349	version (Windows) {
	350	libNameString = winLibs;
	351	}
	352	else version (linux) {
	353	libNameString = linLibs;
	354	}
	355	}
	356
	357	char[][] libNames = libNameString.split(",");
	358	foreach (inout char[] l; libNames) {
	359	l = l.strip();
	360	}
	361
	362	myLib = Derelict_LoadSharedLib(libNames);
	363	userLoad(myLib);
	364	}
	365
	366	char[] versionString()
	367	{
	368	return versionStr;
	369	}
	370
	371	void unload()
	372	{
	373	if (myLib !is null) {
	374	Derelict_UnloadSharedLib(myLib);
	375	myLib = null;
	376	}
	377	}
	378
	379	static ~this()
	380	{
	381	foreach (x; registeredLoaders) {
	382	x.unload();
	383	}
	384	}
	385
	386	private {
	387	static GenericLoader*[] registeredLoaders;
	388
	389	SharedLib myLib;
	390	char[] winLibs;
	391	char[] linLibs;
	392	char[] macLibs;
	393	char[] versionStr = "";
	394
	395	void function(SharedLib) userLoad;
	396	}
410	397	}
411	398
…	…
413	400
414	401	struct GenericDependentLoader {
415		void setup(GenericLoader* dependence, void function(SharedLib) userLoad) {
416		assert (dependence !is null);
417		assert (userLoad !is null);
418
419		this.dependence = dependence;
420		this.userLoad = userLoad;
421		}
422
423		private SharedLib myLib() {
424		return dependence.myLib;
425		}
426
427		void load()
428		{
429		assert (myLib !is null);
430		userLoad(myLib);
431		}
432
433		char[] versionString()
434		{
435		return dependence.versionString;
436		}
437
438		void unload()
439		{
440		}
441
442		private {
443		GenericLoader* dependence;
444		~~void function(SharedLib)~~ userLoad;
445		}
	402	void setup(GenericLoader* dependence, void function(SharedLib) userLoad) {
	403	assert (dependence !is null);
	404	assert (userLoad !is null);
	405
	406	this.dependence = dependence;
	407	this.userLoad = userLoad;
	408	}
	409
	410	private SharedLib myLib() {
	411	return dependence.myLib;
	412	}
	413
	414	void load()
	415	{
	416	assert (myLib !is null);
	417	userLoad(myLib);
	418	}
	419
	420	char[] versionString()
	421	{
	422	return dependence.versionString;
	423	}
	424
	425	void unload()
	426	{
	427	}
	428
	429	private {
	430	GenericLoader* dependence;
	431	void function(SharedLib) userLoad;
	432	}
446	433	}
447	434
…	…
449	436
450	437	struct GenericStaticLoader {
451		void setup(void function() userLoad = null, char[] versionStr = "") {
452		this.userLoad = userLoad;
453		this.versionStr = versionStr;
454		}
455
456		void load()
457		{
458		if (userLoad !is null) {
459		userLoad();
460		}
461		}
462
463		char[] versionString()
464		{
465		return versionString;
466		}
467
468		void unload()
469		{
470		}
471
472		private {
473		~~char[]~~ versionStr;
474		~~void function()~~ userLoad;
475		}
	438	void setup(void function() userLoad = null, char[] versionStr = "") {
	439	this.userLoad = userLoad;
	440	this.versionStr = versionStr;
	441	}
	442
	443	void load()
	444	{
	445	if (userLoad !is null) {
	446	userLoad();
	447	}
	448	}
	449
	450	char[] versionString()
	451	{
	452	return versionString;
	453	}
	454
	455	void unload()
	456	{
	457	}
	458
	459	private {
	460	char[] versionStr;
	461	void function() userLoad;
	462	}
476	463	}
477	464

derelict

Navigation

Changeset 208

Legend:

trunk/DerelictUtil/derelict/util/loader.d

Download in other formats: