mirrors/phobos
1
0
Fork 0
mirror of https://github.com/dlang/phobos.git synced 2025-05-04 09:00:22 +03:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

Automatically add spaces to binary operators (<<)

Browse source 
command:

sed -E "s/([[:alnum:]]) << ([[:alnum:]])/\1 << \2/g" -i **/*.d
sed -E "s/([[:alnum:]])<< ([[:alnum:]])/\1 << \2/g" -i **/*.d
sed -E "s/([[:alnum:]]) <<([[:alnum:]])/\1 << \2/g" -i **/*.d
This commit is contained in:
Sebastian Wilzbach 2017-02-23 00:50:14 +01:00
parent d905ef53b1
commit ef7be4b60d
11 changed files with 132 additions and 132 deletions
Download patch file Download diff file Expand all files Collapse all files

106
etc/c/sqlite3.d
View file

@ -149,59 +149,59 @@ enum
*/ */
enum enum
{ {
SQLITE_IOERR_READ = (SQLITE_IOERR | (1<<8)), SQLITE_IOERR_READ = (SQLITE_IOERR | (1 << 8)),
SQLITE_IOERR_SHORT_READ = (SQLITE_IOERR | (2<<8)), SQLITE_IOERR_SHORT_READ = (SQLITE_IOERR | (2 << 8)),
SQLITE_IOERR_WRITE = (SQLITE_IOERR | (3<<8)), SQLITE_IOERR_WRITE = (SQLITE_IOERR | (3 << 8)),
SQLITE_IOERR_FSYNC = (SQLITE_IOERR | (4<<8)), SQLITE_IOERR_FSYNC = (SQLITE_IOERR | (4 << 8)),
SQLITE_IOERR_DIR_FSYNC = (SQLITE_IOERR | (5<<8)), SQLITE_IOERR_DIR_FSYNC = (SQLITE_IOERR | (5 << 8)),
SQLITE_IOERR_TRUNCATE = (SQLITE_IOERR | (6<<8)), SQLITE_IOERR_TRUNCATE = (SQLITE_IOERR | (6 << 8)),
SQLITE_IOERR_FSTAT = (SQLITE_IOERR | (7<<8)), SQLITE_IOERR_FSTAT = (SQLITE_IOERR | (7 << 8)),
SQLITE_IOERR_UNLOCK = (SQLITE_IOERR | (8<<8)), SQLITE_IOERR_UNLOCK = (SQLITE_IOERR | (8 << 8)),
SQLITE_IOERR_RDLOCK = (SQLITE_IOERR | (9<<8)), SQLITE_IOERR_RDLOCK = (SQLITE_IOERR | (9 << 8)),
SQLITE_IOERR_DELETE = (SQLITE_IOERR | (10<<8)), SQLITE_IOERR_DELETE = (SQLITE_IOERR | (10 << 8)),
SQLITE_IOERR_BLOCKED = (SQLITE_IOERR | (11<<8)), SQLITE_IOERR_BLOCKED = (SQLITE_IOERR | (11 << 8)),
SQLITE_IOERR_NOMEM = (SQLITE_IOERR | (12<<8)), SQLITE_IOERR_NOMEM = (SQLITE_IOERR | (12 << 8)),
SQLITE_IOERR_ACCESS = (SQLITE_IOERR | (13<<8)), SQLITE_IOERR_ACCESS = (SQLITE_IOERR | (13 << 8)),
SQLITE_IOERR_CHECKRESERVEDLOCK = (SQLITE_IOERR | (14<<8)), SQLITE_IOERR_CHECKRESERVEDLOCK = (SQLITE_IOERR | (14 << 8)),
SQLITE_IOERR_LOCK = (SQLITE_IOERR | (15<<8)), SQLITE_IOERR_LOCK = (SQLITE_IOERR | (15 << 8)),
SQLITE_IOERR_CLOSE = (SQLITE_IOERR | (16<<8)), SQLITE_IOERR_CLOSE = (SQLITE_IOERR | (16 << 8)),
SQLITE_IOERR_DIR_CLOSE = (SQLITE_IOERR | (17<<8)), SQLITE_IOERR_DIR_CLOSE = (SQLITE_IOERR | (17 << 8)),
SQLITE_IOERR_SHMOPEN = (SQLITE_IOERR | (18<<8)), SQLITE_IOERR_SHMOPEN = (SQLITE_IOERR | (18 << 8)),
SQLITE_IOERR_SHMSIZE = (SQLITE_IOERR | (19<<8)), SQLITE_IOERR_SHMSIZE = (SQLITE_IOERR | (19 << 8)),
SQLITE_IOERR_SHMLOCK = (SQLITE_IOERR | (20<<8)), SQLITE_IOERR_SHMLOCK = (SQLITE_IOERR | (20 << 8)),
SQLITE_IOERR_SHMMAP = (SQLITE_IOERR | (21<<8)), SQLITE_IOERR_SHMMAP = (SQLITE_IOERR | (21 << 8)),
SQLITE_IOERR_SEEK = (SQLITE_IOERR | (22<<8)), SQLITE_IOERR_SEEK = (SQLITE_IOERR | (22 << 8)),
SQLITE_IOERR_DELETE_NOENT = (SQLITE_IOERR | (23<<8)), SQLITE_IOERR_DELETE_NOENT = (SQLITE_IOERR | (23 << 8)),
SQLITE_IOERR_MMAP = (SQLITE_IOERR | (24<<8)), SQLITE_IOERR_MMAP = (SQLITE_IOERR | (24 << 8)),
SQLITE_LOCKED_SHAREDCACHE = (SQLITE_LOCKED | (1<<8)), SQLITE_LOCKED_SHAREDCACHE = (SQLITE_LOCKED | (1 << 8)),
SQLITE_BUSY_RECOVERY = (SQLITE_BUSY | (1<<8)), SQLITE_BUSY_RECOVERY = (SQLITE_BUSY | (1 << 8)),
SQLITE_CANTOPEN_NOTEMPDIR = (SQLITE_CANTOPEN | (1<<8)), SQLITE_CANTOPEN_NOTEMPDIR = (SQLITE_CANTOPEN | (1 << 8)),
SQLITE_IOERR_GETTEMPPATH = (SQLITE_IOERR | (25<<8)), SQLITE_IOERR_GETTEMPPATH = (SQLITE_IOERR | (25 << 8)),
SQLITE_IOERR_CONVPATH = (SQLITE_IOERR | (26<<8)), SQLITE_IOERR_CONVPATH = (SQLITE_IOERR | (26 << 8)),
SQLITE_BUSY_SNAPSHOT = (SQLITE_BUSY | (2<<8)), SQLITE_BUSY_SNAPSHOT = (SQLITE_BUSY | (2 << 8)),
SQLITE_CANTOPEN_ISDIR = (SQLITE_CANTOPEN | (2<<8)), SQLITE_CANTOPEN_ISDIR = (SQLITE_CANTOPEN | (2 << 8)),
SQLITE_CANTOPEN_FULLPATH = (SQLITE_CANTOPEN | (3<<8)), SQLITE_CANTOPEN_FULLPATH = (SQLITE_CANTOPEN | (3 << 8)),
SQLITE_CANTOPEN_CONVPATH = (SQLITE_CANTOPEN | (4<<8)), SQLITE_CANTOPEN_CONVPATH = (SQLITE_CANTOPEN | (4 << 8)),
SQLITE_CORRUPT_VTAB = (SQLITE_CORRUPT | (1<<8)), SQLITE_CORRUPT_VTAB = (SQLITE_CORRUPT | (1 << 8)),
SQLITE_READONLY_RECOVERY = (SQLITE_READONLY | (1<<8)), SQLITE_READONLY_RECOVERY = (SQLITE_READONLY | (1 << 8)),
SQLITE_READONLY_CANTLOCK = (SQLITE_READONLY | (2<<8)), SQLITE_READONLY_CANTLOCK = (SQLITE_READONLY | (2 << 8)),
SQLITE_READONLY_ROLLBACK = (SQLITE_READONLY | (3<<8)), SQLITE_READONLY_ROLLBACK = (SQLITE_READONLY | (3 << 8)),
SQLITE_READONLY_DBMOVED = (SQLITE_READONLY | (4<<8)), SQLITE_READONLY_DBMOVED = (SQLITE_READONLY | (4 << 8)),
SQLITE_ABORT_ROLLBACK = (SQLITE_ABORT | (2<<8)), SQLITE_ABORT_ROLLBACK = (SQLITE_ABORT | (2 << 8)),
SQLITE_CONSTRAINT_CHECK = (SQLITE_CONSTRAINT | (1<<8)), SQLITE_CONSTRAINT_CHECK = (SQLITE_CONSTRAINT | (1 << 8)),
SQLITE_CONSTRAINT_COMMITHOOK = (SQLITE_CONSTRAINT | (2<<8)), SQLITE_CONSTRAINT_COMMITHOOK = (SQLITE_CONSTRAINT | (2 << 8)),
SQLITE_CONSTRAINT_FOREIGNKEY = (SQLITE_CONSTRAINT | (3<<8)), SQLITE_CONSTRAINT_FOREIGNKEY = (SQLITE_CONSTRAINT | (3 << 8)),
SQLITE_CONSTRAINT_FUNCTION = (SQLITE_CONSTRAINT | (4<<8)), SQLITE_CONSTRAINT_FUNCTION = (SQLITE_CONSTRAINT | (4 << 8)),
SQLITE_CONSTRAINT_NOTNULL = (SQLITE_CONSTRAINT | (5<<8)), SQLITE_CONSTRAINT_NOTNULL = (SQLITE_CONSTRAINT | (5 << 8)),
SQLITE_CONSTRAINT_PRIMARYKEY = (SQLITE_CONSTRAINT | (6<<8)), SQLITE_CONSTRAINT_PRIMARYKEY = (SQLITE_CONSTRAINT | (6 << 8)),
SQLITE_CONSTRAINT_TRIGGER = (SQLITE_CONSTRAINT | (7<<8)), SQLITE_CONSTRAINT_TRIGGER = (SQLITE_CONSTRAINT | (7 << 8)),
SQLITE_CONSTRAINT_UNIQUE = (SQLITE_CONSTRAINT | (8<<8)), SQLITE_CONSTRAINT_UNIQUE = (SQLITE_CONSTRAINT | (8 << 8)),
SQLITE_CONSTRAINT_VTAB = (SQLITE_CONSTRAINT | (9<<8)), SQLITE_CONSTRAINT_VTAB = (SQLITE_CONSTRAINT | (9 << 8)),
SQLITE_CONSTRAINT_ROWID = (SQLITE_CONSTRAINT |(10<<8)), SQLITE_CONSTRAINT_ROWID = (SQLITE_CONSTRAINT |(10 << 8)),
SQLITE_NOTICE_RECOVER_WAL = (SQLITE_NOTICE | (1<<8)), SQLITE_NOTICE_RECOVER_WAL = (SQLITE_NOTICE | (1 << 8)),
SQLITE_NOTICE_RECOVER_ROLLBACK = (SQLITE_NOTICE | (2<<8)), SQLITE_NOTICE_RECOVER_ROLLBACK = (SQLITE_NOTICE | (2 << 8)),
SQLITE_WARNING_AUTOINDEX = (SQLITE_WARNING | (1<<8)), SQLITE_WARNING_AUTOINDEX = (SQLITE_WARNING | (1 << 8)),
SQLITE_AUTH_USER = (SQLITE_AUTH | (1<<8)) SQLITE_AUTH_USER = (SQLITE_AUTH | (1 << 8))
} }
/** /**

2
std/algorithm/sorting.d
View file

@ -2327,7 +2327,7 @@ private template TimSortImpl(alias pred, R)
size_t minRunLength()(size_t n) size_t minRunLength()(size_t n)
{ {
immutable shift = bsr(n)-5; immutable shift = bsr(n)-5;
auto result = (n>>shift) + !!(n & ~((1<<shift)-1)); auto result = (n>>shift) + !!(n & ~((1 << shift)-1));
return result; return result;
} }

8
std/conv.d
View file

@ -1372,18 +1372,18 @@ if (!isImplicitlyConvertible!(S, T) &&
// Narrowing conversions from enum -> integral should be allowed, but they // Narrowing conversions from enum -> integral should be allowed, but they
// should throw at runtime if the enum value doesn't fit in the target // should throw at runtime if the enum value doesn't fit in the target
// type. // type.
enum E1 : ulong { A = 1, B = 1UL<<48, C = 0 } enum E1 : ulong { A = 1, B = 1UL << 48, C = 0 }
assert(to!int(E1.A) == 1); assert(to!int(E1.A) == 1);
assert(to!bool(E1.A) == true); assert(to!bool(E1.A) == true);
assertThrown!ConvOverflowException(to!int(E1.B)); // E1.B overflows int assertThrown!ConvOverflowException(to!int(E1.B)); // E1.B overflows int
assertThrown!ConvOverflowException(to!bool(E1.B)); // E1.B overflows bool assertThrown!ConvOverflowException(to!bool(E1.B)); // E1.B overflows bool
assert(to!bool(E1.C) == false); assert(to!bool(E1.C) == false);
enum E2 : long { A = -1L<<48, B = -1<<31, C = 1<<31 } enum E2 : long { A = -1L << 48, B = -1 << 31, C = 1 << 31 }
assertThrown!ConvOverflowException(to!int(E2.A)); // E2.A overflows int assertThrown!ConvOverflowException(to!int(E2.A)); // E2.A overflows int
assertThrown!ConvOverflowException(to!uint(E2.B)); // E2.B overflows uint assertThrown!ConvOverflowException(to!uint(E2.B)); // E2.B overflows uint
assert(to!int(E2.B) == -1<<31); // but does not overflow int assert(to!int(E2.B) == -1 << 31); // but does not overflow int
assert(to!int(E2.C) == 1<<31); // E2.C does not overflow int assert(to!int(E2.C) == 1 << 31); // E2.C does not overflow int
enum E3 : int { A = -1, B = 1, C = 255, D = 0 } enum E3 : int { A = -1, B = 1, C = 255, D = 0 }
assertThrown!ConvOverflowException(to!ubyte(E3.A)); assertThrown!ConvOverflowException(to!ubyte(E3.A));

2
std/internal/math/biguintnoasm.d
View file

@ -288,7 +288,7 @@ uint multibyteDivAssign(uint [] dest, uint divisor, uint overflow)
ulong c = cast(ulong) overflow; ulong c = cast(ulong) overflow;
for (ptrdiff_t i = dest.length-1; i>= 0; --i) for (ptrdiff_t i = dest.length-1; i>= 0; --i)
{ {
c = (c<<32) + cast(ulong)(dest[i]); c = (c << 32) + cast(ulong)(dest[i]);
uint q = cast(uint)(c/divisor); uint q = cast(uint)(c/divisor);
c -= divisor * q; c -= divisor * q;
dest[i] = q; dest[i] = q;

16
std/math.d
View file

@ -7537,10 +7537,10 @@ if (isFloatingPoint!T)
{ {
foreach (ulong i; 1 .. 62) foreach (ulong i; 1 .. 62)
{ {
assert(nextPow2(1UL<<i) == 2UL<<i); assert(nextPow2(1UL << i) == 2UL << i);
assert(nextPow2((1UL<<i) - 1) == 1UL<<i); assert(nextPow2((1UL << i) - 1) == 1UL << i);
assert(nextPow2((1UL<<i) + 1) == 2UL<<i); assert(nextPow2((1UL << i) + 1) == 2UL << i);
assert(nextPow2((1UL<<i) + (1UL<<(i-1))) == 2UL<<i); assert(nextPow2((1UL << i) + (1UL<<(i-1))) == 2UL << i);
} }
} }
@ -7667,10 +7667,10 @@ if (isFloatingPoint!T)
{ {
foreach (ulong i; 1 .. 62) foreach (ulong i; 1 .. 62)
{ {
assert(truncPow2(2UL<<i) == 2UL<<i); assert(truncPow2(2UL << i) == 2UL << i);
assert(truncPow2((2UL<<i) + 1) == 2UL<<i); assert(truncPow2((2UL << i) + 1) == 2UL << i);
assert(truncPow2((2UL<<i) - 1) == 1UL<<i); assert(truncPow2((2UL << i) - 1) == 1UL << i);
assert(truncPow2((2UL<<i) - (2UL<<(i-1))) == 1UL<<i); assert(truncPow2((2UL << i) - (2UL<<(i-1))) == 1UL << i);
} }
} }

6
std/regex/internal/backtracking.d
View file

@ -26,7 +26,7 @@ template BacktrackingMatcher(bool CTregex)
} }
static assert(State.sizeof % size_t.sizeof == 0); static assert(State.sizeof % size_t.sizeof == 0);
enum stateSize = State.sizeof / size_t.sizeof; enum stateSize = State.sizeof / size_t.sizeof;
enum initialStack = 1<<11; // items in a block of segmented stack enum initialStack = 1 << 11; // items in a block of segmented stack
alias String = const(Char)[]; alias String = const(Char)[];
alias RegEx = Regex!Char; alias RegEx = Regex!Char;
alias MatchFn = bool function (ref BacktrackingMatcher!(Char, Stream)); alias MatchFn = bool function (ref BacktrackingMatcher!(Char, Stream));
@ -55,8 +55,8 @@ template BacktrackingMatcher(bool CTregex)
immutable d = idx - offset; immutable d = idx - offset;
if (d < 64) // including overflow if (d < 64) // including overflow
{ {
immutable p = mask & (1UL<<d); immutable p = mask & (1UL << d);
mask |= 1UL<<d; mask |= 1UL << d;
return p != 0; return p != 0;
} }
else else

10
std/regex/internal/ir.d
View file

@ -238,18 +238,18 @@ struct Bytecode
uint raw; uint raw;
//natural constraints //natural constraints
enum maxSequence = 2+4; enum maxSequence = 2+4;
enum maxData = 1<<22; enum maxData = 1 << 22;
enum maxRaw = 1<<31; enum maxRaw = 1 << 31;
this(IR code, uint data) this(IR code, uint data)
{ {
assert(data < (1<<22) && code < 256); assert(data < (1 << 22) && code < 256);
raw = code<<24 | data; raw = code << 24 | data;
} }
this(IR code, uint data, uint seq) this(IR code, uint data, uint seq)
{ {
assert(data < (1<<22) && code < 256 ); assert(data < (1 << 22) && code < 256 );
assert(seq >= 2 && seq < maxSequence); assert(seq >= 2 && seq < maxSequence);
raw = code << 24 | (seq - 2)<<22 | data; raw = code << 24 | (seq - 2)<<22 | data;
} }

24
std/regex/internal/kickstart.d
View file

@ -425,8 +425,8 @@ public:
assert((cast(size_t) p & (Char.sizeof-1)) == orginalAlign); assert((cast(size_t) p & (Char.sizeof-1)) == orginalAlign);
static if (charSize == 3) static if (charSize == 3)
{ {
state = (state<<1) | table[p[1]]; state = (state << 1) | table[p[1]];
state = (state<<1) | table[p[2]]; state = (state << 1) | table[p[2]];
p += 4; p += 4;
} }
else else
@ -441,14 +441,14 @@ public:
//use the usual shift-or cycle //use the usual shift-or cycle
static if (charSize == 3) static if (charSize == 3)
{ {
state = (state<<1) | table[p[0]]; state = (state << 1) | table[p[0]];
state = (state<<1) | table[p[1]]; state = (state << 1) | table[p[1]];
state = (state<<1) | table[p[2]]; state = (state << 1) | table[p[2]];
p += 4; p += 4;
} }
else else
{ {
state = (state<<1) | table[p[0]]; state = (state << 1) | table[p[0]];
p++; p++;
} }
if (!(state & limit)) if (!(state & limit))
@ -466,9 +466,9 @@ public:
const(ubyte)* end = cast(ubyte*)(haystack.ptr + haystack.length); const(ubyte)* end = cast(ubyte*)(haystack.ptr + haystack.length);
while (p != end) while (p != end)
{ {
state = (state<<1) | table[p[0]]; state = (state << 1) | table[p[0]];
state = (state<<1) | table[p[1]]; state = (state << 1) | table[p[1]];
state = (state<<1) | table[p[2]]; state = (state << 1) | table[p[2]];
p += 4; p += 4;
if (!(state & limit))//division rounds down for dchar if (!(state & limit))//division rounds down for dchar
return (p-cast(ubyte*) haystack.ptr)/Char.sizeof return (p-cast(ubyte*) haystack.ptr)/Char.sizeof
@ -481,17 +481,17 @@ public:
size_t i = 0; size_t i = 0;
if (len & 1) if (len & 1)
{ {
state = (state<<1) | table[p[i++]]; state = (state << 1) | table[p[i++]];
if (!(state & limit)) if (!(state & limit))
return idx+i/Char.sizeof-length; return idx+i/Char.sizeof-length;
} }
while (i < len) while (i < len)
{ {
state = (state<<1) | table[p[i++]]; state = (state << 1) | table[p[i++]];
if (!(state & limit)) if (!(state & limit))
return idx+i/Char.sizeof return idx+i/Char.sizeof
-length; -length;
state = (state<<1) | table[p[i++]]; state = (state << 1) | table[p[i++]];
if (!(state & limit)) if (!(state & limit))
return idx+i/Char.sizeof return idx+i/Char.sizeof
-length; -length;

24
std/regex/internal/shiftor.d
View file

@ -414,8 +414,8 @@ public:
assert((cast(size_t) p & (Char.sizeof-1)) == orginalAlign); assert((cast(size_t) p & (Char.sizeof-1)) == orginalAlign);
static if (charSize == 3) static if (charSize == 3)
{ {
state = (state<<1) | table[p[1]]; state = (state << 1) | table[p[1]];
state = (state<<1) | table[p[2]]; state = (state << 1) | table[p[2]];
p += 4; p += 4;
} }
else else
@ -432,14 +432,14 @@ public:
//use the usual shift-or cycle //use the usual shift-or cycle
static if (charSize == 3) static if (charSize == 3)
{ {
state = (state<<1) | table[p[0]]; state = (state << 1) | table[p[0]];
state = (state<<1) | table[p[1]]; state = (state << 1) | table[p[1]];
state = (state<<1) | table[p[2]]; state = (state << 1) | table[p[2]];
p += 4; p += 4;
} }
else else
{ {
state = (state<<1) | table[p[0]]; state = (state << 1) | table[p[0]];
p++; p++;
} }
if (!(state & limit)) if (!(state & limit))
@ -459,9 +459,9 @@ public:
const(ubyte)* end = cast(ubyte*)(haystack.ptr + haystack.length); const(ubyte)* end = cast(ubyte*)(haystack.ptr + haystack.length);
while (p != end) while (p != end)
{ {
state = (state<<1) | table[p[0]]; state = (state << 1) | table[p[0]];
state = (state<<1) | table[p[1]]; state = (state << 1) | table[p[1]];
state = (state<<1) | table[p[2]]; state = (state << 1) | table[p[2]];
p += 4; p += 4;
if (!(state & limit))//division rounds down for dchar if (!(state & limit))//division rounds down for dchar
{ {
@ -476,7 +476,7 @@ public:
size_t i = 0; size_t i = 0;
if (len & 1) if (len & 1)
{ {
state = (state<<1) | table[p[i++]]; state = (state << 1) | table[p[i++]];
if (!(state & limit)) if (!(state & limit))
{ {
s._index += i/Char.sizeof-length; s._index += i/Char.sizeof-length;
@ -485,13 +485,13 @@ public:
} }
while (i < len) while (i < len)
{ {
state = (state<<1) | table[p[i++]]; state = (state << 1) | table[p[i++]];
if (!(state & limit)) if (!(state & limit))
{ {
s._index += i/Char.sizeof-length; s._index += i/Char.sizeof-length;
return true; return true;
} }
state = (state<<1) | table[p[i++]]; state = (state << 1) | table[p[i++]];
if (!(state & limit)) if (!(state & limit))
{ {
s._index += i/Char.sizeof-length; s._index += i/Char.sizeof-length;

22
std/typecons.d
View file

@ -7087,10 +7087,10 @@ template isBitFlagEnum(E)
enum A enum A
{ {
None, None,
A = 1<<0, A = 1 << 0,
B = 1<<1, B = 1 << 1,
C = 1<<2, C = 1 << 2,
D = 1<<3, D = 1 << 3,
} }
static assert(isBitFlagEnum!A); static assert(isBitFlagEnum!A);
@ -7107,8 +7107,8 @@ template isBitFlagEnum(E)
enum C: double enum C: double
{ {
A = 1<<0, A = 1 << 0,
B = 1<<1 B = 1 << 1
} }
static assert(!isBitFlagEnum!C); static assert(!isBitFlagEnum!C);
@ -7126,8 +7126,8 @@ the OR combination, which can produce surprising effects like this:
---- ----
enum E enum E
{ {
A = 1<<0, A = 1 << 0,
B = 1<<1 B = 1 << 1
} }
E e = E.A | E.B; E e = E.A | E.B;
// will throw SwitchError // will throw SwitchError
@ -7274,9 +7274,9 @@ public:
enum Enum enum Enum
{ {
None, None,
A = 1<<0, A = 1 << 0,
B = 1<<1, B = 1 << 1,
C = 1<<2 C = 1 << 2
} }
BitFlags!Enum flags1; BitFlags!Enum flags1;
assert(!(flags1 & (Enum.A | Enum.B | Enum.C))); assert(!(flags1 & (Enum.A | Enum.B | Enum.C)));

44
std/uni.d
View file

@ -774,12 +774,12 @@ size_t replicateBits(size_t times, size_t bits)(size_t val) @safe pure nothrow @
static if (times == size_t.sizeof*8) static if (times == size_t.sizeof*8)
return val ? size_t.max : 0; return val ? size_t.max : 0;
else else
return val ? (1<<times)-1 : 0; return val ? (1 << times)-1 : 0;
} }
else static if (times % 2) else static if (times % 2)
return (replicateBits!(times-1, bits)(val)<<bits) | val; return (replicateBits!(times-1, bits)(val)<<bits) | val;
else else
return replicateBits!(times/2, bits*2)((val<<bits) | val); return replicateBits!(times/2, bits*2)((val << bits) | val);
} }
@safe pure nothrow @nogc unittest // for replicate @safe pure nothrow @nogc unittest // for replicate
@ -1131,7 +1131,7 @@ pure nothrow:
immutable r = n % factor; immutable r = n % factor;
immutable tgt_shift = bits*r; immutable tgt_shift = bits*r;
immutable word = origin[q]; immutable word = origin[q];
origin[q] = (word & ~(mask<<tgt_shift)) origin[q] = (word & ~(mask << tgt_shift))
| (cast(size_t) val << tgt_shift); | (cast(size_t) val << tgt_shift);
} }
@ -1560,7 +1560,7 @@ if (is(T : ElementType!Range))
{ {
assert(isPow2OrZero(range.length)); assert(isPow2OrZero(range.length));
size_t idx = 0, m = range.length/2; size_t idx = 0, m = range.length/2;
enum max = 1<<10; enum max = 1 << 10;
while (m >= max) while (m >= max)
{ {
if (pred(range[idx+m], needle)) if (pred(range[idx+m], needle))
@ -3073,7 +3073,7 @@ private:
version(LittleEndian) version(LittleEndian)
*dest = val | (*dest & 0xFF00_0000); *dest = val | (*dest & 0xFF00_0000);
else else
*dest = (val<<8) | (*dest & 0xFF); *dest = (val << 8) | (*dest & 0xFF);
} }
@system private uint read24(scope const ubyte* ptr, size_t idx) pure nothrow @nogc @system private uint read24(scope const ubyte* ptr, size_t idx) pure nothrow @nogc
@ -3782,7 +3782,7 @@ private:
void addValue(size_t level, T)(T val, size_t numVals) void addValue(size_t level, T)(T val, size_t numVals)
{ {
alias j = idx!level; alias j = idx!level;
enum pageSize = 1<<Prefix[level].bitSize; enum pageSize = 1 << Prefix[level].bitSize;
if (numVals == 0) if (numVals == 0)
return; return;
auto ptr = table.slice!(level); auto ptr = table.slice!(level);
@ -3860,7 +3860,7 @@ private:
{ {
alias NextIdx = typeof(table.slice!(level-1)[0]); alias NextIdx = typeof(table.slice!(level-1)[0]);
NextIdx next_lvl_index; NextIdx next_lvl_index;
enum pageSize = 1<<Prefix[level].bitSize; enum pageSize = 1 << Prefix[level].bitSize;
assert(idx!level % pageSize == 0); assert(idx!level % pageSize == 0);
immutable last = idx!level-pageSize; immutable last = idx!level-pageSize;
const slice = ptr[idx!level - pageSize .. idx!level]; const slice = ptr[idx!level - pageSize .. idx!level];
@ -3956,7 +3956,7 @@ public:
table = typeof(table)(indices); table = typeof(table)(indices);
// one page per level is a bootstrap minimum // one page per level is a bootstrap minimum
foreach (i, Pred; Prefix) foreach (i, Pred; Prefix)
table.length!i = (1<<Pred.bitSize); table.length!i = (1 << Pred.bitSize);
} }
/** /**
@ -4652,7 +4652,7 @@ template Utf8Matcher()
alias Table(int size) = Tables[size-1]; alias Table(int size) = Tables[size-1];
enum leadMask(size_t size) = (cast(size_t) 1<<(7 - size))-1; enum leadMask(size_t size) = (cast(size_t) 1<<(7 - size))-1;
enum encMask(size_t size) = ((1<<size)-1)<<(8-size); enum encMask(size_t size) = ((1 << size)-1)<<(8-size);
char truncate()(char ch) pure @safe char truncate()(char ch) pure @safe
{ {
@ -5489,13 +5489,13 @@ struct sliceBits(size_t from, size_t to)
static auto opCall(T)(T x) static auto opCall(T)(T x)
out(result) out(result)
{ {
assert(result < (1<<to-from)); assert(result < (1 << to-from));
} }
body body
{ {
static assert(from < to); static assert(from < to);
static if (from == 0) static if (from == 0)
return x & ((1<<to)-1); return x & ((1 << to)-1);
else else
return (x >> from) & ((1<<(to-from))-1); return (x >> from) & ((1<<(to-from))-1);
} }
@ -5699,15 +5699,15 @@ if (is(Char1 : dchar) && is(Char2 : dchar))
// not optimized as usually done 1 time (and not public interface) // not optimized as usually done 1 time (and not public interface)
if (val < 128) if (val < 128)
arr ~= cast(ubyte) val; arr ~= cast(ubyte) val;
else if (val < (1<<13)) else if (val < (1 << 13))
{ {
arr ~= (0b1_00<<5) | cast(ubyte)(val>>8); arr ~= (0b1_00 << 5) | cast(ubyte)(val>>8);
arr ~= val & 0xFF; arr ~= val & 0xFF;
} }
else else
{ {
assert(val < (1<<21)); assert(val < (1 << 21));
arr ~= (0b1_01<<5) | cast(ubyte)(val>>16); arr ~= (0b1_01 << 5) | cast(ubyte)(val>>16);
arr ~= (val >> 8) & 0xFF; arr ~= (val >> 8) & 0xFF;
arr ~= val & 0xFF; arr ~= val & 0xFF;
} }
@ -5723,7 +5723,7 @@ if (is(Char1 : dchar) && is(Char2 : dchar))
uint val = (first & 0x1F); uint val = (first & 0x1F);
enforce(idx + extra <= arr.length, "bad code point interval encoding"); enforce(idx + extra <= arr.length, "bad code point interval encoding");
foreach (j; 0 .. extra) foreach (j; 0 .. extra)
val = (val<<8) | arr[idx+j]; val = (val << 8) | arr[idx+j];
idx += extra; idx += extra;
return val; return val;
} }
@ -5753,20 +5753,20 @@ if (isInputRange!Range && isIntegralPair!(ElementType!Range))
import std.algorithm.comparison : equal; import std.algorithm.comparison : equal;
import std.typecons : tuple; import std.typecons : tuple;
auto run = [tuple(80, 127), tuple(128, (1<<10)+128)]; auto run = [tuple(80, 127), tuple(128, (1 << 10)+128)];
ubyte[] enc = [cast(ubyte) 80, 47, 1, (0b1_00<<5) | (1<<2), 0]; ubyte[] enc = [cast(ubyte) 80, 47, 1, (0b1_00 << 5) | (1 << 2), 0];
assert(compressIntervals(run) == enc); assert(compressIntervals(run) == enc);
auto run2 = [tuple(0, (1<<20)+512+1), tuple((1<<20)+512+4, lastDchar+1)]; auto run2 = [tuple(0, (1 << 20)+512+1), tuple((1 << 20)+512+4, lastDchar+1)];
ubyte[] enc2 = [cast(ubyte) 0, (0b1_01<<5) | (1<<4), 2, 1, 3]; // odd length-ed ubyte[] enc2 = [cast(ubyte) 0, (0b1_01 << 5) | (1 << 4), 2, 1, 3]; // odd length-ed
assert(compressIntervals(run2) == enc2); assert(compressIntervals(run2) == enc2);
size_t idx = 0; size_t idx = 0;
assert(decompressFrom(enc, idx) == 80); assert(decompressFrom(enc, idx) == 80);
assert(decompressFrom(enc, idx) == 47); assert(decompressFrom(enc, idx) == 47);
assert(decompressFrom(enc, idx) == 1); assert(decompressFrom(enc, idx) == 1);
assert(decompressFrom(enc, idx) == (1<<10)); assert(decompressFrom(enc, idx) == (1 << 10));
idx = 0; idx = 0;
assert(decompressFrom(enc2, idx) == 0); assert(decompressFrom(enc2, idx) == 0);
assert(decompressFrom(enc2, idx) == (1<<20)+512+1); assert(decompressFrom(enc2, idx) == (1 << 20)+512+1);
assert(equal(decompressIntervals(compressIntervals(run)), run)); assert(equal(decompressIntervals(compressIntervals(run)), run));
assert(equal(decompressIntervals(compressIntervals(run2)), run2)); assert(equal(decompressIntervals(compressIntervals(run2)), run2));
} }