Changeset 4384

trunk/lib/build-dmd.sh

r4325	r4384
16	16	dmdsettings
17	17
18		make clean -fdmd-posix.mak \|\| goerror
19		make ~~lib doc~~ install -fdmd-posix.mak SYSTEM_VERSION="$POSIXFLAG" \|\| goerror
	18	make clean-all -fdmd-posix.mak \|\| goerror
	19	make all install -fdmd-posix.mak SYSTEM_VERSION="$POSIXFLAG" \|\| goerror
20	20	make clean -fdmd-posix.mak \|\| goerror
21	21	chmod 644 ../tango/core/*.di \|\| goerror

trunk/lib/build-gdc.sh

r4325	r4384
1		#!/usr/bin/env bash
	1	#!/usr/bin/env bash -v
2	2	cd "`dirname $0`"
3	3

trunk/lib/common/tango/core/Runtime.d

r3456	r4384
7	7	*/
8	8	module tango.core.Runtime;
9
	9	debug private extern(C) int printf(char*,...);
10	10
11	11	private
…	…
147	147	////////////////////////////////////////////////////////////////////////////////
148	148
149
150	149	/**
151	150	* This routine is called by the runtime to run module unit tests on startup.
…	…
161	160	if( Runtime.sm_moduleUnitTester is null )
162	161	{
	162	debug printf("unittest start\n");
163	163	foreach( m; ModuleInfo )
164	164	{
165		if( m.unitTest )
	165	if( m.unitTest ) {
	166	char[] name=m.name~"\n\0";
	167	debug printf(name.ptr);
166	168	m.unitTest();
	169	}
167	170	}
	171	debug printf("unittest end\n");
168	172	return true;
169	173	}

trunk/lib/common/tango/posix.mak

r4325	r4384
11	11	# Delete unneeded files created by build process
12	12
13		LIB_TARGET=libtango-cc-tango.a
14		LIB_MASK=libtango-cc-tango*.a
	13	LIB_BASE=libtango-cc-tango
	14	LIB_BUILD=
	15	LIB_TARGET=$(LIB_BASE)$(LIB_BUILD).a
	16	LIB_MASK=$(LIB_BASE)*.a
15	17
16	18	CP=cp -f
…	…
22	24	SYSTEM_VERSION=
23	25
24		CFLAGS=-O $(ADD_CFLAGS)
25		~~#CFLAGS~~=-g $(ADD_CFLAGS)
	26	CFLAGS_RELEASE=-O $(ADD_CFLAGS)
	27	CFLAGS_DEBUG=-g $(ADD_CFLAGS)
26	28
27		DFLAGS=-release -O -inline -w -nofloat $(SYSTEM_VERSION) $(ADD_DFLAGS)
28		#DFLAGS=-g -w -nofloat -version=Posix $(ADD_DFLAGS)
	29	DFLAGS_RELEASE=-release -O -inline -w -nofloat $(SYSTEM_VERSION) $(ADD_DFLAGS) -I../../..
	30	DFLAGS_DEBUG=-g -w -nofloat $(SYSTEM_VERSION) $(ADD_DFLAGS) -I../../..
	31	TFLAGS_RELEASE=-O -inline -w -nofloat $(SYSTEM_VERSION) $(ADD_DFLAGS)
	32	TFLAGS_DEBUG=-g -w -nofloat $(SYSTEM_VERSION) $(ADD_DFLAGS)
29	33
30		TFLAGS=-O -inline -w -nofloat $(SYSTEM_VERSION) $(ADD_DFLAGS)
31		#TFLAGS=-g -w -nofloat -version=Posix $(ADD_DFLAGS)
	34	ifeq ($(VERSION),debug)
	35	CFLAGS=$(CFLAGS_DEBUG)
	36	DFLAGS=$(DFLAGS_DEBUG)
	37	TFLAGS=$(TFLAGS_DEBUG)
	38	else
	39	CFLAGS=$(CFLAGS_RELEASE)
	40	DFLAGS=$(DFLAGS_RELEASE)
	41	TFLAGS=$(TFLAGS_RELEASE)
	42	endif
32	43
33	44	DOCFLAGS=-version=DDoc $(SYSTEM_VERSION)
…	…
42	53
43	54	.SUFFIXES: .s .S .c .cpp .d .html .o
	55	.PHONY : lib lib-release lib-debug unittest all doc clean install clean-all
44	56
45	57	.s.o:
…	…
63	75	# $(DC) -c -o- $(DOCFLAGS) -Df$*.html tango.ddoc $<
64	76
65		targets : lib doc
66		all : lib doc
67		tango : lib
68		lib : tango.lib
69		doc : tango.doc
	77	all : lib-release lib-debug doc
	78	tango : lib-release lib-debug
	79
	80	######################################################
	81	unittest :
	82	make -fposix.mak clean DC="$(DC)" LIB_BUILD="" VERSION="$(VERSION)"
	83	make -fposix.mak lib DC="$(DC)" LIB_BUILD="" VERSION="$(VERSION)" \
	84	ADD_CFLAGS="$(ADD_CFLAGS)" ADD_DFLAGS="$(ADD_DFLAGS) -unittest -debug=UnitTest" \
	85	SYSTEM_VERSION="$(SYSTEM_VERSION)"
	86	lib-release :
	87	make -fposix.mak clean DC="$(DC)" LIB_BUILD="" VERSION="$(VERSION)"
	88	make -fposix.mak DC="$(DC)" LIB_BUILD="" VERSION=release lib \
	89	ADD_CFLAGS="$(ADD_CFLAGS)" ADD_DFLAGS="$(ADD_DFLAGS)" SYSTEM_VERSION="$(SYSTEM_VERSION)"
	90	lib-debug :
	91	make -fposix.mak clean DC="$(DC)" LIB_BUILD="" VERSION="$(VERSION)"
	92	make -fposix.mak DC="$(DC)" LIB_BUILD="-d" VERSION=debug lib \
	93	ADD_CFLAGS="$(ADD_CFLAGS)" ADD_DFLAGS="$(ADD_DFLAGS)" SYSTEM_VERSION="$(SYSTEM_VERSION)"
70	94
71	95	######################################################
…	…
103	127
104	128	######################################################
105
106		tango.lib : $(LIB_TARGET)
107
	129	lib : $(LIB_TARGET)
108	130	$(LIB_TARGET) : $(ALL_OBJS)
109	131	$(RM) $@
110	132	$(LC) $@ $(ALL_OBJS)
111	133
112		tango.doc : $(ALL_DOCS)
	134	tango.doc:doc
	135	doc : $(ALL_DOCS)
113	136	echo Documentation generated.
114	137
…	…
125	148	find . -name "*.di" \| xargs $(RM)
126	149	$(RM) $(ALL_OBJS)
	150
	151	clean-all: clean
127	152	$(RM) $(ALL_DOCS)
128	153	find . -name "$(LIB_MASK)" \| xargs $(RM)

trunk/lib/compiler/dmd/OBJECTDEFS.inc

r4357	r4384
22	22	rt/dmain2.obj \
23	23	invariant.obj \
	24	rt/invariant_.obj \
24	25	rt/lifetime.obj \
25	26	rt/memory.obj \
…	…
34	35	OBJ_POSIX=rt/alloca.obj \
35	36	rt/cmath2.obj \
	37	rt/gcosx.obj \
36	38	rt/deh2.obj \
37	39	rt/llmath.obj

trunk/lib/compiler/dmd/invariant.d

r454	r4384
1
2	1	/*
3	2	* Placed into the Public Domain
…	…
6	5	*/
7	6
	7	private {
	8	extern(C) int printf(char*,...);
	9	}
8	10	void _d_invariant(Object o)
9	11	{ ClassInfo c;
…	…
12	14
13	15	// BUG: needs to be filename/line of caller, not library routine
14		assert(o !is null); // just do null check, not invariant check
15
	16	assert(o !is null); // just do null check, not invariant check
16	17	c = o.classinfo;
17	18	do
18	19	{
19		if (c.classInvariant)
20		{
21		(*c.classInvariant)(o);
22		}
23		c = c.base;
	20	if (c.classInvariant)
	21	{
	22	(*c.classInvariant)(o);
	23	}
	24	c = c.base;
24	25	} while (c);
25	26	}

trunk/lib/compiler/dmd/object_.d

r4357	r4384
42	42	import tango.stdc.string; // : memcmp, memcpy, memmove;
43	43	import tango.stdc.stdlib; // : calloc, realloc, free;
44		import util.string;
	44	import rt.util.string;
45	45	debug(PRINTF) import tango.stdc.stdio; // : printf;
46	46
…	…
67	67
68	68	alias size_t hash_t;
	69	alias int equals_t;
69	70
70	71	/**
…	…
111	112	* Returns !=0 if this object does have the same contents as obj.
112	113	*/
113		int opEquals(Object o)
114		{
115		return cast(int)(this is o);
	114	equals_t opEquals(Object o)
	115	{
	116	return cast(equals_t)(this is o);
116	117	}
117	118
…	…
152	153	void function(Object) classInvariant;
153	154	uint flags;
154		// 1: // IUnknown
	155	// 1: // is IUnknown or is derived from IUnknown
155	156	// 2: // has no possible pointers into GC memory
156	157	// 4: // has offTi[] member
…	…
230	231	}
231	232
232		int opEquals(Object o)
	233	override equals_t opEquals(Object o)
233	234	{
234	235	/* TypeInfo instances are singletons, but duplicates can exist
…	…
239	240	return 1;
240	241	TypeInfo ti = cast(TypeInfo)o;
241		return cast(int)(ti && this.toString() == ti.toString());
	242	return cast(equals_t)(ti && this.toString() == ti.toString());
242	243	}
243	244
244	245	/// Returns a hash of the instance of a type.
245		hash_t getHash(void *p) { return cast(hash_t)p; }
	246	hash_t getHash(in void* p) { return cast(hash_t)p; }
246	247
247	248	/// Compares two instances for equality.
248		~~int equals(void p1, void p2) { return cast(int)(p1 == p2)~~; }
	249	equals_t equals(in void* p1, in void* p2) { return p1 == p2; }
249	250
250	251	/// Compares two instances for <, ==, or >.
251		int compare(void p1, void p2) { return 0; }
	252	int compare(in void* p1, in void* p2) { return 0; }
252	253
253	254	/// Returns size of the type.
…	…
255	256
256	257	/// Swaps two instances of the type.
257		void swap(void ~~p1, void ~~p2)
	258	void swap(void* p1, void* p2)
258	259	{
259	260	size_t n = tsize();
260	261	for (size_t i = 0; i < n; i++)
261		{ byte t;
262
263		t = (cast(byte *)p1)[i];
264		(cast(byte )p1)[i] = (cast(byte )p2)[i];
265		(cast(byte *)p2)[i] = t;
	262	{
	263	byte t = (cast(byte *)p1)[i];
	264	(cast(byte)p1)[i] = (cast(byte)p2)[i];
	265	(cast(byte*)p2)[i] = t;
266	266	}
267	267	}
…	…
283	283	class TypeInfo_Typedef : TypeInfo
284	284	{
285		char[] toString() { return name; }
286
287		int opEquals(Object o)
288		{ TypeInfo_Typedef c;
289
290		return cast(int)
291		(this is o \|\|
292		((c = cast(TypeInfo_Typedef)o) !is null &&
293		this.name == c.name &&
294		this.base == c.base));
295		}
296
297		hash_t getHash(void *p) { return base.getHash(p); }
298		int equals(void p1, void p2) { return base.equals(p1, p2); }
299		int compare(void p1, void p2) { return base.compare(p1, p2); }
300		size_t tsize() { return base.tsize(); }
301		void swap(void p1, void p2) { return base.swap(p1, p2); }
302
303		TypeInfo next() { return base.next(); }
304		uint flags() { return base.flags(); }
305		void[] init() { return m_init.length ? m_init : base.init(); }
	285	override char[] toString() { return name; }
	286
	287	override equals_t opEquals(Object o)
	288	{
	289	TypeInfo_Typedef c;
	290	return this is o \|\|
	291	((c = cast(TypeInfo_Typedef)o) !is null &&
	292	this.name == c.name &&
	293	this.base == c.base);
	294	}
	295
	296	override hash_t getHash(in void* p) { return base.getHash(p); }
	297	override equals_t equals(in void* p1, in void* p2) { return base.equals(p1, p2); }
	298	override int compare(in void* p1, in void* p2) { return base.compare(p1, p2); }
	299	override size_t tsize() { return base.tsize(); }
	300	override void swap(void* p1, void* p2) { return base.swap(p1, p2); }
	301
	302	override TypeInfo next() { return base.next(); }
	303	override uint flags() { return base.flags(); }
	304	override void[] init() { return m_init.length ? m_init : base.init(); }
306	305
307	306	TypeInfo base;
…	…
312	311	class TypeInfo_Enum : TypeInfo_Typedef
313	312	{
	313
314	314	}
315	315
316	316	class TypeInfo_Pointer : TypeInfo
317	317	{
318		char[] toString() { return m_next.toString() ~ "*"; }
319
320		int opEquals(Object o)
321		{ ~~TypeInfo_Pointer c;~~
322
	318	override char[] toString() { return m_next.toString() ~ "*"; }
	319
	320	override equals_t opEquals(Object o)
	321	{
	322	TypeInfo_Pointer c;
323	323	return this is o \|\|
324	324	((c = cast(TypeInfo_Pointer)o) !is null &&
…	…
326	326	}
327	327
328		hash_t getHash(void *p)
	328	override hash_t getHash(in void* p)
329	329	{
330	330	return cast(hash_t)cast(void*)p;
331	331	}
332	332
333		int equals(void p1, void p2)
334		{
335		return cast(int)(cast(void )p1 == cast(void* *)p2);
336		}
337
338		int compare(void p1, void p2)
339		{
340		if (cast(void ~~)p1 < cast(void~~ )p2)
	333	override equals_t equals(in void* p1, in void* p2)
	334	{
	335	return cast(equals_t)(cast(void)p1 == cast(void**)p2);
	336	}
	337
	338	override int compare(in void* p1, in void* p2)
	339	{
	340	if (cast(void)p1 < cast(void**)p2)
341	341	return -1;
342		else if (cast(void ~~)p1 > cast(void~~ )p2)
	342	else if (cast(void)p1 > cast(void**)p2)
343	343	return 1;
344	344	else
…	…
346	346	}
347	347
348		size_t tsize()
	348	override size_t tsize()
349	349	{
350	350	return (void*).sizeof;
351	351	}
352	352
353		void swap(void p1, void p2)
354		{ ~~void* tmp;~~
355		tmp = cast(void*)p1;
	353	override void swap(void* p1, void* p2)
	354	{
	355	void* tmp = cast(void*)p1;
356	356	cast(void)p1 = cast(void**)p2;
357	357	cast(void*)p2 = tmp;
358	358	}
359	359
360		TypeInfo next() { return m_next; }
361		uint flags() { return 1; }
	360	override TypeInfo next() { return m_next; }
	361	override uint flags() { return 1; }
362	362
363	363	TypeInfo m_next;
…	…
366	366	class TypeInfo_Array : TypeInfo
367	367	{
368		char[] toString() { return value.toString() ~ "[]"; }
369
370		int opEquals(Object o)
371		{ ~~TypeInfo_Array c;~~
372
373		return ~~cast(int)~~
374		(~~this is o \|\|~~
375		~~((c = cast(TypeInfo_Array)o) !is null &&~~
376		~~this.value == c.value));~~
377		}
378
379		~~hash_t getHash(void *p)~~
380		{ size_t sz = value.tsize();
	368	override char[] toString() { return value.toString() ~ "[]"; }
	369
	370	override equals_t opEquals(Object o)
	371	{
	372	TypeInfo_Array c;
	373	return this is o \|\|
	374	((c = cast(TypeInfo_Array)o) !is null &&
	375	this.value == c.value);
	376	}
	377
	378	override hash_t getHash(in void* p)
	379	{
	380	size_t sz = value.tsize();
381	381	hash_t hash = 0;
382	382	void[] a = cast(void[])p;
…	…
386	386	}
387	387
388		int equals(void p1, void p2)
	388	override equals_t equals(in void* p1, in void* p2)
389	389	{
390	390	void[] a1 = cast(void[])p1;
391	391	void[] a2 = cast(void[])p2;
392	392	if (a1.length != a2.length)
393		return 0;
	393	return false;
394	394	size_t sz = value.tsize();
395	395	for (size_t i = 0; i < a1.length; i++)
396	396	{
397	397	if (!value.equals(a1.ptr + i * sz, a2.ptr + i * sz))
398		return 0;
399		}
400		return 1;
401		}
402
403		int compare(void p1, void p2)
	398	return false;
	399	}
	400	return true;
	401	}
	402
	403	override int compare(in void* p1, in void* p2)
404	404	{
405	405	void[] a1 = cast(void[])p1;
…	…
419	419	}
420	420
421		size_t tsize()
	421	override size_t tsize()
422	422	{
423	423	return (void[]).sizeof;
424	424	}
425	425
426		void swap(void p1, void p2)
427		{ ~~void[] tmp;~~
428		tmp = cast(void[])p1;
	426	override void swap(void* p1, void* p2)
	427	{
	428	void[] tmp = cast(void[])p1;
429	429	cast(void[])p1 = cast(void[])p2;
430	430	cast(void[])p2 = tmp;
…	…
433	433	TypeInfo value;
434	434
435		TypeInfo next()
	435	override TypeInfo next()
436	436	{
437	437	return value;
438		}
439
440		uint flags() { return 1; }
	438	}
	439
	440	override uint flags() { return 1; }
441	441	}
442	442
443	443	class TypeInfo_StaticArray : TypeInfo
444	444	{
445		char[] toString()
	445	override char[] toString()
446	446	{
447	447	char [10] tmp = void;
…	…
449	449	}
450	450
451		int opEquals(Object o)
452		{ ~~TypeInfo_StaticArray c;~~
453
454		return ~~cast(int)~~
455		(~~this is o \|\|~~
456		~~((c = cast(TypeInfo_StaticArray)o) !is null~~ &&
457		~~this.len == c.len &&~~
458		~~this.value == c.value));~~
459		}
460
461		~~hash_t getHash(void *p)~~
462		{ size_t sz = value.tsize();
	451	override equals_t opEquals(Object o)
	452	{
	453	TypeInfo_StaticArray c;
	454	return this is o \|\|
	455	((c = cast(TypeInfo_StaticArray)o) !is null &&
	456	this.len == c.len &&
	457	this.value == c.value);
	458	}
	459
	460	override hash_t getHash(in void* p)
	461	{
	462	size_t sz = value.tsize();
463	463	hash_t hash = 0;
464	464	for (size_t i = 0; i < len; i++)
…	…
467	467	}
468	468
469		int equals(void p1, void p2)
	469	override equals_t equals(in void* p1, in void* p2)
470	470	{
471	471	size_t sz = value.tsize();
…	…
474	474	{
475	475	if (!value.equals(p1 + u * sz, p2 + u * sz))
476		return 0;
477		}
478		return 1;
479		}
480
481		int compare(void p1, void p2)
	476	return false;
	477	}
	478	return true;
	479	}
	480
	481	override int compare(in void* p1, in void* p2)
482	482	{
483	483	size_t sz = value.tsize();
…	…
492	492	}
493	493
494		size_t tsize()
	494	override size_t tsize()
495	495	{
496	496	return len * value.tsize();
497	497	}
498	498
499		void swap(void p1, void p2)
500		{ void* tmp;
	499	override void swap(void* p1, void* p2)
	500	{
	501	void* tmp;
501	502	size_t sz = value.tsize();
502	503	ubyte[16] buffer;
…	…
518	519	}
519	520
520		void[] init() { return value.init(); }
521		TypeInfo next() { return value; }
522		uint flags() { return value.flags(); }
	521	override void[] init() { return value.init(); }
	522	override TypeInfo next() { return value; }
	523	override uint flags() { return value.flags(); }
523	524
524	525	TypeInfo value;
525		size_t len;
	526	size_t len;
526	527	}
527	528
528	529	class TypeInfo_AssociativeArray : TypeInfo
529	530	{
530		char[] toString()
	531	override char[] toString()
531	532	{
532	533	return next.toString() ~ "[" ~ key.toString() ~ "]";
533	534	}
534	535
535		int opEquals(Object o)
536		{ ~~TypeInfo_AssociativeArray c;~~
537
	536	override equals_t opEquals(Object o)
	537	{
	538	TypeInfo_AssociativeArray c;
538	539	return this is o \|\|
539	540	((c = cast(TypeInfo_AssociativeArray)o) !is null &&
…	…
544	545	// BUG: need to add the rest of the functions
545	546
546		size_t tsize()
	547	override size_t tsize()
547	548	{
548	549	return (char[int]).sizeof;
549	550	}
550	551
551		TypeInfo next() { return value; }
552		uint flags() { return 1; }
	552	override TypeInfo next() { return value; }
	553	override uint flags() { return 1; }
553	554
554	555	TypeInfo value;
…	…
558	559	class TypeInfo_Function : TypeInfo
559	560	{
560		char[] toString()
	561	override char[] toString()
561	562	{
562	563	return next.toString() ~ "()";
563	564	}
564	565
565		int opEquals(Object o)
566		{ ~~TypeInfo_Function c;~~
567
	566	override equals_t opEquals(Object o)
	567	{
	568	TypeInfo_Function c;
568	569	return this is o \|\|
569	570	((c = cast(TypeInfo_Function)o) !is null &&
…	…
573	574	// BUG: need to add the rest of the functions
574	575
575		size_t tsize()
	576	override size_t tsize()
576	577	{
577	578	return 0; // no size for functions
…	…
583	584	class TypeInfo_Delegate : TypeInfo
584	585	{
585		char[] toString()
586		{
587		return ~~next.toString() ~ " delegate()"~~;
588		}
589
590		int opEquals(Object o)
591		{ ~~TypeInfo_Delegate c;~~
592
	586	override char[] toString()
	587	{
	588	return (next.toString() ~ " delegate()");
	589	}
	590
	591	override equals_t opEquals(Object o)
	592	{
	593	TypeInfo_Delegate c;
593	594	return this is o \|\|
594	595	((c = cast(TypeInfo_Delegate)o) !is null &&
…	…
598	599	// BUG: need to add the rest of the functions
599	600
600		size_t tsize()
601		{ alias int delegate() dg;
	601	override size_t tsize()
	602	{
	603	alias int delegate() dg;
602	604	return dg.sizeof;
603	605	}
604	606
605		uint flags() { return 1; }
	607	override uint flags() { return 1; }
606	608
607	609	TypeInfo next;
…	…
610	612	class TypeInfo_Class : TypeInfo
611	613	{
612		char[] toString() { return info.name; }
613
614		int opEquals(Object o)
615		{ ~~TypeInfo_Class c;~~
616
	614	override char[] toString() { return info.name; }
	615
	616	override equals_t opEquals(Object o)
	617	{
	618	TypeInfo_Class c;
617	619	return this is o \|\|
618	620	((c = cast(TypeInfo_Class)o) !is null &&
…	…
620	622	}
621	623
622		hash_t getHash(void *p)
	624	override hash_t getHash(in void* p)
623	625	{
624	626	Object o = cast(Object)p;
…	…
626	628	}
627	629
628		int equals(void p1, void p2)
	630	override equals_t equals(in void* p1, in void* p2)
629	631	{
630	632	Object o1 = cast(Object)p1;
…	…
634	636	}
635	637
636		int compare(void p1, void p2)
	638	override int compare(in void* p1, in void* p2)
637	639	{
638	640	Object o1 = cast(Object)p1;
…	…
644	646	{
645	647	if (o1)
646		{ if (!o2)
	648	{
	649	if (!o2)
647	650	c = 1;
648	651	else
…	…
655	658	}
656	659
657		size_t tsize()
	660	override size_t tsize()
658	661	{
659	662	return Object.sizeof;
660	663	}
661	664
662		uint flags() { return 1; }
663
664		OffsetTypeInfo[] offTi()
	665	override uint flags() { return 1; }
	666
	667	override OffsetTypeInfo[] offTi()
665	668	{
666	669	return (info.flags & 4) ? info.offTi : null;
…	…
672	675	class TypeInfo_Interface : TypeInfo
673	676	{
674		char[] toString() { return info.name; }
675
676		int opEquals(Object o)
677		{ ~~TypeInfo_Interface c;~~
678
	677	override char[] toString() { return info.name; }
	678
	679	override equals_t opEquals(Object o)
	680	{
	681	TypeInfo_Interface c;
679	682	return this is o \|\|
680	683	((c = cast(TypeInfo_Interface)o) !is null &&
…	…
682	685	}
683	686
684		hash_t getHash(void *p)
	687	override hash_t getHash(in void* p)
685	688	{
686	689	Interface* pi = cast(Interface )cast(void**)p;
…	…
690	693	}
691	694
692		int equals(void p1, void p2)
	695	override equals_t equals(in void* p1, in void* p2)
693	696	{
694	697	Interface* pi = cast(Interface )cast(void**)p1;
…	…
700	703	}
701	704
702		int compare(void p1, void p2)
	705	override int compare(in void* p1, in void* p2)
703	706	{
704	707	Interface* pi = cast(Interface )cast(void**)p1;
…	…
712	715	{
713	716	if (o1)
714		{ if (!o2)
	717	{
	718	if (!o2)
715	719	c = 1;
716	720	else
…	…
723	727	}
724	728
725		size_t tsize()
	729	override size_t tsize()
726	730	{
727	731	return Object.sizeof;
728	732	}
729	733
730		uint flags() { return 1; }
	734	override uint flags() { return 1; }
731	735
732	736	ClassInfo info;
…	…
735	739	class TypeInfo_Struct : TypeInfo
736	740	{
737		char[] toString() { return name; }
738
739		int opEquals(Object o)
740		{ ~~TypeInfo_Struct s;~~
741
	741	override char[] toString() { return name; }
	742
	743	override equals_t opEquals(Object o)
	744	{
	745	TypeInfo_Struct s;
742	746	return this is o \|\|
743	747	((s = cast(TypeInfo_Struct)o) !is null &&
…	…
746	750	}
747	751
748		hash_t getHash(void *p)
749		{ hash_t h;
750
	752	override hash_t getHash(in void* p)
	753	{
751	754	assert(p);
752	755	if (xtoHash)
753		{ debug(PRINTF) printf("getHash() using xtoHash\n");
754		h = (*xtoHash)(p);
	756	{
	757	debug(PRINTF) printf("getHash() using xtoHash\n");
	758	return (*xtoHash)(p);
755	759	}
756	760	else
757	761	{
	762	hash_t h;
758	763	debug(PRINTF) printf("getHash() using default hash\n");
759	764	// A sorry hash algorithm.
760	765	// Should use the one for strings.
761	766	// BUG: relies on the GC not moving objects
	767	auto q = cast(ubyte*)p;
762	768	for (size_t i = 0; i < init.length; i++)
763		{ h = h * 9 + cast(ubyte)p;
764		p++;
	769	{
	770	h = h * 9 + *q;
	771	q++;
765	772	}
766		}
767		return h;
768		}
769
770		int equals(void p1, void p2)
771		{ int c;
772
	773	return h;
	774	}
	775	}
	776
	777	override equals_t equals(in void* p1, in void* p2)
	778	{
773	779	if (p1 == p2)
774		~~c = 1~~;
	780	return true;
775	781	else if (!p1 \|\| !p2)
776		~~c = 0~~;
	782	return false;
777	783	else if (xopEquals)
778		~~c =~~ (*xopEquals)(p1, p2);
	784	return (*xopEquals)(p1, p2);
779	785	else
780	786	// BUG: relies on the GC not moving objects
781		c = (memcmp(p1, p2, init.length) == 0);
782		return c;
783		}
784
785		int compare(void p1, void p2)
786		{
787		int c = 0;
788
	787	return memcmp(p1, p2, init.length) == 0;
	788	}
	789
	790	override int compare(in void* p1, in void* p2)
	791	{
789	792	// Regard null references as always being "less than"
790	793	if (p1 != p2)
791	794	{
792	795	if (p1)
793		{ if (!p2)
794		c = 1;
	796	{
	797	if (!p2)
	798	return true;
795	799	else if (xopCmp)
796		~~c =~~ (*xopCmp)(p2, p1);
	800	return (*xopCmp)(p2, p1);
797	801	else
798	802	// BUG: relies on the GC not moving objects
799		~~c =~~ memcmp(p1, p2, init.length);
	803	return memcmp(p1, p2, init.length);
800	804	}
801	805	else
802		~~c =~~ -1;
803		}
804		return c;
805		}
806
807		size_t tsize()
	806	return -1;
	807	}
	808	return 0;
	809	}
	810
	811	override size_t tsize()
808	812	{
809	813	return init.length;
810	814	}
811	815
812		void[] init() { return m_init; }
813
814		uint flags() { return m_flags; }
	816	override void[] init() { return m_init; }
	817
	818	override uint flags() { return m_flags; }
815	819
816	820	char[] name;
817	821	void[] m_init; // initializer; init.ptr == null if 0 initialize
818	822
819		hash_t ~~function(void*)~~ xtoHash;
820		~~int function(void,~~void) xopEquals;
821		int ~~function(void,~~void) xopCmp;
822		char[] ~~function(void*)~~ xtoString;
	823	hash_t function(in void*) xtoHash;
	824	equals_t function(in void, in void) xopEquals;
	825	int function(in void, in void) xopCmp;
	826	char[] function(in void*) xtoString;
823	827
824	828	uint m_flags;
…	…
829	833	TypeInfo[] elements;
830	834
831		char[] toString()
	835	override char[] toString()
832	836	{
833	837	char[] s;
…	…
843	847	}
844	848
845		int opEquals(Object o)
	849	override equals_t opEquals(Object o)
846	850	{
847	851	if (this is o)
848		return 1;
	852	return true;
849	853
850	854	auto t = cast(TypeInfo_Tuple)o;
…	…
854	858	{
855	859	if (elements[i] != t.elements[i])
856		return 0;
	860	return false;
857	861	}
858		return 1;
859		}
860		return 0;
861		}
862
863		hash_t getHash(void *p)
	862	return true;
	863	}
	864	return false;
	865	}
	866
	867	override hash_t getHash(in void* p)
864	868	{
865	869	assert(0);
866	870	}
867	871
868		int equals(void p1, void p2)
	872	override equals_t equals(in void* p1, in void* p2)
869	873	{
870	874	assert(0);
871	875	}
872	876
873		int compare(void p1, void p2)
	877	override int compare(in void* p1, in void* p2)
874	878	{
875	879	assert(0);
876	880	}
877	881
878		size_t tsize()
	882	override size_t tsize()
879	883	{
880	884	assert(0);
881	885	}
882	886
883		void swap(void p1, void p2)
	887	override void swap(void* p1, void* p2)
884	888	{
885	889	assert(0);
…	…
906	910	Exception next;
907	911
908		this( char[] msg, Exception next = null )
	912	this( char[] msg, Exception next=null )
909	913	{
910	914	this.msg = msg;
…	…
921	925	}
922	926
923		char[] toString()
	927	override char[] toString()
924	928	{
925	929	return msg;
…	…
1029	1033	}
1030	1034
	1035	version (OSX)
	1036	{
	1037	extern (C)
	1038	{
	1039	extern void* _minfo_beg;
	1040	extern void* _minfo_end;
	1041	}
	1042	}
	1043
1031	1044	ModuleInfo[] _moduleinfo_dtors;
1032	1045	uint _moduleinfo_dtors_i;
…	…
1056	1069	}
1057	1070	}
1058
	1071
	1072	version (OSX){
	1073	/* The ModuleInfo references are stored in the special segment
	1074	* __minfodata, which is bracketed by the segments __minfo_beg
	1075	* and __minfo_end. The variables _minfo_beg and _minfo_end
	1076	* are of zero size and are in the two bracketing segments,
	1077	* respectively.
	1078	*/
	1079	size_t length = cast(ModuleInfo)&_minfo_end - cast(ModuleInfo)&_minfo_beg;
	1080	_moduleinfo_array = (cast(ModuleInfo*)&_minfo_beg)[0 .. length];
	1081	debug printf("moduleinfo: ptr = %p, length = %d\n", _moduleinfo_array.ptr, _moduleinfo_array.length);
	1082
	1083	debug foreach (m; _moduleinfo_array)
	1084	{
	1085	//printf("\t%p\n", m);
	1086	printf("\t%.*s\n", m.name);
	1087	}
	1088	}
	1089
