#2038: 64Bit.4.patch - tango - D Programming Language - Trac

build/script/unittest.sh

old	new
33	33	OPTIONS="-oq -d-debug -d-debug=UnitTest"
34	34	fi
35	35
36		build/bin/$~~PLATFORM$ARCH/bob -v -r=$DC -c=$DC -p=$PLATFORM -l=libtango-$DC-tst -o="~~-g -unittest $OPTIONS" .
	36	build/bin/${PLATFORM}32/bob -v -r=$DC -c=$DC -p=$PLATFORM -l=libtango-$DC-tst -o="-m64 -g -unittest $OPTIONS" .
37	37
38	38	if ! which $DC >& /dev/null
39	39	then
…	…
100	100	fi
101	101
102	102	echo "$DC $EXE.d $DFILES -g $OPTIONS -unittest -L-L. -L-ltango-$DC-tst $DL -L-lz -L-lbz2"
103		$DC $EXE.d $DFILES -g $OPTIONS -unittest -L-L. -L-ltango-$DC-tst $DL -L-lz -L-lbz2 && rm $EXE.d && rm libtango-$DC-tst.a
	103	$DC $EXE.d $DFILES -g $OPTIONS -m$ARCH -unittest -L-L. -L-ltango-$DC-tst $DL -L-lz -L-lbz2 && rm $EXE.d && rm libtango-$DC-tst.a
104	104
105	105	./runUnittests_$DC
106	106

build/src/bob.d

old	new
38	38	new FreeBSD (args);
39	39	new Solaris (args);
40	40	new Windows (args);
41		stdout.formatln ("{} files", FileFilter.builder(args.os, args.compiler)());
	41	Stdout.formatln ("{} files", FileFilter.builder(args.os, args.compiler)());
42	42	}
43	43	}
44	44
…	…
170	170
171	171	if (args.core) {
172	172	foreach (file; scan(".c")) {
173		auto obj = compile (file, gcc32);
	173	auto obj = compile (file, gcc);
174	174	addToLib(obj);
175	175	}
176	176
177	177	foreach (file; scan(".S")) {
178		auto obj = compile (file, gcc32);
	178	auto obj = compile (file, gcc);
179	179	addToLib(obj);
180	180	}
181	181	}
…	…
780	780	if (args.verbose)
781	781	{
782	782	foreach (str; cmd)
783		stdout (str)(' ');
784		stdout.newline;
	783	Stdout (str)(' ');
	784	Stdout.newline;
785	785	}
786	786
787	787	if (! args.inhibit)
…	…
794	794	proc.copyEnv (true);
795	795
796	796	proc.execute();
797		stdout.stream.copy (proc.stderr);
798		stdout.stream.copy (proc.stdout);
	797	Stdout.stream.copy (proc.stderr);
	798	Stdout.stream.copy (proc.stdout);
799	799	auto result = proc.wait;
800	800	if (result.reason != Process.Result.Exit)
801	801	throw new Exception (result.toString);

object.di

old	new
119	119	equals_t equals(void p1, void p2);
120	120	/// compares the types of this TypeInfo stored at p1 and p2
121	121	int compare(void p1, void p2);
	122	/// Return alignment of type
	123	size_t talign() { return tsize(); }
122	124	/// returns the size of a type with the current TypeInfo
123	125	size_t tsize();
124	126	/// swaps the two types stored at p1 and p2
…	…
131	133	PointerMap pointermap();
132	134	/// offsets of the various elements
133	135	OffsetTypeInfo[] offTi();
	136
	137	/** Return internal info on arguments fitting into 8byte.
	138	* See X86-64 ABI 3.2.3
	139	*/
	140	version (X86_64) int argTypes(out TypeInfo arg1, out TypeInfo arg2);
134	141	}
135	142
136	143	class TypeInfo_Typedef : TypeInfo

tango/text/convert/Layout.d

old	new
45	45	{
46	46	private import tango.time.Time;
47	47	private import tango.text.convert.DateTime;
48		}
	48	}
