codesearch.isocpp.org by Andrew Tomazos.

Enter a valid C/C++ code snippet...

Searching for `static_cast<size_t>`...

2489599 source files searched.

27515 matches found.

Here is a random sample of matches...


actcd19/main/q/qtwebkit/qtwebkit_2.3.4.dfsg-10/.pc/m68k_support.diff/Source/WTF/wtf/dtoa/utils.h:136:

        inline int StrLength(const char* string) {
size_t length = strlen(string);
ASSERT(length == static_cast<size_t>(static_cast<int>(length)));
return static_cast<int>(length);
}


actcd19/main/w/webrtc-audio-processing/webrtc-audio-processing_0.3-1/webrtc/common_audio/resampler/push_resampler.cc:51:

    
const size_t src_size_10ms_mono =
static_cast<size_t>(src_sample_rate_hz / 100);
const size_t dst_size_10ms_mono =
static_cast<size_t>(dst_sample_rate_hz / 100);


actcd19/main/w/webkit2gtk/webkit2gtk_2.18.3-1/Tools/TestWebKitAPI/Tests/WTF/StringView.cpp:483:

        EXPECT_EQ(static_cast<size_t>(6), referenceB.findIgnoringASCIICase(stringViewFromLiteral("g")));
EXPECT_EQ(static_cast<size_t>(4), referenceB.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "efg")));
EXPECT_EQ(static_cast<size_t>(3), referenceB.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "Éefg")));
EXPECT_EQ(static_cast<size_t>(6), referenceB.findIgnoringASCIICase(stringViewFromLiteral("G")));
EXPECT_EQ(static_cast<size_t>(4), referenceB.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "EFG")));


actcd19/main/p/paraview/paraview_5.4.1+dfsg4-3.1/VTK/Filters/Hybrid/vtkFacetReader.cxx:281:

        vtkIdType num_cells = numcells;