1059	1090	version (Win32)
1060	1091	{
…	…
1064	1095
1065	1096	_moduleinfo_dtors = new ModuleInfo[_moduleinfo_array.length];
1066		debug(PRINTF) printf("_moduleinfo_dtors = x%x\n", cast(void *)_moduleinfo_dtors);
	1097	debug(PRINTF) printf("_moduleinfo_dtors = x%x\n", cast(void*)_moduleinfo_dtors);
1067	1098	_moduleIndependentCtors();
1068	1099	_moduleCtor2(null,_moduleinfo_array, 0);

trunk/lib/compiler/dmd/posix.mak

r4357	r4384
32	32	CFLAGS_RELEASE=-O $(ADD_CFLAGS)
33	33	CFLAGS_DEBUG=-g $(ADD_CFLAGS)
34		DFLAGS_RELEASE=-release -O -inline -w -nofloat $(SYSTEM_VERSION) $(ADD_DFLAGS) -I../../.. -I$(SRC_DIR)~~/rt~~
35		DFLAGS_DEBUG=-g -w -nofloat $(SYSTEM_VERSION) $(ADD_DFLAGS) -I../../.. -I$(SRC_DIR)~~/rt~~
	34	DFLAGS_RELEASE=-release -O -inline -w -nofloat $(SYSTEM_VERSION) $(ADD_DFLAGS) -I../../.. -I$(SRC_DIR)
	35	DFLAGS_DEBUG=-g -w -nofloat $(SYSTEM_VERSION) $(ADD_DFLAGS) -I../../.. -I$(SRC_DIR)
36	36	TFLAGS_RELEASE=-O -inline -w -nofloat $(SYSTEM_VERSION) $(ADD_DFLAGS)
37	37	TFLAGS_DEBUG=-g -w -nofloat $(SYSTEM_VERSION) $(ADD_DFLAGS)

trunk/lib/compiler/dmd/rt/aApply.d

r4357	r4384
30	30	*/
31	31
	32	module rt.aApply;
	33
32	34	/* This code handles decoding UTF strings for foreach loops.
33	35	* There are 6 combinations of conversions between char, wchar,
…	…
35	37	*/
36	38
37		private import util.utf;
	39	private import rt.util.utf;
38	40
39	41	/**********************************************
…	…
102	104	else
103	105	{
104		w = cast(wchar)((((d - 0x10000) >> 10) & 0x3FF) + 0xD800);
	106	w = cast(wchar)((((d - 0x10000) >> 10) & 0x3FF) + 0xD800);
105	107	result = dg(cast(void *)&w);
106	108	if (result)
107	109	break;
108		w = cast(wchar)(((d - 0x10000) & 0x3FF) + 0xDC00);
	110	w = cast(wchar)(((d - 0x10000) & 0x3FF) + 0xDC00);
109	111	}
110	112	}
…	…
199	201	else
200	202	{
201		w = cast(wchar)((((d - 0x10000) >> 10) & 0x3FF) + 0xD800);
	203	w = cast(wchar)((((d - 0x10000) >> 10) & 0x3FF) + 0xD800);
202	204	result = dg(cast(void *)&w);
203	205	if (result)
204	206	break;
205		w = cast(wchar)(((d - 0x10000) & 0x3FF) + 0xDC00);
	207	w = cast(wchar)(((d - 0x10000) & 0x3FF) + 0xDC00);
206	208	}
207	209	result = dg(cast(void *)&w);
…	…
290	292	else
291	293	{
292		w = cast(wchar) ((((d - 0x10000) >> 10) & 0x3FF) + 0xD800);
	294	w = cast(wchar) ((((d - 0x10000) >> 10) & 0x3FF) + 0xD800);
293	295	result = dg(&i, cast(void *)&w);
294	296	if (result)
295	297	break;
296		w = cast(wchar) (((d - 0x10000) & 0x3FF) + 0xDC00);
	298	w = cast(wchar) (((d - 0x10000) & 0x3FF) + 0xDC00);
297	299	}
298	300	}
…	…
393	395	else
394	396	{
395		w = cast(wchar) ((((d - 0x10000) >> 10) & 0x3FF) + 0xD800);
	397	w = cast(wchar) ((((d - 0x10000) >> 10) & 0x3FF) + 0xD800);
396	398	result = dg(&j, cast(void *)&w);
397	399	if (result)
398	400	break;
399		w = cast(wchar) (((d - 0x10000) & 0x3FF) + 0xDC00);
	401	w = cast(wchar) (((d - 0x10000) & 0x3FF) + 0xDC00);
400	402	}
401	403	result = dg(&j, cast(void *)&w);

trunk/lib/compiler/dmd/rt/aApplyR.d

r4357	r4384
1
2	1	/**
3	2	* Part of the D programming language runtime library.
…	…
31	30	*/
32	31
	32	module rt.aApplyR;
	33
33	34	/* This code handles decoding UTF strings for foreach_reverse loops.
34	35	* There are 6 combinations of conversions between char, wchar,
…	…
36	37	*/
37	38
38		private import util.utf;
	39	private import rt.util.utf;
39	40
40	41	/**********************************************/
…	…
80	81	debug(apply) printf("_aApplyRcd1.unittest\n");
81	82
82		auto s = "hello"c;
	83	auto s = "hello"c[];
83	84	int i;
84	85
…	…
144	145	debug(apply) printf("_aApplyRwd1.unittest\n");
145	146
146		auto s = "hello"w;
	147	auto s = "hello"w[];
147	148	int i;
148	149
…	…
230	231	debug(apply) printf("_aApplyRcw1.unittest\n");
231	232
232		auto s = "hello"c;
	233	auto s = "hello"c[];
233	234	int i;
234	235
…	…
311	312	debug(apply) printf("_aApplyRwc1.unittest\n");
312	313
313		auto s = "hello"w;
	314	auto s = "hello"w[];
314	315	int i;
315	316
…	…
390	391	debug(apply) printf("_aApplyRdc1.unittest\n");
391	392
392		auto s = "hello"d;
	393	auto s = "hello"d[];
393	394	int i;
394	395
…	…
462	463	debug(apply) printf("_aApplyRdw1.unittest\n");
463	464
464		auto s = "hello"d;
	465	auto s = "hello"d[];
465	466	int i;
466	467
…	…
544	545	debug(apply) printf("_aApplyRcd2.unittest\n");
545	546
546		auto s = "hello"c;
	547	auto s = "hello"c[];
547	548	int i;
548	549
…	…
609	610	debug(apply) printf("_aApplyRwd2.unittest\n");
610	611
611		auto s = "hello"w;
	612	auto s = "hello"w[];
612	613	int i;
613	614
…	…
697	698	debug(apply) printf("_aApplyRcw2.unittest\n");
698	699
699		auto s = "hello"c;
	700	auto s = "hello"c[];
700	701	int i;
701	702
…	…
780	781	debug(apply) printf("_aApplyRwc2.unittest\n");
781	782
782		auto s = "hello"w;
	783	auto s = "hello"w[];
783	784	int i;
784	785
…	…
860	861	debug(apply) printf("_aApplyRdc2.unittest\n");
861	862
862		auto s = "hello"d;
	863	auto s = "hello"d[];
863	864	int i;
864	865
…	…
934	935	debug(apply) printf("_aApplyRdw2.unittest\n");
935	936
936		auto s = "hello"d;
	937	auto s = "hello"d[];
937	938	int i;
938	939
…	…
972	973	assert(i == 5);
973	974	}
974
975

trunk/lib/compiler/dmd/rt/aaA.d

r4357	r4384
31	31	* Modified by Sean Kelly <sean@f4.ca> for use with Tango.
32	32	*/
	33
	34	module rt.aaA;
33	35
34	36	private
…	…
585	587	_aaRehash_x(e);
586	588	}
	589	delete aa.b;
587	590
588	591	newb.nodes = aa.nodes;
…	…
591	594
592	595	*paa.a = newb;
	596	_aaBalance(paa);
593	597	}
594	598	return (*paa).a;
595	599	}
596	600
597
	601	/********************************************
	602	* Balance an array.
	603	*/
	604
	605	void _aaBalance(AA* paa)
	606	{
	607	//printf("_aaBalance()\n");
	608	if (paa.a)
	609	{
	610	aaA*[16] tmp;
	611	aaA*[] array = tmp;
	612	auto aa = paa.a;
	613	foreach (j, e; aa.b)
	614	{
	615	/* Temporarily store contents of bucket in array[]
	616	*/
	617	size_t k = 0;
	618	void addToArray(aaA* e)
	619	{
	620	while (e)
	621	{ addToArray(e.left);
	622	if (k == array.length)
	623	array.length = array.length * 2;
	624	array[k++] = e;
	625	e = e.right;
	626	}
	627	}
	628	addToArray(e);
	629	/* The contents of the bucket are now sorted into array[].
	630	* Rebuild the tree.
	631	*/
	632	void buildTree(aaA** p, size_t x1, size_t x2)
	633	{
	634	if (x1 >= x2)
	635	*p = null;
	636	else
	637	{ auto mid = (x1 + x2) >> 1;
	638	*p = array[mid];
	639	buildTree(&(*p).left, x1, mid);
	640	buildTree(&(*p).right, mid + 1, x2);
	641	}
	642	}
	643	auto p = &aa.b[j];
	644	buildTree(p, 0, k);
	645	}
	646	}
	647	}
598	648	/********************************************
599	649	* Produce array of N byte keys from aa.

trunk/lib/compiler/dmd/rt/adi.d

r4357	r4384
33	33	*/
34	34
	35	module rt.adi;
35	36
36	37	//debug=adi; // uncomment to turn on debugging printf's
…	…
40	41	import tango.stdc.string;
41	42	import tango.stdc.stdlib;
42		import util.utf;
	43	import rt.util.utf;
43	44
44	45	enum BlkAttr : uint
…	…
146	147	unittest
147	148	{
148		auto a = "abcd"c;
	149	auto a = "abcd"c[];
149	150
150	151	auto r = a.dup.reverse;
…	…
245	246	unittest
246	247	{
247		w~~string~~ a = "abcd";
248		w~~string~~ r;
	248	wchar[] a = "abcd";
	249	wchar[] r;
249	250
250	251	r = a.dup.reverse;

trunk/lib/compiler/dmd/rt/alloca.d

r4357	r4384
4	4	* Written by Walter Bright
5	5	*/
	6
	7	module rt.alloca;
6	8
7	9	/+
…	…
18	20	* work right, do not change its name, do not call it from other compilers.
19	21	* Input:
20		* ~~nbytes~~ number of bytes to allocate
21		* ~~ECX~~ address of variable with # of bytes in locals
22		* This is adjusted upon return to reflect the additional
23		* size of the stack frame.
	22	* nbytes number of bytes to allocate
	23	* ECX address of variable with # of bytes in locals
	24	* This is adjusted upon return to reflect the additional
	25	* size of the stack frame.
24	26	* Returns:
25		* ~~EAX~~ allocated data, null if stack overflows
	27	* EAX allocated data, null if stack overflows
26	28	*/
27	29
…	…
30	32	asm
31	33	{
32		~~naked~~ ;
33		~~mov EDX,ECX~~ ;
34		~~mov EAX,4[ESP]~~ ; // get nbytes
35		~~push EBX~~ ;
36		~~push EDI~~ ;
37		~~push ESI~~ ;
38		~~add EAX,3~~ ;
39		~~and EAX,0xFFFFFFFC~~ ; // round up to dword
40		~~jnz Abegin~~ ;
41		~~mov EAX,4~~ ; // allow zero bytes allocation, 0 rounded to dword is 4..
	34	naked ;
	35	mov EDX,ECX ;
	36	mov EAX,4[ESP] ; // get nbytes
	37	push EBX ;
	38	push EDI ;
	39	push ESI ;
	40	add EAX,3 ;
	41	and EAX,0xFFFFFFFC ; // round up to dword
	42	jnz Abegin ;
	43	mov EAX,4 ; // allow zero bytes allocation, 0 rounded to dword is 4..
42	44	Abegin:
43		~~mov ESI,EAX~~ ; // ESI = nbytes
44		~~neg EAX~~ ;
45		~~add EAX,ESP~~ ; // EAX is now what the new ESP will be.
46		~~jae Aoverflow~~ ;
	45	mov ESI,EAX ; // ESI = nbytes
	46	neg EAX ;
	47	add EAX,ESP ; // EAX is now what the new ESP will be.
	48	jae Aoverflow ;
47	49	}
48	50	version (Win32)
…	…
50	52	asm
51	53	{
52		// We need to be careful about the guard page
53		// Thus, for every 4k page, touch it to cause the OS to load it in.
54		~~mov ECX,EAX~~ ; // ECX is new location for stack
55		~~mov EBX,ESI~~ ; // EBX is size to "grow" stack
	54	// We need to be careful about the guard page
	55	// Thus, for every 4k page, touch it to cause the OS to load it in.
	56	mov ECX,EAX ; // ECX is new location for stack
	57	mov EBX,ESI ; // EBX is size to "grow" stack
56	58	L1:
57		~~test [ECX+EBX],EBX~~ ; // bring in page
58		~~sub EBX,0x1000~~ ; // next 4K page down
59		~~jae L1~~ ; // if more pages
60		~~test [ECX],EBX~~ ; // bring in last page
	59	test [ECX+EBX],EBX ; // bring in page
	60	sub EBX,0x1000 ; // next 4K page down
	61	jae L1 ; // if more pages
	62	test [ECX],EBX ; // bring in last page
61	63	}
62	64	}
…	…
65	67	asm
66	68	{
67		// is ESP off bottom?
68		~~cmp EAX,_x386_break~~ ;
69		~~jbe Aoverflow~~ ;
	69	// is ESP off bottom?
	70	cmp EAX,_x386_break ;
	71	jbe Aoverflow ;
70	72	}
71	73	}
…	…
74	76	asm
75	77	{
76		~~cmp EAX,_pastdata~~ ;
77		~~jbe Aoverflow~~ ; // Unlikely - ~2 Gbytes under UNIX
	78	cmp EAX,_pastdata ;
	79	jbe Aoverflow ; // Unlikely - ~2 Gbytes under UNIX
78	80	}
79	81	}
80	82	asm
81	83	{
82		// Copy down to [ESP] the temps on the stack.
83		// The number of temps is (EBP - ESP - locals).
84		~~mov ECX,EBP~~ ;
85		~~sub ECX,ESP~~ ;
86		~~sub ECX,[EDX]~~ ; // ECX = number of temps (bytes) to move.
87		~~add [EDX],ESI~~ ; // adjust locals by nbytes for next call to alloca()
88		~~mov ESP,EAX~~ ; // Set up new stack pointer.
89		~~add EAX,ECX~~ ; // Return value = ESP + temps.
90		~~mov EDI,ESP~~ ; // Destination of copy of temps.
91		~~add ESI,ESP~~ ; // Source of copy.
92		~~shr ECX,2~~ ; // ECX to count of dwords in temps
93		// Always at least 4 (nbytes, EIP, ESI,and EDI).
94		~~rep~~ ;
95		~~movsd~~ ;
96		~~jmp done~~ ;
	84	// Copy down to [ESP] the temps on the stack.
	85	// The number of temps is (EBP - ESP - locals).
	86	mov ECX,EBP ;
	87	sub ECX,ESP ;
	88	sub ECX,[EDX] ; // ECX = number of temps (bytes) to move.
	89	add [EDX],ESI ; // adjust locals by nbytes for next call to alloca()
	90	mov ESP,EAX ; // Set up new stack pointer.
	91	add EAX,ECX ; // Return value = ESP + temps.
	92	mov EDI,ESP ; // Destination of copy of temps.
	93	add ESI,ESP ; // Source of copy.
	94	shr ECX,2 ; // ECX to count of dwords in temps
	95	// Always at least 4 (nbytes, EIP, ESI,and EDI).
	96	rep ;
	97	movsd ;
	98	jmp done ;
97	99
98	100	Aoverflow:
99		// Overflowed the stack. Return null
100		~~xor EAX,EAX~~ ;
	101	// Overflowed the stack. Return null
	102	xor EAX,EAX ;
101	103
102	104	done:
103		~~pop ESI~~ ;
104		~~pop EDI~~ ;
105		~~pop EBX~~ ;
106		~~ret~~ ;
	105	pop ESI ;
	106	pop EDI ;
	107	pop EBX ;
	108	ret ;
107	109	}
108	110	}
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