49	49
50	50
51	51	/*******************************************************************************
…	…
66	66	alias void* Arg;
67	67	alias va_list ArgList;
68	68	}
	69	else version(DigitalMars)
	70	{
	71	private import tango.core.Vararg;
	72	alias void* Arg;
	73	alias va_list ArgList;
	74	}
69	75	else
70	76	{
71	77	alias void* Arg;
…	…
83	89	{
84	90	public alias convert opCall;
85	91	public alias uint delegate (T[]) Sink;
86
	92
87	93	static if (is (DateTimeLocale))
88	94	private DateTimeLocale* dateTime = &DateTimeDefault;
89	95
90	96	/**********************************************************************
91	97
92	98	Return shared instance
93
	99
94	100	Note that this is not threadsafe, and that static-ctor
95	101	usage doesn't get invoked appropriately (compiler bug)
96	102
…	…
252	258
253	259	Arg[64] arglist = void;
254	260	ArgU[64] storedArgs = void;
255
	261
256	262	foreach (i, arg; arguments)
257	263	{
258	264	static if (is(typeof(args.ptr)))
…	…
271	277	arglist[i] = &(storedArgs[i].f);
272	278	converted = true;
273	279	break;
274
	280
275	281	case TypeCode.CFLOAT:
276	282	storedArgs[i].cf = va_arg!(cfloat)(args);
277	283	arglist[i] = &(storedArgs[i].cf);
278	284	converted = true;
279	285	break;
280
	286
281	287	case TypeCode.DOUBLE, TypeCode.IDOUBLE:
282	288	storedArgs[i].d = va_arg!(double)(args);
283	289	arglist[i] = &(storedArgs[i].d);
284	290	converted = true;
285	291	break;
286
	292
287	293	case TypeCode.CDOUBLE:
288	294	storedArgs[i].cd = va_arg!(cdouble)(args);
289	295	arglist[i] = &(storedArgs[i].cd);
290	296	converted = true;
291	297	break;
292
	298
293	299	case TypeCode.REAL, TypeCode.IREAL:
294	300	storedArgs[i].r = va_arg!(real)(args);
295	301	arglist[i] = &(storedArgs[i].r);
…	…
301	307	arglist[i] = &(storedArgs[i].cr);
302	308	converted = true;
303	309	break;
304
	310
305	311	default:
306	312	break;
307	313	}
…	…
524	530	}
525	531	length += sink ("]");
526	532	}
527		else
	533	else
528	534	if (_ti.classinfo.name.length is 25 && _ti.classinfo.name[9..$] == "AssociativeArray")
529	535	{
530	536	auto tiAsso = cast(TypeInfo_AssociativeArray)_ti;
…	…
538	544
539	545	length += sink ("{");
540	546	bool first = true;
541
	547
542	548	size_t roundUp (size_t sz)
543	549	{
544	550	return (sz + (void).sizeof -1) & ~((void).sizeof - 1);
…	…
560	566	}
561	567	length += sink ("}");
562	568	}
563		else
	569	else
564	570	if (_ti.classinfo.name[9] is TypeCode.ARRAY)
565	571	{
566	572	if (_ti is typeid(char[]))
567	573	emit (Utf.fromString8 (cast(char[]) _arg, result));
568	574	else
569		if (_ti is typeid(wchar[]))
	575	if (_ti is typeid(wchar[]))
570	576	emit (Utf.fromString16 (cast(wchar[]) _arg, result));
571	577	else
572	578	if (_ti is typeid(dchar[]))
…	…
596	602	emit (dispatch (result, format, _ti, _arg));
597	603	}
598	604
599
	605
600	606	// process this argument
601	607	if (index >= ti.length)
602	608	emit ("{invalid index}");
…	…
691	697
692	698	case TypeCode.STRUCT:
693	699	auto s = cast(TypeInfo_Struct) type;
694		if (s.xtoString)
	700	if (s.xtoString)
695	701	{
696	702	char[] delegate() toString;
697	703	toString.ptr = p;
…	…
734	740	version (WithExtensions)
735	741	{
736	742	result = Extensions!(T).run (type, result, p, format);
737		return (result) ? result :
	743	return (result) ? result :
738	744	"{unhandled argument type: " ~ Utf.fromString8 (type.toString, result) ~ "}";
739	745	}
740	746	else
…	…
808	814	}
809	815	break;
810	816	}
811
	817
812	818	return Float.format (output, v, dec, exp, pad);
813	819	}
814	820
…	…
848	854	{
849	855	return floatingTail (result, val.im, format, "*1i");
850	856	}
851
	857
852	858	/**********************************************************************
853	859
854	860	format a complex value
…	…
859	865	{
860	866	static bool signed (real x)
861	867	{
862		static if (real.sizeof is 4)
	868	static if (real.sizeof is 4)
863	869	return ((cast(uint )&x) & 0x8000_0000) != 0;
864	870	else
865		static if (real.sizeof is 8)
	871	static if (real.sizeof is 8)
866	872	return ((cast(ulong )&x) & 0x8000_0000_0000_0000) != 0;
867	873	else
868	874	{
…	…
935	941	CREAL = 'c',
936	942	IFLOAT = 'o',
937	943	IDOUBLE = 'p',
938		IREAL = 'j'
	944	IREAL = 'j'
939	945	}
940	946
941	947
…	…
1086	1092	assert( Formatter( "{:f.}", 1.237 ) == "1.24" );
1087	1093	assert( Formatter( "{:f.}", 1.000 ) == "1" );
1088	1094	assert( Formatter( "{:f2.}", 200.001 ) == "200");
1089
	1095
1090	1096	// array output
1091	1097	int[] a = [ 51, 52, 53, 54, 55 ];
1092	1098	assert( Formatter( "{}", a ) == "[51, 52, 53, 54, 55]" );
…	…
1099	1105	ushort[3] c = [ cast(ushort)51, 52, 53 ];
1100	1106	assert( Formatter( "{}", c ) == "[51, 52, 53]" );
1101	1107
1102		// integer AA
	1108	// integer AA
1103	1109	ushort[long] d;
1104	1110	d[234] = 2;
1105	1111	d[345] = 3;
1106	1112	assert( Formatter( "{}", d ) == "{234 => 2, 345 => 3}" \|\|
1107	1113	Formatter( "{}", d ) == "{345 => 3, 234 => 2}");
1108
1109		// bool/string AA
	1114
	1115	// bool/string AA
1110	1116	bool[char[]] e;
1111	1117	e[ "key".dup ] = true;
1112	1118	e[ "value".dup ] = false;
1113	1119	assert( Formatter( "{}", e ) == "{key => true, value => false}" \|\|
1114	1120	Formatter( "{}", e ) == "{value => false, key => true}");
1115	1121
1116		// string/double AA
	1122	// string/double AA
1117	1123	char[][ double ] f;
1118	1124	f[ 1.0 ] = "one".dup;
1119	1125	f[ 3.14 ] = "PI".dup;
…	…
1158	1164
1159	1165	struct S
1160	1166	{
1161		char[] toString () {return "foo";}
	1167	char[] toString () {return "foo";}
1162	1168	}
1163	1169
1164	1170	S s;

tango/text/Text.d

old	new
125	125
126	126	// reserve some space for inserts/additions
127	127	Text reserve (int extra);
128
	128
129	129	// write content to stream
130	130	Text write (OutputStream sink);
131	131	}
…	…
213	213
214	214	private import tango.stdc.string : memmove;
215	215
	216	version(DigitalMars)
	217	{
	218	private import tango.core.Vararg;
	219	}
216	220
217	221	/*******************************************************************************
218	222
…	…
285	289
286	290	bool next ()
287	291	{
288		return locate (&engine.forward, text.slice,
	292	return locate (&engine.forward, text.slice,
289	293	text.selectPoint + text.selectLength);
290	294	}
291	295
292	296	/***************************************************************
293	297
294		Returns true if there is a match within the
	298	Returns true if there is a match within the
295	299	associated text
296	300
297	301	***************************************************************/
298	302
299	303	bool within ()
300		{
	304	{
301	305	return engine.within (text.slice);
302	306	}
303	307
304	308	/***************************************************************
305
	309
306	310	Returns number of matches within the associated
307	311	text
308	312
309	313	***************************************************************/
310	314
311	315	size_t count ()
312		{
	316	{
313	317	return engine.count (text.slice);
314	318	}
315	319
…	…
320	324	***************************************************************/
321	325
322	326	void replace (T chr)
323		{
324		replace ((&chr)[0..1]);
	327	{
	328	replace ((&chr)[0..1]);
325	329	}
326	330
327	331	/***************************************************************
…	…
331	335	***************************************************************/
332	336
333	337	void replace (T[] sub = null)
334		{
	338	{
335	339	auto dst = new T[text.length];
336	340	dst.length = 0;
337	341
…	…
339	343	dst ~= token;
340	344	text.set (dst, false);
341	345	}
342
	346
343	347	/***************************************************************
344	348
345	349	locate pattern index and select as appropriate
…	…
379	383
380	384	Note: A character like 'a' will be implicitly converted to
381	385	uint and thus will be accepted for this constructor, making
382		it appear like you can initialize a Text instance with a
	386	it appear like you can initialize a Text instance with a
383	387	single character, something which is not supported.
384	388
385	389	***********************************************************************/
…	…
431	435	this class. This can be useful when wrapping an array
432	436	"temporarily" with a stack-based Text.
433	437
434		Also resets the curent selection to null
	438	Also resets the curent selection to null
435	439
436	440	***********************************************************************/
437	441
…	…
456	460	these methods. This can be useful when wrapping an array
457	461	"temporarily" with a stack-based Text.
458	462
459		Also resets the curent selection to null
	463	Also resets the curent selection to null
460	464
461	465	***********************************************************************/
462	466
…	…
530	534	}
531	535
532	536	/***********************************************************************
533
	537
534	538	Return a search iterator for a given pattern. The iterator
535	539	sets the current text selection as appropriate. For example:
536	540	---
…	…
735	739	deprecated: use format() instead
736	740
737	741	***********************************************************************/
738
	742
739	743	deprecated final Text append (int v, T[] fmt = null)
740	744	{
741	745	return append (cast(long) v, fmt);
…	…
780	784	final Text append (InputStream source)
781	785	{
782	786	T[8192/T.sizeof] tmp = void;
783		while (true)
	787	while (true)
784	788	{
785		auto len = source.read (tmp);
786		if (len is source.Eof)
787		break;
	789	auto len = source.read (tmp);
	790	if (len is source.Eof)
	791	break;
788	792
789	793	// check to ensure UTF conversion is ok
790	794	assert ((len & (T.sizeof-1)) is 0);
…	…
1635	1639	*******************************************************************************/
1636	1640
1637	1641	debug (UnitTest)
1638		{
	1642	{
1639	1643	import tango.io.device.Array;
1640	1644
1641	1645	//void main() {}

tango/io/stream/Snoop.d

old	new
17	17
18	18	private import tango.text.convert.Format;
19	19
	20	version(DigitalMars)
	21	{
	22	private import tango.core.Vararg;
	23	}
	24
20	25	private alias void delegate(char[]) Snoop;
21	26
22	27	/*******************************************************************************

tango/io/stream/Format.d

old	new
16	16
17	17	private import tango.text.convert.Layout;
18	18
	19	version(DigitalMars)
	20	{
	21	private import tango.core.Vararg;
	22	}
	23
19	24	/*******************************************************************************
20	25
21	26	A bridge between a Layout instance and a stream. This is used for

tango/core/rt/gc/basic/gcx.d

old	new
2344	2344	}
2345	2345	else
2346	2346	{
2347		~~asm~~
	2347	version (D_InlineAsm_X86)
2348	2348	{
2349		pushad ;
2350		mov sp[EBP],ESP ;
	2349	asm
	2350	{
	2351	pushad ;
	2352	mov sp[EBP],ESP ;
	2353	}
2351	2354	}
	2355	else version (D_InlineAsm_X86_64)
	2356	{
	2357	asm
	2358	{
	2359	push RAX ;
	2360	push RBX ;
	2361	push RCX ;
	2362	push RDX ;
	2363	push RSI ;
	2364	push RDI ;
	2365	push RBP ;
	2366	push R8 ;
	2367	push R9 ;
	2368	push R10 ;
	2369	push R11 ;
	2370	push R12 ;
	2371	push R13 ;
	2372	push R14 ;
	2373	push R15 ;
	2374	push EAX ; // 16 byte align the stack
	2375	}
2352	2376	}
	2377	else
	2378	{
	2379	static assert( false, "Architecture not supported." );
	2380	}
	2381	}
2353	2382	result = fullcollect(sp);
2354	2383	version (GNU)
2355	2384	{
…	…
2519	2548	for (n = 0; n < npools; n++)
2520	2549	{ size_t pn;
2521	2550	size_t ncommitted;
2522		~~uint* bbase;~~
2523	2551
2524	2552	pool = pooltable[n];
2525		bbase = pool.mark.base();
	2553	auto bbase = pool.mark.base();
2526	2554	ncommitted = pool.ncommitted;
2527	2555	for (pn = 0; pn < ncommitted; pn++, bbase += PAGESIZE / (32 * 16))
2528	2556	{

tango/core/rt/gc/basic/gcbits.d

old	new
50	50
51	51	struct GCBits
52	52	{
53		const int BITS_PER_WORD = 32;
54		const int BITS_SHIFT = 5;
55		const int BITS_MASK = 31;
	53	alias size_t wordtype;
56	54
57		uint* data = null;
	55	const BITS_PER_WORD = (wordtype.sizeof * 8);
	56	const BITS_SHIFT = (wordtype.sizeof == 8 ? 6 : 5);
	57	const BITS_MASK = (BITS_PER_WORD - 1);
	58	const BITS_1 = cast(wordtype)1;
	59
	60	wordtype* data = null;
58	61	size_t nwords = 0; // allocated words in data[] excluding sentinals
59	62	size_t nbits = 0; // number of bits in data[] excluding sentinals
60	63
…	…
79	82	{
80	83	this.nbits = nbits;
81	84	nwords = (nbits + (BITS_PER_WORD - 1)) >> BITS_SHIFT;
82		data = cast(~~uint*)calloc(nwords + 2, uint~~.sizeof);
	85	data = cast(wordtype*)calloc(nwords + 2, wordtype.sizeof);
83	86	if (!data)
84	87	onOutOfMemoryError();
85	88	}
86	89
87		~~uint~~ test(size_t i)
	90	wordtype test(size_t i)
88	91	in
89	92	{
90	93	assert(i < nbits);
…	…
92	95	body
93	96	{
94	97	//return (cast(bit *)(data + 1))[i];
95		return data[1 + (i >> BITS_SHIFT)] & (1 << (i & BITS_MASK));
	98	return data[1 + (i >> BITS_SHIFT)] & (BITS_1 << (i & BITS_MASK));
96	99	}
97	100
98	101	void set(size_t i)
…	…
103	106	body
104	107	{
105	108	//(cast(bit *)(data + 1))[i] = 1;
106		data[1 + (i >> BITS_SHIFT)] \|= (1 << (i & BITS_MASK));
	109	data[1 + (i >> BITS_SHIFT)] \|= (BITS_1 << (i & BITS_MASK));
107	110	}
108	111
109	112	void clear(size_t i)
…	…
114	117	body
115	118	{
116	119	//(cast(bit *)(data + 1))[i] = 0;
117		data[1 + (i >> BITS_SHIFT)] &= ~(1 << (i & BITS_MASK));
	120	data[1 + (i >> BITS_SHIFT)] &= ~(BITS_1 << (i & BITS_MASK));
118	121	}
119	122
120		~~uint~~ testClear(size_t i)
	123	wordtype testClear(size_t i)
121	124	{
122	125	version (bitops)
123	126	{
…	…
136	139	}
137	140	}
138	141	else
139		{ ~~uint~~ result;
	142	{ wordtype result;
140	143
141	144	//result = (cast(bit *)(data + 1))[i];
142	145	//(cast(bit *)(data + 1))[i] = 0;
143	146
144		~~uint~~* p = &data[1 + (i >> BITS_SHIFT)];
145		~~uint mask = (~~1 << (i & BITS_MASK));
	147	wordtype* p = &data[1 + (i >> BITS_SHIFT)];
	148	wordtype mask = (BITS_1 << (i & BITS_MASK));
146	149	result = *p & mask;
147	150	*p &= ~mask;
148	151	return result;
…	…
188	191	for (;d1!=dEnd;++d1)
189	192	*d1=0u;
190	193	} else {
191		memset(data + 1, 0, nwords * ~~uint~~.sizeof);
	194	memset(data + 1, 0, nwords * wordtype.sizeof);
192	195	}
193	196	}
194	197
…	…
200	203	body
201	204	{
202	205	version(MEMCPY_NON_SIG_SAFE) {
203		~~uint~~ * d1=data+1,d2=f.data+1,dEnd=d1+nwords;
	206	wordtype * d1=data+1,d2=f.data+1,dEnd=d1+nwords;
204	207	for (;d1!=dEnd;++d1,++d2)
205	208	d1=d2;
206	209	} else {
207		memcpy(data + 1, f.data + 1, nwords * ~~uint~~.sizeof);
	210	memcpy(data + 1, f.data + 1, nwords * wordtype.sizeof);
208	211	}
209	212	}
210	213
211		~~uint~~* base()
	214	wordtype* base()
212	215	in
213	216	{
214	217	assert(data);

tango/core/rt/compiler/ldc/object_.d

old	new
412	412	/// Compares two instances for <, ==, or >.
413	413	int compare(in void* p1, in void* p2) { return 0; } //throw new Exception("non comparable",__FILE__,__LINE__);
414	414
	415	/// Return alignment of type
	416	size_t talign() { return tsize(); }
	417
415	418	/// Returns size of the type.
416	419	size_t tsize() { return 0; }
417	420

tango/core/rt/compiler/ldc/typeinfo/ti_void.d

old	new
22	22	return cast(byte )p1 - cast(byte )p2;
23	23	}
24	24
	25	override size_t talign()
	26	{
	27	return void.alignof;
	28	}
	29
25	30	override size_t tsize()
26	31	{
27	32	return void.sizeof;

tango/core/rt/compiler/ldc/typeinfo/ti_wchar.d

old	new
21	21	return cast(wchar )p1 - cast(wchar )p2;
22	22	}
23	23
	24	override size_t talign()
	25	{
	26	return wchar.alignof;
	27	}
	28
24	29	override size_t tsize()
25	30	{
26	31	return wchar.sizeof;

tango/core/rt/compiler/ldc/typeinfo/ti_ptr.d

old	new
25	25	return 0;
26	26	}
27	27
	28	override size_t talign()
	29	{
	30	return (void*).alignof;
	31	}
	32
28	33	override size_t tsize()
29	34	{
30	35	return (void*).sizeof;

tango/core/rt/compiler/ldc/typeinfo/ti_Afloat.d

old	new
76	76	return 0;
77	77	}
78	78
	79	override size_t talign()
	80	{
	81	return (float[]).alignof;
	82	}
	83
79	84	override size_t tsize()
80	85	{
81	86	return (float[]).sizeof;

tango/core/rt/compiler/ldc/typeinfo/ti_double.d

old	new
43	43	return _compare(cast(double )p1, cast(double )p2);
44	44	}
45	45
	46	override size_t talign()
	47	{
	48	return double.alignof;
	49	}
	50
46	51	override size_t tsize()
47	52	{
48	53	return double.sizeof;

tango/core/rt/compiler/ldc/typeinfo/ti_delegate.d

old	new
18	18	return cast(dg )p1 == cast(dg )p2;
19	19	}
20	20
	21	override size_t talign()
	22	{
	23	return dg.alignof;
	24	}
	25
21	26	override size_t tsize()
22	27	{
23	28	return dg.sizeof;

tango/core/rt/compiler/ldc/typeinfo/ti_Adouble.d

old	new
76	76	return 0;
77	77	}
78	78
	79	override size_t talign()
	80	{
	81	return (double[]).alignof;
	82	}
	83
79	84	override size_t tsize()
80	85	{
81	86	return (double[]).sizeof;

tango/core/rt/compiler/ldc/typeinfo/ti_char.d

old	new
20	20	return cast(char )p1 - cast(char )p2;
21	21	}
22	22
	23	override size_t talign()
	24	{
	25	return char.alignof;
	26	}
	27
23	28	override size_t tsize()
24	29	{
25	30	return char.sizeof;

tango/core/rt/compiler/ldc/typeinfo/ti_Acdouble.d

old	new
75	75	return 0;
76	76	}
77	77
	78	override size_t talign()
	79	{
	80	return (cdouble[]).alignof;
	81	}
	82
78	83	override size_t tsize()
79	84	{
80	85	return (cdouble[]).sizeof;

tango/core/rt/compiler/ldc/typeinfo/ti_uint.d

old	new
26	26	return 0;
27	27	}
28	28
	29	override size_t talign()
	30	{
	31	return uint.alignof;
	32	}
	33
29	34	override size_t tsize()
30	35	{
31	36	return uint.sizeof;

tango/core/rt/compiler/ldc/typeinfo/ti_AC.d

old	new
82	82	return 0;
83	83	}
84	84
	85	override size_t talign()
	86	{
	87	return (Object[]).alignof;
	88	}
	89
85	90	override size_t tsize()
86	91	{
87	92	return (Object[]).sizeof;

tango/core/rt/compiler/ldc/typeinfo/ti_ulong.d

old	new
31	31	return 0;
32	32	}
33	33
	34	override size_t talign()
	35	{
	36	return ulong.alignof;
	37	}
	38
34	39	override size_t tsize()
35	40	{
36	41	return ulong.sizeof;

tango/core/rt/compiler/ldc/typeinfo/ti_creal.d

old	new
44	44	return _compare(cast(creal )p1, cast(creal )p2);
45	45	}
46	46
	47	override size_t talign()
	48	{
	49	return creal.alignof;
	50	}
	51
47	52	override size_t tsize()
48	53	{
49	54	return creal.sizeof;

tango/core/rt/compiler/ldc/typeinfo/ti_ubyte.d

old	new
22	22	return cast(ubyte )p1 - cast(ubyte )p2;
23	23	}
24	24
	25	override size_t talign()
	26	{
	27	return ubyte.alignof;
	28	}
	29
25	30	override size_t tsize()
26	31	{
27	32	return ubyte.sizeof;

tango/core/rt/compiler/ldc/typeinfo/ti_Aint.d

old	new
47	47	return 0;
48	48	}
49	49
	50	override size_t talign()
	51	{
	52	return (int[]).alignof;
	53	}
	54
50	55	override size_t tsize()
51	56	{
52	57	return (int[]).sizeof;

tango/core/rt/compiler/ldc/typeinfo/ti_long.d

old	new
31	31	return 0;
32	32	}
33	33
	34	override size_t talign()
	35	{
	36	return long.alignof;
	37	}
	38
34	39	override size_t tsize()
35	40	{
36	41	return long.sizeof;

tango/core/rt/compiler/ldc/typeinfo/ti_short.d

old	new
22	22	return cast(short )p1 - cast(short )p2;
23	23	}
24	24
	25	override size_t talign()
	26	{
	27	return short.alignof;
	28	}
	29
25	30	override size_t tsize()
26	31	{
27	32	return short.sizeof;

tango/core/rt/compiler/ldc/typeinfo/ti_Along.d

old	new
48	48	return 0;
49	49	}
50	50
	51	override size_t talign()
	52	{
	53	return (long[]).alignof;
	54	}
	55
51	56	override size_t tsize()
52	57	{
53	58	return (long[]).sizeof;

tango/core/rt/compiler/ldc/typeinfo/ti_byte.d

old	new
22	22	return cast(byte )p1 - cast(byte )p2;
23	23	}
24	24
	25	override size_t talign()
	26	{
	27	return byte.alignof;
	28	}
	29
25	30	override size_t tsize()
26	31	{
27	32	return byte.sizeof;

tango/core/rt/compiler/ldc/typeinfo/ti_float.d

old	new
42	42	return _compare(cast(float )p1, cast(float )p2);
43	43	}
44	44
	45	override size_t talign()
	46	{
	47	return float.alignof;
	48	}
	49
45	50	override size_t tsize()
46	51	{
47	52	return float.sizeof;

tango/core/rt/compiler/ldc/typeinfo/ti_cfloat.d

old	new
44	44	return _compare(cast(cfloat )p1, cast(cfloat )p2);
45	45	}
46	46
	47	override size_t talign()
	48	{
	49	return cfloat.alignof;
	50	}
	51
47	52	override size_t tsize()
48	53	{
49	54	return cfloat.sizeof;

tango/core/rt/compiler/ldc/typeinfo/ti_Acfloat.d

old	new
76	76	return 0;
77	77	}
78	78
	79	override size_t talign()
	80	{
	81	return (cfloat[]).alignof;
	82	}
	83
79	84	override size_t tsize()
80	85	{
81	86	return (cfloat[]).sizeof;

tango/core/rt/compiler/ldc/typeinfo/ti_cdouble.d

old	new
44	44	return _compare(cast(cdouble )p1, cast(cdouble )p2);
45	45	}
46	46
	47	override size_t talign()
	48	{
	49	return cdouble.alignof;
	50	}
	51
47	52	override size_t tsize()
48	53	{
49	54	return cdouble.sizeof;

tango/core/rt/compiler/ldc/typeinfo/ti_dchar.d

old	new
22	22	return cast(dchar )p1 - cast(dchar )p2;
23	23	}
24	24
	25	override size_t talign()
	26	{
	27	return dchar.alignof;
	28	}
	29
25	30	override size_t tsize()
26	31	{
27	32	return dchar.sizeof;

tango/core/rt/compiler/ldc/typeinfo/ti_C.d

old	new
62	62	return c;
63	63	}
64	64
	65	override size_t talign()
	66	{
	67	return Object.alignof;
	68	}
	69
65	70	override size_t tsize()
66	71	{
67	72	return Object.sizeof;

tango/core/rt/compiler/ldc/typeinfo/ti_real.d

old	new
43	43	return _compare(cast(real )p1, cast(real )p2);
44	44	}
45	45
	46	override size_t talign()
	47	{
	48	return real.alignof;
	49	}
	50
46	51	override size_t tsize()
47	52	{
48	53	return real.sizeof;

tango/core/rt/compiler/ldc/typeinfo/ti_ushort.d

old	new
22	22	return cast(ushort )p1 - cast(ushort )p2;
23	23	}
24	24
	25	override size_t talign()
	26	{
	27	return ushort.alignof;
	28	}
	29
25	30	override size_t tsize()
26	31	{
27	32	return ushort.sizeof;

tango/core/rt/compiler/ldc/typeinfo/ti_Areal.d

old	new
76	76	return 0;
77	77	}
78	78
	79	override size_t talign()
	80	{
	81	return (real[]).alignof;
	82	}
	83
79	84	override size_t tsize()
80	85	{
81	86	return (real[]).sizeof;

tango/core/rt/compiler/ldc/typeinfo/ti_Acreal.d

old	new
76	76	return 0;
77	77	}
78	78
	79	override size_t talign()
	80	{
	81	return (creal[]).alignof;
	82	}
	83
79	84	override size_t tsize()
80	85	{
81	86	return (creal[]).sizeof;

tango/core/rt/compiler/ldc/typeinfo/ti_Ag.d

old	new
48	48	return 0;
49	49	}
50	50
	51	override size_t talign()
	52	{
	53	return (byte[]).alignof;
	54	}
	55
51	56	override size_t tsize()
52	57	{
53	58	return (byte[]).sizeof;

tango/core/rt/compiler/ldc/typeinfo/ti_int.d

old	new
26	26	return 0;
27	27	}
28	28
	29	override size_t talign()
	30	{
	31	return int.alignof;
	32	}
	33
29	34	override size_t tsize()
30	35	{
31	36	return int.sizeof;

tango/core/rt/compiler/ldc/typeinfo/ti_Ashort.d

old	new
47	47	return 0;
48	48	}
49	49
	50	override size_t talign()
	51	{
	52	return (short[]).alignof;
	53	}
	54
50	55	override size_t tsize()
51	56	{
52	57	return (short[]).sizeof;

tango/core/rt/compiler/dmd/rt/trace.d

old	new
17	17	{
18	18	import rt.compiler.util.string;
19	19	import tango.stdc.string : memset, memcpy, strlen;
20		import tango.stdc.stdlib : malloc, free, exit, strtoul, strtoull, qsort,
	20	import tango.stdc.stdlib : malloc, free, exit, strtoul, strtoull, qsort,
21	21	EXIT_FAILURE;
22	22	import tango.stdc.ctype : isspace, isalpha, isgraph;
23	23	import tango.stdc.stdio : fopen, fclose, fprintf, fgetc, FILE, EOF;
…	…
906	906	}
907	907	}
908	908	}
	909	else version (D_InlineAsm_X86_64)
	910	{
	911	extern (D)
	912	{
	913	void QueryPerformanceCounter(timer_t* ctr)
	914	{
	915	asm
	916	{
	917	naked ;
	918	rdtsc ;
	919	mov [RDI],EAX ;
	920	mov 4[RDI],EDX ;
	921	ret ;
	922	}
	923	}
	924
	925	void QueryPerformanceFrequency(timer_t* freq)
	926	{
	927	*freq = 3579545;
	928	}
	929	}
	930	}
909	931	else
910	932	{
911	933	static assert(0);

tango/core/rt/compiler/dmd/rt/lifetime.d

old	new
303	303	if (ndims == 0)
304	304	result = 0;
305	305	else
306		{ ~~va_list q;~~
307		va_~~start!(int)(q, ndims)~~;
	306	{
	307	va_list q;
308	308
	309	version(X86)
	310	va_start(q, ndims);
	311	else version(X86_64)
	312	va_start(q, __va_argsave);
	313	else
	314	static assert(false, "platform not supported");
	315
309	316	void[] foo(TypeInfo ti, size_t* pdim, int ndims)
310	317	{
311	318	size_t dim = *pdim;
…	…
329	336	}
330	337
331	338	size_t* pdim = cast(size_t *)q;
332		result = cast(ulong)foo(ti, pdim, ndims);
	339	result = cast(ulong)foo(ti, pdim, ndims).ptr;
333	340	debug(PRINTF) printf("result = %llx\n", result);
334	341
335	342	version (none)
…	…
358	365	else
359	366	{
360	367	va_list q;
361		~~va_start!(int)(q, ndims);~~
362	368
	369	version(X86)
	370	va_start(q, ndims);
	371	else version(X86_64)
	372	va_start(q, __va_argsave);
	373	else
	374	static assert(false, "platform not supported");
	375
363	376	void[] foo(TypeInfo ti, size_t* pdim, int ndims)
364	377	{
365	378	size_t dim = *pdim;
…	…
382	395	}
383	396
384	397	size_t* pdim = cast(size_t *)q;
385		result = cast(ulong)foo(ti, pdim, ndims);
	398	result = cast(ulong)foo(ti, pdim, ndims).ptr;
386	399	debug(PRINTF) printf("result = %llx\n", result);
387	400
388	401	version (none)
…	…
830	843	const size_t b=0; // flatness factor, how fast the extra space decreases with array size
831	844	const size_t a=100; // allocate at most a% of the requested size as extra space (rounding will change this)
832	845	const size_t minBits=1; // minimum bit size
833
834	846
	847
835	848	static size_t log2plusB(size_t c)
836	849	{
837	850	// could use the bsr bit op
…	…
1167	1180	}
1168	1181	result = gc_malloc(length * sizeelem, !(ti.next.flags() & 1) ? BlkAttr.NO_SCAN : 0, pm);
1169	1182
1170		va_list q;
1171		va_start!(size_t)(q, length);
	1183	version(X86)
	1184	{
	1185	va_list q;
	1186	va_start!(size_t)(q, length);
1172	1187
1173		size_t stacksize = (sizeelem + int.sizeof - 1) & ~(int.sizeof - 1);
	1188	size_t stacksize = (sizeelem + int.sizeof - 1) & ~(int.sizeof - 1);
1174	1189
1175		if (stacksize == sizeelem)
1176		{
1177		memcpy(result, q, length * sizeelem);
	1190	if (stacksize == sizeelem)
	1191	{
	1192	memcpy(result, q, length * sizeelem);
	1193	}
	1194	else
	1195	{
	1196	for (size_t i = 0; i < length; i++)
	1197	{
	1198	memcpy(result + i * sizeelem, q, sizeelem);
	1199	q += stacksize;
	1200	}
	1201	}
	1202
	1203	va_end(q);
1178	1204	}
1179		else
	1205	else version(X86_64)
1180	1206	{
	1207	va_list q;
	1208	va_start(q, __va_argsave);
1181	1209	for (size_t i = 0; i < length; i++)
1182	1210	{
1183		memcpy(result + i * sizeelem, q, sizeelem);
1184		q += stacksize;
	1211	va_arg(q, ti.next, result + i * sizeelem);
1185	1212	}
	1213	va_end(q);
1186	1214	}
1187
1188		~~va_end(q);~~
1189	1215	}
1190	1216	return result;
1191	1217	}

tango/core/rt/compiler/dmd/rt/memory.d

old	new
109	109	ret;
110	110	}
111	111	}
	112	else version( D_InlineAsm_X86_64 )
	113	{
	114	asm
	115	{
	116	naked;
	117	mov RAX, RSP;
	118	ret;
	119	}
	120	}
112	121	else
113	122	{
114	123	static assert( false, "Architecture not supported." );
…	…
155	164	extern int _end;
156	165	}
157	166	}
158
	167
159	168	version (Solaris)
160	169	{
161	170	extern (C)

tango/core/rt/compiler/dmd/rt/cover.d

old	new
34	34	struct BitArray
35	35	{
36	36	size_t len;
37		uint* ptr;
	37	size_t* ptr;
38	38
39	39	bool opIndex( size_t i )
40	40	in

tango/core/rt/compiler/dmd/rt/aaA.d

old	new
110	110
111	111	size_t aligntsize(size_t tsize)
112	112	{
113		// Is pointer alignment on the x64 4 bytes or 8?
114		return (tsize + size_t.sizeof - 1) & ~(size_t.sizeof - 1);
	113	version (X86_64)
	114	// Size of key needed to align value on 16 bytes
	115	return (tsize + 15) & ~(15);
	116	else
	117	return (tsize + size_t.sizeof - 1) & ~(size_t.sizeof - 1);
115	118	}
116	119
117	120	extern (C):
…	…
824	827	else
825	828	{
826	829	va_list q;
827		va_start!(size_t)(q, length);
	830	version(X86_64) va_start(q, __va_argsave); else va_start!(size_t)(q, length);
828	831
829	832	result = new BB();
830	833	result.keyti = keyti;

tango/core/rt/compiler/dmd/object_.d

old	new
416	416
417	417	/// Compares two instances for <, ==, or >.
418	418	int compare(in void* p1, in void* p2) { return 0; } // throw new Exception("non comparable",__FILE__,__LINE__);
419
	419	/// Return alignment of type
	420	size_t talign() { return tsize(); }
420	421	/// Returns size of the type.
421	422	size_t tsize() { return 0; }
422	423
…	…
473	474
474	475	/// Get type information on the contents of the type; null if not available
475	476	OffsetTypeInfo[] offTi() { return null; }
	477
	478
	479	/** Return internal info on arguments fitting into 8byte.
	480	* See X86-64 ABI 3.2.3
	481	*/
	482	version (X86_64) int argTypes(out TypeInfo arg1, out TypeInfo arg2)
	483	{ arg1 = this;
	484	return 0;
	485	}
476	486	}
477	487
478	488	class TypeInfo_Typedef : TypeInfo

tango/core/rt/compiler/dmd/typeinfo/ti_void.d

old	new
22	22	return cast(byte )p1 - cast(byte )p2;
23	23	}
24	24
	25	override size_t talign()
	26	{
	27	return void.alignof;
	28	}
	29
25	30	override size_t tsize()
26	31	{
27	32	return void.sizeof;

tango/core/rt/compiler/dmd/typeinfo/ti_wchar.d

old	new
21	21	return cast(wchar )p1 - cast(wchar )p2;
22	22	}
23	23
	24	override size_t talign()
	25	{
	26	return wchar.alignof;
	27	}
	28
24	29	override size_t tsize()
25	30	{
26	31	return wchar.sizeof;

tango/core/rt/compiler/dmd/typeinfo/ti_ptr.d

old	new
25	25	return 0;
26	26	}
27	27
	28	override size_t talign()
	29	{
	30	return (void*).alignof;
	31	}
	32
28	33	override size_t tsize()
29	34	{
30	35	return (void*).sizeof;

tango/core/rt/compiler/dmd/typeinfo/ti_Afloat.d

old	new
76	76	return 0;
77	77	}
78	78
	79	override size_t talign()
	80	{
	81	return (float[]).alignof;
	82	}
	83
79	84	override size_t tsize()
80	85	{
81	86	return (float[]).sizeof;

tango/core/rt/compiler/dmd/typeinfo/ti_double.d

old	new
43	43	return _compare(cast(double )p1, cast(double )p2);
44	44	}
45	45
	46	override size_t talign()
	47	{
	48	return double.alignof;
	49	}
	50
46	51	override size_t tsize()
47	52	{
48	53	return double.sizeof;

tango/core/rt/compiler/dmd/typeinfo/ti_delegate.d

old	new
18	18	return cast(dg )p1 == cast(dg )p2;
19	19	}
20	20
	21	override size_t talign()
	22	{
	23	return dg.alignof;
	24	}
	25
21	26	override size_t tsize()
22	27	{
23	28	return dg.sizeof;

tango/core/rt/compiler/dmd/typeinfo/ti_Adouble.d

old	new
76	76	return 0;
77	77	}
78	78
	79	override size_t talign()
	80	{
	81	return (double[]).alignof;
	82	}
	83
79	84	override size_t tsize()
80	85	{
81	86	return (double[]).sizeof;

tango/core/rt/compiler/dmd/typeinfo/ti_char.d

old	new
20	20	return cast(char )p1 - cast(char )p2;
21	21	}
22	22
	23	override size_t talign()
	24	{
	25	return char.alignof;
	26	}
	27
23	28	override size_t tsize()
24	29	{
25	30	return char.sizeof;

tango/core/rt/compiler/dmd/typeinfo/ti_Acdouble.d

old	new
75	75	return 0;
76	76	}
77	77
	78	override size_t talign()
	79	{
	80	return (cdouble[]).alignof;
	81	}
	82
78	83	override size_t tsize()
79	84	{
80	85	return (cdouble[]).sizeof;

tango/core/rt/compiler/dmd/typeinfo/ti_uint.d

old	new
26	26	return 0;
27	27	}
28	28
	29	override size_t talign()
	30	{
	31	return uint.alignof;
	32	}
	33
29	34	override size_t tsize()
30	35	{
31	36	return uint.sizeof;

tango/core/rt/compiler/dmd/typeinfo/ti_AC.d

old	new
82	82	return 0;
83	83	}
84	84
	85	override size_t talign()
	86	{
	87	return (Object[]).alignof;
	88	}
	89
85	90	override size_t tsize()
86	91	{
87	92	return (Object[]).sizeof;

tango/core/rt/compiler/dmd/typeinfo/ti_ulong.d

old	new
31	31	return 0;
32	32	}
33	33
	34	override size_t talign()
	35	{
	36	return ulong.alignof;
	37	}
	38
34	39	override size_t tsize()
35	40	{
36	41	return ulong.sizeof;

tango/core/rt/compiler/dmd/typeinfo/ti_creal.d

old	new
44	44	return _compare(cast(creal )p1, cast(creal )p2);
45	45	}
46	46
	47	override size_t talign()
	48	{
	49	return creal.alignof;
	50	}
	51
47	52	override size_t tsize()
48	53	{
49	54	return creal.sizeof;

tango/core/rt/compiler/dmd/typeinfo/ti_ubyte.d

old	new
22	22	return cast(ubyte )p1 - cast(ubyte )p2;
23	23	}
24	24
	25	override size_t talign()
	26	{
	27	return ubyte.alignof;
	28	}
	29
25	30	override size_t tsize()
26	31	{
27	32	return ubyte.sizeof;

tango/core/rt/compiler/dmd/typeinfo/ti_Aint.d

old	new
47	47	return 0;
48	48	}
49	49
	50	override size_t talign()
	51	{
	52	return (int[]).alignof;
	53	}
	54
50	55	override size_t tsize()
51	56	{
52	57	return (int[]).sizeof;

tango/core/rt/compiler/dmd/typeinfo/ti_long.d

old	new
31	31	return 0;
32	32	}
33	33
	34	override size_t talign()
	35	{
	36	return long.alignof;
	37	}
	38
34	39	override size_t tsize()
35	40	{
36	41	return long.sizeof;

tango/core/rt/compiler/dmd/typeinfo/ti_short.d

old	new
22	22	return cast(short )p1 - cast(short )p2;
23	23	}
24	24
	25	override size_t talign()
	26	{
	27	return short.alignof;
	28	}
	29
25	30	override size_t tsize()
26	31	{
27	32	return short.sizeof;

tango/core/rt/compiler/dmd/typeinfo/ti_Along.d

old	new
48	48	return 0;
49	49	}
50	50
	51	override size_t talign()
	52	{
	53	return (long[]).alignof;
	54	}
	55
51	56	override size_t tsize()
52	57	{
53	58	return (long[]).sizeof;

tango/core/rt/compiler/dmd/typeinfo/ti_byte.d

old	new
22	22	return cast(byte )p1 - cast(byte )p2;
23	23	}
24	24
	25	override size_t talign()
	26	{
	27	return byte.alignof;
	28	}
	29
25	30	override size_t tsize()
26	31	{
27	32	return byte.sizeof;

tango/core/rt/compiler/dmd/typeinfo/ti_float.d

old	new
42	42	return _compare(cast(float )p1, cast(float )p2);
43	43	}
44	44
	45	override size_t talign()
	46	{
	47	return float.alignof;
	48	}
	49
45	50	override size_t tsize()
46	51	{
47	52	return float.sizeof;

tango/core/rt/compiler/dmd/typeinfo/ti_cfloat.d

old	new
44	44	return _compare(cast(cfloat )p1, cast(cfloat )p2);
45	45	}
46	46
	47	override size_t talign()
	48	{
	49	return cfloat.alignof;
	50	}
	51
47	52	override size_t tsize()
48	53	{
49	54	return cfloat.sizeof;

tango/core/rt/compiler/dmd/typeinfo/ti_Acfloat.d

old	new
76	76	return 0;
77	77	}
78	78
	79	override size_t talign()
	80	{
	81	return (cfloat[]).alignof;
	82	}
	83
79	84	override size_t tsize()
80	85	{
81	86	return (cfloat[]).sizeof;

tango/core/rt/compiler/dmd/typeinfo/ti_cdouble.d

old	new
44	44	return _compare(cast(cdouble )p1, cast(cdouble )p2);
45	45	}
46	46
	47	override size_t talign()
	48	{
	49	return cdouble.alignof;
	50	}
	51
47	52	override size_t tsize()
48	53	{
49	54	return cdouble.sizeof;

tango/core/rt/compiler/dmd/typeinfo/ti_dchar.d

old	new
22	22	return cast(dchar )p1 - cast(dchar )p2;
23	23	}
24	24
	25	override size_t talign()
	26	{
	27	return dchar.alignof;
	28	}
	29
25	30	override size_t tsize()
26	31	{
27	32	return dchar.sizeof;

tango/core/rt/compiler/dmd/typeinfo/ti_C.d

old	new
62	62	return c;
63	63	}
64	64
	65	override size_t talign()
	66	{
	67	return Object.alignof;
	68	}
	69
65	70	override size_t tsize()
66	71	{
67	72	return Object.sizeof;

tango/core/rt/compiler/dmd/typeinfo/ti_real.d

old	new
43	43	return _compare(cast(real )p1, cast(real )p2);
44	44	}
45	45
	46	override size_t talign()
	47	{
	48	return real.alignof;
	49	}
	50
46	51	override size_t tsize()
47	52	{
48	53	return real.sizeof;

tango/core/rt/compiler/dmd/typeinfo/ti_ushort.d

old	new
22	22	return cast(ushort )p1 - cast(ushort )p2;
23	23	}
24	24
	25	override size_t talign()
	26	{
	27	return ushort.alignof;
	28	}
	29
25	30	override size_t tsize()
26	31	{
27	32	return ushort.sizeof;

tango/core/rt/compiler/dmd/typeinfo/ti_Areal.d

old	new
76	76	return 0;
77	77	}
78	78
	79	override size_t talign()
	80	{
	81	return (real[]).alignof;
	82	}
	83
79	84	override size_t tsize()
80	85	{
81	86	return (real[]).sizeof;

tango/core/rt/compiler/dmd/typeinfo/ti_Acreal.d

old	new
76	76	return 0;
77	77	}
78	78
	79	override size_t talign()
	80	{
	81	return (creal[]).alignof;
	82	}
	83
79	84	override size_t tsize()
80	85	{
81	86	return (creal[]).sizeof;

tango/core/rt/compiler/dmd/typeinfo/ti_Ag.d

old	new
48	48	return 0;
49	49	}
50	50
	51	override size_t talign()
	52	{
	53	return (byte[]).alignof;
	54	}
	55
51	56	override size_t tsize()
52	57	{
53	58	return (byte[]).sizeof;

tango/core/rt/compiler/dmd/typeinfo/ti_int.d

old	new
26	26	return 0;
27	27	}
28	28
	29	override size_t talign()
	30	{
	31	return int.alignof;
	32	}
	33
29	34	override size_t tsize()
30	35	{
31	36	return int.sizeof;

tango/core/rt/compiler/dmd/typeinfo/ti_Ashort.d

old	new
47	47	return 0;
48	48	}
49	49
	50	override size_t talign()
	51	{
	52	return (short[]).alignof;
	53	}
	54
50	55	override size_t tsize()
51	56	{
52	57	return (short[]).sizeof;

tango/core/rt/compiler/dmd/posix/deh.d

old	new
35	35	extern (C)
36	36	{
37	37	version (darwin) {}
38
	38
39	39	else
40	40	{
41	41	extern void* _deh_beg;
…	…
111	111	{
112	112	static FuncTable[] functionTables;
113	113	static bool hasFunctionTables;
114
	114
115	115	if (!hasFunctionTables)
116	116	{
117	117	functionTables = getSectionData!(FuncTable, "__DATA", "__deh_eh");
118	118	hasFunctionTables = true;
119	119	}
120
	120
121	121	foreach (ft ; functionTables)
122	122	{
123	123	if (ft.fptr <= address && address < cast(void )(cast(char )ft.fptr + ft.fsize))
124	124	return ft.handlertable;
125	125	}
126
	126
127	127	return null;
128	128	}
129
	129
130	130	else
131	131	{
132	132	FuncTable *ft;
…	…
164	164	* caller's EBP
165	165	*/
166	166
167		~~uint __eh_find_caller(uint regbp, uin~~t *pretaddr)
	167	size_t __eh_find_caller(size_t regbp, size_t *pretaddr)
168	168	{
169		~~uint bp = cast(uin~~t )regbp;
	169	size_t bp = cast(size_t )regbp;
170	170
171	171	if (bp) // if not end of call chain
172	172	{
…	…
176	176	// stack should grow to smaller values
177	177	terminate();
178	178
179		pretaddr = cast(~~uint *)(regbp + in~~t.sizeof);
	179	pretaddr = cast(size_t *)(regbp + size_t.sizeof);
180	180	}
181	181	return bp;
182	182	}
…	…
195	195	* Throw a D object.
196	196	*/
197	197
198		extern(C) void _d_throwc(Object *h){
199		uint regebp;
	198	extern(C) void _d_throwc(Object *h)
	199	{
	200	size_t regebp;
200	201
201	202	debug(deh)
202	203	{
…	…
204	205	printf("\tvptr = %p\n", cast(void *)h);
205	206	}
206	207
207		asm
208		{
209		mov regebp,EBP ;
210		}
	208	version (D_InlineAsm_X86)
	209	asm
	210	{
	211	mov regebp,EBP ;
	212	}
	213	else version (D_InlineAsm_X86_64)
	214	asm
	215	{
	216	mov regebp,RBP ;
	217	}
	218	else
	219	static assert(0);
211	220
212	221	//static uint abc;
213	222	//if (++abc == 2) (char )0=0;
…	…
218	227	DHandlerTable *handler_table;
219	228	FuncTable *pfunc;
220	229	DHandlerInfo *phi;
221		~~uin~~t retaddr;
222		~~uin~~t funcoffset;
	230	size_t retaddr;
	231	size_t funcoffset;
223	232	uint spoff;
224	233	uint retoffset;
225	234	int index;
226		int dim;
	235	size_t dim;
227	236	int ndx;
228	237	int prev_ndx;
229	238
…	…
275	284	phi = handler_table.handler_info.ptr + i;
276	285
277	286	debug(deh) printf("i = %d, phi.offset = %04x\n", i, funcoffset + phi.offset);
278		if (~~cast(uint)~~retaddr > funcoffset + phi.offset &&
279		~~cast(uint)~~retaddr <= funcoffset + phi.endoffset)
	287	if (retaddr > funcoffset + phi.offset &&
	288	retaddr <= funcoffset + phi.endoffset)
280	289	index = i;
281	290	}
282	291	debug(deh) printf("index = %d\n", index);
…	…
287	296	{
288	297	phi = handler_table.handler_info.ptr + ndx;
289	298	prev_ndx = phi.prev_index;
	299
290	300	if (phi.cioffset)
291	301	{
292	302	// this is a catch handler (no finally)
293	303	DCatchInfo *pci;
294		int ncatches;
295		int i;
	304	size_t ncatches;
	305	size_t i;
296	306
297	307	pci = cast(DCatchInfo )(cast(char )handler_table + phi.cioffset);
298	308	ncatches = pci.ncatches;
	309
299	310	for (i = 0; i < ncatches; i++)
300	311	{
301	312	DCatchBlock *pcb;
…	…
311	322
312	323	// Jump to catch block. Does not return.
313	324	{
314		~~uin~~t catch_esp;
	325	size_t catch_esp;
315	326	fp_t catch_addr;
316	327
317	328	catch_addr = cast(fp_t)(pcb.code);
318	329	catch_esp = regebp - handler_table.espoffset - fp_t.sizeof;
319		asm
320		{
321		mov EAX,catch_esp ;
322		mov ECX,catch_addr ;
323		mov [EAX],ECX ;
324		mov EBP,regebp ;
325		mov ESP,EAX ; // reset stack
326		ret ; // jump to catch block
327		}
	330
	331	version (D_InlineAsm_X86)
	332	asm
	333	{
	334	mov EAX,catch_esp ;
	335	mov ECX,catch_addr ;
	336	mov [EAX],ECX ;
	337	mov EBP,regebp ;
	338	mov ESP,EAX ; // reset stack
	339	ret ; // jump to catch block
	340	}
	341	else version (D_InlineAsm_X86_64)
	342	asm
	343	{
	344	mov RAX,catch_esp ;
	345	mov RCX,catch_esp ;
	346	mov RCX,catch_addr ;
	347	mov [RAX],RCX ;
	348	mov RBP,regebp ;
	349	mov RSP,RAX ; // reset stack
	350	ret ; // jump to catch block
	351	}
	352	else
	353	static assert(0);
	354
328	355	}
329	356	}
330	357	}
…	…
338	365
339	366	version (OSX)
340	367	{
341		asm {
342		sub ESP,4 ;
343		push EBX ;
344		mov EBX,blockaddr ;
345		push EBP ;
346		mov EBP,regebp ;
347		call EBX ;
348		pop EBP ;
349		pop EBX ;
350		add ESP,4 ;
351		}
352		} else {
353		asm {
354		push EBX ;
355		mov EBX,blockaddr ;
356		push EBP ;
357		mov EBP,regebp ;
358		call EBX ;
359		pop EBP ;
360		pop EBX ;
361		}
	368	version (D_InlineAsm_X86)
	369	asm
	370	{
	371	sub ESP,4 ;
	372	push EBX ;
	373	mov EBX,blockaddr ;
	374	push EBP ;
	375	mov EBP,regebp ;
	376	call EBX ;
	377	pop EBP ;
	378	pop EBX ;
	379	add ESP,4 ;
	380	}
	381	else version (D_InlineAsm_X86_64)
	382	asm
	383	{
	384	sub RSP,8 ;
	385	push RBX ;
	386	mov RBX,blockaddr ;
	387	push RBP ;
	388	mov RBP,regebp ;
	389	call RBX ;
	390	pop RBP ;
	391	pop RBX ;
	392	add RSP,8 ;
	393	}
	394	else
	395	static assert(0);
362	396	}
	397	else
	398	{
	399	version (D_InlineAsm_X86)
	400	asm
	401	{
	402	push EBX ;
	403	mov EBX,blockaddr ;
	404	push EBP ;
	405	mov EBP,regebp ;
	406	call EBX ;
	407	pop EBP ;
	408	pop EBX ;
	409	}
	410	else version (D_InlineAsm_X86_64)
	411	asm
	412	{
	413	sub RSP,8 ;
	414	push RBX ;
	415	mov RBX,blockaddr ;
	416	push RBP ;
	417	mov RBP,regebp ;
	418	call RBX ;
	419	pop RBP ;
	420	pop RBX ;
	421	add RSP,8 ;
	422	}
	423	else
	424	static assert(0);
	425	}
363	426	}
364	427	}
365	428	}

tango/core/rt/compiler/gdc/object_.d

old	new
413	413	/// Compares two instances for <, ==, or >.
414	414	int compare(in void* p1, in void* p2) { return 0; } // throw new Exception("non comparable",__FILE__,__LINE__);
415	415
	416	/// Return alignment of type
	417	size_t talign() { return tsize(); }
	418
416	419	/// Returns size of the type.
417	420	size_t tsize() { return 0; }
418	421

tango/core/rt/compiler/gdc/typeinfo/ti_void.d

old	new
22	22	return cast(byte )p1 - cast(byte )p2;
23	23	}
24	24
	25	override size_t talign()
	26	{
	27	return void.alignof;
	28	}
	29
25	30	override size_t tsize()
26	31	{
27	32	return void.sizeof;

tango/core/rt/compiler/gdc/typeinfo/ti_wchar.d

old	new
21	21	return cast(wchar )p1 - cast(wchar )p2;
22	22	}
23	23
	24	override size_t talign()
	25	{
	26	return wchar.alignof;
	27	}
	28
24	29	override size_t tsize()
25	30	{
26	31	return wchar.sizeof;

tango/core/rt/compiler/gdc/typeinfo/ti_ptr.d

old	new
25	25	return 0;
26	26	}
27	27
	28	override size_t talign()
	29	{
	30	return (void*).alignof;
	31	}
	32
28	33	override size_t tsize()
29	34	{
30	35	return (void*).sizeof;

tango/core/rt/compiler/gdc/typeinfo/ti_Afloat.d

old	new
76	76	return 0;
77	77	}
78	78
	79	override size_t talign()
	80	{
	81	return (float[]).alignof;
	82	}
	83
79	84	override size_t tsize()
80	85	{
81	86	return (float[]).sizeof;

tango/core/rt/compiler/gdc/typeinfo/ti_double.d

old	new
43	43	return _compare(cast(double )p1, cast(double )p2);
44	44	}
45	45
	46	override size_t talign()
	47	{
	48	return double.alignof;
	49	}
	50
46	51	override size_t tsize()
47	52	{
48	53	return double.sizeof;

tango/core/rt/compiler/gdc/typeinfo/ti_delegate.d

old	new
18	18	return cast(dg )p1 == cast(dg )p2;
19	19	}
20	20
	21	override size_t talign()
	22	{
	23	return dg.alignof;
	24	}
	25
21	26	override size_t tsize()
22	27	{
23	28	return dg.sizeof;

tango/core/rt/compiler/gdc/typeinfo/ti_Adouble.d

old	new
76	76	return 0;
77	77	}
78	78
	79	override size_t talign()
	80	{
	81	return (double[]).alignof;
	82	}
	83
79	84	override size_t tsize()
80	85	{
81	86	return (double[]).sizeof;

tango/core/rt/compiler/gdc/typeinfo/ti_char.d

old	new
20	20	return cast(char )p1 - cast(char )p2;
21	21	}
22	22
	23	override size_t talign()
	24	{
	25	return char.alignof;
	26	}
	27
23	28	override size_t tsize()
24	29	{
25	30	return char.sizeof;

tango/core/rt/compiler/gdc/typeinfo/ti_Acdouble.d

old	new
75	75	return 0;
76	76	}
77	77
	78	override size_t talign()
	79	{
	80	return (cdouble[]).alignof;
	81	}
	82
78	83	override size_t tsize()
79	84	{
80	85	return (cdouble[]).sizeof;

tango/core/rt/compiler/gdc/typeinfo/ti_uint.d

old	new
26	26	return 0;
27	27	}
28	28
	29	override size_t talign()
	30	{
	31	return uint.alignof;
	32	}
	33
29	34	override size_t tsize()
30	35	{
31	36	return uint.sizeof;

tango/core/rt/compiler/gdc/typeinfo/ti_AC.d

old	new
82	82	return 0;
83	83	}
84	84
	85	override size_t talign()
	86	{
	87	return (Object[]).alignof;
	88	}
	89
85	90	override size_t tsize()
86	91	{
87	92	return (Object[]).sizeof;

tango/core/rt/compiler/gdc/typeinfo/ti_ulong.d

old	new
31	31	return 0;
32	32	}
33	33
	34	override size_t talign()
	35	{
	36	return ulong.alignof;
	37	}
	38
34	39	override size_t tsize()
35	40	{
36	41	return ulong.sizeof;

tango/core/rt/compiler/gdc/typeinfo/ti_creal.d

old	new
44	44	return _compare(cast(creal )p1, cast(creal )p2);
45	45	}
46	46
	47	override size_t talign()
	48	{
	49	return creal.alignof;
	50	}
	51
47	52	override size_t tsize()
48	53	{
49	54	return creal.sizeof;

tango/core/rt/compiler/gdc/typeinfo/ti_ubyte.d

old	new
22	22	return cast(ubyte )p1 - cast(ubyte )p2;
23	23	}
24	24
	25	override size_t talign()
	26	{
	27	return ubyte.alignof;
	28	}
	29
25	30	override size_t tsize()
26	31	{
27	32	return ubyte.sizeof;

tango/core/rt/compiler/gdc/typeinfo/ti_Aint.d

old	new
47	47	return 0;
48	48	}
49	49
	50	override size_t talign()
	51	{
	52	return (int[]).alignof;
	53	}
	54
50	55	override size_t tsize()
51	56	{
52	57	return (int[]).sizeof;

tango/core/rt/compiler/gdc/typeinfo/ti_long.d

old	new
31	31	return 0;
32	32	}
33	33
	34	override size_t talign()
	35	{
	36	return long.alignof;
	37	}
	38
34	39	override size_t tsize()
35	40	{
36	41	return long.sizeof;

tango/core/rt/compiler/gdc/typeinfo/ti_short.d

old	new
22	22	return cast(short )p1 - cast(short )p2;
23	23	}
24	24
	25	override size_t talign()
	26	{
	27	return short.alignof;
	28	}
	29
25	30	override size_t tsize()
26	31	{
27	32	return short.sizeof;

tango/core/rt/compiler/gdc/typeinfo/ti_Along.d

old	new
48	48	return 0;
49	49	}
50	50
	51	override size_t talign()
	52	{
	53	return (long[]).alignof;
	54	}
	55
51	56	override size_t tsize()
52	57	{
53	58	return (long[]).sizeof;

tango/core/rt/compiler/gdc/typeinfo/ti_byte.d

old	new
22	22	return cast(byte )p1 - cast(byte )p2;
23	23	}
24	24
	25	override size_t talign()
	26	{
	27	return byte.alignof;
	28	}
	29
25	30	override size_t tsize()
26	31	{
27	32	return byte.sizeof;

tango/core/rt/compiler/gdc/typeinfo/ti_float.d

old	new
42	42	return _compare(cast(float )p1, cast(float )p2);
43	43	}
44	44
	45	override size_t talign()
	46	{
	47	return float.alignof;
	48	}
	49
45	50	override size_t tsize()
46	51	{
47	52	return float.sizeof;

tango/core/rt/compiler/gdc/typeinfo/ti_cfloat.d

old	new
44	44	return _compare(cast(cfloat )p1, cast(cfloat )p2);
45	45	}
46	46
	47	override size_t talign()
	48	{
	49	return cfloat.alignof;
	50	}
	51
47	52	override size_t tsize()
48	53	{
49	54	return cfloat.sizeof;

tango/core/rt/compiler/gdc/typeinfo/ti_Acfloat.d

old	new
76	76	return 0;
77	77	}
78	78
	79	override size_t talign()
	80	{
	81	return (cfloat[]).alignof;
	82	}
	83
79	84	override size_t tsize()
80	85	{
81	86	return (cfloat[]).sizeof;

tango/core/rt/compiler/gdc/typeinfo/ti_cdouble.d

old	new
44	44	return _compare(cast(cdouble )p1, cast(cdouble )p2);
45	45	}
46	46
	47	override size_t talign()
	48	{
	49	return cdouble.alignof;
	50	}
	51
47	52	override size_t tsize()
48	53	{
49	54	return cdouble.sizeof;

tango/core/rt/compiler/gdc/typeinfo/ti_dchar.d

old	new
22	22	return cast(dchar )p1 - cast(dchar )p2;
23	23	}
24	24
	25	override size_t talign()
	26	{
	27	return dchar.alignof;
	28	}
	29
25	30	override size_t tsize()
26	31	{
27	32	return dchar.sizeof;

tango/core/rt/compiler/gdc/typeinfo/ti_C.d

old	new
62	62	return c;
63	63	}
64	64
	65	override size_t talign()
	66	{
	67	return Object.alignof;
	68	}
	69
65	70	override size_t tsize()
66	71	{
67	72	return Object.sizeof;

tango/core/rt/compiler/gdc/typeinfo/ti_real.d

old	new
43	43	return _compare(cast(real )p1, cast(real )p2);
44	44	}
45	45
	46	override size_t talign()
	47	{
	48	return real.alignof;
	49	}
	50
46	51	override size_t tsize()
47	52	{
48	53	return real.sizeof;

tango/core/rt/compiler/gdc/typeinfo/ti_ushort.d

old	new
22	22	return cast(ushort )p1 - cast(ushort )p2;
23	23	}
24	24
	25	override size_t talign()
	26	{
	27	return ushort.alignof;
	28	}
	29
25	30	override size_t tsize()
26	31	{
27	32	return ushort.sizeof;

tango/core/rt/compiler/gdc/typeinfo/ti_Areal.d

old	new
76	76	return 0;
77	77	}
78	78
	79	override size_t talign()
	80	{
	81	return (real[]).alignof;
	82	}
	83
79	84	override size_t tsize()
80	85	{
81	86	return (real[]).sizeof;

tango/core/rt/compiler/gdc/typeinfo/ti_Acreal.d

old	new
76	76	return 0;
77	77	}
78	78
	79	override size_t talign()
	80	{
	81	return (creal[]).alignof;
	82	}
	83
79	84	override size_t tsize()
80	85	{
81	86	return (creal[]).sizeof;

tango/core/rt/compiler/gdc/typeinfo/ti_Ag.d

old	new
48	48	return 0;
49	49	}
50	50
	51	override size_t talign()
	52	{
	53	return (byte[]).alignof;
	54	}
	55
51	56	override size_t tsize()
52	57	{
53	58	return (byte[]).sizeof;

tango/core/rt/compiler/gdc/typeinfo/ti_int.d

old	new
26	26	return 0;
27	27	}
28	28
	29	override size_t talign()
	30	{
	31	return int.alignof;
	32	}
	33
29	34	override size_t tsize()
30	35	{
31	36	return int.sizeof;

tango/core/rt/compiler/gdc/typeinfo/ti_Ashort.d

old	new
47	47	return 0;
48	48	}
49	49
	50	override size_t talign()
	51	{
	52	return (short[]).alignof;
	53	}
	54
50	55	override size_t tsize()
51	56	{
52	57	return (short[]).sizeof;

tango/core/Variant.d

old	new
8	8	module tango.core.Variant;
9	9
10	10	private import tango.core.Memory : GC;
11		private import tango.core.Vararg ~~: va_list~~;
	11	private import tango.core.Vararg;
12	12	private import tango.core.Traits;
13	13	private import tango.core.Tuple;
14	14
…	…
37	37	version=EnableVararg;
38	38	}
39	39	}
	40	version( X86_64 )
	41	{
	42	version( Windows )
	43	{
	44	version=EnableVararg;
	45	}
	46	else version( Posix )
	47	{
	48	version=EnableVararg;
	49	}
	50	}
40	51	}
41	52	else version( LDC )
42	53	{
…	…
337	348	*
338	349	* Returns:
339	350	* The new Variant.
340		*
	351	*
341	352	* Example:
342	353	* -----
343	354	* auto v = Variant(42);
…	…
366	377	*
367	378	* Returns:
368	379	* The new Variant.
369		*
	380	*
370	381	* Example:
371	382	* -----
372	383	* int life = 42;
…	…
389	400	*
390	401	* Returns:
391	402	* The new value of the assigned-to variant.
392		*
	403	*
393	404	* Example:
394	405	* -----
395	406	* Variant v;
…	…
446	457	*
447	458	* Returns:
448	459	* true if the Variant contains a value of type T, false otherwise.
449		*
	460	*
450	461	* Example:
451	462	* -----
452	463	* auto v = Variant(cast(int) 42);
…	…
468	479	* true if the Variant contains a value of type T, or if the Variant
469	480	* contains a value that can be implicitly cast to type T; false
470	481	* otherwise.
471		*
	482	*
472	483	* Example:
473	484	* -----
474	485	* auto v = Variant(cast(int) 42);
…	…
739	750	else
740	751	return value.heap.ptr;
741	752	}
742
	753
743	754	version( EnableVararg )
744	755	{
745	756	/**
…	…
751	762
752	763	foreach( i, ref v ; vs )
753	764	args = Variant.fromPtr(types[i], args, v);
754
	765
755	766	return vs;
756	767	}
757
	768
758	769	/// ditto
759	770	static Variant[] fromVararg(...)
760	771	{
761	772	return Variant.fromVararg(_arguments, _argptr);
762	773	}
763
	774
764	775	/**
765	776	* Converts an array of Variants into a vararg function argument list.
766	777	*
…	…
780	791	size += (ti.tsize + size_t.sizeof-1) & ~(size_t.sizeof-1);
781	792	noptr = noptr && (ti.flags & 2);
782	793	}
783
	794
784	795	// Create the storage, and tell the GC whether it needs to be scanned
785	796	// or not.
786	797	auto storage = new ubyte[size];
…	…
810	821	{
811	822	return (_type = v);
812	823	}
813
	824
814	825	/*
815	826	* Creates a Variant using a given TypeInfo and a void*. Returns the
816	827	* given pointer adjusted for the next vararg.
…	…
861	872	if( type.tsize <= this.value.data.length )
862	873	{
863	874	// Copy into storage
864		r.value.data[0 .. type.tsize] =
	875	r.value.data[0 .. type.tsize] =
865	876	(cast(ubyte*)ptr)[0 .. type.tsize];
866	877	}
867	878	else
…	…
1255	1266	B va_a = new B;
1256	1267	C va_b = new D;
1257	1268	D va_c = new D;
1258
	1269
1259	1270	auto vs = scoop(va_0, va_1, va_2, va_3,
1260	1271	va_4, va_5, va_6, va_7,
1261	1272	va_8, va_9, va_a, va_b, va_c);
…	…
1277	1288	assert( vs[0x9].get!(typeof(va_9)).msg == "A" );
1278	1289	assert( vs[0xa].get!(typeof(va_a)).msg == "B" );
1279	1290	assert( vs[0xc].get!(typeof(va_c)).msg == "D" );
1280
	1291
1281	1292	assert( vs[0xb].get!(typeof(va_b)).name == "phil" );
1282	1293	assert( vs[0xc].get!(typeof(va_c)).name == "phil" );
1283	1294

tango/core/Thread.d

old	new
348	348	{
349	349	__builtin_unwind_init();
350	350	}
	351	else version ( D_InlineAsm_X86_64 )
	352	{
	353	asm
	354	{
	355	// Not sure what goes here, pushad is invalid in 64 bit code
	356	push RAX ;
	357	push RBX ;
	358	push RCX ;
	359	push RDX ;
	360	push RSI ;
	361	push RDI ;
	362	push RBP ;
	363	push R8 ;
	364	push R9 ;
	365	push R10 ;
	366	push R11 ;
	367	push R12 ;
	368	push R13 ;
	369	push R14 ;
	370	push R15 ;
	371	push EAX ; // 16 byte align the stack
	372	}
	373	}
351	374	else
352	375	{
353	376	static assert( false, "Architecture not supported." );
…	…
411	434	{
412	435	// registers will be popped automatically
413	436	}
	437	else version ( D_InlineAsm_X86_64 )
	438	{
	439	asm
	440	{
	441	// Not sure what goes here, popad is invalid in 64 bit code
	442	pop EAX ; // 16 byte align the stack
	443	pop R15 ;
	444	pop R14 ;
	445	pop R13 ;
	446	pop R12 ;
	447	pop R11 ;
	448	pop R10 ;
	449	pop R9 ;
	450	pop R8 ;
	451	pop RBP ;
	452	pop RDI ;
	453	pop RSI ;
	454	pop RDX ;
	455	pop RCX ;
	456	pop RBX ;
	457	pop RAX ;
	458	}
	459	}
414	460	else
415	461	{
416	462	static assert( false, "Architecture not supported." );
…	…
2670	2716	}
2671	2717	else version( AsmX86_64_Posix )
2672	2718	{
2673		asm
	2719	version( DigitalMars ) asm
2674	2720	{
2675	2721	naked;
2676	2722
2677	2723	// save current stack state
	2724	push RBP;
	2725	mov RBP, RSP;
	2726	push RBX;
	2727	push R12;
	2728	push R13;
	2729	push R14;
	2730	push R15;
	2731	sub RSP, 4;
	2732	stmxcsr [RSP];
	2733	sub RSP, 4;
	2734	//version(SynchroFloatExcept){
	2735	fstcw [RSP];
	2736	fwait;
	2737	//} else {
	2738	// fnstcw [RSP];
	2739	// fnclex;
	2740	//}
	2741
	2742	// store oldp again with more accurate address
	2743	mov [RDI], RSP;
	2744	// load newp to begin context switch
	2745	mov RSP, RSI;
	2746
	2747	// load saved state from new stack
	2748	fldcw [RSP];
	2749	add RSP, 4;
	2750	ldmxcsr [RSP];
	2751	add RSP, 4;
	2752	pop R15;
	2753	pop R14;
	2754	pop R13;
	2755	pop R12;
	2756
	2757	pop RBX;
	2758	pop RBP;
	2759
	2760	// 'return' to complete switch
	2761	ret;
	2762
	2763	}
	2764	else asm
	2765	{
	2766	naked;
	2767
	2768	// save current stack state
2678	2769	pushq RBP;
2679	2770	mov RBP, RSP;
2680	2771	pushq RBX;

tango/core/Vararg.d

old	new
21	21	}
22	22	else
23	23	{
24		/**
25		* The base vararg list type.
26		*/
27		alias void* va_list;
28
29
30		/**
31		* This function initializes the supplied argument pointer for subsequent
32		* use by va_arg and va_end.
33		*
34		* Params:
35		* ap = The argument pointer to initialize.
36		* paramn = The identifier of the rightmost parameter in the function
37		* parameter list.
38		*/
39		void va_start(T) ( out va_list ap, ref T parmn )
	24	version (X86)
40	25	{
41		ap = cast(va_list) ( cast(void*) &parmn + ( ( T.sizeof + int.sizeof - 1 ) & ~( int.sizeof - 1 ) ) );
42		}
	26	alias void* va_list;
43	27
44		/**
45		* This function returns the next argument in the sequence referenced by
46		* the supplied argument pointer. The argument pointer will be adjusted
47		* to point to the next arggument in the sequence.
48		*
49		* Params:
50		* ap = The argument pointer.
51		*
52		* Returns:
53		* The next argument in the sequence. The result is undefined if ap
54		* does not point to a valid argument.
55		*/
56		T va_arg(T) ( ref va_list ap )
57		{
58		T arg = cast(T) ap;
59		ap = cast(va_list) ( cast(void*) ap + ( ( T.sizeof + int.sizeof - 1 ) & ~( int.sizeof - 1 ) ) );
60		return arg;
	28	template va_arg(T)
	29	{
	30	T va_arg(ref va_list _argptr)
	31	{
	32	T arg = cast(T)_argptr;
	33	_argptr = _argptr + ((T.sizeof + int.sizeof - 1) & ~(int.sizeof - 1));
	34	return arg;
	35	}
	36	}
61	37	}
62
63		/**
64		* This function cleans up any resources allocated by va_start. It is
65		* currently a no-op and exists mostly for syntax compatibility with
66		* the variadric argument functions for C.
67		*
68		* Params:
69		* ap = The argument pointer.
70		*/
71		void va_end( va_list ap )
	38	else
72	39	{
73
	40	public import tango.stdc.stdarg;
74	41	}
75
76
77		/**
78		* This function copied the argument pointer src to dst.
79		*
80		* Params:
81		* src = The source pointer.
82		* dst = The destination pointer.
83		*/
84		~~void va_copy( out va_list dst, va_list src )~~
85		{
86		~~dst = src;~~
87		}
88	42	}

tango/core/sync/Atomic.d

old	new
245	245	return oldval;
246	246	}
247	247	} else version(D_InlineAsm_X86) {
248		T atomicSwap( T )( ~~inout~~ T val, T newval )
	248	T atomicSwap( T )( ref T val, T newval )
249	249	in {
250	250	// NOTE: 32 bit x86 systems support 8 byte CAS, which only requires
251	251	// 4 byte alignment, so use size_t as the align type here.
…	…
289	289	}
290	290	}
291	291	} else version (D_InlineAsm_X86_64){
292		T atomicSwap( T )( ~~inout~~ T val, T newval )
	292	T atomicSwap( T )( ref T val, T newval )
293	293	in {
294	294	assert( atomicValueIsProperlyAligned!(T)( cast(size_t) &val ) );
295	295	} body {
…	…
332	332	}
333	333	}
334	334	} else {
335		T atomicSwap( T )( ~~inout~~ T val, T newval )
	335	T atomicSwap( T )( ref T val, T newval )
336	336	in {
337	337	assert( atomicValueIsProperlyAligned!(T)( cast(size_t) &val ) );
338	338	} body {

tango/stdc/stdarg.d

old	new
8	8	*/
9	9	module tango.stdc.stdarg;
10	10
11
12	11	version( GNU )
13	12	{
14	13	public import std.c.stdarg;
…	…
19	18	}
20	19	else
21	20	{
	21	version (X86)
	22	{
	23	/*********************
	24	* The argument pointer type.
	25	*/
22	26	alias void* va_list;
23	27
24		template va_start( T )
	28	/**********
	29	* Initialize ap.
	30	* For 32 bit code, parmn should be the last named parameter.
	31	* For 64 bit code, parmn should be __va_argsave.
	32	*/
	33	void va_start(T)(out va_list ap, ref T parmn)
25	34	{
26		void va_start( out va_list ap, ref T parmn )
	35	ap = cast(va_list)(cast(void*)&parmn + ((T.sizeof + int.sizeof - 1) & ~(int.sizeof - 1)));
	36	}
	37
	38	/************
	39	* Retrieve and return the next value that is type T.
	40	* Should use the other va_arg instead, as this won't work for 64 bit code.
	41	*/
	42	T va_arg(T)(ref va_list ap)
	43	{
	44	T arg = cast(T)ap;
	45	ap = cast(va_list)(cast(void*)ap + ((T.sizeof + int.sizeof - 1) & ~(int.sizeof - 1)));
	46	return arg;
	47	}
	48
	49	/************
	50	* Retrieve and return the next value that is type T.
	51	* This is the preferred version.
	52	*/
	53	void va_arg(T)(ref va_list ap, ref T parmn)
	54	{
	55	parmn = cast(T)ap;
	56	ap = cast(va_list)(cast(void*)ap + ((T.sizeof + int.sizeof - 1) & ~(int.sizeof - 1)));
	57	}
	58
	59	/*************
	60	* Retrieve and store through parmn the next value that is of TypeInfo ti.
	61	* Used when the static type is not known.
	62	*/
	63	void va_arg()(ref va_list ap, TypeInfo ti, void* parmn)
	64	{
	65	// Wait until everyone updates to get TypeInfo.talign()
	66	//auto talign = ti.talign();
	67	//auto p = cast(void*)(cast(size_t)ap + talign - 1) & ~(talign - 1);
	68	auto p = ap;
	69	auto tsize = ti.tsize();
	70	ap = cast(void*)(cast(size_t)p + ((tsize + size_t.sizeof - 1) & ~(size_t.sizeof - 1)));
	71	parmn[0..tsize] = p[0..tsize];
	72	}
	73
	74	/***********************
	75	* End use of ap.
	76	*/
	77	void va_end(va_list ap)
	78	{
	79	}
	80
	81	void va_copy(out va_list dest, va_list src)
	82	{
	83	dest = src;
	84	}
	85	}
	86	else version (X86_64)
	87	{
	88	// Layout of this struct must match __gnuc_va_list for C ABI compatibility
	89	struct __va_list
	90	{
	91	uint offset_regs = 6 * 8; // no regs
	92	uint offset_fpregs = 6 * 8 + 8 * 16; // no fp regs
	93	void* stack_args;
	94	void* reg_args;
	95	}
	96
	97	struct __va_argsave_t
	98	{
	99	size_t[6] regs; // RDI,RSI,RDX,RCX,R8,R9
	100	real[8] fpregs; // XMM0..XMM7
	101	__va_list va;
	102	}
	103
	104	/*
	105	* Making it an array of 1 causes va_list to be passed as a pointer in
	106	* function argument lists
	107	*/
	108	alias void* va_list;
	109
	110	void va_start(T)(out va_list ap, ref T parmn)
	111	{
	112	ap = &parmn.va;
	113	}
	114
	115	T va_arg(T)(va_list ap)
	116	{ T a;
	117	va_arg(ap, a);
	118	return a;
	119	}
	120
	121	void va_arg(T)(va_list apx, ref T parmn)
	122	{
	123	__va_list* ap = cast(__va_list*)apx;
	124	static if (is(T U == __argTypes))
27	125	{
28		ap = cast(va_list) ( cast(void*) &parmn + ( ( T.sizeof + int.sizeof - 1 ) & ~( int.sizeof - 1 ) ) );
	126	static if (U.length == 0 \|\| T.sizeof > 16 \|\| U[0].sizeof > 8)
	127	{ // Always passed in memory
	128	// The arg may have more strict alignment than the stack
	129	auto p = (cast(size_t)ap.stack_args + T.alignof - 1) & ~(T.alignof - 1);
	130	ap.stack_args = cast(void*)(p + ((T.sizeof + size_t.sizeof - 1) & ~(size_t.sizeof - 1)));
	131	parmn = cast(T)p;
	132	}
	133	else static if (U.length == 1)
	134	{ // Arg is passed in one register
	135	alias U[0] T1;
	136	static if (is(T1 == double) \|\| is(T1 == float))
	137	{ // Passed in XMM register
	138	if (ap.offset_fpregs < (6 * 8 + 16 * 8))
	139	{
	140	parmn = cast(T)(ap.reg_args + ap.offset_fpregs);
	141	ap.offset_fpregs += 16;
	142	}
	143	else
	144	{
	145	parmn = cast(T)ap.stack_args;
	146	ap.stack_args += (T1.sizeof + size_t.sizeof - 1) & ~(size_t.sizeof - 1);
	147	}
	148	}
	149	else
	150	{ // Passed in regular register
	151	if (ap.offset_regs < 6 * 8 && T.sizeof <= 8)
	152	{
	153	parmn = cast(T)(ap.reg_args + ap.offset_regs);
	154	ap.offset_regs += 8;
	155	}
	156	else
	157	{
	158	auto p = (cast(size_t)ap.stack_args + T.alignof - 1) & ~(T.alignof - 1);
	159	ap.stack_args = cast(void*)(p + ((T.sizeof + size_t.sizeof - 1) & ~(size_t.sizeof - 1)));
	160	parmn = cast(T)p;
	161	}
	162	}
	163	}
	164	else static if (U.length == 2)
	165	{ // Arg is passed in two registers
	166	alias U[0] T1;
	167	alias U[1] T2;
	168
	169	static if (is(T1 == double) \|\| is(T1 == float))
	170	{
	171	if (ap.offset_fpregs < (6 * 8 + 16 * 8))
	172	{
	173	cast(T1)&parmn = cast(T1)(ap.reg_args + ap.offset_fpregs);
	174	ap.offset_fpregs += 16;
	175	}
	176	else
	177	{
	178	cast(T1)&parmn = cast(T1)ap.stack_args;
	179	ap.stack_args += (T1.sizeof + size_t.sizeof - 1) & ~(size_t.sizeof - 1);
	180	}
	181	}
	182	else
	183	{
	184	if (ap.offset_regs < 6 * 8 && T1.sizeof <= 8)
	185	{
	186	cast(T1)&parmn = cast(T1)(ap.reg_args + ap.offset_regs);
	187	ap.offset_regs += 8;
	188	}
	189	else
	190	{
	191	cast(T1)&parmn = cast(T1)ap.stack_args;
	192	ap.stack_args += 8;
	193	}
	194	}
	195
	196	auto p = cast(void*)&parmn + 8;
	197	static if (is(T2 == double) \|\| is(T2 == float))
	198	{
	199	if (ap.offset_fpregs < (6 * 8 + 16 * 8))
	200	{
	201	cast(T2)p = cast(T2)(ap.reg_args + ap.offset_fpregs);
	202	ap.offset_fpregs += 16;
	203	}
	204	else
	205	{
	206	cast(T2)p = cast(T2)ap.stack_args;
	207	ap.stack_args += (T2.sizeof + size_t.sizeof - 1) & ~(size_t.sizeof - 1);
	208	}
	209	}
	210	else
	211	{
	212	void* a = void;
	213	if (ap.offset_regs < 6 * 8 && T2.sizeof <= 8)
	214	{
	215	a = ap.reg_args + ap.offset_regs;
	216	ap.offset_regs += 8;
	217	}
	218	else
	219	{
	220	a = ap.stack_args;
	221	ap.stack_args += 8;
	222	}
	223	// Be careful not to go past the size of the actual argument
	224	const sz2 = T.sizeof - 8;
	225	p[0..sz2] = a[0..sz2];
	226	}
	227	}
	228	else
	229	{
	230	static assert(0);
	231	}
29	232	}
	233	else
	234	{
	235	static assert(0, "not a valid argument type for va_arg");
	236	}
30	237	}
31	238
32		~~template va_arg( T~~ )
	239	void va_arg()(va_list apx, TypeInfo ti, void* parmn)
33	240	{
34		T va_arg( ref va_list ap )
	241	__va_list* ap = cast(__va_list*)apx;
	242	TypeInfo arg1, arg2;
	243	if (!ti.argTypes(arg1, arg2))
35	244	{
36		T arg = cast(T) ap;
37		ap = cast(va_list) ( cast(void*) ap + ( ( T.sizeof + int.sizeof - 1 ) & ~( int.sizeof - 1 ) ) );
38		return arg;
	245	if (arg1 && arg1.tsize() <= 8)
	246	{ // Arg is passed in one register
	247	auto tsize = arg1.tsize();
	248	void* p;
	249	auto s = arg1.toString();
	250	if (s == "double" \|\| s == "float")
	251	{ // Passed in XMM register
	252	if (ap.offset_fpregs < (6 * 8 + 16 * 8))
	253	{
	254	p = ap.reg_args + ap.offset_fpregs;
	255	ap.offset_fpregs += 16;
	256	}
	257	else
	258	{
	259	p = ap.stack_args;
	260	ap.stack_args += (tsize + size_t.sizeof - 1) & ~(size_t.sizeof - 1);
	261	}
	262	}
	263	else
	264	{ // Passed in regular register
	265	if (ap.offset_regs < 6 * 8)
	266	{
	267	p = ap.reg_args + ap.offset_regs;
	268	ap.offset_regs += 8;
	269	}
	270	else
	271	{
	272	p = ap.stack_args;
	273	ap.stack_args += 8;
	274	}
	275	}
	276	parmn[0..tsize] = p[0..tsize];
	277
	278	if (arg2)
	279	{
	280	parmn += 8;
	281	tsize = arg2.tsize();
	282	s = arg2.toString();
	283	if (s == "double" \|\| s == "float")
	284	{ // Passed in XMM register
	285	if (ap.offset_fpregs < (6 * 8 + 16 * 8))
	286	{
	287	p = ap.reg_args + ap.offset_fpregs;
	288	ap.offset_fpregs += 16;
	289	}
	290	else
	291	{
	292	p = ap.stack_args;
	293	ap.stack_args += (tsize + size_t.sizeof - 1) & ~(size_t.sizeof - 1);
	294	}
	295	}
	296	else
	297	{ // Passed in regular register
	298	if (ap.offset_regs < 6 * 8)
	299	{
	300	p = ap.reg_args + ap.offset_regs;
	301	ap.offset_regs += 8;
	302	}
	303	else
	304	{
	305	p = ap.stack_args;
	306	ap.stack_args += 8;
	307	}
	308	}
	309	tsize = ti.tsize() - 8;
	310	parmn[0..tsize] = p[0..tsize];
	311	}
	312	}
	313	else
	314	{ // Always passed in memory
	315	// The arg may have more strict alignment than the stack
	316	auto talign = ti.talign();
	317	auto tsize = ti.tsize();
	318	auto p = cast(void*)((cast(size_t)ap.stack_args + talign - 1) & ~(talign - 1));
	319	ap.stack_args = cast(void*)(cast(size_t)p + ((tsize + size_t.sizeof - 1) & ~(size_t.sizeof - 1)));
	320	parmn[0..tsize] = p[0..tsize];
	321	}
39	322	}
	323	else
	324	{
	325	assert(0, "not a valid argument type for va_arg");
	326	}
40	327	}
41	328
42		void va_end( ~~va_list ap~~ )
	329	void va_end(va_list ap)
43	330	{
44
45	331	}
46	332
47		void va_copy( ~~out va_list dest, va_list src~~ )
	333	void va_copy(out va_list dest, va_list src)
48	334	{
49	335	dest = src;
50	336	}
51	337	}
	338	else
	339	{
	340	static assert(0);
	341	}
	342	}

tango/util/log/Log.d

old	new
3	3	copyright: Copyright (c) 2004 Kris Bell. All rights reserved
4	4
5	5	license: BSD style: $(LICENSE)
6
	6
7	7	version: May 2004 : Initial release
8	8	version: Oct 2004: Hierarchy moved due to circular dependencies
9	9	version: Apr 2008: Lazy delegates removed due to awkward usage
…	…
20	20
21	21	Generic usage:
22	22
23		Loggers are named entities, sometimes shared, sometimes specific to
24		a particular portion of code. The names are generally hierarchical in
25		nature, using dot notation (with '.') to separate each named section.
	23	Loggers are named entities, sometimes shared, sometimes specific to
	24	a particular portion of code. The names are generally hierarchical in
	25	nature, using dot notation (with '.') to separate each named section.
26	26	For example, a typical name might be something like "mail.send.writer"
27	27	---
28	28	import tango.util.log.Log;
29
	29
30	30	auto log = Log.lookup ("mail.send.writer");
31	31
32	32	log.info ("an informational message");
…	…
34	34
35	35	etc ...
36	36	---
37
38		It is considered good form to pass a logger instance as a function or
39		class-ctor argument, or to assign a new logger instance during static
40		class construction. For example: if it were considered appropriate to
	37
	38	It is considered good form to pass a logger instance as a function or
	39	class-ctor argument, or to assign a new logger instance during static
	40	class construction. For example: if it were considered appropriate to
41	41	have one logger instance per class, each might be constructed like so:
42	42	---
43	43	private Logger log;
44
	44
45	45	static this()
46	46	{
47	47	log = Log.lookup (nameOfThisClassOrStructOrModule);
…	…
63	63	log.warn (log.format (buf, "a very long message: {}", someLongMessage));
64	64	---
65	65
66		To avoid overhead when constructing arguments passed to formatted
	66	To avoid overhead when constructing arguments passed to formatted
67	67	messages, you should check to see whether a logger is active or not:
68	68	---
69	69	if (log.warn)
70	70	log.warn ("temperature is {} degrees!", complexFunction());
71	71	---
72
73		tango.log closely follows both the API and the behaviour as documented
74		at the official Log4J site, where you'll find a good tutorial. Those
75		pages are hosted over
	72
	73	tango.log closely follows both the API and the behaviour as documented
	74	at the official Log4J site, where you'll find a good tutorial. Those
	75	pages are hosted over
76	76	<A HREF="http://logging.apache.org/log4j/docs/documentation.html">here</A>.
77	77
78	78	*******************************************************************************/
…	…
103	103	alias void* Arg;
104	104	alias va_list ArgList;
105	105	}
	106	version (DigitalMars)
	107	{
	108	private import tango.core.Vararg;
	109	alias void* Arg;
	110	alias va_list ArgList;
	111	}
106	112	else
107	113	{
108	114	alias void* Arg;
…	…
127	133	}
128	134
129	135	/*******************************************************************************
130
	136
131	137	These represent the standard LOG4J event levels. Note that
132	138	Debug is called Trace here, because debug is a reserved word
133		in D
	139	in D
134	140
135	141	*******************************************************************************/
136	142
137		alias ILogger.Level Level;
	143	alias ILogger.Level Level;
138	144
139	145
140	146	/*******************************************************************************
141	147
142		Manager for routing Logger calls to the default hierarchy. Note
	148	Manager for routing Logger calls to the default hierarchy. Note
143	149	that you may have multiple hierarchies per application, but must
144		access the hierarchy directly for root() and lookup() methods within
	150	access the hierarchy directly for root() and lookup() methods within
145	151	each additional instance.
146	152
147	153	*******************************************************************************/
…	…
167	173	private struct Pair {char[] name; Level value;}
168	174
169	175	private static Level [char[]] map;
170
171		private static Pair[] Pairs =
	176
	177	private static Pair[] Pairs =
172	178	[
173	179	{"TRACE", Level.Trace},
174	180	{"Trace", Level.Trace},
…	…
191	197	];
192	198
193	199	// logging-level names
194		private static char[][] LevelNames =
	200	private static char[][] LevelNames =
195	201	[
196	202	"Trace", "Info", "Warn", "Error", "Fatal", "None"
197	203	];
198	204
199	205	/***********************************************************************
200
201		Initialize the base hierarchy
202
	206
	207	Initialize the base hierarchy
	208
203	209	***********************************************************************/
204	210
205	211	static this ()
…	…
209	215	foreach (p; Pairs)
210	216	map[p.name] = p.value;
211	217
212		version (Posix)
	218	version (Posix)
213	219	{
214	220	beginTime = Clock.now;
215	221	}
…	…
220	226
221	227	if (! QueryPerformanceFrequency (&freq))
222	228	throw new PlatformException ("high-resolution timer is not available");
223
	229
224	230	QueryPerformanceCounter (&timerStart);
225		multiplier = cast(double) TimeSpan.TicksPerSecond / freq;
	231	multiplier = cast(double) TimeSpan.TicksPerSecond / freq;
226	232	beginTime = Clock.now;
227	233	}
228	234	}
229	235
230	236	/***********************************************************************
231
	237
232	238	Return the level of a given name
233	239
234	240	***********************************************************************/
…	…
242	248	}
243	249
244	250	/***********************************************************************
245
	251
246	252	Return the current time
247	253
248	254	***********************************************************************/
249	255
250	256	static Time time ()
251	257	{
252		version (Posix)
	258	version (Posix)
253	259	{
254	260	return Clock.now;
255	261	}
…	…
266	272	/***********************************************************************
267	273
268	274	Return the root Logger instance. This is the ancestor of
269		all loggers and, as such, can be used to manipulate the
270		entire hierarchy. For instance, setting the root 'level'
	275	all loggers and, as such, can be used to manipulate the
	276	entire hierarchy. For instance, setting the root 'level'
271	277	attribute will affect all other loggers in the tree.
272	278
273	279	***********************************************************************/
…	…
278	284	}
279	285
280	286	/***********************************************************************
281
	287
282	288	Return an instance of the named logger. Names should be
283		hierarchical in nature, using dot notation (with '.') to
284		separate each name section. For example, a typical name
	289	hierarchical in nature, using dot notation (with '.') to
	290	separate each name section. For example, a typical name
285	291	might be something like "tango.io.Stdout".
286	292
287	293	If the logger does not currently exist, it is created and
…	…
297	303	}
298	304
299	305	/***********************************************************************
300
	306
301	307	Return text name for a log level
302	308
303	309	***********************************************************************/
…	…
309	315	}
310	316
311	317	/***********************************************************************
312
	318
313	319	Return the singleton hierarchy.
314	320
315	321	***********************************************************************/
…	…
320	326	}
321	327
322	328	/***********************************************************************
323
	329
324	330	Pedestrian usage support, as an alias for Log.root.info()
325	331
326	332	***********************************************************************/
…	…
336	342
337	343	Adds a StreamAppender to the root node, and sets
338	344	the activity level to be everything enabled.
339
	345
