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

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
{
SQLITE_IOERR_READ = (SQLITE_IOERR | (1<<8)),
SQLITE_IOERR_SHORT_READ = (SQLITE_IOERR | (2<<8)),
SQLITE_IOERR_WRITE = (SQLITE_IOERR | (3<<8)),
SQLITE_IOERR_FSYNC = (SQLITE_IOERR | (4<<8)),
SQLITE_IOERR_DIR_FSYNC = (SQLITE_IOERR | (5<<8)),
SQLITE_IOERR_TRUNCATE = (SQLITE_IOERR | (6<<8)),
SQLITE_IOERR_FSTAT = (SQLITE_IOERR | (7<<8)),
SQLITE_IOERR_UNLOCK = (SQLITE_IOERR | (8<<8)),
SQLITE_IOERR_RDLOCK = (SQLITE_IOERR | (9<<8)),
SQLITE_IOERR_DELETE = (SQLITE_IOERR | (10<<8)),
SQLITE_IOERR_BLOCKED = (SQLITE_IOERR | (11<<8)),
SQLITE_IOERR_NOMEM = (SQLITE_IOERR | (12<<8)),
SQLITE_IOERR_ACCESS = (SQLITE_IOERR | (13<<8)),
SQLITE_IOERR_CHECKRESERVEDLOCK = (SQLITE_IOERR | (14<<8)),
SQLITE_IOERR_LOCK = (SQLITE_IOERR | (15<<8)),
SQLITE_IOERR_CLOSE = (SQLITE_IOERR | (16<<8)),
SQLITE_IOERR_DIR_CLOSE = (SQLITE_IOERR | (17<<8)),
SQLITE_IOERR_SHMOPEN = (SQLITE_IOERR | (18<<8)),
SQLITE_IOERR_SHMSIZE = (SQLITE_IOERR | (19<<8)),
SQLITE_IOERR_SHMLOCK = (SQLITE_IOERR | (20<<8)),
SQLITE_IOERR_SHMMAP = (SQLITE_IOERR | (21<<8)),
SQLITE_IOERR_SEEK = (SQLITE_IOERR | (22<<8)),
SQLITE_IOERR_DELETE_NOENT = (SQLITE_IOERR | (23<<8)),
SQLITE_IOERR_MMAP = (SQLITE_IOERR | (24<<8)),
SQLITE_LOCKED_SHAREDCACHE = (SQLITE_LOCKED | (1<<8)),
SQLITE_BUSY_RECOVERY = (SQLITE_BUSY | (1<<8)),
SQLITE_CANTOPEN_NOTEMPDIR = (SQLITE_CANTOPEN | (1<<8)),
SQLITE_IOERR_GETTEMPPATH = (SQLITE_IOERR | (25<<8)),
SQLITE_IOERR_CONVPATH = (SQLITE_IOERR | (26<<8)),
SQLITE_BUSY_SNAPSHOT = (SQLITE_BUSY | (2<<8)),
SQLITE_CANTOPEN_ISDIR = (SQLITE_CANTOPEN | (2<<8)),
SQLITE_CANTOPEN_FULLPATH = (SQLITE_CANTOPEN | (3<<8)),
SQLITE_CANTOPEN_CONVPATH = (SQLITE_CANTOPEN | (4<<8)),
SQLITE_CORRUPT_VTAB = (SQLITE_CORRUPT | (1<<8)),
SQLITE_READONLY_RECOVERY = (SQLITE_READONLY | (1<<8)),
SQLITE_READONLY_CANTLOCK = (SQLITE_READONLY | (2<<8)),
SQLITE_READONLY_ROLLBACK = (SQLITE_READONLY | (3<<8)),
SQLITE_READONLY_DBMOVED = (SQLITE_READONLY | (4<<8)),
SQLITE_ABORT_ROLLBACK = (SQLITE_ABORT | (2<<8)),
SQLITE_CONSTRAINT_CHECK = (SQLITE_CONSTRAINT | (1<<8)),
SQLITE_CONSTRAINT_COMMITHOOK = (SQLITE_CONSTRAINT | (2<<8)),
SQLITE_CONSTRAINT_FOREIGNKEY = (SQLITE_CONSTRAINT | (3<<8)),
SQLITE_CONSTRAINT_FUNCTION = (SQLITE_CONSTRAINT | (4<<8)),
SQLITE_CONSTRAINT_NOTNULL = (SQLITE_CONSTRAINT | (5<<8)),
SQLITE_CONSTRAINT_PRIMARYKEY = (SQLITE_CONSTRAINT | (6<<8)),
SQLITE_CONSTRAINT_TRIGGER = (SQLITE_CONSTRAINT | (7<<8)),
SQLITE_CONSTRAINT_UNIQUE = (SQLITE_CONSTRAINT | (8<<8)),
SQLITE_CONSTRAINT_VTAB = (SQLITE_CONSTRAINT | (9<<8)),
SQLITE_CONSTRAINT_ROWID = (SQLITE_CONSTRAINT |(10<<8)),
SQLITE_NOTICE_RECOVER_WAL = (SQLITE_NOTICE | (1<<8)),
SQLITE_NOTICE_RECOVER_ROLLBACK = (SQLITE_NOTICE | (2<<8)),
SQLITE_WARNING_AUTOINDEX = (SQLITE_WARNING | (1<<8)),
SQLITE_AUTH_USER = (SQLITE_AUTH | (1<<8))
SQLITE_IOERR_READ = (SQLITE_IOERR | (1 << 8)),
SQLITE_IOERR_SHORT_READ = (SQLITE_IOERR | (2 << 8)),
SQLITE_IOERR_WRITE = (SQLITE_IOERR | (3 << 8)),
SQLITE_IOERR_FSYNC = (SQLITE_IOERR | (4 << 8)),
SQLITE_IOERR_DIR_FSYNC = (SQLITE_IOERR | (5 << 8)),
SQLITE_IOERR_TRUNCATE = (SQLITE_IOERR | (6 << 8)),
SQLITE_IOERR_FSTAT = (SQLITE_IOERR | (7 << 8)),
SQLITE_IOERR_UNLOCK = (SQLITE_IOERR | (8 << 8)),
SQLITE_IOERR_RDLOCK = (SQLITE_IOERR | (9 << 8)),
SQLITE_IOERR_DELETE = (SQLITE_IOERR | (10 << 8)),
SQLITE_IOERR_BLOCKED = (SQLITE_IOERR | (11 << 8)),
SQLITE_IOERR_NOMEM = (SQLITE_IOERR | (12 << 8)),
SQLITE_IOERR_ACCESS = (SQLITE_IOERR | (13 << 8)),
SQLITE_IOERR_CHECKRESERVEDLOCK = (SQLITE_IOERR | (14 << 8)),
SQLITE_IOERR_LOCK = (SQLITE_IOERR | (15 << 8)),
SQLITE_IOERR_CLOSE = (SQLITE_IOERR | (16 << 8)),
SQLITE_IOERR_DIR_CLOSE = (SQLITE_IOERR | (17 << 8)),
SQLITE_IOERR_SHMOPEN = (SQLITE_IOERR | (18 << 8)),
SQLITE_IOERR_SHMSIZE = (SQLITE_IOERR | (19 << 8)),
SQLITE_IOERR_SHMLOCK = (SQLITE_IOERR | (20 << 8)),
SQLITE_IOERR_SHMMAP = (SQLITE_IOERR | (21 << 8)),
SQLITE_IOERR_SEEK = (SQLITE_IOERR | (22 << 8)),
SQLITE_IOERR_DELETE_NOENT = (SQLITE_IOERR | (23 << 8)),
SQLITE_IOERR_MMAP = (SQLITE_IOERR | (24 << 8)),
SQLITE_LOCKED_SHAREDCACHE = (SQLITE_LOCKED | (1 << 8)),
SQLITE_BUSY_RECOVERY = (SQLITE_BUSY | (1 << 8)),
SQLITE_CANTOPEN_NOTEMPDIR = (SQLITE_CANTOPEN | (1 << 8)),
SQLITE_IOERR_GETTEMPPATH = (SQLITE_IOERR | (25 << 8)),
SQLITE_IOERR_CONVPATH = (SQLITE_IOERR | (26 << 8)),
SQLITE_BUSY_SNAPSHOT = (SQLITE_BUSY | (2 << 8)),
SQLITE_CANTOPEN_ISDIR = (SQLITE_CANTOPEN | (2 << 8)),
SQLITE_CANTOPEN_FULLPATH = (SQLITE_CANTOPEN | (3 << 8)),
SQLITE_CANTOPEN_CONVPATH = (SQLITE_CANTOPEN | (4 << 8)),
SQLITE_CORRUPT_VTAB = (SQLITE_CORRUPT | (1 << 8)),
SQLITE_READONLY_RECOVERY = (SQLITE_READONLY | (1 << 8)),
SQLITE_READONLY_CANTLOCK = (SQLITE_READONLY | (2 << 8)),
SQLITE_READONLY_ROLLBACK = (SQLITE_READONLY | (3 << 8)),
SQLITE_READONLY_DBMOVED = (SQLITE_READONLY | (4 << 8)),
SQLITE_ABORT_ROLLBACK = (SQLITE_ABORT | (2 << 8)),
SQLITE_CONSTRAINT_CHECK = (SQLITE_CONSTRAINT | (1 << 8)),
SQLITE_CONSTRAINT_COMMITHOOK = (SQLITE_CONSTRAINT | (2 << 8)),
SQLITE_CONSTRAINT_FOREIGNKEY = (SQLITE_CONSTRAINT | (3 << 8)),
SQLITE_CONSTRAINT_FUNCTION = (SQLITE_CONSTRAINT | (4 << 8)),
SQLITE_CONSTRAINT_NOTNULL = (SQLITE_CONSTRAINT | (5 << 8)),
SQLITE_CONSTRAINT_PRIMARYKEY = (SQLITE_CONSTRAINT | (6 << 8)),
SQLITE_CONSTRAINT_TRIGGER = (SQLITE_CONSTRAINT | (7 << 8)),
SQLITE_CONSTRAINT_UNIQUE = (SQLITE_CONSTRAINT | (8 << 8)),
SQLITE_CONSTRAINT_VTAB = (SQLITE_CONSTRAINT | (9 << 8)),
SQLITE_CONSTRAINT_ROWID = (SQLITE_CONSTRAINT |(10 << 8)),
SQLITE_NOTICE_RECOVER_WAL = (SQLITE_NOTICE | (1 << 8)),
SQLITE_NOTICE_RECOVER_ROLLBACK = (SQLITE_NOTICE | (2 << 8)),
SQLITE_WARNING_AUTOINDEX = (SQLITE_WARNING | (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)
{
immutable shift = bsr(n)-5;
auto result = (n>>shift) + !!(n & ~((1<<shift)-1));
auto result = (n>>shift) + !!(n & ~((1 << shift)-1));
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
// should throw at runtime if the enum value doesn't fit in the target
// 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!bool(E1.A) == true);
assertThrown!ConvOverflowException(to!int(E1.B)); // E1.B overflows int
assertThrown!ConvOverflowException(to!bool(E1.B)); // E1.B overflows bool
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!uint(E2.B)); // E2.B overflows uint
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.B) == -1 << 31); // but 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 }
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;
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);
c -= divisor * q;
dest[i] = q;