vtkIdType num_points_per_cell = numpointpercell;
if ( pointList.size() < static_cast<size_t>(num_points_per_cell) )
{
pointList.resize(num_points_per_cell);


actcd19/main/g/grpc/grpc_1.16.1-1/test/core/end2end/tests/stream_compression_compressed_payload.cc:345:

        op->reserved = nullptr;
op++;
error = grpc_call_start_batch(c, ops, static_cast<size_t>(op - ops), tag(2),
nullptr);
GPR_ASSERT(GRPC_CALL_OK == error);


actcd19/main/c/chromium/chromium_72.0.3626.121-1/third_party/angle/src/tests/perf_tests/TexturesPerf.cpp:175:

        const auto &params = GetParam();

size_t textureSize = static_cast<size_t>(1) << params.textureMipCount;
std::vector<GLubyte> textureData(textureSize * textureSize * 4);
for (auto &byte : textureData)


actcd19/main/c/cataclysm-dda/cataclysm-dda_0.C+git20190228.faafa3a-2/src/creature_tracker.cpp:44:

    std::shared_ptr<monster> Creature_tracker::from_temporary_id( const int id )
{
if( static_cast<size_t>( id ) < monsters_list.size() ) {
return monsters_list[id];
} else {


actcd19/main/q/qtwebengine-opensource-src/qtwebengine-opensource-src_5.11.3+dfsg-2/src/3rdparty/chromium/third_party/libaddressinput/src/cpp/src/address_data.cc:125:

    bool AddressData::IsRepeatedFieldValue(AddressField field) {
assert(field >= 0);
assert(static_cast<size_t>(field) < size(kVectorStringField));
return kVectorStringField[field] != nullptr;
}


actcd19/main/g/gcc-arm-none-eabi/gcc-arm-none-eabi_7-2018-q2-5/libstdc++-v3/include/ext/stdio_filebuf.h:78:

          */
stdio_filebuf(int __fd, std::ios_base::openmode __mode,
size_t __size = static_cast<size_t>(BUFSIZ));

/**


actcd19/main/c/cgal/cgal_4.13-1/include/CGAL/Multiset.h:1930:

      // Compare the object to the one stored at the given node in order to decide
// in which direction to proceed.
const size_t max_steps = static_cast<size_t> (1.5 * iBlackHeight);
Comparison_result res = comp_f(object, nodeP->object);
bool found_pos = true;


actcd19/main/c/chromium/chromium_72.0.3626.121-1/third_party/angle/src/libANGLE/validationES3.cpp:548:

            if (static_cast<size_t>(xoffset + width) > texture->getWidth(target, level) ||
static_cast<size_t>(yoffset + height) > texture->getHeight(target, level) ||
static_cast<size_t>(zoffset + depth) > texture->getDepth(target, level))
{
context->validationError(GL_INVALID_VALUE, kOffsetOverflow);


actcd19/main/t/trilinos/trilinos_12.12.1-7/packages/tpetra/core/src/Tpetra_Details_packCrsMatrix.hpp:179:

        if (curInd < static_cast<local_row_index_type> (counts_.dimension_0 ())) {
const auto lclRow = lclRowInds_(curInd);
if (static_cast<size_t> (lclRow + 1) >= static_cast<size_t> (rowOffsets_.dimension_0 ()) ||
static_cast<local_row_index_type> (lclRow) < static_cast<local_row_index_type> (0)) {
error_ () = 3;


actcd19/contrib/c/corsix-th/corsix-th_0.62-2/CorsixTH/Src/th_lua_internal.h:108:

        /* Set __index on the methods metatable to the superclass methods */ \
lua_getmetatable(pState->L, -1); \
lua_getfield(pState->L, pState->metatables[static_cast<size_t>(super_mt)], "__index"); \
lua_setfield(pState->L, -2, "__index"); \
lua_pop(pState->L, 1); \


actcd19/main/w/webkit2gtk/webkit2gtk_2.22.7-1/Tools/TestWebKitAPI/Tests/WebCore/DFAMinimizer.cpp:52:

    {
ContentExtensions::DFA dfa = buildDFAFromPatterns({ ".*aaa", ".*aab", ".*aba", ".*abb", ".*baa", ".*bab", ".*bba", ".*bbb"});
EXPECT_EQ(static_cast<size_t>(12), countLiveNodes(dfa));
dfa.minimize();
EXPECT_EQ(static_cast<size_t>(4), countLiveNodes(dfa));


actcd19/main/f/firefox/firefox_65.0.1-1/gfx/angle/checkout/src/libANGLE/State.cpp:1610:

    void State::setVertexAttribu(GLuint index, const GLuint values[4])
{
ASSERT(static_cast<size_t>(index) < mVertexAttribCurrentValues.size());
mVertexAttribCurrentValues[index].setUnsignedIntValues(values);
mDirtyBits.set(DIRTY_BIT_CURRENT_VALUES);


actcd19/main/libr/libreoffice/libreoffice_6.0.6~rc1-1/sc/source/filter/xml/XMLStylesExportHelper.cxx:842:

        bool& bIsAutoStyle, sal_Int32& nValidationIndex, sal_Int32& nNumberFormat, const sal_Int32 nRemoveBeforeRow)
{
OSL_ENSURE(static_cast<size_t>(nTable) < aTables.size(), "wrong table");
if (static_cast<size_t>(nTable) >= aTables.size())
return -1;


actcd19/main/a/android-platform-system-core/android-platform-system-core_8.1.0+r23-4/libbacktrace/backtrace_test.cpp:943:

      // Create two map pages.
// Mark the second page as not-readable.
size_t pagesize = static_cast<size_t>(sysconf(_SC_PAGE_SIZE));
uint8_t* memory;
if (posix_memalign(reinterpret_cast<void**>(&memory), pagesize, 2 * pagesize) != 0) {


actcd19/main/libr/libreoffice/libreoffice_6.0.6~rc1-1/desktop/qa/desktop_lib/test_desktop_lib.cxx:1514:

            Scheduler::ProcessEventsToIdle();

CPPUNIT_ASSERT_EQUAL(static_cast<size_t>(1), notifs.size());

size_t i = 0;


actcd19/main/m/mame/mame_0.176-3/3rdparty/rapidjson/include/rapidjson/reader.h:1055:

                    length = offset;
#else
length = static_cast<size_t>(__builtin_ffs(r) - 1);
#endif
p += length;


actcd19/main/s/swift-im/swift-im_2.0+dev6-1/Swift/QtUI/QtChatWindow.cpp:362:

    
void QtChatWindow::handleCurrentLabelChanged(int index) {
if (static_cast<size_t>(index) >= labelModel_->availableLabels_.size()) {
qDebug() << "User selected a label that doesn't exist";
return;


actcd19/main/a/android-platform-art/android-platform-art_8.1.0+r23-3/runtime/gc/allocator/rosalloc.cc:154:

            }
remainder->SetByteSize(this, fpr_byte_size - req_byte_size);
DCHECK_EQ(remainder->ByteSize(this) % kPageSize, static_cast<size_t>(0));
// Don't need to call madvise on remainder here.
free_page_runs_.insert(remainder);


actcd19/main/p/paraview/paraview_5.4.1+dfsg4-3.1/VTK/Common/Core/vtkByteSwap.cxx:127:

      // No need to swap segments of 1 byte.
os->write(reinterpret_cast<const char*>(first),
num*static_cast<size_t>(sizeof(signed char)));
}
inline void vtkByteSwapRangeWrite(const unsigned char* first, size_t num,


actcd19/main/c/chromium/chromium_72.0.3626.121-1/third_party/blink/renderer/modules/webgl/webgl2_rendering_context_base.cc:4451:

        case GL_SEPARATE_ATTRIBS:
if (varyings.size() >
static_cast<size_t>(max_transform_feedback_separate_attribs_)) {
SynthesizeGLError(GL_INVALID_VALUE, "transformFeedbackVaryings",
"too many varyings");


actcd19/main/p/pcl/pcl_1.8.1+dfsg1-1/filters/include/pcl/filters/impl/fast_bilateral_omp.hpp:107:

        size_t start_x = static_cast<size_t>( 
std::max ((static_cast<float> (small_x) - static_cast<float> (padding_xy) - 0.5f) * sigma_s_ + 1, 0.f));
size_t end_x = static_cast<size_t>(
std::max ((static_cast<float> (small_x) - static_cast<float> (padding_xy) + 0.5f) * sigma_s_ + 1, 0.f));
size_t start_y = static_cast<size_t>(


actcd19/main/o/openclonk/openclonk_8.1-1/src/platform/C4CrashHandlerWin32.cpp:181:

    		LOG_DYNAMIC_TEXT("RAX: " POINTER_FORMAT ", RBX: " POINTER_FORMAT ", RCX: " POINTER_FORMAT ", RDX: " POINTER_FORMAT "\n",
static_cast<size_t>(exc->ContextRecord->Rax), static_cast<size_t>(exc->ContextRecord->Rbx),
static_cast<size_t>(exc->ContextRecord->Rcx), static_cast<size_t>(exc->ContextRecord->Rdx));
LOG_DYNAMIC_TEXT("RBP: " POINTER_FORMAT ", RSI: " POINTER_FORMAT ", RDI: " POINTER_FORMAT ", R8: " POINTER_FORMAT "\n",
static_cast<size_t>(exc->ContextRecord->Rbp), static_cast<size_t>(exc->ContextRecord->Rsi),


actcd19/main/v/vtk7/vtk7_7.1.1+dfsg1-12/IO/ParallelNetCDF/vtkPNetCDFPOPReader.cxx:352:

            //set up start and stride values for this process's data (count is already set)
size_t start[]= { static_cast<size_t>(subext[4]),
static_cast<size_t>(subext[2]),
static_cast<size_t>(subext[0]) };


actcd19/main/a/ace/ace_6.4.5+dfsg-1/ace/SUN_Proactor.cpp:164:

         transfer_count = 0; // zero bytes transferred
else
transfer_count = static_cast<size_t> (op_return);

return 1; // completed


actcd19/main/h/h2o/h2o_2.2.5+dfsg2-2/deps/brotli/enc/block_splitter.cc:311:

      split->types.push_back(cur_id);
split->lengths.push_back(cur_length);
split->num_types = static_cast<size_t>(max_type) + 1;
}


actcd19/main/libr/libreoffice/libreoffice_5.4.3-4/oox/source/helper/binaryinputstream.cxx:181:

                sal_Int32 nBytesRead = readData( maBuffer, nReadSize, nAtomSize );
if( nBytesRead > 0 )
memcpy( opnMem, maBuffer.getConstArray(), static_cast< size_t >( nBytesRead ) );
opnMem += nBytesRead;
nBytes -= nBytesRead;


actcd19/main/r/rlvm/rlvm_0.14-3/src/machine/general_operations.cc:122:

      Gameexe& gexe = machine.system().gameexe();
std::vector<int> values = gexe(full_key_name_);
if (static_cast<size_t>(entry_) < values.size()) {
return values[entry_];
} else {


actcd19/main/w/webkit2gtk/webkit2gtk_2.22.7-1/Source/WebCore/platform/graphics/WidthIterator.cpp:257:

                static bool expandAroundIdeographs = FontCascade::canExpandAroundIdeographsInComplexText();
bool treatAsSpace = FontCascade::treatAsSpace(character);
bool currentIsLastCharacter = currentCharacter + advanceLength == static_cast<size_t>(m_run.length());
bool forceLeadingExpansion = false; // On the left, regardless of m_run.ltr()
bool forceTrailingExpansion = false; // On the right, regardless of m_run.ltr()


actcd19/main/v/vtk7/vtk7_7.1.1+dfsg1-12/Utilities/KWSys/vtksys/SystemInformation.cxx:4439:

        {
this->AvailableVirtualMemory = static_cast< size_t >( swap.xsu_avail/1048576 );
this->TotalVirtualMemory = static_cast< size_t >( swap.xsu_total/1048576 );
}
#else


actcd19/main/q/qtwebkit-opensource-src/qtwebkit-opensource-src_5.212.0~alpha2-20/Tools/TestWebKitAPI/Tests/WTF/StringImpl.cpp:254:

        EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA->findIgnoringASCIICase(stringFromUTF8("É").get()));
EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA->findIgnoringASCIICase(stringFromUTF8("CÉe").get()));
EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA->findIgnoringASCIICase(stringFromUTF8("éd").get()));
EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA->findIgnoringASCIICase(stringFromUTF8("CÉ").get()));
EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA->findIgnoringASCIICase(stringFromUTF8("Y").get()));


actcd19/main/r/re2/re2_20190101+dfsg-2/re2/parse.cc:1772:

    
// Chop seq where s now begins.
seq = StringPiece(seq.begin(), static_cast<size_t>(s->begin() - seq.begin()));

if (name.size() > 0 && name[0] == '^') {


actcd19/main/libr/libreoffice/libreoffice_5.4.3-4/vcl/qa/cppunit/pdfexport/pdfexport.cxx:503:

        auto pXObjects = dynamic_cast<vcl::filter::PDFDictionaryElement*>(pResources->Lookup("XObject"));
CPPUNIT_ASSERT(pXObjects);
CPPUNIT_ASSERT_EQUAL(static_cast<size_t>(1), pXObjects->GetItems().size());
vcl::filter::PDFObjectElement* pXObject = pXObjects->LookupObject(pXObjects->GetItems().begin()->first);
// This failed, the reference to the image was created, but not the image.


actcd19/main/a/android-platform-art/android-platform-art_8.1.0+r23-3/runtime/gc/allocator/rosalloc.cc:1355:

        DCHECK(last_free_page_run->IsFree());
DCHECK(IsFreePage(ToPageMapIndex(last_free_page_run)));
DCHECK_EQ(last_free_page_run->ByteSize(this) % kPageSize, static_cast<size_t>(0));
DCHECK_EQ(last_free_page_run->End(this), base_ + footprint_);
free_page_runs_.erase(last_free_page_run);


actcd19/main/n/nghttp2/nghttp2_1.36.0-2/src/h2load.cc:1282:

          next_client_id(0) {
if (!config->is_rate_mode() && !config->is_timing_based_mode()) {
progress_interval = std::max(static_cast<size_t>(1), req_todo / 10);
} else {
progress_interval = std::max(static_cast<size_t>(1), nclients / 10);


actcd19/main/s/securefs/securefs_0.8.3+ds-1/sources/lite_fs.cpp:427:

                                                   0,
underbuf.get() + iv_size,
static_cast<size_t>(readlen) - iv_size - mac_size);
if (!success)
{


actcd19/main/q/qtwebengine-opensource-src/qtwebengine-opensource-src_5.11.3+dfsg-2/src/3rdparty/chromium/base/synchronization/waitable_event_perftest.cc:108:

      perf_test::PrintResult(
"wait_time", modifier, trace,
static_cast<size_t>(wait_time.InNanoseconds()) / event->samples(),
"ns/sample", true);
}


actcd19/main/t/thunderbird/thunderbird_60.5.1-1/media/webrtc/trunk/webrtc/base/stringutils.h:125:

    namespace rtc {

const size_t SIZE_UNKNOWN = static_cast<size_t>(-1);

template<class CTYPE>


actcd19/main/w/webkit2gtk/webkit2gtk_2.18.3-1/Tools/TestWebKitAPI/Tests/WTF/StringView.cpp:456:

        EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "Ée")));
EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "bé")));
EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "x")));
EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "É")));
EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "CÉe")));


