| /src/crypto/external/bsd/openssl.old/dist/test/ossl_shim/ |
| async_bio.h | 36 void AsyncBioEnforceWriteQuota(BIO *bio, bool enforce);
|
| async_bio.cc | 177 void AsyncBioEnforceWriteQuota(BIO *bio, bool enforce) {
182 a->enforce_write_quota = enforce;
|
| /src/external/gpl3/gcc.old/dist/libphobos/src/std/regex/internal/ |
| parser.d | 212 enforce(ir.length < maxCompiledLength,
219 enforce(ir.length < maxCompiledLength,
284 enforce(groupStack.top <= maxGroupNumber, "limit on number of submatches is exceeded");
295 enforce(groupStack.top <= maxGroupNumber, "limit on submatches is exceeded");
313 enforce(lookaroundNest <= maxLookaroundDepth,
404 enforce(ir.length + len < maxCompiledLength, "maximum compiled pattern length is exceeded");
458 enforce(ir[fix].code == IR.Option, "no matching ')'");
461 enforce(ir[fix].code == IR.OrStart, "no matching ')'");
651 enforce(!empty, "Unexpected end of pattern");
673 enforce(front == '<', "Expected '<' in named group")
[all...] |
| /src/external/gpl3/gcc.old/dist/libphobos/src/std/container/ |
| array.d | 394 import std.exception : enforce;
994 enforce(!empty);
1048 enforce(r._outer._data is _data && r._a <= length);
1066 enforce(r._outer._data is _data && r._a <= length);
1092 enforce(_data);
1094 enforce(offset <= length);
1111 enforce(r._outer._data is _data);
1114 enforce(offset <= length);
1125 enforce(r._outer._data is _data);
1147 enforce(r._outer._data is _data)
[all...] |
| slist.d | 59 import std.exception : enforce;
122 enforce(n);
523 enforce(!r._head);
526 enforce(r._head);
555 enforce(!r.empty);
580 enforce(!r._head);
614 enforce(_first);
|
| binaryheap.d | 71 import std.exception : enforce;
250 enforce(!empty, "Cannot call front on an empty heap.");
294 enforce(length < _store.length,
318 enforce(!empty, "Cannot call removeFront on an empty heap.");
|
| /src/external/gpl3/gcc.old/dist/libphobos/src/std/ |
| zip.d | 115 import std.exception : enforce;
355 enforce!ZipException(_compressedSize == 0, "Can't change compression method for a compressed element");
619 enforce!ZipException(comment.length <= 0xFFFF, "archive comment longer than 65535");
627 enforce!ZipException(to!ulong(archiveSize) + localFileHeaderLength + de.name.length
789 enforce!ZipException(data.length <= uint.max - 2, "zip files bigger than 4 GB are unsupported");
819 enforce!ZipException(eocdOffset + zip64EndOfCentralDirLength <= _data.length,
823 enforce!ZipException(_data[i .. i + 4] == zip64EndOfCentralDirSignature,
827 enforce!ZipException(eocd64Size + i - 12 <= data.length,
838 enforce!ZipException(numEntriesUlong <= uint.max,
841 enforce!ZipException(numEntriesUlong == totalEntriesUlong
[all...] |
| utf.d | 422 enforce(stride(s, i) == codeLength!char(c),
425 enforce(stride(RandomCU!char(s), i) == codeLength!char(c),
430 enforce(stride(refRandom, i) == codeLength!char(c),
432 enforce(refRandom.length == randLen,
437 enforce(stride(s) == codeLength!char(c),
440 enforce(stride(InputCU!char(s)) == codeLength!char(c),
445 enforce(stride(refBidir) == codeLength!char(c),
447 enforce(refBidir.length == bidirLen,
532 enforce(stride(s, i) == codeLength!wchar(c),
535 enforce(stride(RandomCU!wchar(s), i) == codeLength!wchar(c)
[all...] |
| stdio.d | 415 import std.exception : enforce;
419 enforce(file.isOpen, "ByRecord: File must be open");
429 enforce(line.empty, text("Leftover characters in record: `",
503 import std.exception : enforce;
506 _p = cast(Impl*) enforce(malloc(Impl.sizeof), "Out of memory");
645 import std.exception : enforce;
676 _p = cast(Impl*) enforce(malloc(Impl.sizeof), "Out of memory");
745 import std.exception : enforce, errnoEnforce;
748 enforce(isOpen, "Attempting to reopen() an unopened file");
938 import std.exception : enforce;
[all...] |
| exception.d | 18 $(TR $(TD Enforce) $(TD
20 $(LREF enforce)
56 // use enforce like assert
58 enforce(a > 2, "a needs to be higher than 2.");
60 // enforce can throw a custom exception
61 enforce!ConvException(a > 2, "a needs to be higher than 2.");
63 // enforce will return it's input
65 auto memory = enforce(malloc(size), "malloc failed")[0 .. size];
164 assertNotThrown!StringException(enforce!StringException(true, "Error!"));
167 assertNotThrown(enforce!StringException(true, "Error!"))
[all...] |
| base64.d | 60 import std.exception : enforce;
642 enforce(!empty, new Base64Exception("Cannot call popFront on Encoder with no data remaining"));
760 enforce(!empty, new Base64Exception("Cannot call popFront on Encoder with no data remaining"));
1001 enforce(srcLen % 4 == 0, new Base64Exception("Invalid length of encoded data"));
1081 enforce(srcLen % 4 == 0, new Base64Exception("Invalid length of encoded data"));
1172 enforce(srcLen % 4 == 0, new Base64Exception("Invalid length of encoded data"));
1261 enforce(srcLen % 4 == 0, new Base64Exception("Invalid length of encoded data"));
1417 enforce(!empty, new Base64Exception("Cannot call popFront on Decoder with no data remaining."));
1471 enforce(!range_.empty, new Base64Exception("Invalid length of encoded data"));
1511 enforce(range_.length % 4 == 0, new Base64Exception("Invalid length of encoded data"))
[all...] |
| json.d | 120 import std.exception : enforce;
157 enforce!JSONException(type == JSONType.string,
187 enforce!JSONException(type == JSONType.integer,
205 enforce!JSONException(type == JSONType.uinteger,
224 enforce!JSONException(type == JSONType.float_,
280 enforce!JSONException(type == JSONType.object,
308 enforce!JSONException(type == JSONType.object,
326 enforce!JSONException(type == JSONType.array,
355 enforce!JSONException(type == JSONType.array,
622 enforce!JSONException(i < a.length
[all...] |
| process.d | 215 import std.exception : enforce;
216 return get(name, null).enforce("Environment variable not found: "~name);
282 import std.exception : enforce, errnoEnforce;
294 enforce(errno != EINVAL,
411 import std.exception : enforce;
414 enforce(envBlock, "Failed to retrieve environment variables.");
2259 import std.exception : enforce;
2260 enforce!ProcessException(owned, "Can't wait on a detached process");
2309 import std.exception : enforce;
2310 enforce!ProcessException(owned, "Can't wait on a detached process")
[all...] |
| conv.d | 557 import std.exception : enforce;
558 enforce(value <= cast(S) T.max,
563 import std.exception : enforce;
564 enforce(0 <= value,
1031 import std.exception : enforce;
1035 enforce(raw.length % Char.sizeof == 0,
1654 import std.exception : enforce;
1656 enforce!ConvException(T.length == res.length,
2838 import std.exception : enforce;
2845 enforce!ConvException(!source.empty, "s must not be empty in integral parse")
[all...] |
| concurrency.d | 444 import std.exception : enforce;
446 enforce!TidMissingException(thisInfo.owner.mbox !is null, "Error: Thread has no owner thread.");
2431 import std.exception : enforce;
2440 enforce(m_prev.next, "invalid list node");
2446 enforce(m_prev.next, "invalid list node");
2452 enforce(m_prev.next, "invalid list node");
2492 import std.exception : enforce;
2496 enforce(n && n.next, "attempting to remove invalid list node");
|
| parallelism.d | 527 import std.exception : enforce;
528 enforce(this.pool !is null, "Job not submitted yet.");
1302 // Not using enforce() to save on function call overhead since this
1635 import std.exception : enforce;
1636 enforce(workUnitSize > 0, "workUnitSize must be > 0.");
1763 import std.exception : enforce;
1768 enforce(buf.length == len,
1943 import std.exception : enforce;
1945 enforce(workUnitSize == size_t.max || workUnitSize <= bufSize,
2568 import std.exception : enforce;
[all...] |
| /src/external/gpl3/gcc.old/dist/libphobos/src/std/internal/ |
| cstring.d | 25 import std.exception : enforce;
28 { enforce(setenv(name.tempCString(), value.tempCString(), 1) != -1); }
34 import std.exception : enforce;
37 { enforce(SetEnvironmentVariableW(name.tempCStringW(), value.tempCStringW())); }
|
| memory.d | 18 Mnemonic for `enforce!OutOfMemoryError(malloc(size))` that (unlike malloc)
|
| /src/external/gpl3/gcc.old/dist/libphobos/src/std/windows/ |
| registry.d | 92 enforce(false, new Win32Exception(message)));
103 enforce(false, new Win32Exception(message, code)));
148 enforce(false, new RegistryException(message, code)));
159 enforce(false, new RegistryException(message)));
547 enforce(type == reqType,
610 enforce(type == REG_VALUE_TYPE.REG_MULTI_SZ,
612 enforce(type == reqType,
643 enforce(type == reqType,
679 enforce(type == reqType,
712 enforce(type == reqType
[all...] |
| /src/external/gpl3/gcc.old/dist/libphobos/src/std/net/ |
| curl.d | 805 import std.exception : enforce;
810 enforce!CurlException(t[0].length > minDomainNameLength,
814 enforce!CurlException(!t[1].empty,
1028 import std.exception : enforce;
1097 enforce(statusLine.code / 100 == 2, new HTTPStatusException(statusLine.code,
1228 import std.exception : enforce;
1237 enforce!CurlException(scheme !is null,
1241 enforce!CurlException(strInfo[0] != size_t.max,
1334 import std.exception : enforce;
1335 enforce!CurlException(currentValid, "Cannot call front() on empty range")
[all...] |
| /src/sys/external/mit/xen-include-public/dist/xen/include/public/xsm/ |
| flask_op.h | 192 struct xen_flask_setenforce enforce; member in union:xen_flask_op::__anon6702
|
| /src/external/gpl3/gcc.old/dist/libphobos/src/std/datetime/ |
| timezone.d | 394 import std.exception : enforce;
400 enforce(st.hour == hour,
414 enforce(st.dstInEffect == dstInEffect, msg("1"));
415 enforce(st.utcOffset == offset, msg("2"));
416 enforce((st + dur!"minutes"(1)).utcOffset == offset, msg("3"));
470 import std.exception : enforce;
471 enforce((utc + offset).hour == local.hour, msg("1"));
472 enforce((utc + offset + dur!"minutes"(1)).hour == local.hour, msg("2"));
971 import std.exception : enforce;
989 enforce(st.hour == hour
[all...] |
| /src/external/gpl3/gcc.old/dist/libphobos/src/std/experimental/allocator/building_blocks/ |
| free_list.d | 37 import std.exception : enforce;
865 import std.exception : enforce;
897 enforce(x <= max);
898 enforce(cas(&_min, chooseAtRuntime, x),
907 enforce(low <= high && high >= (void*).sizeof);
908 enforce(cas(&_min, chooseAtRuntime, low),
910 enforce(cas(&_max, chooseAtRuntime, high),
933 enforce(x >= min && x >= (void*).sizeof);
934 enforce(cas(&_max, chooseAtRuntime, x),
961 @property void approxMaxLength(size_t x) shared { _approxMaxLength = enforce(x);
[all...] |
| scoped_allocator.d | 240 auto foo = alloc.make!int(1).enforce;
241 auto bar = alloc.make!int(2).enforce;
|
| /src/external/cddl/osnet/dist/uts/common/fs/zfs/ |
| dsl_dir.c | 701 enforce_res_t enforce = ENFORCE_ALWAYS; local
735 enforce = ENFORCE_ALWAYS;
738 enforce = ENFORCE_ABOVE;
742 return (enforce);
760 enforce_res_t enforce; local
768 * If we're allowed to change the limit, don't enforce the limit
775 enforce = dsl_enforce_ds_ss_limits(dd, prop, cr);
776 if (enforce == ENFORCE_NEVER)
788 * We don't enforce the limit for temporary snapshots. This is
822 if (enforce == ENFORCE_ALWAYS && (count + delta) > limit
[all...] |