340	346	***********************************************************************/
341	347
342	348	static void config (OutputStream stream, bool flush = true)
…	…
348	354
349	355	/*******************************************************************************
350	356
351		Loggers are named entities, sometimes shared, sometimes specific to
352		a particular portion of code. The names are generally hierarchical in
353		nature, using dot notation (with '.') to separate each named section.
	357	Loggers are named entities, sometimes shared, sometimes specific to
	358	a particular portion of code. The names are generally hierarchical in
	359	nature, using dot notation (with '.') to separate each named section.
354	360	For example, a typical name might be something like "mail.send.writer"
355	361	---
356	362	import tango.util.log.Log;format
357
	363
358	364	auto log = Log.lookup ("mail.send.writer");
359	365
360	366	log.info ("an informational message");
…	…
362	368
363	369	etc ...
364	370	---
365
366		It is considered good form to pass a logger instance as a function or
367		class-ctor argument, or to assign a new logger instance during static
368		class construction. For example: if it were considered appropriate to
	371
	372	It is considered good form to pass a logger instance as a function or
	373	class-ctor argument, or to assign a new logger instance during static
	374	class construction. For example: if it were considered appropriate to
369	375	have one logger instance per class, each might be constructed like so:
370	376	---
371	377	private Logger log;
372
	378
373	379	static this()
374	380	{
375	381	log = Log.lookup (nameOfThisClassOrStructOrModule);
…	…
391	397	log.warn (log.format (buf, "a very long warning: {}", someLongWarning));
392	398	---
393	399
394		To avoid overhead when constructing argument passed to formatted
	400	To avoid overhead when constructing argument passed to formatted
395	401	messages, you should check to see whether a logger is active or not:
396	402	---
397	403	if (log.enabled (log.Warn))
398	404	log.warn ("temperature is {} degrees!", complexFunction());
399	405	---
400
401		The above will be handled implicitly by the logging system when
402		macros are added to the language (used to be handled implicitly
	406
	407	The above will be handled implicitly by the logging system when
	408	macros are added to the language (used to be handled implicitly
403	409	via lazy delegates, but usage of those turned out to be awkward).
404	410
405		tango.log closely follows both the API and the behaviour as documented
406		at the official Log4J site, where you'll find a good tutorial. Those
407		pages are hosted over
	411	tango.log closely follows both the API and the behaviour as documented
	412	at the official Log4J site, where you'll find a good tutorial. Those
	413	pages are hosted over
408	414	<A HREF="http://logging.apache.org/log4j/docs/documentation.html">here</A>.
409	415
410	416	*******************************************************************************/
411	417
412	418	public class Logger : ILogger
413		{
414
415		alias Level.Trace Trace; // shortcut to Level values
	419	{
	420
	421	alias Level.Trace Trace; // shortcut to Level values
416	422	alias Level.Info Info; // ...
417	423	alias Level.Warn Warn; // ...
418	424	alias Level.Error Error; // ...
…	…
421	427	alias append opCall; // shortcut to append
422	428
423	429	/***********************************************************************
424
	430
425	431	Context for a hierarchy, used for customizing behaviour
426	432	of log hierarchies. You can use this to implement dynamic
427	433	log-levels, based upon filtering or some other mechanism
…	…
432	438	{
433	439	/// return a label for this context
434	440	char[] label ();
435
	441
436	442	/// first arg is the setting of the logger itself, and
437	443	/// the second arg is what kind of message we're being
438	444	/// asked to produce
…	…
440	446	}
441	447
442	448	/***********************************************************************
443
	449
444	450	***********************************************************************/
445	451
446	452	private Logger next,
…	…
453	459	private Appender appender_;
454	460
455	461	/***********************************************************************
456
457		Construct a LoggerInstance with the specified name for the
	462
	463	Construct a LoggerInstance with the specified name for the
458	464	given hierarchy. By default, logger instances are additive
459	465	and are set to emit all events.
460	466
…	…
469	475	}
470	476
471	477	/***********************************************************************
472
	478
473	479	Is this logger enabed for the specified Level?
474	480
475	481	***********************************************************************/
…	…
592	598	/***********************************************************************
593	599
594	600	Return the name of this Logger (sans the appended dot).
595
	601
596	602	***********************************************************************/
597	603
598	604	final char[] name ()
…	…
600	606	int i = name_.length;
601	607	if (i > 0)
602	608	--i;
603		return name_[0 .. i];
	609	return name_[0 .. i];
604	610	}
605	611
606	612	/***********************************************************************
607
	613
608	614	Return the Level this logger is set to
609	615
610	616	***********************************************************************/
611	617
612	618	final Level level ()
613	619	{
614		return level_;
	620	return level_;
615	621	}
616	622
617	623	/***********************************************************************
618
	624
619	625	Set the current level for this logger (and only this logger).
620	626
621	627	***********************************************************************/
…	…
626	632	}
627	633
628	634	/***********************************************************************
629
	635
630	636	Set the current level for this logger, and (optionally) all
631	637	of its descendents.
632	638
…	…
634	640
635	641	final Logger level (Level level, bool propagate)
636	642	{
637		level_ = level;
638		if (propagate)
	643	level_ = level;
	644	if (propagate)
639	645	foreach (log; host_)
640	646	if (log.isChildOf (name_))
641	647	log.level_ = level;
…	…
643	649	}
644	650
645	651	/***********************************************************************
646
	652
647	653	Is this logger additive? That is, should we walk ancestors
648	654	looking for more appenders?
649	655
…	…
655	661	}
656	662
657	663	/***********************************************************************
658
	664
659	665	Set the additive status of this logger. See bool additive().
660	666
661	667	***********************************************************************/
662	668
663	669	final Logger additive (bool enabled)
664	670	{
665		additive_ = enabled;
	671	additive_ = enabled;
666	672	return this;
667	673	}
668	674
669	675	/***********************************************************************
670
	676
671	677	Add (another) appender to this logger. Appenders are each
672	678	invoked for log events as they are produced. At most, one
673	679	instance of each appender will be invoked.
…	…
683	689	}
684	690
685	691	/***********************************************************************
686
	692
687	693	Remove all appenders from this Logger
688	694
689	695	***********************************************************************/
690	696
691	697	final Logger clear ()
692	698	{
693		appender_ = null;
	699	appender_ = null;
694	700	return this;
695	701	}
696	702
697	703	/***********************************************************************
698
	704
699	705	Get time since this application started
700	706
701	707	***********************************************************************/
…	…
706	712	}
707	713
708	714	/***********************************************************************
709
	715
710	716	Send a message to this logger via its appender list.
711	717
712	718	***********************************************************************/
…	…
725	731	}
726	732
727	733	/***********************************************************************
728
	734
729	735	Send a message to this logger via its appender list.
730	736
731	737	***********************************************************************/
…	…
734	740	{
735	741	// combine appenders from all ancestors
736	742	auto links = this;
737		Appender.Mask masks = 0;
	743	Appender.Mask masks = 0;
738	744	do {
739	745	auto appender = links.appender_;
740	746
741	747	// this level have an appender?
742	748	while (appender)
743		{
	749	{
744	750	auto mask = appender.mask;
745	751
746	752	// have we visited this appender already?
…	…
777	783	***********************************************************************/
778	784
779	785	final Logger format (Level level, char[] fmt, TypeInfo[] types, ArgList args)
780		{
	786	{
781	787	char[2048] tmp = void;
782
	788
783	789	if (types.length)
784	790	append (level, Format.vprint (tmp, fmt, types, args));
785	791	else
786		append (level, fmt);
	792	append (level, fmt);
787	793	return this;
788	794	}
789	795
790	796	/***********************************************************************
791
792		See if the provided Logger name is a parent of this one. Note
793		that each Logger name has a '.' appended to the end, such that
	797
	798	See if the provided Logger name is a parent of this one. Note
	799	that each Logger name has a '.' appended to the end, such that
794	800	name segments will not partially match.
795	801
796	802	***********************************************************************/
…	…
801	807
802	808	// possible parent if length is shorter
803	809	if (len < name_.length)
804		// does the prefix match? Note we append a "." to each
	810	// does the prefix match? Note we append a "." to each
805	811	// (the root is a parent of everything)
806		return (len is 0 \|\|
	812	return (len is 0 \|\|
807	813	memcmp (&candidate[0], &name_[0], len) is 0);
808	814	return false;
809	815	}
810	816
811	817	/***********************************************************************
812
	818
813	819	See if the provided Logger is a better match as a parent of
814	820	this one. This is used to restructure the hierarchy when a
815	821	new logger instance is introduced
…	…
828	834	}
829	835
830	836	/*******************************************************************************
831
	837
832	838	The Logger hierarchy implementation. We keep a reference to each
833	839	logger in a hash-table for convenient lookup purposes, plus keep
834	840	each logger linked to the others in an ordered group. Ordering
835		places shortest names at the head and longest ones at the tail,
	841	places shortest names at the head and longest ones at the tail,
836	842	making the job of identifying ancestors easier in an orderly
837	843	fashion. For example, when propagating levels across descendents
838	844	it would be a mistake to propagate to a child before all of its
…	…
844	850	{
845	851	private Logger root_;
846	852	private char[] name_,
847		address_;
	853	address_;
848	854	private Logger.Context context_;
849	855	private Logger[char[]] loggers;
850	856
851	857
852	858	/***********************************************************************
853
	859
854	860	Construct a hierarchy with the given name.
855	861
856	862	***********************************************************************/
…	…
873	879	{
874	880	return "";
875	881	}
876
	882
877	883	/**********************************************************************
878	884
879	885
…	…
932	938
933	939	/**********************************************************************
934	940
935		Return the diagnostic context. Useful for setting an
	941	Return the diagnostic context. Useful for setting an
936	942	override logging level.
937	943
938	944	**********************************************************************/
939
	945
940	946	final Logger.Context context ()
941	947	{
942	948	return context_;
943	949	}
944
	950
945	951	/**********************************************************************
946	952
947		Set the diagnostic context. Not usually necessary, as a
948		default was created. Useful when you need to provide a
	953	Set the diagnostic context. Not usually necessary, as a
	954	default was created. Useful when you need to provide a
949	955	different implementation, such as a ThreadLocal variant.
950	956
951	957	**********************************************************************/
952
	958
953	959	final void context (Logger.Context context)
954	960	{
955	961	context_ = context;
956	962	}
957
	963
958	964	/***********************************************************************
959
	965
960	966	Return the root node.
961	967
962	968	***********************************************************************/
…	…
967	973	}
968	974
969	975	/***********************************************************************
970
	976
971	977	Return the instance of a Logger with the provided label. If
972	978	the instance does not exist, it is created at this time.
973	979
…	…
1001	1007	}
1002	1008
1003	1009	/***********************************************************************
1004
	1010
1005	1011	Return the instance of a Logger with the provided label. If
1006	1012	the instance does not exist, it is created at this time.
1007	1013
…	…
1021	1027	// insert into linked list
1022	1028	insert (li);
1023	1029
1024		// look for and adjust children. Don't force
	1030	// look for and adjust children. Don't force
1025	1031	// property inheritance on existing loggers
1026	1032	update (li);
1027	1033
1028	1034	// insert into map
1029	1035	loggers [name] = li;
1030	1036	}
1031
	1037
1032	1038	return *l;
1033	1039	}
1034	1040
1035	1041	/***********************************************************************
1036
1037		Loggers are maintained in a sorted linked-list. The order
1038		is maintained such that the shortest name is at the root,
	1042
	1043	Loggers are maintained in a sorted linked-list. The order
	1044	is maintained such that the shortest name is at the root,
1039	1045	and the longest at the tail.
1040	1046
1041	1047	This is done so that updateLoggers() will always have a
…	…
1054	1060	if (l.name.length < curr.name.length)
1055	1061	if (prev is null)
1056	1062	throw new IllegalElementException ("invalid hierarchy");
1057		else
	1063	else
1058	1064	{
1059	1065	l.next = prev.next;
1060	1066	prev.next = l;
…	…
1066	1072	propagate (l, curr, true);
1067	1073
1068	1074	// remember where insertion point should be
1069		prev = curr;
1070		curr = curr.next;
	1075	prev = curr;
	1076	curr = curr.next;
1071	1077	}
1072	1078
1073	1079	// add to tail
…	…
1075	1081	}
1076	1082
1077	1083	/***********************************************************************
1078
1079		Propagate hierarchical changes across known loggers.
	1084
	1085	Propagate hierarchical changes across known loggers.
1080	1086	This includes changes in the hierarchy itself, and to
1081		the various settings of child loggers with respect to
1082		their parent(s).
	1087	the various settings of child loggers with respect to
	1088	their parent(s).
1083	1089
1084	1090	***********************************************************************/
1085	1091
…	…
1090	1096	}
1091	1097
1092	1098	/***********************************************************************
1093
	1099
1094	1100	Propagate changes in the hierarchy downward to child Loggers.
1095		Note that while 'parent' is always changed, the adjustment of
	1101	Note that while 'parent' is always changed, the adjustment of
1096	1102	'level' is selectable.
1097	1103
1098	1104	***********************************************************************/
…	…
1136	1142	private Hierarchy host_;
1137	1143
1138	1144	/***********************************************************************
1139
	1145
1140	1146	Set the various attributes of this event.
1141	1147
1142	1148	***********************************************************************/
…	…
1151	1157	}
1152	1158
1153	1159	/***********************************************************************
1154
	1160
1155	1161	Return the message attached to this event.
1156	1162
1157	1163	***********************************************************************/
…	…
1162	1168	}
1163	1169
1164	1170	/***********************************************************************
1165
	1171
1166	1172	Return the name of the logger which produced this event
1167	1173
1168	1174	***********************************************************************/
…	…
1173	1179	}
1174	1180
1175	1181	/***********************************************************************
1176
	1182
1177	1183	Return the logger level of this event.
1178	1184
1179	1185	***********************************************************************/
…	…
1184	1190	}
1185	1191
1186	1192	/***********************************************************************
1187
	1193
1188	1194	Return the hierarchy where the event was produced from
1189	1195
1190	1196	***********************************************************************/
…	…
1195	1201	}
1196	1202
1197	1203	/***********************************************************************
1198
1199		Return the time this event was produced, relative to the
	1204
	1205	Return the time this event was produced, relative to the
1200	1206	start of this executable
1201	1207
1202	1208	***********************************************************************/
…	…
1207	1213	}
1208	1214
1209	1215	/***********************************************************************
1210
	1216
1211	1217	Return the time this event was produced relative to Epoch
1212	1218
1213	1219	***********************************************************************/
…	…
1218	1224	}
1219	1225
1220	1226	/***********************************************************************
1221
	1227
1222	1228	Return time when the executable started
1223	1229
1224	1230	***********************************************************************/
…	…
1229	1235	}
1230	1236
1231	1237	/***********************************************************************
1232
	1238
1233	1239	Return the logger level name of this event.
1234	1240
1235	1241	***********************************************************************/
…	…
1240	1246	}
1241	1247
1242	1248	/***********************************************************************
1243
	1249
1244	1250	Convert a time value (in milliseconds) to ascii
1245	1251
1246	1252	***********************************************************************/
…	…
1255	1261	s[--len] = cast(char)(ms % 10 + '0');
1256	1262	ms /= 10;
1257	1263	} while (ms && len);
1258		return s[len..s.length];
	1264	return s[len..s.length];