actcd19/main/q/qtwebengine-opensource-src/qtwebengine-opensource-src_5.11.3+dfsg-2/src/3rdparty/chromium/components/sessions/core/tab_restore_service_helper.cc:499:

    bool TabRestoreServiceHelper::ValidateTab(const Tab& tab) {
return !tab.navigations.empty() &&
static_cast<size_t>(tab.current_navigation_index) <
tab.navigations.size();
}


actcd19/main/q/qtwebengine-opensource-src/qtwebengine-opensource-src_5.11.3+dfsg-2/src/3rdparty/chromium/base/allocator/partition_allocator/partition_alloc_unittest.cc:138:

          EXPECT_EQ(reinterpret_cast<size_t>(first) & kPartitionPageBaseMask,
reinterpret_cast<size_t>(last) & kPartitionPageBaseMask);
EXPECT_EQ(num_slots, static_cast<size_t>(
bucket->active_pages_head->num_allocated_slots));
EXPECT_EQ(nullptr, bucket->active_pages_head->freelist_head);


actcd19/main/libr/libreoffice/libreoffice_5.4.3-4/sc/source/core/tool/token.cxx:3362:

    {
FormulaToken** p = pCode;
FormulaToken** pEnd = p + static_cast<size_t>(nLen);
for (; p != pEnd; ++p)
{


actcd19/main/p/percona-xtrabackup/percona-xtrabackup_2.2.3-2.1/sql/rpl_record.cc:154:

      DBUG_ASSERT(null_ptr == row_data + null_byte_count);
DBUG_DUMP("row_data", row_data, pack_ptr - row_data);
DBUG_RETURN(static_cast<size_t>(pack_ptr - row_data));
}
#endif


actcd19/main/c/chromium/chromium_72.0.3626.121-1/content/browser/speech/speech_recognition_engine.cc:152:

        // Since kMaxUploadWrite is a uint32_t, no overflow occurs in this downcast.
uint32_t write_bytes = std::min(upload_body_.length() - upload_position_,
static_cast<size_t>(kMaxUploadWrite));
MojoResult result =
upload_pipe_->WriteData(upload_body_.data() + upload_position_,


actcd19/main/g/grpc/grpc_1.16.1-1/test/core/end2end/tests/write_buffering.cc:140:

      op->reserved = nullptr;
op++;
error = grpc_call_start_batch(c, ops, static_cast<size_t>(op - ops), tag(2),
nullptr);
GPR_ASSERT(GRPC_CALL_OK == error);


actcd19/main/q/qtbase-opensource-src/qtbase-opensource-src_5.10.1+dfsg-5/src/3rdparty/angle/src/libANGLE/validationES2.cpp:140:

            }

if (static_cast<size_t>(xoffset + width) > texture->getWidth(target, level) ||
static_cast<size_t>(yoffset + height) > texture->getHeight(target, level))
{


actcd19/main/a/alljoyn-core-1604/alljoyn-core-1604_16.04a+dfsg.1-3/alljoyn_core/unit_test/SecurityDefaultPolicyTest.cc:746:

            MsgArg arg("s", "String that should be Echoed back.");
Message replyMsg(peer1Bus);
EXPECT_EQ(ER_PERMISSION_DENIED, managerToPeer1Proxy.MethodCall(interfaceName, "Echo", &arg, static_cast<size_t>(1), replyMsg));
EXPECT_STREQ("org.alljoyn.Bus.Security.Error.PermissionDenied", replyMsg->GetErrorName());


actcd19/main/libv/libvmime/libvmime_0.9.2-5/src/vmime/charsetConverter_iconv.cpp:171:

    	{
// Fullfill the buffer
size_t inLength = static_cast <size_t>(in.read(inBuffer + inPos, sizeof(inBuffer) - inPos) + inPos);
size_t outLength = sizeof(outBuffer);


actcd19/main/a/abiword/abiword_3.0.2-8/src/af/util/xp/ut_stringbuf.cpp:321:

    		if (seql == 0) 
break; // end-of-string?
bytelength += static_cast<size_t>(seql);
}
if(bytelength == 0)


actcd19/main/libr/libreoffice/libreoffice_6.1.5-1/sc/source/core/data/dptabres.cxx:552:

                        if (nSize > 0)
{
assert(nSize == static_cast<size_t>(nCount));
if ((nSize % 2) == 1)
fResult = mSortedValues[nSize / 2];


actcd19/main/q/qtwebengine-opensource-src/qtwebengine-opensource-src_5.11.3+dfsg-2/src/3rdparty/chromium/third_party/protobuf/src/google/protobuf/duration.pb.cc:171:

    
void Duration::SharedCtor() {
::memset(&seconds_, 0, static_cast<size_t>(
reinterpret_cast<char*>(&nanos_) -
reinterpret_cast<char*>(&seconds_)) + sizeof(nanos_));


actcd19/main/q/qtwebengine-opensource-src/qtwebengine-opensource-src_5.11.3+dfsg-2/src/3rdparty/chromium/third_party/WebKit/Source/platform/SharedBuffer.h:117:

      size_t GetSomeData(
const char*& data,
STRICTLY_TYPED_ARG(position) = static_cast<size_t>(0)) const {
STRICT_ARG_TYPE(size_t);
return GetSomeDataInternal(data, position);


actcd19/main/f/fw4spl/fw4spl_17.2.0-2/SrcLib/core/fwServices/test/tu/src/ProxyTest.cpp:136:

        CPPUNIT_ASSERT_EQUAL(static_cast<size_t>(0), sig->getNumberOfConnections());
CPPUNIT_ASSERT_EQUAL(static_cast<size_t>(0), sig2->getNumberOfConnections());
CPPUNIT_ASSERT_EQUAL(static_cast<size_t>(0), slot->getNumberOfConnections());
CPPUNIT_ASSERT_EQUAL(static_cast<size_t>(0), slot2->getNumberOfConnections());
CPPUNIT_ASSERT_EQUAL(static_cast<size_t>(0), slot3->getNumberOfConnections());


actcd19/main/a/android-platform-art/android-platform-art_8.1.0+r23-3/runtime/generated/asm_support_gen.h:86:

    DEFINE_CHECK_EQ(static_cast<int32_t>(METHOD_DEX_CACHE_HASH_BITS), (static_cast<int32_t>(art::LeastSignificantBit(art::mirror::DexCache::kDexCacheMethodCacheSize))))
#define CARD_TABLE_CARD_SHIFT 0xa
DEFINE_CHECK_EQ(static_cast<size_t>(CARD_TABLE_CARD_SHIFT), (static_cast<size_t>(art::gc::accounting::CardTable::kCardShift)))
#define MIN_LARGE_OBJECT_THRESHOLD 0x3000
DEFINE_CHECK_EQ(static_cast<size_t>(MIN_LARGE_OBJECT_THRESHOLD), (static_cast<size_t>(art::gc::Heap::kMinLargeObjectThreshold)))


actcd19/main/n/nodejs/nodejs_10.15.2~dfsg-1/src/node_zlib.cc:393:

            unreported_allocations_.exchange(0, std::memory_order_relaxed);
if (report == 0) return;
CHECK_IMPLIES(report < 0, zlib_memory_ >= static_cast<size_t>(-report));
zlib_memory_ += report;
env()->isolate()->AdjustAmountOfExternalAllocatedMemory(report);


actcd19/main/m/mongodb/mongodb_3.4.18-2/src/mongo/dbtests/query_stage_keep.cpp:223:

            // elements is greater than or equal to max_load_factor()*bucket_count().
size_t rehashSize =
static_cast<size_t>(ws.getFlagged().max_load_factor() * ws.getFlagged().bucket_count());
while (ws.getFlagged().size() <= rehashSize) {
WorkingSetID id = ws.allocate();


actcd19/main/q/qtwebengine-opensource-src/qtwebengine-opensource-src_5.11.3+dfsg-2/src/3rdparty/chromium/headless/public/util/generic_url_request_job.cc:186:

      size_t bytes_available = body_size_ - read_offset_;
size_t bytes_to_copy =
std::min(static_cast<size_t>(buf_size), bytes_available);
if (bytes_to_copy) {
std::memcpy(buf->data(), &body_[read_offset_], bytes_to_copy);


actcd19/main/a/aegisub/aegisub_3.2.2+dfsg-4/libaegisub/common/format.cpp:40:

    template<typename Char>
int actual_len(int max_len, std::basic_string<Char> value) {
if (max_len > 0 && static_cast<size_t>(max_len) < value.size())
return max_len;
return value.size();


actcd19/main/a/assimp/assimp_4.1.0~dfsg-5/code/FBXParser.cpp:375:

        const size_t length = static_cast<size_t>(t.end()-t.begin());
std::copy(t.begin(),t.end(),temp);
temp[std::min(static_cast<size_t>(MAX_FLOAT_LENGTH),length)] = '\0';

return fast_atof(temp);


actcd19/main/f/firefox/firefox_65.0.1-1/media/webrtc/signaling/gtest/jsep_session_unittest.cpp:4703:

    
JsepOfferOptions options;
options.mOfferToReceiveAudio = Some(static_cast<size_t>(1U));
options.mOfferToReceiveVideo = Some(static_cast<size_t>(1U));


actcd19/main/libr/libreoffice/libreoffice_6.1.5-1/extensions/source/scanner/sane.cxx:971:

        OUString aText;
SANE_Unit nUnit = mppOptions[n]->unit;
size_t nUnitAsSize = static_cast<size_t>(nUnit);
if (nUnitAsSize >= SAL_N_ELEMENTS( ppUnits ))
aText = "[unknown units]";


actcd19/main/p/paraview/paraview_5.0.1+dfsg1-5.1/VTK/Domains/Chemistry/vtkCMLMoleculeReader.cxx:235:

    
// Store name for lookups
size_t atomId = static_cast<size_t>(atom.GetId());
if (atomId >= this->AtomNames.size())
{


actcd19/main/c/cmake/cmake_3.13.4-1/Source/cmBase32.cxx:61:

      }

size_t remain = static_cast<size_t>(end - input);
if (remain != 0) {
// Temporary source buffer filled up with 0s


actcd19/main/s/swift-im/swift-im_3.0.4-1/Swiften/Parser/UnitTest/XMLParserTest.cpp:315:

    				"<foo bar:baz='bla'/>"));

CPPUNIT_ASSERT_EQUAL(static_cast<size_t>(1), client_.events[0].attributes.getEntries().size());
CPPUNIT_ASSERT_EQUAL(std::string("bar:baz"), client_.events[0].attributes.getEntries()[0].getAttribute().getName());
}


actcd19/main/a/adapterremoval/adapterremoval_2.2.3-1/src/main.cpp:83:

            default: {
std::cerr << "ERROR: Unknown run-type: "
<< static_cast<size_t>(config.run_type)
<< std::endl;
return 1;


actcd19/main/t/tango/tango_9.2.5a+dfsg1-2/lib/cpp/log4tango/src/StringUtil.cpp:65:

                    
// If that worked, return a string.
if ((n > -1) && (static_cast<size_t>(n) < size)) {
std::string s(buffer);
delete [] buffer;


actcd19/main/t/trilinos/trilinos_12.12.1-7/packages/tpetra/tsqr/src/Tsqr_Matrix.hpp:165:

              throw std::range_error (os.str());
}
return static_cast<size_t>(num_rows) * static_cast<size_t>(num_cols);
}


actcd19/main/q/qtwebkit-opensource-src/qtwebkit-opensource-src_5.212.0~alpha2-5/Source/ThirdParty/ANGLE/src/libGLESv2/entry_points_gles_2_0_ext.cpp:949:

    
if (!rx::IsUnsignedAdditionSafe(offsetSize, lengthSize) ||
offsetSize + lengthSize > static_cast<size_t>(buffer->getSize()))
{
context->recordError(Error(GL_INVALID_VALUE));


actcd19/main/q/qtwebengine-opensource-src/qtwebengine-opensource-src_5.11.3+dfsg-2/src/3rdparty/chromium/media/base/audio_bus.cc:166:

      CHECK(data);
CHECK_GE(channel, 0);
CHECK_LT(static_cast<size_t>(channel), channel_data_.size());
DCHECK(IsAligned(data));
channel_data_[channel] = data;


actcd19/main/c/chromium/chromium_72.0.3626.121-1/v8/src/heap/spaces.h:824:

    
// Returns the offset of a given address to this page.
inline size_t Offset(Address a) { return static_cast<size_t>(a - address()); }

// Returns the address for a given offset to the this page.


actcd19/main/s/spirv-tools/spirv-tools_2019.1-2/source/comp/markv_decoder.cpp:828:

    
for (operand_index_ = 0;
operand_index_ < static_cast<size_t>(inst_.num_operands);
++operand_index_) {
assert(!expected_operands.empty());


actcd19/main/f/firefox-esr/firefox-esr_60.5.1esr-1/media/webrtc/trunk/webrtc/modules/video_capture/windows/device_info_ds.cc:438:

      ReadLockScoped cs(_apiLock);

if (capabilityIndex < 0 || static_cast<size_t>(capabilityIndex) >=
_captureCapabilitiesWindows.size()) {
return -1;


actcd19/main/w/webkit2gtk/webkit2gtk_2.22.7-1/Source/ThirdParty/ANGLE/src/compiler/translator/IntermNode.cpp:1353:

                }
const TFieldList &fields = mLeft->getType().getStruct()->fields();
size_t index = static_cast<size_t>(rightConstant->getIConst(0));

size_t previousFieldsSize = 0;


actcd19/main/p/paraview/paraview_5.4.1+dfsg4-3.1/ThirdParty/pugixml/pugixml.cxx:2909:

    			xml_encoding native_encoding = is_little_endian() ? encoding_utf16_le : encoding_utf16_be;

if (native_encoding != encoding) convert_utf_endian_swap(dest, dest, static_cast<size_t>(end - dest));

return static_cast<size_t>(end - dest) * sizeof(uint16_t);


actcd19/main/q/qtwebengine-opensource-src/qtwebengine-opensource-src_5.11.3+dfsg-2/src/3rdparty/chromium/content/child/blink_platform_impl.cc:739:

    
size_t BlinkPlatformImpl::NumberOfProcessors() {
return static_cast<size_t>(base::SysInfo::NumberOfProcessors());
}


actcd19/main/w/webkit2gtk/webkit2gtk_2.18.3-1/Source/WebCore/Modules/mediastream/libwebrtc/LibWebRTCDataChannelHandler.cpp:117:

    
callOnMainThread([protectedClient = makeRef(*m_client), amount = m_channel->buffered_amount()] {
protectedClient->bufferedAmountIsDecreasing(static_cast<size_t>(amount));
});
}


actcd19/main/c/chromium/chromium_72.0.3626.121-1/content/browser/renderer_host/render_process_host_impl.cc:2444:

      DCHECK_GT(keep_alive_ref_count_, 0U);
base::TimeTicks now = base::TimeTicks::Now();
size_t client_type = static_cast<size_t>(client);
keep_alive_client_count_[client_type]--;
if (keep_alive_client_count_[client_type] == 0) {


actcd19/main/libr/libreoffice/libreoffice_6.1.5-1/editeng/source/outliner/paralist.hxx:51:

        Paragraph*      GetParagraph( sal_Int32 nPos ) const
{
return 0 <= nPos && static_cast<size_t>(nPos) < maEntries.size() ? maEntries[nPos].get() : nullptr;
}


actcd19/main/v/vtk6/vtk6_6.3.0+dfsg2-2/IO/Image/vtkPNGWriter.cxx:119:

              }
}
if (static_cast<size_t>(bytes_printed) >= internalFileNameSize)
{
// add null terminating character just to be safe.


actcd19/main/c/chromium/chromium_72.0.3626.121-1/components/crash/content/app/minidump_with_crashpad_info.cc:303:

          break;

if (!dest->Write(&buf[0], static_cast<size_t>(bytes_read))) {
return false;
}


actcd19/main/w/webkit2gtk/webkit2gtk_2.22.7-1/Tools/TestWebKitAPI/Tests/WTF/StringView.cpp:435:

        EXPECT_EQ(static_cast<size_t>(0), referenceA.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "abcé")));
EXPECT_EQ(static_cast<size_t>(0), referenceA.findIgnoringASCIICase(stringViewFromLiteral("A")));
EXPECT_EQ(static_cast<size_t>(0), referenceA.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "ABCé")));
EXPECT_EQ(static_cast<size_t>(0), referenceB.findIgnoringASCIICase(stringViewFromLiteral("a")));
EXPECT_EQ(static_cast<size_t>(0), referenceB.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "abcÉ")));


actcd19/main/l/llvm-toolchain-7/llvm-toolchain-7_7.0.1-8/libcxx/test/std/re/re.alg/re.alg.match/basic.pass.cpp:1037:

            assert(m.suffix().first == m[0].second);
assert(m.suffix().second == m[0].second);
assert(m.length(0) >= 0 && static_cast<size_t>(m.length(0)) == std::char_traits<wchar_t>::length(s));
assert(m.position(0) == 0);
assert(m.str(0) == s);


actcd19/main/libr/libreoffice/libreoffice_6.1.5-1/dtrans/source/win32/misc/ImplHelper.cxx:202:

            {
ptdDest = static_cast< DVTARGETDEVICE* >( CoTaskMemAlloc( ptdSrc->tdSize ) );
memcpy( ptdDest, ptdSrc, static_cast< size_t >( ptdSrc->tdSize ) );
}
}