trunk/lib/compiler/dmd/rt/arraybyte.d

r4357	r4384
10	10	*/
11	11
12		import util.cpuid;
	12	module rt.arraybyte;
	13
	14	import rt.util.cpuid;
13	15
14	16	debug(UnitTest)
15	17	{
	18	private extern(C) int printf(char*,...);
16	19	/* This is so unit tests will test every CPU variant
17	20	*/
18	21	int cpuid;
19	22	const int CPUID_MAX = 4;
20		bool mmx() { return cpuid == 1 && util.cpuid.mmx(); }
21		bool sse() { return cpuid == 2 && util.cpuid.sse(); }
22		bool sse2() { return cpuid == 3 && util.cpuid.sse2(); }
23		bool amd3dnow() { return cpuid == 4 && util.cpuid.amd3dnow(); }
	23	bool mmx() { return cpuid == 1 && rt.util.cpuid.mmx(); }
	24	bool sse() { return cpuid == 2 && rt.util.cpuid.sse(); }
	25	bool sse2() { return cpuid == 3 && rt.util.cpuid.sse2(); }
	26	bool amd3dnow() { return cpuid == 4 && rt.util.cpuid.amd3dnow(); }
24	27	}
25	28	else
26	29	{
27		alias util.cpuid.mmx mmx;
28		alias util.cpuid.sse sse;
29		alias util.cpuid.sse2 sse2;
30		alias util.cpuid.amd3dnow amd3dnow;
	30	alias rt.util.cpuid.mmx mmx;
	31	alias rt.util.cpuid.sse sse;
	32	alias rt.util.cpuid.sse2 sse2;
	33	alias rt.util.cpuid.amd3dnow amd3dnow;
31	34	}
32	35

trunk/lib/compiler/dmd/rt/arraycast.d

r4357	r4384
25	25	* Modified by Sean Kelly <sean@f4.ca> for use with Tango.
26	26	*/
	27
	28	module rt.arraycast;
27	29
28	30	/******************************************

trunk/lib/compiler/dmd/rt/arraycat.d

r4357	r4384
30	30	*/
31	31
	32	module rt.arraycat;
	33
32	34	private
33	35	{

trunk/lib/compiler/dmd/rt/arraydouble.d

r4357	r4384
6	6	*/
7	7
8		import util.cpuid;
	8	module rt.arraydouble;
	9
	10	import rt.util.cpuid;
9	11
10	12	debug(UnitTest)
11	13	{
	14	private extern(C) int printf(char*,...);
12	15	/* This is so unit tests will test every CPU variant
13	16	*/
14	17	int cpuid;
15	18	const int CPUID_MAX = 5;
16		bool mmx() { return cpuid == 1 && util.cpuid.mmx(); }
17		bool sse() { return cpuid == 2 && util.cpuid.sse(); }
18		bool sse2() { return cpuid == 3 && util.cpuid.sse2(); }
19		bool amd3dnow() { return cpuid == 4 && util.cpuid.amd3dnow(); }
	19	bool mmx() { return cpuid == 1 && rt.util.cpuid.mmx(); }
	20	bool sse() { return cpuid == 2 && rt.util.cpuid.sse(); }
	21	bool sse2() { return cpuid == 3 && rt.util.cpuid.sse2(); }
	22	bool amd3dnow() { return cpuid == 4 && rt.util.cpuid.amd3dnow(); }
20	23	}
21	24	else
22	25	{
23		import util.cpuid;
24		alias util.cpuid.mmx mmx;
25		alias util.cpuid.sse sse;
26		alias util.cpuid.sse2 sse2;
27		alias util.cpuid.amd3dnow amd3dnow;
	26	import rt.util.cpuid;
	27	alias rt.util.cpuid.mmx mmx;
	28	alias rt.util.cpuid.sse sse;
	29	alias rt.util.cpuid.sse2 sse2;
	30	alias rt.util.cpuid.amd3dnow amd3dnow;
28	31	}
29	32

trunk/lib/compiler/dmd/rt/arrayfloat.d

r4357	r4384
6	6	*/
7	7
8		import util.cpuid;
	8	module rt.arrayfloat;
	9
	10	import rt.util.cpuid;
9	11
10	12	debug(UnitTest)
11	13	{
	14	private extern(C) int printf(char*,...);
12	15	/* This is so unit tests will test every CPU variant
13	16	*/
14	17	int cpuid;
15	18	const int CPUID_MAX = 5;
16		bool mmx() { return cpuid == 1 && util.cpuid.mmx(); }
17		bool sse() { return cpuid == 2 && util.cpuid.sse(); }
18		bool sse2() { return cpuid == 3 && util.cpuid.sse2(); }
19		bool amd3dnow() { return cpuid == 4 && util.cpuid.amd3dnow(); }
	19	bool mmx() { return cpuid == 1 && rt.util.cpuid.mmx(); }
	20	bool sse() { return cpuid == 2 && rt.util.cpuid.sse(); }
	21	bool sse2() { return cpuid == 3 && rt.util.cpuid.sse2(); }
	22	bool amd3dnow() { return cpuid == 4 && rt.util.cpuid.amd3dnow(); }
20	23	}
21	24	else
22	25	{
23		import util.cpuid;
24		alias util.cpuid.mmx mmx;
25		alias util.cpuid.sse sse;
26		alias util.cpuid.sse2 sse2;
27		alias util.cpuid.amd3dnow amd3dnow;
	26	alias rt.util.cpuid.mmx mmx;
	27	alias rt.util.cpuid.sse sse;
	28	alias rt.util.cpuid.sse2 sse2;
	29	alias rt.util.cpuid.amd3dnow amd3dnow;
28	30	}
29	31

trunk/lib/compiler/dmd/rt/arrayint.d

r4357	r4384
10	10	*/
11	11
12		import util.cpuid;
	12	module rt.arrayint;
	13
	14	private import rt.util.cpuid;
13	15
14	16	debug(UnitTest)
15	17	{
	18	private extern(C) int printf(char*,...);
16	19	/* This is so unit tests will test every CPU variant
17	20	*/
18	21	int cpuid;
19	22	const int CPUID_MAX = 4;
20		bool mmx() { return cpuid == 1 && util.cpuid.mmx(); }
21		bool sse() { return cpuid == 2 && util.cpuid.sse(); }
22		bool sse2() { return cpuid == 3 && util.cpuid.sse2(); }
23		bool amd3dnow() { return cpuid == 4 && util.cpuid.amd3dnow(); }
	23	bool mmx() { return cpuid == 1 && rt.util.cpuid.mmx(); }
	24	bool sse() { return cpuid == 2 && rt.util.cpuid.sse(); }
	25	bool sse2() { return cpuid == 3 && rt.util.cpuid.sse2(); }
	26	bool amd3dnow() { return cpuid == 4 && rt.util.cpuid.amd3dnow(); }
24	27	}
25	28	else
26	29	{
27		alias util.cpuid.mmx mmx;
28		alias util.cpuid.sse sse;
29		alias util.cpuid.sse2 sse2;
30		alias util.cpuid.amd3dnow amd3dnow;
	30	alias rt.util.cpuid.mmx mmx;
	31	alias rt.util.cpuid.sse sse;
	32	alias rt.util.cpuid.sse2 sse2;
	33	alias rt.util.cpuid.amd3dnow amd3dnow;
31	34	}
32	35

trunk/lib/compiler/dmd/rt/arrayreal.d

r4357	r4384
5	5	*/
6	6
7		import util.cpuid;
	7	module rt.arrayreal;
	8
	9	import rt.util.cpuid;
8	10
9	11	debug(UnitTest)
10	12	{
	13	private extern(C) int printf(char*,...);
11	14	/* This is so unit tests will test every CPU variant
12	15	*/
13	16	int cpuid;
14	17	const int CPUID_MAX = 1;
15		bool mmx() { return cpuid == 1 && util.cpuid.mmx(); }
16		bool sse() { return cpuid == 2 && util.cpuid.sse(); }
17		bool sse2() { return cpuid == 3 && util.cpuid.sse2(); }
18		bool amd3dnow() { return cpuid == 4 && util.cpuid.amd3dnow(); }
	18	bool mmx() { return cpuid == 1 && rt.util.cpuid.mmx(); }
	19	bool sse() { return cpuid == 2 && rt.util.cpuid.sse(); }
	20	bool sse2() { return cpuid == 3 && rt.util.cpuid.sse2(); }
	21	bool amd3dnow() { return cpuid == 4 && rt.util.cpuid.amd3dnow(); }
19	22	}
20	23	else
21	24	{
22		import util.cpuid;
23		alias util.cpuid.mmx mmx;
24		alias util.cpuid.sse sse;
25		alias util.cpuid.sse2 sse2;
26		alias util.cpuid.amd3dnow amd3dnow;
	25	alias rt.util.cpuid.mmx mmx;
	26	alias rt.util.cpuid.sse sse;
	27	alias rt.util.cpuid.sse2 sse2;
	28	alias rt.util.cpuid.amd3dnow amd3dnow;
27	29	}
28	30

trunk/lib/compiler/dmd/rt/arrayshort.d

r4357	r4384
10	10	*/
11	11
12		import util.cpuid;
	12	module rt.arrayshort;
	13
	14	private import rt.util.cpuid;
13	15
14	16	debug(UnitTest)
15	17	{
	18	private extern(C) int printf(char*,...);
16	19	/* This is so unit tests will test every CPU variant
17	20	*/
18	21	int cpuid;
19	22	const int CPUID_MAX = 4;
20		bool mmx() { return cpuid == 1 && util.cpuid.mmx(); }
21		bool sse() { return cpuid == 2 && util.cpuid.sse(); }
22		bool sse2() { return cpuid == 3 && util.cpuid.sse2(); }
23		bool amd3dnow() { return cpuid == 4 && util.cpuid.amd3dnow(); }
	23	bool mmx() { return cpuid == 1 && rt.util.cpuid.mmx(); }
	24	bool sse() { return cpuid == 2 && rt.util.cpuid.sse(); }
	25	bool sse2() { return cpuid == 3 && rt.util.cpuid.sse2(); }
	26	bool amd3dnow() { return cpuid == 4 && rt.util.cpuid.amd3dnow(); }
24	27	}
25	28	else
26	29	{
27		alias util.cpuid.mmx mmx;
28		alias util.cpuid.sse sse;
29		alias util.cpuid.sse2 sse2;
30		alias util.cpuid.sse2 sse2;
	30	alias rt.util.cpuid.mmx mmx;
	31	alias rt.util.cpuid.sse sse;
	32	alias rt.util.cpuid.sse2 sse2;
	33	alias rt.util.cpuid.sse2 sse2;
31	34	}
32	35

trunk/lib/compiler/dmd/rt/cast_.d

r4357	r4384
25	25	* Modified by Sean Kelly <sean@f4.ca> for use with Tango.
26	26	*/
	27
	28	module rt.cast_;
27	29
28	30	extern (C):

trunk/lib/compiler/dmd/rt/cmath2.d

r4357	r4384
10	10	* Modified by Sean Kelly <sean@f4.ca> for use with Tango.
11	11	*/
	12
	13	module rt.cmath2;
12	14
13	15	private import tango.stdc.math;

trunk/lib/compiler/dmd/rt/compiler.d

r4357	r4384
5	5	*/
6	6
	7	module rt.compiler;
	8
7	9	// Identify the compiler used and its various features.
8
9		~~module compiler;~~
10	10
11	11	const

trunk/lib/compiler/dmd/rt/complex.c

r4357	r4384
22	22	if (fabs(y.re) < fabs(y.im))
23	23	{
24		r = y.re / y.im;
25		den = y.im + r * y.re;
26		q.re = (x.re * r + x.im) / den;
27		q.im = (x.im * r - x.re) / den;
	24	r = y.re / y.im;
	25	den = y.im + r * y.re;
	26	q.re = (x.re * r + x.im) / den;
	27	q.im = (x.im * r - x.re) / den;
28	28	}
29	29	else
30	30	{
31		r = y.im / y.re;
32		den = y.re + r * y.im;
33		q.re = (x.re + r * x.im) / den;
34		q.im = (x.im - r * x.re) / den;
	31	r = y.im / y.re;
	32	den = y.re + r * y.im;
	33	q.re = (x.re + r * x.im) / den;
	34	q.im = (x.im - r * x.re) / den;
35	35	}
36	36	return q;
…	…
53	53	y = fabs(z.im);
54	54	if (x == 0)
55		ans = y;
	55	ans = y;
56	56	else if (y == 0)
57		ans = x;
	57	ans = x;
58	58	else if (x > y)
59	59	{
60		temp = y / x;
61		ans = x * sqrt(1 + temp * temp);
	60	temp = y / x;
	61	ans = x * sqrt(1 + temp * temp);
62	62	}
63	63	else
64	64	{
65		temp = x / y;
66		ans = y * sqrt(1 + temp * temp);
	65	temp = x / y;
	66	ans = y * sqrt(1 + temp * temp);
67	67	}
68	68	return ans;
…	…
76	76	if (z.re == 0 && z.im == 0)
77	77	{
78		c.re = 0;
79		c.im = 0;
	78	c.re = 0;
	79	c.im = 0;
80	80	}
81	81	else
82	82	{
83		x = fabs(z.re);
84		y = fabs(z.im);
85		if (x >= y)
86		{
87		r = y / x;
88		w = sqrt(x) * sqrt(0.5 * (1 + sqrt(1 + r * r)));
89		}
90		else
91		{
92		r = x / y;
93		w = sqrt(y) * sqrt(0.5 * (r + sqrt(1 + r * r)));
94		}
95		if (z.re >= 0)
96		{
97		c.re = w;
98		c.im = z.im / (w + w);
99		}
100		else
101		{
102		c.im = (z.im >= 0) ? w : -w;
103		c.re = z.im / (c.im + c.im);
104		}
	83	x = fabs(z.re);
	84	y = fabs(z.im);
	85	if (x >= y)
	86	{
	87	r = y / x;
	88	w = sqrt(x) * sqrt(0.5 * (1 + sqrt(1 + r * r)));
	89	}
	90	else
	91	{
	92	r = x / y;
	93	w = sqrt(y) * sqrt(0.5 * (r + sqrt(1 + r * r)));
	94	}
	95	if (z.re >= 0)
	96	{
	97	c.re = w;
	98	c.im = z.im / (w + w);
	99	}
	100	else
	101	{
	102	c.im = (z.im >= 0) ? w : -w;
	103	c.re = z.im / (c.im + c.im);
	104	}
105	105	}
106	106	return c;
107	107	}
108

trunk/lib/compiler/dmd/rt/cover.d

r4357	r4384
12	12	* Authors: Walter Bright, Sean Kelly
13	13	*/
	14
	15	module rt.cover;
	16
14	17	private
15	18	{
16	19	version( Win32 )
17	20	import tango.sys.win32.UserGdi;
18		else version( linux )
19		import tango.sys.linux.linux;
	21	else version( Posix )
	22	{
	23	import tango.stdc.posix.fcntl;
	24	import tango.stdc.posix.unistd;
	25	}
20	26	import tango.core.BitManip;
21	27	import tango.stdc.stdio;
22		import util.utf;
	28	import rt.util.utf;
23	29
24	30	struct BitArray
…	…
126	132	if( merge )
127	133	{
128		if( !readFile( ~~c.filename ~ ".lst"~~, lstbuf ) )
	134	if( !readFile( addExt( baseName( c.filename ), "lst" ), lstbuf ) )
129	135	break;
130	136	splitLines( lstbuf, lstlines );
…	…
155	161	}
156	162
157		FILE* flst = fopen( (~~c.filename ~ ".lst"~~).ptr, "wb" );
	163	FILE* flst = fopen( (addExt( baseName( c.filename ), "lst\0" )).ptr, "wb" );
158	164
159	165	if( !flst )
…	…
207	213	const char sep = '/';
208	214
209		~~char[]~~ dest = path;
	215	auto dest = path;
210	216
211	217	if( dest && dest[$ - 1] != sep )
…	…
213	219	dest ~= name;
214	220	return dest;
	221	}
	222
	223
	224	char[] baseName( char[] name, char[] ext = null )
	225	{
	226	auto i = name.length;
	227	for( ; i > 0; --i )
	228	{
	229	version( Windows )
	230	{
	231	if( name[i - 1] == ':' \|\| name[i - 1] == '\\' )
	232	break;
	233	}
	234	else version( Posix )
	235	{
	236	if( name[i - 1] == '/' )
	237	break;
	238	}
	239	}
	240	return chomp( name[i .. $], ext ? ext : "" );
	241	}
	242
	243
	244	char[] getExt( char[] name )
	245	{
	246	auto i = name.length;
	247
	248	while( i > 0 )
	249	{
	250	if( name[i - 1] == '.' )
	251	return name[i .. $];
	252	--i;
	253	version( Windows )
	254	{
	255	if( name[i] == ':' \|\| name[i] == '\\' )
	256	break;
	257	}
	258	else version( Posix )
	259	{
	260	if( name[i] == '/' )
	261	break;
	262	}
	263	}
	264	return null;
	265	}
	266
	267
	268	char[] addExt( char[] name, char[] ext )
	269	{
	270	auto existing = getExt( name );
	271
	272	if( existing.length == 0 )
	273	{
	274	if( name.length && name[$ - 1] == '.' )
	275	name ~= ext;
	276	else
	277	name = name ~ "." ~ ext;
	278	}
	279	else
	280	{
	281	name = name[0 .. $ - existing.length] ~ ext;
	282	}
	283	return name;
	284	}
	285
	286
	287	char[] chomp( char[] str, char[] delim = null )
	288	{
	289	if( delim is null )
	290	{
	291	auto len = str.length;
	292
	293	if( len )
	294	{
	295	auto c = str[len - 1];
	296
	297	if( c == '\r' )
	298	--len;
	299	else if( c == '\n' && str[--len - 1] == '\r' )
	300	--len;
	301	}
	302	return str[0 .. len];
	303	}
	304	else if( str.length >= delim.length )
	305	{
	306	if( str[$ - delim.length .. $] == delim )
	307	return str[0 .. $ - delim.length];
	308	}
	309	return str;
215	310	}
216	311
…	…
250	345	return true;
251	346	}
252		else version( ~~linu~~x )
	347	else version( Posix )
253	348	{
254	349	char[] namez = new char[name.length + 1];
…	…
311	406
312	407
313		char[] expandTabs( char[] str~~ing~~, int tabsize = 8 )
	408	char[] expandTabs( char[] str, int tabsize = 8 )
314	409	{
315	410	const dchar LS = '\u2028'; // UTF line separator
…	…
317	412
318	413	bool changes = false;
319		char[] result = str~~ing~~;
	414	char[] result = str;
320	415	int column;
321	416	int nspaces;
322	417
323		foreach( size_t i, dchar c; str~~ing~~ )
	418	foreach( size_t i, dchar c; str )
324	419	{
325	420	switch( c )
…	…
331	426	changes = true;
332	427	result = null;
333		result.length = str~~ing~~.length + nspaces - 1;
	428	result.length = str.length + nspaces - 1;
334	429	result.length = i + nspaces;
335		result[0 .. i] = str~~ing~~[0 .. i];
	430	result[0 .. i] = str[0 .. i];
336	431	result[i .. i + nspaces] = ' ';
337	432	}

trunk/lib/compiler/dmd/rt/critical.c

r4357	r4384
9	9	#if _WIN32
10	10
11		#include <windows.h>
	11	#include <windows.h>
12	12
13	13	/******************************************
…	…
34	34	if (!dcs->next)
35	35	{
36		EnterCriticalSection(&critical_section.cs);
37		~~if (!dcs->next)~~ // if, in the meantime, another thread didn't set it
38		{
39		dcs->next = dcs_list;
40		dcs_list = dcs;
41		InitializeCriticalSection(&dcs->cs);
42		}
43		LeaveCriticalSection(&critical_section.cs);
	36	EnterCriticalSection(&critical_section.cs);
	37	if (!dcs->next) // if, in the meantime, another thread didn't set it
	38	{
	39	dcs->next = dcs_list;
	40	dcs_list = dcs;
	41	InitializeCriticalSection(&dcs->cs);
	42	}
	43	LeaveCriticalSection(&critical_section.cs);
44	44	}
45	45	EnterCriticalSection(&dcs->cs);
…	…
54	54	{
55	55	if (!inited)
56		{ InitializeCriticalSection(&critical_section.cs);
57		dcs_list = &critical_section;
58		inited = 1;
	56	{ InitializeCriticalSection(&critical_section.cs);
	57	dcs_list = &critical_section;
	58	inited = 1;
59	59	}
60	60	}
…	…
63	63	{
64	64	if (inited)
65		{ inited = 0;
66		while (dcs_list)
67		{
68		DeleteCriticalSection(&dcs_list->cs);
69		dcs_list = dcs_list->next;
70		}
	65	{ inited = 0;
	66	while (dcs_list)
	67	{
	68	DeleteCriticalSection(&dcs_list->cs);
	69	dcs_list = dcs_list->next;
	70	}
71	71	}
72	72	}
…	…
76	76	/* ================================= linux ============================ */
77	77
78		#if linux
	78	#if linux \|\| __APPLE__
79	79
80		#include <stdio.h>
81		#include <stdlib.h>
82		#include <pthread.h>
	80	#include <stdio.h>
	81	#include <stdlib.h>
	82	#include <pthread.h>
	83
	84	// PTHREAD_MUTEX_RECURSIVE is what posix says should be supported,
	85	// but some versions of glibc have only PTHREAD_MUTEX_RECURSIVE_NP
	86	// (the np stands for non-portable), when they have the same meaning.
	87	#ifndef PTHREAD_MUTEX_RECURSIVE
	88	#define PTHREAD_MUTEX_RECURSIVE PTHREAD_MUTEX_RECURSIVE_NP
	89	#endif
83	90
84	91	/******************************************
…	…
107	114	{
108	115	if (!dcs_list)
109		{ _STI_critical_init();
110		atexit(_STD_critical_term);
	116	{ _STI_critical_init();
	117	atexit(_STD_critical_term);
111	118	}
112	119	//printf("_d_criticalenter(dcs = x%x)\n", dcs);
113	120	if (!dcs->next)
114	121	{
115		pthread_mutex_lock(&critical_section.cs);
116		~~if (!dcs->next)~~ // if, in the meantime, another thread didn't set it
117		{
118		dcs->next = dcs_list;
119		dcs_list = dcs;
120		pthread_mutex_init(&dcs->cs, &_criticals_attr);
121		}
122		pthread_mutex_unlock(&critical_section.cs);
	122	pthread_mutex_lock(&critical_section.cs);
	123	if (!dcs->next) // if, in the meantime, another thread didn't set it
	124	{
	125	dcs->next = dcs_list;
	126	dcs_list = dcs;
	127	pthread_mutex_init(&dcs->cs, &_criticals_attr);
	128	}
	129	pthread_mutex_unlock(&critical_section.cs);
123	130	}
124	131	pthread_mutex_lock(&dcs->cs);
…	…
134	141	{
135	142	if (!dcs_list)
136		{ //printf("_STI_critical_init()\n");
137		pthread_mutexattr_init(&_criticals_attr);
138		~~pthread_mutexattr_settype(&_criticals_attr, PTHREAD_MUTEX_RECURSIVE_NP~~);
	143	{ //printf("_STI_critical_init()\n");
	144	pthread_mutexattr_init(&_criticals_attr);
	145	pthread_mutexattr_settype(&_criticals_attr, PTHREAD_MUTEX_RECURSIVE);
139	146
140		// The global critical section doesn't need to be recursive
141		pthread_mutex_init(&critical_section.cs, 0);
142		dcs_list = &critical_section;
	147	// The global critical section doesn't need to be recursive
	148	pthread_mutex_init(&critical_section.cs, 0);
	149	dcs_list = &critical_section;
143	150	}
144	151	}
…	…
147	154	{
148	155	if (dcs_list)
149		{ //printf("_STI_critical_term()\n");
150		while (dcs_list)
151		{
152		//printf("\tlooping... %x\n", dcs_list);
153		pthread_mutex_destroy(&dcs_list->cs);
154		dcs_list = dcs_list->next;
155		}
	156	{ //printf("_STI_critical_term()\n");
	157	while (dcs_list)
	158	{
	159	//printf("\tlooping... %x\n", dcs_list);
	160	pthread_mutex_destroy(&dcs_list->cs);
	161	dcs_list = dcs_list->next;
	162	}
156	163	}
157	164	}
158	165
159	166	#endif
160

trunk/lib/compiler/dmd/rt/deh.c

r4357	r4384
156	156
157	157	if (_d_isbaseof(ci, pcb->type))
158		{ // Matched the catch type, so we've found the handler.
	158	{
	159	// Matched the catch type, so we've found the handler.
159	160	int regebp;
160	161
…	…
410	411	/* ======================== linux =============================== */
411	412
412		#if linux
	413	#if linux \|\| __APPLE__
413	414
414	415	#include "mars.h"

trunk/lib/compiler/dmd/rt/deh2.d

r4357	r4384
22	22	*/
23	23
	24	module rt.deh2;
	25
24	26	// Exception handling support for linux
25	27
26	28	//debug=1;
	29	debug import tango.stdc.stdio: printf;
	30	import tango.stdc.stdio: printf;
	31	import tango.stdc.stdlib: exit;
27	32
28	33	extern (C)
…	…
188	193	{ // if end of call chain
189	194	debug printf("end of call chain\n");
	195	printf("unhandled exception\n");
	196	exit(1);
190	197	break;
191	198	}
…	…
291	298	void *blockaddr = phi.finally_code;
292	299
293		~~asm~~
	300	version (OSX)
294	301	{
295		push EBX ;
296		mov EBX,blockaddr ;
297		push EBP ;
298		mov EBP,regebp ;
299		call EBX ;
300		pop EBP ;
301		pop EBX ;
	302	asm {
	303	sub ESP,4 ;
	304	push EBX ;
	305	mov EBX,blockaddr ;
	306	push EBP ;
	307	mov EBP,regebp ;
	308	call EBX ;
	309	pop EBP ;
	310	pop EBX ;
	311	add ESP,4 ;
	312	}
	313	} else {
	314	asm {
	315	push EBX ;
	316	mov EBX,blockaddr ;
	317	push EBP ;
	318	mov EBP,regebp ;
	319	call EBX ;
	320	pop EBP ;
	321	pop EBX ;
	322	}
302	323	}
303	324	}
…	…
305	326	}
306	327	}
307