16
std/math.d
View file

@ -7537,10 +7537,10 @@ if (isFloatingPoint!T)
{
foreach (ulong i; 1 .. 62)
{
assert(nextPow2(1UL<<i) == 2UL<<i);
assert(nextPow2((1UL<<i) - 1) == 1UL<<i);
assert(nextPow2((1UL<<i) + 1) == 2UL<<i);
assert(nextPow2((1UL<<i) + (1UL<<(i-1))) == 2UL<<i);
assert(nextPow2(1UL << i) == 2UL << i);
assert(nextPow2((1UL << i) - 1) == 1UL << i);
assert(nextPow2((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)
{
assert(truncPow2(2UL<<i) == 2UL<<i);
assert(truncPow2((2UL<<i) + 1) == 2UL<<i);
assert(truncPow2((2UL<<i) - 1) == 1UL<<i);
assert(truncPow2((2UL<<i) - (2UL<<(i-1))) == 1UL<<i);
assert(truncPow2(2UL << i) == 2UL << i);
assert(truncPow2((2UL << i) + 1) == 2UL << i);
assert(truncPow2((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);
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 RegEx = Regex!Char;
alias MatchFn = bool function (ref BacktrackingMatcher!(Char, Stream));
@ -55,8 +55,8 @@ template BacktrackingMatcher(bool CTregex)
immutable d = idx - offset;
if (d < 64) // including overflow
{
immutable p = mask & (1UL<<d);
mask |= 1UL<<d;
immutable p = mask & (1UL << d);
mask |= 1UL << d;
return p != 0;
}
else

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

@ -238,18 +238,18 @@ struct Bytecode
uint raw;
//natural constraints
enum maxSequence = 2+4;
enum maxData = 1<<22;
enum maxRaw = 1<<31;
enum maxData = 1 << 22;
enum maxRaw = 1 << 31;
this(IR code, uint data)
{
assert(data < (1<<22) && code < 256);
raw = code<<24 | data;
assert(data < (1 << 22) && code < 256);
raw = code << 24 | data;
}
this(IR code, uint data, uint seq)
{
assert(data < (1<<22) && code < 256 );
assert(data < (1 << 22) && code < 256 );
assert(seq >= 2 && seq < maxSequence);
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);
static if (charSize == 3)
{
state = (state<<1) | table[p[1]];
state = (state<<1) | table[p[2]];
state = (state << 1) | table[p[1]];
state = (state << 1) | table[p[2]];
p += 4;
}
else
@ -441,14 +441,14 @@ public:
//use the usual shift-or cycle
static if (charSize == 3)
{
state = (state<<1) | table[p[0]];
state = (state<<1) | table[p[1]];
state = (state<<1) | table[p[2]];
state = (state << 1) | table[p[0]];
state = (state << 1) | table[p[1]];
state = (state << 1) | table[p[2]];
p += 4;
}
else
{
state = (state<<1) | table[p[0]];
state = (state << 1) | table[p[0]];
p++;
}
if (!(state & limit))
@ -466,9 +466,9 @@ public:
const(ubyte)* end = cast(ubyte*)(haystack.ptr + haystack.length);
while (p != end)
{
state = (state<<1) | table[p[0]];
state = (state<<1) | table[p[1]];
state = (state<<1) | table[p[2]];
state = (state << 1) | table[p[0]];
state = (state << 1) | table[p[1]];
state = (state << 1) | table[p[2]];
p += 4;
if (!(state & limit))//division rounds down for dchar
return (p-cast(ubyte*) haystack.ptr)/Char.sizeof
@ -481,17 +481,17 @@ public:
size_t i = 0;
if (len & 1)
{
state = (state<<1) | table[p[i++]];
state = (state << 1) | table[p[i++]];
if (!(state & limit))
return idx+i/Char.sizeof-length;
}
while (i < len)
{
state = (state<<1) | table[p[i++]];
state = (state << 1) | table[p[i++]];
if (!(state & limit))
return idx+i/Char.sizeof
-length;
state = (state<<1) | table[p[i++]];
state = (state << 1) | table[p[i++]];
if (!(state & limit))
return idx+i/Char.sizeof
-length;

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

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

22
std/typecons.d
View file

@ -7087,10 +7087,10 @@ template isBitFlagEnum(E)
enum A
{
None,
A = 1<<0,
B = 1<<1,
C = 1<<2,
D = 1<<3,
A = 1 << 0,
B = 1 << 1,
C = 1 << 2,
D = 1 << 3,
}
static assert(isBitFlagEnum!A);
@ -7107,8 +7107,8 @@ template isBitFlagEnum(E)
enum C: double
{
A = 1<<0,
B = 1<<1
A = 1 << 0,
B = 1 << 1
}
static assert(!isBitFlagEnum!C);
@ -7126,8 +7126,8 @@ the OR combination, which can produce surprising effects like this:
----
enum E
{
A = 1<<0,
B = 1<<1
A = 1 << 0,
B = 1 << 1
}
E e = E.A | E.B;
// will throw SwitchError
@ -7274,9 +7274,9 @@ public:
enum Enum
{
None,
A = 1<<0,
B = 1<<1,
C = 1<<2
A = 1 << 0,
B = 1 << 1,
C = 1 << 2
}
BitFlags!Enum flags1;
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)
return val ? size_t.max : 0;
else
return val ? (1<<times)-1 : 0;
return val ? (1 << times)-1 : 0;
}
else static if (times % 2)
return (replicateBits!(times-1, bits)(val)<<bits) | val;
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
@ -1131,7 +1131,7 @@ pure nothrow:
immutable r = n % factor;
immutable tgt_shift = bits*r;
immutable word = origin[q];
origin[q] = (word & ~(mask<<tgt_shift))
origin[q] = (word & ~(mask << tgt_shift))
| (cast(size_t) val << tgt_shift);
}
@ -1560,7 +1560,7 @@ if (is(T : ElementType!Range))
{
assert(isPow2OrZero(range.length));
size_t idx = 0, m = range.length/2;
enum max = 1<<10;
enum max = 1 << 10;
while (m >= max)
{
if (pred(range[idx+m], needle))
@ -3073,7 +3073,7 @@ private:
version(LittleEndian)
*dest = val | (*dest & 0xFF00_0000);
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
@ -3782,7 +3782,7 @@ private:
void addValue(size_t level, T)(T val, size_t numVals)
{
alias j = idx!level;
enum pageSize = 1<<Prefix[level].bitSize;
enum pageSize = 1 << Prefix[level].bitSize;
if (numVals == 0)
return;
auto ptr = table.slice!(level);
@ -3860,7 +3860,7 @@ private:
{
alias NextIdx = typeof(table.slice!(level-1)[0]);
NextIdx next_lvl_index;
enum pageSize = 1<<Prefix[level].bitSize;
enum pageSize = 1 << Prefix[level].bitSize;
assert(idx!level % pageSize == 0);
immutable last = idx!level-pageSize;
const slice = ptr[idx!level - pageSize .. idx!level];
@ -3956,7 +3956,7 @@ public:
table = typeof(table)(indices);
// one page per level is a bootstrap minimum
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];
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
{
@ -5489,13 +5489,13 @@ struct sliceBits(size_t from, size_t to)
static auto opCall(T)(T x)
out(result)
{
assert(result < (1<<to-from));
assert(result < (1 << to-from));
}
body
{
static assert(from < to);
static if (from == 0)
return x & ((1<<to)-1);
return x & ((1 << to)-1);
else
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)
if (val < 128)
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;
}
else
{
assert(val < (1<<21));
arr ~= (0b1_01<<5) | cast(ubyte)(val>>16);
assert(val < (1 << 21));
arr ~= (0b1_01 << 5) | cast(ubyte)(val>>16);
arr ~= (val >> 8) & 0xFF;
arr ~= val & 0xFF;
}
@ -5723,7 +5723,7 @@ if (is(Char1 : dchar) && is(Char2 : dchar))
uint val = (first & 0x1F);
enforce(idx + extra <= arr.length, "bad code point interval encoding");
foreach (j; 0 .. extra)
val = (val<<8) | arr[idx+j];
val = (val << 8) | arr[idx+j];
idx += extra;
return val;
}
@ -5753,20 +5753,20 @@ if (isInputRange!Range && isIntegralPair!(ElementType!Range))
import std.algorithm.comparison : equal;
import std.typecons : tuple;
auto run = [tuple(80, 127), tuple(128, (1<<10)+128)];
ubyte[] enc = [cast(ubyte) 80, 47, 1, (0b1_00<<5) | (1<<2), 0];
auto run = [tuple(80, 127), tuple(128, (1 << 10)+128)];
ubyte[] enc = [cast(ubyte) 80, 47, 1, (0b1_00 << 5) | (1 << 2), 0];
assert(compressIntervals(run) == enc);
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
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
assert(compressIntervals(run2) == enc2);
size_t idx = 0;
assert(decompressFrom(enc, idx) == 80);
assert(decompressFrom(enc, idx) == 47);
assert(decompressFrom(enc, idx) == 1);
assert(decompressFrom(enc, idx) == (1<<10));
assert(decompressFrom(enc, idx) == (1 << 10));
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(run2)), run2));
}