actcd19/main/c/chromium/chromium_72.0.3626.121-1/net/log/file_net_log_observer_unittest.cc:724:

      VerifyEventsInLog(
log.get(), kNumEvents,
static_cast<size_t>(kTotalNumFiles * ((kFileSize - 1) / kEventSize + 1)));
}


actcd19/main/g/grpc/grpc_1.16.1-1/test/core/end2end/tests/proxy_auth.cc:189:

      op->reserved = nullptr;
op++;
error = grpc_call_start_batch(s, ops, static_cast<size_t>(op - ops), tag(102),
nullptr);
GPR_ASSERT(GRPC_CALL_OK == error);


actcd19/main/s/spdlog/spdlog_1.3.1-1/include/spdlog/sinks/syslog_sink.h:35:

            priorities_[static_cast<size_t>(level::trace)] = LOG_DEBUG;
priorities_[static_cast<size_t>(level::debug)] = LOG_DEBUG;
priorities_[static_cast<size_t>(level::info)] = LOG_INFO;
priorities_[static_cast<size_t>(level::warn)] = LOG_WARNING;
priorities_[static_cast<size_t>(level::err)] = LOG_ERR;


actcd19/main/m/mysql-5.7/mysql-5.7_5.7.25-1/sql/json_path.cc:481:

        }