trunk/lib/compiler/dmd/rt/dmain2.d

r4357	r4384
9	9	*/
10	10
	11	module rt.dmain2;
	12
11	13	private
12	14	{
13		import util.console;
	15	import rt.util.console;
14	16
15	17	import tango.stdc.stddef;
16	18	import tango.stdc.stdlib;
17	19	import tango.stdc.string;
	20	extern(C) int printf(char*,...);
18	21	}
19	22
…	…
86	89	void _d_criticalInit()
87	90	{
88		version (~~linu~~x)
	91	version (Posix)
89	92	{
90	93	_STI_monitor_staticctor();
…	…
122	125	void _d_criticalTerm()
123	126	{
124		version (~~linu~~x)
	127	version (Posix)
125	128	{
126	129	_STD_critical_term();
…	…
155	158	}
156	159
	160	version (OSX)
	161	{
	162	// The bottom of the stack
	163	extern (C) void* __osx_stack_end = cast(void*)0xC0000000;
	164	}
	165
157	166	/***********************************
158	167	* The D main() function supplied by the user's program
…	…
171	180	int result;
172	181
173		version (linux)
	182	version (OSX)
	183	{/* OSX does not provide a way to get at the top of the
	184	* stack, except for the magic value 0xC0000000.
	185	* But as far as the gc is concerned, argv is at the top
	186	* of the main thread's stack, so save the address of that.
	187	*/
	188	__osx_stack_end = cast(void*)&argv;
	189	}
	190	version (Posix)
174	191	{
175	192	_STI_monitor_staticctor();
…	…
203	220	wargc = 0;
204	221	}
205		else version (~~linu~~x)
	222	else version (Posix)
206	223	{
207	224	char[]* am = cast(char[]) malloc(argc (char[]).sizeof);
…	…
229	246	catch (Exception e)
230	247	{
	248	printf("pippoException\n");
231	249	while (e)
232	250	{
…	…
255	273	catch (Object o)
256	274	{
257		// fprintf(stderr, "%.*s\n", o.toString());
	275	printf("pippoException\n");
	276	//fprintf(stderr, "%.*s\n", o.toString());
258	277	console (o.toString)("\n");
259	278	result = EXIT_FAILURE;
…	…
296	315	tryExec(&runAll);
297	316
298		version (~~linu~~x)
	317	version (Posix)
299	318	{
300	319	_STD_critical_term();

trunk/lib/compiler/dmd/rt/lifetime.d

r4357	r4384
25	25	* Authors: Walter Bright, Sean Kelly
26	26	*/
27		module lifetime;
	27	module rt.lifetime;
28	28
29	29

trunk/lib/compiler/dmd/rt/llmath.d

r4357	r4384
1	1	// llmath.d
2		// Copyright (C) 1993-200~~3 by Digital Mars,~~ www.digitalmars.com
	2	// Copyright (C) 1993-2008 by Digital Mars, http://www.digitalmars.com
3	3	// All Rights Reserved
4	4	// Written by Walter Bright
5	5
6	6	// Compiler runtime support for 64 bit longs
	7
	8	module rt.llmath;
7	9
8	10	extern (C):
…	…
12	14	* Unsigned long divide.
13	15	* Input:
14		* [EDX,EAX],[ECX,EBX]
	16	* [EDX,EAX],[ECX,EBX]
15	17	* Output:
16		* [EDX,EAX] = [EDX,EAX] / [ECX,EBX]
17		* [ECX,EBX] = [EDX,EAX] % [ECX,EBX]
18		* ESI,EDI destroyed
	18	* [EDX,EAX] = [EDX,EAX] / [ECX,EBX]
	19	* [ECX,EBX] = [EDX,EAX] % [ECX,EBX]
19	20	*/
20	21
…	…
23	24	asm
24	25	{
25		naked ;
26		test ECX,ECX ;
27		jz uldiv ;
28
29		push EBP ;
30
31		// left justify [ECX,EBX] and leave count of shifts + 1 in EBP
32
33		mov EBP,1 ; // at least 1 shift
34		test ECX,ECX ; // left justified?
35		js L1 ; // yes
36		jnz L2 ;
37		add EBP,8 ;
38		mov CH,CL ;
39		mov CL,BH ;
40		mov BH,BL ;
41		xor BL,BL ; // [ECX,EBX] <<= 8
42		test ECX,ECX ;
43		js L1 ;
44		even ;
45		L2: inc EBP ; // another shift
46		shl EBX,1 ;
47		rcl ECX,1 ; // [ECX,EBX] <<= 1
48		jno L2 ; // not left justified yet
49
50		L1: mov ESI,ECX ;
51		mov EDI,EBX ; // [ESI,EDI] = divisor
52
53		mov ECX,EDX ;
54		mov EBX,EAX ; // [ECX,EBX] = [EDX,EAX]
55		xor EAX,EAX ;
56		cdq ; // [EDX,EAX] = 0
57		even ;
58		L4: cmp ESI,ECX ; // is [ECX,EBX] > [ESI,EDI]?
59		ja L3 ; // yes
60		jb L5 ; // definitely less than
61		cmp EDI,EBX ; // check low order word
62		ja L3 ;
63		L5: sub EBX,EDI ;
64		sbb ECX,ESI ; // [ECX,EBX] -= [ESI,EDI]
65		stc ; // rotate in a 1
66		L3: rcl EAX,1 ;
67		rcl EDX,1 ; // [EDX,EAX] = ([EDX,EAX] << 1) + C
68		shr ESI,1 ;
69		rcr EDI,1 ; // [ESI,EDI] >>= 1
70		dec EBP ; // control count
71		jne L4 ;
72		pop EBP ;
73		ret ;
74
75		div0: mov EAX,-1 ;
76		cwd ; // quotient is -1
77		// xor ECX,ECX ;
78		// mov EBX,ECX ; // remainder is 0 (ECX and EBX already 0)
79		pop EBP ;
80		ret ;
81
82		uldiv: test EDX,EDX ;
83		jnz D3 ;
84		// Both high words are 0, we can use the DIV instruction
85		div EBX ;
86		mov EBX,EDX ;
87		mov EDX,ECX ; // EDX = ECX = 0
88		ret ;
89
90		even ;
91		D3: // Divide [EDX,EAX] by EBX
92		mov ECX,EAX ;
93		mov EAX,EDX ;
94		xor EDX,EDX ;
95		div EBX ;
96		xchg ECX,EAX ;
97		div EBX ;
98		// ECX,EAX = result
99		// EDX = remainder
100		mov EBX,EDX ;
101		mov EDX,ECX ;
102		xor ECX,ECX ;
103		ret ;
	26	naked ;
	27	test ECX,ECX ;
	28	jz uldiv ;
	29
	30	// if ECX > EDX, then quotient is 0 and remainder is [EDX,EAX]
	31	cmp ECX,EDX ;
	32	ja quo0 ;
	33
	34	test ECX,ECX ;
	35	js Lleft ;
	36
	37	/* We have n>d, and know that n/d will fit in 32 bits.
	38	* d will be left justified if we shift it left s bits.
	39	* [d1,d0] <<= s
	40	* [n2,n1,n0] = [n1,n0] << s
	41	*
	42	* Use one divide, by this reasoning:
	43	* ([n2,n1]<<32 + n0)/(d1<<32 + d0)
	44	* becomes:
	45	* ([n2,n1]<<32)/(d1<<32 + d0) + n0/(d1<<32 + d0)
	46	* The second divide is always 0.
	47	* Ignore the d0 in the first divide, which will yield a quotient
	48	* that might be too high by 1 (because d1 is left justified).
	49	* We can tell if it's too big if:
	50	* q*[d1,d0] > [n2,n1,n0]
	51	* which is:
	52	* q[d1,d0] > [[q[d1,0]+q%[d1,0],n1,n0]
	53	* If we subtract q*[d1,0] from both sides, we get:
	54	* q*d0 > [[n2,n1]%d1,n0]
	55	* So if it is too big by one, reduce q by one to q'=q-one.
	56	* Compute remainder as:
	57	* r = ([n1,n0] - q'*[d1,d0]) >> s
	58	* Again, we can subtract q*[d1,0]:
	59	* r = ([n1,n0] - q[d1,0] - (q'[d1,d0] - q*[d1,0])) >> s
	60	* r = ([[n2,n1]%d1,n0] + (q[d1,0] - (q - one)[d1,d0])) >> s
	61	* r = ([[n2,n1]%d1,n0] + (q[d1,0] - [d1 (q-one),d0*(1-q)])) >> s
	62	* r = ([[n2,n1]%d1,n0] + [d1 one,d0(one-q)])) >> s
	63	*/
	64
	65	push EBP ;
	66	push ESI ;
	67	push EDI ;
	68
	69	mov ESI,EDX ;
	70	mov EDI,EAX ;
	71	mov EBP,ECX ;
	72
	73	bsr EAX,ECX ; // EAX is now 30..0
	74	xor EAX,0x1F ; // EAX is now 1..31
	75	mov CH,AL ;
	76	neg EAX ;
	77	add EAX,32 ;
	78	mov CL,AL ;
	79
	80	mov EAX,EBX ;
	81	shr EAX,CL ;
	82	xchg CH,CL ;
	83	shl EBP,CL ;
	84	or EBP,EAX ;
	85	shl EBX,CL ;
	86
	87	mov EDX,ESI ;
	88	xchg CH,CL ;
	89	shr EDX,CL ;
	90
	91	mov EAX,EDI ;
	92	shr EAX,CL ;
	93	xchg CH,CL ;
	94	shl EDI,CL ;
	95	shl ESI,CL ;
	96	or EAX,ESI ;
	97
	98	div EBP ;
	99	push EBP ;
	100	mov EBP,EAX ;
	101	mov ESI,EDX ;
	102
	103	mul EBX ;
	104	cmp EDX,ESI ;
	105	ja L1 ;
	106	jb L2 ;
	107	cmp EAX,EDI ;
	108	jbe L2 ;
	109	L1: dec EBP ;
	110	sub EAX,EBX ;
	111	sbb EDX,0[ESP] ;
	112	L2:
	113	add ESP,4 ;
	114	sub EDI,EAX ;
	115	sbb ESI,EDX ;
	116	mov EAX,ESI ;
	117	xchg CH,CL ;
	118	shl EAX,CL ;
	119	xchg CH,CL ;
	120	shr EDI,CL ;
	121	or EDI,EAX ;
	122	shr ESI,CL ;
	123	mov EBX,EDI ;
	124	mov ECX,ESI ;
	125	mov EAX,EBP ;
	126	xor EDX,EDX ;
	127
	128	pop EDI ;
	129	pop ESI ;
	130	pop EBP ;
	131	ret ;
	132
	133	uldiv: test EDX,EDX ;
	134	jnz D3 ;
	135	// Both high words are 0, we can use the DIV instruction
	136	div EBX ;
	137	mov EBX,EDX ;
	138	mov EDX,ECX ; // EDX = ECX = 0
	139	ret ;
	140
	141	even ;
	142	D3: // Divide [EDX,EAX] by EBX
	143	mov ECX,EAX ;
	144	mov EAX,EDX ;
	145	xor EDX,EDX ;
	146	div EBX ;
	147	xchg ECX,EAX ;
	148	div EBX ;
	149	// ECX,EAX = result
	150	// EDX = remainder
	151	mov EBX,EDX ;
	152	mov EDX,ECX ;
	153	xor ECX,ECX ;
	154	ret ;
	155
	156	quo0: // Quotient is 0
	157	// Remainder is [EDX,EAX]
	158	mov EBX,EAX ;
	159	mov ECX,EDX ;
	160	xor EAX,EAX ;
	161	xor EDX,EDX ;
	162	ret ;
	163
	164	Lleft: // The quotient is 0 or 1 and EDX >= ECX
	165	cmp EDX,ECX ;
	166	ja quo1 ; // [EDX,EAX] > [ECX,EBX]
	167	// EDX == ECX
	168	cmp EAX,EBX ;
	169	jb quo0 ;
	170
	171	quo1: // Quotient is 1
	172	// Remainder is [EDX,EAX] - [ECX,EBX]
	173	sub EAX,EBX ;
	174	sbb EDX,ECX ;
	175	mov EBX,EAX ;
	176	mov ECX,EDX ;
	177	mov EAX,1 ;
	178	xor EDX,EDX ;
	179	ret ;
104	180	}
105	181	}
…	…
109	185	* Signed long divide.
110	186	* Input:
111		* [EDX,EAX],[ECX,EBX]
	187	* [EDX,EAX],[ECX,EBX]
112	188	* Output:
113		* [EDX,EAX] = [EDX,EAX] / [ECX,EBX]
114		* [ECX,EBX] = [EDX,EAX] % [ECX,EBX]
115		* ~~ESI,EDI~~ destroyed
	189	* [EDX,EAX] = [EDX,EAX] / [ECX,EBX]
	190	* [ECX,EBX] = [EDX,EAX] % [ECX,EBX]
	191	* ESI,EDI destroyed
116	192	*/
117	193
…	…
120	196	asm
121	197	{
122		~~naked~~ ;
123		~~test EDX,EDX ;~~ // [EDX,EAX] negative?
124		~~jns L10 ;~~ // no
125		~~//neg64 EDX,EAX ;~~ // [EDX,EAX] = -[EDX,EAX]
126		~~neg EDX~~ ;
127		~~neg EAX~~ ;
128		~~sbb EDX,0~~ ;
129		~~test ECX,ECX ;~~ // [ECX,EBX] negative?
130		~~jns L11 ;~~ // no
131		~~//neg64 ECX,EBX~~ ;
132		~~neg ECX~~ ;
133		~~neg EBX~~ ;
134		~~sbb ECX,0~~ ;
135		~~call __ULDIV__~~ ;
136		~~//neg64 ECX,EBX ;~~ // remainder same sign as dividend
137		~~neg ECX~~ ;
138		~~neg EBX~~ ;
139		~~sbb ECX,0~~ ;
140		~~ret~~ ;
141
142		L11: ~~call __ULDIV__~~ ;
143		~~//neg64 ECX,EBX ;~~ // remainder same sign as dividend
144		~~neg ECX~~ ;
145		~~neg EBX~~ ;
146		~~sbb ECX,0~~ ;
147		~~//neg64 EDX,EAX ;~~ // quotient is negative
148		~~neg EDX~~ ;
149		~~neg EAX~~ ;
150		~~sbb EDX,0~~ ;
151		~~ret~~ ;
152
153		L10: ~~test ECX,ECX ;~~ // [ECX,EBX] negative?
154		~~jns L12 ;~~ // no (all is positive)
155		~~//neg64 ECX,EBX~~ ;
156		~~neg ECX~~ ;
157		~~neg EBX~~ ;
158		~~sbb ECX,0~~ ;
159		~~call __ULDIV__~~ ;
160		~~//neg64 EDX,EAX ;~~ // quotient is negative
161		~~neg EDX~~ ;
162		~~neg EAX~~ ;
163		~~sbb EDX,0~~ ;
164		~~ret~~ ;
165
166		L12: ~~jmp __ULDIV__~~ ;
	198	naked ;
	199	test EDX,EDX ; // [EDX,EAX] negative?
	200	jns L10 ; // no
	201	//neg64 EDX,EAX ; // [EDX,EAX] = -[EDX,EAX]
	202	neg EDX ;
	203	neg EAX ;
	204	sbb EDX,0 ;
	205	test ECX,ECX ; // [ECX,EBX] negative?
	206	jns L11 ; // no
	207	//neg64 ECX,EBX ;
	208	neg ECX ;
	209	neg EBX ;
	210	sbb ECX,0 ;
	211	call __ULDIV__ ;
	212	//neg64 ECX,EBX ; // remainder same sign as dividend
	213	neg ECX ;
	214	neg EBX ;
	215	sbb ECX,0 ;
	216	ret ;
	217
	218	L11: call __ULDIV__ ;
	219	//neg64 ECX,EBX ; // remainder same sign as dividend
	220	neg ECX ;
	221	neg EBX ;
	222	sbb ECX,0 ;
	223	//neg64 EDX,EAX ; // quotient is negative
	224	neg EDX ;
	225	neg EAX ;
	226	sbb EDX,0 ;
	227	ret ;
	228
	229	L10: test ECX,ECX ; // [ECX,EBX] negative?
	230	jns L12 ; // no (all is positive)
	231	//neg64 ECX,EBX ;
	232	neg ECX ;
	233	neg EBX ;
	234	sbb ECX,0 ;
	235	call __ULDIV__ ;
	236	//neg64 EDX,EAX ; // quotient is negative
	237	neg EDX ;
	238	neg EAX ;
	239	sbb EDX,0 ;
	240	ret ;
	241
	242	L12: jmp __ULDIV__ ;
167	243	}
168	244	}
…	…
179	255	asm
180	256	{
181		~~naked~~ ;
182		~~cmp EDX,ECX~~ ;
183		~~jne C1~~ ;
184		~~push EDX~~ ;
185		~~xor EDX,EDX~~ ;
186		~~cmp EAX,EBX~~ ;
187		~~jz C2~~ ;
188		~~ja C3~~ ;
189		~~dec EDX~~ ;
190		~~pop EDX~~ ;
191		~~ret~~ ;
192
193		C3: ~~inc EDX~~ ;
194		C2: ~~pop EDX~~ ;
195		C1: ~~ret~~ ;
	257	naked ;
	258	cmp EDX,ECX ;
	259	jne C1 ;
	260	push EDX ;
	261	xor EDX,EDX ;
	262	cmp EAX,EBX ;
	263	jz C2 ;
	264	ja C3 ;
	265	dec EDX ;
	266	pop EDX ;
	267	ret ;
	268
	269	C3: inc EDX ;
	270	C2: pop EDX ;
	271	C1: ret ;
196	272	}
197	273	}
…	…
206	282	real __U64_LDBL()
207	283	{
208		asm
209		{ naked ;
210		push EDX ;
211		push EAX ;
212		and dword ptr 4[ESP], 0x7FFFFFFF ;
213		fild qword ptr [ESP] ;
214		test EDX,EDX ;
215		jns L1 ;
216		fld real ptr adjust ;
217		faddp ST(1), ST ;
218		L1: ;
219		add ESP, 8 ;
220		ret ;
	284	version (OSX) {
	285	asm
	286	{ naked ;
	287	push EDX ;
	288	push EAX ;
	289	and dword ptr 4[ESP], 0x7FFFFFFF ;
	290	fild qword ptr [ESP] ;
	291	test EDX,EDX ;
	292	jns L1 ;
	293	push 0x0000403e ;
	294	push 0x80000000 ;
	295	push 0 ;
	296	fld real ptr [ESP] ; // adjust
	297	add ESP,12 ;
	298	faddp ST(1), ST ;
	299	L1: ;
	300	add ESP, 8 ;
	301	ret ;
	302	}
	303	} else {
	304	asm
	305	{ naked ;
	306	push EDX ;
	307	push EAX ;
	308	and dword ptr 4[ESP], 0x7FFFFFFF ;
	309	fild qword ptr [ESP] ;
	310	test EDX,EDX ;
	311	jns L1 ;
	312	fld real ptr adjust ;
	313	faddp ST(1), ST ;
	314	L1: ;
	315	add ESP, 8 ;
	316	ret ;
	317	}
221	318	}
222	319	}
…	…
226	323	{
227	324	asm
228		{ ~~naked~~ ;
229		~~call __U64_LDBL~~ ;
230		~~sub ESP,8~~ ;
231		~~fstp double ptr [ESP]~~ ;
232		~~pop EAX~~ ;
233		~~pop EDX~~ ;
234		~~ret~~ ;
	325	{ naked ;
	326	call __U64_LDBL ;
	327	sub ESP,8 ;
	328	fstp double ptr [ESP] ;
	329	pop EAX ;
	330	pop EDX ;
	331	ret ;
235	332	}
236	333	}
…	…
243	340	{
244	341	// BUG: should handle NAN's and overflows
	342	version (OSX) {
	343	asm {
	344	naked ;
	345	push 0xFBF ; // roundTo0
	346	push 0x0000403e ;
	347	push 0x80000000 ;
	348	push 0 ; // adjust
	349	push EDX ;
	350	push EAX ;
	351	fld double ptr [ESP] ;
	352	sub ESP,8 ;
	353	fld real ptr 16[ESP] ; // adjust
	354	fcomp ;
	355	fstsw AX ;
	356	fstcw 8[ESP] ;
	357	fldcw 28[ESP] ; // roundTo0
	358	sahf ;
	359	jae L1 ;
	360	fld real ptr 16[ESP] ; // adjust
	361	fsubp ST(1), ST ;
	362	fistp qword ptr [ESP] ;
	363	pop EAX ;
	364	pop EDX ;
	365	fldcw [ESP] ;
	366	add ESP,24 ;
	367	add EDX,0x8000_0000 ;
	368	ret ;
	369	L1: ;
	370	fistp qword ptr [ESP] ;
	371	pop EAX ;
	372	pop EDX ;
	373	fldcw [ESP] ;
	374	add ESP,24 ;
	375	ret ;
	376	}
	377	} else {
	378	asm
	379	{ naked ;
	380	push EDX ;
	381	push EAX ;
	382	fld double ptr [ESP] ;
	383	sub ESP,8 ;
	384	fld real ptr adjust ;
	385	fcomp ;
	386	fstsw AX ;
	387	fstcw 8[ESP] ;
	388	fldcw roundTo0 ;
	389	sahf ;
	390	jae L1 ;
	391	fld real ptr adjust ;
	392	fsubp ST(1), ST ;
	393	fistp qword ptr [ESP] ;
	394	pop EAX ;
	395	pop EDX ;
	396	fldcw [ESP] ;
	397	add ESP,8 ;
	398	add EDX,0x8000_0000 ;
	399	ret ;
	400	L1: ;
	401	fistp qword ptr [ESP] ;
	402	pop EAX ;
	403	pop EDX ;
	404	fldcw [ESP] ;
	405	add ESP,8 ;
	406	ret ;
	407	}
	408	}
	409	}
	410
	411	// Convert double in ST0 to uint
	412
	413	uint __DBLULNG()
	414	{
	415	// BUG: should handle NAN's and overflows
	416	version (OSX) {
	417	asm {
	418	naked ;
	419	push 0xFBF ; // roundTo0
	420	sub ESP,12 ;
	421	fstcw 8[ESP] ;
	422	fldcw 12[ESP] ; // roundTo0
	423	fistp qword ptr [ESP] ;
	424	fldcw 8[ESP] ;
	425	pop EAX ;
	426	add ESP,12 ;
	427	ret ;
	428	}
	429	} else {
	430	asm {
	431	naked ;
	432	sub ESP,16 ;
	433	fstcw 8[ESP] ;
	434	fldcw roundTo0 ;
	435	fistp qword ptr [ESP] ;
	436	fldcw 8[ESP] ;
	437	pop EAX ;
	438	add ESP,12 ;
	439	ret ;
	440	}
	441	}
	442	}
	443
	444
	445	// Convert real in ST0 to ulong
	446
	447	ulong __LDBLULLNG()
	448	{
	449	version (OSX)
	450	{
245	451	asm
246		{ naked ;
247		push EDX ;
248		push EAX ;
249		fld double ptr [ESP] ;
250		sub ESP,8 ;
251		fld real ptr adjust ;
252		fcomp ;
253		fstsw AX ;
254		fstcw 8[ESP] ;
255		fldcw roundTo0 ;
256		sahf ;
257		jae L1 ;
258		fld real ptr adjust ;
259		fsubp ST(1), ST ;
260		fistp qword ptr [ESP] ;
261		pop EAX ;
262		pop EDX ;
263		fldcw [ESP] ;
264		add ESP,8 ;
265		add EDX,0x8000_0000 ;
266		ret ;
267		L1: ;
268		fistp qword ptr [ESP] ;
269		pop EAX ;
270		pop EDX ;
271		fldcw [ESP] ;
272		add ESP,8 ;
273		ret ;
274		}
275		}
276
277		// Convert double in ST0 to uint
278
279		uint __DBLULNG()
280		{
281		// BUG: should handle NAN's and overflows
	452	{ naked ;
	453	push 0xFBF ; // roundTo0
	454	push 0x0000403e ;
	455	push 0x80000000 ;
	456	push 0 ; // adjust
	457	sub ESP,16 ;
	458	fld real ptr 16[ESP] ; // adjust
	459	fcomp ;
	460	fstsw AX ;
	461	fstcw 8[ESP] ;
	462	fldcw 28[ESP] ; // roundTo0
	463	sahf ;
	464	jae L1 ;
	465	fld real ptr 16[ESP] ; // adjust
	466	fsubp ST(1), ST ;
	467	fistp qword ptr [ESP] ;
	468	pop EAX ;
	469	pop EDX ;
	470	fldcw [ESP] ;
	471	add ESP,24 ;
	472	add EDX,0x8000_0000 ;
	473	ret ;
	474	L1: ;
	475	fistp qword ptr [ESP] ;
	476	pop EAX ;
	477	pop EDX ;
	478	fldcw [ESP] ;
	479	add ESP,24 ;
	480	ret ;
	481	}
	482	}
	483	else
	484	{
282	485	asm
283		{ naked ;
284		sub ESP,16 ;
285		fstcw 8[ESP] ;
286		fldcw roundTo0 ;
287		fistp qword ptr [ESP] ;
288		fldcw 8[ESP] ;
289		pop EAX ;
290		add ESP,12 ;
291		ret ;
292		}
293		}
	486	{ naked ;
	487	sub ESP,16 ;
	488	fld real ptr adjust ;
	489	fcomp ;
	490	fstsw AX ;
	491	fstcw 8[ESP] ;
	492	fldcw roundTo0 ;
	493	sahf ;
	494	jae L1 ;
	495	fld real ptr adjust ;
	496	fsubp ST(1), ST ;
	497	fistp qword ptr [ESP] ;
	498	pop EAX ;
	499	pop EDX ;
	500	fldcw [ESP] ;
	501	add ESP,8 ;
	502	add EDX,0x8000_0000 ;
	503	ret ;
	504	L1: ;
	505	fistp qword ptr [ESP] ;
	506	pop EAX ;
	507	pop EDX ;
	508	fldcw [ESP] ;
	509	add ESP,8 ;
	510	ret ;
	511	}
	512	}
	513	}
	514

trunk/lib/compiler/dmd/rt/mars.h

r4357	r4384
103	103	}
104	104	#endif
105

trunk/lib/compiler/dmd/rt/memory.d

r4357	r4384
24	24	* Authors: Walter Bright, Sean Kelly
25	25	*/
26		module memory;
	26	module rt.memory;
27	27
28	28
…	…
36	36	{
37	37	extern (C) extern void* __libc_stack_end;
	38	}
	39	}
	40	version (OSX)
	41	{
	42	extern (C)
	43	{
	44	extern void* __osx_stack_end; // set by D startup code
38	45	}
39	46	}
…	…
57	64	else version( linux )
58	65	{
59		version( SimpleLibcStackEnd )
60		{
	66	version( SimpleLibcStackEnd ) {
61	67	return __libc_stack_end;
62		}
63		else
64		{
	68	} else {
65	69	// See discussion: http://autopackage.org/forums/viewtopic.php?t=22
66	70	static void** libc_stack_end;
…	…
74	78	return *libc_stack_end;
75	79	}
76		}
77		~~else~~
78		{
	80	} else version (darwin) {
	81	return __osx_stack_end;
	82	} else {
79	83	static assert( false, "Operating system not supported." );
80	84	}
…	…
149	153	scan( &__data_start, &_end );
150	154	}
	155	else version( darwin ){
	156	// already ranges already added through osxgc.c functions
	157	}
151	158	else
152	159	{

trunk/lib/compiler/dmd/rt/memset.d

r4357	r4384
21	21	* distribution.
22	22	*/
	23	module rt.memset;
23	24
24	25
…	…
37	38
38	39	for (ptop = &p[count]; p < ptop; p++)
39		*p = value;
	40	*p = value;
40	41	return pstart;
41	42	}
…	…
47	48	asm
48	49	{
49		~~mov EDI,p~~ ;
50		~~mov EAX,value~~ ;
51		~~mov ECX,count~~ ;
52		~~mov EDX,EDI~~ ;
53		~~rep~~ ;
54		~~stosd~~ ;
55		~~mov EAX,EDX~~ ;
	50	mov EDI,p ;
	51	mov EAX,value ;
	52	mov ECX,count ;
	53	mov EDX,EDI ;
	54	rep ;
	55	stosd ;
	56	mov EAX,EDX ;
56	57	}
57	58	}
…	…
62	63
63	64	for (ptop = &p[count]; p < ptop; p++)
64		*p = value;
	65	*p = value;
65	66	return pstart;
66	67	}
…	…
73	74
74	75	for (ptop = &p[count]; p < ptop; p++)
75		*p = value;
	76	*p = value;
76	77	return pstart;
77	78	}
…	…
83	84
84	85	for (ptop = &p[count]; p < ptop; p++)
85		*p = value;
	86	*p = value;