1259	1265	}
1260	1266	}
1261	1267
…	…
1266	1272	emitting messages sent to a particular logger. There may be more
1267	1273	than one appender attached to any logger. The actual message is
1268	1274	constructed by another class known as an EventLayout.
1269
	1275
1270	1276	*******************************************************************************/
1271	1277
1272	1278	public class Appender
…	…
1282	1288
1283	1289	Interface for all logging layout instances
1284	1290
1285		Implement this method to perform the formatting of
	1291	Implement this method to perform the formatting of
1286	1292	message content.
1287	1293
1288	1294	***********************************************************************/
…	…
1293	1299	}
1294	1300
1295	1301	/***********************************************************************
1296
	1302
1297	1303	Return the mask used to identify this Appender. The mask
1298		is used to figure out whether an appender has already been
	1304	is used to figure out whether an appender has already been
1299	1305	invoked for a particular logger.
1300	1306
1301	1307	***********************************************************************/
…	…
1303	1309	abstract Mask mask ();
1304	1310
1305	1311	/***********************************************************************
1306
	1312
1307	1313	Return the name of this Appender.
1308	1314
1309	1315	***********************************************************************/
1310	1316
1311	1317	abstract char[] name ();
1312
	1318
1313	1319	/***********************************************************************
1314
	1320
1315	1321	Append a message to the output.
1316	1322
1317	1323	***********************************************************************/
…	…
1319	1325	abstract void append (LogEvent event);
1320	1326
1321	1327	/***********************************************************************
1322
1323		~~Create an Appender and default its layout to LayoutSimple.~~
1324	1328
	1329	Create an Appender and default its layout to LayoutSimple.
	1330
1325	1331	***********************************************************************/
1326	1332
1327	1333	this ()
…	…
1330	1336	}
1331	1337
1332	1338	/***********************************************************************
1333
1334		~~Create an Appender and default its layout to LayoutSimple.~~
1335	1339
	1340	Create an Appender and default its layout to LayoutSimple.
	1341
1336	1342	***********************************************************************/
1337	1343
1338	1344	static this ()
…	…
1341	1347	}
1342	1348
1343	1349	/***********************************************************************
1344
	1350
1345	1351	Return the current Level setting
1346	1352
1347	1353	***********************************************************************/
…	…
1352	1358	}
1353	1359
1354	1360	/***********************************************************************
1355
	1361
1356	1362	Return the current Level setting
1357	1363
1358	1364	***********************************************************************/
…	…
1364	1370	}
1365	1371
1366	1372	/***********************************************************************
1367
	1373
1368	1374	Static method to return a mask for identifying the Appender.
1369	1375	Each Appender class should have a unique fingerprint so that
1370	1376	we can figure out which ones have been invoked for a given
…	…
1394	1400	}
1395	1401
1396	1402	/***********************************************************************
1397
	1403
1398	1404	Set the current layout to be that of the argument, or the
1399	1405	generic layout where the argument is null
1400	1406
…	…
1406	1412	}
1407	1413
1408	1414	/***********************************************************************
1409
	1415
1410	1416	Return the current Layout
1411	1417
1412	1418	***********************************************************************/
…	…
1417	1423	}
1418	1424
1419	1425	/***********************************************************************
1420
	1426
1421	1427	Attach another appender to this one
1422	1428
1423	1429	***********************************************************************/
…	…
1428	1434	}
1429	1435
1430	1436	/***********************************************************************
1431
	1437
1432	1438	Return the next appender in the list
1433	1439
1434	1440	***********************************************************************/
…	…
1439	1445	}
1440	1446
1441	1447	/***********************************************************************
1442
1443		Close this appender. This would be used for file, sockets,
	1448
	1449	Close this appender. This would be used for file, sockets,
1444	1450	and such like.
1445	1451
1446	1452	***********************************************************************/
…	…
1463	1469	private Mask mask_;
1464	1470
1465	1471	/***********************************************************************
1466
	1472
1467	1473	Create with the given Layout
1468	1474
1469	1475	***********************************************************************/
…	…
1475	1481	}
1476	1482
1477	1483	/***********************************************************************
1478
	1484
1479	1485	Return the fingerprint for this class
1480	1486
1481	1487	***********************************************************************/
…	…
1486	1492	}
1487	1493
1488	1494	/***********************************************************************
1489
	1495
1490	1496	Return the name of this class
1491	1497
1492	1498	***********************************************************************/
…	…
1495	1501	{
1496	1502	return this.classinfo.name;
1497	1503	}
1498
	1504