if (append(Json_path_leg(static_cast<size_t>(cell_index))))
PARSER_RETURN(false); /* purecov: inspected */
}


actcd19/main/c/chromium/chromium_72.0.3626.121-1/media/renderers/audio_renderer_impl_unittest.cc:743:

      std::vector<bool> mask = channel_mask();
EXPECT_FALSE(mask.empty());
ASSERT_EQ(mask.size(), static_cast<size_t>(hw_params.channels()));
for (int ch = 0; ch < hw_params.channels(); ++ch) {
if (ch > 1)


actcd19/main/l/llvm-toolchain-3.8/llvm-toolchain-3.8_3.8.1-23/lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.cpp:2353:

    
// Write allocation data to file
num_bytes = static_cast<size_t>(*alloc->size.get());
if (log)
log->Printf("RenderScriptRuntime::SaveAllocation - Writing 0x%zX bytes", num_bytes);


actcd19/main/libk/libkml/libkml_1.3.0-5/tests/kml/dom/folder_test.cc:152:

    TEST_F(FolderTest, TestAddFeatureTwiceToSameFolder) {
PlacemarkPtr placemark = KmlFactory::GetFactory()->CreatePlacemark();
ASSERT_EQ(static_cast<size_t>(0),
folder_->get_feature_array_size());
folder_->add_feature(placemark);


actcd19/main/m/mrpt/mrpt_1.5.6-1/libs/base/include/mrpt/math/CBinaryRelation.h:145:

    			typename std::set<T>::const_iterator it1=std::find(b,e,t1),it2=std::find(b,e,t2);
if (it1==e||it2==e) throw std::domain_error("Element not found");
return getRelationValue(static_cast<size_t>(std::distance(b,it1)),static_cast<size_t>(distance(b,it2)));
}
/**


actcd19/main/b/bedops/bedops_2.4.35+dfsg-1/.pc/use_debian_libs/applications/bed/starch/src/starchcat.c:3242:

    #ifdef __cplusplus
STARCH_encodeBase64(&r_base64EncodedSha1Digest,
static_cast<size_t>( STARCH2_MD_FOOTER_BASE64_ENCODED_SHA1_LENGTH ),
reinterpret_cast<const unsigned char *>( r_sha1Digest ),
static_cast<size_t>( STARCH2_MD_FOOTER_SHA1_LENGTH ) );


actcd19/main/t/trilinos/trilinos_12.12.1-7/packages/intrepid/src/Shared/Intrepid_RealSpaceToolsDef.hpp:104:

        for (size_t j=0; j<static_cast<size_t>(static_cast<size_t>(inArray.dimension(1))); j++)
for (size_t k=0; k<static_cast<size_t>(static_cast<size_t>(inArray.dimension(2))); k++)
for (size_t l=0; l<static_cast<size_t>(static_cast<size_t>(inArray.dimension(3))); l++){
absArrayWrap(i,j,k,l) = std::abs(inArrayWrap(i,j,k,l));
}


actcd19/main/m/monero/monero_0.13.0.4-2/src/rpc/core_rpc_server.cpp:798:

          return true;
}
if(!miner.start(info.address, static_cast<size_t>(req.threads_count), attrs, req.do_background_mining, req.ignore_battery))
{
res.status = "Failed, mining not started";


actcd19/main/c/chromium/chromium_72.0.3626.121-1/net/log/test_net_log_util.cc:22:

        return static_cast<size_t>(offset);

size_t abs_offset = static_cast<size_t>(-offset);
// If offset indicates a position before the start of the array, just return
// the end of the list.


actcd19/main/l/llvm-toolchain-8/llvm-toolchain-8_8~+rc3-1~exp1/lldb/source/Core/IOHandler.cpp:1465:

      for (size_t i = 0; i < num_submenus; ++i) {
Menu *submenu = submenus[i].get();
if (static_cast<size_t>(m_max_submenu_name_length) < submenu->m_name.size())
m_max_submenu_name_length = submenu->m_name.size();
if (static_cast<size_t>(m_max_submenu_key_name_length) <


actcd19/main/q/qtwebengine-opensource-src/qtwebengine-opensource-src_5.11.3+dfsg-2/src/3rdparty/chromium/net/nqe/network_quality_observation_source.cc:40:

        return "";
}
return kObservationSourceMapping[static_cast<size_t>(source)];
}


actcd19/main/c/chromium/chromium_72.0.3626.121-1/third_party/angle/src/libANGLE/validationES3.cpp:580:

            {
size_t offset = reinterpret_cast<size_t>(pixels);
size_t dataBytesPerPixel = static_cast<size_t>(gl::GetTypeInfo(type).bytes);

if ((offset % dataBytesPerPixel) != 0)