86	87	return pstart;
87	88	}
…	…
93	94
94	95	for (ptop = &p[count]; p < ptop; p++)
95		*p = value;
	96	*p = value;
96	97	return pstart;
97	98	}
…	…
103	104
104	105	for (ptop = &p[count]; p < ptop; p++)
105		*p = value;
	106	*p = value;
106	107	return pstart;
107	108	}
…	…
113	114	for (i = 0; i < count; i++)
114	115	{
115		memcpy(p, value, sizelem);
116		p = cast(void )(cast(char )p + sizelem);
	116	memcpy(p, value, sizelem);
	117	p = cast(void )(cast(char )p + sizelem);
117	118	}
118	119	return pstart;

trunk/lib/compiler/dmd/rt/monitor.c

r4357	r4384
13	13
14	14	#if _WIN32
15		#elif linux
16		#define USE_PTHREADS 1
	15	#elif linux \|\| __APPLE__
	16	#define USE_PTHREADS 1
17	17	#else
18	18	#endif
…	…
43	43	} Monitor;
44	44
45		#define MONPTR(h) (&((Monitor *)(h)->monitor)->mon)
	45	#define MONPTR(h) (&((Monitor *)(h)->monitor)->mon)
46	46
47	47	static volatile int inited;
…	…
56	56	{
57	57	if (!inited)
58		{ InitializeCriticalSection(&_monitor_critsec);
59		inited = 1;
	58	{ InitializeCriticalSection(&_monitor_critsec);
	59	inited = 1;
60	60	}
61	61	}
…	…
64	64	{
65	65	if (inited)
66		{ inited = 0;
67		DeleteCriticalSection(&_monitor_critsec);
	66	{ inited = 0;
	67	DeleteCriticalSection(&_monitor_critsec);
68	68	}
69	69	}
…	…
128	128	#if USE_PTHREADS
129	129
	130	// PTHREAD_MUTEX_RECURSIVE is what posix says should be supported,
	131	// but some versions of glibc have only PTHREAD_MUTEX_RECURSIVE_NP
	132	// (the np stands for non-portable), when they have the same meaning.
	133	#ifndef PTHREAD_MUTEX_RECURSIVE
	134	#define PTHREAD_MUTEX_RECURSIVE PTHREAD_MUTEX_RECURSIVE_NP
	135	#endif
	136
130	137	// Includes attribute fixes from David Friedman's GDC port
131	138
…	…
137	144	if (!inited)
138	145	{
139		pthread_mutexattr_init(&_monitors_attr);
140		~~pthread_mutexattr_settype(&_monitors_attr, PTHREAD_MUTEX_RECURSIVE_NP~~);
141		pthread_mutex_init(&_monitor_critsec, 0);
142		inited = 1;
	146	pthread_mutexattr_init(&_monitors_attr);
	147	pthread_mutexattr_settype(&_monitors_attr, PTHREAD_MUTEX_RECURSIVE);
	148	pthread_mutex_init(&_monitor_critsec, 0);
	149	inited = 1;
143	150	}
144	151	}
…	…
147	154	{
148	155	if (inited)
149		{ inited = 0;
150		pthread_mutex_destroy(&_monitor_critsec);
151		pthread_mutexattr_destroy(&_monitors_attr);
	156	{ inited = 0;
	157	pthread_mutex_destroy(&_monitor_critsec);
	158	pthread_mutexattr_destroy(&_monitors_attr);
152	159	}
153	160	}

trunk/lib/compiler/dmd/rt/obj.d

r4357	r4384
1
2
3	1	// Copyright (c) 2002 by Digital Mars
4	2	// All Rights Reserved
5	3	// written by Walter Bright
6	4	// www.digitalmars.com
	5
	6	module rt.obj;
7	7
8	8	extern (C):
…	…
26	26	return o1.opCmp(o2);
27	27	}
28

trunk/lib/compiler/dmd/rt/qsort.d

r4357	r4384
14	14	*/
15	15
	16	module rt.qsort;
16	17
17	18	/*
…	…
156	157	}
157	158	}
158

trunk/lib/compiler/dmd/rt/qsort2.d

r4357	r4384
13	13	* Modified by Sean Kelly <sean@f4.ca> for use with Tango.
14	14	*/
	15
	16	module rt.qsort2;
15	17
16	18	//debug=qsort;

trunk/lib/compiler/dmd/rt/trace.d

r4357	r4384
12	12	*/
13	13
	14	module rt.trace;
	15
14	16	private
15	17	{
	18	import rt.util.string;
16	19	import tango.stdc.ctype;
17	20	import tango.stdc.stdio;
18	21	import tango.stdc.string;
19	22	import tango.stdc.stdlib;
20		~~import util.string;~~
21	23	}
22	24
…	…
149	151	// Qsort() comparison routine for array of pointers to SymPair's.
150	152
151		static int sympair_cmp(~~void* e1,~~ void* e2)
	153	static int sympair_cmp(in void* e1, in void* e2)
152	154	{ SymPair** psp1;
153	155	SymPair** psp2;
…	…
284	286	// Qsort() comparison routine for array of pointers to Symbol's.
285	287
286		static int symbol_cmp(~~void* e1,~~ void* e2)
	288	static int symbol_cmp(in void* e1, in void* e2)
287	289	{ Symbol** ps1;
288	290	Symbol** ps2;
…	…
786	788	*/
787	789
788		asm
789		{ naked ;
790		pushad ;
791		mov ECX,8*4[ESP] ;
792		xor EAX,EAX ;
793		mov AL,[ECX] ;
794		cmp AL,0xFF ;
795		jne L1 ;
796		cmp byte ptr 1[ECX],0 ;
797		jne L1 ;
798		mov AX,2[ECX] ;
799		add 8*4[ESP],3 ;
800		add ECX,3 ;
801		L1: inc EAX ;
802		inc ECX ;
803		add 8*4[ESP],EAX ;
804		dec EAX ;
805		push ECX ;
806		push EAX ;
807		call trace_pro ;
808		add ESP,8 ;
809		popad ;
810		ret ;
	790	version (OSX) { // 16 byte align stack
	791	asm {
	792	naked ;
	793	pushad ;
	794	mov ECX,8*4[ESP] ;
	795	xor EAX,EAX ;
	796	mov AL,[ECX] ;
	797	cmp AL,0xFF ;
	798	jne L1 ;
	799	cmp byte ptr 1[ECX],0 ;
	800	jne L1 ;
	801	mov AX,2[ECX] ;
	802	add 8*4[ESP],3 ;
	803	add ECX,3 ;
	804	L1: inc EAX ;
	805	inc ECX ;
	806	add 8*4[ESP],EAX ;
	807	dec EAX ;
	808	sub ESP,4 ;
	809	push ECX ;
	810	push EAX ;
	811	call trace_pro ;
	812	add ESP,12 ;
	813	popad ;
	814	ret ;
	815	}
	816	} else {
	817	asm {
	818	naked ;
	819	pushad ;
	820	mov ECX,8*4[ESP] ;
	821	xor EAX,EAX ;
	822	mov AL,[ECX] ;
	823	cmp AL,0xFF ;
	824	jne L1 ;
	825	cmp byte ptr 1[ECX],0 ;
	826	jne L1 ;
	827	mov AX,2[ECX] ;
	828	add 8*4[ESP],3 ;
	829	add ECX,3 ;
	830	L1: inc EAX ;
	831	inc ECX ;
	832	add 8*4[ESP],EAX ;
	833	dec EAX ;
	834	push ECX ;
	835	push EAX ;
	836	call trace_pro ;
	837	add ESP,8 ;
	838	popad ;
	839	ret ;
	840	}
811	841	}
812	842	}
…	…
818	848	void _trace_epi_n()
819	849	{
820		asm
821		{ naked ;
822		pushad ;
823		}
824		trace_epi();
825		asm
826		{
827		popad ;
828		ret ;
	850	version (OSX) { // 16 byte align stack
	851	asm{
	852	naked ;
	853	pushad ;
	854	sub ESP,12 ;
	855	}
	856	trace_epi();
	857	asm {
	858	add ESP,12 ;
	859	popad ;
	860	ret ;
	861	}
	862	}
	863	else {
	864	asm {
	865	naked ;
	866	pushad ;
	867	}
	868	trace_epi();
	869	asm
	870	{
	871	popad ;
	872	ret ;
	873	}
829	874	}
830	875	}

trunk/lib/compiler/dmd/rt/typeinfo/ti_AC.d

r4357	r4384
1		module typeinfo.ti_AC;
	1	module rt.typeinfo.ti_AC;
2	2
3	3	// Object[]
…	…
5	5	class TypeInfo_AC : TypeInfo
6	6	{
7		hash_t getHash(void *p)
	7	override hash_t getHash(in void* p)
8	8	{ Object[] s = cast(Object[])p;
9	9	hash_t hash = 0;
…	…
17	17	}
18	18
19		int equals(void p1, void p2)
	19	override equals_t equals(in void* p1, in void* p2)
20	20	{
21	21	Object[] s1 = cast(Object[])p1;
…	…
32	32	(!(o1 is null) && !(o2 is null) && o1.opEquals(o2)))
33	33	continue;
34		return 0;
	34	return false;
35	35	}
36		return 1;
	36	return true;
37	37	}
38		return 0;
	38	return false;
39	39	}
40	40
41		int compare(void p1, void p2)
	41	override int compare(in void* p1, in void* p2)
42	42	{
43	43	Object[] s1 = cast(Object[])p1;
…	…
79	79	}
80	80
81		size_t tsize()
	81	override size_t tsize()
82	82	{
83	83	return (Object[]).sizeof;
84	84	}
85	85
86		uint flags()
	86	override uint flags()
87	87	{
88	88	return 1;
89	89	}
90	90
91		TypeInfo next()
	91	override TypeInfo next()
92	92	{
93	93	return typeid(Object);

trunk/lib/compiler/dmd/rt/typeinfo/ti_Acdouble.d

r4357	r4384
22	22	*/
23	23
24		module typeinfo.ti_Acdouble;
	24	module rt.typeinfo.ti_Acdouble;
25	25
26		private import typeinfo.ti_cdouble;
	26	private import rt.typeinfo.ti_cdouble;
27	27
28	28	// cdouble[]
…	…
30	30	class TypeInfo_Ar : TypeInfo
31	31	{
32		char[] toString() { return "cdouble[]"; }
	32	override char[] toString() { return "cdouble[]"; }
33	33
34		hash_t getHash(void *p)
	34	override hash_t getHash(in void* p)
35	35	{ cdouble[] s = cast(cdouble[])p;
36	36	size_t len = s.length;
…	…
52	52	}
53	53
54		int equals(void p1, void p2)
	54	override equals_t equals(in void* p1, in void* p2)
55	55	{
56	56	cdouble[] s1 = cast(cdouble[])p1;
…	…
59	59
60	60	if (len != s2.length)
61		return 0;
	61	return false;
62	62	for (size_t u = 0; u < len; u++)
63	63	{
64		int c = TypeInfo_r._equals(s1[u], s2[u]);
65		if (c == 0)
66		return 0;
	64	if (!TypeInfo_r._equals(s1[u], s2[u]))
	65	return false;
67	66	}
68		return 1;
	67	return true;
69	68	}
70	69
71		int compare(void p1, void p2)
	70	override int compare(in void* p1, in void* p2)
72	71	{
73	72	cdouble[] s1 = cast(cdouble[])p1;
…	…
90	89	}
91	90
92		size_t tsize()
	91	override size_t tsize()
93	92	{
94	93	return (cdouble[]).sizeof;
95	94	}
96	95
97		uint flags()
	96	override uint flags()
98	97	{
99	98	return 1;
100	99	}
101	100
102		TypeInfo next()
	101	override TypeInfo next()
103	102	{
104	103	return typeid(cdouble);

trunk/lib/compiler/dmd/rt/typeinfo/ti_Acfloat.d

r4357	r4384
22	22	*/
23	23
24		module typeinfo.ti_Acfloat;
	24	module rt.typeinfo.ti_Acfloat;
25	25
26		private import typeinfo.ti_cfloat;
	26	private import rt.typeinfo.ti_cfloat;
27	27
28	28	// cfloat[]
…	…
30	30	class TypeInfo_Aq : TypeInfo
31	31	{
32		char[] toString() { return "cfloat[]"; }
	32	override char[] toString() { return "cfloat[]"; }
33	33
34		hash_t getHash(void *p)
	34	override hash_t getHash(in void* p)
35	35	{ cfloat[] s = cast(cfloat[])p;
36	36	size_t len = s.length;
…	…
50	50	}
51	51
52		int equals(void p1, void p2)
	52	override equals_t equals(in void* p1, in void* p2)
53	53	{
54	54	cfloat[] s1 = cast(cfloat[])p1;
…	…
57	57
58	58	if (len != s2.length)
59		return 0;
	59	return false;
60	60	for (size_t u = 0; u < len; u++)
61	61	{
62		int c = TypeInfo_q._equals(s1[u], s2[u]);
63		if (c == 0)
64		return 0;
	62	if (!TypeInfo_q._equals(s1[u], s2[u]))
	63	return false;
65	64	}
66		return 1;
	65	return true;
67	66	}
68	67
69		int compare(void p1, void p2)
	68	override int compare(in void* p1, in void* p2)
70	69	{
71	70	cfloat[] s1 = cast(cfloat[])p1;
…	…
88	87	}
89	88
90		size_t tsize()
	89	override size_t tsize()
91	90	{
92	91	return (cfloat[]).sizeof;
93	92	}
94	93
95		uint flags()
	94	override uint flags()
96	95	{
97	96	return 1;
98	97	}
99	98
100		TypeInfo next()
	99	override TypeInfo next()
101	100	{
102	101	return typeid(cfloat);

trunk/lib/compiler/dmd/rt/typeinfo/ti_Acreal.d

r4357	r4384
22	22	*/
23	23
24		module typeinfo.ti_Acreal;
	24	module rt.typeinfo.ti_Acreal;
25	25
26		private import typeinfo.ti_creal;
	26	private import rt.typeinfo.ti_creal;
27	27
28	28	// creal[]
…	…
30	30	class TypeInfo_Ac : TypeInfo
31	31	{
32		char[] toString() { return "creal[]"; }
	32	override char[] toString() { return "creal[]"; }
33	33
34		hash_t getHash(void *p)
	34	override hash_t getHash(in void* p)
35	35	{ creal[] s = cast(creal[])p;
36	36	size_t len = s.length;
…	…
53	53	}
54	54
55		int equals(void p1, void p2)
	55	override equals_t equals(in void* p1, in void* p2)
56	56	{
57	57	creal[] s1 = cast(creal[])p1;
…	…
63	63	for (size_t u = 0; u < len; u++)
64	64	{
65		int c = TypeInfo_c._equals(s1[u], s2[u]);
66		if (c == 0)
67		return 0;
	65	if (!TypeInfo_c._equals(s1[u], s2[u]))
	66	return false;
68	67	}
69		return 1;
	68	return true;
70	69	}
71	70
72		int compare(void p1, void p2)
	71	override int compare(in void* p1, in void* p2)
73	72	{
74	73	creal[] s1 = cast(creal[])p1;
…	…
91	90	}
92	91
93		size_t tsize()
	92	override size_t tsize()
94	93	{
95	94	return (creal[]).sizeof;
96	95	}
97	96
98		uint flags()
	97	override uint flags()
99	98	{
100	99	return 1;
101	100	}
102	101
103		TypeInfo next()
	102	override TypeInfo next()
104	103	{
105	104	return typeid(creal);

trunk/lib/compiler/dmd/rt/typeinfo/ti_Adouble.d

r4357	r4384
22	22	*/
23	23
24		module typeinfo.ti_Adouble;
	24	module rt.typeinfo.ti_Adouble;
25	25
26		private import typeinfo.ti_double;
	26	private import rt.typeinfo.ti_double;
27	27
28	28	// double[]
…	…
30	30	class TypeInfo_Ad : TypeInfo
31	31	{
32		char[] toString() { return "double[]"; }
	32	override char[] toString() { return "double[]"; }
33	33
34		hash_t getHash(void *p)
	34	override hash_t getHash(in void* p)
35	35	{ double[] s = cast(double[])p;
36	36	size_t len = s.length;
…	…
50	50	}
51	51
52		int equals(void p1, void p2)
	52	override equals_t equals(in void* p1, in void* p2)
53	53	{
54	54	double[] s1 = cast(double[])p1;
…	…
60	60	for (size_t u = 0; u < len; u++)
61	61	{
62		int c = TypeInfo_d._equals(s1[u], s2[u]);
63		if (c == 0)
64		return 0;
	62	if (!TypeInfo_d._equals(s1[u], s2[u]))
	63	return false;
65	64	}
66		return 1;
	65	return true;
67	66	}
68	67
69		int compare(void p1, void p2)
	68	override int compare(in void* p1, in void* p2)
70	69	{
71	70	double[] s1 = cast(double[])p1;
…	…
88	87	}
89	88
90		size_t tsize()
	89	override size_t tsize()
91	90	{
92	91	return (double[]).sizeof;
93	92	}
94	93
95		uint flags()
	94	override uint flags()
96	95	{
97	96	return 1;
98	97	}
99	98
100		TypeInfo next()
	99	override TypeInfo next()
101	100	{
102	101	return typeid(double);
…	…
110	109	char[] toString() { return "idouble[]"; }
111	110
112		TypeInfo next()
	111	override TypeInfo next()
113	112	{
114	113	return typeid(idouble);

trunk/lib/compiler/dmd/rt/typeinfo/ti_Afloat.d

r4357	r4384
22	22	*/
23	23
24		module typeinfo.ti_Afloat;
	24	module rt.typeinfo.ti_Afloat;
25	25
26		private import typeinfo.ti_float;
	26	private import rt.typeinfo.ti_float;
27	27
28	28	// float[]
…	…
30	30	class TypeInfo_Af : TypeInfo
31	31	{
32		char[] toString() { return "float[]"; }
	32	override char[] toString() { return "float[]"; }
33	33
34		hash_t getHash(void *p)
	34	override hash_t getHash(in void* p)
35	35	{ float[] s = cast(float[])p;
36	36	size_t len = s.length;
…	…
49	49	}
50	50
51		int equals(void p1, void p2)
	51	override equals_t equals(in void* p1, in void* p2)
52	52	{
53	53	float[] s1 = cast(float[])p1;
…	…
59	59	for (size_t u = 0; u < len; u++)
60	60	{
61		int c = TypeInfo_f._equals(s1[u], s2[u]);
62		if (c == 0)
63		return 0;
	61	if (!TypeInfo_f._equals(s1[u], s2[u]))
	62	return false;
64	63	}
65		return 1;
	64	return true;
66	65	}
67	66
68		int compare(void p1, void p2)
	67	override int compare(in void* p1, in void* p2)
69	68	{
70	69	float[] s1 = cast(float[])p1;
…	…
87	86	}
88	87
89		size_t tsize()
	88	override size_t tsize()
90	89	{
91	90	return (float[]).sizeof;
92	91	}
93	92
94		uint flags()
	93	override uint flags()
95	94	{
96	95	return 1;
97	96	}
98	97
99		TypeInfo next()
	98	override TypeInfo next()
100	99	{
101	100	return typeid(float);
…	…
107	106	class TypeInfo_Ao : TypeInfo_Af
108	107	{
109		char[] toString() { return "ifloat[]"; }
	108	override char[] toString() { return "ifloat[]"; }
110	109
111		TypeInfo next()
	110	override TypeInfo next()
112	111	{
113	112	return typeid(ifloat);

trunk/lib/compiler/dmd/rt/typeinfo/ti_Ag.d

r4357	r4384
1	1
2		module typeinfo.ti_Ag;
	2	module rt.typeinfo.ti_Ag;
3	3
4	4	private import tango.stdc.string;
5		private import util.string;
	5	private import rt.util.string;
6	6
7	7	// byte[]
…	…
9	9	class TypeInfo_Ag : TypeInfo
10	10	{
11		char[] toString() { return "byte[]"; }
12
13		hash_t getHash(void *p)
	11	override char[] toString() { return "byte[]"; }
	12
	13	override hash_t getHash(in void* p)
14	14	{ byte[] s = cast(byte[])p;
15	15	size_t len = s.length;
…	…
52	52	}
53	53
54		int equals(void p1, void p2)
	54	override equals_t equals(in void* p1, in void* p2)
55	55	{
56	56	byte[] s1 = cast(byte[])p1;
…	…
61	61	}
62	62
63		int compare(void p1, void p2)
	63	override int compare(in void* p1, in void* p2)
64	64	{
65	65	byte[] s1 = cast(byte[])p1;
…	…
82	82	}
83	83
84		size_t tsize()
	84	override size_t tsize()
85	85	{
86	86	return (byte[]).sizeof;
87	87	}
88	88
89		uint flags()
	89	override uint flags()
90	90	{
91	91	return 1;
92	92	}
93	93
94		TypeInfo next()
	94	override TypeInfo next()
95	95	{
96	96	return typeid(byte);
…	…
103	103	class TypeInfo_Ah : TypeInfo_Ag
104	104	{
105		char[] toString() { return "ubyte[]"; }
106
107		int compare(void p1, void p2)
	105	override char[] toString() { return "ubyte[]"; }
	106
	107	override int compare(in void* p1, in void* p2)
108	108	{
109	109	char[] s1 = cast(char[])p1;
…	…
113	113	}
114	114
115		TypeInfo next()
	115	override TypeInfo next()
116	116	{
117	117	return typeid(ubyte);
…	…
123	123	class TypeInfo_Av : TypeInfo_Ah
124	124	{
125		char[] toString() { return "void[]"; }
126
127		TypeInfo next()
	125	override char[] toString() { return "void[]"; }
	126
	127	override TypeInfo next()
128	128	{
129	129	return typeid(void);
…	…
135	135	class TypeInfo_Ab : TypeInfo_Ah
136	136	{
137		char[] toString() { return "bool[]"; }
138
139		TypeInfo next()
	137	override char[] toString() { return "bool[]"; }
	138
	139	override TypeInfo next()
140	140	{
141	141	return typeid(bool);
…	…
147	147	class TypeInfo_Aa : TypeInfo_Ag
148	148	{
149		char[] toString() { return "char[]"; }
150
151		hash_t getHash(void *p)
	149	override char[] toString() { return "char[]"; }
	150
	151	override hash_t getHash(in void* p)
152	152	{ char[] s = cast(char[])p;
153	153	hash_t hash = 0;
…	…
198	198	}
199	199
200		TypeInfo next()
	200	override TypeInfo next()
201	201	{
202	202	return typeid(char);
203	203	}
204	204	}
205
206

trunk/lib/compiler/dmd/rt/typeinfo/ti_Aint.d

r4357	r4384
1	1
2		module typeinfo.ti_Aint;
	2	module rt.typeinfo.ti_Aint;
3	3
4	4	private import tango.stdc.string;
…	…
8	8	class TypeInfo_Ai : TypeInfo
9	9	{
10		char[] toString() { return "int[]"; }
	10	override char[] toString() { return "int[]"; }
11	11
12		hash_t getHash(void *p)
	12	override hash_t getHash(in void* p)
13	13	{ int[] s = cast(int[])p;
14	14	auto len = s.length;
…	…
27	27	}
28	28
29		int equals(void p1, void p2)
	29	override equals_t equals(in void* p1, in void* p2)
30	30	{
31	31	int[] s1 = cast(int[])p1;
…	…
36	36	}
37	37
38		int compare(void p1, void p2)
	38	override int compare(in void* p1, in void* p2)
39	39	{
40	40	int[] s1 = cast(int[])p1;
…	…
57	57	}
58	58
59		size_t tsize()
	59	override size_t tsize()
60	60	{
61	61	return (int[]).sizeof;
62	62	}
63	63
64		uint flags()
	64	override uint flags()
65	65	{
66	66	return 1;
67	67	}
68	68
69		TypeInfo next()
	69	override TypeInfo next()
70	70	{
71	71	return typeid(int);
72	72	}
	73	}
	74
	75	unittest
	76	{
	77	int[][] a = [[5,3,8,7], [2,5,3,8,7]];
	78	a.sort;
	79	assert(a == [[2,5,3,8,7], [5,3,8,7]]);
	80
	81	a = [[5,3,8,7], [5,3,8]];
	82	a.sort;
	83	assert(a == [[5,3,8], [5,3,8,7]]);
73	84	}
74	85
…	…
77	88	class TypeInfo_Ak : TypeInfo_Ai
78	89	{
79		char[] toString() { return "uint[]"; }
	90	override char[] toString() { return "uint[]"; }
80	91
81		int compare(void p1, void p2)
	92	override int compare(in void* p1, in void* p2)
82	93	{
83	94	uint[] s1 = cast(uint[])p1;
…	…
100	111	}
101	112
102		TypeInfo next()
	113	override TypeInfo next()
103	114	{
104	115	return typeid(uint);
…	…
110	121	class TypeInfo_Aw : TypeInfo_Ak
111	122	{
112		char[] toString() { return "dchar[]"; }
	123	override char[] toString() { return "dchar[]"; }
113	124
114		TypeInfo next()
	125	override TypeInfo next()
115	126	{
116	127	return typeid(dchar);
117	128	}
118	129	}
119

trunk/lib/compiler/dmd/rt/typeinfo/ti_Along.d

r4357	r4384
1	1
2		module typeinfo.ti_Along;
	2	module rt.typeinfo.ti_Along;
3	3
4	4	private import tango.stdc.string;
…	…
8	8	class TypeInfo_Al : TypeInfo
9	9	{
10		char[] toString() { return "long[]"; }
	10	override char[] toString() { return "long[]"; }
11	11
12		hash_t getHash(void *p)
	12	override hash_t getHash(in void* p)
13	13	{ long[] s = cast(long[])p;
14	14	size_t len = s.length;
…	…
27	27	}
28	28
29		int equals(void p1, void p2)
	29	override equals_t equals(in void* p1, in void* p2)
30	30	{
31	31	long[] s1 = cast(long[])p1;
…	…
36	36	}
37	37
38		int compare(void p1, void p2)
	38	override int compare(in void* p1, in void* p2)
39	39	{
40	40	long[] s1 = cast(long[])p1;
…	…
58	58	}
59	59
60		size_t tsize()
	60	override size_t tsize()
61	61	{
62	62	return (long[]).sizeof;
63	63	}
64	64
65		uint flags()
	65	override uint flags()
66	66	{
67	67	return 1;
68	68	}
69	69
70		TypeInfo next()
	70	override TypeInfo next()
71	71	{
72	72	return typeid(long);
…	…
79	79	class TypeInfo_Am : TypeInfo_Al
80	80	{
81		char[] toString() { return "ulong[]"; }
	81	override char[] toString() { return "ulong[]"; }
82	82
83		int compare(void p1, void p2)
	83	override int compare(in void* p1, in void* p2)
84	84	{
85	85	ulong[] s1 = cast(ulong[])p1;
…	…
103	103	}
104	104
105		TypeInfo next()
	105	override TypeInfo next()
106	106	{
107	107	return typeid(ulong);

trunk/lib/compiler/dmd/rt/typeinfo/ti_Areal.d

r4357	r4384
22	22	*/
23	23
24		module typeinfo.ti_Areal;
	24	module rt.typeinfo.ti_Areal;
25	25
26		private import typeinfo.ti_real;
	26	private import rt.typeinfo.ti_real;
27	27
28	28	// real[]
…	…
30	30	class TypeInfo_Ae : TypeInfo
31	31	{
32		char[] toString() { return "real[]"; }
	32	override char[] toString() { return "real[]"; }
33	33
34		hash_t getHash(void *p)
	34	override hash_t getHash(in void* p)
35	35	{ real[] s = cast(real[])p;
36	36	size_t len = s.length;
…	…
51	51	}
52	52
53		int equals(void p1, void p2)
	53	override equals_t equals(in void* p1, in void* p2)
54	54	{
55	55	real[] s1 = cast(real[])p1;
…	…
58	58
59	59	if (len != s2.length)
60		return 0;
	60	return false;
61	61	for (size_t u = 0; u < len; u++)
62	62	{
63		int c = TypeInfo_e._equals(s1[u], s2[u]);
64		if (c == 0)
65		return 0;
	63	if (!TypeInfo_e._equals(s1[u], s2[u]))
	64	return false;
66	65	}
67		return 1;
	66	return true;
68	67	}
69	68
70		int compare(void p1, void p2)
	69	override int compare(in void* p1, in void* p2)
71	70	{
72	71	real[] s1 = cast(real[])p1;
…	…
89	88	}
90	89
91		size_t tsize()
	90	override size_t tsize()
92	91	{
93	92	return (real[]).sizeof;
94	93	}
95	94
96		uint flags()
	95	override uint flags()
97	96	{
98	97	return 1;
99	98	}
100	99
101		TypeInfo next()
	100	override TypeInfo next()
102	101	{
103	102	return typeid(real);
…	…
109	108	class TypeInfo_Aj : TypeInfo_Ae
110	109	{
111		char[] toString() { return "ireal[]"; }
	110	override char[] toString() { return "ireal[]"; }
112	111
113		TypeInfo next()
	112	override TypeInfo next()
114	113	{
115	114	return typeid(ireal);

trunk/lib/compiler/dmd/rt/typeinfo/ti_Ashort.d

r4357	r4384
1	1
2		module typeinfo.ti_Ashort;
	2	module rt.typeinfo.ti_Ashort;
3	3
4	4	private import tango.stdc.string;
…	…
8	8	class TypeInfo_As : TypeInfo
9	9	{
10		char[] toString() { return "short[]"; }
	10	override char[] toString() { return "short[]"; }
11	11
12		hash_t getHash(void *p)
	12	override hash_t getHash(in void* p)
13	13	{ short[] s = cast(short[])p;
14	14	size_t len = s.length;
…	…
40	40	}
41	41
42		int equals(void p1, void p2)
	42	override equals_t equals(in void* p1, in void* p2)
43	43	{
44	44	short[] s1 = cast(short[])p1;
…	…
49	49	}
50	50
51		int compare(void p1, void p2)
	51	override int compare(in void* p1, in void* p2)
52	52	{
53	53	short[] s1 = cast(short[])p1;
…	…
70	70	}
71	71
72		size_t tsize()
	72	override size_t tsize()
73	73	{
74	74	return (short[]).sizeof;
75	75	}
76	76
77		uint flags()
	77	override uint flags()
78	78	{
79	79	return 1;
80	80	}
81	81
82		TypeInfo next()
	82	override TypeInfo next()
83	83	{
84	84	return typeid(short);
…	…
91	91	class TypeInfo_At : TypeInfo_As
92	92	{
93		char[] toString() { return "ushort[]"; }
	93	override char[] toString() { return "ushort[]"; }
94	94
95		int compare(void p1, void p2)
	95	override int compare(in void* p1, in void* p2)
96	96	{
97	97	ushort[] s1 = cast(ushort[])p1;
…	…
114	114	}
115	115
116		TypeInfo next()
	116	override TypeInfo next()
117	117	{
118	118	return typeid(ushort);
…	…
124	124	class TypeInfo_Au : TypeInfo_At
125	125	{
126		char[] toString() { return "wchar[]"; }
	126	override char[] toString() { return "wchar[]"; }
127	127
128		TypeInfo next()
	128	override TypeInfo next()
129	129	{
130	130	return typeid(wchar);

trunk/lib/compiler/dmd/rt/typeinfo/ti_C.d

r4357	r4384
22	22	*/
23	23
24		module typeinfo.ti_C;
	24	module rt.typeinfo.ti_C;
25	25
26	26	// Object
…	…
28	28	class TypeInfo_C : TypeInfo
29	29	{
30		hash_t getHash(void *p)
	30	override hash_t getHash(in void* p)
31	31	{
32	32	Object o = cast(Object)p;
…	…
34	34	}
35	35
36		int equals(void p1, void p2)
	36	override equals_t equals(in void* p1, in void* p2)
37	37	{
38	38	Object o1 = cast(Object)p1;
…	…
42	42	}
43	43
44		int compare(void p1, void p2)
	44	override int compare(in void* p1, in void* p2)
45	45	{
46	46	Object o1 = cast(Object)p1;
…	…
63	63	}
64	64
65		size_t tsize()
	65	override size_t tsize()
66	66	{
67	67	return Object.sizeof;
68	68	}
69	69
70		uint flags()
	70	override uint flags()
71	71	{
72	72	return 1;

trunk/lib/compiler/dmd/rt/typeinfo/ti_byte.d

r4357	r4384
2	2	// byte
3	3
4		module typeinfo.ti_byte;
	4	module rt.typeinfo.ti_byte;
5	5
6	6	class TypeInfo_g : TypeInfo
7	7	{
8		char[] toString() { return "byte"; }
	8	override char[] toString() { return "byte"; }
9	9
10		hash_t getHash(void *p)
	10	override hash_t getHash(in void* p)
11	11	{
12		return cast(byte )p;
	12	return cast(byte )p;
13	13	}
14	14
15		int equals(void p1, void p2)
	15	override equals_t equals(in void* p1, in void* p2)
16	16	{
17		return cast(byte )p1 == cast(byte )p2;
	17	return cast(byte )p1 == cast(byte )p2;
18	18	}
19	19
20		int compare(void p1, void p2)
	20	override int compare(in void* p1, in void* p2)
21	21	{
22		return cast(byte )p1 - cast(byte )p2;
	22	return cast(byte )p1 - cast(byte )p2;
23	23	}
24	24
25		size_t tsize()
	25	override size_t tsize()
26	26	{
27		return byte.sizeof;
	27	return byte.sizeof;
28	28	}
29	29
30		void swap(void p1, void p2)
	30	override void swap(void p1, void p2)
31	31	{
32		byte t;
	32	byte t;
33	33
34		t = cast(byte )p1;
35		cast(byte )p1 = cast(byte )p2;
36		cast(byte )p2 = t;
	34	t = cast(byte )p1;
	35	cast(byte )p1 = cast(byte )p2;
	36	cast(byte )p2 = t;
37	37	}
38	38	}
39

trunk/lib/compiler/dmd/rt/typeinfo/ti_cdouble.d

r4357	r4384
2	2	// cdouble
3	3
4		module typeinfo.ti_cdouble;
	4	module rt.typeinfo.ti_cdouble;
5	5
6	6	class TypeInfo_r : TypeInfo
7	7	{
8		char[] toString() { return "cdouble"; }
	8	override char[] toString() { return "cdouble"; }
9	9
10		hash_t getHash(void *p)
	10	override hash_t getHash(in void* p)
11	11	{
12	12	return (cast(uint )p)[0] + (cast(uint )p)[1] +
…	…
14	14	}
15	15
16		static int _equals(cdouble f1, cdouble f2)
	16	static equals_t _equals(cdouble f1, cdouble f2)
17	17	{
18	18	return f1 == f2;
…	…
35	35	}
36	36
37		int equals(void p1, void p2)
	37	override equals_t equals(in void* p1, in void* p2)
38	38	{
39	39	return _equals(cast(cdouble )p1, cast(cdouble )p2);
40	40	}
41	41
42		int compare(void p1, void p2)
	42	override int compare(in void* p1, in void* p2)
43	43	{
44	44	return _compare(cast(cdouble )p1, cast(cdouble )p2);
45	45	}
46	46
47		size_t tsize()
	47	override size_t tsize()
48	48	{
49	49	return cdouble.sizeof;
50	50	}
51	51
52		void swap(void p1, void p2)
	52	override void swap(void p1, void p2)
53	53	{
54	54	cdouble t;
…	…
59	59	}
60	60
61		void[] init()
	61	override void[] init()
62	62	{ static cdouble r;
63	63

trunk/lib/compiler/dmd/rt/typeinfo/ti_cfloat.d

r4357	r4384
2	2	// cfloat
3	3
4		module typeinfo.ti_cfloat;
	4	module rt.typeinfo.ti_cfloat;
5	5
6	6	class TypeInfo_q : TypeInfo
7	7	{
8		char[] toString() { return "cfloat"; }
	8	override char[] toString() { return "cfloat"; }
9	9
10		hash_t getHash(void *p)
	10	override hash_t getHash(in void* p)
11	11	{
12	12	return (cast(uint )p)[0] + (cast(uint )p)[1];
13	13	}
14	14
15		static int _equals(cfloat f1, cfloat f2)
	15	static equals_t _equals(cfloat f1, cfloat f2)
16	16	{
17	17	return f1 == f2;
…	…
34	34	}
35	35
36		int equals(void p1, void p2)
	36	override equals_t equals(in void* p1, in void* p2)
37	37	{
38	38	return _equals(cast(cfloat )p1, cast(cfloat )p2);
39	39	}
40	40
41		int compare(void p1, void p2)
	41	override int compare(in void* p1, in void* p2)
42	42	{
43	43	return _compare(cast(cfloat )p1, cast(cfloat )p2);
44	44	}
45	45
46		size_t tsize()
	46	override size_t tsize()
47	47	{
48	48	return cfloat.sizeof;
49	49	}
50	50
51		void swap(void p1, void p2)
	51	override void swap(void p1, void p2)
52	52	{
53	53	cfloat t;
…	…
58	58	}
59	59
60		void[] init()
	60	override void[] init()
61	61	{ static cfloat r;
62	62

trunk/lib/compiler/dmd/rt/typeinfo/ti_char.d

r4357	r4384
1	1
2		module typeinfo.ti_char;
	2	module rt.typeinfo.ti_char;
3	3
4	4	class TypeInfo_a : TypeInfo
5	5	{
6		char[] toString() { return "char"; }
	6	override char[] toString() { return "char"; }
7	7
8		hash_t getHash(void *p)
	8	override hash_t getHash(in void* p)
9	9	{
10	10	return cast(char )p;
11	11	}
12	12
13		int equals(void p1, void p2)
	13	override equals_t equals(in void* p1, in void* p2)
14	14	{
15	15	return cast(char )p1 == cast(char )p2;
16	16	}
17	17
18		int compare(void p1, void p2)
	18	override int compare(in void* p1, in void* p2)
19	19	{
20	20	return cast(char )p1 - cast(char )p2;
21	21	}
22	22
23		size_t tsize()
	23	override size_t tsize()
24	24	{
25	25	return char.sizeof;
26	26	}
27	27
28		void swap(void p1, void p2)
	28	override void swap(void p1, void p2)
29	29	{
30	30	char t;
…	…
35	35	}
36	36
37		void[] init()
	37	override void[] init()
38	38	{ static char c;
39	39

trunk/lib/compiler/dmd/rt/typeinfo/ti_creal.d

r4357	r4384
2	2	// creal
3	3
4		module typeinfo.ti_creal;
	4	module rt.typeinfo.ti_creal;
5	5
6	6	class TypeInfo_c : TypeInfo
7	7	{
8		char[] toString() { return "creal"; }
	8	override char[] toString() { return "creal"; }
9	9
10		hash_t getHash(void *p)
	10	override hash_t getHash(in void* p)
11	11	{
12	12	return (cast(uint )p)[0] + (cast(uint )p)[1] +
…	…
15	15	}
16	16
17		static int _equals(creal f1, creal f2)
	17	static equals_t _equals(creal f1, creal f2)
18	18	{
19	19	return f1 == f2;
…	…
36	36	}
37	37
38		int equals(void p1, void p2)
	38	override equals_t equals(in void* p1, in void* p2)
39	39	{
40	40	return _equals(cast(creal )p1, cast(creal )p2);
41	41	}
42	42
43		int compare(void p1, void p2)
	43	override int compare(in void* p1, in void* p2)
44	44	{
45	45	return _compare(cast(creal )p1, cast(creal )p2);
46	46	}
47	47
48		size_t tsize()
	48	override size_t tsize()
49	49	{
50	50	return creal.sizeof;
51	51	}
52	52
53		void swap(void p1, void p2)
	53	override void swap(void p1, void p2)
54	54	{
55	55	creal t;
…	…
60	60	}
61	61
62		void[] init()
	62	override void[] init()
63	63	{ static creal r;
64	64

trunk/lib/compiler/dmd/rt/typeinfo/ti_dchar.d

r4357	r4384
2	2	// dchar
3	3
4		module typeinfo.ti_dchar;
	4	module rt.typeinfo.ti_dchar;
5	5
6	6	class TypeInfo_w : TypeInfo
7	7	{
8		char[] toString() { return "dchar"; }
	8	override char[] toString() { return "dchar"; }
9	9
10		hash_t getHash(void *p)
	10	override hash_t getHash(in void* p)
11	11	{
12	12	return cast(dchar )p;
13	13	}
14	14
15		int equals(void p1, void p2)
	15	override equals_t equals(in void* p1, in void* p2)
16	16	{
17	17	return cast(dchar )p1 == cast(dchar )p2;
18	18	}
19	19
20		int compare(void p1, void p2)
	20	override int compare(in void* p1, in void* p2)
21	21	{
22	22	return cast(dchar )p1 - cast(dchar )p2;
23	23	}
24	24
25		size_t tsize()
	25	override size_t tsize()
26	26	{
27	27	return dchar.sizeof;
28	28	}
29	29
30		void swap(void p1, void p2)
	30	override void swap(void p1, void p2)
31	31	{
32	32	dchar t;
…	…
37	37	}
38	38
39		void[] init()
	39	override void[] init()
40	40	{ static dchar c;
41	41

trunk/lib/compiler/dmd/rt/typeinfo/ti_delegate.d

r4357	r4384
2	2	// delegate
3	3
4		module typeinfo.ti_delegate;
	4	module rt.typeinfo.ti_delegate;
5	5
6	6	alias void delegate(int) dg;
…	…
8	8	class TypeInfo_D : TypeInfo
9	9	{
10		hash_t getHash(void *p)
	10	override hash_t getHash(in void* p)
11	11	{ long l = cast(long )p;
12	12
…	…
14	14	}
15	15
16		int equals(void p1, void p2)
	16	override equals_t equals(in void* p1, in void* p2)
17	17	{
18	18	return cast(dg )p1 == cast(dg )p2;
19	19	}
20	20
21		size_t tsize()
	21	override size_t tsize()
22	22	{
23	23	return dg.sizeof;
24	24	}
25	25
26		void swap(void p1, void p2)
	26	override void swap(void p1, void p2)
27	27	{
28	28	dg t;
…	…
33	33	}
34	34
35		uint flags()
	35	override uint flags()
36	36	{
37	37	return 1;

trunk/lib/compiler/dmd/rt/typeinfo/ti_double.d

r4357	r4384
2	2	// double
3	3
4		module typeinfo.ti_double;
	4	module rt.typeinfo.ti_double;
5	5
6	6	class TypeInfo_d : TypeInfo
7	7	{
8		char[] toString() { return "double"; }
	8	override char[] toString() { return "double"; }
9	9
10		hash_t getHash(void *p)
	10	override hash_t getHash(in void* p)
11	11	{
12	12	return (cast(uint )p)[0] + (cast(uint )p)[1];
13	13	}
14	14
15		static int _equals(double f1, double f2)
	15	static equals_t _equals(double f1, double f2)
16	16	{
17	17	return f1 == f2 \|\|
…	…
33	33	}
34	34
35		int equals(void p1, void p2)
	35	override equals_t equals(in void* p1, in void* p2)
36	36	{
37	37	return _equals(cast(double )p1, cast(double )p2);
38	38	}
39	39
40		int compare(void p1, void p2)
	40	override int compare(in void* p1, in void* p2)
41	41	{
42	42	return _compare(cast(double )p1, cast(double )p2);
43	43	}
44	44
45		size_t tsize()
	45	override size_t tsize()
46	46	{
47	47	return double.sizeof;
48	48	}
49	49
50		void swap(void p1, void p2)
	50	override void swap(void p1, void p2)
51	51	{
52	52	double t;
…	…
57	57	}
58	58
59		void[] init()
	59	override void[] init()
60	60	{ static double r;
61	61
…	…
63	63	}
64	64	}
65

trunk/lib/compiler/dmd/rt/typeinfo/ti_float.d

r4357	r4384
2	2	// float
3	3
4		module typeinfo.ti_float;
	4	module rt.typeinfo.ti_float;
5	5
6	6	class TypeInfo_f : TypeInfo
7	7	{
8		char[] toString() { return "float"; }
	8	override char[] toString() { return "float"; }
9	9
10		hash_t getHash(void *p)
	10	override hash_t getHash(in void* p)
11	11	{
12	12	return cast(uint )p;
13	13	}
14	14
15		static int _equals(float f1, float f2)
	15	static equals_t _equals(float f1, float f2)
16	16	{
17	17	return f1 == f2 \|\|
…	…
33	33	}
34	34
35		int equals(void p1, void p2)
	35	override equals_t equals(in void* p1, in void* p2)
36	36	{
37	37	return _equals(cast(float )p1, cast(float )p2);
38	38	}
39	39
40		int compare(void p1, void p2)
	40	override int compare(in void* p1, in void* p2)
41	41	{
42	42	return _compare(cast(float )p1, cast(float )p2);
43	43	}
44	44
45		size_t tsize()
	45	override size_t tsize()
46	46	{
47	47	return float.sizeof;
48	48	}
49	49
50		void swap(void p1, void p2)
	50	override void swap(void p1, void p2)
51	51	{
52	52	float t;
…	…
57	57	}
58	58
59		void[] init()
	59	override void[] init()
60	60	{ static float r;
61	61

trunk/lib/compiler/dmd/rt/typeinfo/ti_idouble.d

r4357	r4384
2	2	// idouble
3	3
4		module typeinfo.ti_idouble;
	4	module rt.typeinfo.ti_idouble;
5	5
6		private import typeinfo.ti_double;
	6	private import rt.typeinfo.ti_double;
7	7
8	8	class TypeInfo_p : TypeInfo_d
9	9	{
10		char[] toString() { return "idouble"; }
	10	override char[] toString() { return "idouble"; }
11	11	}
12

trunk/lib/compiler/dmd/rt/typeinfo/ti_ifloat.d

r4357	r4384
2	2	// ifloat
3	3
4		module typeinfo.ti_ifloat;
	4	module rt.typeinfo.ti_ifloat;
5	5
6		private import typeinfo.ti_float;
	6	private import rt.typeinfo.ti_float;
7	7
8	8	class TypeInfo_o : TypeInfo_f
9	9	{
10		char[] toString() { return "ifloat"; }
	10	override char[] toString() { return "ifloat"; }
11	11	}
12

trunk/lib/compiler/dmd/rt/typeinfo/ti_int.d

r4357	r4384
2	2	// int
3	3
4		module typeinfo.ti_int;
	4	module rt.typeinfo.ti_int;
5	5
6	6	class TypeInfo_i : TypeInfo
7	7	{
8		char[] toString() { return "int"; }
	8	override char[] toString() { return "int"; }
9	9
10		hash_t getHash(void *p)
	10	override hash_t getHash(in void* p)
11	11	{
12		return cast(uint )p;
	12	return cast(uint )p;
13	13	}
14	14
15		int equals(void p1, void p2)
	15	override equals_t equals(in void* p1, in void* p2)
16	16	{
17		return cast(uint )p1 == cast(uint )p2;
	17	return cast(uint )p1 == cast(uint )p2;
18	18	}
19	19
20		int compare(void p1, void p2)
	20	override int compare(in void* p1, in void* p2)
21	21	{
22		if (cast(int) p1 < cast(int) p2)
23		return -1;
24		else if (cast(int) p1 > cast(int) p2)
25		return 1;
26		return 0;
	22	if (cast(int) p1 < cast(int) p2)
	23	return -1;
	24	else if (cast(int) p1 > cast(int) p2)
	25	return 1;
	26	return 0;
27	27	}
28	28
29		size_t tsize()
	29	override size_t tsize()
30	30	{
31		return int.sizeof;
	31	return int.sizeof;
32	32	}
33	33
34		void swap(void p1, void p2)
	34	override void swap(void p1, void p2)
35	35	{
36		int t;
	36	int t;
37	37
38		t = cast(int )p1;
39		cast(int )p1 = cast(int )p2;
40		cast(int )p2 = t;
	38	t = cast(int )p1;
	39	cast(int )p1 = cast(int )p2;
	40	cast(int )p2 = t;
41	41	}
42	42	}
43

trunk/lib/compiler/dmd/rt/typeinfo/ti_ireal.d

r4357	r4384
2	2	// ireal
3	3
4		module typeinfo.ti_ireal;
	4	module rt.typeinfo.ti_ireal;
5	5
6		private import typeinfo.ti_real;
	6	private import rt.typeinfo.ti_real;
7	7
8	8	class TypeInfo_j : TypeInfo_e
9	9	{
10		char[] toString() { return "ireal"; }
	10	override char[] toString() { return "ireal"; }
11	11	}
12

trunk/lib/compiler/dmd/rt/typeinfo/ti_long.d

r4357	r4384
2	2	// long
3	3
4		module typeinfo.ti_long;
	4	module rt.typeinfo.ti_long;
5	5
6	6	class TypeInfo_l : TypeInfo
7	7	{
8		char[] toString() { return "long"; }
	8	override char[] toString() { return "long"; }
9	9
10		hash_t getHash(void *p)
	10	override hash_t getHash(in void* p)
11	11	{
12		return cast(uint )p + (cast(uint *)p)[1];
	12	return cast(uint )p + (cast(uint *)p)[1];
13	13	}
14	14
15		int equals(void p1, void p2)
	15	override equals_t equals(in void* p1, in void* p2)
16	16	{
17		return cast(long )p1 == cast(long )p2;
	17	return cast(long )p1 == cast(long )p2;
18	18	}
19	19
20		int compare(void p1, void p2)
	20	override int compare(in void* p1, in void* p2)
21	21	{
22		if (cast(long )p1 < cast(long )p2)
23		return -1;
24		else if (cast(long )p1 > cast(long )p2)
25		return 1;
26		return 0;
	22	if (cast(long )p1 < cast(long )p2)
	23	return -1;
	24	else if (cast(long )p1 > cast(long )p2)
	25	return 1;
	26	return 0;
27	27	}
28	28
29		size_t tsize()
	29	override size_t tsize()
30	30	{
31		return long.sizeof;
	31	return long.sizeof;
32	32	}
33	33
34		void swap(void p1, void p2)
	34	override void swap(void p1, void p2)
35	35	{
36		long t;
	36	long t;
37	37
38		t = cast(long )p1;
39		cast(long )p1 = cast(long )p2;
40		cast(long )p2 = t;
	38	t = cast(long )p1;
	39	cast(long )p1 = cast(long )p2;
	40	cast(long )p2 = t;
41	41	}
42	42	}
43

trunk/lib/compiler/dmd/rt/typeinfo/ti_ptr.d

r4357	r4384
2	2	// pointer
3	3
4		module typeinfo.ti_ptr;
	4	module rt.typeinfo.ti_ptr;
5	5
6	6	class TypeInfo_P : TypeInfo
7	7	{
8		hash_t getHash(void *p)
	8	override hash_t getHash(in void* p)
9	9	{
10	10	return cast(uint)cast(void *)p;
11	11	}
12	12
13		int equals(void p1, void p2)
	13	override equals_t equals(in void* p1, in void* p2)
14	14	{
15	15	return cast(void )p1 == cast(void* *)p2;
16	16	}
17	17
18		int compare(void p1, void p2)
	18	override int compare(in void* p1, in void* p2)
19	19	{
20	20	auto c = cast(void )p1 - cast(void* *)p2;
…	…
26	26	}
27	27
28		size_t tsize()
	28	override size_t tsize()
29	29	{
30	30	return (void*).sizeof;
31	31	}
32	32
33		void swap(void p1, void p2)
	33	override void swap(void p1, void p2)
34	34	{
35	35	void* t;
…	…
40	40	}
41	41
42		uint flags()
	42	override uint flags()
43	43	{
44	44	return 1;

trunk/lib/compiler/dmd/rt/typeinfo/ti_real.d

r4357	r4384
2	2	// real
3	3
4		module typeinfo.ti_real;
	4	module rt.typeinfo.ti_real;
5	5
6	6	class TypeInfo_e : TypeInfo
7	7	{
8		char[] toString() { return "real"; }
	8	override char[] toString() { return "real"; }
9	9
10		hash_t getHash(void *p)
	10	override hash_t getHash(in void* p)
11	11	{
12	12	return (cast(uint )p)[0] + (cast(uint )p)[1] + (cast(ushort *)p)[4];
13	13	}
14	14
15		static int _equals(real f1, real f2)
	15	static equals_t _equals(real f1, real f2)
16	16	{
17	17	return f1 == f2 \|\|
…	…
33	33	}
34	34
35		int equals(void p1, void p2)
	35	override equals_t equals(in void* p1, in void* p2)
36	36	{
37	37	return _equals(cast(real )p1, cast(real )p2);
38	38	}
39	39
40		int compare(void p1, void p2)
	40	override int compare(in void* p1, in void* p2)
41	41	{
42	42	return _compare(cast(real )p1, cast(real )p2);
43	43	}
44	44
45		size_t tsize()
	45	override size_t tsize()
46	46	{
47	47	return real.sizeof;
48	48	}
49	49
50		void swap(void p1, void p2)
	50	override void swap(void p1, void p2)
51	51	{
52	52	real t;
…	…
57	57	}
58	58
59		void[] init()
	59	override void[] init()
60	60	{ static real r;
61	61

trunk/lib/compiler/dmd/rt/typeinfo/ti_short.d

r4357	r4384
2	2	// short
3	3
4		module typeinfo.ti_short;
	4	module rt.typeinfo.ti_short;
5	5
6	6	class TypeInfo_s : TypeInfo
7	7	{
8		char[] toString() { return "short"; }
	8	override char[] toString() { return "short"; }
9	9
10		hash_t getHash(void *p)
	10	override hash_t getHash(in void* p)
11	11	{
12		return cast(short )p;
	12	return cast(short )p;
13	13	}
14	14
15		int equals(void p1, void p2)
	15	override equals_t equals(in void* p1, in void* p2)
16	16	{
17		return cast(short )p1 == cast(short )p2;
	17	return cast(short )p1 == cast(short )p2;
18	18	}
19	19
20		int compare(void p1, void p2)
	20	override int compare(in void* p1, in void* p2)
21	21	{
22		return cast(short )p1 - cast(short )p2;
	22	return cast(short )p1 - cast(short )p2;
23	23	}
24	24
25		size_t tsize()
	25	override size_t tsize()
26	26	{
27		return short.sizeof;
	27	return short.sizeof;
28	28	}
29	29
30		void swap(void p1, void p2)
	30	override void swap(void p1, void p2)
31	31	{
32		short t;
	32	short t;
33	33
34		t = cast(short )p1;
35		cast(short )p1 = cast(short )p2;
36		cast(short )p2 = t;
	34	t = cast(short )p1;
	35	cast(short )p1 = cast(short )p2;
	36	cast(short )p2 = t;
37	37	}
38	38	}
39

trunk/lib/compiler/dmd/rt/typeinfo/ti_ubyte.d

r4357	r4384
2	2	// ubyte
3	3
4		module typeinfo.ti_ubyte;
	4	module rt.typeinfo.ti_ubyte;
5	5
6	6	class TypeInfo_h : TypeInfo
7	7	{
8		char[] toString() { return "ubyte"; }
	8	override char[] toString() { return "ubyte"; }
9	9
10		hash_t getHash(void *p)
	10	override hash_t getHash(in void* p)
11	11	{
12	12	return cast(ubyte )p;
13	13	}
14	14
15		int equals(void p1, void p2)
	15	override equals_t equals(in void* p1, in void* p2)
16	16	{
17	17	return cast(ubyte )p1 == cast(ubyte )p2;
18	18	}
19	19
20		int compare(void p1, void p2)
	20	override int compare(in void* p1, in void* p2)
21	21	{
22	22	return cast(ubyte )p1 - cast(ubyte )p2;
23	23	}
24	24
25		size_t tsize()
	25	override size_t tsize()
26	26	{
27	27	return ubyte.sizeof;
28	28	}
29	29
30		void swap(void p1, void p2)
	30	override void swap(void p1, void p2)
31	31	{
32	32	ubyte t;
…	…
40	40	class TypeInfo_b : TypeInfo_h
41	41	{
42		char[] toString() { return "bool"; }
	42	override char[] toString() { return "bool"; }
43	43	}

trunk/lib/compiler/dmd/rt/typeinfo/ti_uint.d

r4357	r4384
2	2	// uint
3	3
4		module typeinfo.ti_uint;
	4	module rt.typeinfo.ti_uint;
5	5
6	6	class TypeInfo_k : TypeInfo
7	7	{
8		char[] toString() { return "uint"; }
	8	override char[] toString() { return "uint"; }
9	9
10		hash_t getHash(void *p)
	10	override hash_t getHash(in void* p)
11	11	{
12		return cast(uint )p;
	12	return cast(uint )p;
13	13	}
14	14
15		int equals(void p1, void p2)
	15	override equals_t equals(in void* p1, in void* p2)
16	16	{
17		return cast(uint )p1 == cast(uint )p2;
	17	return cast(uint )p1 == cast(uint )p2;
18	18	}
19	19
20		int compare(void p1, void p2)
	20	override int compare(in void* p1, in void* p2)
21	21	{
22		if (cast(uint) p1 < cast(uint) p2)
23		return -1;
24		else if (cast(uint) p1 > cast(uint) p2)
25		return 1;
26		return 0;
	22	if (cast(uint) p1 < cast(uint) p2)
	23	return -1;
	24	else if (cast(uint) p1 > cast(uint) p2)
	25	return 1;
	26	return 0;
27	27	}
28	28
29		size_t tsize()
	29	override size_t tsize()
30	30	{
31		return uint.sizeof;
	31	return uint.sizeof;
32	32	}
33	33
34		void swap(void p1, void p2)
	34	override void swap(void p1, void p2)
35	35	{
36		int t;
	36	int t;
37	37
38		t = cast(uint )p1;
39		cast(uint )p1 = cast(uint )p2;
40		cast(uint )p2 = t;
	38	t = cast(uint )p1;
	39	cast(uint )p1 = cast(uint )p2;
	40	cast(uint )p2 = t;
41	41	}
42	42	}
43

trunk/lib/compiler/dmd/rt/typeinfo/ti_ulong.d

r4357	r4384
2	2	// ulong
3	3
4		module typeinfo.ti_ulong;
	4	module rt.typeinfo.ti_ulong;
5	5
6	6	class TypeInfo_m : TypeInfo
7	7	{
8		char[] toString() { return "ulong"; }
	8	override char[] toString() { return "ulong"; }
9	9
10		hash_t getHash(void *p)
	10	override hash_t getHash(in void* p)
11	11	{
12		return cast(uint )p + (cast(uint *)p)[1];
	12	return cast(uint )p + (cast(uint *)p)[1];
13	13	}
14	14
15		int equals(void p1, void p2)
	15	override equals_t equals(in void* p1, in void* p2)
16	16	{
17		return cast(ulong )p1 == cast(ulong )p2;
	17	return cast(ulong )p1 == cast(ulong )p2;
18	18	}
19	19
20		int compare(void p1, void p2)
	20	override int compare(in void* p1, in void* p2)
21	21	{
22		if (cast(ulong )p1 < cast(ulong )p2)
23		return -1;
24		else if (cast(ulong )p1 > cast(ulong )p2)
25		return 1;
26		return 0;
	22	if (cast(ulong )p1 < cast(ulong )p2)
	23	return -1;
	24	else if (cast(ulong )p1 > cast(ulong )p2)
	25	return 1;
	26	return 0;
27	27	}
28	28
29		size_t tsize()
	29	override size_t tsize()
30	30	{
31		return ulong.sizeof;
	31	return ulong.sizeof;
32	32	}
33	33
34		void swap(void p1, void p2)
	34	override void swap(void p1, void p2)
35	35	{
36		ulong t;
	36	ulong t;
37	37
38		t = cast(ulong )p1;
39		cast(ulong )p1 = cast(ulong )p2;
40		cast(ulong )p2 = t;
	38	t = cast(ulong )p1;
	39	cast(ulong )p1 = cast(ulong )p2;
	40	cast(ulong )p2 = t;
41	41	}
42	42	}
43

trunk/lib/compiler/dmd/rt/typeinfo/ti_ushort.d

r4357	r4384
2	2	// ushort
3	3
4		module typeinfo.ti_ushort;
	4	module rt.typeinfo.ti_ushort;
5	5
6	6	class TypeInfo_t : TypeInfo
7	7	{
8		char[] toString() { return "ushort"; }
	8	override char[] toString() { return "ushort"; }
9	9
10		hash_t getHash(void *p)
	10	override hash_t getHash(in void* p)
11	11	{
12		return cast(ushort )p;
	12	return cast(ushort )p;
13	13	}
14	14
15		int equals(void p1, void p2)
	15	override equals_t equals(in void* p1, in void* p2)
16	16	{
17		return cast(ushort )p1 == cast(ushort )p2;
	17	return cast(ushort )p1 == cast(ushort )p2;
18	18	}
19	19
20		int compare(void p1, void p2)
	20	override int compare(in void* p1, in void* p2)
21	21	{
22		return cast(ushort )p1 - cast(ushort )p2;
	22	return cast(ushort )p1 - cast(ushort )p2;
23	23	}
24	24
25		size_t tsize()
	25	override size_t tsize()
26	26	{
27		return ushort.sizeof;
	27	return ushort.sizeof;
28	28	}
29	29
30		void swap(void p1, void p2)
	30	override void swap(void p1, void p2)
31	31	{
32		ushort t;
	32	ushort t;
33	33
34		t = cast(ushort )p1;
35		cast(ushort )p1 = cast(ushort )p2;
36		cast(ushort )p2 = t;
	34	t = cast(ushort )p1;
	35	cast(ushort )p1 = cast(ushort )p2;
	36	cast(ushort )p2 = t;
37	37	}
38	38	}
39

trunk/lib/compiler/dmd/rt/typeinfo/ti_void.d

r4357	r4384
2	2	// void
3	3
4		module typeinfo.ti_void;
	4	module rt.typeinfo.ti_void;
5	5
6	6	class TypeInfo_v : TypeInfo
7	7	{
8		char[] toString() { return "void"; }
	8	override char[] toString() { return "void"; }
9	9
10		hash_t getHash(void *p)
	10	override hash_t getHash(in void* p)
11	11	{
12	12	assert(0);
13	13	}
14	14
15		int equals(void p1, void p2)
	15	override equals_t equals(in void* p1, in void* p2)
16	16	{
17	17	return cast(byte )p1 == cast(byte )p2;
18	18	}
19	19
20		int compare(void p1, void p2)
	20	override int compare(in void* p1, in void* p2)
21	21	{
22	22	return cast(byte )p1 - cast(byte )p2;
23	23	}
24	24
25		size_t tsize()
	25	override size_t tsize()
26	26	{
27	27	return void.sizeof;
28	28	}
29	29
30		void swap(void p1, void p2)
	30	override void swap(void p1, void p2)
31	31	{
32	32	byte t;
…	…
37	37	}
38	38
39		uint flags()
	39	override uint flags()
40	40	{
41	41	return 1;

trunk/lib/compiler/dmd/rt/typeinfo/ti_wchar.d

r4357	r4384
1	1
2		module typeinfo.ti_wchar;
	2	module rt.typeinfo.ti_wchar;
3	3
4	4
5	5	class TypeInfo_u : TypeInfo
6	6	{
7		char[] toString() { return "wchar"; }
	7	override char[] toString() { return "wchar"; }
8	8
9		hash_t getHash(void *p)
	9	override hash_t getHash(in void* p)
10	10	{
11	11	return cast(wchar )p;
12	12	}
13	13
14		int equals(void p1, void p2)
	14	override equals_t equals(in void* p1, in void* p2)
15	15	{
16	16	return cast(wchar )p1 == cast(wchar )p2;
17	17	}
18	18
19		int compare(void p1, void p2)
	19	override int compare(in void* p1, in void* p2)
20	20	{
21	21	return cast(wchar )p1 - cast(wchar )p2;
22	22	}
23	23
24		size_t tsize()
	24	override size_t tsize()
25	25	{
26	26	return wchar.sizeof;
27	27	}
28	28
29		void swap(void p1, void p2)
	29	override void swap(void p1, void p2)
30	30	{
31	31	wchar t;
…	…
36	36	}
37	37
38		void[] init()
	38	override void[] init()
39	39	{ static wchar c;
40	40

trunk/lib/compiler/dmd/rt/util/console.d

r4357	r4384
12	12	*******************************************************************************/
13	13
14		module util.console;
	14	module rt.util.console;
15	15
16		private import util.string;
	16	private import rt.util.string;
17	17
18		version (Win32)
19		{
	18	version (Win32) {
20	19	private extern (Windows) int GetStdHandle (int);
21	20	private extern (Windows) int WriteFile (int, char, int, int, void*);
22		}
23
24		else
25
26		version (Posix)
27		{
28		private extern (C) int write (int, void*, int);
29		}
30
31		/+
32		// emit a char[] to the console. Note that Win32 does not handle utf8, but
33		// then neither does fprintf (stderr). This will handle redirection though.
34		// May need to remedy the utf8 issue
35		int console (char[] s)
36		{
37		version (Win32)
38		{
39		int count;
40		if (WriteFile (GetStdHandle(0xfffffff5), s.ptr, s.length, &count, null))
41		return count;
42		return -1;
43		}
44		else
45		version (Posix)
46		{
47		return write (2, s.ptr, s.length);
48		}
	21	} else version (Posix){
	22	import tango.stdc.posix.unistd;
49	23	}
50
51		~~// emit an integer to the console~~
52		~~int console (uint i)~~
53		{
54		~~char[10] tmp = void;~~
55
56		~~return console (intToUtf8 (tmp, i));~~
57		}
58		+/
59	24
60	25	struct Console

trunk/lib/compiler/dmd/rt/util/cpuid.d

r4357	r4384
39	39	*/
40	40
41		module util.cpuid;
	41	module rt.util.cpuid;
42	42
43	43	private import tango.stdc.string : strlen;

trunk/lib/compiler/dmd/rt/util/ctype.d

r4357	r4384
25	25	// Simple ASCII char classification functions
26	26
27		module util.ctype;
	27	module rt.util.ctype;
28	28
29	29	int isalnum(dchar c) { return (c <= 0x7F) ? _ctype[c] & (_ALP\|_DIG) : 0; }

trunk/lib/compiler/dmd/rt/util/string.d

r4357	r4384
12	12	*******************************************************************************/
13	13
14		module util.string;
	14	module rt.util.string;
15	15
16	16	private import tango.stdc.string;
…	…
45	45
46	46	if (result == 0)
47		result = ~~cast(int)s1.length - cast(int)s2.length~~;
	47	result = (s1.length<s2.length)?-1:((s1.length==s2.length)?0:1);
48	48
49	49	return result;

trunk/lib/compiler/dmd/rt/util/utf.d

r4357	r4384
1		// ~~utf.d~~
	1	// Written in the D programming language
2	2
3	3	/*
…	…
23	23	*/
24	24
25		// Description of UTF-8 at:
26		// http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8
27		// http://anubis.dkuug.dk/JTC1/SC2/WG2/docs/n1335
28
29
30		module util.utf;
	25	/********************************************
	26	* Encode and decode UTF-8, UTF-16 and UTF-32 strings.
	27	*
	28	* For Win32 systems, the C wchar_t type is UTF-16 and corresponds to the D
	29	* wchar type.
	30	* For linux systems, the C wchar_t type is UTF-32 and corresponds to
	31	* the D utf.dchar type.
	32	*
	33	* UTF character support is restricted to (\u0000 <= character <= \U0010FFFF).
	34	*
	35	* See_Also:
	36	* $(LINK2 http://en.wikipedia.org/wiki/Unicode, Wikipedia)<br>
	37	* $(LINK http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8)<br>
	38	* $(LINK http://anubis.dkuug.dk/JTC1/SC2/WG2/docs/n1335)
	39	* Macros:
	40	* WIKI = Phobos/StdUtf
	41	*/
	42
	43	module rt.util.utf;
	44
31	45
32	46
33	47	extern (C) void onUnicodeError( char[] msg, size_t idx );
	48	/*******************************
	49	* Test if c is a valid UTF-32 character.
	50	*
	51	* \uFFFE and \uFFFF are considered valid by this function,
	52	* as they are permitted for internal use by an application,
	53	* but they are not allowed for interchange by the Unicode standard.
	54	*
	55	* Returns: true if it is, false if not.
	56	*/
34	57
35	58
…	…
80	103	];
81	104
82		uint stride(char[] s, size_t i)
	105	/**
	106	* stride() returns the length of a UTF-8 sequence starting at index i
	107	* in string s.
	108	* Returns:
	109	* The number of bytes in the UTF-8 sequence or
	110	* 0xFF meaning s[i] is not the start of of UTF-8 sequence.
	111	*/
	112	uint stride(in char[] s, size_t i)
83	113	{
84	114	return UTF8stride[s[i]];
85	115	}
86	116
87		uint stride(wchar[] s, size_t i)
	117	/**
	118	* stride() returns the length of a UTF-16 sequence starting at index i
	119	* in string s.
	120	*/
	121	uint stride(in wchar[] s, size_t i)
88	122	{ uint u = s[i];
89	123	return 1 + (u >= 0xD800 && u <= 0xDBFF);
90	124	}
91	125
92		uint stride(dchar[] s, size_t i)
	126	/**
	127	* stride() returns the length of a UTF-32 sequence starting at index i
	128	* in string s.
	129	* Returns: The return value will always be 1.
	130	*/
	131	uint stride(in dchar[] s, size_t i)
93	132	{
94	133	return 1;
…	…
96	135
97	136	/*******************************************
98		* Given an index i~~nto an array of char's~~,
99		* and assuming that index is at the start of a UTF character,
100		* determine the number of UCS characters up to that index.
101		*/
102
103		size_t toUCSindex(char[] s, size_t i)
	137	* Given an index i into an array of characters s[],
	138	* and assuming that index i is at the start of a UTF character,
	139	* determine the number of UCS characters up to that index i.
	140	*/
	141
	142	size_t toUCSindex(in char[] s, size_t i)
104	143	{
105	144	size_t n;
…	…
122	161	}
123	162
124		size_t toUCSindex(wchar[] s, size_t i)
	163	/** ditto */
	164	size_t toUCSindex(in wchar[] s, size_t i)
125	165	{
126	166	size_t n;
…	…
141	181	}
142	182
143		size_t toUCSindex(dchar[] s, size_t i)
	183	/** ditto */
	184	size_t toUCSindex(in dchar[] s, size_t i)
144	185	{
145	186	return i;
…	…
147	188
148	189	/******************************************
149		* Given a UCS index ~~into an array of characters~~, return the UTF index.
150		*/
151
152		size_t toUTFindex(char[] s, size_t n)
	190	* Given a UCS index n into an array of characters s[], return the UTF index.
	191	*/
	192
	193	size_t toUTFindex(in char[] s, size_t n)
153	194	{
154	195	size_t i;
…	…
164	205	}
165	206
166		size_t toUTFindex(wchar[] s, size_t n)
	207	/** ditto */
	208	size_t toUTFindex(in wchar[] s, size_t n)
167	209	{
168	210	size_t i;
…	…
176	218	}
177	219
178		size_t toUTFindex(dchar[] s, size_t n)
	220	/** ditto */
	221	size_t toUTFindex(in dchar[] s, size_t n)
179	222	{
180	223	return n;
…	…
183	226	/* =================== Decode ======================= */
184	227
185		dchar decode(char[] s, inout size_t idx)
	228	/***************
	229	* Decodes and returns character starting at s[idx]. idx is advanced past the
	230	* decoded character. If the character is not well formed, a UtfException is
	231	* thrown and idx remains unchanged.
	232	*/
	233	dchar decode(in char[] s, inout size_t idx)
186	234	in
187	235	{
…	…
276	324	debug(utf) printf("utf.decode.unittest\n");
277	325
278		static ~~char[] s1 = "abcd"~~;
	326	static s1 = "abcd"c;
279	327	i = 0;
280	328	c = decode(s1, i);
…	…
285	333	assert(i == 2);
286	334
287		static ~~char[] s2 = "\xC2\xA9"~~;
	335	static s2 = "\xC2\xA9"c;
288	336	i = 0;
289	337	c = decode(s2, i);
…	…
291	339	assert(i == 2);
292	340
293		static ~~char[] s3 = "\xE2\x89\xA0"~~;
	341	static s3 = "\xE2\x89\xA0"c;
294	342	i = 0;
295	343	c = decode(s3, i);
…	…
322	370	}
323	371
324		/~~**************************************************~~/
325
326		dchar decode(wchar[] s, inout size_t idx)
	372	/** ditto */
	373
	374	dchar decode(in wchar[] s, inout size_t idx)
327	375	in
328	376	{
…	…
380	428	}
381	429
382		/~~**************************************************~~/
383
384		dchar decode(dchar[] s, inout size_t idx)
	430	/** ditto */
	431
	432	dchar decode(in dchar[] s, inout size_t idx)
385	433	in
386	434	{
…	…
405	453	/* =================== Encode ======================= */
406	454
	455	/*******************************
	456	* Encodes character c and appends it to array s[].
	457	*/
407	458	void encode(inout char[] s, dchar c)
408	459	in
…	…
457	508	debug(utf) printf("utf.encode.unittest\n");
458	509
459		char[] s = "abcd";
	510	char[] s = "abcd".dup;
460	511	encode(s, cast(dchar)'a');
461	512	assert(s.length == 5);
…	…
472	523	}
473	524
474		/~~**************************************************~~/
	525	/** ditto */
475	526
476	527	void encode(inout wchar[] s, dchar c)
…	…
498	549	}
499	550
	551	/** ditto */
500	552	void encode(inout dchar[] s, dchar c)
501	553	in
…	…
581	633	}
582	634
	635	/*******************
	636	* Encodes string s into UTF-8 and returns the encoded string.
	637	*/
583	638	char[] toUTF8(char[] s)
584	639	in
…	…
591	646	}
592	647
593		char[] toUTF8(wchar[] s)
	648	/** ditto */
	649	char[] toUTF8(in wchar[] s)
594	650	{
595	651	char[] r;
…	…
617	673	}
618	674
619		char[] toUTF8(dchar[] s)
	675	/** ditto */
	676	char[] toUTF8(in dchar[] s)
620	677	{
621	678	char[] r;
…	…
665	722	}
666	723
667		wchar[] toUTF16(char[] s)
	724	/****************
	725	* Encodes string s into UTF-16 and returns the encoded string.
	726	* toUTF16z() is suitable for calling the 'W' functions in the Win32 API that take
	727	* an LPWSTR or LPCWSTR argument.
	728	*/
	729	wchar[] toUTF16(in char[] s)
668	730	{
669	731	wchar[] r;
…	…
689	751	}
690	752
691		wchar* toUTF16z(char[] s)
	753	alias wchar* wptr;
	754	/** ditto */
	755	wptr toUTF16z(in char[] s)
692	756	{
693	757	wchar[] r;
…	…
714	778	}
715	779
	780	/** ditto */
716	781	wchar[] toUTF16(wchar[] s)
717	782	in
…	…
724	789	}
725	790
726		wchar[] toUTF16(dchar[] s)
	791	/** ditto */
	792	wchar[] toUTF16(in dchar[] s)
727	793	{
728	794	wchar[] r;
…	…
740	806	/* =================== Conversion to UTF32 ======================= */
741	807
742		dchar[] toUTF32(char[] s)
	808	/*****
	809	* Encodes string s into UTF-32 and returns the encoded string.
	810	*/
	811	dchar[] toUTF32(in char[] s)
743	812	{
744	813	dchar[] r;
…	…
756	825	r[j++] = c;
757	826	}
758		return r[0 .. j];
759		}
760
761		dchar[] toUTF32(wchar[] s)
	827	return cast(dchar[])r[0 .. j];
	828	}
	829
	830	/** ditto */
	831	dchar[] toUTF32(in wchar[] s)
762	832	{
763	833	dchar[] r;
…	…
778	848	}
779	849
	850	/** ditto */
780	851	dchar[] toUTF32(dchar[] s)
781	852	in

trunk/lib/compiler/dmd/win32.mak

r4359	r4384
68	68	include OBJECTDEFS.inc
69	69
70		~~OBJ_WIN= \~~
71		~~rt/deh.obj~~
72
73	70	ALL_OBJECTS= $(ALL_OBJS) $(OBJ_WIN)
74	71	# $(patsubst %.o,%.obj,$(ALL_OBJS)) $(OBJ_WIN)

trunk/lib/dmd-posix.mak

r3997	r4384
3	3	# Targets:
4	4	# make
5		# Same as make all
	5	# same as make lib
	6	# make all
	7	# make lib-release lib-debug and doc
6	8	# make lib
7		# Build the runtime library
	9	# Build the compiler runtime library (which version depends on VERSION, name on LIB_BUILD)
	10	# make lib-release
	11	# Build the release version of the compiler runtime library
	12	# make lib-debug
	13	# Build the debug version of the compiler runtime library
8	14	# make doc
9	15	# Generate documentation
10	16	# make clean
11	17	# Delete unneeded files created by build process
	18	# make clean-all
	19	# Delete unneeded files created by build process and the libraries
	20	# make unittest
	21	# Performs the unittests of the runtime library
12	22
13		LIB_TARGET=libtango-base-dmd.a
14		LIB_MASK=libtango-base-dmd*.a
	23	LIB_BASE=libtango-base-dmd
	24	LIB_BUILD=
	25	LIB_TARGET=$(LIB_BASE)$(LIB_BUILD).a
	26	LIB_MASK=$(LIB_BASE)*.a
15	27
16	28	DIR_CC=./common/tango
…	…
28	40	ADD_CFLAGS=-m32
29	41	ADD_DFLAGS=
	42	#-g -debug -debug=PRINTF
	43
	44	.PHONY : lib lib-release lib-debug unittest all doc clean install clean-all targets
30	45
31	46	targets : lib doc
32		all : lib doc
	47	all : lib-release lib-debug doc
33	48
34	49	######################################################
…	…
41	56
42	57	######################################################
	58	unittest :
	59	make -fdmd-posix.mak clean DC="$(DC)" LIB_BUILD="" VERSION="$(VERSION)"
	60	make -fdmd-posix.mak lib DC="$(DC)" LIB_BUILD="" VERSION="$(VERSION)" \
	61	ADD_CFLAGS="$(ADD_CFLAGS)" ADD_DFLAGS="$(ADD_DFLAGS) -unittest -debug=UnitTest" \
	62	SYSTEM_VERSION="$(SYSTEM_VERSION)"
	63	lib-release :
	64	make -fdmd-posix.mak clean DC="$(DC)" LIB_BUILD="" VERSION="$(VERSION)"
	65	make -fdmd-posix.mak DC="$(DC)" LIB_BUILD="" VERSION=release lib \
	66	ADD_CFLAGS="$(ADD_CFLAGS)" ADD_DFLAGS="$(ADD_DFLAGS)" SYSTEM_VERSION="$(SYSTEM_VERSION)"
	67	lib-debug :
	68	make -fdmd-posix.mak clean DC="$(DC)" LIB_BUILD="" VERSION="$(VERSION)"
	69	make -fdmd-posix.mak DC="$(DC)" LIB_BUILD="-d" VERSION=debug lib \
	70	ADD_CFLAGS="$(ADD_CFLAGS)" ADD_DFLAGS="$(ADD_DFLAGS)" SYSTEM_VERSION="$(SYSTEM_VERSION)"
43	71
44		lib : $(ALL_OBJS)
45		make -C $(DIR_CC) -fposix.mak lib DC=$(DC) ADD_DFLAGS="$(ADD_DFLAGS)" ADD_CFLAGS="$(ADD_CFLAGS)"
46		make -C $(DIR_RT) -fposix.mak lib DC=$(DC) ADD_DFLAGS="$(ADD_DFLAGS)" ADD_CFLAGS="$(ADD_CFLAGS)"
47		make -C $(DIR_GC) -fposix.mak lib DC=$(DC) ADD_DFLAGS="$(ADD_DFLAGS)" ADD_CFLAGS="$(ADD_CFLAGS)"
	72	lib : $(LIB_TARGET)
	73	$(LIB_TARGET) : $(ALL_OBJS)
	74	make -C $(DIR_CC) -fposix.mak lib DC=$(DC) ADD_DFLAGS="$(ADD_DFLAGS)" ADD_CFLAGS="$(ADD_CFLAGS)" \
	75	VERSION="$(VERSION)" LIB_BUILD="$(LIB_BUILD)" SYSTEM_VERSION="$(SYSTEM_VERSION)"
	76	make -C $(DIR_RT) -fposix.mak lib DC=$(DC) ADD_DFLAGS="$(ADD_DFLAGS)" ADD_CFLAGS="$(ADD_CFLAGS)" \
	77	VERSION="$(VERSION)" LIB_BUILD="$(LIB_BUILD)" SYSTEM_VERSION="$(SYSTEM_VERSION)"
	78	make -C $(DIR_GC) -fposix.mak lib DC=$(DC) ADD_DFLAGS="$(ADD_DFLAGS)" ADD_CFLAGS="$(ADD_CFLAGS)" \
	79	VERSION="$(VERSION)" LIB_BUILD="$(LIB_BUILD)" SYSTEM_VERSION="$(SYSTEM_VERSION)"
48	80	find . -name "libphobos*.a" \| xargs $(RM)
49		$(LC) $(LIB_TARGET) `find $(DIR_CC) -name "*.o" \| xargs echo`
50		$(LC) $(LIB_TARGET) `find $(DIR_RT) -name "*.o" \| xargs echo`
51		$(LC) $(LIB_TARGET) `find $(DIR_GC) -name "*.o" \| xargs echo`
	81	$(RM) $@
	82	$(LC) $@ `find $(DIR_CC) -name "*.o" \| xargs echo`
	83	$(LC) $@ `find $(DIR_RT) -name "*.o" \| xargs echo`
	84	$(LC) $@ `find $(DIR_GC) -name "*.o" \| xargs echo`
	85	ifneq ($(RANLIB),)
	86	$(RANLIB) $@
	87	endif
52	88
53	89	doc : $(ALL_DOCS)
…	…
61	97	clean :
62	98	$(RM) $(ALL_OBJS)
63		~~$(RM) $(ALL_DOCS)~~
64	99	make -C $(DIR_CC) -fposix.mak clean
65	100	make -C $(DIR_RT) -fposix.mak clean
66	101	make -C $(DIR_GC) -fposix.mak clean
67		# $(RM) $(LIB_MASK)
	102
	103	clean-all : clean
	104	make -C $(DIR_CC) -fposix.mak clean-all
	105	make -C $(DIR_RT) -fposix.mak clean-all
	106	make -C $(DIR_GC) -fposix.mak clean-all
	107	$(RM) $(ALL_DOCS)
	108	$(RM) $(LIB_MASK)
68	109
69	110	install :

trunk/lib/dmd-win32.mak

r2863	r4384
56	56	make -fwin32.mak lib DC=$(DC) ADD_DFLAGS="$(ADD_DFLAGS)" ADD_CFLAGS="$(ADD_CFLAGS)"
57	57	cd ..\..
58		$(RM) phobos*.lib
	58	$(RM) phobos*.lib $(LIB_TARGET)
59	59	$(LC) -c -n $(LIB_TARGET) $(LIB_CC) $(LIB_RT) $(LIB_GC)
60	60

trunk/lib/gc/basic/gc.d

r4097	r4384
54	54	}
55	55
	56	version (DigitalMars) version(OSX) {
	57	extern(C) void _d_osx_image_init();
	58	}
	59
56	60	extern (C) void thread_init();
57	61
…	…
71	75	}
72	76	_gc.initialize();
	77	version (DigitalMars) version(OSX) {
	78	_d_osx_image_init();
	79	}
73	80	// NOTE: The GC must initialize the thread library
74	81	// before its first collection.

trunk/lib/gc/basic/gcx.d

r4172	r4384
54	54	private import cstring = tango.stdc.string : memcpy, memmove, memset;
55	55	debug(THREADINVARIANT) private import tango.stdc.posix.pthread;
56		debug private import tango.stdc.stdio;
	56	debug(PRINTF) private import tango.stdc.posix.pthread : pthread_self, pthread_t;
	57	debug private import tango.stdc.stdio : printf;
57	58
58	59	version (GNU)

trunk/lib/gc/basic/posix.mak

r4325	r4384
11	11	# Delete unneeded files created by build process
12	12
13		LIB_TARGET=libtango-gc-basic.a
14		LIB_MASK=libtango-gc-basic*.a
	13	LIB_BASE=libtango-gc-basic
	14	LIB_BUILD=
	15	LIB_TARGET=$(LIB_BASE)$(LIB_BUILD).a
	16	LIB_MASK=$(LIB_BASE)*.a
15	17
16	18	CP=cp -f
…	…
22	24	SYSTEM_VERSION=
23	25
24		CFLAGS=-O $(ADD_CFLAGS)
25		#CFLAGS=-g $(ADD_CFLAGS)
	26	CFLAGS_RELEASE=-O $(ADD_CFLAGS)
	27	CFLAGS_DEBUG=-g $(ADD_CFLAGS)
	28	DFLAGS_RELEASE=-release -O -inline -w -nofloat $(SYSTEM_VERSION) $(ADD_DFLAGS) -I../../common -I../../..
	29	DFLAGS_DEBUG=-g -w -nofloat $(SYSTEM_VERSION) $(ADD_DFLAGS) -I../../common -I../../..
	30	TFLAGS_RELEASE=-O -inline -w -nofloat $(SYSTEM_VERSION) $(ADD_DFLAGS)
	31	TFLAGS_DEBUG=-g -w -nofloat $(SYSTEM_VERSION) $(ADD_DFLAGS)
	32	DOCFLAGS=-version=DDoc $(SYSTEM_VERSION)
26	33
27		DFLAGS=-release -O -inline -w -nofloat $(SYSTEM_VERSION) $(ADD_DFLAGS)
28		#DFLAGS=-g -w -nofloat -version=Posix $(ADD_DFLAGS)
29
30		TFLAGS=-O -inline -w -nofloat $(SYSTEM_VERSION) $(ADD_DFLAGS)
31		#TFLAGS=-g -w -nofloat -version=Posix $(ADD_DFLAGS)
32
33		DOCFLAGS=-version=DDoc $(SYSTEM_VERSION)
	34	ifeq ($(VERSION),debug)
	35	CFLAGS=$(CFLAGS_DEBUG)
	36	DFLAGS=$(DFLAGS_DEBUG)
	37	TFLAGS=$(TFLAGS_DEBUG)
	38	else
	39	CFLAGS=$(CFLAGS_RELEASE)
	40	DFLAGS=$(DFLAGS_RELEASE)
	41	TFLAGS=$(TFLAGS_RELEASE)
	42	endif
34	43
35	44	CC=gcc
…	…
40	49
41	50	.SUFFIXES: .s .S .c .cpp .d .html .o
	51	.PHONY : lib lib-release lib-debug unittest all doc clean install clean-all
42	52
43	53	.s.o:
…	…
61	71
62	72	targets : lib doc
63		all : lib doc
64		lib : basic.lib
65		doc : basic.doc
	73	all : lib-release lib-debug doc
66	74
67	75	######################################################
…	…
79	87
80	88	######################################################
	89	unittest :
	90	make -fposix.mak clean DC="$(DC)" LIB_BUILD="" VERSION="$(VERSION)"
	91	make -fposix.mak lib DC="$(DC)" LIB_BUILD="" VERSION="$(VERSION)" \
	92	ADD_CFLAGS="$(ADD_CFLAGS)" ADD_DFLAGS="$(ADD_DFLAGS) -unittest -debug=UnitTest" \
	93	SYSTEM_VERSION="$(SYSTEM_VERSION)"
	94	lib-release :
	95	make -fposix.mak clean DC="$(DC)" LIB_BUILD="" VERSION="$(VERSION)"
	96	make -fposix.mak DC="$(DC)" LIB_BUILD="" VERSION=release lib \
	97	ADD_CFLAGS="$(ADD_CFLAGS)" ADD_DFLAGS="$(ADD_DFLAGS)" SYSTEM_VERSION="$(SYSTEM_VERSION)"
	98	lib-debug :
	99	make -fposix.mak clean DC="$(DC)" LIB_BUILD="" VERSION="$(VERSION)"
	100	make -fposix.mak DC="$(DC)" LIB_BUILD="-d" VERSION=debug lib \
	101	ADD_CFLAGS="$(ADD_CFLAGS)" ADD_DFLAGS="$(ADD_DFLAGS)" SYSTEM_VERSION="$(SYSTEM_VERSION)"
81	102
82		basic.lib : $(LIB_TARGET)
	103	######################################################
	104
	105	lib : $(LIB_TARGET)
83	106
84	107	$(LIB_TARGET) : $(ALL_OBJS)
…	…
86	109	$(LC) $@ $(ALL_OBJS)
87	110
88		~~basic.~~doc : $(ALL_DOCS)
	111	doc : $(ALL_DOCS)
89	112	echo No documentation available.
90	113
…	…
95	118	$(RM) $(ALL_OBJS)
96	119	$(RM) $(ALL_DOCS)
	120
	121	clean-all : clean
97	122	$(RM) $(LIB_MASK)
98	123

trunk/lib/install-dmd.sh

r3711	r4384
56	56	LIBPREFIX="$PREFIX"
57	57	INCLPREFIX="$PREFIX"
58		BASELIB="libtango-base-dmd.a"
	58	BASELIB="libtango-base-dmd*.a"
59	59
60	60	while [ "$#" != "0" ]

trunk/lib/unittest.sh

r4341	r4384
102	102	tango/util/collection/impl/.d tango/util/log/model/.d tango/util/log/*.d \
103	103	tango/util/container/.d tango/util/container/model/.d tango/util/container/more/*.d \
104		tango/time/chrono/.d tango/time/.d -dc=$DC-~~posix~~-tango
	104	tango/time/chrono/.d tango/time/.d -dc=$DC-darwin-tango
105	105
106	106	mv $EXE lib/$EXE

Navigation

Legend:

Download in other formats: