Ticket #2038: 64Bit.4.patch
File 64Bit.4.patch, 144.8 kB (added by Marenz, 13 years ago) |
---|
Fixed compilation errors in deh.d |
-
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.a103 $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, gcc 32);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, gcc 32);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 asm2347 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 uinttest(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 uinttestClear(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 { uintresult;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 v a_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, uint *pretaddr)167 size_t __eh_find_caller(size_t regbp, size_t *pretaddr) 168 168 { 169 uint bp = *cast(uint *)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 + int.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 uint retaddr;222 uint 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 uint 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 asm2719 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 )( inoutT 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 )( inoutT 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 )( inoutT 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);