1499	1505	/***********************************************************************
1500
	1506
1501	1507	Append an event to the output.
1502
	1508
1503	1509	***********************************************************************/
1504	1510
1505	1511	final void append (LogEvent event)
…	…
1522	1528	private OutputStream stream_;
1523	1529
1524	1530	/***********************************************************************
1525
	1531
1526	1532	Create with the given stream and layout
1527	1533
1528	1534	***********************************************************************/
…	…
1538	1544	}
1539	1545
1540	1546	/***********************************************************************
1541
	1547
1542	1548	Return the fingerprint for this class
1543	1549
1544	1550	***********************************************************************/
…	…
1549	1555	}
1550	1556
1551	1557	/***********************************************************************
1552
	1558
1553	1559	Return the name of this class
1554	1560
1555	1561	***********************************************************************/
…	…
1558	1564	{
1559	1565	return this.classinfo.name;
1560	1566	}
1561
	1567
1562	1568	/***********************************************************************
1563
	1569
1564	1570	Append an event to the output.
1565
	1571
1566	1572	***********************************************************************/
1567	1573
1568	1574	final void append (LogEvent event)
…	…
1591	1597	public class LayoutTimer : Appender.Layout
1592	1598	{
1593	1599	/***********************************************************************
1594
	1600
1595	1601	Subclasses should implement this method to perform the
1596	1602	formatting of the actual message content.
1597	1603
…	…
1621	1627	debug (Log)
1622	1628	{
1623	1629	import tango.io.Console;
1624
	1630
1625	1631	void main()
1626	1632	{
1627	1633	Log.config (Cerr.stream);

Ticket #2038: 64Bit.4.patch

build/script/unittest.sh

build/src/bob.d

object.di

tango/text/convert/Layout.d

tango/text/Text.d

tango/io/stream/Snoop.d

tango/io/stream/Format.d

tango/core/rt/gc/basic/gcx.d

tango/core/rt/gc/basic/gcbits.d

tango/core/rt/compiler/ldc/object_.d

tango/core/rt/compiler/ldc/typeinfo/ti_void.d

tango/core/rt/compiler/ldc/typeinfo/ti_wchar.d

tango/core/rt/compiler/ldc/typeinfo/ti_ptr.d

tango/core/rt/compiler/ldc/typeinfo/ti_Afloat.d

tango/core/rt/compiler/ldc/typeinfo/ti_double.d

tango/core/rt/compiler/ldc/typeinfo/ti_delegate.d

tango/core/rt/compiler/ldc/typeinfo/ti_Adouble.d

tango/core/rt/compiler/ldc/typeinfo/ti_char.d

tango/core/rt/compiler/ldc/typeinfo/ti_Acdouble.d

tango/core/rt/compiler/ldc/typeinfo/ti_uint.d

tango/core/rt/compiler/ldc/typeinfo/ti_AC.d

tango/core/rt/compiler/ldc/typeinfo/ti_ulong.d

tango/core/rt/compiler/ldc/typeinfo/ti_creal.d

tango/core/rt/compiler/ldc/typeinfo/ti_ubyte.d

tango/core/rt/compiler/ldc/typeinfo/ti_Aint.d

tango/core/rt/compiler/ldc/typeinfo/ti_long.d

tango/core/rt/compiler/ldc/typeinfo/ti_short.d

tango/core/rt/compiler/ldc/typeinfo/ti_Along.d

tango/core/rt/compiler/ldc/typeinfo/ti_byte.d

tango/core/rt/compiler/ldc/typeinfo/ti_float.d

tango/core/rt/compiler/ldc/typeinfo/ti_cfloat.d

tango/core/rt/compiler/ldc/typeinfo/ti_Acfloat.d

tango/core/rt/compiler/ldc/typeinfo/ti_cdouble.d

tango/core/rt/compiler/ldc/typeinfo/ti_dchar.d

tango/core/rt/compiler/ldc/typeinfo/ti_C.d

tango/core/rt/compiler/ldc/typeinfo/ti_real.d

tango/core/rt/compiler/ldc/typeinfo/ti_ushort.d

tango/core/rt/compiler/ldc/typeinfo/ti_Areal.d

tango/core/rt/compiler/ldc/typeinfo/ti_Acreal.d

tango/core/rt/compiler/ldc/typeinfo/ti_Ag.d

tango/core/rt/compiler/ldc/typeinfo/ti_int.d

tango/core/rt/compiler/ldc/typeinfo/ti_Ashort.d

tango/core/rt/compiler/dmd/rt/trace.d

tango/core/rt/compiler/dmd/rt/lifetime.d

tango/core/rt/compiler/dmd/rt/memory.d

tango/core/rt/compiler/dmd/rt/cover.d

tango/core/rt/compiler/dmd/rt/aaA.d

tango/core/rt/compiler/dmd/object_.d

tango/core/rt/compiler/dmd/typeinfo/ti_void.d

tango/core/rt/compiler/dmd/typeinfo/ti_wchar.d

tango/core/rt/compiler/dmd/typeinfo/ti_ptr.d

tango/core/rt/compiler/dmd/typeinfo/ti_Afloat.d

tango/core/rt/compiler/dmd/typeinfo/ti_double.d

tango/core/rt/compiler/dmd/typeinfo/ti_delegate.d

tango/core/rt/compiler/dmd/typeinfo/ti_Adouble.d

tango/core/rt/compiler/dmd/typeinfo/ti_char.d

tango/core/rt/compiler/dmd/typeinfo/ti_Acdouble.d

tango/core/rt/compiler/dmd/typeinfo/ti_uint.d

tango/core/rt/compiler/dmd/typeinfo/ti_AC.d

tango/core/rt/compiler/dmd/typeinfo/ti_ulong.d

tango/core/rt/compiler/dmd/typeinfo/ti_creal.d

tango/core/rt/compiler/dmd/typeinfo/ti_ubyte.d

tango/core/rt/compiler/dmd/typeinfo/ti_Aint.d

tango/core/rt/compiler/dmd/typeinfo/ti_long.d

tango/core/rt/compiler/dmd/typeinfo/ti_short.d

tango/core/rt/compiler/dmd/typeinfo/ti_Along.d

tango/core/rt/compiler/dmd/typeinfo/ti_byte.d

tango/core/rt/compiler/dmd/typeinfo/ti_float.d

tango/core/rt/compiler/dmd/typeinfo/ti_cfloat.d

tango/core/rt/compiler/dmd/typeinfo/ti_Acfloat.d

tango/core/rt/compiler/dmd/typeinfo/ti_cdouble.d

tango/core/rt/compiler/dmd/typeinfo/ti_dchar.d

tango/core/rt/compiler/dmd/typeinfo/ti_C.d

tango/core/rt/compiler/dmd/typeinfo/ti_real.d

tango/core/rt/compiler/dmd/typeinfo/ti_ushort.d

tango/core/rt/compiler/dmd/typeinfo/ti_Areal.d

tango/core/rt/compiler/dmd/typeinfo/ti_Acreal.d

tango/core/rt/compiler/dmd/typeinfo/ti_Ag.d

tango/core/rt/compiler/dmd/typeinfo/ti_int.d