writeRandomBytes_arc4random_buf: 45| 12.0k|writeRandomBytes_arc4random_buf(void *target, size_t count) { 46| 12.0k| arc4random_buf(target, count); 47| | // MSan does not understand `arc4random_buf`, so explain its effects 48| 12.0k| MSAN_UNPOISON(target, count); ------------------ | | 49| 12.0k| do { \ | | 50| 12.0k| } while (0) | | ------------------ | | | Branch (50:16): [Folded, False: 12.0k] | | ------------------ ------------------ 49| 12.0k|} xmlparse.c:sip24_init: 194| 877k|sip24_init(struct siphash *H, const struct sipkey *key) { 195| 877k| H->v0 = SIP_ULL(0x736f6d65U, 0x70736575U) ^ key->k[0]; ------------------ | | 112| 877k|#define SIP_ULL(high, low) ((((uint64_t)high) << 32) | (low)) ------------------ 196| 877k| H->v1 = SIP_ULL(0x646f7261U, 0x6e646f6dU) ^ key->k[1]; ------------------ | | 112| 877k|#define SIP_ULL(high, low) ((((uint64_t)high) << 32) | (low)) ------------------ 197| 877k| H->v2 = SIP_ULL(0x6c796765U, 0x6e657261U) ^ key->k[0]; ------------------ | | 112| 877k|#define SIP_ULL(high, low) ((((uint64_t)high) << 32) | (low)) ------------------ 198| 877k| H->v3 = SIP_ULL(0x74656462U, 0x79746573U) ^ key->k[1]; ------------------ | | 112| 877k|#define SIP_ULL(high, low) ((((uint64_t)high) << 32) | (low)) ------------------ 199| | 200| 877k| H->p = H->buf; 201| 877k| H->c = 0; 202| | 203| 877k| return H; 204| 877k|} /* sip24_init() */ xmlparse.c:sip24_update: 209| 898k|sip24_update(struct siphash *H, const void *src, size_t len) { 210| 898k| const unsigned char *p = (const unsigned char *)src, *pe = p + len; 211| 898k| uint64_t m; 212| | 213| 1.37M| do { 214| 6.36M| while (p < pe && H->p < sip_endof(H->buf)) ------------------ | | 206| 5.46M|#define sip_endof(a) (&(a)[sizeof(a) / sizeof *(a)]) ------------------ | Branch (214:12): [True: 5.46M, False: 898k] | Branch (214:22): [True: 4.99M, False: 472k] ------------------ 215| 4.99M| *H->p++ = *p++; 216| | 217| 1.37M| if (H->p < sip_endof(H->buf)) ------------------ | | 206| 1.37M|#define sip_endof(a) (&(a)[sizeof(a) / sizeof *(a)]) ------------------ | Branch (217:9): [True: 896k, False: 474k] ------------------ 218| 896k| break; 219| | 220| 474k| m = SIP_U8TO64_LE(H->buf); ------------------ | | 127| 474k| (((uint64_t)((p)[0]) << 0) | ((uint64_t)((p)[1]) << 8) \ | | 128| 474k| | ((uint64_t)((p)[2]) << 16) | ((uint64_t)((p)[3]) << 24) \ | | 129| 474k| | ((uint64_t)((p)[4]) << 32) | ((uint64_t)((p)[5]) << 40) \ | | 130| 474k| | ((uint64_t)((p)[6]) << 48) | ((uint64_t)((p)[7]) << 56)) ------------------ 221| 474k| H->v3 ^= m; 222| 474k| sip_round(H, 2); 223| 474k| H->v0 ^= m; 224| | 225| 474k| H->p = H->buf; 226| 474k| H->c += 8; 227| 474k| } while (p < pe); ------------------ | Branch (227:12): [True: 472k, False: 1.84k] ------------------ 228| | 229| 898k| return H; 230| 898k|} /* sip24_update() */ xmlparse.c:sip_round: 169| 2.22M|sip_round(struct siphash *H, const int rounds) { 170| 2.22M| int i; 171| | 172| 8.44M| for (i = 0; i < rounds; i++) { ------------------ | Branch (172:15): [True: 6.21M, False: 2.22M] ------------------ 173| 6.21M| H->v0 += H->v1; 174| 6.21M| H->v1 = SIP_ROTL(H->v1, 13); ------------------ | | 114| 6.21M|#define SIP_ROTL(x, b) (uint64_t)(((x) << (b)) | ((x) >> (64 - (b)))) ------------------ 175| 6.21M| H->v1 ^= H->v0; 176| 6.21M| H->v0 = SIP_ROTL(H->v0, 32); ------------------ | | 114| 6.21M|#define SIP_ROTL(x, b) (uint64_t)(((x) << (b)) | ((x) >> (64 - (b)))) ------------------ 177| | 178| 6.21M| H->v2 += H->v3; 179| 6.21M| H->v3 = SIP_ROTL(H->v3, 16); ------------------ | | 114| 6.21M|#define SIP_ROTL(x, b) (uint64_t)(((x) << (b)) | ((x) >> (64 - (b)))) ------------------ 180| 6.21M| H->v3 ^= H->v2; 181| | 182| 6.21M| H->v0 += H->v3; 183| 6.21M| H->v3 = SIP_ROTL(H->v3, 21); ------------------ | | 114| 6.21M|#define SIP_ROTL(x, b) (uint64_t)(((x) << (b)) | ((x) >> (64 - (b)))) ------------------ 184| 6.21M| H->v3 ^= H->v0; 185| | 186| 6.21M| H->v2 += H->v1; 187| 6.21M| H->v1 = SIP_ROTL(H->v1, 17); ------------------ | | 114| 6.21M|#define SIP_ROTL(x, b) (uint64_t)(((x) << (b)) | ((x) >> (64 - (b)))) ------------------ 188| 6.21M| H->v1 ^= H->v2; 189| 6.21M| H->v2 = SIP_ROTL(H->v2, 32); ------------------ | | 114| 6.21M|#define SIP_ROTL(x, b) (uint64_t)(((x) << (b)) | ((x) >> (64 - (b)))) ------------------ 190| 6.21M| } 191| 2.22M|} /* sip_round() */ xmlparse.c:sip24_final: 233| 877k|sip24_final(struct siphash *H) { 234| 877k| const char left = (char)(H->p - H->buf); 235| 877k| uint64_t b = (H->c + left) << 56; 236| | 237| 877k| switch (left) { ------------------ | Branch (237:11): [True: 877k, False: 0] ------------------ 238| 3.37k| case 7: ------------------ | Branch (238:3): [True: 3.37k, False: 874k] ------------------ 239| 3.37k| b |= (uint64_t)H->buf[6] << 48; 240| 3.37k| EXPAT_FALLTHROUGH; ------------------ | | 47| 3.37k|# define EXPAT_FALLTHROUGH __attribute__((fallthrough)) ------------------ 241| 24.6k| case 6: ------------------ | Branch (241:3): [True: 21.2k, False: 856k] ------------------ 242| 24.6k| b |= (uint64_t)H->buf[5] << 40; 243| 24.6k| EXPAT_FALLTHROUGH; ------------------ | | 47| 24.6k|# define EXPAT_FALLTHROUGH __attribute__((fallthrough)) ------------------ 244| 62.5k| case 5: ------------------ | Branch (244:3): [True: 37.9k, False: 839k] ------------------ 245| 62.5k| b |= (uint64_t)H->buf[4] << 32; 246| 62.5k| EXPAT_FALLTHROUGH; ------------------ | | 47| 62.5k|# define EXPAT_FALLTHROUGH __attribute__((fallthrough)) ------------------ 247| 64.9k| case 4: ------------------ | Branch (247:3): [True: 2.34k, False: 875k] ------------------ 248| 64.9k| b |= (uint64_t)H->buf[3] << 24; 249| 64.9k| EXPAT_FALLTHROUGH; ------------------ | | 47| 64.9k|# define EXPAT_FALLTHROUGH __attribute__((fallthrough)) ------------------ 250| 79.3k| case 3: ------------------ | Branch (250:3): [True: 14.4k, False: 863k] ------------------ 251| 79.3k| b |= (uint64_t)H->buf[2] << 16; 252| 79.3k| EXPAT_FALLTHROUGH; ------------------ | | 47| 79.3k|# define EXPAT_FALLTHROUGH __attribute__((fallthrough)) ------------------ 253| 88.9k| case 2: ------------------ | Branch (253:3): [True: 9.60k, False: 868k] ------------------ 254| 88.9k| b |= (uint64_t)H->buf[1] << 8; 255| 88.9k| EXPAT_FALLTHROUGH; ------------------ | | 47| 88.9k|# define EXPAT_FALLTHROUGH __attribute__((fallthrough)) ------------------ 256| 875k| case 1: ------------------ | Branch (256:3): [True: 786k, False: 90.9k] ------------------ 257| 875k| b |= (uint64_t)H->buf[0] << 0; 258| 875k| EXPAT_FALLTHROUGH; ------------------ | | 47| 875k|# define EXPAT_FALLTHROUGH __attribute__((fallthrough)) ------------------ 259| 877k| case 0: ------------------ | Branch (259:3): [True: 1.98k, False: 875k] ------------------ 260| 877k| break; 261| 877k| } 262| | 263| 877k| H->v3 ^= b; 264| 877k| sip_round(H, 2); 265| 877k| H->v0 ^= b; 266| 877k| H->v2 ^= 0xff; 267| 877k| sip_round(H, 4); 268| | 269| 877k| return H->v0 ^ H->v1 ^ H->v2 ^ H->v3; 270| 877k|} /* sip24_final() */ xcslen: 45| 937k|xcslen(const XML_Char *s) { 46| |#ifdef XML_UNICODE 47| |# ifdef XML_UNICODE_WCHAR_T 48| | return wcslen(s); 49| |# else 50| | // XML_Char is unsigned short 51| | size_t len = 0; 52| | while (s[len]) { 53| | len++; 54| | } 55| | return len; 56| |# endif 57| |#else 58| 937k| return strlen(s); 59| 937k|#endif 60| 937k|} XML_ParserCreate: 1061| 7.30k|XML_ParserCreate(const XML_Char *encodingName) { 1062| 7.30k| return XML_ParserCreate_MM(encodingName, NULL, NULL); 1063| 7.30k|} XML_ParserCreateNS: 1066| 4.76k|XML_ParserCreateNS(const XML_Char *encodingName, XML_Char nsSep) { 1067| 4.76k| XML_Char tmp[2] = {nsSep, 0}; 1068| | return XML_ParserCreate_MM(encodingName, NULL, tmp); 1069| 4.76k|} XML_ParserCreate_MM: 1294| 12.0k| const XML_Char *nameSep) { 1295| 12.0k| return parserCreate(encodingName, memsuite, nameSep, NULL, NULL); 1296| 12.0k|} XML_ParserFree: 1865| 12.0k|XML_ParserFree(XML_Parser parser) { 1866| 12.0k| TAG *tagList; 1867| 12.0k| if ((parser == NULL) || isCalledFromInsideHandler(parser)) ------------------ | Branch (1867:7): [True: 0, False: 12.0k] | Branch (1867:27): [True: 0, False: 12.0k] ------------------ 1868| 0| return; 1869| | // The application-defined release callback may access the parser, so it 1870| | // must run before any parser state is freed. 1871| 12.0k| if (parser->m_unknownEncodingRelease) ------------------ | Branch (1871:7): [True: 0, False: 12.0k] ------------------ 1872| 0| callUnknownEncodingRelease(parser); 1873| | /* free m_tagStack and m_freeTagList */ 1874| 12.0k| tagList = parser->m_tagStack; 1875| 40.0k| for (;;) { 1876| 40.0k| TAG *p; 1877| 40.0k| if (tagList == NULL) { ------------------ | Branch (1877:9): [True: 12.2k, False: 27.8k] ------------------ 1878| 12.2k| if (parser->m_freeTagList == NULL) ------------------ | Branch (1878:11): [True: 12.0k, False: 184] ------------------ 1879| 12.0k| break; 1880| 184| tagList = parser->m_freeTagList; 1881| 184| parser->m_freeTagList = NULL; 1882| 184| } 1883| 27.9k| p = tagList; 1884| 27.9k| tagList = tagList->parent; 1885| 27.9k| FREE(parser, p->buf.raw); ------------------ | | 837| 27.9k|# define FREE(parser, p) (expat_free((parser), (p), __LINE__)) ------------------ 1886| 27.9k| destroyBindings(p->bindings, parser); 1887| 27.9k| FREE(parser, p); ------------------ | | 837| 27.9k|# define FREE(parser, p) (expat_free((parser), (p), __LINE__)) ------------------ 1888| 27.9k| } 1889| | /* free m_openInternalEntities */ 1890| 12.0k| for (OPEN_INTERNAL_ENTITY *entityList = parser->m_openInternalEntities; 1891| 12.1k| entityList != NULL;) { ------------------ | Branch (1891:8): [True: 115, False: 12.0k] ------------------ 1892| 115| OPEN_INTERNAL_ENTITY *const openEntity = entityList; 1893| 115| entityList = entityList->next; 1894| 115| FREE(parser, openEntity); ------------------ | | 837| 115|# define FREE(parser, p) (expat_free((parser), (p), __LINE__)) ------------------ 1895| 115| } 1896| | /* free m_openAttributeEntities */ 1897| 12.0k| for (OPEN_INTERNAL_ENTITY *entityList = parser->m_openAttributeEntities; 1898| 12.0k| entityList != NULL;) { ------------------ | Branch (1898:8): [True: 22, False: 12.0k] ------------------ 1899| 22| OPEN_INTERNAL_ENTITY *const openEntity = entityList; 1900| 22| entityList = entityList->next; 1901| 22| FREE(parser, openEntity); ------------------ | | 837| 22|# define FREE(parser, p) (expat_free((parser), (p), __LINE__)) ------------------ 1902| 22| } 1903| | /* free m_openValueEntities */ 1904| 12.0k| for (OPEN_INTERNAL_ENTITY *entityList = parser->m_openValueEntities; 1905| 12.0k| entityList != NULL;) { ------------------ | Branch (1905:8): [True: 0, False: 12.0k] ------------------ 1906| 0| OPEN_INTERNAL_ENTITY *const openEntity = entityList; 1907| 0| entityList = entityList->next; 1908| 0| FREE(parser, openEntity); ------------------ | | 837| 0|# define FREE(parser, p) (expat_free((parser), (p), __LINE__)) ------------------ 1909| 0| } 1910| | /* free m_freeEntities */ 1911| 12.0k| for (OPEN_INTERNAL_ENTITY *entityList = parser->m_freeEntities; 1912| 14.0k| entityList != NULL;) { ------------------ | Branch (1912:8): [True: 1.99k, False: 12.0k] ------------------ 1913| 1.99k| OPEN_INTERNAL_ENTITY *const openEntity = entityList; 1914| 1.99k| entityList = entityList->next; 1915| 1.99k| FREE(parser, openEntity); ------------------ | | 837| 1.99k|# define FREE(parser, p) (expat_free((parser), (p), __LINE__)) ------------------ 1916| 1.99k| } 1917| 12.0k| parser->m_freeEntities = NULL; 1918| 12.0k| destroyBindings(parser->m_freeBindingList, parser); 1919| 12.0k| destroyBindings(parser->m_inheritedBindings, parser); 1920| 12.0k| poolDestroy(&parser->m_tempPool); 1921| 12.0k| poolDestroy(&parser->m_temp2Pool); 1922| 12.0k| FREE(parser, (void *)parser->m_protocolEncodingName); ------------------ | | 837| 12.0k|# define FREE(parser, p) (expat_free((parser), (p), __LINE__)) ------------------ 1923| 12.0k|#ifdef XML_DTD 1924| | /* external parameter entity parsers share the DTD structure 1925| | parser->m_dtd with the root parser, so we must not destroy it 1926| | */ 1927| 12.0k| if (! parser->m_isParamEntity && parser->m_dtd) ------------------ | Branch (1927:7): [True: 12.0k, False: 0] | Branch (1927:36): [True: 12.0k, False: 0] ------------------ 1928| |#else 1929| | if (parser->m_dtd) 1930| |#endif /* XML_DTD */ 1931| 12.0k| dtdDestroy(parser->m_dtd, (XML_Bool)! parser->m_parentParser, parser); 1932| 12.0k| FREE(parser, parser->m_atts); ------------------ | | 837| 12.0k|# define FREE(parser, p) (expat_free((parser), (p), __LINE__)) ------------------ 1933| 12.0k| FREE(parser, parser->m_groupConnector); ------------------ | | 837| 12.0k|# define FREE(parser, p) (expat_free((parser), (p), __LINE__)) ------------------ 1934| | // NOTE: We are avoiding FREE(..) here because parser->m_buffer 1935| | // is not being allocated with MALLOC(..) but with plain 1936| | // .malloc_fcn(..). 1937| 12.0k| parser->m_mem.free_fcn(parser->m_buffer); 1938| 12.0k| FREE(parser, parser->m_dataBuf); ------------------ | | 837| 12.0k|# define FREE(parser, p) (expat_free((parser), (p), __LINE__)) ------------------ 1939| 12.0k| FREE(parser, parser->m_nsAtts); ------------------ | | 837| 12.0k|# define FREE(parser, p) (expat_free((parser), (p), __LINE__)) ------------------ 1940| 12.0k| FREE(parser, parser->m_unknownEncodingMem); ------------------ | | 837| 12.0k|# define FREE(parser, p) (expat_free((parser), (p), __LINE__)) ------------------ 1941| 12.0k| FREE(parser, parser); ------------------ | | 837| 12.0k|# define FREE(parser, p) (expat_free((parser), (p), __LINE__)) ------------------ 1942| 12.0k|} XML_Parse: 2301| 12.0k|XML_Parse(XML_Parser parser, const char *s, int len, int isFinal) { 2302| 12.0k| if ((parser == NULL) || (len < 0) || ((s == NULL) && (len != 0))) { ------------------ | Branch (2302:7): [True: 0, False: 12.0k] | Branch (2302:27): [True: 0, False: 12.0k] | Branch (2302:41): [True: 0, False: 12.0k] | Branch (2302:56): [True: 0, False: 0] ------------------ 2303| 0| if (parser != NULL) ------------------ | Branch (2303:9): [True: 0, False: 0] ------------------ 2304| 0| parser->m_errorCode = XML_ERROR_INVALID_ARGUMENT; 2305| 0| return XML_STATUS_ERROR; ------------------ | | 81| 0|# define XML_STATUS_ERROR XML_STATUS_ERROR ------------------ 2306| 0| } 2307| 12.0k| if (isCalledFromInsideHandler(parser)) ------------------ | Branch (2307:7): [True: 0, False: 12.0k] ------------------ 2308| 0| return XML_STATUS_ERROR; ------------------ | | 81| 0|# define XML_STATUS_ERROR XML_STATUS_ERROR ------------------ 2309| 12.0k| switch (parser->m_parsingStatus.parsing) { 2310| 0| case XML_SUSPENDED: ------------------ | Branch (2310:3): [True: 0, False: 12.0k] ------------------ 2311| 0| parser->m_errorCode = XML_ERROR_SUSPENDED; 2312| 0| return XML_STATUS_ERROR; ------------------ | | 81| 0|# define XML_STATUS_ERROR XML_STATUS_ERROR ------------------ 2313| 0| case XML_FINISHED: ------------------ | Branch (2313:3): [True: 0, False: 12.0k] ------------------ 2314| 0| parser->m_errorCode = XML_ERROR_FINISHED; 2315| 0| return XML_STATUS_ERROR; ------------------ | | 81| 0|# define XML_STATUS_ERROR XML_STATUS_ERROR ------------------ 2316| 12.0k| case XML_INITIALIZED: ------------------ | Branch (2316:3): [True: 12.0k, False: 0] ------------------ 2317| 12.0k| if (parser->m_parentParser == NULL && ! startParsing(parser)) { ------------------ | Branch (2317:9): [True: 12.0k, False: 0] | Branch (2317:43): [True: 0, False: 12.0k] ------------------ 2318| 0| parser->m_errorCode = XML_ERROR_NO_MEMORY; 2319| 0| return XML_STATUS_ERROR; ------------------ | | 81| 0|# define XML_STATUS_ERROR XML_STATUS_ERROR ------------------ 2320| 0| } 2321| 12.0k| EXPAT_FALLTHROUGH; ------------------ | | 47| 12.0k|# define EXPAT_FALLTHROUGH __attribute__((fallthrough)) ------------------ 2322| 12.0k| default: ------------------ | Branch (2322:3): [True: 0, False: 12.0k] ------------------ 2323| 12.0k| parser->m_parsingStatus.parsing = XML_PARSING; 2324| 12.0k| } 2325| | 2326| |#if XML_CONTEXT_BYTES == 0 2327| | if (parser->m_bufferPtr == parser->m_bufferEnd) { 2328| | const char *end; 2329| | int nLeftOver; 2330| | enum XML_Status result; 2331| | /* Detect overflow (a+b > MAX <==> b > MAX-a) */ 2332| | if ((uint64_t)len > UINT64_MAX - parser->m_parseEndByteIndex) { 2333| | parser->m_errorCode = XML_ERROR_NO_MEMORY; 2334| | parser->m_eventPtr = parser->m_eventEndPtr = NULL; 2335| | parser->m_processor = errorProcessor; 2336| | return XML_STATUS_ERROR; 2337| | } 2338| | // though this isn't a buffer request, we assume that `len` is the app's 2339| | // preferred buffer fill size, and therefore save it here. 2340| | parser->m_lastBufferRequestSize = len; 2341| | parser->m_parseEndByteIndex += len; 2342| | parser->m_positionPtr = s; 2343| | parser->m_parsingStatus.finalBuffer = (XML_Bool)isFinal; 2344| | 2345| | parser->m_errorCode 2346| | = callProcessor(parser, s, parser->m_parseEndPtr = s + len, &end); 2347| | 2348| | if (parser->m_errorCode != XML_ERROR_NONE) { 2349| | parser->m_eventEndPtr = parser->m_eventPtr; 2350| | parser->m_processor = errorProcessor; 2351| | return XML_STATUS_ERROR; 2352| | } else { 2353| | switch (parser->m_parsingStatus.parsing) { 2354| | case XML_SUSPENDED: 2355| | result = XML_STATUS_SUSPENDED; 2356| | break; 2357| | case XML_INITIALIZED: 2358| | case XML_PARSING: 2359| | if (isFinal) { 2360| | parser->m_parsingStatus.parsing = XML_FINISHED; 2361| | return XML_STATUS_OK; 2362| | } 2363| | EXPAT_FALLTHROUGH; 2364| | default: 2365| | result = XML_STATUS_OK; 2366| | } 2367| | } 2368| | 2369| | XmlUpdatePosition(parser->m_encoding, parser->m_positionPtr, end, 2370| | &parser->m_position); 2371| | nLeftOver = s + len - end; 2372| | if (nLeftOver) { 2373| | // Back up and restore the parsing status to avoid XML_ERROR_SUSPENDED 2374| | // (and XML_ERROR_FINISHED) from XML_GetBuffer. 2375| | const enum XML_Parsing originalStatus = parser->m_parsingStatus.parsing; 2376| | parser->m_parsingStatus.parsing = XML_PARSING; 2377| | void *const temp = XML_GetBuffer(parser, nLeftOver); 2378| | parser->m_parsingStatus.parsing = originalStatus; 2379| | // GetBuffer may have overwritten this, but we want to remember what the 2380| | // app requested, not how many bytes were left over after parsing. 2381| | parser->m_lastBufferRequestSize = len; 2382| | if (temp == NULL) { 2383| | // NOTE: parser->m_errorCode has already been set by XML_GetBuffer(). 2384| | parser->m_eventPtr = parser->m_eventEndPtr = NULL; 2385| | parser->m_processor = errorProcessor; 2386| | return XML_STATUS_ERROR; 2387| | } 2388| | // Since we know that the buffer was empty and XML_CONTEXT_BYTES is 0, we 2389| | // don't have any data to preserve, and can copy straight into the start 2390| | // of the buffer rather than the GetBuffer return pointer (which may be 2391| | // pointing further into the allocated buffer). 2392| | memcpy(parser->m_buffer, end, nLeftOver); 2393| | } 2394| | parser->m_bufferPtr = parser->m_buffer; 2395| | parser->m_bufferEnd = parser->m_buffer + nLeftOver; 2396| | parser->m_positionPtr = parser->m_bufferPtr; 2397| | parser->m_parseEndPtr = parser->m_bufferEnd; 2398| | parser->m_eventPtr = parser->m_bufferPtr; 2399| | parser->m_eventEndPtr = parser->m_bufferPtr; 2400| | return result; 2401| | } 2402| |#endif /* XML_CONTEXT_BYTES == 0 */ 2403| 12.0k| void *buff = XML_GetBuffer(parser, len); 2404| 12.0k| if (buff == NULL) ------------------ | Branch (2404:7): [True: 0, False: 12.0k] ------------------ 2405| 0| return XML_STATUS_ERROR; ------------------ | | 81| 0|# define XML_STATUS_ERROR XML_STATUS_ERROR ------------------ 2406| 12.0k| if (len > 0) { ------------------ | Branch (2406:7): [True: 12.0k, False: 0] ------------------ 2407| 12.0k| assert(s != NULL); // make sure s==NULL && len!=0 was rejected above ------------------ | Branch (2407:5): [True: 0, False: 12.0k] | Branch (2407:5): [True: 12.0k, False: 0] ------------------ 2408| 12.0k| memcpy(buff, s, len); 2409| 12.0k| } 2410| 12.0k| return XML_ParseBuffer(parser, len, isFinal); 2411| 12.0k|} XML_ParseBuffer: 2414| 12.0k|XML_ParseBuffer(XML_Parser parser, int len, int isFinal) { 2415| 12.0k| const char *start; 2416| 12.0k| enum XML_Status result = XML_STATUS_OK; ------------------ | | 83| 12.0k|# define XML_STATUS_OK XML_STATUS_OK ------------------ 2417| | 2418| 12.0k| if ((parser == NULL) || isCalledFromInsideHandler(parser)) ------------------ | Branch (2418:7): [True: 0, False: 12.0k] | Branch (2418:27): [True: 0, False: 12.0k] ------------------ 2419| 0| return XML_STATUS_ERROR; ------------------ | | 81| 0|# define XML_STATUS_ERROR XML_STATUS_ERROR ------------------ 2420| | 2421| 12.0k| if (len < 0) { ------------------ | Branch (2421:7): [True: 0, False: 12.0k] ------------------ 2422| 0| parser->m_errorCode = XML_ERROR_INVALID_ARGUMENT; 2423| 0| return XML_STATUS_ERROR; ------------------ | | 81| 0|# define XML_STATUS_ERROR XML_STATUS_ERROR ------------------ 2424| 0| } 2425| | 2426| 12.0k| switch (parser->m_parsingStatus.parsing) { 2427| 0| case XML_SUSPENDED: ------------------ | Branch (2427:3): [True: 0, False: 12.0k] ------------------ 2428| 0| parser->m_errorCode = XML_ERROR_SUSPENDED; 2429| 0| return XML_STATUS_ERROR; ------------------ | | 81| 0|# define XML_STATUS_ERROR XML_STATUS_ERROR ------------------ 2430| 0| case XML_FINISHED: ------------------ | Branch (2430:3): [True: 0, False: 12.0k] ------------------ 2431| 0| parser->m_errorCode = XML_ERROR_FINISHED; 2432| 0| return XML_STATUS_ERROR; ------------------ | | 81| 0|# define XML_STATUS_ERROR XML_STATUS_ERROR ------------------ 2433| 0| case XML_INITIALIZED: ------------------ | Branch (2433:3): [True: 0, False: 12.0k] ------------------ 2434| | /* Has someone called XML_GetBuffer successfully before? */ 2435| 0| if (! parser->m_bufferPtr) { ------------------ | Branch (2435:9): [True: 0, False: 0] ------------------ 2436| 0| parser->m_errorCode = XML_ERROR_NO_BUFFER; 2437| 0| return XML_STATUS_ERROR; ------------------ | | 81| 0|# define XML_STATUS_ERROR XML_STATUS_ERROR ------------------ 2438| 0| } 2439| | 2440| 0| if (parser->m_parentParser == NULL && ! startParsing(parser)) { ------------------ | Branch (2440:9): [True: 0, False: 0] | Branch (2440:43): [True: 0, False: 0] ------------------ 2441| 0| parser->m_errorCode = XML_ERROR_NO_MEMORY; 2442| 0| return XML_STATUS_ERROR; ------------------ | | 81| 0|# define XML_STATUS_ERROR XML_STATUS_ERROR ------------------ 2443| 0| } 2444| 0| EXPAT_FALLTHROUGH; ------------------ | | 47| 0|# define EXPAT_FALLTHROUGH __attribute__((fallthrough)) ------------------ 2445| 12.0k| default: ------------------ | Branch (2445:3): [True: 12.0k, False: 0] ------------------ 2446| 12.0k| parser->m_parsingStatus.parsing = XML_PARSING; 2447| 12.0k| } 2448| | 2449| 12.0k| if (len > EXPAT_SAFE_PTR_DIFF(parser->m_bufferLim, parser->m_bufferEnd)) { ------------------ | | 229| 12.0k|#define EXPAT_SAFE_PTR_DIFF(p, q) (((p) && (q)) ? ((p) - (q)) : 0) | | ------------------ | | | Branch (229:37): [True: 12.0k, False: 0] | | | Branch (229:44): [True: 12.0k, False: 0] | | ------------------ ------------------ | Branch (2449:7): [True: 0, False: 12.0k] ------------------ 2450| 0| parser->m_errorCode = XML_ERROR_INVALID_ARGUMENT; 2451| 0| return XML_STATUS_ERROR; ------------------ | | 81| 0|# define XML_STATUS_ERROR XML_STATUS_ERROR ------------------ 2452| 0| } 2453| | 2454| | // Detect and avoid integer overflow 2455| 12.0k| if ((uint64_t)len > UINT64_MAX - parser->m_parseEndByteIndex) { ------------------ | Branch (2455:7): [True: 0, False: 12.0k] ------------------ 2456| 0| parser->m_errorCode = XML_ERROR_NO_MEMORY; 2457| 0| parser->m_eventPtr = parser->m_eventEndPtr = NULL; 2458| 0| parser->m_processor = errorProcessor; 2459| 0| return XML_STATUS_ERROR; ------------------ | | 81| 0|# define XML_STATUS_ERROR XML_STATUS_ERROR ------------------ 2460| 0| } 2461| | 2462| 12.0k| start = parser->m_bufferPtr; 2463| 12.0k| parser->m_positionPtr = start; 2464| 12.0k| parser->m_bufferEnd += len; 2465| 12.0k| parser->m_parseEndPtr = parser->m_bufferEnd; 2466| 12.0k| parser->m_parseEndByteIndex += len; 2467| 12.0k| parser->m_parsingStatus.finalBuffer = (XML_Bool)isFinal; 2468| | 2469| 12.0k| parser->m_errorCode = callProcessor(parser, start, parser->m_parseEndPtr, 2470| 12.0k| &parser->m_bufferPtr); 2471| | 2472| 12.0k| if (parser->m_errorCode != XML_ERROR_NONE) { ------------------ | Branch (2472:7): [True: 11.8k, False: 251] ------------------ 2473| 11.8k| parser->m_eventEndPtr = parser->m_eventPtr; 2474| 11.8k| parser->m_processor = errorProcessor; 2475| 11.8k| return XML_STATUS_ERROR; ------------------ | | 81| 11.8k|# define XML_STATUS_ERROR XML_STATUS_ERROR ------------------ 2476| 11.8k| } else { 2477| 251| switch (parser->m_parsingStatus.parsing) { 2478| 0| case XML_SUSPENDED: ------------------ | Branch (2478:5): [True: 0, False: 251] ------------------ 2479| 0| result = XML_STATUS_SUSPENDED; ------------------ | | 85| 0|# define XML_STATUS_SUSPENDED XML_STATUS_SUSPENDED ------------------ 2480| 0| break; 2481| 0| case XML_INITIALIZED: ------------------ | Branch (2481:5): [True: 0, False: 251] ------------------ 2482| 251| case XML_PARSING: ------------------ | Branch (2482:5): [True: 251, False: 0] ------------------ 2483| 251| if (isFinal) { ------------------ | Branch (2483:11): [True: 251, False: 0] ------------------ 2484| 251| parser->m_parsingStatus.parsing = XML_FINISHED; 2485| 251| return result; 2486| 251| } 2487| 0| break; 2488| 0| default:; /* should not happen */ ------------------ | Branch (2488:5): [True: 0, False: 251] ------------------ 2489| 251| } 2490| 251| } 2491| | 2492| 0| XmlUpdatePosition(parser->m_encoding, parser->m_positionPtr, ------------------ | | 269| 0| (((enc)->updatePosition)(enc, ptr, end, pos)) ------------------ 2493| 0| parser->m_bufferPtr, &parser->m_position); 2494| 0| parser->m_positionPtr = parser->m_bufferPtr; 2495| 0| return result; 2496| 12.0k|} XML_GetBuffer: 2522| 12.0k|XML_GetBuffer(XML_Parser parser, int len) { 2523| 12.0k| if ((parser == NULL) || isCalledFromInsideHandler(parser)) ------------------ | Branch (2523:7): [True: 0, False: 12.0k] | Branch (2523:27): [True: 0, False: 12.0k] ------------------ 2524| 0| return NULL; 2525| 12.0k| if (len < 0) { ------------------ | Branch (2525:7): [True: 0, False: 12.0k] ------------------ 2526| 0| parser->m_errorCode = XML_ERROR_NO_MEMORY; 2527| 0| return NULL; 2528| 0| } 2529| 12.0k| switch (parser->m_parsingStatus.parsing) { 2530| 0| case XML_SUSPENDED: ------------------ | Branch (2530:3): [True: 0, False: 12.0k] ------------------ 2531| 0| parser->m_errorCode = XML_ERROR_SUSPENDED; 2532| 0| return NULL; 2533| 0| case XML_FINISHED: ------------------ | Branch (2533:3): [True: 0, False: 12.0k] ------------------ 2534| 0| parser->m_errorCode = XML_ERROR_FINISHED; 2535| 0| return NULL; 2536| 12.0k| default:; ------------------ | Branch (2536:3): [True: 12.0k, False: 0] ------------------ 2537| 12.0k| } 2538| | 2539| | // whether or not the request succeeds, `len` seems to be the app's preferred 2540| | // buffer fill size; remember it. 2541| 12.0k| parser->m_lastBufferRequestSize = len; 2542| 12.0k| if (len > EXPAT_SAFE_PTR_DIFF(parser->m_bufferLim, parser->m_bufferEnd) ------------------ | | 229| 24.1k|#define EXPAT_SAFE_PTR_DIFF(p, q) (((p) && (q)) ? ((p) - (q)) : 0) | | ------------------ | | | Branch (229:37): [True: 0, False: 12.0k] | | | Branch (229:44): [True: 0, False: 0] | | ------------------ ------------------ | Branch (2542:7): [True: 12.0k, False: 0] ------------------ 2543| 12.0k| || parser->m_buffer == NULL) { ------------------ | Branch (2543:10): [True: 0, False: 0] ------------------ 2544| | /* Do not invoke signed arithmetic overflow: */ 2545| 12.0k| int neededSize = (int)((unsigned)len 2546| 12.0k| + (unsigned)EXPAT_SAFE_PTR_DIFF( ------------------ | | 229| 12.0k|#define EXPAT_SAFE_PTR_DIFF(p, q) (((p) && (q)) ? ((p) - (q)) : 0) | | ------------------ | | | Branch (229:37): [True: 0, False: 12.0k] | | | Branch (229:44): [True: 0, False: 0] | | ------------------ ------------------ 2547| 12.0k| parser->m_bufferEnd, parser->m_bufferPtr)); 2548| 12.0k| if (neededSize < 0) { ------------------ | Branch (2548:9): [True: 0, False: 12.0k] ------------------ 2549| 0| parser->m_errorCode = XML_ERROR_NO_MEMORY; 2550| 0| return NULL; 2551| 0| } 2552| 12.0k|#if XML_CONTEXT_BYTES > 0 2553| 12.0k| const int parsed 2554| 12.0k| = (int)EXPAT_SAFE_PTR_DIFF(parser->m_bufferPtr, parser->m_buffer); ------------------ | | 229| 12.0k|#define EXPAT_SAFE_PTR_DIFF(p, q) (((p) && (q)) ? ((p) - (q)) : 0) | | ------------------ | | | Branch (229:37): [True: 0, False: 12.0k] | | | Branch (229:44): [True: 0, False: 0] | | ------------------ ------------------ 2555| 12.0k| int keep = parsed; 2556| 12.0k| if (keep > XML_CONTEXT_BYTES) ------------------ | | 119| 12.0k|#define XML_CONTEXT_BYTES 1024 ------------------ | Branch (2556:9): [True: 0, False: 12.0k] ------------------ 2557| 0| keep = XML_CONTEXT_BYTES; ------------------ | | 119| 0|#define XML_CONTEXT_BYTES 1024 ------------------ 2558| | /* Detect and prevent integer overflow */ 2559| 12.0k| if (keep > INT_MAX - neededSize) { ------------------ | Branch (2559:9): [True: 0, False: 12.0k] ------------------ 2560| 0| parser->m_errorCode = XML_ERROR_NO_MEMORY; 2561| 0| return NULL; 2562| 0| } 2563| |#else 2564| | int keep = 0; 2565| |#endif /* XML_CONTEXT_BYTES > 0 */ 2566| 12.0k| neededSize += keep; 2567| 12.0k| if (parser->m_buffer && parser->m_bufferPtr ------------------ | Branch (2567:9): [True: 0, False: 12.0k] | Branch (2567:29): [True: 0, False: 0] ------------------ 2568| 0| && neededSize ------------------ | Branch (2568:12): [True: 0, False: 0] ------------------ 2569| 0| <= EXPAT_SAFE_PTR_DIFF(parser->m_bufferLim, parser->m_buffer)) { ------------------ | | 229| 0|#define EXPAT_SAFE_PTR_DIFF(p, q) (((p) && (q)) ? ((p) - (q)) : 0) | | ------------------ | | | Branch (229:37): [True: 0, False: 0] | | | Branch (229:44): [True: 0, False: 0] | | ------------------ ------------------ 2570| 0|#if XML_CONTEXT_BYTES > 0 2571| 0| if (keep < parsed) { ------------------ | Branch (2571:11): [True: 0, False: 0] ------------------ 2572| 0| int offset = parsed - keep; 2573| | /* The buffer pointers cannot be NULL here; we have at least some bytes 2574| | * in the buffer */ 2575| 0| memmove(parser->m_buffer, &parser->m_buffer[offset], 2576| 0| parser->m_bufferEnd - parser->m_bufferPtr + keep); 2577| 0| parser->m_bufferEnd -= offset; 2578| 0| parser->m_bufferPtr -= offset; 2579| 0| } 2580| |#else 2581| | memmove(parser->m_buffer, parser->m_bufferPtr, 2582| | EXPAT_SAFE_PTR_DIFF(parser->m_bufferEnd, parser->m_bufferPtr)); 2583| | parser->m_bufferEnd 2584| | = parser->m_buffer 2585| | + EXPAT_SAFE_PTR_DIFF(parser->m_bufferEnd, parser->m_bufferPtr); 2586| | parser->m_bufferPtr = parser->m_buffer; 2587| |#endif /* XML_CONTEXT_BYTES > 0 */ 2588| 12.0k| } else { 2589| 12.0k| int bufferSize 2590| 12.0k| = (int)EXPAT_SAFE_PTR_DIFF(parser->m_bufferLim, parser->m_buffer); ------------------ | | 229| 12.0k|#define EXPAT_SAFE_PTR_DIFF(p, q) (((p) && (q)) ? ((p) - (q)) : 0) | | ------------------ | | | Branch (229:37): [True: 0, False: 12.0k] | | | Branch (229:44): [True: 0, False: 0] | | ------------------ ------------------ 2591| 12.0k| if (bufferSize == 0) ------------------ | Branch (2591:11): [True: 12.0k, False: 0] ------------------ 2592| 12.0k| bufferSize = INIT_BUFFER_SIZE; ------------------ | | 258| 12.0k|#define INIT_BUFFER_SIZE 1024 ------------------ 2593| 12.0k| do { 2594| | /* Do not invoke signed arithmetic overflow: */ 2595| 12.0k| bufferSize = (int)(2U * (unsigned)bufferSize); 2596| 12.0k| } while (bufferSize < neededSize && bufferSize > 0); ------------------ | Branch (2596:16): [True: 0, False: 12.0k] | Branch (2596:43): [True: 0, False: 0] ------------------ 2597| 12.0k| if (bufferSize <= 0) { ------------------ | Branch (2597:11): [True: 0, False: 12.0k] ------------------ 2598| 0| parser->m_errorCode = XML_ERROR_NO_MEMORY; 2599| 0| return NULL; 2600| 0| } 2601| | // NOTE: We are avoiding MALLOC(..) here to leave limiting 2602| | // the input size to the application using Expat. 2603| 12.0k| char *const newBuf = parser->m_mem.malloc_fcn(bufferSize); 2604| 12.0k| if (newBuf == NULL) { ------------------ | Branch (2604:11): [True: 0, False: 12.0k] ------------------ 2605| 0| parser->m_errorCode = XML_ERROR_NO_MEMORY; 2606| 0| return NULL; 2607| 0| } 2608| 12.0k| setParserBuffer(parser, newBuf, bufferSize, keep); 2609| 12.0k| } 2610| 12.0k| parser->m_eventPtr = parser->m_eventEndPtr = NULL; 2611| 12.0k| parser->m_positionPtr = NULL; 2612| 12.0k| } 2613| 12.0k| return parser->m_bufferEnd; 2614| 12.0k|} xmlparse.c:parserCreate: 1301| 12.0k| DTD *dtd, XML_Parser parentParser) { 1302| 12.0k| XML_Parser parser = NULL; 1303| | 1304| 12.0k|#if XML_GE == 1 1305| 12.0k| const size_t increase 1306| 12.0k| = sizeof(size_t) + EXPAT_MALLOC_PADDING + sizeof(struct XML_ParserStruct); ------------------ | | 124| 12.0k|# define EXPAT_MALLOC_PADDING ((EXPAT_MALLOC_ALIGNMENT) - sizeof(size_t)) | | ------------------ | | | | 123| 12.0k|# define EXPAT_MALLOC_ALIGNMENT sizeof(union expat_align) | | ------------------ ------------------ 1307| | 1308| 12.0k| if (parentParser != NULL) { ------------------ | Branch (1308:7): [True: 0, False: 12.0k] ------------------ 1309| 0| const XML_Parser rootParser = getRootParserOf(parentParser, NULL); 1310| 0| if (! expat_heap_increase_tolerable(rootParser, increase, __LINE__)) { ------------------ | Branch (1310:9): [True: 0, False: 0] ------------------ 1311| 0| return NULL; 1312| 0| } 1313| 0| } 1314| |#else 1315| | UNUSED_P(parentParser); 1316| |#endif 1317| | 1318| 12.0k| if (memsuite) { ------------------ | Branch (1318:7): [True: 0, False: 12.0k] ------------------ 1319| 0| XML_Memory_Handling_Suite *mtemp; 1320| 0|#if XML_GE == 1 1321| 0| void *const sizeAndParser 1322| 0| = memsuite->malloc_fcn(sizeof(size_t) + EXPAT_MALLOC_PADDING ------------------ | | 124| 0|# define EXPAT_MALLOC_PADDING ((EXPAT_MALLOC_ALIGNMENT) - sizeof(size_t)) | | ------------------ | | | | 123| 0|# define EXPAT_MALLOC_ALIGNMENT sizeof(union expat_align) | | ------------------ ------------------ 1323| 0| + sizeof(struct XML_ParserStruct)); 1324| 0| if (sizeAndParser != NULL) { ------------------ | Branch (1324:9): [True: 0, False: 0] ------------------ 1325| 0| *(size_t *)sizeAndParser = sizeof(struct XML_ParserStruct); 1326| 0| parser = (XML_Parser)((char *)sizeAndParser + sizeof(size_t) 1327| 0| + EXPAT_MALLOC_PADDING); ------------------ | | 124| 0|# define EXPAT_MALLOC_PADDING ((EXPAT_MALLOC_ALIGNMENT) - sizeof(size_t)) | | ------------------ | | | | 123| 0|# define EXPAT_MALLOC_ALIGNMENT sizeof(union expat_align) | | ------------------ ------------------ 1328| |#else 1329| | parser = memsuite->malloc_fcn(sizeof(struct XML_ParserStruct)); 1330| | if (parser != NULL) { 1331| |#endif 1332| 0| mtemp = (XML_Memory_Handling_Suite *)&(parser->m_mem); 1333| 0| mtemp->malloc_fcn = memsuite->malloc_fcn; 1334| 0| mtemp->realloc_fcn = memsuite->realloc_fcn; 1335| 0| mtemp->free_fcn = memsuite->free_fcn; 1336| 0| } 1337| 12.0k| } else { 1338| 12.0k| XML_Memory_Handling_Suite *mtemp; 1339| 12.0k|#if XML_GE == 1 1340| 12.0k| void *const sizeAndParser = malloc(sizeof(size_t) + EXPAT_MALLOC_PADDING ------------------ | | 124| 12.0k|# define EXPAT_MALLOC_PADDING ((EXPAT_MALLOC_ALIGNMENT) - sizeof(size_t)) | | ------------------ | | | | 123| 12.0k|# define EXPAT_MALLOC_ALIGNMENT sizeof(union expat_align) | | ------------------ ------------------ 1341| 12.0k| + sizeof(struct XML_ParserStruct)); 1342| 12.0k| if (sizeAndParser != NULL) { ------------------ | Branch (1342:9): [True: 12.0k, False: 0] ------------------ 1343| 12.0k| *(size_t *)sizeAndParser = sizeof(struct XML_ParserStruct); 1344| 12.0k| parser = (XML_Parser)((char *)sizeAndParser + sizeof(size_t) 1345| 12.0k| + EXPAT_MALLOC_PADDING); ------------------ | | 124| 12.0k|# define EXPAT_MALLOC_PADDING ((EXPAT_MALLOC_ALIGNMENT) - sizeof(size_t)) | | ------------------ | | | | 123| 12.0k|# define EXPAT_MALLOC_ALIGNMENT sizeof(union expat_align) | | ------------------ ------------------ 1346| |#else 1347| | parser = malloc(sizeof(struct XML_ParserStruct)); 1348| | if (parser != NULL) { 1349| |#endif 1350| 12.0k| mtemp = (XML_Memory_Handling_Suite *)&(parser->m_mem); 1351| 12.0k| mtemp->malloc_fcn = malloc; 1352| 12.0k| mtemp->realloc_fcn = realloc; 1353| 12.0k| mtemp->free_fcn = free; 1354| 12.0k| } 1355| 12.0k| } // cppcheck-suppress[memleak symbolName=sizeAndParser] // Cppcheck >=2.18.0 1356| | 1357| 12.0k| if (! parser) ------------------ | Branch (1357:7): [True: 0, False: 12.0k] ------------------ 1358| 0| return parser; 1359| | 1360| 12.0k|#if XML_GE == 1 1361| | // Initialize .m_alloc_tracker 1362| 12.0k| memset(&parser->m_alloc_tracker, 0, sizeof(MALLOC_TRACKER)); 1363| 12.0k| if (parentParser == NULL) { ------------------ | Branch (1363:7): [True: 12.0k, False: 0] ------------------ 1364| 12.0k| parser->m_alloc_tracker.debugLevel 1365| 12.0k| = getDebugLevel("EXPAT_MALLOC_DEBUG", 0u); 1366| 12.0k| parser->m_alloc_tracker.maximumAmplificationFactor 1367| 12.0k| = EXPAT_ALLOC_TRACKER_MAXIMUM_AMPLIFICATION_DEFAULT; ------------------ | | 113| 12.0k|# define EXPAT_ALLOC_TRACKER_MAXIMUM_AMPLIFICATION_DEFAULT 100.0f ------------------ 1368| 12.0k| parser->m_alloc_tracker.activationThresholdBytes 1369| 12.0k| = EXPAT_ALLOC_TRACKER_ACTIVATION_THRESHOLD_DEFAULT; ------------------ | | 115| 12.0k| 67108864 // 64 MiB, 2^26 ------------------ 1370| | 1371| | // NOTE: This initialization needs to come this early because these fields 1372| | // are read by allocation tracking code 1373| 12.0k| parser->m_parentParser = NULL; 1374| 12.0k| parser->m_accounting.countBytesDirect = 0; 1375| 12.0k| } else { 1376| 0| parser->m_parentParser = parentParser; 1377| 0| } 1378| | 1379| | // Record XML_ParserStruct allocation we did a few lines up before 1380| 12.0k| const XML_Parser rootParser = getRootParserOf(parser, NULL); 1381| 12.0k| assert(rootParser->m_parentParser == NULL); ------------------ | Branch (1381:3): [True: 0, False: 12.0k] | Branch (1381:3): [True: 12.0k, False: 0] ------------------ 1382| 12.0k| assert(SIZE_MAX - rootParser->m_alloc_tracker.bytesAllocated >= increase); ------------------ | Branch (1382:3): [True: 0, False: 12.0k] | Branch (1382:3): [True: 12.0k, False: 0] ------------------ 1383| 12.0k| rootParser->m_alloc_tracker.bytesAllocated += increase; 1384| | 1385| | // Report on allocation 1386| 12.0k| if (rootParser->m_alloc_tracker.debugLevel >= 2) { ------------------ | Branch (1386:7): [True: 0, False: 12.0k] ------------------ 1387| 0| if (rootParser->m_alloc_tracker.bytesAllocated ------------------ | Branch (1387:9): [True: 0, False: 0] ------------------ 1388| 0| > rootParser->m_alloc_tracker.peakBytesAllocated) { 1389| 0| rootParser->m_alloc_tracker.peakBytesAllocated 1390| 0| = rootParser->m_alloc_tracker.bytesAllocated; 1391| 0| } 1392| | 1393| 0| expat_heap_stat(rootParser, '+', increase, 1394| 0| rootParser->m_alloc_tracker.bytesAllocated, 1395| 0| rootParser->m_alloc_tracker.peakBytesAllocated, __LINE__); 1396| 0| } 1397| |#else 1398| | parser->m_parentParser = NULL; 1399| |#endif // XML_GE == 1 1400| | 1401| 12.0k| parser->m_buffer = NULL; 1402| 12.0k| parser->m_bufferLim = NULL; 1403| | 1404| 12.0k| parser->m_attsSize = INIT_ATTS_SIZE; ------------------ | | 255| 12.0k|#define INIT_ATTS_SIZE 16 ------------------ 1405| 12.0k| parser->m_atts = MALLOC(parser, parser->m_attsSize * sizeof(ATTRIBUTE)); ------------------ | | 835| 12.0k|# define MALLOC(parser, s) (expat_malloc((parser), (s), __LINE__)) ------------------ 1406| 12.0k| if (parser->m_atts == NULL) { ------------------ | Branch (1406:7): [True: 0, False: 12.0k] ------------------ 1407| 0| FREE(parser, parser); ------------------ | | 837| 0|# define FREE(parser, p) (expat_free((parser), (p), __LINE__)) ------------------ 1408| 0| return NULL; 1409| 0| } 1410| 12.0k| parser->m_dataBuf = MALLOC(parser, INIT_DATA_BUF_SIZE * sizeof(XML_Char)); ------------------ | | 835| 12.0k|# define MALLOC(parser, s) (expat_malloc((parser), (s), __LINE__)) ------------------ 1411| 12.0k| if (parser->m_dataBuf == NULL) { ------------------ | Branch (1411:7): [True: 0, False: 12.0k] ------------------ 1412| 0| FREE(parser, parser->m_atts); ------------------ | | 837| 0|# define FREE(parser, p) (expat_free((parser), (p), __LINE__)) ------------------ 1413| 0| FREE(parser, parser); ------------------ | | 837| 0|# define FREE(parser, p) (expat_free((parser), (p), __LINE__)) ------------------ 1414| 0| return NULL; 1415| 0| } 1416| 12.0k| parser->m_dataBufEnd = parser->m_dataBuf + INIT_DATA_BUF_SIZE; ------------------ | | 254| 12.0k|#define INIT_DATA_BUF_SIZE 1024 ------------------ 1417| | 1418| 12.0k| if (dtd) ------------------ | Branch (1418:7): [True: 0, False: 12.0k] ------------------ 1419| 0| parser->m_dtd = dtd; 1420| 12.0k| else { 1421| 12.0k| parser->m_dtd = dtdCreate(parser); 1422| 12.0k| if (parser->m_dtd == NULL) { ------------------ | Branch (1422:9): [True: 0, False: 12.0k] ------------------ 1423| 0| FREE(parser, parser->m_dataBuf); ------------------ | | 837| 0|# define FREE(parser, p) (expat_free((parser), (p), __LINE__)) ------------------ 1424| 0| FREE(parser, parser->m_atts); ------------------ | | 837| 0|# define FREE(parser, p) (expat_free((parser), (p), __LINE__)) ------------------ 1425| 0| FREE(parser, parser); ------------------ | | 837| 0|# define FREE(parser, p) (expat_free((parser), (p), __LINE__)) ------------------ 1426| 0| return NULL; 1427| 0| } 1428| 12.0k| } 1429| | 1430| 12.0k| parser->m_freeBindingList = NULL; 1431| 12.0k| parser->m_freeTagList = NULL; 1432| 12.0k| parser->m_freeEntities = NULL; 1433| | 1434| 12.0k| parser->m_groupSize = 0; 1435| 12.0k| parser->m_groupConnector = NULL; 1436| | 1437| 12.0k| parser->m_unknownEncodingHandler = NULL; 1438| 12.0k| parser->m_unknownEncodingHandlerData = NULL; 1439| | 1440| 12.0k| parser->m_namespaceSeparator = ASCII_EXCL; ------------------ | | 105| 12.0k|#define ASCII_EXCL 0x21 ------------------ 1441| 12.0k| parser->m_ns = XML_FALSE; ------------------ | | 64| 12.0k|# define XML_FALSE ((XML_Bool)0) ------------------ 1442| 12.0k| parser->m_ns_triplets = XML_FALSE; ------------------ | | 64| 12.0k|# define XML_FALSE ((XML_Bool)0) ------------------ 1443| | 1444| 12.0k| parser->m_nsAtts = NULL; 1445| 12.0k| parser->m_nsAttsVersion = 0; 1446| 12.0k| parser->m_nsAttsPower = 0; 1447| | 1448| 12.0k| parser->m_protocolEncodingName = NULL; 1449| | 1450| 12.0k| poolInit(&parser->m_tempPool, parser); 1451| 12.0k| poolInit(&parser->m_temp2Pool, parser); 1452| 12.0k| parserInit(parser, encodingName); 1453| | 1454| 12.0k| if (encodingName && ! parser->m_protocolEncodingName) { ------------------ | Branch (1454:7): [True: 12.0k, False: 0] | Branch (1454:23): [True: 0, False: 12.0k] ------------------ 1455| 0| if (dtd) { ------------------ | Branch (1455:9): [True: 0, False: 0] ------------------ 1456| | // We need to stop the upcoming call to XML_ParserFree from happily 1457| | // destroying parser->m_dtd because the DTD is shared with the parent 1458| | // parser and the only guard that keeps XML_ParserFree from destroying 1459| | // parser->m_dtd is parser->m_isParamEntity but it will be set to 1460| | // XML_TRUE only later in XML_ExternalEntityParserCreate (or not at all). 1461| 0| parser->m_dtd = NULL; 1462| 0| } 1463| 0| XML_ParserFree(parser); 1464| 0| return NULL; 1465| 0| } 1466| | 1467| 12.0k| if (nameSep) { ------------------ | Branch (1467:7): [True: 4.76k, False: 7.30k] ------------------ 1468| 4.76k| parser->m_ns = XML_TRUE; ------------------ | | 63| 4.76k|# define XML_TRUE ((XML_Bool)1) ------------------ 1469| 4.76k| parser->m_internalEncoding = XmlGetInternalEncodingNS(); ------------------ | | 192| 4.76k|# define XmlGetInternalEncodingNS XmlGetUtf8InternalEncodingNS ------------------ 1470| 4.76k| parser->m_namespaceSeparator = *nameSep; 1471| 7.30k| } else { 1472| 7.30k| parser->m_internalEncoding = XmlGetInternalEncoding(); ------------------ | | 191| 7.30k|# define XmlGetInternalEncoding XmlGetUtf8InternalEncoding ------------------ 1473| 7.30k| } 1474| | 1475| 12.0k| return parser; 1476| 12.0k|} xmlparse.c:expat_heap_increase_tolerable: 861| 217k| int sourceLine) { 862| 217k| assert(rootParser != NULL); ------------------ | Branch (862:3): [True: 0, False: 217k] | Branch (862:3): [True: 217k, False: 0] ------------------ 863| 217k| assert(increase > 0); ------------------ | Branch (863:3): [True: 0, False: 217k] | Branch (863:3): [True: 217k, False: 0] ------------------ 864| | 865| 217k| size_t newTotal = 0; 866| 217k| bool tolerable = true; 867| | 868| | // Detect integer overflow 869| 217k| if (SIZE_MAX - rootParser->m_alloc_tracker.bytesAllocated < increase) { ------------------ | Branch (869:7): [True: 0, False: 217k] ------------------ 870| 0| tolerable = false; 871| 217k| } else { 872| 217k| newTotal = rootParser->m_alloc_tracker.bytesAllocated + increase; 873| | 874| 217k| if (newTotal >= rootParser->m_alloc_tracker.activationThresholdBytes) { ------------------ | Branch (874:9): [True: 0, False: 217k] ------------------ 875| 0| assert(newTotal > 0); ------------------ | Branch (875:7): [True: 0, False: 0] | Branch (875:7): [True: 0, False: 0] ------------------ 876| | // NOTE: This can be +infinity when dividing by zero but not -nan 877| 0| const float amplification 878| 0| = (float)newTotal / (float)rootParser->m_accounting.countBytesDirect; 879| 0| if (amplification ------------------ | Branch (879:11): [True: 0, False: 0] ------------------ 880| 0| > rootParser->m_alloc_tracker.maximumAmplificationFactor) { 881| 0| tolerable = false; 882| 0| } 883| 0| } 884| 217k| } 885| | 886| 217k| if (! tolerable && (rootParser->m_alloc_tracker.debugLevel >= 1)) { ------------------ | Branch (886:7): [True: 0, False: 217k] | Branch (886:22): [True: 0, False: 0] ------------------ 887| 0| expat_heap_stat(rootParser, '+', increase, newTotal, newTotal, sourceLine); 888| 0| } 889| | 890| 217k| return tolerable; 891| 217k|} xmlparse.c:getDebugLevel: 9689| 48.2k|getDebugLevel(const char *variableName, unsigned long defaultDebugLevel) { 9690| 48.2k| const char *const valueOrNull = getenv(variableName); 9691| 48.2k| if (valueOrNull == NULL) { ------------------ | Branch (9691:7): [True: 48.2k, False: 0] ------------------ 9692| 48.2k| return defaultDebugLevel; 9693| 48.2k| } 9694| 0| const char *const value = valueOrNull; 9695| | 9696| 0| errno = 0; 9697| 0| char *afterValue = NULL; 9698| 0| unsigned long debugLevel = strtoul(value, &afterValue, 10); 9699| 0| if ((errno != 0) || (afterValue == value) || (afterValue[0] != '\0')) { ------------------ | Branch (9699:7): [True: 0, False: 0] | Branch (9699:23): [True: 0, False: 0] | Branch (9699:48): [True: 0, False: 0] ------------------ 9700| 0| errno = 0; 9701| 0| return defaultDebugLevel; 9702| 0| } 9703| | 9704| 0| return debugLevel; 9705| 0|} xmlparse.c:expat_malloc: 898| 214k|expat_malloc(XML_Parser parser, size_t size, int sourceLine) { 899| | // Detect integer overflow 900| 214k| if (SIZE_MAX - size < sizeof(size_t) + EXPAT_MALLOC_PADDING) { ------------------ | | 124| 214k|# define EXPAT_MALLOC_PADDING ((EXPAT_MALLOC_ALIGNMENT) - sizeof(size_t)) | | ------------------ | | | | 123| 214k|# define EXPAT_MALLOC_ALIGNMENT sizeof(union expat_align) | | ------------------ ------------------ | Branch (900:7): [True: 0, False: 214k] ------------------ 901| 0| return NULL; 902| 0| } 903| | 904| 214k| const XML_Parser rootParser = getRootParserOf(parser, NULL); 905| 214k| assert(rootParser->m_parentParser == NULL); ------------------ | Branch (905:3): [True: 0, False: 214k] | Branch (905:3): [True: 214k, False: 0] ------------------ 906| | 907| 214k| const size_t bytesToAllocate = sizeof(size_t) + EXPAT_MALLOC_PADDING + size; ------------------ | | 124| 214k|# define EXPAT_MALLOC_PADDING ((EXPAT_MALLOC_ALIGNMENT) - sizeof(size_t)) | | ------------------ | | | | 123| 214k|# define EXPAT_MALLOC_ALIGNMENT sizeof(union expat_align) | | ------------------ ------------------ 908| | 909| 214k| if (SIZE_MAX - rootParser->m_alloc_tracker.bytesAllocated < bytesToAllocate) { ------------------ | Branch (909:7): [True: 0, False: 214k] ------------------ 910| 0| return NULL; // i.e. signal integer overflow as out-of-memory 911| 0| } 912| | 913| 214k| if (! expat_heap_increase_tolerable(rootParser, bytesToAllocate, ------------------ | Branch (913:7): [True: 0, False: 214k] ------------------ 914| 214k| sourceLine)) { 915| 0| return NULL; // i.e. signal violation as out-of-memory 916| 0| } 917| | 918| | // Actually allocate 919| 214k| void *const mallocedPtr = parser->m_mem.malloc_fcn(bytesToAllocate); 920| | 921| 214k| if (mallocedPtr == NULL) { ------------------ | Branch (921:7): [True: 0, False: 214k] ------------------ 922| 0| return NULL; 923| 0| } 924| | 925| | // Update in-block recorded size 926| 214k| *(size_t *)mallocedPtr = size; 927| | 928| | // Update accounting 929| 214k| rootParser->m_alloc_tracker.bytesAllocated += bytesToAllocate; 930| | 931| | // Report as needed 932| 214k| if (rootParser->m_alloc_tracker.debugLevel >= 2) { ------------------ | Branch (932:7): [True: 0, False: 214k] ------------------ 933| 0| if (rootParser->m_alloc_tracker.bytesAllocated ------------------ | Branch (933:9): [True: 0, False: 0] ------------------ 934| 0| > rootParser->m_alloc_tracker.peakBytesAllocated) { 935| 0| rootParser->m_alloc_tracker.peakBytesAllocated 936| 0| = rootParser->m_alloc_tracker.bytesAllocated; 937| 0| } 938| 0| expat_heap_stat(rootParser, '+', bytesToAllocate, 939| 0| rootParser->m_alloc_tracker.bytesAllocated, 940| 0| rootParser->m_alloc_tracker.peakBytesAllocated, sourceLine); 941| 0| } 942| | 943| 214k| return (char *)mallocedPtr + sizeof(size_t) + EXPAT_MALLOC_PADDING; ------------------ | | 124| 214k|# define EXPAT_MALLOC_PADDING ((EXPAT_MALLOC_ALIGNMENT) - sizeof(size_t)) | | ------------------ | | | | 123| 214k|# define EXPAT_MALLOC_ALIGNMENT sizeof(union expat_align) | | ------------------ ------------------ 944| 214k|} xmlparse.c:dtdCreate: 7864| 12.0k|dtdCreate(XML_Parser parser) { 7865| 12.0k| DTD *p = MALLOC(parser, sizeof(DTD)); ------------------ | | 835| 12.0k|# define MALLOC(parser, s) (expat_malloc((parser), (s), __LINE__)) ------------------ 7866| 12.0k| if (p == NULL) ------------------ | Branch (7866:7): [True: 0, False: 12.0k] ------------------ 7867| 0| return p; 7868| 12.0k| poolInit(&(p->pool), parser); 7869| 12.0k| poolInit(&(p->entityValuePool), parser); 7870| 12.0k| hashTableInit(&(p->generalEntities), parser); 7871| 12.0k| hashTableInit(&(p->elementTypes), parser); 7872| 12.0k| hashTableInit(&(p->attributeIds), parser); 7873| 12.0k| hashTableInit(&(p->prefixes), parser); 7874| 12.0k|#ifdef XML_DTD 7875| 12.0k| p->paramEntityRead = false; 7876| 12.0k| hashTableInit(&(p->paramEntities), parser); 7877| 12.0k|#endif /* XML_DTD */ 7878| 12.0k| p->defaultPrefix.name = NULL; 7879| 12.0k| p->defaultPrefix.binding = NULL; 7880| | 7881| 12.0k| p->in_eldecl = false; 7882| 12.0k| p->scaffIndex = NULL; 7883| 12.0k| p->scaffIndexSize = 0; 7884| 12.0k| p->scaffold = NULL; 7885| 12.0k| p->scaffLevel = 0; 7886| 12.0k| p->scaffSize = 0; 7887| 12.0k| p->scaffCount = 0; 7888| 12.0k| p->contentStringLen = 0; 7889| | 7890| 12.0k| p->keepProcessing = XML_TRUE; ------------------ | | 63| 12.0k|# define XML_TRUE ((XML_Bool)1) ------------------ 7891| 12.0k| p->hasParamEntityRefs = XML_FALSE; ------------------ | | 64| 12.0k|# define XML_FALSE ((XML_Bool)0) ------------------ 7892| 12.0k| p->standalone = XML_FALSE; ------------------ | | 64| 12.0k|# define XML_FALSE ((XML_Bool)0) ------------------ 7893| 12.0k| return p; 7894| 12.0k|} xmlparse.c:hashTableInit: 8379| 75.7k|hashTableInit(HASH_TABLE *p, XML_Parser parser) { 8380| 75.7k| p->power = 0; 8381| 75.7k| p->size = 0; 8382| 75.7k| p->used = 0; 8383| | p->v = NULL; 8384| 75.7k| p->parser = parser; 8385| 75.7k|} xmlparse.c:poolInit: 8404| 48.2k|poolInit(STRING_POOL *pool, XML_Parser parser) { 8405| 48.2k| pool->blocks = NULL; 8406| 48.2k| pool->freeBlocks = NULL; 8407| 48.2k| pool->start = NULL; 8408| 48.2k| pool->ptr = NULL; 8409| | pool->end = NULL; 8410| 48.2k| pool->parser = parser; 8411| 48.2k|} xmlparse.c:isCalledFromInsideHandler: 1187| 48.2k|isCalledFromInsideHandler(XML_Parser parser) { 1188| 48.2k| return parser->m_handlerCallDepth > 0; 1189| 48.2k|} xmlparse.c:expat_free: 951| 1.52M|expat_free(XML_Parser parser, void *ptr, int sourceLine) { 952| 1.52M| assert(parser != NULL); ------------------ | Branch (952:3): [True: 0, False: 1.52M] | Branch (952:3): [True: 1.52M, False: 0] ------------------ 953| | 954| 1.52M| if (ptr == NULL) { ------------------ | Branch (954:7): [True: 1.29M, False: 226k] ------------------ 955| 1.29M| return; 956| 1.29M| } 957| | 958| 226k| const XML_Parser rootParser = getRootParserOf(parser, NULL); 959| 226k| assert(rootParser->m_parentParser == NULL); ------------------ | Branch (959:3): [True: 0, False: 226k] | Branch (959:3): [True: 226k, False: 0] ------------------ 960| | 961| | // Extract size (to the eyes of malloc_fcn/realloc_fcn) and 962| | // the original pointer returned by malloc/realloc 963| 226k| void *const mallocedPtr = (char *)ptr - EXPAT_MALLOC_PADDING - sizeof(size_t); ------------------ | | 124| 226k|# define EXPAT_MALLOC_PADDING ((EXPAT_MALLOC_ALIGNMENT) - sizeof(size_t)) | | ------------------ | | | | 123| 226k|# define EXPAT_MALLOC_ALIGNMENT sizeof(union expat_align) | | ------------------ ------------------ 964| 226k| const size_t bytesAllocated 965| 226k| = sizeof(size_t) + EXPAT_MALLOC_PADDING + *(size_t *)mallocedPtr; ------------------ | | 124| 226k|# define EXPAT_MALLOC_PADDING ((EXPAT_MALLOC_ALIGNMENT) - sizeof(size_t)) | | ------------------ | | | | 123| 226k|# define EXPAT_MALLOC_ALIGNMENT sizeof(union expat_align) | | ------------------ ------------------ 966| | 967| | // Update accounting 968| 226k| assert(rootParser->m_alloc_tracker.bytesAllocated >= bytesAllocated); ------------------ | Branch (968:3): [True: 0, False: 226k] | Branch (968:3): [True: 226k, False: 0] ------------------ 969| 226k| rootParser->m_alloc_tracker.bytesAllocated -= bytesAllocated; 970| | 971| | // Report as needed 972| 226k| if (rootParser->m_alloc_tracker.debugLevel >= 2) { ------------------ | Branch (972:7): [True: 0, False: 226k] ------------------ 973| 0| expat_heap_stat(rootParser, '-', bytesAllocated, 974| 0| rootParser->m_alloc_tracker.bytesAllocated, 975| 0| rootParser->m_alloc_tracker.peakBytesAllocated, sourceLine); 976| 0| } 977| | 978| | // NOTE: This may be freeing rootParser, so freeing has to come last 979| 226k| parser->m_mem.free_fcn(mallocedPtr); 980| 226k|} xmlparse.c:parserInit: 1479| 12.0k|parserInit(XML_Parser parser, const XML_Char *encodingName) { 1480| 12.0k| parser->m_processor = prologInitProcessor; 1481| 12.0k| XmlPrologStateInit(&parser->m_prologState); 1482| 12.0k| if (encodingName != NULL) { ------------------ | Branch (1482:7): [True: 12.0k, False: 0] ------------------ 1483| 12.0k| parser->m_protocolEncodingName = copyString(encodingName, parser); 1484| 12.0k| } 1485| 12.0k| parser->m_curBase = NULL; 1486| 12.0k| XmlInitEncoding(&parser->m_initEncoding, &parser->m_encoding, 0); 1487| 12.0k| parser->m_userData = NULL; 1488| 12.0k| parser->m_handlerArg = NULL; 1489| 12.0k| parser->m_startElementHandler = NULL; 1490| 12.0k| parser->m_endElementHandler = NULL; 1491| 12.0k| parser->m_characterDataHandler = NULL; 1492| 12.0k| parser->m_processingInstructionHandler = NULL; 1493| 12.0k| parser->m_commentHandler = NULL; 1494| 12.0k| parser->m_startCdataSectionHandler = NULL; 1495| 12.0k| parser->m_endCdataSectionHandler = NULL; 1496| 12.0k| parser->m_defaultHandler = NULL; 1497| 12.0k| parser->m_startDoctypeDeclHandler = NULL; 1498| 12.0k| parser->m_endDoctypeDeclHandler = NULL; 1499| 12.0k| parser->m_unparsedEntityDeclHandler = NULL; 1500| 12.0k| parser->m_notationDeclHandler = NULL; 1501| 12.0k| parser->m_startNamespaceDeclHandler = NULL; 1502| 12.0k| parser->m_endNamespaceDeclHandler = NULL; 1503| 12.0k| parser->m_notStandaloneHandler = NULL; 1504| 12.0k| parser->m_externalEntityRefHandler = NULL; 1505| 12.0k| parser->m_externalEntityRefHandlerArg = parser; 1506| 12.0k| parser->m_skippedEntityHandler = NULL; 1507| 12.0k| parser->m_elementDeclHandler = NULL; 1508| 12.0k| parser->m_attlistDeclHandler = NULL; 1509| 12.0k| parser->m_entityDeclHandler = NULL; 1510| 12.0k| parser->m_xmlDeclHandler = NULL; 1511| 12.0k| parser->m_bufferPtr = parser->m_buffer; 1512| 12.0k| parser->m_bufferEnd = parser->m_buffer; 1513| 12.0k| parser->m_parseEndByteIndex = 0; 1514| 12.0k| parser->m_parseEndPtr = NULL; 1515| 12.0k| parser->m_partialTokenBytesBefore = 0; 1516| 12.0k| parser->m_reparseDeferralEnabled = g_reparseDeferralEnabledDefault; 1517| 12.0k| parser->m_lastBufferRequestSize = 0; 1518| 12.0k| parser->m_declElementType = NULL; 1519| 12.0k| parser->m_declAttributeId = NULL; 1520| 12.0k| parser->m_declEntity = NULL; 1521| 12.0k| parser->m_doctypeName = NULL; 1522| 12.0k| parser->m_doctypeSysid = NULL; 1523| 12.0k| parser->m_doctypePubid = NULL; 1524| 12.0k| parser->m_declAttributeType = NULL; 1525| 12.0k| parser->m_declNotationName = NULL; 1526| 12.0k| parser->m_declNotationPublicId = NULL; 1527| 12.0k| parser->m_declAttributeIsCdata = false; 1528| 12.0k| parser->m_declAttributeIsId = false; 1529| 12.0k| memset(&parser->m_position, 0, sizeof(POSITION)); 1530| 12.0k| parser->m_errorCode = XML_ERROR_NONE; 1531| 12.0k| parser->m_eventPtr = NULL; 1532| 12.0k| parser->m_eventEndPtr = NULL; 1533| 12.0k| parser->m_positionPtr = NULL; 1534| 12.0k| parser->m_openInternalEntities = NULL; 1535| 12.0k| parser->m_openAttributeEntities = NULL; 1536| 12.0k| parser->m_openValueEntities = NULL; 1537| 12.0k| parser->m_defaultExpandInternalEntities = XML_TRUE; ------------------ | | 63| 12.0k|# define XML_TRUE ((XML_Bool)1) ------------------ 1538| 12.0k| parser->m_tagLevel = 0; 1539| 12.0k| parser->m_tagStack = NULL; 1540| 12.0k| parser->m_inheritedBindings = NULL; 1541| 12.0k| parser->m_nSpecifiedAtts = 0; 1542| 12.0k| parser->m_unknownEncodingMem = NULL; 1543| 12.0k| parser->m_unknownEncodingConvert = NULL; 1544| 12.0k| parser->m_unknownEncodingRelease = NULL; 1545| 12.0k| parser->m_unknownEncodingData = NULL; 1546| 12.0k| parser->m_parsingStatus.parsing = XML_INITIALIZED; 1547| | // Reentry can only be triggered inside m_processor calls 1548| 12.0k| parser->m_reenter = XML_FALSE; ------------------ | | 64| 12.0k|# define XML_FALSE ((XML_Bool)0) ------------------ 1549| 12.0k| parser->m_handlerCallDepth = 0; 1550| 12.0k|#ifdef XML_DTD 1551| 12.0k| parser->m_isParamEntity = XML_FALSE; ------------------ | | 64| 12.0k|# define XML_FALSE ((XML_Bool)0) ------------------ 1552| 12.0k| parser->m_useForeignDTD = XML_FALSE; ------------------ | | 64| 12.0k|# define XML_FALSE ((XML_Bool)0) ------------------ 1553| 12.0k| parser->m_paramEntityParsing = XML_PARAM_ENTITY_PARSING_NEVER; 1554| 12.0k|#endif 1555| 12.0k| parser->m_hash_secret_salt_128.k[0] = 0; 1556| 12.0k| parser->m_hash_secret_salt_128.k[1] = 0; 1557| 12.0k| parser->m_hash_secret_salt_set = XML_FALSE; ------------------ | | 64| 12.0k|# define XML_FALSE ((XML_Bool)0) ------------------ 1558| | 1559| 12.0k|#if XML_GE == 1 1560| 12.0k| memset(&parser->m_accounting, 0, sizeof(ACCOUNTING)); 1561| 12.0k| parser->m_accounting.debugLevel = getDebugLevel("EXPAT_ACCOUNTING_DEBUG", 0u); 1562| 12.0k| parser->m_accounting.maximumAmplificationFactor 1563| 12.0k| = EXPAT_BILLION_LAUGHS_ATTACK_PROTECTION_MAXIMUM_AMPLIFICATION_DEFAULT; ------------------ | | 109| 12.0k| 100.0f ------------------ 1564| 12.0k| parser->m_accounting.activationThresholdBytes 1565| 12.0k| = EXPAT_BILLION_LAUGHS_ATTACK_PROTECTION_ACTIVATION_THRESHOLD_DEFAULT; ------------------ | | 111| 12.0k| 8388608 // 8 MiB, 2^23 ------------------ 1566| | 1567| 12.0k| memset(&parser->m_entity_stats, 0, sizeof(ENTITY_STATS)); 1568| 12.0k| parser->m_entity_stats.debugLevel = getDebugLevel("EXPAT_ENTITY_DEBUG", 0u); 1569| 12.0k|#endif 1570| 12.0k|} xmlparse.c:prologInitProcessor: 5266| 12.0k| const char **nextPtr) { 5267| 12.0k| enum XML_Error result = initializeEncoding(parser); 5268| 12.0k| if (result != XML_ERROR_NONE) ------------------ | Branch (5268:7): [True: 2, False: 12.0k] ------------------ 5269| 2| return result; 5270| 12.0k| parser->m_processor = prologProcessor; 5271| 12.0k| return prologProcessor(parser, s, end, nextPtr); 5272| 12.0k|} xmlparse.c:initializeEncoding: 5095| 12.0k|initializeEncoding(XML_Parser parser) { 5096| 12.0k| const char *s; 5097| |#ifdef XML_UNICODE 5098| | char encodingBuf[128]; 5099| | /* See comments about `protocolEncodingName` in parserInit() */ 5100| | if (! parser->m_protocolEncodingName) 5101| | s = NULL; 5102| | else { 5103| | int i; 5104| | for (i = 0; parser->m_protocolEncodingName[i]; i++) { 5105| | if (i == sizeof(encodingBuf) - 1 5106| | || (parser->m_protocolEncodingName[i] & ~0x7f) != 0) { 5107| | encodingBuf[0] = '\0'; 5108| | break; 5109| | } 5110| | encodingBuf[i] = (char)parser->m_protocolEncodingName[i]; 5111| | } 5112| | encodingBuf[i] = '\0'; 5113| | s = encodingBuf; 5114| | } 5115| |#else 5116| 12.0k| s = parser->m_protocolEncodingName; 5117| 12.0k|#endif 5118| 12.0k| if ((parser->m_ns ? XmlInitEncodingNS : XmlInitEncoding)( ------------------ | Branch (5118:7): [True: 12.0k, False: 2] | Branch (5118:8): [True: 4.76k, False: 7.30k] ------------------ 5119| 12.0k| &parser->m_initEncoding, &parser->m_encoding, s)) 5120| 12.0k| return XML_ERROR_NONE; 5121| 2| return handleUnknownEncoding(parser, parser->m_protocolEncodingName); 5122| 12.0k|} xmlparse.c:handleUnknownEncoding: 5219| 2|handleUnknownEncoding(XML_Parser parser, const XML_Char *encodingName) { 5220| 2| if (parser->m_unknownEncodingHandler) { ------------------ | Branch (5220:7): [True: 0, False: 2] ------------------ 5221| 0| XML_Encoding info; 5222| 0| int i; 5223| 0| for (i = 0; i < 256; i++) ------------------ | Branch (5223:17): [True: 0, False: 0] ------------------ 5224| 0| info.map[i] = -1; 5225| 0| info.convert = NULL; 5226| 0| info.data = NULL; 5227| 0| info.release = NULL; 5228| 0| beforeHandler(parser); 5229| 0| const int status = parser->m_unknownEncodingHandler( 5230| 0| parser->m_unknownEncodingHandlerData, encodingName, &info); 5231| 0| afterHandler(parser); 5232| | 5233| 0| parser->m_unknownEncodingRelease = info.release; 5234| 0| parser->m_unknownEncodingData = info.data; 5235| | 5236| 0| if (status) { ------------------ | Branch (5236:9): [True: 0, False: 0] ------------------ 5237| 0| ENCODING *enc; 5238| 0| parser->m_unknownEncodingMem = MALLOC(parser, XmlSizeOfUnknownEncoding()); ------------------ | | 835| 0|# define MALLOC(parser, s) (expat_malloc((parser), (s), __LINE__)) ------------------ 5239| 0| if (! parser->m_unknownEncodingMem) { ------------------ | Branch (5239:11): [True: 0, False: 0] ------------------ 5240| 0| if (parser->m_unknownEncodingRelease) ------------------ | Branch (5240:13): [True: 0, False: 0] ------------------ 5241| 0| callUnknownEncodingRelease(parser); 5242| 0| else 5243| 0| parser->m_unknownEncodingData = NULL; 5244| 0| return XML_ERROR_NO_MEMORY; 5245| 0| } 5246| 0| parser->m_unknownEncodingConvert = info.convert; 5247| 0| enc = (parser->m_ns ? XmlInitUnknownEncodingNS : XmlInitUnknownEncoding)( ------------------ | Branch (5247:14): [True: 0, False: 0] ------------------ 5248| 0| parser->m_unknownEncodingMem, info.map, 5249| 0| info.convert ? callUnknownEncodingConvert : NULL, parser); ------------------ | Branch (5249:11): [True: 0, False: 0] ------------------ 5250| 0| if (enc) { ------------------ | Branch (5250:11): [True: 0, False: 0] ------------------ 5251| 0| parser->m_encoding = enc; 5252| 0| return XML_ERROR_NONE; 5253| 0| } 5254| 0| parser->m_unknownEncodingConvert = NULL; 5255| 0| } 5256| 0| if (parser->m_unknownEncodingRelease != NULL) ------------------ | Branch (5256:9): [True: 0, False: 0] ------------------ 5257| 0| callUnknownEncodingRelease(parser); 5258| 0| else 5259| 0| parser->m_unknownEncodingData = NULL; 5260| 0| } 5261| 2| return XML_ERROR_UNKNOWN_ENCODING; 5262| 2|} xmlparse.c:prologProcessor: 5475| 12.0k| const char **nextPtr) { 5476| 12.0k| const char *next = s; 5477| 12.0k| int tok = XmlPrologTok(parser->m_encoding, s, end, &next); ------------------ | | 226| 12.0k| XmlTok(enc, XML_PROLOG_STATE, ptr, end, nextTokPtr) | | ------------------ | | | | 223| 12.0k| (((enc)->scanners[state])(enc, ptr, end, nextTokPtr)) | | ------------------ ------------------ 5478| 12.0k| return doProlog(parser, parser->m_encoding, s, end, tok, next, nextPtr, 5479| 12.0k| (XML_Bool)! parser->m_parsingStatus.finalBuffer, XML_TRUE, ------------------ | | 63| 12.0k|# define XML_TRUE ((XML_Bool)1) ------------------ 5480| 12.0k| XML_ACCOUNT_DIRECT); 5481| 12.0k|} xmlparse.c:doProlog: 5486| 12.0k| XML_Bool allowClosingDoctype, enum XML_Account account) { 5487| 12.0k|#ifdef XML_DTD 5488| 12.0k| static const XML_Char externalSubsetName[] = {ASCII_HASH, '\0'}; ------------------ | | 123| 12.0k|#define ASCII_HASH 0x23 ------------------ 5489| 12.0k|#endif /* XML_DTD */ 5490| 12.0k| static const XML_Char atypeCDATA[] 5491| 12.0k| = {ASCII_C, ASCII_D, ASCII_A, ASCII_T, ASCII_A, '\0'}; ------------------ | | 40| 12.0k|#define ASCII_C 0x43 ------------------ = {ASCII_C, ASCII_D, ASCII_A, ASCII_T, ASCII_A, '\0'}; ------------------ | | 41| 12.0k|#define ASCII_D 0x44 ------------------ = {ASCII_C, ASCII_D, ASCII_A, ASCII_T, ASCII_A, '\0'}; ------------------ | | 38| 12.0k|#define ASCII_A 0x41 ------------------ = {ASCII_C, ASCII_D, ASCII_A, ASCII_T, ASCII_A, '\0'}; ------------------ | | 57| 12.0k|#define ASCII_T 0x54 ------------------ = {ASCII_C, ASCII_D, ASCII_A, ASCII_T, ASCII_A, '\0'}; ------------------ | | 38| 12.0k|#define ASCII_A 0x41 ------------------ 5492| 12.0k| static const XML_Char atypeID[] = {ASCII_I, ASCII_D, '\0'}; ------------------ | | 46| 12.0k|#define ASCII_I 0x49 ------------------ static const XML_Char atypeID[] = {ASCII_I, ASCII_D, '\0'}; ------------------ | | 41| 12.0k|#define ASCII_D 0x44 ------------------ 5493| 12.0k| static const XML_Char atypeIDREF[] 5494| 12.0k| = {ASCII_I, ASCII_D, ASCII_R, ASCII_E, ASCII_F, '\0'}; ------------------ | | 46| 12.0k|#define ASCII_I 0x49 ------------------ = {ASCII_I, ASCII_D, ASCII_R, ASCII_E, ASCII_F, '\0'}; ------------------ | | 41| 12.0k|#define ASCII_D 0x44 ------------------ = {ASCII_I, ASCII_D, ASCII_R, ASCII_E, ASCII_F, '\0'}; ------------------ | | 55| 12.0k|#define ASCII_R 0x52 ------------------ = {ASCII_I, ASCII_D, ASCII_R, ASCII_E, ASCII_F, '\0'}; ------------------ | | 42| 12.0k|#define ASCII_E 0x45 ------------------ = {ASCII_I, ASCII_D, ASCII_R, ASCII_E, ASCII_F, '\0'}; ------------------ | | 43| 12.0k|#define ASCII_F 0x46 ------------------ 5495| 12.0k| static const XML_Char atypeIDREFS[] 5496| 12.0k| = {ASCII_I, ASCII_D, ASCII_R, ASCII_E, ASCII_F, ASCII_S, '\0'}; ------------------ | | 46| 12.0k|#define ASCII_I 0x49 ------------------ = {ASCII_I, ASCII_D, ASCII_R, ASCII_E, ASCII_F, ASCII_S, '\0'}; ------------------ | | 41| 12.0k|#define ASCII_D 0x44 ------------------ = {ASCII_I, ASCII_D, ASCII_R, ASCII_E, ASCII_F, ASCII_S, '\0'}; ------------------ | | 55| 12.0k|#define ASCII_R 0x52 ------------------ = {ASCII_I, ASCII_D, ASCII_R, ASCII_E, ASCII_F, ASCII_S, '\0'}; ------------------ | | 42| 12.0k|#define ASCII_E 0x45 ------------------ = {ASCII_I, ASCII_D, ASCII_R, ASCII_E, ASCII_F, ASCII_S, '\0'}; ------------------ | | 43| 12.0k|#define ASCII_F 0x46 ------------------ = {ASCII_I, ASCII_D, ASCII_R, ASCII_E, ASCII_F, ASCII_S, '\0'}; ------------------ | | 56| 12.0k|#define ASCII_S 0x53 ------------------ 5497| 12.0k| static const XML_Char atypeENTITY[] 5498| 12.0k| = {ASCII_E, ASCII_N, ASCII_T, ASCII_I, ASCII_T, ASCII_Y, '\0'}; ------------------ | | 42| 12.0k|#define ASCII_E 0x45 ------------------ = {ASCII_E, ASCII_N, ASCII_T, ASCII_I, ASCII_T, ASCII_Y, '\0'}; ------------------ | | 51| 12.0k|#define ASCII_N 0x4E ------------------ = {ASCII_E, ASCII_N, ASCII_T, ASCII_I, ASCII_T, ASCII_Y, '\0'}; ------------------ | | 57| 12.0k|#define ASCII_T 0x54 ------------------ = {ASCII_E, ASCII_N, ASCII_T, ASCII_I, ASCII_T, ASCII_Y, '\0'}; ------------------ | | 46| 12.0k|#define ASCII_I 0x49 ------------------ = {ASCII_E, ASCII_N, ASCII_T, ASCII_I, ASCII_T, ASCII_Y, '\0'}; ------------------ | | 57| 12.0k|#define ASCII_T 0x54 ------------------ = {ASCII_E, ASCII_N, ASCII_T, ASCII_I, ASCII_T, ASCII_Y, '\0'}; ------------------ | | 62| 12.0k|#define ASCII_Y 0x59 ------------------ 5499| 12.0k| static const XML_Char atypeENTITIES[] 5500| 12.0k| = {ASCII_E, ASCII_N, ASCII_T, ASCII_I, ASCII_T, ------------------ | | 42| 12.0k|#define ASCII_E 0x45 ------------------ = {ASCII_E, ASCII_N, ASCII_T, ASCII_I, ASCII_T, ------------------ | | 51| 12.0k|#define ASCII_N 0x4E ------------------ = {ASCII_E, ASCII_N, ASCII_T, ASCII_I, ASCII_T, ------------------ | | 57| 12.0k|#define ASCII_T 0x54 ------------------ = {ASCII_E, ASCII_N, ASCII_T, ASCII_I, ASCII_T, ------------------ | | 46| 12.0k|#define ASCII_I 0x49 ------------------ = {ASCII_E, ASCII_N, ASCII_T, ASCII_I, ASCII_T, ------------------ | | 57| 12.0k|#define ASCII_T 0x54 ------------------ 5501| 12.0k| ASCII_I, ASCII_E, ASCII_S, '\0'}; ------------------ | | 46| 12.0k|#define ASCII_I 0x49 ------------------ ASCII_I, ASCII_E, ASCII_S, '\0'}; ------------------ | | 42| 12.0k|#define ASCII_E 0x45 ------------------ ASCII_I, ASCII_E, ASCII_S, '\0'}; ------------------ | | 56| 12.0k|#define ASCII_S 0x53 ------------------ 5502| 12.0k| static const XML_Char atypeNMTOKEN[] 5503| 12.0k| = {ASCII_N, ASCII_M, ASCII_T, ASCII_O, ASCII_K, ASCII_E, ASCII_N, '\0'}; ------------------ | | 51| 12.0k|#define ASCII_N 0x4E ------------------ = {ASCII_N, ASCII_M, ASCII_T, ASCII_O, ASCII_K, ASCII_E, ASCII_N, '\0'}; ------------------ | | 50| 12.0k|#define ASCII_M 0x4D ------------------ = {ASCII_N, ASCII_M, ASCII_T, ASCII_O, ASCII_K, ASCII_E, ASCII_N, '\0'}; ------------------ | | 57| 12.0k|#define ASCII_T 0x54 ------------------ = {ASCII_N, ASCII_M, ASCII_T, ASCII_O, ASCII_K, ASCII_E, ASCII_N, '\0'}; ------------------ | | 52| 12.0k|#define ASCII_O 0x4F ------------------ = {ASCII_N, ASCII_M, ASCII_T, ASCII_O, ASCII_K, ASCII_E, ASCII_N, '\0'}; ------------------ | | 48| 12.0k|#define ASCII_K 0x4B ------------------ = {ASCII_N, ASCII_M, ASCII_T, ASCII_O, ASCII_K, ASCII_E, ASCII_N, '\0'}; ------------------ | | 42| 12.0k|#define ASCII_E 0x45 ------------------ = {ASCII_N, ASCII_M, ASCII_T, ASCII_O, ASCII_K, ASCII_E, ASCII_N, '\0'}; ------------------ | | 51| 12.0k|#define ASCII_N 0x4E ------------------ 5504| 12.0k| static const XML_Char atypeNMTOKENS[] 5505| 12.0k| = {ASCII_N, ASCII_M, ASCII_T, ASCII_O, ASCII_K, ------------------ | | 51| 12.0k|#define ASCII_N 0x4E ------------------ = {ASCII_N, ASCII_M, ASCII_T, ASCII_O, ASCII_K, ------------------ | | 50| 12.0k|#define ASCII_M 0x4D ------------------ = {ASCII_N, ASCII_M, ASCII_T, ASCII_O, ASCII_K, ------------------ | | 57| 12.0k|#define ASCII_T 0x54 ------------------ = {ASCII_N, ASCII_M, ASCII_T, ASCII_O, ASCII_K, ------------------ | | 52| 12.0k|#define ASCII_O 0x4F ------------------ = {ASCII_N, ASCII_M, ASCII_T, ASCII_O, ASCII_K, ------------------ | | 48| 12.0k|#define ASCII_K 0x4B ------------------ 5506| 12.0k| ASCII_E, ASCII_N, ASCII_S, '\0'}; ------------------ | | 42| 12.0k|#define ASCII_E 0x45 ------------------ ASCII_E, ASCII_N, ASCII_S, '\0'}; ------------------ | | 51| 12.0k|#define ASCII_N 0x4E ------------------ ASCII_E, ASCII_N, ASCII_S, '\0'}; ------------------ | | 56| 12.0k|#define ASCII_S 0x53 ------------------ 5507| 12.0k| static const XML_Char notationPrefix[] 5508| 12.0k| = {ASCII_N, ASCII_O, ASCII_T, ASCII_A, ASCII_T, ------------------ | | 51| 12.0k|#define ASCII_N 0x4E ------------------ = {ASCII_N, ASCII_O, ASCII_T, ASCII_A, ASCII_T, ------------------ | | 52| 12.0k|#define ASCII_O 0x4F ------------------ = {ASCII_N, ASCII_O, ASCII_T, ASCII_A, ASCII_T, ------------------ | | 57| 12.0k|#define ASCII_T 0x54 ------------------ = {ASCII_N, ASCII_O, ASCII_T, ASCII_A, ASCII_T, ------------------ | | 38| 12.0k|#define ASCII_A 0x41 ------------------ = {ASCII_N, ASCII_O, ASCII_T, ASCII_A, ASCII_T, ------------------ | | 57| 12.0k|#define ASCII_T 0x54 ------------------ 5509| 12.0k| ASCII_I, ASCII_O, ASCII_N, ASCII_LPAREN, '\0'}; ------------------ | | 46| 12.0k|#define ASCII_I 0x49 ------------------ ASCII_I, ASCII_O, ASCII_N, ASCII_LPAREN, '\0'}; ------------------ | | 52| 12.0k|#define ASCII_O 0x4F ------------------ ASCII_I, ASCII_O, ASCII_N, ASCII_LPAREN, '\0'}; ------------------ | | 51| 12.0k|#define ASCII_N 0x4E ------------------ ASCII_I, ASCII_O, ASCII_N, ASCII_LPAREN, '\0'}; ------------------ | | 119| 12.0k|#define ASCII_LPAREN 0x28 ------------------ 5510| 12.0k| static const XML_Char enumValueSep[] = {ASCII_PIPE, '\0'}; ------------------ | | 124| 12.0k|#define ASCII_PIPE 0x7C ------------------ 5511| 12.0k| static const XML_Char enumValueStart[] = {ASCII_LPAREN, '\0'}; ------------------ | | 119| 12.0k|#define ASCII_LPAREN 0x28 ------------------ 5512| | 5513| |#ifndef XML_DTD 5514| | UNUSED_P(account); 5515| |#endif 5516| | 5517| | /* save one level of indirection */ 5518| 12.0k| DTD *const dtd = parser->m_dtd; 5519| | 5520| 12.0k| const char **eventPP; 5521| 12.0k| const char **eventEndPP; 5522| 12.0k| enum XML_Content_Quant quant; 5523| | 5524| 12.0k| if (enc == parser->m_encoding) { ------------------ | Branch (5524:7): [True: 12.0k, False: 0] ------------------ 5525| 12.0k| eventPP = &parser->m_eventPtr; 5526| 12.0k| eventEndPP = &parser->m_eventEndPtr; 5527| 12.0k| } else { 5528| 0| eventPP = &(parser->m_openInternalEntities->internalEventPtr); 5529| 0| eventEndPP = &(parser->m_openInternalEntities->internalEventEndPtr); 5530| 0| } 5531| | 5532| 163k| for (;;) { 5533| 163k| int role; 5534| 163k| XML_Bool handleDefault = XML_TRUE; ------------------ | | 63| 163k|# define XML_TRUE ((XML_Bool)1) ------------------ 5535| 163k| *eventPP = s; 5536| 163k| *eventEndPP = next; 5537| 163k| if (tok <= 0) { ------------------ | Branch (5537:9): [True: 2.45k, False: 161k] ------------------ 5538| 2.45k| if (haveMore && tok != XML_TOK_INVALID) { ------------------ | | 57| 0|# define XML_TOK_INVALID 0 ------------------ | Branch (5538:11): [True: 0, False: 2.45k] | Branch (5538:23): [True: 0, False: 0] ------------------ 5539| 0| *nextPtr = s; 5540| 0| return XML_ERROR_NONE; 5541| 0| } 5542| 2.45k| switch (tok) { 5543| 1.94k| case XML_TOK_INVALID: ------------------ | | 57| 1.94k|# define XML_TOK_INVALID 0 ------------------ | Branch (5543:7): [True: 1.94k, False: 509] ------------------ 5544| 1.94k| *eventPP = next; 5545| 1.94k| return XML_ERROR_INVALID_TOKEN; 5546| 477| case XML_TOK_PARTIAL: ------------------ | | 56| 477|# define XML_TOK_PARTIAL -1 /* only part of a token */ ------------------ | Branch (5546:7): [True: 477, False: 1.98k] ------------------ 5547| 477| return XML_ERROR_UNCLOSED_TOKEN; 5548| 17| case XML_TOK_PARTIAL_CHAR: ------------------ | | 55| 17|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ ------------------ | Branch (5548:7): [True: 17, False: 2.44k] ------------------ 5549| 17| return XML_ERROR_PARTIAL_CHAR; 5550| 2| case -XML_TOK_PROLOG_S: ------------------ | | 82| 2|# define XML_TOK_PROLOG_S 15 ------------------ | Branch (5550:7): [True: 2, False: 2.45k] ------------------ 5551| 2| tok = -tok; 5552| 2| break; 5553| 5| case XML_TOK_NONE: ------------------ | | 51| 5|# define XML_TOK_NONE -4 /* The string to be scanned is empty */ ------------------ | Branch (5553:7): [True: 5, False: 2.45k] ------------------ 5554| 5|#ifdef XML_DTD 5555| | /* for internal PE NOT referenced between declarations */ 5556| 5| if (enc != parser->m_encoding ------------------ | Branch (5556:13): [True: 0, False: 5] ------------------ 5557| 0| && ! parser->m_openInternalEntities->betweenDecl) { ------------------ | Branch (5557:16): [True: 0, False: 0] ------------------ 5558| 0| *nextPtr = s; 5559| 0| return XML_ERROR_NONE; 5560| 0| } 5561| | /* WFC: PE Between Declarations - must check that PE contains 5562| | complete markup, not only for external PEs, but also for 5563| | internal PEs if the reference occurs between declarations. 5564| | */ 5565| 5| if (parser->m_isParamEntity || enc != parser->m_encoding) { ------------------ | Branch (5565:13): [True: 0, False: 5] | Branch (5565:40): [True: 0, False: 5] ------------------ 5566| 0| if (XmlTokenRole(&parser->m_prologState, XML_TOK_NONE, end, end, enc) ------------------ | | 128| 0| (((state)->handler)(state, tok, ptr, end, enc)) ------------------ | Branch (5566:15): [True: 0, False: 0] ------------------ 5567| 0| == XML_ROLE_ERROR) 5568| 0| return XML_ERROR_INCOMPLETE_PE; 5569| 0| *nextPtr = s; 5570| 0| return XML_ERROR_NONE; 5571| 0| } 5572| 5|#endif /* XML_DTD */ 5573| 5| return XML_ERROR_NO_ELEMENTS; 5574| 8| default: ------------------ | Branch (5574:7): [True: 8, False: 2.44k] ------------------ 5575| 8| tok = -tok; 5576| 8| next = end; 5577| 8| break; 5578| 2.45k| } 5579| 2.45k| } 5580| 161k| role = XmlTokenRole(&parser->m_prologState, tok, s, next, enc); ------------------ | | 128| 161k| (((state)->handler)(state, tok, ptr, end, enc)) ------------------ 5581| 161k|#if XML_GE == 1 5582| 161k| switch (role) { 5583| 7.68k| case XML_ROLE_INSTANCE_START: // bytes accounted in contentProcessor ------------------ | Branch (5583:5): [True: 7.68k, False: 153k] ------------------ 5584| 8.16k| case XML_ROLE_XML_DECL: // bytes accounted in processXmlDecl ------------------ | Branch (5584:5): [True: 481, False: 160k] ------------------ 5585| 8.16k|# ifdef XML_DTD 5586| 8.16k| case XML_ROLE_TEXT_DECL: // bytes accounted in processXmlDecl ------------------ | Branch (5586:5): [True: 0, False: 161k] ------------------ 5587| 8.16k|# endif 5588| 8.16k| break; 5589| 153k| default: ------------------ | Branch (5589:5): [True: 153k, False: 8.16k] ------------------ 5590| 153k| if (! accountingDiffTolerated(parser, tok, s, next, __LINE__, account)) { ------------------ | Branch (5590:11): [True: 0, False: 153k] ------------------ 5591| 0| accountingOnAbort(parser); 5592| 0| return XML_ERROR_AMPLIFICATION_LIMIT_BREACH; 5593| 0| } 5594| 161k| } 5595| 161k|#endif 5596| 161k| switch (role) { ------------------ | Branch (5596:13): [True: 161k, False: 0] ------------------ 5597| 481| case XML_ROLE_XML_DECL: { ------------------ | Branch (5597:5): [True: 481, False: 160k] ------------------ 5598| 481| enum XML_Error result = processXmlDecl(parser, 0, s, next); 5599| 481| if (result != XML_ERROR_NONE) ------------------ | Branch (5599:11): [True: 344, False: 137] ------------------ 5600| 344| return result; 5601| 137| enc = parser->m_encoding; 5602| 137| handleDefault = XML_FALSE; ------------------ | | 64| 137|# define XML_FALSE ((XML_Bool)0) ------------------ 5603| 137| } break; 5604| 6.06k| case XML_ROLE_DOCTYPE_NAME: ------------------ | Branch (5604:5): [True: 6.06k, False: 155k] ------------------ 5605| 6.06k| if (parser->m_startDoctypeDeclHandler) { ------------------ | Branch (5605:11): [True: 0, False: 6.06k] ------------------ 5606| 0| parser->m_doctypeName 5607| 0| = poolStoreString(&parser->m_tempPool, enc, s, next); 5608| 0| if (! parser->m_doctypeName) ------------------ | Branch (5608:13): [True: 0, False: 0] ------------------ 5609| 0| return XML_ERROR_NO_MEMORY; 5610| 0| poolFinish(&parser->m_tempPool); ------------------ | | 676| 0|#define poolFinish(pool) ((pool)->start = (pool)->ptr) ------------------ 5611| 0| parser->m_doctypePubid = NULL; 5612| 0| handleDefault = XML_FALSE; ------------------ | | 64| 0|# define XML_FALSE ((XML_Bool)0) ------------------ 5613| 0| } 5614| 6.06k| parser->m_doctypeSysid = NULL; /* always initialize to NULL */ 5615| 6.06k| break; 5616| 3.34k| case XML_ROLE_DOCTYPE_INTERNAL_SUBSET: ------------------ | Branch (5616:5): [True: 3.34k, False: 158k] ------------------ 5617| 3.34k| if (parser->m_startDoctypeDeclHandler) { ------------------ | Branch (5617:11): [True: 0, False: 3.34k] ------------------ 5618| 0| beforeHandler(parser); 5619| 0| parser->m_startDoctypeDeclHandler( 5620| 0| parser->m_handlerArg, parser->m_doctypeName, parser->m_doctypeSysid, 5621| 0| parser->m_doctypePubid, 1); 5622| 0| afterHandler(parser); 5623| 0| parser->m_doctypeName = NULL; 5624| 0| poolClear(&parser->m_tempPool); 5625| 0| handleDefault = XML_FALSE; ------------------ | | 64| 0|# define XML_FALSE ((XML_Bool)0) ------------------ 5626| 0| } 5627| 3.34k| break; 5628| 0|#ifdef XML_DTD 5629| 0| case XML_ROLE_TEXT_DECL: { ------------------ | Branch (5629:5): [True: 0, False: 161k] ------------------ 5630| 0| enum XML_Error result = processXmlDecl(parser, 1, s, next); 5631| 0| if (result != XML_ERROR_NONE) ------------------ | Branch (5631:11): [True: 0, False: 0] ------------------ 5632| 0| return result; 5633| 0| enc = parser->m_encoding; 5634| 0| handleDefault = XML_FALSE; ------------------ | | 64| 0|# define XML_FALSE ((XML_Bool)0) ------------------ 5635| 0| } break; 5636| 0|#endif /* XML_DTD */ 5637| 252| case XML_ROLE_DOCTYPE_PUBLIC_ID: ------------------ | Branch (5637:5): [True: 252, False: 161k] ------------------ 5638| 252|#ifdef XML_DTD 5639| 252| parser->m_useForeignDTD = XML_FALSE; ------------------ | | 64| 252|# define XML_FALSE ((XML_Bool)0) ------------------ 5640| 252| parser->m_declEntity = (ENTITY *)lookup( 5641| 252| parser, &dtd->paramEntities, externalSubsetName, sizeof(ENTITY)); 5642| 252| if (! parser->m_declEntity) ------------------ | Branch (5642:11): [True: 0, False: 252] ------------------ 5643| 0| return XML_ERROR_NO_MEMORY; 5644| 252|#endif /* XML_DTD */ 5645| 252| dtd->hasParamEntityRefs = XML_TRUE; ------------------ | | 63| 252|# define XML_TRUE ((XML_Bool)1) ------------------ 5646| 252| if (parser->m_startDoctypeDeclHandler) { ------------------ | Branch (5646:11): [True: 0, False: 252] ------------------ 5647| 0| XML_Char *pubId; 5648| 0| if (! XmlIsPublicId(enc, s, next, eventPP)) ------------------ | | 272| 0| (((enc)->isPublicId)(enc, ptr, end, badPtr)) ------------------ | Branch (5648:13): [True: 0, False: 0] ------------------ 5649| 0| return XML_ERROR_PUBLICID; 5650| 0| pubId = poolStoreString(&parser->m_tempPool, enc, 5651| 0| s + enc->minBytesPerChar, 5652| 0| next - enc->minBytesPerChar); 5653| 0| if (! pubId) ------------------ | Branch (5653:13): [True: 0, False: 0] ------------------ 5654| 0| return XML_ERROR_NO_MEMORY; 5655| 0| normalizePublicId(pubId); 5656| 0| poolFinish(&parser->m_tempPool); ------------------ | | 676| 0|#define poolFinish(pool) ((pool)->start = (pool)->ptr) ------------------ 5657| 0| parser->m_doctypePubid = pubId; 5658| 0| handleDefault = XML_FALSE; ------------------ | | 64| 0|# define XML_FALSE ((XML_Bool)0) ------------------ 5659| 0| goto alreadyChecked; 5660| 0| } 5661| 252| EXPAT_FALLTHROUGH; ------------------ | | 47| 252|# define EXPAT_FALLTHROUGH __attribute__((fallthrough)) ------------------ 5662| 794| case XML_ROLE_ENTITY_PUBLIC_ID: ------------------ | Branch (5662:5): [True: 542, False: 160k] ------------------ 5663| 794| if (! XmlIsPublicId(enc, s, next, eventPP)) ------------------ | | 272| 794| (((enc)->isPublicId)(enc, ptr, end, badPtr)) ------------------ | Branch (5663:11): [True: 15, False: 779] ------------------ 5664| 15| return XML_ERROR_PUBLICID; 5665| 779| alreadyChecked: 5666| 779| if (dtd->keepProcessing && parser->m_declEntity) { ------------------ | Branch (5666:11): [True: 645, False: 134] | Branch (5666:34): [True: 345, False: 300] ------------------ 5667| 345| XML_Char *tem 5668| 345| = poolStoreString(&dtd->pool, enc, s + enc->minBytesPerChar, 5669| 345| next - enc->minBytesPerChar); 5670| 345| if (! tem) ------------------ | Branch (5670:13): [True: 0, False: 345] ------------------ 5671| 0| return XML_ERROR_NO_MEMORY; 5672| 345| normalizePublicId(tem); 5673| 345| parser->m_declEntity->publicId = tem; 5674| 345| poolFinish(&dtd->pool); ------------------ | | 676| 345|#define poolFinish(pool) ((pool)->start = (pool)->ptr) ------------------ 5675| | /* Don't suppress the default handler if we fell through from 5676| | * the XML_ROLE_DOCTYPE_PUBLIC_ID case. 5677| | */ 5678| 345| if (parser->m_entityDeclHandler && role == XML_ROLE_ENTITY_PUBLIC_ID) ------------------ | Branch (5678:13): [True: 0, False: 345] | Branch (5678:44): [True: 0, False: 0] ------------------ 5679| 0| handleDefault = XML_FALSE; ------------------ | | 64| 0|# define XML_FALSE ((XML_Bool)0) ------------------ 5680| 345| } 5681| 779| break; 5682| 3.99k| case XML_ROLE_DOCTYPE_CLOSE: ------------------ | Branch (5682:5): [True: 3.99k, False: 157k] ------------------ 5683| 3.99k| if (allowClosingDoctype != XML_TRUE) { ------------------ | | 63| 3.99k|# define XML_TRUE ((XML_Bool)1) ------------------ | Branch (5683:11): [True: 0, False: 3.99k] ------------------ 5684| | /* Must not close doctype from within expanded parameter entities */ 5685| 0| return XML_ERROR_INVALID_TOKEN; 5686| 0| } 5687| | 5688| 3.99k| if (parser->m_doctypeName) { ------------------ | Branch (5688:11): [True: 0, False: 3.99k] ------------------ 5689| 0| beforeHandler(parser); 5690| 0| parser->m_startDoctypeDeclHandler( 5691| 0| parser->m_handlerArg, parser->m_doctypeName, parser->m_doctypeSysid, 5692| 0| parser->m_doctypePubid, 0); 5693| 0| afterHandler(parser); 5694| 0| poolClear(&parser->m_tempPool); 5695| 0| handleDefault = XML_FALSE; ------------------ | | 64| 0|# define XML_FALSE ((XML_Bool)0) ------------------ 5696| 0| } 5697| | /* parser->m_doctypeSysid will be non-NULL in the case of a previous 5698| | XML_ROLE_DOCTYPE_SYSTEM_ID, even if parser->m_startDoctypeDeclHandler 5699| | was not set, indicating an external subset 5700| | */ 5701| 3.99k|#ifdef XML_DTD 5702| 3.99k| if (parser->m_doctypeSysid || parser->m_useForeignDTD) { ------------------ | Branch (5702:11): [True: 151, False: 3.84k] | Branch (5702:37): [True: 0, False: 3.84k] ------------------ 5703| 151| XML_Bool hadParamEntityRefs = dtd->hasParamEntityRefs; 5704| 151| dtd->hasParamEntityRefs = XML_TRUE; ------------------ | | 63| 151|# define XML_TRUE ((XML_Bool)1) ------------------ 5705| 151| if (parser->m_paramEntityParsing ------------------ | Branch (5705:13): [True: 0, False: 151] ------------------ 5706| 0| && parser->m_externalEntityRefHandler) { ------------------ | Branch (5706:16): [True: 0, False: 0] ------------------ 5707| 0| ENTITY *entity = (ENTITY *)lookup(parser, &dtd->paramEntities, 5708| 0| externalSubsetName, sizeof(ENTITY)); 5709| 0| if (! entity) { ------------------ | Branch (5709:15): [True: 0, False: 0] ------------------ 5710| | /* The external subset name "#" will have already been 5711| | * inserted into the hash table at the start of the 5712| | * external entity parsing, so no allocation will happen 5713| | * and lookup() cannot fail. 5714| | */ 5715| 0| return XML_ERROR_NO_MEMORY; /* LCOV_EXCL_LINE */ 5716| 0| } 5717| 0| if (parser->m_useForeignDTD) ------------------ | Branch (5717:15): [True: 0, False: 0] ------------------ 5718| 0| entity->base = parser->m_curBase; 5719| 0| dtd->paramEntityRead = false; 5720| 0| beforeHandler(parser); 5721| 0| const int status = parser->m_externalEntityRefHandler( 5722| 0| parser->m_externalEntityRefHandlerArg, 0, entity->base, 5723| 0| entity->systemId, entity->publicId); 5724| 0| afterHandler(parser); 5725| 0| if (! status) ------------------ | Branch (5725:15): [True: 0, False: 0] ------------------ 5726| 0| return XML_ERROR_EXTERNAL_ENTITY_HANDLING; 5727| 0| if (dtd->paramEntityRead) { ------------------ | Branch (5727:15): [True: 0, False: 0] ------------------ 5728| 0| if (! dtd->standalone && parser->m_notStandaloneHandler) { ------------------ | Branch (5728:17): [True: 0, False: 0] | Branch (5728:38): [True: 0, False: 0] ------------------ 5729| 0| beforeHandler(parser); 5730| 0| const int handlerStatus 5731| 0| = parser->m_notStandaloneHandler(parser->m_handlerArg); 5732| 0| afterHandler(parser); 5733| 0| if (! handlerStatus) ------------------ | Branch (5733:19): [True: 0, False: 0] ------------------ 5734| 0| return XML_ERROR_NOT_STANDALONE; 5735| 0| } 5736| 0| } 5737| | /* if we didn't read the foreign DTD then this means that there 5738| | is no external subset and we must reset dtd->hasParamEntityRefs 5739| | */ 5740| 0| else if (! parser->m_doctypeSysid) ------------------ | Branch (5740:20): [True: 0, False: 0] ------------------ 5741| 0| dtd->hasParamEntityRefs = hadParamEntityRefs; 5742| | /* end of DTD - no need to update dtd->keepProcessing */ 5743| 0| } 5744| 151| parser->m_useForeignDTD = XML_FALSE; ------------------ | | 64| 151|# define XML_FALSE ((XML_Bool)0) ------------------ 5745| 151| } 5746| 3.99k|#endif /* XML_DTD */ 5747| 3.99k| if (parser->m_endDoctypeDeclHandler) { ------------------ | Branch (5747:11): [True: 0, False: 3.99k] ------------------ 5748| 0| beforeHandler(parser); 5749| 0| parser->m_endDoctypeDeclHandler(parser->m_handlerArg); 5750| 0| afterHandler(parser); 5751| 0| handleDefault = XML_FALSE; ------------------ | | 64| 0|# define XML_FALSE ((XML_Bool)0) ------------------ 5752| 0| } 5753| 3.99k| break; 5754| 7.68k| case XML_ROLE_INSTANCE_START: ------------------ | Branch (5754:5): [True: 7.68k, False: 153k] ------------------ 5755| 7.68k|#ifdef XML_DTD 5756| | /* if there is no DOCTYPE declaration then now is the 5757| | last chance to read the foreign DTD 5758| | */ 5759| 7.68k| if (parser->m_useForeignDTD) { ------------------ | Branch (5759:11): [True: 0, False: 7.68k] ------------------ 5760| 0| XML_Bool hadParamEntityRefs = dtd->hasParamEntityRefs; 5761| 0| dtd->hasParamEntityRefs = XML_TRUE; ------------------ | | 63| 0|# define XML_TRUE ((XML_Bool)1) ------------------ 5762| 0| if (parser->m_paramEntityParsing ------------------ | Branch (5762:13): [True: 0, False: 0] ------------------ 5763| 0| && parser->m_externalEntityRefHandler) { ------------------ | Branch (5763:16): [True: 0, False: 0] ------------------ 5764| 0| ENTITY *entity = (ENTITY *)lookup(parser, &dtd->paramEntities, 5765| 0| externalSubsetName, sizeof(ENTITY)); 5766| 0| if (! entity) ------------------ | Branch (5766:15): [True: 0, False: 0] ------------------ 5767| 0| return XML_ERROR_NO_MEMORY; 5768| 0| entity->base = parser->m_curBase; 5769| 0| dtd->paramEntityRead = false; 5770| 0| beforeHandler(parser); 5771| 0| const int status = parser->m_externalEntityRefHandler( 5772| 0| parser->m_externalEntityRefHandlerArg, 0, entity->base, 5773| 0| entity->systemId, entity->publicId); 5774| 0| afterHandler(parser); 5775| 0| if (! status) ------------------ | Branch (5775:15): [True: 0, False: 0] ------------------ 5776| 0| return XML_ERROR_EXTERNAL_ENTITY_HANDLING; 5777| 0| if (dtd->paramEntityRead) { ------------------ | Branch (5777:15): [True: 0, False: 0] ------------------ 5778| 0| if (! dtd->standalone && parser->m_notStandaloneHandler) { ------------------ | Branch (5778:17): [True: 0, False: 0] | Branch (5778:38): [True: 0, False: 0] ------------------ 5779| 0| beforeHandler(parser); 5780| 0| const int handlerStatus 5781| 0| = parser->m_notStandaloneHandler(parser->m_handlerArg); 5782| 0| afterHandler(parser); 5783| 0| if (! handlerStatus) ------------------ | Branch (5783:19): [True: 0, False: 0] ------------------ 5784| 0| return XML_ERROR_NOT_STANDALONE; 5785| 0| } 5786| 0| } 5787| | /* if we didn't read the foreign DTD then this means that there 5788| | is no external subset and we must reset dtd->hasParamEntityRefs 5789| | */ 5790| 0| else 5791| 0| dtd->hasParamEntityRefs = hadParamEntityRefs; 5792| | /* end of DTD - no need to update dtd->keepProcessing */ 5793| 0| } 5794| 0| } 5795| 7.68k|#endif /* XML_DTD */ 5796| 7.68k| parser->m_processor = contentProcessor; 5797| 7.68k| return contentProcessor(parser, s, end, nextPtr); 5798| 1.52k| case XML_ROLE_ATTLIST_ELEMENT_NAME: ------------------ | Branch (5798:5): [True: 1.52k, False: 159k] ------------------ 5799| 1.52k| parser->m_declElementType = getElementType(parser, enc, s, next); 5800| 1.52k| if (! parser->m_declElementType) ------------------ | Branch (5800:11): [True: 0, False: 1.52k] ------------------ 5801| 0| return XML_ERROR_NO_MEMORY; 5802| 1.52k| goto checkAttListDeclHandler; 5803| 3.82k| case XML_ROLE_ATTRIBUTE_NAME: ------------------ | Branch (5803:5): [True: 3.82k, False: 157k] ------------------ 5804| 3.82k| parser->m_declAttributeId = getAttributeId(parser, enc, s, next); 5805| 3.82k| if (! parser->m_declAttributeId) ------------------ | Branch (5805:11): [True: 0, False: 3.82k] ------------------ 5806| 0| return XML_ERROR_NO_MEMORY; 5807| 3.82k| parser->m_declAttributeIsCdata = false; 5808| 3.82k| parser->m_declAttributeType = NULL; 5809| 3.82k| parser->m_declAttributeIsId = false; 5810| 3.82k| goto checkAttListDeclHandler; 5811| 727| case XML_ROLE_ATTRIBUTE_TYPE_CDATA: ------------------ | Branch (5811:5): [True: 727, False: 160k] ------------------ 5812| 727| parser->m_declAttributeIsCdata = true; 5813| 727| parser->m_declAttributeType = atypeCDATA; 5814| 727| goto checkAttListDeclHandler; 5815| 1.64k| case XML_ROLE_ATTRIBUTE_TYPE_ID: ------------------ | Branch (5815:5): [True: 1.64k, False: 159k] ------------------ 5816| 1.64k| parser->m_declAttributeIsId = true; 5817| 1.64k| parser->m_declAttributeType = atypeID; 5818| 1.64k| goto checkAttListDeclHandler; 5819| 71| case XML_ROLE_ATTRIBUTE_TYPE_IDREF: ------------------ | Branch (5819:5): [True: 71, False: 161k] ------------------ 5820| 71| parser->m_declAttributeType = atypeIDREF; 5821| 71| goto checkAttListDeclHandler; 5822| 124| case XML_ROLE_ATTRIBUTE_TYPE_IDREFS: ------------------ | Branch (5822:5): [True: 124, False: 161k] ------------------ 5823| 124| parser->m_declAttributeType = atypeIDREFS; 5824| 124| goto checkAttListDeclHandler; 5825| 128| case XML_ROLE_ATTRIBUTE_TYPE_ENTITY: ------------------ | Branch (5825:5): [True: 128, False: 161k] ------------------ 5826| 128| parser->m_declAttributeType = atypeENTITY; 5827| 128| goto checkAttListDeclHandler; 5828| 68| case XML_ROLE_ATTRIBUTE_TYPE_ENTITIES: ------------------ | Branch (5828:5): [True: 68, False: 161k] ------------------ 5829| 68| parser->m_declAttributeType = atypeENTITIES; 5830| 68| goto checkAttListDeclHandler; 5831| 99| case XML_ROLE_ATTRIBUTE_TYPE_NMTOKEN: ------------------ | Branch (5831:5): [True: 99, False: 161k] ------------------ 5832| 99| parser->m_declAttributeType = atypeNMTOKEN; 5833| 99| goto checkAttListDeclHandler; 5834| 108| case XML_ROLE_ATTRIBUTE_TYPE_NMTOKENS: ------------------ | Branch (5834:5): [True: 108, False: 161k] ------------------ 5835| 108| parser->m_declAttributeType = atypeNMTOKENS; 5836| 8.32k| checkAttListDeclHandler: 5837| 8.32k| if (dtd->keepProcessing && parser->m_attlistDeclHandler) ------------------ | Branch (5837:11): [True: 7.54k, False: 778] | Branch (5837:34): [True: 0, False: 7.54k] ------------------ 5838| 0| handleDefault = XML_FALSE; ------------------ | | 64| 0|# define XML_FALSE ((XML_Bool)0) ------------------ 5839| 8.32k| break; 5840| 3.87k| case XML_ROLE_ATTRIBUTE_ENUM_VALUE: ------------------ | Branch (5840:5): [True: 3.87k, False: 157k] ------------------ 5841| 4.67k| case XML_ROLE_ATTRIBUTE_NOTATION_VALUE: ------------------ | Branch (5841:5): [True: 796, False: 160k] ------------------ 5842| 4.67k| if (dtd->keepProcessing && parser->m_attlistDeclHandler) { ------------------ | Branch (5842:11): [True: 4.20k, False: 470] | Branch (5842:34): [True: 0, False: 4.20k] ------------------ 5843| 0| const XML_Char *prefix; 5844| 0| if (parser->m_declAttributeType) { ------------------ | Branch (5844:13): [True: 0, False: 0] ------------------ 5845| 0| prefix = enumValueSep; 5846| 0| } else { 5847| 0| prefix = (role == XML_ROLE_ATTRIBUTE_NOTATION_VALUE ? notationPrefix ------------------ | Branch (5847:21): [True: 0, False: 0] ------------------ 5848| 0| : enumValueStart); 5849| 0| } 5850| 0| if (! poolAppendString(&parser->m_tempPool, prefix)) ------------------ | Branch (5850:13): [True: 0, False: 0] ------------------ 5851| 0| return XML_ERROR_NO_MEMORY; 5852| 0| if (! poolAppend(&parser->m_tempPool, enc, s, next)) ------------------ | Branch (5852:13): [True: 0, False: 0] ------------------ 5853| 0| return XML_ERROR_NO_MEMORY; 5854| 0| parser->m_declAttributeType = parser->m_tempPool.start; 5855| 0| handleDefault = XML_FALSE; ------------------ | | 64| 0|# define XML_FALSE ((XML_Bool)0) ------------------ 5856| 0| } 5857| 4.67k| break; 5858| 4.67k| case XML_ROLE_IMPLIED_ATTRIBUTE_VALUE: ------------------ | Branch (5858:5): [True: 693, False: 160k] ------------------ 5859| 774| case XML_ROLE_REQUIRED_ATTRIBUTE_VALUE: ------------------ | Branch (5859:5): [True: 81, False: 161k] ------------------ 5860| 774| if (dtd->keepProcessing) { ------------------ | Branch (5860:11): [True: 708, False: 66] ------------------ 5861| 708| if (! defineAttribute(parser->m_declElementType, ------------------ | Branch (5861:13): [True: 0, False: 708] ------------------ 5862| 708| parser->m_declAttributeId, 5863| 708| parser->m_declAttributeIsCdata, 5864| 708| parser->m_declAttributeIsId, 0, parser)) 5865| 0| return XML_ERROR_NO_MEMORY; 5866| 708| if (parser->m_attlistDeclHandler && parser->m_declAttributeType) { ------------------ | Branch (5866:13): [True: 0, False: 708] | Branch (5866:45): [True: 0, False: 0] ------------------ 5867| 0| if (*parser->m_declAttributeType == XML_T(ASCII_LPAREN) ------------------ | | 220| 0|# define XML_T(x) x ------------------ | Branch (5867:15): [True: 0, False: 0] ------------------ 5868| 0| || (*parser->m_declAttributeType == XML_T(ASCII_N) ------------------ | | 220| 0|# define XML_T(x) x ------------------ | Branch (5868:19): [True: 0, False: 0] ------------------ 5869| 0| && parser->m_declAttributeType[1] == XML_T(ASCII_O))) { ------------------ | | 220| 0|# define XML_T(x) x ------------------ | Branch (5869:22): [True: 0, False: 0] ------------------ 5870| | /* Enumerated or Notation type */ 5871| 0| if (! poolAppendChar(&parser->m_tempPool, XML_T(ASCII_RPAREN)) ------------------ | | 220| 0|# define XML_T(x) x ------------------ | Branch (5871:17): [True: 0, False: 0] ------------------ 5872| 0| || ! poolAppendChar(&parser->m_tempPool, XML_T('\0'))) ------------------ | | 220| 0|# define XML_T(x) x ------------------ | Branch (5872:20): [True: 0, False: 0] ------------------ 5873| 0| return XML_ERROR_NO_MEMORY; 5874| 0| parser->m_declAttributeType = parser->m_tempPool.start; 5875| 0| poolFinish(&parser->m_tempPool); ------------------ | | 676| 0|#define poolFinish(pool) ((pool)->start = (pool)->ptr) ------------------ 5876| 0| } 5877| 0| *eventEndPP = s; 5878| 0| beforeHandler(parser); 5879| 0| parser->m_attlistDeclHandler( 5880| 0| parser->m_handlerArg, parser->m_declElementType->name, 5881| 0| parser->m_declAttributeId->name, parser->m_declAttributeType, 0, 5882| 0| role == XML_ROLE_REQUIRED_ATTRIBUTE_VALUE); 5883| 0| afterHandler(parser); 5884| 0| handleDefault = XML_FALSE; ------------------ | | 64| 0|# define XML_FALSE ((XML_Bool)0) ------------------ 5885| 0| } 5886| 708| } 5887| 774| poolClear(&parser->m_tempPool); 5888| 774| break; 5889| 2.58k| case XML_ROLE_DEFAULT_ATTRIBUTE_VALUE: ------------------ | Branch (5889:5): [True: 2.58k, False: 158k] ------------------ 5890| 2.72k| case XML_ROLE_FIXED_ATTRIBUTE_VALUE: ------------------ | Branch (5890:5): [True: 136, False: 161k] ------------------ 5891| 2.72k| if (dtd->keepProcessing) { ------------------ | Branch (5891:11): [True: 2.41k, False: 307] ------------------ 5892| 2.41k| const XML_Char *attVal; 5893| 2.41k| enum XML_Error result = storeAttributeValue( 5894| 2.41k| parser, enc, parser->m_declAttributeIsCdata, 5895| 2.41k| s + enc->minBytesPerChar, next - enc->minBytesPerChar, &dtd->pool, 5896| 2.41k| XML_ACCOUNT_NONE); 5897| 2.41k| if (result) ------------------ | Branch (5897:13): [True: 21, False: 2.39k] ------------------ 5898| 21| return result; 5899| 2.39k| attVal = poolStart(&dtd->pool); ------------------ | | 671| 2.39k|#define poolStart(pool) ((pool)->start) ------------------ 5900| 2.39k| poolFinish(&dtd->pool); ------------------ | | 676| 2.39k|#define poolFinish(pool) ((pool)->start = (pool)->ptr) ------------------ 5901| | /* ID attributes aren't allowed to have a default */ 5902| 2.39k| if (! defineAttribute( ------------------ | Branch (5902:13): [True: 0, False: 2.39k] ------------------ 5903| 2.39k| parser->m_declElementType, parser->m_declAttributeId, 5904| 2.39k| parser->m_declAttributeIsCdata, false, attVal, parser)) 5905| 0| return XML_ERROR_NO_MEMORY; 5906| 2.39k| if (parser->m_attlistDeclHandler && parser->m_declAttributeType) { ------------------ | Branch (5906:13): [True: 0, False: 2.39k] | Branch (5906:45): [True: 0, False: 0] ------------------ 5907| 0| if (*parser->m_declAttributeType == XML_T(ASCII_LPAREN) ------------------ | | 220| 0|# define XML_T(x) x ------------------ | Branch (5907:15): [True: 0, False: 0] ------------------ 5908| 0| || (*parser->m_declAttributeType == XML_T(ASCII_N) ------------------ | | 220| 0|# define XML_T(x) x ------------------ | Branch (5908:19): [True: 0, False: 0] ------------------ 5909| 0| && parser->m_declAttributeType[1] == XML_T(ASCII_O))) { ------------------ | | 220| 0|# define XML_T(x) x ------------------ | Branch (5909:22): [True: 0, False: 0] ------------------ 5910| | /* Enumerated or Notation type */ 5911| 0| if (! poolAppendChar(&parser->m_tempPool, XML_T(ASCII_RPAREN)) ------------------ | | 220| 0|# define XML_T(x) x ------------------ | Branch (5911:17): [True: 0, False: 0] ------------------ 5912| 0| || ! poolAppendChar(&parser->m_tempPool, XML_T('\0'))) ------------------ | | 220| 0|# define XML_T(x) x ------------------ | Branch (5912:20): [True: 0, False: 0] ------------------ 5913| 0| return XML_ERROR_NO_MEMORY; 5914| 0| parser->m_declAttributeType = parser->m_tempPool.start; 5915| 0| poolFinish(&parser->m_tempPool); ------------------ | | 676| 0|#define poolFinish(pool) ((pool)->start = (pool)->ptr) ------------------ 5916| 0| } 5917| 0| *eventEndPP = s; 5918| 0| beforeHandler(parser); 5919| 0| parser->m_attlistDeclHandler( 5920| 0| parser->m_handlerArg, parser->m_declElementType->name, 5921| 0| parser->m_declAttributeId->name, parser->m_declAttributeType, 5922| 0| attVal, role == XML_ROLE_FIXED_ATTRIBUTE_VALUE); 5923| 0| afterHandler(parser); 5924| 0| poolClear(&parser->m_tempPool); 5925| 0| handleDefault = XML_FALSE; ------------------ | | 64| 0|# define XML_FALSE ((XML_Bool)0) ------------------ 5926| 0| } 5927| 2.39k| } 5928| 2.70k| break; 5929| 3.89k| case XML_ROLE_ENTITY_VALUE: ------------------ | Branch (5929:5): [True: 3.89k, False: 157k] ------------------ 5930| 3.89k| if (dtd->keepProcessing) { ------------------ | Branch (5930:11): [True: 3.72k, False: 168] ------------------ 5931| 3.72k|#if XML_GE == 1 5932| | // This will store the given replacement text in 5933| | // parser->m_declEntity->textPtr. 5934| 3.72k| const enum XML_Error result = callStoreEntityValue( 5935| 3.72k| parser, enc, s + enc->minBytesPerChar, next - enc->minBytesPerChar, 5936| 3.72k| XML_ACCOUNT_NONE); 5937| 3.72k| if (result != XML_ERROR_NONE) { ------------------ | Branch (5937:13): [True: 23, False: 3.70k] ------------------ 5938| 23| poolDiscard(&dtd->entityValuePool); ------------------ | | 675| 23|#define poolDiscard(pool) ((pool)->ptr = (pool)->start) ------------------ 5939| 23| return result; 5940| 23| } 5941| 3.70k| if (parser->m_declEntity) { ------------------ | Branch (5941:13): [True: 2.68k, False: 1.02k] ------------------ 5942| | /* Detect and prevent signed integer overflow */ 5943| 2.68k| if ((size_t)poolLength(&dtd->entityValuePool) > (size_t)INT_MAX) { ------------------ | | 672| 2.68k|#define poolLength(pool) ((pool)->ptr - (pool)->start) ------------------ | Branch (5943:15): [True: 0, False: 2.68k] ------------------ 5944| 0| poolDiscard(&dtd->entityValuePool); ------------------ | | 675| 0|#define poolDiscard(pool) ((pool)->ptr = (pool)->start) ------------------ 5945| 0| return XML_ERROR_NO_MEMORY; 5946| 0| } 5947| 2.68k| parser->m_declEntity->textPtr = poolStart(&dtd->entityValuePool); ------------------ | | 671| 2.68k|#define poolStart(pool) ((pool)->start) ------------------ 5948| 2.68k| parser->m_declEntity->textLen = poolLength(&dtd->entityValuePool); ------------------ | | 672| 2.68k|#define poolLength(pool) ((pool)->ptr - (pool)->start) ------------------ 5949| 2.68k| poolFinish(&dtd->entityValuePool); ------------------ | | 676| 2.68k|#define poolFinish(pool) ((pool)->start = (pool)->ptr) ------------------ 5950| 2.68k| if (parser->m_entityDeclHandler) { ------------------ | Branch (5950:15): [True: 0, False: 2.68k] ------------------ 5951| 0| *eventEndPP = s; 5952| 0| beforeHandler(parser); 5953| 0| parser->m_entityDeclHandler( 5954| 0| parser->m_handlerArg, parser->m_declEntity->name, 5955| 0| parser->m_declEntity->is_param, parser->m_declEntity->textPtr, 5956| 0| (int)parser->m_declEntity->textLen, parser->m_curBase, 0, 0, 0); 5957| 0| afterHandler(parser); 5958| 0| handleDefault = XML_FALSE; ------------------ | | 64| 0|# define XML_FALSE ((XML_Bool)0) ------------------ 5959| 0| } 5960| 2.68k| } else 5961| 1.02k| poolDiscard(&dtd->entityValuePool); ------------------ | | 675| 1.02k|#define poolDiscard(pool) ((pool)->ptr = (pool)->start) ------------------ 5962| |#else 5963| | // This will store "&entity123;" in parser->m_declEntity->textPtr 5964| | // to end up as "&entity123;" in the handler. 5965| | if (parser->m_declEntity != NULL) { 5966| | const enum XML_Error result 5967| | = storeSelfEntityValue(parser, parser->m_declEntity); 5968| | if (result != XML_ERROR_NONE) 5969| | return result; 5970| | 5971| | if (parser->m_entityDeclHandler) { 5972| | *eventEndPP = s; 5973| | beforeHandler(parser); 5974| | parser->m_entityDeclHandler( 5975| | parser->m_handlerArg, parser->m_declEntity->name, 5976| | parser->m_declEntity->is_param, parser->m_declEntity->textPtr, 5977| | (int)parser->m_declEntity->textLen, parser->m_curBase, 0, 0, 0); 5978| | afterHandler(parser); 5979| | handleDefault = XML_FALSE; 5980| | } 5981| | } 5982| |#endif 5983| 3.70k| } 5984| 3.87k| break; 5985| 3.87k| case XML_ROLE_DOCTYPE_SYSTEM_ID: ------------------ | Branch (5985:5): [True: 178, False: 161k] ------------------ 5986| 178|#ifdef XML_DTD 5987| 178| parser->m_useForeignDTD = XML_FALSE; ------------------ | | 64| 178|# define XML_FALSE ((XML_Bool)0) ------------------ 5988| 178|#endif /* XML_DTD */ 5989| 178| dtd->hasParamEntityRefs = XML_TRUE; ------------------ | | 63| 178|# define XML_TRUE ((XML_Bool)1) ------------------ 5990| 178| if (parser->m_startDoctypeDeclHandler) { ------------------ | Branch (5990:11): [True: 0, False: 178] ------------------ 5991| 0| parser->m_doctypeSysid = poolStoreString(&parser->m_tempPool, enc, 5992| 0| s + enc->minBytesPerChar, 5993| 0| next - enc->minBytesPerChar); 5994| 0| if (parser->m_doctypeSysid == NULL) ------------------ | Branch (5994:13): [True: 0, False: 0] ------------------ 5995| 0| return XML_ERROR_NO_MEMORY; 5996| 0| poolFinish(&parser->m_tempPool); ------------------ | | 676| 0|#define poolFinish(pool) ((pool)->start = (pool)->ptr) ------------------ 5997| 0| handleDefault = XML_FALSE; ------------------ | | 64| 0|# define XML_FALSE ((XML_Bool)0) ------------------ 5998| 0| } 5999| 178|#ifdef XML_DTD 6000| 178| else 6001| | /* use externalSubsetName to make parser->m_doctypeSysid non-NULL 6002| | for the case where no parser->m_startDoctypeDeclHandler is set */ 6003| 178| parser->m_doctypeSysid = externalSubsetName; 6004| 178|#endif /* XML_DTD */ 6005| 178| if (! dtd->standalone ------------------ | Branch (6005:11): [True: 178, False: 0] ------------------ 6006| 178|#ifdef XML_DTD 6007| 178| && ! parser->m_paramEntityParsing ------------------ | Branch (6007:14): [True: 178, False: 0] ------------------ 6008| 178|#endif /* XML_DTD */ 6009| 178| && parser->m_notStandaloneHandler) { ------------------ | Branch (6009:14): [True: 0, False: 178] ------------------ 6010| 0| beforeHandler(parser); 6011| 0| const int status = parser->m_notStandaloneHandler(parser->m_handlerArg); 6012| 0| afterHandler(parser); 6013| 0| if (! status) ------------------ | Branch (6013:13): [True: 0, False: 0] ------------------ 6014| 0| return XML_ERROR_NOT_STANDALONE; 6015| 0| } 6016| |#ifndef XML_DTD 6017| | break; 6018| |#else /* XML_DTD */ 6019| 178| if (! parser->m_declEntity) { ------------------ | Branch (6019:11): [True: 138, False: 40] ------------------ 6020| 138| parser->m_declEntity = (ENTITY *)lookup( 6021| 138| parser, &dtd->paramEntities, externalSubsetName, sizeof(ENTITY)); 6022| 138| if (! parser->m_declEntity) ------------------ | Branch (6022:13): [True: 0, False: 138] ------------------ 6023| 0| return XML_ERROR_NO_MEMORY; 6024| 138| parser->m_declEntity->publicId = NULL; 6025| 138| } 6026| 178|#endif /* XML_DTD */ 6027| 178| EXPAT_FALLTHROUGH; ------------------ | | 47| 178|# define EXPAT_FALLTHROUGH __attribute__((fallthrough)) ------------------ 6028| 1.23k| case XML_ROLE_ENTITY_SYSTEM_ID: ------------------ | Branch (6028:5): [True: 1.05k, False: 160k] ------------------ 6029| 1.23k| if (dtd->keepProcessing && parser->m_declEntity) { ------------------ | Branch (6029:11): [True: 1.04k, False: 191] | Branch (6029:34): [True: 385, False: 661] ------------------ 6030| 385| parser->m_declEntity->systemId 6031| 385| = poolStoreString(&dtd->pool, enc, s + enc->minBytesPerChar, 6032| 385| next - enc->minBytesPerChar); 6033| 385| if (! parser->m_declEntity->systemId) ------------------ | Branch (6033:13): [True: 0, False: 385] ------------------ 6034| 0| return XML_ERROR_NO_MEMORY; 6035| 385| parser->m_declEntity->base = parser->m_curBase; 6036| 385| poolFinish(&dtd->pool); ------------------ | | 676| 385|#define poolFinish(pool) ((pool)->start = (pool)->ptr) ------------------ 6037| | /* Don't suppress the default handler if we fell through from 6038| | * the XML_ROLE_DOCTYPE_SYSTEM_ID case. 6039| | */ 6040| 385| if (parser->m_entityDeclHandler && role == XML_ROLE_ENTITY_SYSTEM_ID) ------------------ | Branch (6040:13): [True: 0, False: 385] | Branch (6040:44): [True: 0, False: 0] ------------------ 6041| 0| handleDefault = XML_FALSE; ------------------ | | 64| 0|# define XML_FALSE ((XML_Bool)0) ------------------ 6042| 385| } 6043| 1.23k| break; 6044| 1.23k| case XML_ROLE_ENTITY_COMPLETE: ------------------ | Branch (6044:5): [True: 835, False: 160k] ------------------ 6045| |#if XML_GE == 0 6046| | // This will store "&entity123;" in entity->textPtr 6047| | // to end up as "&entity123;" in the handler. 6048| | if (parser->m_declEntity != NULL) { 6049| | const enum XML_Error result 6050| | = storeSelfEntityValue(parser, parser->m_declEntity); 6051| | if (result != XML_ERROR_NONE) 6052| | return result; 6053| | } 6054| |#endif 6055| 835| if (dtd->keepProcessing && parser->m_declEntity ------------------ | Branch (6055:11): [True: 710, False: 125] | Branch (6055:34): [True: 168, False: 542] ------------------ 6056| 168| && parser->m_entityDeclHandler) { ------------------ | Branch (6056:14): [True: 0, False: 168] ------------------ 6057| 0| *eventEndPP = s; 6058| 0| beforeHandler(parser); 6059| 0| parser->m_entityDeclHandler( 6060| 0| parser->m_handlerArg, parser->m_declEntity->name, 6061| 0| parser->m_declEntity->is_param, 0, 0, parser->m_declEntity->base, 6062| 0| parser->m_declEntity->systemId, parser->m_declEntity->publicId, 0); 6063| 0| afterHandler(parser); 6064| 0| handleDefault = XML_FALSE; ------------------ | | 64| 0|# define XML_FALSE ((XML_Bool)0) ------------------ 6065| 0| } 6066| 835| break; 6067| 218| case XML_ROLE_ENTITY_NOTATION_NAME: ------------------ | Branch (6067:5): [True: 218, False: 161k] ------------------ 6068| 218| if (dtd->keepProcessing && parser->m_declEntity) { ------------------ | Branch (6068:11): [True: 152, False: 66] | Branch (6068:34): [True: 33, False: 119] ------------------ 6069| 33| parser->m_declEntity->notation 6070| 33| = poolStoreString(&dtd->pool, enc, s, next); 6071| 33| if (! parser->m_declEntity->notation) ------------------ | Branch (6071:13): [True: 0, False: 33] ------------------ 6072| 0| return XML_ERROR_NO_MEMORY; 6073| 33| poolFinish(&dtd->pool); ------------------ | | 676| 33|#define poolFinish(pool) ((pool)->start = (pool)->ptr) ------------------ 6074| 33| if (parser->m_unparsedEntityDeclHandler) { ------------------ | Branch (6074:13): [True: 0, False: 33] ------------------ 6075| 0| *eventEndPP = s; 6076| 0| beforeHandler(parser); 6077| 0| parser->m_unparsedEntityDeclHandler( 6078| 0| parser->m_handlerArg, parser->m_declEntity->name, 6079| 0| parser->m_declEntity->base, parser->m_declEntity->systemId, 6080| 0| parser->m_declEntity->publicId, parser->m_declEntity->notation); 6081| 0| afterHandler(parser); 6082| 0| handleDefault = XML_FALSE; ------------------ | | 64| 0|# define XML_FALSE ((XML_Bool)0) ------------------ 6083| 33| } else if (parser->m_entityDeclHandler) { ------------------ | Branch (6083:20): [True: 0, False: 33] ------------------ 6084| 0| *eventEndPP = s; 6085| 0| beforeHandler(parser); 6086| 0| parser->m_entityDeclHandler( 6087| 0| parser->m_handlerArg, parser->m_declEntity->name, 0, 0, 0, 6088| 0| parser->m_declEntity->base, parser->m_declEntity->systemId, 6089| 0| parser->m_declEntity->publicId, parser->m_declEntity->notation); 6090| 0| afterHandler(parser); 6091| 0| handleDefault = XML_FALSE; ------------------ | | 64| 0|# define XML_FALSE ((XML_Bool)0) ------------------ 6092| 0| } 6093| 33| } 6094| 218| break; 6095| 4.23k| case XML_ROLE_GENERAL_ENTITY_NAME: { ------------------ | Branch (6095:5): [True: 4.23k, False: 157k] ------------------ 6096| 4.23k| if (XmlPredefinedEntityName(enc, s, next)) { ------------------ | | 266| 4.23k| (((enc)->predefinedEntityName)(enc, ptr, end)) | | ------------------ | | | Branch (266:5): [True: 68, False: 4.16k] | | ------------------ ------------------ 6097| 68| parser->m_declEntity = NULL; 6098| 68| break; 6099| 68| } 6100| 4.16k| if (dtd->keepProcessing) { ------------------ | Branch (6100:11): [True: 3.86k, False: 296] ------------------ 6101| 3.86k| const XML_Char *name = poolStoreString(&dtd->pool, enc, s, next); 6102| 3.86k| if (! name) ------------------ | Branch (6102:13): [True: 0, False: 3.86k] ------------------ 6103| 0| return XML_ERROR_NO_MEMORY; 6104| 3.86k| parser->m_declEntity = (ENTITY *)lookup(parser, &dtd->generalEntities, 6105| 3.86k| name, sizeof(ENTITY)); 6106| 3.86k| if (! parser->m_declEntity) ------------------ | Branch (6106:13): [True: 0, False: 3.86k] ------------------ 6107| 0| return XML_ERROR_NO_MEMORY; 6108| 3.86k| if (parser->m_declEntity->name != name) { ------------------ | Branch (6108:13): [True: 1.05k, False: 2.81k] ------------------ 6109| 1.05k| poolDiscard(&dtd->pool); ------------------ | | 675| 1.05k|#define poolDiscard(pool) ((pool)->ptr = (pool)->start) ------------------ 6110| 1.05k| parser->m_declEntity = NULL; 6111| 2.81k| } else { 6112| 2.81k| poolFinish(&dtd->pool); ------------------ | | 676| 2.81k|#define poolFinish(pool) ((pool)->start = (pool)->ptr) ------------------ 6113| 2.81k| parser->m_declEntity->publicId = NULL; 6114| 2.81k| parser->m_declEntity->is_param = false; 6115| | /* if we have a parent parser or are reading an internal parameter 6116| | entity, then the entity declaration is not considered "internal" 6117| | */ 6118| 2.81k| parser->m_declEntity->is_internal 6119| 2.81k| = ! (parser->m_parentParser || parser->m_openInternalEntities); ------------------ | Branch (6119:20): [True: 0, False: 2.81k] | Branch (6119:46): [True: 0, False: 2.81k] ------------------ 6120| 2.81k| if (parser->m_entityDeclHandler) ------------------ | Branch (6120:15): [True: 0, False: 2.81k] ------------------ 6121| 0| handleDefault = XML_FALSE; ------------------ | | 64| 0|# define XML_FALSE ((XML_Bool)0) ------------------ 6122| 2.81k| } 6123| 3.86k| } else { 6124| 296| poolDiscard(&dtd->pool); ------------------ | | 675| 296|#define poolDiscard(pool) ((pool)->ptr = (pool)->start) ------------------ 6125| 296| parser->m_declEntity = NULL; 6126| 296| } 6127| 4.16k| } break; 6128| 4.16k| case XML_ROLE_PARAM_ENTITY_NAME: ------------------ | Branch (6128:5): [True: 903, False: 160k] ------------------ 6129| 903|#ifdef XML_DTD 6130| 903| if (dtd->keepProcessing) { ------------------ | Branch (6130:11): [True: 812, False: 91] ------------------ 6131| 812| const XML_Char *name = poolStoreString(&dtd->pool, enc, s, next); 6132| 812| if (! name) ------------------ | Branch (6132:13): [True: 0, False: 812] ------------------ 6133| 0| return XML_ERROR_NO_MEMORY; 6134| 812| parser->m_declEntity = (ENTITY *)lookup(parser, &dtd->paramEntities, 6135| 812| name, sizeof(ENTITY)); 6136| 812| if (! parser->m_declEntity) ------------------ | Branch (6136:13): [True: 0, False: 812] ------------------ 6137| 0| return XML_ERROR_NO_MEMORY; 6138| 812| if (parser->m_declEntity->name != name) { ------------------ | Branch (6138:13): [True: 662, False: 150] ------------------ 6139| 662| poolDiscard(&dtd->pool); ------------------ | | 675| 662|#define poolDiscard(pool) ((pool)->ptr = (pool)->start) ------------------ 6140| 662| parser->m_declEntity = NULL; 6141| 662| } else { 6142| 150| poolFinish(&dtd->pool); ------------------ | | 676| 150|#define poolFinish(pool) ((pool)->start = (pool)->ptr) ------------------ 6143| 150| parser->m_declEntity->publicId = NULL; 6144| 150| parser->m_declEntity->is_param = true; 6145| | /* if we have a parent parser or are reading an internal parameter 6146| | entity, then the entity declaration is not considered "internal" 6147| | */ 6148| 150| parser->m_declEntity->is_internal 6149| 150| = ! (parser->m_parentParser || parser->m_openInternalEntities); ------------------ | Branch (6149:20): [True: 0, False: 150] | Branch (6149:46): [True: 0, False: 150] ------------------ 6150| 150| if (parser->m_entityDeclHandler) ------------------ | Branch (6150:15): [True: 0, False: 150] ------------------ 6151| 0| handleDefault = XML_FALSE; ------------------ | | 64| 0|# define XML_FALSE ((XML_Bool)0) ------------------ 6152| 150| } 6153| 812| } else { 6154| 91| poolDiscard(&dtd->pool); ------------------ | | 675| 91|#define poolDiscard(pool) ((pool)->ptr = (pool)->start) ------------------ 6155| 91| parser->m_declEntity = NULL; 6156| 91| } 6157| |#else /* not XML_DTD */ 6158| | parser->m_declEntity = NULL; 6159| |#endif /* XML_DTD */ 6160| 903| break; 6161| 903| case XML_ROLE_NOTATION_NAME: ------------------ | Branch (6161:5): [True: 866, False: 160k] ------------------ 6162| 866| parser->m_declNotationPublicId = NULL; 6163| 866| parser->m_declNotationName = NULL; 6164| 866| if (parser->m_notationDeclHandler) { ------------------ | Branch (6164:11): [True: 0, False: 866] ------------------ 6165| 0| parser->m_declNotationName 6166| 0| = poolStoreString(&parser->m_tempPool, enc, s, next); 6167| 0| if (! parser->m_declNotationName) ------------------ | Branch (6167:13): [True: 0, False: 0] ------------------ 6168| 0| return XML_ERROR_NO_MEMORY; 6169| 0| poolFinish(&parser->m_tempPool); ------------------ | | 676| 0|#define poolFinish(pool) ((pool)->start = (pool)->ptr) ------------------ 6170| 0| handleDefault = XML_FALSE; ------------------ | | 64| 0|# define XML_FALSE ((XML_Bool)0) ------------------ 6171| 0| } 6172| 866| break; 6173| 866| case XML_ROLE_NOTATION_PUBLIC_ID: ------------------ | Branch (6173:5): [True: 533, False: 160k] ------------------ 6174| 533| if (! XmlIsPublicId(enc, s, next, eventPP)) ------------------ | | 272| 533| (((enc)->isPublicId)(enc, ptr, end, badPtr)) ------------------ | Branch (6174:11): [True: 1, False: 532] ------------------ 6175| 1| return XML_ERROR_PUBLICID; 6176| 532| if (parser ------------------ | Branch (6176:11): [True: 0, False: 532] ------------------ 6177| 532| ->m_declNotationName) { /* means m_notationDeclHandler != NULL */ 6178| 0| XML_Char *tem = poolStoreString(&parser->m_tempPool, enc, 6179| 0| s + enc->minBytesPerChar, 6180| 0| next - enc->minBytesPerChar); 6181| 0| if (! tem) ------------------ | Branch (6181:13): [True: 0, False: 0] ------------------ 6182| 0| return XML_ERROR_NO_MEMORY; 6183| 0| normalizePublicId(tem); 6184| 0| parser->m_declNotationPublicId = tem; 6185| 0| poolFinish(&parser->m_tempPool); ------------------ | | 676| 0|#define poolFinish(pool) ((pool)->start = (pool)->ptr) ------------------ 6186| 0| handleDefault = XML_FALSE; ------------------ | | 64| 0|# define XML_FALSE ((XML_Bool)0) ------------------ 6187| 0| } 6188| 532| break; 6189| 532| case XML_ROLE_NOTATION_SYSTEM_ID: ------------------ | Branch (6189:5): [True: 404, False: 161k] ------------------ 6190| 404| if (parser->m_declNotationName && parser->m_notationDeclHandler) { ------------------ | Branch (6190:11): [True: 0, False: 404] | Branch (6190:41): [True: 0, False: 0] ------------------ 6191| 0| const XML_Char *systemId = poolStoreString(&parser->m_tempPool, enc, 6192| 0| s + enc->minBytesPerChar, 6193| 0| next - enc->minBytesPerChar); 6194| 0| if (! systemId) ------------------ | Branch (6194:13): [True: 0, False: 0] ------------------ 6195| 0| return XML_ERROR_NO_MEMORY; 6196| 0| *eventEndPP = s; 6197| 0| beforeHandler(parser); 6198| 0| parser->m_notationDeclHandler( 6199| 0| parser->m_handlerArg, parser->m_declNotationName, parser->m_curBase, 6200| 0| systemId, parser->m_declNotationPublicId); 6201| 0| afterHandler(parser); 6202| 0| handleDefault = XML_FALSE; ------------------ | | 64| 0|# define XML_FALSE ((XML_Bool)0) ------------------ 6203| 0| } 6204| 404| poolClear(&parser->m_tempPool); 6205| 404| break; 6206| 411| case XML_ROLE_NOTATION_NO_SYSTEM_ID: ------------------ | Branch (6206:5): [True: 411, False: 161k] ------------------ 6207| 411| if (parser->m_declNotationPublicId && parser->m_notationDeclHandler) { ------------------ | Branch (6207:11): [True: 0, False: 411] | Branch (6207:45): [True: 0, False: 0] ------------------ 6208| 0| *eventEndPP = s; 6209| 0| beforeHandler(parser); 6210| 0| parser->m_notationDeclHandler( 6211| 0| parser->m_handlerArg, parser->m_declNotationName, parser->m_curBase, 6212| 0| 0, parser->m_declNotationPublicId); 6213| 0| afterHandler(parser); 6214| 0| handleDefault = XML_FALSE; ------------------ | | 64| 0|# define XML_FALSE ((XML_Bool)0) ------------------ 6215| 0| } 6216| 411| poolClear(&parser->m_tempPool); 6217| 411| break; 6218| 1.52k| case XML_ROLE_ERROR: ------------------ | Branch (6218:5): [True: 1.52k, False: 159k] ------------------ 6219| 1.52k| switch (tok) { 6220| 42| case XML_TOK_PARAM_ENTITY_REF: ------------------ | | 95| 42|# define XML_TOK_PARAM_ENTITY_REF 28 ------------------ | Branch (6220:7): [True: 42, False: 1.48k] ------------------ 6221| | /* PE references in internal subset are 6222| | not allowed within declarations. */ 6223| 42| return XML_ERROR_PARAM_ENTITY_REF; 6224| 2| case XML_TOK_XML_DECL: ------------------ | | 77| 2|# define XML_TOK_XML_DECL 12 /* XML decl or text decl */ ------------------ | Branch (6224:7): [True: 2, False: 1.52k] ------------------ 6225| 2| return XML_ERROR_MISPLACED_XML_PI; 6226| 1.48k| default: ------------------ | Branch (6226:7): [True: 1.48k, False: 44] ------------------ 6227| 1.48k| return XML_ERROR_SYNTAX; 6228| 1.52k| } 6229| 0|#ifdef XML_DTD 6230| 0| case XML_ROLE_IGNORE_SECT: { ------------------ | Branch (6230:5): [True: 0, False: 161k] ------------------ 6231| 0| enum XML_Error result; 6232| 0| if (parser->m_defaultHandler) ------------------ | Branch (6232:11): [True: 0, False: 0] ------------------ 6233| 0| reportDefault(parser, enc, s, next); 6234| 0| handleDefault = XML_FALSE; ------------------ | | 64| 0|# define XML_FALSE ((XML_Bool)0) ------------------ 6235| 0| result = doIgnoreSection(parser, enc, &next, end, nextPtr, haveMore); 6236| 0| if (result != XML_ERROR_NONE) ------------------ | Branch (6236:11): [True: 0, False: 0] ------------------ 6237| 0| return result; 6238| 0| else if (! next) { ------------------ | Branch (6238:16): [True: 0, False: 0] ------------------ 6239| 0| parser->m_processor = ignoreSectionProcessor; 6240| 0| return result; 6241| 0| } 6242| 0| } break; 6243| 0|#endif /* XML_DTD */ 6244| 8.37k| case XML_ROLE_GROUP_OPEN: ------------------ | Branch (6244:5): [True: 8.37k, False: 153k] ------------------ 6245| 8.37k| if (parser->m_prologState.level >= parser->m_groupSize) { ------------------ | Branch (6245:11): [True: 584, False: 7.79k] ------------------ 6246| 584| if (parser->m_groupSize) { ------------------ | Branch (6246:13): [True: 99, False: 485] ------------------ 6247| | /* Detect and prevent integer overflow */ 6248| 99| if (parser->m_groupSize > SIZE_MAX / 2) { ------------------ | Branch (6248:15): [True: 0, False: 99] ------------------ 6249| 0| return XML_ERROR_NO_MEMORY; 6250| 0| } 6251| | 6252| 99| char *const new_connector = REALLOC(parser, parser->m_groupConnector, ------------------ | | 836| 99|# define REALLOC(parser, p, s) (expat_realloc((parser), (p), (s), __LINE__)) ------------------ 6253| 99| parser->m_groupSize *= 2); 6254| 99| if (new_connector == NULL) { ------------------ | Branch (6254:15): [True: 0, False: 99] ------------------ 6255| 0| parser->m_groupSize /= 2; 6256| 0| return XML_ERROR_NO_MEMORY; 6257| 0| } 6258| 99| parser->m_groupConnector = new_connector; 6259| 485| } else { 6260| 485| parser->m_groupConnector = MALLOC(parser, parser->m_groupSize = 32); ------------------ | | 835| 485|# define MALLOC(parser, s) (expat_malloc((parser), (s), __LINE__)) ------------------ 6261| 485| if (! parser->m_groupConnector) { ------------------ | Branch (6261:15): [True: 0, False: 485] ------------------ 6262| 0| parser->m_groupSize = 0; 6263| 0| return XML_ERROR_NO_MEMORY; 6264| 0| } 6265| 485| } 6266| 584| } 6267| 8.37k| parser->m_groupConnector[parser->m_prologState.level] = 0; 6268| 8.37k| if (dtd->in_eldecl) { ------------------ | Branch (6268:11): [True: 0, False: 8.37k] ------------------ 6269| 0| int myindex = nextScaffoldPart(parser); 6270| 0| if (myindex < 0) ------------------ | Branch (6270:13): [True: 0, False: 0] ------------------ 6271| 0| return XML_ERROR_NO_MEMORY; 6272| 0| assert(dtd->scaffIndex != NULL); ------------------ | Branch (6272:9): [True: 0, False: 0] | Branch (6272:9): [True: 0, False: 0] ------------------ 6273| 0| if ((size_t)dtd->scaffLevel >= dtd->scaffIndexSize) { ------------------ | Branch (6273:13): [True: 0, False: 0] ------------------ 6274| | /* Detect and prevent integer overflow */ 6275| 0| if (dtd->scaffIndexSize > SIZE_MAX / 2 / sizeof(int)) { ------------------ | Branch (6275:15): [True: 0, False: 0] ------------------ 6276| 0| return XML_ERROR_NO_MEMORY; 6277| 0| } 6278| 0| assert(dtd->scaffIndexSize > 0); ------------------ | Branch (6278:11): [True: 0, False: 0] | Branch (6278:11): [True: 0, False: 0] ------------------ 6279| 0| const size_t new_size = dtd->scaffIndexSize * 2; 6280| 0| int *const new_scaff_index 6281| 0| = REALLOC(parser, dtd->scaffIndex, new_size * sizeof(int)); ------------------ | | 836| 0|# define REALLOC(parser, p, s) (expat_realloc((parser), (p), (s), __LINE__)) ------------------ 6282| 0| if (new_scaff_index == NULL) { ------------------ | Branch (6282:15): [True: 0, False: 0] ------------------ 6283| 0| return XML_ERROR_NO_MEMORY; 6284| 0| } 6285| 0| dtd->scaffIndex = new_scaff_index; 6286| 0| dtd->scaffIndexSize = new_size; 6287| 0| } 6288| 0| dtd->scaffIndex[dtd->scaffLevel] = myindex; 6289| 0| dtd->scaffLevel++; 6290| 0| dtd->scaffold[myindex].type = XML_CTYPE_SEQ; 6291| 0| if (parser->m_elementDeclHandler) ------------------ | Branch (6291:13): [True: 0, False: 0] ------------------ 6292| 0| handleDefault = XML_FALSE; ------------------ | | 64| 0|# define XML_FALSE ((XML_Bool)0) ------------------ 6293| 0| } 6294| 8.37k| break; 6295| 8.37k| case XML_ROLE_GROUP_SEQUENCE: ------------------ | Branch (6295:5): [True: 1.63k, False: 159k] ------------------ 6296| 1.63k| if (parser->m_groupConnector[parser->m_prologState.level] == ASCII_PIPE) ------------------ | | 124| 1.63k|#define ASCII_PIPE 0x7C ------------------ | Branch (6296:11): [True: 1, False: 1.63k] ------------------ 6297| 1| return XML_ERROR_SYNTAX; 6298| 1.63k| parser->m_groupConnector[parser->m_prologState.level] = ASCII_COMMA; ------------------ | | 125| 1.63k|#define ASCII_COMMA 0x2C ------------------ 6299| 1.63k| if (dtd->in_eldecl && parser->m_elementDeclHandler) ------------------ | Branch (6299:11): [True: 0, False: 1.63k] | Branch (6299:29): [True: 0, False: 0] ------------------ 6300| 0| handleDefault = XML_FALSE; ------------------ | | 64| 0|# define XML_FALSE ((XML_Bool)0) ------------------ 6301| 1.63k| break; 6302| 1.61k| case XML_ROLE_GROUP_CHOICE: ------------------ | Branch (6302:5): [True: 1.61k, False: 159k] ------------------ 6303| 1.61k| if (parser->m_groupConnector[parser->m_prologState.level] == ASCII_COMMA) ------------------ | | 125| 1.61k|#define ASCII_COMMA 0x2C ------------------ | Branch (6303:11): [True: 1, False: 1.61k] ------------------ 6304| 1| return XML_ERROR_SYNTAX; 6305| 1.61k| if (dtd->in_eldecl ------------------ | Branch (6305:11): [True: 0, False: 1.61k] ------------------ 6306| 0| && ! parser->m_groupConnector[parser->m_prologState.level] ------------------ | Branch (6306:14): [True: 0, False: 0] ------------------ 6307| 0| && (dtd->scaffold[dtd->scaffIndex[dtd->scaffLevel - 1]].type ------------------ | Branch (6307:14): [True: 0, False: 0] ------------------ 6308| 0| != XML_CTYPE_MIXED)) { 6309| 0| dtd->scaffold[dtd->scaffIndex[dtd->scaffLevel - 1]].type 6310| 0| = XML_CTYPE_CHOICE; 6311| 0| if (parser->m_elementDeclHandler) ------------------ | Branch (6311:13): [True: 0, False: 0] ------------------ 6312| 0| handleDefault = XML_FALSE; ------------------ | | 64| 0|# define XML_FALSE ((XML_Bool)0) ------------------ 6313| 0| } 6314| 1.61k| parser->m_groupConnector[parser->m_prologState.level] = ASCII_PIPE; ------------------ | | 124| 1.61k|#define ASCII_PIPE 0x7C ------------------ 6315| 1.61k| break; 6316| 789| case XML_ROLE_PARAM_ENTITY_REF: ------------------ | Branch (6316:5): [True: 789, False: 160k] ------------------ 6317| 789|#ifdef XML_DTD 6318| 789| case XML_ROLE_INNER_PARAM_ENTITY_REF: ------------------ | Branch (6318:5): [True: 0, False: 161k] ------------------ 6319| 789| dtd->hasParamEntityRefs = XML_TRUE; ------------------ | | 63| 789|# define XML_TRUE ((XML_Bool)1) ------------------ 6320| 789| if (! parser->m_paramEntityParsing) ------------------ | Branch (6320:11): [True: 789, False: 0] ------------------ 6321| 789| dtd->keepProcessing = dtd->standalone; 6322| 0| else { 6323| 0| const XML_Char *name; 6324| 0| ENTITY *entity; 6325| 0| name = poolStoreString(&dtd->pool, enc, s + enc->minBytesPerChar, 6326| 0| next - enc->minBytesPerChar); 6327| 0| if (! name) ------------------ | Branch (6327:13): [True: 0, False: 0] ------------------ 6328| 0| return XML_ERROR_NO_MEMORY; 6329| 0| entity = (ENTITY *)lookup(parser, &dtd->paramEntities, name, 0); 6330| 0| poolDiscard(&dtd->pool); ------------------ | | 675| 0|#define poolDiscard(pool) ((pool)->ptr = (pool)->start) ------------------ 6331| | /* first, determine if a check for an existing declaration is needed; 6332| | if yes, check that the entity exists, and that it is internal, 6333| | otherwise call the skipped entity handler 6334| | */ 6335| 0| if (parser->m_prologState.documentEntity ------------------ | Branch (6335:13): [True: 0, False: 0] ------------------ 6336| 0| && (dtd->standalone ? ! parser->m_openInternalEntities ------------------ | Branch (6336:16): [True: 0, False: 0] | Branch (6336:17): [True: 0, False: 0] ------------------ 6337| 0| : ! dtd->hasParamEntityRefs)) { 6338| 0| if (! entity) ------------------ | Branch (6338:15): [True: 0, False: 0] ------------------ 6339| 0| return XML_ERROR_UNDEFINED_ENTITY; 6340| 0| else if (! entity->is_internal) { ------------------ | Branch (6340:20): [True: 0, False: 0] ------------------ 6341| | /* It's hard to exhaustively search the code to be sure, 6342| | * but there doesn't seem to be a way of executing the 6343| | * following line. There are two cases: 6344| | * 6345| | * If 'standalone' is false, the DTD must have no 6346| | * parameter entities or we wouldn't have passed the outer 6347| | * 'if' statement. That means the only entity in the hash 6348| | * table is the external subset name "#" which cannot be 6349| | * given as a parameter entity name in XML syntax, so the 6350| | * lookup must have returned NULL and we don't even reach 6351| | * the test for an internal entity. 6352| | * 6353| | * If 'standalone' is true, it does not seem to be 6354| | * possible to create entities taking this code path that 6355| | * are not internal entities, so fail the test above. 6356| | * 6357| | * Because this analysis is very uncertain, the code is 6358| | * being left in place and merely removed from the 6359| | * coverage test statistics. 6360| | */ 6361| 0| return XML_ERROR_ENTITY_DECLARED_IN_PE; /* LCOV_EXCL_LINE */ 6362| 0| } 6363| 0| } else if (! entity) { ------------------ | Branch (6363:20): [True: 0, False: 0] ------------------ 6364| 0| dtd->keepProcessing = dtd->standalone; 6365| | /* cannot report skipped entities in declarations */ 6366| 0| if ((role == XML_ROLE_PARAM_ENTITY_REF) ------------------ | Branch (6366:15): [True: 0, False: 0] ------------------ 6367| 0| && parser->m_skippedEntityHandler) { ------------------ | Branch (6367:18): [True: 0, False: 0] ------------------ 6368| 0| beforeHandler(parser); 6369| 0| parser->m_skippedEntityHandler(parser->m_handlerArg, name, 1); 6370| 0| afterHandler(parser); 6371| 0| handleDefault = XML_FALSE; ------------------ | | 64| 0|# define XML_FALSE ((XML_Bool)0) ------------------ 6372| 0| } 6373| 0| break; 6374| 0| } 6375| 0| if (entity->open) ------------------ | Branch (6375:13): [True: 0, False: 0] ------------------ 6376| 0| return XML_ERROR_RECURSIVE_ENTITY_REF; 6377| 0| if (entity->textPtr) { ------------------ | Branch (6377:13): [True: 0, False: 0] ------------------ 6378| 0| enum XML_Error result; 6379| 0| bool betweenDecl = (role == XML_ROLE_PARAM_ENTITY_REF); 6380| 0| result = processEntity(parser, entity, betweenDecl, ENTITY_INTERNAL); 6381| 0| if (result != XML_ERROR_NONE) ------------------ | Branch (6381:15): [True: 0, False: 0] ------------------ 6382| 0| return result; 6383| 0| handleDefault = XML_FALSE; ------------------ | | 64| 0|# define XML_FALSE ((XML_Bool)0) ------------------ 6384| 0| break; 6385| 0| } 6386| 0| if (parser->m_externalEntityRefHandler) { ------------------ | Branch (6386:13): [True: 0, False: 0] ------------------ 6387| 0| dtd->paramEntityRead = false; 6388| 0| entity->open = true; 6389| 0| entityTrackingOnOpen(parser, entity, __LINE__); 6390| 0| beforeHandler(parser); 6391| 0| const int status = parser->m_externalEntityRefHandler( 6392| 0| parser->m_externalEntityRefHandlerArg, 0, entity->base, 6393| 0| entity->systemId, entity->publicId); 6394| 0| afterHandler(parser); 6395| 0| if (! status) { ------------------ | Branch (6395:15): [True: 0, False: 0] ------------------ 6396| 0| entityTrackingOnClose(parser, entity, __LINE__); 6397| 0| entity->open = false; 6398| 0| return XML_ERROR_EXTERNAL_ENTITY_HANDLING; 6399| 0| } 6400| 0| entityTrackingOnClose(parser, entity, __LINE__); 6401| 0| entity->open = false; 6402| 0| handleDefault = XML_FALSE; ------------------ | | 64| 0|# define XML_FALSE ((XML_Bool)0) ------------------ 6403| 0| if (! dtd->paramEntityRead) { ------------------ | Branch (6403:15): [True: 0, False: 0] ------------------ 6404| 0| dtd->keepProcessing = dtd->standalone; 6405| 0| break; 6406| 0| } 6407| 0| } else { 6408| 0| dtd->keepProcessing = dtd->standalone; 6409| 0| break; 6410| 0| } 6411| 0| } 6412| 789|#endif /* XML_DTD */ 6413| 789| if (! dtd->standalone && parser->m_notStandaloneHandler) { ------------------ | Branch (6413:11): [True: 789, False: 0] | Branch (6413:32): [True: 0, False: 789] ------------------ 6414| 0| beforeHandler(parser); 6415| 0| const int status = parser->m_notStandaloneHandler(parser->m_handlerArg); 6416| 0| afterHandler(parser); 6417| 0| if (! status) ------------------ | Branch (6417:13): [True: 0, False: 0] ------------------ 6418| 0| return XML_ERROR_NOT_STANDALONE; 6419| 0| } 6420| 789| break; 6421| | 6422| | /* Element declaration stuff */ 6423| | 6424| 1.55k| case XML_ROLE_ELEMENT_NAME: ------------------ | Branch (6424:5): [True: 1.55k, False: 159k] ------------------ 6425| 1.55k| if (parser->m_elementDeclHandler) { ------------------ | Branch (6425:11): [True: 0, False: 1.55k] ------------------ 6426| 0| parser->m_declElementType = getElementType(parser, enc, s, next); 6427| 0| if (! parser->m_declElementType) ------------------ | Branch (6427:13): [True: 0, False: 0] ------------------ 6428| 0| return XML_ERROR_NO_MEMORY; 6429| 0| dtd->scaffLevel = 0; 6430| 0| dtd->scaffCount = 0; 6431| 0| dtd->in_eldecl = true; 6432| 0| handleDefault = XML_FALSE; ------------------ | | 64| 0|# define XML_FALSE ((XML_Bool)0) ------------------ 6433| 0| } 6434| 1.55k| break; 6435| | 6436| 1.55k| case XML_ROLE_CONTENT_ANY: ------------------ | Branch (6436:5): [True: 82, False: 161k] ------------------ 6437| 148| case XML_ROLE_CONTENT_EMPTY: ------------------ | Branch (6437:5): [True: 66, False: 161k] ------------------ 6438| 148| if (dtd->in_eldecl) { ------------------ | Branch (6438:11): [True: 0, False: 148] ------------------ 6439| 0| if (parser->m_elementDeclHandler) { ------------------ | Branch (6439:13): [True: 0, False: 0] ------------------ 6440| | // NOTE: We are avoiding MALLOC(..) here to so that 6441| | // applications that are not using XML_FreeContentModel but 6442| | // plain free(..) or .free_fcn() to free the content model's 6443| | // memory are safe. 6444| 0| XML_Content *content = parser->m_mem.malloc_fcn(sizeof(XML_Content)); 6445| 0| if (! content) ------------------ | Branch (6445:15): [True: 0, False: 0] ------------------ 6446| 0| return XML_ERROR_NO_MEMORY; 6447| 0| content->quant = XML_CQUANT_NONE; 6448| 0| content->name = NULL; 6449| 0| content->numchildren = 0; 6450| 0| content->children = NULL; 6451| 0| content->type = ((role == XML_ROLE_CONTENT_ANY) ? XML_CTYPE_ANY ------------------ | Branch (6451:28): [True: 0, False: 0] ------------------ 6452| 0| : XML_CTYPE_EMPTY); 6453| 0| *eventEndPP = s; 6454| 0| beforeHandler(parser); 6455| 0| parser->m_elementDeclHandler( 6456| 0| parser->m_handlerArg, parser->m_declElementType->name, content); 6457| 0| afterHandler(parser); 6458| 0| handleDefault = XML_FALSE; ------------------ | | 64| 0|# define XML_FALSE ((XML_Bool)0) ------------------ 6459| 0| } 6460| 0| dtd->in_eldecl = false; 6461| 0| } 6462| 148| break; 6463| | 6464| 300| case XML_ROLE_CONTENT_PCDATA: ------------------ | Branch (6464:5): [True: 300, False: 161k] ------------------ 6465| 300| if (dtd->in_eldecl) { ------------------ | Branch (6465:11): [True: 0, False: 300] ------------------ 6466| 0| dtd->scaffold[dtd->scaffIndex[dtd->scaffLevel - 1]].type 6467| 0| = XML_CTYPE_MIXED; 6468| 0| if (parser->m_elementDeclHandler) ------------------ | Branch (6468:13): [True: 0, False: 0] ------------------ 6469| 0| handleDefault = XML_FALSE; ------------------ | | 64| 0|# define XML_FALSE ((XML_Bool)0) ------------------ 6470| 0| } 6471| 300| break; 6472| | 6473| 4.37k| case XML_ROLE_CONTENT_ELEMENT: ------------------ | Branch (6473:5): [True: 4.37k, False: 157k] ------------------ 6474| 4.37k| quant = XML_CQUANT_NONE; 6475| 4.37k| goto elementContent; 6476| 277| case XML_ROLE_CONTENT_ELEMENT_OPT: ------------------ | Branch (6476:5): [True: 277, False: 161k] ------------------ 6477| 277| quant = XML_CQUANT_OPT; 6478| 277| goto elementContent; 6479| 295| case XML_ROLE_CONTENT_ELEMENT_REP: ------------------ | Branch (6479:5): [True: 295, False: 161k] ------------------ 6480| 295| quant = XML_CQUANT_REP; 6481| 295| goto elementContent; 6482| 333| case XML_ROLE_CONTENT_ELEMENT_PLUS: ------------------ | Branch (6482:5): [True: 333, False: 161k] ------------------ 6483| 333| quant = XML_CQUANT_PLUS; 6484| 5.28k| elementContent: 6485| 5.28k| if (dtd->in_eldecl) { ------------------ | Branch (6485:11): [True: 0, False: 5.28k] ------------------ 6486| 0| ELEMENT_TYPE *el; 6487| 0| const XML_Char *name; 6488| 0| size_t nameLen; 6489| 0| const char *nxt 6490| 0| = (quant == XML_CQUANT_NONE ? next : next - enc->minBytesPerChar); ------------------ | Branch (6490:16): [True: 0, False: 0] ------------------ 6491| 0| int myindex = nextScaffoldPart(parser); 6492| 0| if (myindex < 0) ------------------ | Branch (6492:13): [True: 0, False: 0] ------------------ 6493| 0| return XML_ERROR_NO_MEMORY; 6494| 0| dtd->scaffold[myindex].type = XML_CTYPE_NAME; 6495| 0| dtd->scaffold[myindex].quant = quant; 6496| 0| el = getElementType(parser, enc, s, nxt); 6497| 0| if (! el) ------------------ | Branch (6497:13): [True: 0, False: 0] ------------------ 6498| 0| return XML_ERROR_NO_MEMORY; 6499| 0| name = el->name; 6500| 0| dtd->scaffold[myindex].name = name; 6501| 0| nameLen = xcslen(name) + /*null terminator*/ 1; 6502| | 6503| | /* Detect and prevent integer overflow */ 6504| 0| if (nameLen > UINT_MAX - dtd->contentStringLen) { ------------------ | Branch (6504:13): [True: 0, False: 0] ------------------ 6505| 0| return XML_ERROR_NO_MEMORY; 6506| 0| } 6507| | 6508| 0| dtd->contentStringLen += (unsigned)nameLen; 6509| 0| if (parser->m_elementDeclHandler) ------------------ | Branch (6509:13): [True: 0, False: 0] ------------------ 6510| 0| handleDefault = XML_FALSE; ------------------ | | 64| 0|# define XML_FALSE ((XML_Bool)0) ------------------ 6511| 0| } 6512| 5.28k| break; 6513| | 6514| 5.28k| case XML_ROLE_GROUP_CLOSE: ------------------ | Branch (6514:5): [True: 1.84k, False: 159k] ------------------ 6515| 1.84k| quant = XML_CQUANT_NONE; 6516| 1.84k| goto closeGroup; 6517| 253| case XML_ROLE_GROUP_CLOSE_OPT: ------------------ | Branch (6517:5): [True: 253, False: 161k] ------------------ 6518| 253| quant = XML_CQUANT_OPT; 6519| 253| goto closeGroup; 6520| 279| case XML_ROLE_GROUP_CLOSE_REP: ------------------ | Branch (6520:5): [True: 279, False: 161k] ------------------ 6521| 279| quant = XML_CQUANT_REP; 6522| 279| goto closeGroup; 6523| 326| case XML_ROLE_GROUP_CLOSE_PLUS: ------------------ | Branch (6523:5): [True: 326, False: 161k] ------------------ 6524| 326| quant = XML_CQUANT_PLUS; 6525| 2.70k| closeGroup: 6526| 2.70k| if (dtd->in_eldecl) { ------------------ | Branch (6526:11): [True: 0, False: 2.70k] ------------------ 6527| 0| if (parser->m_elementDeclHandler) ------------------ | Branch (6527:13): [True: 0, False: 0] ------------------ 6528| 0| handleDefault = XML_FALSE; ------------------ | | 64| 0|# define XML_FALSE ((XML_Bool)0) ------------------ 6529| 0| dtd->scaffLevel--; 6530| 0| dtd->scaffold[dtd->scaffIndex[dtd->scaffLevel]].quant = quant; 6531| 0| if (dtd->scaffLevel == 0) { ------------------ | Branch (6531:13): [True: 0, False: 0] ------------------ 6532| 0| if (! handleDefault) { ------------------ | Branch (6532:15): [True: 0, False: 0] ------------------ 6533| 0| XML_Content *model = build_model(parser); 6534| 0| if (! model) ------------------ | Branch (6534:17): [True: 0, False: 0] ------------------ 6535| 0| return XML_ERROR_NO_MEMORY; 6536| 0| *eventEndPP = s; 6537| 0| beforeHandler(parser); 6538| 0| parser->m_elementDeclHandler( 6539| 0| parser->m_handlerArg, parser->m_declElementType->name, model); 6540| 0| afterHandler(parser); 6541| 0| } 6542| 0| dtd->in_eldecl = false; 6543| 0| dtd->contentStringLen = 0; 6544| 0| } 6545| 0| } 6546| 2.70k| break; 6547| | /* End element declaration stuff */ 6548| | 6549| 3.12k| case XML_ROLE_PI: ------------------ | Branch (6549:5): [True: 3.12k, False: 158k] ------------------ 6550| 3.12k| if (! reportProcessingInstruction(parser, enc, s, next)) ------------------ | Branch (6550:11): [True: 0, False: 3.12k] ------------------ 6551| 0| return XML_ERROR_NO_MEMORY; 6552| 3.12k| handleDefault = XML_FALSE; ------------------ | | 64| 3.12k|# define XML_FALSE ((XML_Bool)0) ------------------ 6553| 3.12k| break; 6554| 824| case XML_ROLE_COMMENT: ------------------ | Branch (6554:5): [True: 824, False: 160k] ------------------ 6555| 824| if (! reportComment(parser, enc, s, next)) ------------------ | Branch (6555:11): [True: 0, False: 824] ------------------ 6556| 0| return XML_ERROR_NO_MEMORY; 6557| 824| handleDefault = XML_FALSE; ------------------ | | 64| 824|# define XML_FALSE ((XML_Bool)0) ------------------ 6558| 824| break; 6559| 1.43k| case XML_ROLE_NONE: ------------------ | Branch (6559:5): [True: 1.43k, False: 160k] ------------------ 6560| 1.43k| switch (tok) { ------------------ | Branch (6560:15): [True: 0, False: 1.43k] ------------------ 6561| 0| case XML_TOK_BOM: ------------------ | | 79| 0|# define XML_TOK_BOM 14 /* Byte order mark */ ------------------ | Branch (6561:7): [True: 0, False: 1.43k] ------------------ 6562| 0| handleDefault = XML_FALSE; ------------------ | | 64| 0|# define XML_FALSE ((XML_Bool)0) ------------------ 6563| 0| break; 6564| 1.43k| } 6565| 1.43k| break; 6566| 17.7k| case XML_ROLE_DOCTYPE_NONE: ------------------ | Branch (6566:5): [True: 17.7k, False: 143k] ------------------ 6567| 17.7k| if (parser->m_startDoctypeDeclHandler) ------------------ | Branch (6567:11): [True: 0, False: 17.7k] ------------------ 6568| 0| handleDefault = XML_FALSE; ------------------ | | 64| 0|# define XML_FALSE ((XML_Bool)0) ------------------ 6569| 17.7k| break; 6570| 25.2k| case XML_ROLE_ENTITY_NONE: ------------------ | Branch (6570:5): [True: 25.2k, False: 136k] ------------------ 6571| 25.2k| if (dtd->keepProcessing && parser->m_entityDeclHandler) ------------------ | Branch (6571:11): [True: 22.9k, False: 2.32k] | Branch (6571:34): [True: 0, False: 22.9k] ------------------ 6572| 0| handleDefault = XML_FALSE; ------------------ | | 64| 0|# define XML_FALSE ((XML_Bool)0) ------------------ 6573| 25.2k| break; 6574| 4.92k| case XML_ROLE_NOTATION_NONE: ------------------ | Branch (6574:5): [True: 4.92k, False: 156k] ------------------ 6575| 4.92k| if (parser->m_notationDeclHandler) ------------------ | Branch (6575:11): [True: 0, False: 4.92k] ------------------ 6576| 0| handleDefault = XML_FALSE; ------------------ | | 64| 0|# define XML_FALSE ((XML_Bool)0) ------------------ 6577| 4.92k| break; 6578| 22.5k| case XML_ROLE_ATTLIST_NONE: ------------------ | Branch (6578:5): [True: 22.5k, False: 138k] ------------------ 6579| 22.5k| if (dtd->keepProcessing && parser->m_attlistDeclHandler) ------------------ | Branch (6579:11): [True: 20.6k, False: 1.87k] | Branch (6579:34): [True: 0, False: 20.6k] ------------------ 6580| 0| handleDefault = XML_FALSE; ------------------ | | 64| 0|# define XML_FALSE ((XML_Bool)0) ------------------ 6581| 22.5k| break; 6582| 9.32k| case XML_ROLE_ELEMENT_NONE: ------------------ | Branch (6582:5): [True: 9.32k, False: 152k] ------------------ 6583| 9.32k| if (parser->m_elementDeclHandler) ------------------ | Branch (6583:11): [True: 0, False: 9.32k] ------------------ 6584| 0| handleDefault = XML_FALSE; ------------------ | | 64| 0|# define XML_FALSE ((XML_Bool)0) ------------------ 6585| 9.32k| break; 6586| 161k| } /* end of big switch */ 6587| | 6588| 151k| if (handleDefault && parser->m_defaultHandler) ------------------ | Branch (6588:9): [True: 147k, False: 4.08k] | Branch (6588:26): [True: 0, False: 147k] ------------------ 6589| 0| reportDefault(parser, enc, s, next); 6590| | 6591| 151k| switch (parser->m_parsingStatus.parsing) { 6592| 0| case XML_SUSPENDED: ------------------ | Branch (6592:5): [True: 0, False: 151k] ------------------ 6593| 0| *nextPtr = next; 6594| 0| return XML_ERROR_NONE; 6595| 0| case XML_FINISHED: ------------------ | Branch (6595:5): [True: 0, False: 151k] ------------------ 6596| 0| return XML_ERROR_ABORTED; 6597| 151k| case XML_PARSING: ------------------ | Branch (6597:5): [True: 151k, False: 0] ------------------ 6598| 151k| if (parser->m_reenter) { ------------------ | Branch (6598:11): [True: 0, False: 151k] ------------------ 6599| 0| *nextPtr = next; 6600| 0| return XML_ERROR_NONE; 6601| 0| } 6602| 151k| EXPAT_FALLTHROUGH; ------------------ | | 47| 151k|# define EXPAT_FALLTHROUGH __attribute__((fallthrough)) ------------------ 6603| 151k| default: ------------------ | Branch (6603:5): [True: 0, False: 151k] ------------------ 6604| 151k| s = next; 6605| 151k| tok = XmlPrologTok(enc, s, end, &next); ------------------ | | 226| 151k| XmlTok(enc, XML_PROLOG_STATE, ptr, end, nextTokPtr) | | ------------------ | | | | 223| 151k| (((enc)->scanners[state])(enc, ptr, end, nextTokPtr)) | | ------------------ ------------------ 6606| 151k| } 6607| 151k| } 6608| | /* not reached */ 6609| 12.0k|} xmlparse.c:accountingDiffTolerated: 9018| 17.2M| enum XML_Account account) { 9019| | /* Note: We need to check the token type *first* to be sure that 9020| | * we can even access variable , safely. 9021| | * E.g. for XML_TOK_NONE may hold an invalid pointer. */ 9022| 17.2M| switch (tok) { ------------------ | Branch (9022:11): [True: 700k, False: 16.5M] ------------------ 9023| 3.44k| case XML_TOK_INVALID: ------------------ | | 57| 3.44k|# define XML_TOK_INVALID 0 ------------------ | Branch (9023:3): [True: 3.44k, False: 17.2M] ------------------ 9024| 4.36k| case XML_TOK_PARTIAL: ------------------ | | 56| 4.36k|# define XML_TOK_PARTIAL -1 /* only part of a token */ ------------------ | Branch (9024:3): [True: 924, False: 17.2M] ------------------ 9025| 4.40k| case XML_TOK_PARTIAL_CHAR: ------------------ | | 55| 4.40k|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ ------------------ | Branch (9025:3): [True: 43, False: 17.2M] ------------------ 9026| 700k| case XML_TOK_NONE: ------------------ | | 51| 700k|# define XML_TOK_NONE -4 /* The string to be scanned is empty */ ------------------ | Branch (9026:3): [True: 696k, False: 16.5M] ------------------ 9027| 700k| return XML_TRUE; ------------------ | | 63| 700k|# define XML_TRUE ((XML_Bool)1) ------------------ 9028| 17.2M| } 9029| | 9030| 16.5M| if (account == XML_ACCOUNT_NONE) ------------------ | Branch (9030:7): [True: 40.1k, False: 16.5M] ------------------ 9031| 40.1k| return XML_TRUE; /* because these bytes have been accounted for, already */ ------------------ | | 63| 40.1k|# define XML_TRUE ((XML_Bool)1) ------------------ 9032| | 9033| 16.5M| unsigned int levelsAwayFromRootParser; 9034| 16.5M| const XML_Parser rootParser 9035| 16.5M| = getRootParserOf(originParser, &levelsAwayFromRootParser); 9036| 16.5M| assert(! rootParser->m_parentParser); ------------------ | Branch (9036:3): [True: 0, False: 16.5M] | Branch (9036:3): [True: 16.5M, False: 0] ------------------ 9037| | 9038| 16.5M| const int isDirect 9039| 16.5M| = (account == XML_ACCOUNT_DIRECT) && (originParser == rootParser); ------------------ | Branch (9039:9): [True: 234k, False: 16.2M] | Branch (9039:44): [True: 234k, False: 0] ------------------ 9040| 16.5M| const ptrdiff_t bytesMore = after - before; 9041| | 9042| 16.5M| XmlBigCount *const additionTarget 9043| 16.5M| = isDirect ? &rootParser->m_accounting.countBytesDirect ------------------ | Branch (9043:9): [True: 234k, False: 16.2M] ------------------ 9044| 16.5M| : &rootParser->m_accounting.countBytesIndirect; 9045| | 9046| | /* Detect and avoid integer overflow */ 9047| 16.5M| if (*additionTarget > (XmlBigCount)(-1) - (XmlBigCount)bytesMore) ------------------ | Branch (9047:7): [True: 0, False: 16.5M] ------------------ 9048| 0| return XML_FALSE; ------------------ | | 64| 0|# define XML_FALSE ((XML_Bool)0) ------------------ 9049| 16.5M| *additionTarget += bytesMore; 9050| | 9051| 16.5M| const XmlBigCount countBytesOutput 9052| 16.5M| = rootParser->m_accounting.countBytesDirect 9053| 16.5M| + rootParser->m_accounting.countBytesIndirect; 9054| 16.5M| const float amplificationFactor 9055| 16.5M| = accountingGetCurrentAmplification(rootParser); 9056| 16.5M| const XML_Bool tolerated 9057| 16.5M| = (countBytesOutput < rootParser->m_accounting.activationThresholdBytes) ------------------ | Branch (9057:9): [True: 16.5M, False: 23] ------------------ 9058| 23| || (amplificationFactor ------------------ | Branch (9058:12): [True: 23, False: 0] ------------------ 9059| 23| <= rootParser->m_accounting.maximumAmplificationFactor); 9060| | 9061| 16.5M| if (rootParser->m_accounting.debugLevel >= 2u) { ------------------ | Branch (9061:7): [True: 0, False: 16.5M] ------------------ 9062| 0| accountingReportStats(rootParser, ""); 9063| 0| accountingReportDiff(rootParser, levelsAwayFromRootParser, before, after, 9064| 0| bytesMore, source_line, account); 9065| 0| } 9066| | 9067| 16.5M| return tolerated; 9068| 16.5M|} xmlparse.c:accountingGetCurrentAmplification: 8937| 16.5M|accountingGetCurrentAmplification(XML_Parser rootParser) { 8938| | // 1.........1.........12 => 22 8939| 16.5M| const size_t lenOfShortestInclude = sizeof("") - 1; 8940| 16.5M| const XmlBigCount countBytesOutput 8941| 16.5M| = rootParser->m_accounting.countBytesDirect 8942| 16.5M| + rootParser->m_accounting.countBytesIndirect; 8943| 16.5M| const float amplificationFactor 8944| 16.5M| = rootParser->m_accounting.countBytesDirect ------------------ | Branch (8944:9): [True: 16.5M, False: 0] ------------------ 8945| 16.5M| ? ((float)countBytesOutput 8946| 16.5M| / (float)(rootParser->m_accounting.countBytesDirect)) 8947| 16.5M| : ((float)(lenOfShortestInclude 8948| 0| + rootParser->m_accounting.countBytesIndirect) 8949| 0| / (float)lenOfShortestInclude); 8950| 16.5M| assert(! rootParser->m_parentParser); ------------------ | Branch (8950:3): [True: 0, False: 16.5M] | Branch (8950:3): [True: 16.5M, False: 0] ------------------ 8951| 16.5M| return amplificationFactor; 8952| 16.5M|} xmlparse.c:processXmlDecl: 5126| 481| const char *next) { 5127| 481| const char *encodingName = NULL; 5128| 481| const XML_Char *storedEncName = NULL; 5129| 481| const ENCODING *newEncoding = NULL; 5130| 481| const char *version = NULL; 5131| 481| const char *versionend = NULL; 5132| 481| const XML_Char *storedversion = NULL; 5133| 481| int standalone = -1; 5134| | 5135| 481|#if XML_GE == 1 5136| 481| if (! accountingDiffTolerated(parser, XML_TOK_XML_DECL, s, next, __LINE__, ------------------ | | 77| 481|# define XML_TOK_XML_DECL 12 /* XML decl or text decl */ ------------------ | Branch (5136:7): [True: 0, False: 481] ------------------ 5137| 481| XML_ACCOUNT_DIRECT)) { 5138| 0| accountingOnAbort(parser); 5139| 0| return XML_ERROR_AMPLIFICATION_LIMIT_BREACH; 5140| 0| } 5141| 481|#endif 5142| | 5143| 481| if (! (parser->m_ns ? XmlParseXmlDeclNS : XmlParseXmlDecl)( ------------------ | Branch (5143:7): [True: 344, False: 137] | Branch (5143:10): [True: 269, False: 212] ------------------ 5144| 481| isGeneralTextEntity, parser->m_encoding, s, next, &parser->m_eventPtr, 5145| 481| &version, &versionend, &encodingName, &newEncoding, &standalone)) { 5146| 344| if (isGeneralTextEntity) ------------------ | Branch (5146:9): [True: 0, False: 344] ------------------ 5147| 0| return XML_ERROR_TEXT_DECL; 5148| 344| else 5149| 344| return XML_ERROR_XML_DECL; 5150| 344| } 5151| 137| if (! isGeneralTextEntity && standalone == 1) { ------------------ | Branch (5151:7): [True: 137, False: 0] | Branch (5151:32): [True: 0, False: 137] ------------------ 5152| 0| parser->m_dtd->standalone = XML_TRUE; ------------------ | | 63| 0|# define XML_TRUE ((XML_Bool)1) ------------------ 5153| 0|#ifdef XML_DTD 5154| 0| if (parser->m_paramEntityParsing ------------------ | Branch (5154:9): [True: 0, False: 0] ------------------ 5155| 0| == XML_PARAM_ENTITY_PARSING_UNLESS_STANDALONE) 5156| 0| parser->m_paramEntityParsing = XML_PARAM_ENTITY_PARSING_NEVER; 5157| 0|#endif /* XML_DTD */ 5158| 0| } 5159| 137| if (parser->m_xmlDeclHandler) { ------------------ | Branch (5159:7): [True: 0, False: 137] ------------------ 5160| 0| if (encodingName != NULL) { ------------------ | Branch (5160:9): [True: 0, False: 0] ------------------ 5161| 0| storedEncName = poolStoreString( 5162| 0| &parser->m_temp2Pool, parser->m_encoding, encodingName, 5163| 0| encodingName + XmlNameLength(parser->m_encoding, encodingName)); ------------------ | | 256| 0|# define XmlNameLength(enc, ptr) (((enc)->nameLength)(enc, ptr)) ------------------ 5164| 0| if (! storedEncName) ------------------ | Branch (5164:11): [True: 0, False: 0] ------------------ 5165| 0| return XML_ERROR_NO_MEMORY; 5166| 0| poolFinish(&parser->m_temp2Pool); ------------------ | | 676| 0|#define poolFinish(pool) ((pool)->start = (pool)->ptr) ------------------ 5167| 0| } 5168| 0| if (version) { ------------------ | Branch (5168:9): [True: 0, False: 0] ------------------ 5169| 0| storedversion 5170| 0| = poolStoreString(&parser->m_temp2Pool, parser->m_encoding, version, 5171| 0| versionend - parser->m_encoding->minBytesPerChar); 5172| 0| if (! storedversion) ------------------ | Branch (5172:11): [True: 0, False: 0] ------------------ 5173| 0| return XML_ERROR_NO_MEMORY; 5174| 0| } 5175| 0| beforeHandler(parser); 5176| 0| parser->m_xmlDeclHandler(parser->m_handlerArg, storedversion, storedEncName, 5177| 0| standalone); 5178| 0| afterHandler(parser); 5179| 137| } else if (parser->m_defaultHandler) ------------------ | Branch (5179:14): [True: 0, False: 137] ------------------ 5180| 0| reportDefault(parser, parser->m_encoding, s, next); 5181| 137| if (parser->m_protocolEncodingName == NULL) { ------------------ | Branch (5181:7): [True: 0, False: 137] ------------------ 5182| 0| if (newEncoding) { ------------------ | Branch (5182:9): [True: 0, False: 0] ------------------ 5183| | /* Check that the specified encoding does not conflict with what 5184| | * the parser has already deduced. Do we have the same number 5185| | * of bytes in the smallest representation of a character? If 5186| | * this is UTF-16, is it the same endianness? 5187| | */ 5188| 0| if (newEncoding->minBytesPerChar != parser->m_encoding->minBytesPerChar ------------------ | Branch (5188:11): [True: 0, False: 0] ------------------ 5189| 0| || (newEncoding->minBytesPerChar == 2 ------------------ | Branch (5189:15): [True: 0, False: 0] ------------------ 5190| 0| && newEncoding != parser->m_encoding)) { ------------------ | Branch (5190:18): [True: 0, False: 0] ------------------ 5191| 0| parser->m_eventPtr = encodingName; 5192| 0| return XML_ERROR_INCORRECT_ENCODING; 5193| 0| } 5194| 0| parser->m_encoding = newEncoding; 5195| 0| } else if (encodingName) { ------------------ | Branch (5195:16): [True: 0, False: 0] ------------------ 5196| 0| enum XML_Error result; 5197| 0| if (! storedEncName) { ------------------ | Branch (5197:11): [True: 0, False: 0] ------------------ 5198| 0| storedEncName = poolStoreString( 5199| 0| &parser->m_temp2Pool, parser->m_encoding, encodingName, 5200| 0| encodingName + XmlNameLength(parser->m_encoding, encodingName)); ------------------ | | 256| 0|# define XmlNameLength(enc, ptr) (((enc)->nameLength)(enc, ptr)) ------------------ 5201| 0| if (! storedEncName) ------------------ | Branch (5201:13): [True: 0, False: 0] ------------------ 5202| 0| return XML_ERROR_NO_MEMORY; 5203| 0| } 5204| 0| result = handleUnknownEncoding(parser, storedEncName); 5205| 0| poolClear(&parser->m_temp2Pool); 5206| 0| if (result == XML_ERROR_UNKNOWN_ENCODING) ------------------ | Branch (5206:11): [True: 0, False: 0] ------------------ 5207| 0| parser->m_eventPtr = encodingName; 5208| 0| return result; 5209| 0| } 5210| 0| } 5211| | 5212| 137| if (storedEncName || storedversion) ------------------ | Branch (5212:7): [True: 0, False: 137] | Branch (5212:24): [True: 0, False: 137] ------------------ 5213| 0| poolClear(&parser->m_temp2Pool); 5214| | 5215| 137| return XML_ERROR_NONE; 5216| 137|} xmlparse.c:poolStoreString: 8523| 807k| const char *end) { 8524| 807k| if (! poolAppend(pool, enc, ptr, end)) ------------------ | Branch (8524:7): [True: 0, False: 807k] ------------------ 8525| 0| return NULL; 8526| 807k| if (! poolAppendChar(pool, 0)) ------------------ | Branch (8526:7): [True: 0, False: 807k] ------------------ 8527| 0| return NULL; 8528| 807k| return pool->start; 8529| 807k|} xmlparse.c:lookup: 8356| 860k|lookup(XML_Parser parser, HASH_TABLE *table, KEY name, size_t createSize) { 8357| 860k| return lookupWithLength(parser, table, name, keylen(name), createSize); 8358| 860k|} xmlparse.c:lookupWithLength: 8250| 860k| size_t createSize) { 8251| 860k| size_t i; 8252| 860k| if (table->size == 0) { ------------------ | Branch (8252:7): [True: 26.9k, False: 833k] ------------------ 8253| 26.9k| size_t tsize; 8254| 26.9k| if (! createSize) ------------------ | Branch (8254:9): [True: 8.43k, False: 18.5k] ------------------ 8255| 8.43k| return NULL; 8256| 18.5k| table->power = INIT_POWER; ------------------ | | 8183| 18.5k|#define INIT_POWER 6 ------------------ 8257| | /* table->size is a power of 2 */ 8258| 18.5k| table->size = (size_t)1 << INIT_POWER; ------------------ | | 8183| 18.5k|#define INIT_POWER 6 ------------------ 8259| 18.5k| tsize = table->size * sizeof(NAMED *); 8260| 18.5k| table->v = MALLOC(table->parser, tsize); ------------------ | | 835| 18.5k|# define MALLOC(parser, s) (expat_malloc((parser), (s), __LINE__)) ------------------ 8261| 18.5k| if (! table->v) { ------------------ | Branch (8261:9): [True: 0, False: 18.5k] ------------------ 8262| 0| table->size = 0; 8263| 0| return NULL; 8264| 0| } 8265| 18.5k| memset(table->v, 0, tsize); 8266| 18.5k| i = hash(parser, name, nameLen) & ((unsigned long)table->size - 1); 8267| 833k| } else { 8268| 833k| unsigned long h = hash(parser, name, nameLen); 8269| 833k| unsigned long mask = (unsigned long)table->size - 1; 8270| 833k| unsigned char step = 0; 8271| 833k| i = h & mask; 8272| 854k| while (table->v[i]) { ------------------ | Branch (8272:12): [True: 827k, False: 27.0k] ------------------ 8273| 827k| if (keyeq(name, nameLen, table->v[i]->name)) ------------------ | Branch (8273:11): [True: 806k, False: 21.8k] ------------------ 8274| 806k| return table->v[i]; 8275| 21.8k| if (! step) ------------------ | Branch (8275:11): [True: 19.8k, False: 2.08k] ------------------ 8276| 19.8k| step = PROBE_STEP(h, mask, table->power); ------------------ | | 251| 19.8k| ((unsigned char)((SECOND_HASH(hash, mask, power)) | 1)) | | ------------------ | | | | 249| 19.8k| ((((hash) & ~(mask)) >> ((power) - 1)) & ((mask) >> 2)) | | ------------------ ------------------ 8277| 21.8k| i < step ? (i += table->size - step) : (i -= step); ------------------ | Branch (8277:7): [True: 1.66k, False: 20.2k] ------------------ 8278| 21.8k| } 8279| 27.0k| if (! createSize) ------------------ | Branch (8279:9): [True: 11.7k, False: 15.2k] ------------------ 8280| 11.7k| return NULL; 8281| | 8282| | /* check for overflow (table is half full) */ 8283| 15.2k| if (table->used >> (table->power - 1)) { ------------------ | Branch (8283:9): [True: 125, False: 15.1k] ------------------ 8284| 125| unsigned char newPower = table->power + 1; 8285| | 8286| | /* Detect and prevent invalid shift */ 8287| 125| if (newPower >= sizeof(unsigned long) * 8 /* bits per byte */) { ------------------ | Branch (8287:11): [True: 0, False: 125] ------------------ 8288| 0| return NULL; 8289| 0| } 8290| | 8291| 125| size_t newSize = (size_t)1 << newPower; 8292| 125| unsigned long newMask = (unsigned long)newSize - 1; 8293| | 8294| | /* Detect and prevent integer overflow */ 8295| 125| if (newSize > SIZE_MAX / sizeof(NAMED *)) { ------------------ | Branch (8295:11): [True: 0, False: 125] ------------------ 8296| 0| return NULL; 8297| 0| } 8298| | 8299| 125| size_t tsize = newSize * sizeof(NAMED *); 8300| 125| NAMED **newV = MALLOC(table->parser, tsize); ------------------ | | 835| 125|# define MALLOC(parser, s) (expat_malloc((parser), (s), __LINE__)) ------------------ 8301| 125| if (! newV) ------------------ | Branch (8301:11): [True: 0, False: 125] ------------------ 8302| 0| return NULL; 8303| 125| memset(newV, 0, tsize); 8304| 10.4k| for (i = 0; i < table->size; i++) ------------------ | Branch (8304:19): [True: 10.3k, False: 125] ------------------ 8305| 10.3k| if (table->v[i]) { ------------------ | Branch (8305:13): [True: 5.15k, False: 5.15k] ------------------ 8306| 5.15k| KEY const key = table->v[i]->name; 8307| 5.15k| unsigned long newHash = hash(parser, key, keylen(key)); 8308| 5.15k| size_t j = newHash & newMask; 8309| 5.15k| step = 0; 8310| 5.86k| while (newV[j]) { ------------------ | Branch (8310:18): [True: 713, False: 5.15k] ------------------ 8311| 713| if (! step) ------------------ | Branch (8311:17): [True: 585, False: 128] ------------------ 8312| 585| step = PROBE_STEP(newHash, newMask, newPower); ------------------ | | 251| 585| ((unsigned char)((SECOND_HASH(hash, mask, power)) | 1)) | | ------------------ | | | | 249| 585| ((((hash) & ~(mask)) >> ((power) - 1)) & ((mask) >> 2)) | | ------------------ ------------------ 8313| 713| j < step ? (j += newSize - step) : (j -= step); ------------------ | Branch (8313:13): [True: 86, False: 627] ------------------ 8314| 713| } 8315| 5.15k| newV[j] = table->v[i]; 8316| 5.15k| } 8317| 125| FREE(table->parser, table->v); ------------------ | | 837| 125|# define FREE(parser, p) (expat_free((parser), (p), __LINE__)) ------------------ 8318| 125| table->v = newV; 8319| 125| table->power = newPower; 8320| 125| table->size = newSize; 8321| 125| i = h & newMask; 8322| 125| step = 0; 8323| 163| while (table->v[i]) { ------------------ | Branch (8323:14): [True: 38, False: 125] ------------------ 8324| 38| if (! step) ------------------ | Branch (8324:13): [True: 30, False: 8] ------------------ 8325| 30| step = PROBE_STEP(h, newMask, newPower); ------------------ | | 251| 30| ((unsigned char)((SECOND_HASH(hash, mask, power)) | 1)) | | ------------------ | | | | 249| 30| ((((hash) & ~(mask)) >> ((power) - 1)) & ((mask) >> 2)) | | ------------------ ------------------ 8326| 38| i < step ? (i += newSize - step) : (i -= step); ------------------ | Branch (8326:9): [True: 5, False: 33] ------------------ 8327| 38| } 8328| 125| } 8329| 15.2k| } 8330| 860k| assert(createSize >= sizeof(NAMED)); ------------------ | Branch (8330:3): [True: 0, False: 33.8k] | Branch (8330:3): [True: 33.8k, False: 0] ------------------ 8331| 33.8k| table->v[i] = MALLOC(table->parser, createSize); ------------------ | | 835| 33.8k|# define MALLOC(parser, s) (expat_malloc((parser), (s), __LINE__)) ------------------ 8332| 33.8k| if (! table->v[i]) ------------------ | Branch (8332:7): [True: 0, False: 33.8k] ------------------ 8333| 0| return NULL; 8334| 33.8k| memset(table->v[i], 0, createSize); 8335| 33.8k| table->v[i]->name = name; // NOTE: This requires and assumes zero termination! 8336| 33.8k| (table->used)++; 8337| 33.8k| return table->v[i]; 8338| 33.8k|} xmlparse.c:hash: 8219| 856k|hash(XML_Parser parser, KEY s, size_t keyLen) { 8220| 856k| struct siphash state; 8221| 856k| struct sipkey key; 8222| 856k| (void)sip24_valid; 8223| 856k| copy_salt_to_sipkey(parser, &key); 8224| 856k| sip24_init(&state, &key); 8225| 856k| sip24_update(&state, s, keyLen * sizeof(XML_Char)); 8226| 856k| return (unsigned long)sip24_final(&state); 8227| 856k|} xmlparse.c:copy_salt_to_sipkey: 8211| 877k|copy_salt_to_sipkey(XML_Parser parser, struct sipkey *key) { 8212| 877k| const XML_Parser rootParser = getRootParserOf(parser, NULL); 8213| 877k| assert(! rootParser->m_parentParser); ------------------ | Branch (8213:3): [True: 0, False: 877k] | Branch (8213:3): [True: 877k, False: 0] ------------------ 8214| | 8215| 877k| *key = rootParser->m_hash_secret_salt_128; 8216| 877k|} xmlparse.c:keyeq: 8189| 827k|keyeq(KEY s1, size_t s1len, KEY s2) { 8190| |#ifdef XML_UNICODE 8191| |# ifdef XML_UNICODE_WCHAR_T 8192| | return (wcsncmp(s1, s2, s1len) == 0 && s2[s1len] == L'\0') ? XML_TRUE 8193| | : XML_FALSE; 8194| |# else 8195| | for (; s1len > 0 && *s1 == *s2; s1len--, s1++, s2++) 8196| | ; /* no loop body! */ 8197| | return ((s1len == 0) && (*s2 == 0)) ? XML_TRUE : XML_FALSE; 8198| |# endif 8199| |#else 8200| 827k| return (strncmp(s1, s2, s1len) == 0 && s2[s1len] == '\0') ? XML_TRUE ------------------ | | 63| 806k|# define XML_TRUE ((XML_Bool)1) ------------------ | Branch (8200:11): [True: 806k, False: 21.8k] | Branch (8200:42): [True: 806k, False: 81] ------------------ 8201| 827k| : XML_FALSE; ------------------ | | 64| 849k|# define XML_FALSE ((XML_Bool)0) ------------------ 8202| 827k|#endif 8203| 827k|} xmlparse.c:keylen: 8206| 886k|keylen(KEY s) { 8207| 886k| return xcslen(s); 8208| 886k|} xmlparse.c:normalizePublicId: 7843| 345|normalizePublicId(XML_Char *publicId) { 7844| 345| XML_Char *p = publicId; 7845| 345| XML_Char *s; 7846| 6.45k| for (s = publicId; *s; s++) { ------------------ | Branch (7846:22): [True: 6.10k, False: 345] ------------------ 7847| 6.10k| switch (*s) { 7848| 654| case 0x20: ------------------ | Branch (7848:5): [True: 654, False: 5.45k] ------------------ 7849| 991| case 0xD: ------------------ | Branch (7849:5): [True: 337, False: 5.77k] ------------------ 7850| 1.18k| case 0xA: ------------------ | Branch (7850:5): [True: 195, False: 5.91k] ------------------ 7851| 1.18k| if (p != publicId && p[-1] != 0x20) ------------------ | Branch (7851:11): [True: 589, False: 597] | Branch (7851:28): [True: 235, False: 354] ------------------ 7852| 235| *p++ = 0x20; 7853| 1.18k| break; 7854| 4.92k| default: ------------------ | Branch (7854:5): [True: 4.92k, False: 1.18k] ------------------ 7855| 4.92k| *p++ = *s; 7856| 6.10k| } 7857| 6.10k| } 7858| 345| if (p != publicId && p[-1] == 0x20) ------------------ | Branch (7858:7): [True: 203, False: 142] | Branch (7858:24): [True: 26, False: 177] ------------------ 7859| 26| --p; 7860| 345| *p = XML_T('\0'); ------------------ | | 220| 345|# define XML_T(x) x ------------------ 7861| 345|} xmlparse.c:contentProcessor: 3445| 16.7k| const char **endPtr) { 3446| 16.7k| enum XML_Error result = doContent( 3447| 16.7k| parser, parser->m_parentParser ? 1 : 0, parser->m_encoding, start, end, ------------------ | Branch (3447:15): [True: 0, False: 16.7k] ------------------ 3448| 16.7k| endPtr, (XML_Bool)! parser->m_parsingStatus.finalBuffer, 3449| 16.7k| XML_ACCOUNT_DIRECT); 3450| 16.7k| if (result == XML_ERROR_NONE) { ------------------ | Branch (3450:7): [True: 9.46k, False: 7.33k] ------------------ 3451| 9.46k| if (! storeRawNames(parser)) ------------------ | Branch (3451:9): [True: 0, False: 9.46k] ------------------ 3452| 0| return XML_ERROR_NO_MEMORY; 3453| 9.46k| } 3454| 16.7k| return result; 3455| 16.7k|} xmlparse.c:doContent: 3581| 215k| XML_Bool haveMore, enum XML_Account account) { 3582| | /* save one level of indirection */ 3583| 215k| DTD *const dtd = parser->m_dtd; 3584| | 3585| 215k| const char **eventPP; 3586| 215k| const char **eventEndPP; 3587| 215k| if (enc == parser->m_encoding) { ------------------ | Branch (3587:7): [True: 16.7k, False: 198k] ------------------ 3588| 16.7k| eventPP = &parser->m_eventPtr; 3589| 16.7k| eventEndPP = &parser->m_eventEndPtr; 3590| 198k| } else { 3591| 198k| eventPP = &(parser->m_openInternalEntities->internalEventPtr); 3592| 198k| eventEndPP = &(parser->m_openInternalEntities->internalEventEndPtr); 3593| 198k| } 3594| 215k| *eventPP = s; 3595| | 3596| 477k| for (;;) { 3597| 477k| const char *next = s; /* XmlContentTok doesn't always set the last arg */ 3598| 477k| int tok = XmlContentTok(enc, s, end, &next); ------------------ | | 229| 477k| XmlTok(enc, XML_CONTENT_STATE, ptr, end, nextTokPtr) | | ------------------ | | | | 223| 477k| (((enc)->scanners[state])(enc, ptr, end, nextTokPtr)) | | ------------------ ------------------ 3599| 477k|#if XML_GE == 1 3600| 477k| const char *accountAfter 3601| 477k| = ((tok == XML_TOK_TRAILING_RSQB) || (tok == XML_TOK_TRAILING_CR)) ------------------ | | 46| 477k| -5 /* ] or ]] at the end of the scan; might be \ ------------------ = ((tok == XML_TOK_TRAILING_RSQB) || (tok == XML_TOK_TRAILING_CR)) ------------------ | | 53| 476k| -3 /* A CR at the end of the scan; \ ------------------ | Branch (3601:12): [True: 688, False: 476k] | Branch (3601:46): [True: 5, False: 476k] ------------------ 3602| 477k| ? (haveMore ? s /* i.e. 0 bytes */ : end) ------------------ | Branch (3602:18): [True: 0, False: 693] ------------------ 3603| 477k| : next; 3604| 477k| if (! accountingDiffTolerated(parser, tok, s, accountAfter, __LINE__, ------------------ | Branch (3604:9): [True: 0, False: 477k] ------------------ 3605| 477k| account)) { 3606| 0| accountingOnAbort(parser); 3607| 0| return XML_ERROR_AMPLIFICATION_LIMIT_BREACH; 3608| 0| } 3609| 477k|#endif 3610| 477k| *eventEndPP = next; 3611| 477k| switch (tok) { 3612| 5| case XML_TOK_TRAILING_CR: ------------------ | | 53| 5| -3 /* A CR at the end of the scan; \ ------------------ | Branch (3612:5): [True: 5, False: 477k] ------------------ 3613| 5| if (haveMore) { ------------------ | Branch (3613:11): [True: 0, False: 5] ------------------ 3614| 0| *nextPtr = s; 3615| 0| return XML_ERROR_NONE; 3616| 0| } 3617| 5| *eventEndPP = end; 3618| 5| if (parser->m_characterDataHandler) { ------------------ | Branch (3618:11): [True: 0, False: 5] ------------------ 3619| 0| XML_Char c = 0xA; 3620| 0| beforeHandler(parser); 3621| 0| parser->m_characterDataHandler(parser->m_handlerArg, &c, 1); 3622| 0| afterHandler(parser); 3623| 5| } else if (parser->m_defaultHandler) ------------------ | Branch (3623:18): [True: 0, False: 5] ------------------ 3624| 0| reportDefault(parser, enc, s, end); 3625| | /* We are at the end of the final buffer, should we check for 3626| | XML_SUSPENDED, XML_FINISHED? 3627| | */ 3628| 5| if (startTagLevel == 0) ------------------ | Branch (3628:11): [True: 5, False: 0] ------------------ 3629| 5| return XML_ERROR_NO_ELEMENTS; 3630| 0| if (parser->m_tagLevel != startTagLevel) ------------------ | Branch (3630:11): [True: 0, False: 0] ------------------ 3631| 0| return XML_ERROR_ASYNC_ENTITY; 3632| 0| *nextPtr = end; 3633| 0| return XML_ERROR_NONE; 3634| 102k| case XML_TOK_NONE: ------------------ | | 51| 102k|# define XML_TOK_NONE -4 /* The string to be scanned is empty */ ------------------ | Branch (3634:5): [True: 102k, False: 374k] ------------------ 3635| 102k| if (haveMore) { ------------------ | Branch (3635:11): [True: 0, False: 102k] ------------------ 3636| 0| *nextPtr = s; 3637| 0| return XML_ERROR_NONE; 3638| 0| } 3639| 102k| if (startTagLevel > 0) { ------------------ | Branch (3639:11): [True: 101k, False: 1.67k] ------------------ 3640| 101k| if (parser->m_tagLevel != startTagLevel) ------------------ | Branch (3640:13): [True: 19, False: 101k] ------------------ 3641| 19| return XML_ERROR_ASYNC_ENTITY; 3642| 101k| *nextPtr = s; 3643| 101k| return XML_ERROR_NONE; 3644| 101k| } 3645| 1.67k| return XML_ERROR_NO_ELEMENTS; 3646| 2.93k| case XML_TOK_INVALID: ------------------ | | 57| 2.93k|# define XML_TOK_INVALID 0 ------------------ | Branch (3646:5): [True: 2.93k, False: 474k] ------------------ 3647| 2.93k| *eventPP = next; 3648| 2.93k| return XML_ERROR_INVALID_TOKEN; 3649| 781| case XML_TOK_PARTIAL: ------------------ | | 56| 781|# define XML_TOK_PARTIAL -1 /* only part of a token */ ------------------ | Branch (3649:5): [True: 781, False: 476k] ------------------ 3650| 781| if (haveMore) { ------------------ | Branch (3650:11): [True: 0, False: 781] ------------------ 3651| 0| *nextPtr = s; 3652| 0| return XML_ERROR_NONE; 3653| 0| } 3654| 781| return XML_ERROR_UNCLOSED_TOKEN; 3655| 33| case XML_TOK_PARTIAL_CHAR: ------------------ | | 55| 33|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ ------------------ | Branch (3655:5): [True: 33, False: 477k] ------------------ 3656| 33| if (haveMore) { ------------------ | Branch (3656:11): [True: 0, False: 33] ------------------ 3657| 0| *nextPtr = s; 3658| 0| return XML_ERROR_NONE; 3659| 0| } 3660| 33| return XML_ERROR_PARTIAL_CHAR; 3661| 145k| case XML_TOK_ENTITY_REF: { ------------------ | | 70| 145k|# define XML_TOK_ENTITY_REF 9 ------------------ | Branch (3661:5): [True: 145k, False: 331k] ------------------ 3662| 145k| const XML_Char *name; 3663| 145k| ENTITY *entity; 3664| 145k| XML_Char ch = (XML_Char)XmlPredefinedEntityName( ------------------ | | 266| 145k| (((enc)->predefinedEntityName)(enc, ptr, end)) ------------------ 3665| 145k| enc, s + enc->minBytesPerChar, next - enc->minBytesPerChar); 3666| 145k| if (ch) { ------------------ | Branch (3666:11): [True: 36.2k, False: 109k] ------------------ 3667| 36.2k|#if XML_GE == 1 3668| | /* NOTE: We are replacing 4-6 characters original input for 1 character 3669| | * so there is no amplification and hence recording without 3670| | * protection. */ 3671| 36.2k| accountingDiffTolerated(parser, tok, (char *)&ch, 3672| 36.2k| ((char *)&ch) + sizeof(XML_Char), __LINE__, 3673| 36.2k| XML_ACCOUNT_ENTITY_EXPANSION); 3674| 36.2k|#endif /* XML_GE == 1 */ 3675| 36.2k| if (parser->m_characterDataHandler) { ------------------ | Branch (3675:13): [True: 0, False: 36.2k] ------------------ 3676| 0| beforeHandler(parser); 3677| 0| parser->m_characterDataHandler(parser->m_handlerArg, &ch, 1); 3678| 0| afterHandler(parser); 3679| 36.2k| } else if (parser->m_defaultHandler) ------------------ | Branch (3679:20): [True: 0, False: 36.2k] ------------------ 3680| 0| reportDefault(parser, enc, s, next); 3681| 36.2k| break; 3682| 36.2k| } 3683| 109k| name = poolStoreString(&dtd->pool, enc, s + enc->minBytesPerChar, 3684| 109k| next - enc->minBytesPerChar); 3685| 109k| if (! name) ------------------ | Branch (3685:11): [True: 0, False: 109k] ------------------ 3686| 0| return XML_ERROR_NO_MEMORY; 3687| 109k| entity = (ENTITY *)lookup(parser, &dtd->generalEntities, name, 0); 3688| 109k| poolDiscard(&dtd->pool); ------------------ | | 675| 109k|#define poolDiscard(pool) ((pool)->ptr = (pool)->start) ------------------ 3689| | /* First, determine if a check for an existing declaration is needed; 3690| | if yes, check that the entity exists, and that it is internal, 3691| | otherwise call the skipped entity or default handler. 3692| | */ 3693| 109k| if (! dtd->hasParamEntityRefs || dtd->standalone) { ------------------ | Branch (3693:11): [True: 103k, False: 5.40k] | Branch (3693:40): [True: 0, False: 5.40k] ------------------ 3694| 103k| if (! entity) ------------------ | Branch (3694:13): [True: 207, False: 103k] ------------------ 3695| 207| return XML_ERROR_UNDEFINED_ENTITY; 3696| 103k| else if (! entity->is_internal) ------------------ | Branch (3696:18): [True: 0, False: 103k] ------------------ 3697| 0| return XML_ERROR_ENTITY_DECLARED_IN_PE; 3698| 103k| } else if (! entity) { ------------------ | Branch (3698:18): [True: 2.95k, False: 2.45k] ------------------ 3699| 2.95k| if (parser->m_skippedEntityHandler) { ------------------ | Branch (3699:13): [True: 0, False: 2.95k] ------------------ 3700| 0| beforeHandler(parser); 3701| 0| parser->m_skippedEntityHandler(parser->m_handlerArg, name, 0); 3702| 0| afterHandler(parser); 3703| 2.95k| } else if (parser->m_defaultHandler) ------------------ | Branch (3703:20): [True: 0, False: 2.95k] ------------------ 3704| 0| reportDefault(parser, enc, s, next); 3705| 2.95k| break; 3706| 2.95k| } 3707| 106k| if (entity->open) ------------------ | Branch (3707:11): [True: 2, False: 106k] ------------------ 3708| 2| return XML_ERROR_RECURSIVE_ENTITY_REF; 3709| 106k| if (entity->notation) ------------------ | Branch (3709:11): [True: 1, False: 106k] ------------------ 3710| 1| return XML_ERROR_BINARY_ENTITY_REF; 3711| 106k| if (entity->textPtr) { ------------------ | Branch (3711:11): [True: 105k, False: 198] ------------------ 3712| 105k| enum XML_Error result; 3713| 105k| if (! parser->m_defaultExpandInternalEntities) { ------------------ | Branch (3713:13): [True: 0, False: 105k] ------------------ 3714| 0| if (parser->m_skippedEntityHandler) { ------------------ | Branch (3714:15): [True: 0, False: 0] ------------------ 3715| 0| beforeHandler(parser); 3716| 0| parser->m_skippedEntityHandler(parser->m_handlerArg, entity->name, 3717| 0| 0); 3718| 0| afterHandler(parser); 3719| 0| } else if (parser->m_defaultHandler) ------------------ | Branch (3719:22): [True: 0, False: 0] ------------------ 3720| 0| reportDefault(parser, enc, s, next); 3721| 0| break; 3722| 0| } 3723| 105k| result = processEntity(parser, entity, XML_FALSE, ENTITY_INTERNAL); ------------------ | | 64| 105k|# define XML_FALSE ((XML_Bool)0) ------------------ 3724| 105k| if (result != XML_ERROR_NONE) ------------------ | Branch (3724:13): [True: 0, False: 105k] ------------------ 3725| 0| return result; 3726| 105k| } else if (parser->m_externalEntityRefHandler) { ------------------ | Branch (3726:18): [True: 0, False: 198] ------------------ 3727| 0| const XML_Char *context; 3728| 0| entity->open = true; 3729| 0| context = getContext(parser); 3730| 0| entity->open = false; 3731| 0| if (! context) ------------------ | Branch (3731:13): [True: 0, False: 0] ------------------ 3732| 0| return XML_ERROR_NO_MEMORY; 3733| 0| beforeHandler(parser); 3734| 0| const int status = parser->m_externalEntityRefHandler( 3735| 0| parser->m_externalEntityRefHandlerArg, context, entity->base, 3736| 0| entity->systemId, entity->publicId); 3737| 0| afterHandler(parser); 3738| 0| if (! status) ------------------ | Branch (3738:13): [True: 0, False: 0] ------------------ 3739| 0| return XML_ERROR_EXTERNAL_ENTITY_HANDLING; 3740| 0| poolDiscard(&parser->m_tempPool); ------------------ | | 675| 0|#define poolDiscard(pool) ((pool)->ptr = (pool)->start) ------------------ 3741| 198| } else if (parser->m_defaultHandler) ------------------ | Branch (3741:18): [True: 0, False: 198] ------------------ 3742| 0| reportDefault(parser, enc, s, next); 3743| 106k| break; 3744| 106k| } 3745| 106k| case XML_TOK_START_TAG_NO_ATTS: ------------------ | | 63| 27.1k|# define XML_TOK_START_TAG_NO_ATTS 2 ------------------ | Branch (3745:5): [True: 27.1k, False: 450k] ------------------ 3746| 32.9k| case XML_TOK_START_TAG_WITH_ATTS: { ------------------ | | 62| 32.9k|# define XML_TOK_START_TAG_WITH_ATTS 1 ------------------ | Branch (3746:5): [True: 5.74k, False: 471k] ------------------ 3747| 32.9k| TAG *tag; 3748| 32.9k| enum XML_Error result; 3749| 32.9k| XML_Char *toPtr; 3750| 32.9k| if (parser->m_freeTagList) { ------------------ | Branch (3750:11): [True: 4.94k, False: 27.9k] ------------------ 3751| 4.94k| tag = parser->m_freeTagList; 3752| 4.94k| parser->m_freeTagList = parser->m_freeTagList->parent; 3753| 27.9k| } else { 3754| 27.9k| tag = MALLOC(parser, sizeof(TAG)); ------------------ | | 835| 27.9k|# define MALLOC(parser, s) (expat_malloc((parser), (s), __LINE__)) ------------------ 3755| 27.9k| if (! tag) ------------------ | Branch (3755:13): [True: 0, False: 27.9k] ------------------ 3756| 0| return XML_ERROR_NO_MEMORY; 3757| 27.9k| tag->buf.raw = MALLOC(parser, INIT_TAG_BUF_SIZE); ------------------ | | 835| 27.9k|# define MALLOC(parser, s) (expat_malloc((parser), (s), __LINE__)) ------------------ 3758| 27.9k| if (! tag->buf.raw) { ------------------ | Branch (3758:13): [True: 0, False: 27.9k] ------------------ 3759| 0| FREE(parser, tag); ------------------ | | 837| 0|# define FREE(parser, p) (expat_free((parser), (p), __LINE__)) ------------------ 3760| 0| return XML_ERROR_NO_MEMORY; 3761| 0| } 3762| 27.9k| tag->bufEnd = tag->buf.raw + INIT_TAG_BUF_SIZE; ------------------ | | 253| 27.9k|#define INIT_TAG_BUF_SIZE 32 /* must be a multiple of sizeof(XML_Char) */ ------------------ 3763| 27.9k| } 3764| 32.9k| tag->bindings = NULL; 3765| 32.9k| tag->parent = parser->m_tagStack; 3766| 32.9k| parser->m_tagStack = tag; 3767| 32.9k| tag->name.localPart = NULL; 3768| 32.9k| tag->name.prefix = NULL; 3769| 32.9k| tag->rawName = s + enc->minBytesPerChar; 3770| 32.9k| tag->rawNameLength = XmlNameLength(enc, tag->rawName); ------------------ | | 256| 32.9k|# define XmlNameLength(enc, ptr) (((enc)->nameLength)(enc, ptr)) ------------------ 3771| 32.9k| ++parser->m_tagLevel; 3772| 32.9k| { 3773| 32.9k| const char *rawNameEnd = tag->rawName + tag->rawNameLength; 3774| 32.9k| const char *fromPtr = tag->rawName; 3775| 32.9k| toPtr = tag->buf.str; 3776| 33.4k| for (;;) { 3777| 33.4k| const enum XML_Convert_Result convert_res 3778| 33.4k| = XmlConvert(enc, &fromPtr, rawNameEnd, (ICHAR **)&toPtr, ------------------ | | 190| 33.4k|# define XmlConvert XmlUtf8Convert | | ------------------ | | | | 275| 33.4k| (((enc)->utf8Convert)(enc, fromP, fromLim, toP, toLim)) | | ------------------ ------------------ 3779| 33.4k| (ICHAR *)tag->bufEnd - 1); 3780| 33.4k| const size_t convLen = (size_t)(toPtr - tag->buf.str); 3781| 33.4k| if ((fromPtr >= rawNameEnd) ------------------ | Branch (3781:15): [True: 32.9k, False: 469] ------------------ 3782| 32.9k| || (convert_res == XML_CONVERT_INPUT_INCOMPLETE)) { ------------------ | Branch (3782:18): [True: 0, False: 469] ------------------ 3783| 32.9k| tag->name.strLen = convLen; 3784| 32.9k| break; 3785| 32.9k| } 3786| 469| if (SIZE_MAX / 2 < (size_t)(tag->bufEnd - tag->buf.raw)) ------------------ | Branch (3786:15): [True: 0, False: 469] ------------------ 3787| 0| return XML_ERROR_NO_MEMORY; 3788| 469| const size_t bufSize = (size_t)(tag->bufEnd - tag->buf.raw) * 2; 3789| 469| { 3790| 469| char *temp = REALLOC(parser, tag->buf.raw, bufSize); ------------------ | | 836| 469|# define REALLOC(parser, p, s) (expat_realloc((parser), (p), (s), __LINE__)) ------------------ 3791| 469| if (temp == NULL) ------------------ | Branch (3791:17): [True: 0, False: 469] ------------------ 3792| 0| return XML_ERROR_NO_MEMORY; 3793| 469| tag->buf.raw = temp; 3794| 469| tag->bufEnd = temp + bufSize; 3795| 469| toPtr = (XML_Char *)temp + convLen; 3796| 469| } 3797| 469| } 3798| 32.9k| } 3799| 32.9k| tag->name.str = tag->buf.str; 3800| 32.9k| *toPtr = XML_T('\0'); ------------------ | | 220| 32.9k|# define XML_T(x) x ------------------ 3801| 32.9k| result 3802| 32.9k| = storeAtts(parser, enc, s, &(tag->name), &(tag->bindings), account); 3803| 32.9k| if (result) ------------------ | Branch (3803:11): [True: 275, False: 32.6k] ------------------ 3804| 275| return result; 3805| 32.6k| if (parser->m_startElementHandler) { ------------------ | Branch (3805:11): [True: 0, False: 32.6k] ------------------ 3806| 0| beforeHandler(parser); 3807| 0| parser->m_startElementHandler(parser->m_handlerArg, tag->name.str, 3808| 0| (const XML_Char **)parser->m_atts); 3809| 0| afterHandler(parser); 3810| 32.6k| } else if (parser->m_defaultHandler) ------------------ | Branch (3810:18): [True: 0, False: 32.6k] ------------------ 3811| 0| reportDefault(parser, enc, s, next); 3812| 32.6k| poolClear(&parser->m_tempPool); 3813| 32.6k| break; 3814| 32.9k| } 3815| 4.36k| case XML_TOK_EMPTY_ELEMENT_NO_ATTS: ------------------ | | 65| 4.36k|# define XML_TOK_EMPTY_ELEMENT_NO_ATTS 4 ------------------ | Branch (3815:5): [True: 4.36k, False: 473k] ------------------ 3816| 26.6k| case XML_TOK_EMPTY_ELEMENT_WITH_ATTS: { ------------------ | | 64| 26.6k|# define XML_TOK_EMPTY_ELEMENT_WITH_ATTS 3 /* empty element tag */ ------------------ | Branch (3816:5): [True: 22.2k, False: 455k] ------------------ 3817| 26.6k| const char *rawName = s + enc->minBytesPerChar; 3818| 26.6k| enum XML_Error result; 3819| 26.6k| BINDING *bindings = NULL; 3820| 26.6k| XML_Bool noElmHandlers = XML_TRUE; ------------------ | | 63| 26.6k|# define XML_TRUE ((XML_Bool)1) ------------------ 3821| 26.6k| TAG_NAME name; 3822| 26.6k| name.str = poolStoreString(&parser->m_tempPool, enc, rawName, 3823| 26.6k| rawName + XmlNameLength(enc, rawName)); ------------------ | | 256| 26.6k|# define XmlNameLength(enc, ptr) (((enc)->nameLength)(enc, ptr)) ------------------ 3824| 26.6k| if (! name.str) ------------------ | Branch (3824:11): [True: 0, False: 26.6k] ------------------ 3825| 0| return XML_ERROR_NO_MEMORY; 3826| 26.6k| poolFinish(&parser->m_tempPool); ------------------ | | 676| 26.6k|#define poolFinish(pool) ((pool)->start = (pool)->ptr) ------------------ 3827| 26.6k| result = storeAtts(parser, enc, s, &name, &bindings, 3828| 26.6k| XML_ACCOUNT_NONE /* token spans whole start tag */); 3829| 26.6k| if (result != XML_ERROR_NONE) { ------------------ | Branch (3829:11): [True: 140, False: 26.5k] ------------------ 3830| 140| freeBindings(parser, bindings); 3831| 140| return result; 3832| 140| } 3833| 26.5k| poolFinish(&parser->m_tempPool); ------------------ | | 676| 26.5k|#define poolFinish(pool) ((pool)->start = (pool)->ptr) ------------------ 3834| 26.5k| if (parser->m_startElementHandler) { ------------------ | Branch (3834:11): [True: 0, False: 26.5k] ------------------ 3835| 0| beforeHandler(parser); 3836| 0| parser->m_startElementHandler(parser->m_handlerArg, name.str, 3837| 0| (const XML_Char **)parser->m_atts); 3838| 0| afterHandler(parser); 3839| 0| noElmHandlers = XML_FALSE; ------------------ | | 64| 0|# define XML_FALSE ((XML_Bool)0) ------------------ 3840| 0| } 3841| 26.5k| if (parser->m_endElementHandler) { ------------------ | Branch (3841:11): [True: 0, False: 26.5k] ------------------ 3842| 0| if (parser->m_startElementHandler) ------------------ | Branch (3842:13): [True: 0, False: 0] ------------------ 3843| 0| *eventPP = *eventEndPP; 3844| 0| beforeHandler(parser); 3845| 0| parser->m_endElementHandler(parser->m_handlerArg, name.str); 3846| 0| afterHandler(parser); 3847| 0| noElmHandlers = XML_FALSE; ------------------ | | 64| 0|# define XML_FALSE ((XML_Bool)0) ------------------ 3848| 0| } 3849| 26.5k| if (noElmHandlers && parser->m_defaultHandler) ------------------ | Branch (3849:11): [True: 26.5k, False: 0] | Branch (3849:28): [True: 0, False: 26.5k] ------------------ 3850| 0| reportDefault(parser, enc, s, next); 3851| 26.5k| poolClear(&parser->m_tempPool); 3852| 26.5k| freeBindings(parser, bindings); 3853| 26.5k| } 3854| 26.5k| if ((parser->m_tagLevel == 0) ------------------ | Branch (3854:11): [True: 753, False: 25.7k] ------------------ 3855| 753| && (parser->m_parsingStatus.parsing != XML_FINISHED)) { ------------------ | Branch (3855:14): [True: 753, False: 0] ------------------ 3856| 753| if (parser->m_parsingStatus.parsing == XML_SUSPENDED ------------------ | Branch (3856:13): [True: 0, False: 753] ------------------ 3857| 753| || (parser->m_parsingStatus.parsing == XML_PARSING ------------------ | Branch (3857:17): [True: 753, False: 0] ------------------ 3858| 753| && parser->m_reenter)) ------------------ | Branch (3858:20): [True: 0, False: 753] ------------------ 3859| 0| parser->m_processor = epilogProcessor; 3860| 753| else 3861| 753| return epilogProcessor(parser, next, end, nextPtr); 3862| 753| } 3863| 25.7k| break; 3864| 25.7k| case XML_TOK_END_TAG: ------------------ | | 66| 5.52k|# define XML_TOK_END_TAG 5 ------------------ | Branch (3864:5): [True: 5.52k, False: 471k] ------------------ 3865| 5.52k| if (parser->m_tagLevel == startTagLevel) ------------------ | Branch (3865:11): [True: 1, False: 5.52k] ------------------ 3866| 1| return XML_ERROR_ASYNC_ENTITY; 3867| 5.52k| else { 3868| 5.52k| int len; 3869| 5.52k| const char *rawName; 3870| 5.52k| TAG *tag = parser->m_tagStack; 3871| 5.52k| rawName = s + enc->minBytesPerChar * 2; 3872| 5.52k| len = XmlNameLength(enc, rawName); ------------------ | | 256| 5.52k|# define XmlNameLength(enc, ptr) (((enc)->nameLength)(enc, ptr)) ------------------ 3873| 5.52k| if (len != tag->rawNameLength ------------------ | Branch (3873:13): [True: 90, False: 5.43k] ------------------ 3874| 5.43k| || memcmp(tag->rawName, rawName, len) != 0) { ------------------ | Branch (3874:16): [True: 173, False: 5.26k] ------------------ 3875| 263| *eventPP = rawName; 3876| 263| return XML_ERROR_TAG_MISMATCH; 3877| 263| } 3878| 5.26k| parser->m_tagStack = tag->parent; 3879| 5.26k| tag->parent = parser->m_freeTagList; 3880| 5.26k| parser->m_freeTagList = tag; 3881| 5.26k| --parser->m_tagLevel; 3882| 5.26k| if (parser->m_endElementHandler) { ------------------ | Branch (3882:13): [True: 0, False: 5.26k] ------------------ 3883| 0| const XML_Char *localPart; 3884| 0| const XML_Char *prefix; 3885| 0| XML_Char *uri; 3886| 0| localPart = tag->name.localPart; 3887| 0| if (parser->m_ns && localPart) { ------------------ | Branch (3887:15): [True: 0, False: 0] | Branch (3887:31): [True: 0, False: 0] ------------------ 3888| | /* localPart and prefix may have been overwritten in 3889| | tag->name.str, since this points to the binding->uri 3890| | buffer which gets reused; so we have to add them again 3891| | */ 3892| 0| uri = (XML_Char *)tag->name.str + tag->name.uriLen; 3893| | /* don't need to check for space - already done in storeAtts() */ 3894| 0| while (*localPart) ------------------ | Branch (3894:20): [True: 0, False: 0] ------------------ 3895| 0| *uri++ = *localPart++; 3896| 0| prefix = tag->name.prefix; 3897| 0| if (parser->m_ns_triplets && prefix) { ------------------ | Branch (3897:17): [True: 0, False: 0] | Branch (3897:42): [True: 0, False: 0] ------------------ 3898| 0| *uri++ = parser->m_namespaceSeparator; 3899| 0| while (*prefix) ------------------ | Branch (3899:22): [True: 0, False: 0] ------------------ 3900| 0| *uri++ = *prefix++; 3901| 0| } 3902| 0| *uri = XML_T('\0'); ------------------ | | 220| 0|# define XML_T(x) x ------------------ 3903| 0| } 3904| 0| beforeHandler(parser); 3905| 0| parser->m_endElementHandler(parser->m_handlerArg, tag->name.str); 3906| 0| afterHandler(parser); 3907| 5.26k| } else if (parser->m_defaultHandler) ------------------ | Branch (3907:20): [True: 0, False: 5.26k] ------------------ 3908| 0| reportDefault(parser, enc, s, next); 3909| 6.03k| while (tag->bindings) { ------------------ | Branch (3909:16): [True: 769, False: 5.26k] ------------------ 3910| 769| BINDING *b = tag->bindings; 3911| 769| if (parser->m_endNamespaceDeclHandler) { ------------------ | Branch (3911:15): [True: 0, False: 769] ------------------ 3912| 0| beforeHandler(parser); 3913| 0| parser->m_endNamespaceDeclHandler(parser->m_handlerArg, 3914| 0| b->prefix->name); 3915| 0| afterHandler(parser); 3916| 0| } 3917| 769| tag->bindings = tag->bindings->nextTagBinding; 3918| 769| b->nextTagBinding = parser->m_freeBindingList; 3919| 769| parser->m_freeBindingList = b; 3920| 769| b->prefix->binding = b->prevPrefixBinding; 3921| 769| } 3922| 5.26k| if ((parser->m_tagLevel == 0) ------------------ | Branch (3922:13): [True: 68, False: 5.19k] ------------------ 3923| 68| && (parser->m_parsingStatus.parsing != XML_FINISHED)) { ------------------ | Branch (3923:16): [True: 68, False: 0] ------------------ 3924| 68| if (parser->m_parsingStatus.parsing == XML_SUSPENDED ------------------ | Branch (3924:15): [True: 0, False: 68] ------------------ 3925| 68| || (parser->m_parsingStatus.parsing == XML_PARSING ------------------ | Branch (3925:19): [True: 68, False: 0] ------------------ 3926| 68| && parser->m_reenter)) ------------------ | Branch (3926:22): [True: 0, False: 68] ------------------ 3927| 0| parser->m_processor = epilogProcessor; 3928| 68| else 3929| 68| return epilogProcessor(parser, next, end, nextPtr); 3930| 68| } 3931| 5.26k| } 3932| 5.19k| break; 3933| 5.19k| case XML_TOK_CHAR_REF: { ------------------ | | 71| 2.34k|# define XML_TOK_CHAR_REF 10 /* numeric character reference */ ------------------ | Branch (3933:5): [True: 2.34k, False: 475k] ------------------ 3934| 2.34k| int n = XmlCharRefNumber(enc, s); ------------------ | | 263| 2.34k|# define XmlCharRefNumber(enc, ptr) (((enc)->charRefNumber)(enc, ptr)) ------------------ 3935| 2.34k| if (n < 0) ------------------ | Branch (3935:11): [True: 107, False: 2.23k] ------------------ 3936| 107| return XML_ERROR_BAD_CHAR_REF; 3937| 2.23k| if (parser->m_characterDataHandler) { ------------------ | Branch (3937:11): [True: 0, False: 2.23k] ------------------ 3938| 0| XML_Char buf[XML_ENCODE_MAX]; 3939| 0| beforeHandler(parser); 3940| 0| parser->m_characterDataHandler(parser->m_handlerArg, buf, 3941| 0| XmlEncode(n, (ICHAR *)buf)); ------------------ | | 193| 0|# define XmlEncode XmlUtf8Encode ------------------ 3942| 0| afterHandler(parser); 3943| 2.23k| } else if (parser->m_defaultHandler) ------------------ | Branch (3943:18): [True: 0, False: 2.23k] ------------------ 3944| 0| reportDefault(parser, enc, s, next); 3945| 2.23k| } break; 3946| 1| case XML_TOK_XML_DECL: ------------------ | | 77| 1|# define XML_TOK_XML_DECL 12 /* XML decl or text decl */ ------------------ | Branch (3946:5): [True: 1, False: 477k] ------------------ 3947| 1| return XML_ERROR_MISPLACED_XML_PI; 3948| 2.80k| case XML_TOK_DATA_NEWLINE: ------------------ | | 68| 2.80k|# define XML_TOK_DATA_NEWLINE 7 ------------------ | Branch (3948:5): [True: 2.80k, False: 474k] ------------------ 3949| 2.80k| if (parser->m_characterDataHandler) { ------------------ | Branch (3949:11): [True: 0, False: 2.80k] ------------------ 3950| 0| XML_Char c = 0xA; 3951| 0| beforeHandler(parser); 3952| 0| parser->m_characterDataHandler(parser->m_handlerArg, &c, 1); 3953| 0| afterHandler(parser); 3954| 2.80k| } else if (parser->m_defaultHandler) ------------------ | Branch (3954:18): [True: 0, False: 2.80k] ------------------ 3955| 0| reportDefault(parser, enc, s, next); 3956| 2.80k| break; 3957| 1.38k| case XML_TOK_CDATA_SECT_OPEN: { ------------------ | | 69| 1.38k|# define XML_TOK_CDATA_SECT_OPEN 8 ------------------ | Branch (3957:5): [True: 1.38k, False: 476k] ------------------ 3958| 1.38k| enum XML_Error result; 3959| 1.38k| if (parser->m_startCdataSectionHandler) { ------------------ | Branch (3959:11): [True: 0, False: 1.38k] ------------------ 3960| 0| beforeHandler(parser); 3961| 0| parser->m_startCdataSectionHandler(parser->m_handlerArg); 3962| 0| afterHandler(parser); 3963| | /* BEGIN disabled code */ 3964| | /* Suppose you doing a transformation on a document that involves 3965| | changing only the character data. You set up a defaultHandler 3966| | and a characterDataHandler. The defaultHandler simply copies 3967| | characters through. The characterDataHandler does the 3968| | transformation and writes the characters out escaping them as 3969| | necessary. This case will fail to work if we leave out the 3970| | following two lines (because & and < inside CDATA sections will 3971| | be incorrectly escaped). 3972| | 3973| | However, now we have a start/endCdataSectionHandler, so it seems 3974| | easier to let the user deal with this. 3975| | */ 3976| 1.38k| } else if ((0) && parser->m_characterDataHandler) { ------------------ | Branch (3976:18): [Folded, False: 1.38k] | Branch (3976:25): [True: 0, False: 0] ------------------ 3977| 0| beforeHandler(parser); 3978| 0| parser->m_characterDataHandler(parser->m_handlerArg, parser->m_dataBuf, 3979| 0| 0); 3980| 0| afterHandler(parser); 3981| | /* END disabled code */ 3982| 1.38k| } else if (parser->m_defaultHandler) ------------------ | Branch (3982:18): [True: 0, False: 1.38k] ------------------ 3983| 0| reportDefault(parser, enc, s, next); 3984| 1.38k| result 3985| 1.38k| = doCdataSection(parser, enc, &next, end, nextPtr, haveMore, account); 3986| 1.38k| if (result != XML_ERROR_NONE) ------------------ | Branch (3986:11): [True: 398, False: 991] ------------------ 3987| 398| return result; 3988| 991| else if (! next) { ------------------ | Branch (3988:16): [True: 0, False: 991] ------------------ 3989| 0| parser->m_processor = cdataSectionProcessor; 3990| 0| return result; 3991| 0| } 3992| 1.38k| } break; 3993| 991| case XML_TOK_TRAILING_RSQB: ------------------ | | 46| 688| -5 /* ] or ]] at the end of the scan; might be \ ------------------ | Branch (3993:5): [True: 688, False: 476k] ------------------ 3994| 688| if (haveMore) { ------------------ | Branch (3994:11): [True: 0, False: 688] ------------------ 3995| 0| *nextPtr = s; 3996| 0| return XML_ERROR_NONE; 3997| 0| } 3998| 688| if (parser->m_characterDataHandler) { ------------------ | Branch (3998:11): [True: 0, False: 688] ------------------ 3999| 0| if (MUST_CONVERT(enc, s)) { ------------------ | | 194| 0|# define MUST_CONVERT(enc, s) (! (enc)->isUtf8) | | ------------------ | | | Branch (194:32): [True: 0, False: 0] | | ------------------ ------------------ 4000| 0| ICHAR *dataPtr = (ICHAR *)parser->m_dataBuf; 4001| 0| XmlConvert(enc, &s, end, &dataPtr, (ICHAR *)parser->m_dataBufEnd); ------------------ | | 190| 0|# define XmlConvert XmlUtf8Convert | | ------------------ | | | | 275| 0| (((enc)->utf8Convert)(enc, fromP, fromLim, toP, toLim)) | | ------------------ ------------------ 4002| 0| beforeHandler(parser); 4003| 0| parser->m_characterDataHandler( 4004| 0| parser->m_handlerArg, parser->m_dataBuf, 4005| 0| (int)(dataPtr - (ICHAR *)parser->m_dataBuf)); 4006| 0| afterHandler(parser); 4007| 0| } else { 4008| 0| beforeHandler(parser); 4009| 0| parser->m_characterDataHandler( 4010| 0| parser->m_handlerArg, (const XML_Char *)s, 4011| 0| (int)((const XML_Char *)end - (const XML_Char *)s)); 4012| 0| afterHandler(parser); 4013| 0| } 4014| 688| } else if (parser->m_defaultHandler) ------------------ | Branch (4014:18): [True: 0, False: 688] ------------------ 4015| 0| reportDefault(parser, enc, s, end); 4016| | /* We are at the end of the final buffer, should we check for 4017| | XML_SUSPENDED, XML_FINISHED? 4018| | */ 4019| 688| if (startTagLevel == 0) { ------------------ | Branch (4019:11): [True: 8, False: 680] ------------------ 4020| 8| *eventPP = end; 4021| 8| return XML_ERROR_NO_ELEMENTS; 4022| 8| } 4023| 680| if (parser->m_tagLevel != startTagLevel) { ------------------ | Branch (4023:11): [True: 9, False: 671] ------------------ 4024| 9| *eventPP = end; 4025| 9| return XML_ERROR_ASYNC_ENTITY; 4026| 9| } 4027| 671| *nextPtr = end; 4028| 671| return XML_ERROR_NONE; 4029| 148k| case XML_TOK_DATA_CHARS: { ------------------ | | 67| 148k|# define XML_TOK_DATA_CHARS 6 ------------------ | Branch (4029:5): [True: 148k, False: 328k] ------------------ 4030| 148k| XML_CharacterDataHandler charDataHandler = parser->m_characterDataHandler; 4031| 148k| if (charDataHandler) { ------------------ | Branch (4031:11): [True: 0, False: 148k] ------------------ 4032| 0| if (MUST_CONVERT(enc, s)) { ------------------ | | 194| 0|# define MUST_CONVERT(enc, s) (! (enc)->isUtf8) | | ------------------ | | | Branch (194:32): [True: 0, False: 0] | | ------------------ ------------------ 4033| 0| for (;;) { 4034| 0| ICHAR *dataPtr = (ICHAR *)parser->m_dataBuf; 4035| 0| const enum XML_Convert_Result convert_res = XmlConvert( ------------------ | | 190| 0|# define XmlConvert XmlUtf8Convert | | ------------------ | | | | 275| 0| (((enc)->utf8Convert)(enc, fromP, fromLim, toP, toLim)) | | ------------------ ------------------ 4036| 0| enc, &s, next, &dataPtr, (ICHAR *)parser->m_dataBufEnd); 4037| 0| *eventEndPP = s; 4038| 0| beforeHandler(parser); 4039| 0| charDataHandler(parser->m_handlerArg, parser->m_dataBuf, 4040| 0| (int)(dataPtr - (ICHAR *)parser->m_dataBuf)); 4041| 0| afterHandler(parser); 4042| 0| if ((convert_res == XML_CONVERT_COMPLETED) ------------------ | Branch (4042:17): [True: 0, False: 0] ------------------ 4043| 0| || (convert_res == XML_CONVERT_INPUT_INCOMPLETE)) ------------------ | Branch (4043:20): [True: 0, False: 0] ------------------ 4044| 0| break; 4045| 0| *eventPP = s; 4046| 0| } 4047| 0| } else { 4048| 0| beforeHandler(parser); 4049| 0| charDataHandler(parser->m_handlerArg, (const XML_Char *)s, 4050| 0| (int)((const XML_Char *)next - (const XML_Char *)s)); 4051| 0| afterHandler(parser); 4052| 0| } 4053| 148k| } else if (parser->m_defaultHandler) ------------------ | Branch (4053:18): [True: 0, False: 148k] ------------------ 4054| 0| reportDefault(parser, enc, s, next); 4055| 148k| } break; 4056| 3.82k| case XML_TOK_PI: ------------------ | | 76| 3.82k|# define XML_TOK_PI 11 /* processing instruction */ ------------------ | Branch (4056:5): [True: 3.82k, False: 473k] ------------------ 4057| 3.82k| if (! reportProcessingInstruction(parser, enc, s, next)) ------------------ | Branch (4057:11): [True: 0, False: 3.82k] ------------------ 4058| 0| return XML_ERROR_NO_MEMORY; 4059| 3.82k| break; 4060| 3.82k| case XML_TOK_COMMENT: ------------------ | | 78| 504|# define XML_TOK_COMMENT 13 ------------------ | Branch (4060:5): [True: 504, False: 476k] ------------------ 4061| 504| if (! reportComment(parser, enc, s, next)) ------------------ | Branch (4061:11): [True: 0, False: 504] ------------------ 4062| 0| return XML_ERROR_NO_MEMORY; 4063| 504| break; 4064| 504| default: ------------------ | Branch (4064:5): [True: 0, False: 477k] ------------------ 4065| | /* All of the tokens produced by XmlContentTok() have their own 4066| | * explicit cases, so this default is not strictly necessary. 4067| | * However it is a useful safety net, so we retain the code and 4068| | * simply exclude it from the coverage tests. 4069| | * 4070| | * LCOV_EXCL_START 4071| | */ 4072| 0| if (parser->m_defaultHandler) ------------------ | Branch (4072:11): [True: 0, False: 0] ------------------ 4073| 0| reportDefault(parser, enc, s, next); 4074| 0| break; 4075| | /* LCOV_EXCL_STOP */ 4076| 477k| } 4077| 367k| switch (parser->m_parsingStatus.parsing) { 4078| 0| case XML_SUSPENDED: ------------------ | Branch (4078:5): [True: 0, False: 367k] ------------------ 4079| 0| *eventPP = next; 4080| 0| *nextPtr = next; 4081| 0| return XML_ERROR_NONE; 4082| 0| case XML_FINISHED: ------------------ | Branch (4082:5): [True: 0, False: 367k] ------------------ 4083| 0| *eventPP = next; 4084| 0| return XML_ERROR_ABORTED; 4085| 367k| case XML_PARSING: ------------------ | Branch (4085:5): [True: 367k, False: 0] ------------------ 4086| 367k| if (parser->m_reenter) { ------------------ | Branch (4086:11): [True: 105k, False: 262k] ------------------ 4087| 105k| *nextPtr = next; 4088| 105k| return XML_ERROR_NONE; 4089| 105k| } 4090| 262k| EXPAT_FALLTHROUGH; ------------------ | | 47| 262k|# define EXPAT_FALLTHROUGH __attribute__((fallthrough)) ------------------ 4091| 262k| default:; ------------------ | Branch (4091:5): [True: 0, False: 367k] ------------------ 4092| 262k| *eventPP = s = next; 4093| 367k| } 4094| 367k| } 4095| | /* not reached */ 4096| 215k|} xmlparse.c:poolAppendChars: 688| 60.4k|poolAppendChars(STRING_POOL *pool, const XML_Char *s, size_t len) { 689| | // Detect and prevent integer overflow 690| 60.4k| if (len > SIZE_MAX / sizeof(XML_Char)) ------------------ | Branch (690:7): [True: 0, False: 60.4k] ------------------ 691| 0| return false; 692| | 693| 60.4k| if (! poolGrowUntil(pool, len)) ------------------ | Branch (693:7): [True: 0, False: 60.4k] ------------------ 694| 0| return false; 695| | 696| 60.4k| memcpy(pool->ptr, s, len * sizeof(XML_Char)); 697| 60.4k| pool->ptr += len; 698| | 699| | return true; 700| 60.4k|} xmlparse.c:poolGrowUntil: 8665| 60.4k|poolGrowUntil(STRING_POOL *pool, size_t needed) { 8666| 65.6k| for (;;) { 8667| 65.6k| const size_t available = pool->end - pool->ptr; 8668| 65.6k| if (available >= needed) { ------------------ | Branch (8668:9): [True: 60.4k, False: 5.24k] ------------------ 8669| 60.4k| return true; 8670| 60.4k| } 8671| 5.24k| if (! poolGrow(pool)) { ------------------ | Branch (8671:9): [True: 0, False: 5.24k] ------------------ 8672| | return false; 8673| 0| } 8674| 5.24k| } 8675| 60.4k|} xmlparse.c:poolGrow: 8560| 54.6k|poolGrow(STRING_POOL *pool) { 8561| 54.6k| if (pool->freeBlocks) { ------------------ | Branch (8561:7): [True: 31.7k, False: 22.9k] ------------------ 8562| 31.7k| if (pool->start == NULL) { ------------------ | Branch (8562:9): [True: 30.8k, False: 839] ------------------ 8563| 30.8k| pool->blocks = pool->freeBlocks; 8564| 30.8k| pool->freeBlocks = pool->freeBlocks->next; 8565| 30.8k| pool->blocks->next = NULL; 8566| 30.8k| pool->start = pool->blocks->s; 8567| 30.8k| pool->end = pool->start + pool->blocks->size; 8568| 30.8k| pool->ptr = pool->start; 8569| 30.8k| return XML_TRUE; ------------------ | | 63| 30.8k|# define XML_TRUE ((XML_Bool)1) ------------------ 8570| 30.8k| } 8571| 839| if (pool->end - pool->start < pool->freeBlocks->size) { ------------------ | Branch (8571:9): [True: 592, False: 247] ------------------ 8572| 592| BLOCK *tem = pool->freeBlocks->next; 8573| 592| pool->freeBlocks->next = pool->blocks; 8574| 592| pool->blocks = pool->freeBlocks; 8575| 592| pool->freeBlocks = tem; 8576| 592| memcpy(pool->blocks->s, pool->start, 8577| 592| (pool->end - pool->start) * sizeof(XML_Char)); 8578| 592| pool->ptr = pool->blocks->s + EXPAT_SAFE_PTR_DIFF(pool->ptr, pool->start); ------------------ | | 229| 592|#define EXPAT_SAFE_PTR_DIFF(p, q) (((p) && (q)) ? ((p) - (q)) : 0) | | ------------------ | | | Branch (229:37): [True: 592, False: 0] | | | Branch (229:44): [True: 592, False: 0] | | ------------------ ------------------ 8579| 592| pool->start = pool->blocks->s; 8580| 592| pool->end = pool->start + pool->blocks->size; 8581| 592| return XML_TRUE; ------------------ | | 63| 592|# define XML_TRUE ((XML_Bool)1) ------------------ 8582| 592| } 8583| 839| } 8584| 23.1k| if (pool->blocks && pool->start == pool->blocks->s) { ------------------ | Branch (8584:7): [True: 4.22k, False: 18.9k] | Branch (8584:23): [True: 2.87k, False: 1.35k] ------------------ 8585| 2.87k| BLOCK *temp; 8586| 2.87k| int blockSize = (int)((unsigned)(pool->end - pool->start) * 2U); 8587| 2.87k| size_t bytesToAllocate; 8588| | 8589| | /* NOTE: Needs to be calculated prior to calling `realloc` 8590| | to avoid dangling pointers: */ 8591| 2.87k| const ptrdiff_t offsetInsideBlock 8592| 2.87k| = EXPAT_SAFE_PTR_DIFF(pool->ptr, pool->start); ------------------ | | 229| 2.87k|#define EXPAT_SAFE_PTR_DIFF(p, q) (((p) && (q)) ? ((p) - (q)) : 0) | | ------------------ | | | Branch (229:37): [True: 2.87k, False: 0] | | | Branch (229:44): [True: 2.87k, False: 0] | | ------------------ ------------------ 8593| | 8594| 2.87k| if (blockSize < 0) { ------------------ | Branch (8594:9): [True: 0, False: 2.87k] ------------------ 8595| | /* This condition traps a situation where either more than 8596| | * INT_MAX/2 bytes have already been allocated. This isn't 8597| | * readily testable, since it is unlikely that an average 8598| | * machine will have that much memory, so we exclude it from the 8599| | * coverage statistics. 8600| | */ 8601| 0| return XML_FALSE; /* LCOV_EXCL_LINE */ ------------------ | | 64| 0|# define XML_FALSE ((XML_Bool)0) ------------------ 8602| 0| } 8603| | 8604| 2.87k| bytesToAllocate = poolBytesToAllocateFor(blockSize); 8605| 2.87k| if (bytesToAllocate == 0) ------------------ | Branch (8605:9): [True: 0, False: 2.87k] ------------------ 8606| 0| return XML_FALSE; ------------------ | | 64| 0|# define XML_FALSE ((XML_Bool)0) ------------------ 8607| | 8608| 2.87k| temp = REALLOC(pool->parser, pool->blocks, bytesToAllocate); ------------------ | | 836| 2.87k|# define REALLOC(parser, p, s) (expat_realloc((parser), (p), (s), __LINE__)) ------------------ 8609| 2.87k| if (temp == NULL) ------------------ | Branch (8609:9): [True: 0, False: 2.87k] ------------------ 8610| 0| return XML_FALSE; ------------------ | | 64| 0|# define XML_FALSE ((XML_Bool)0) ------------------ 8611| 2.87k| pool->blocks = temp; 8612| 2.87k| pool->blocks->size = blockSize; 8613| 2.87k| pool->ptr = pool->blocks->s + offsetInsideBlock; 8614| 2.87k| pool->start = pool->blocks->s; 8615| 2.87k| pool->end = pool->start + blockSize; 8616| 20.2k| } else { 8617| 20.2k| BLOCK *tem; 8618| 20.2k| int blockSize = (int)(pool->end - pool->start); 8619| 20.2k| size_t bytesToAllocate; 8620| | 8621| 20.2k| if (blockSize < 0) { ------------------ | Branch (8621:9): [True: 0, False: 20.2k] ------------------ 8622| | /* This condition traps a situation where either more than 8623| | * INT_MAX bytes have already been allocated (which is prevented 8624| | * by various pieces of program logic, not least this one, never 8625| | * mind the unlikelihood of actually having that much memory) or 8626| | * the pool control fields have been corrupted (which could 8627| | * conceivably happen in an extremely buggy user handler 8628| | * function). Either way it isn't readily testable, so we 8629| | * exclude it from the coverage statistics. 8630| | */ 8631| 0| return XML_FALSE; /* LCOV_EXCL_LINE */ ------------------ | | 64| 0|# define XML_FALSE ((XML_Bool)0) ------------------ 8632| 0| } 8633| | 8634| 20.2k| if (blockSize < INIT_BLOCK_SIZE) ------------------ | | 257| 20.2k|#define INIT_BLOCK_SIZE 1024 ------------------ | Branch (8634:9): [True: 19.7k, False: 552] ------------------ 8635| 19.7k| blockSize = INIT_BLOCK_SIZE; ------------------ | | 257| 19.7k|#define INIT_BLOCK_SIZE 1024 ------------------ 8636| 552| else { 8637| | /* Detect overflow, avoiding _signed_ overflow undefined behavior */ 8638| 552| if ((int)((unsigned)blockSize * 2U) < 0) { ------------------ | Branch (8638:11): [True: 0, False: 552] ------------------ 8639| 0| return XML_FALSE; ------------------ | | 64| 0|# define XML_FALSE ((XML_Bool)0) ------------------ 8640| 0| } 8641| 552| blockSize *= 2; 8642| 552| } 8643| | 8644| 20.2k| bytesToAllocate = poolBytesToAllocateFor(blockSize); 8645| 20.2k| if (bytesToAllocate == 0) ------------------ | Branch (8645:9): [True: 0, False: 20.2k] ------------------ 8646| 0| return XML_FALSE; ------------------ | | 64| 0|# define XML_FALSE ((XML_Bool)0) ------------------ 8647| | 8648| 20.2k| tem = MALLOC(pool->parser, bytesToAllocate); ------------------ | | 835| 20.2k|# define MALLOC(parser, s) (expat_malloc((parser), (s), __LINE__)) ------------------ 8649| 20.2k| if (! tem) ------------------ | Branch (8649:9): [True: 0, False: 20.2k] ------------------ 8650| 0| return XML_FALSE; ------------------ | | 64| 0|# define XML_FALSE ((XML_Bool)0) ------------------ 8651| 20.2k| tem->size = blockSize; 8652| 20.2k| tem->next = pool->blocks; 8653| 20.2k| pool->blocks = tem; 8654| 20.2k| if (pool->ptr != pool->start) ------------------ | Branch (8654:9): [True: 842, False: 19.4k] ------------------ 8655| 842| memcpy(tem->s, pool->start, 8656| 842| EXPAT_SAFE_PTR_DIFF(pool->ptr, pool->start) * sizeof(XML_Char)); ------------------ | | 229| 842|#define EXPAT_SAFE_PTR_DIFF(p, q) (((p) && (q)) ? ((p) - (q)) : 0) | | ------------------ | | | Branch (229:37): [True: 842, False: 0] | | | Branch (229:44): [True: 842, False: 0] | | ------------------ ------------------ 8657| 20.2k| pool->ptr = tem->s + EXPAT_SAFE_PTR_DIFF(pool->ptr, pool->start); ------------------ | | 229| 20.2k|#define EXPAT_SAFE_PTR_DIFF(p, q) (((p) && (q)) ? ((p) - (q)) : 0) | | ------------------ | | | Branch (229:37): [True: 1.35k, False: 18.9k] | | | Branch (229:44): [True: 1.35k, False: 0] | | ------------------ ------------------ 8658| 20.2k| pool->start = tem->s; 8659| 20.2k| pool->end = tem->s + blockSize; 8660| 20.2k| } 8661| 23.1k| return XML_TRUE; ------------------ | | 63| 23.1k|# define XML_TRUE ((XML_Bool)1) ------------------ 8662| 23.1k|} xmlparse.c:poolBytesToAllocateFor: 8532| 23.1k|poolBytesToAllocateFor(int blockSize) { 8533| | /* Unprotected math would be: 8534| | ** return offsetof(BLOCK, s) + blockSize * sizeof(XML_Char); 8535| | ** 8536| | ** Detect overflow, avoiding _signed_ overflow undefined behavior 8537| | ** For a + b * c we check b * c in isolation first, so that addition of a 8538| | ** on top has no chance of making us accept a small non-negative number 8539| | */ 8540| 23.1k| const size_t stretch = sizeof(XML_Char); /* can be 4 bytes */ 8541| | 8542| 23.1k| if (blockSize <= 0) ------------------ | Branch (8542:7): [True: 0, False: 23.1k] ------------------ 8543| 0| return 0; 8544| | 8545| 23.1k| if (blockSize > (int)(INT_MAX / stretch)) ------------------ | Branch (8545:7): [True: 0, False: 23.1k] ------------------ 8546| 0| return 0; 8547| | 8548| 23.1k| { 8549| 23.1k| const int stretchedBlockSize = blockSize * (int)stretch; 8550| 23.1k| const int bytesToAllocate 8551| 23.1k| = (int)(offsetof(BLOCK, s) + (unsigned)stretchedBlockSize); 8552| 23.1k| if (bytesToAllocate < 0) ------------------ | Branch (8552:9): [True: 0, False: 23.1k] ------------------ 8553| 0| return 0; 8554| | 8555| 23.1k| return (size_t)bytesToAllocate; 8556| 23.1k| } 8557| 23.1k|} xmlparse.c:hashTableIterInit: 8388| 12.0k|hashTableIterInit(HASH_TABLE_ITER *iter, const HASH_TABLE *table) { 8389| 12.0k| iter->p = table->v; 8390| 12.0k| iter->end = iter->p ? iter->p + table->size : NULL; ------------------ | Branch (8390:15): [True: 7.46k, False: 4.61k] ------------------ 8391| 12.0k|} xmlparse.c:hashTableIterNext: 8394| 27.4k|hashTableIterNext(HASH_TABLE_ITER *iter) { 8395| 499k| while (iter->p != iter->end) { ------------------ | Branch (8395:10): [True: 487k, False: 12.0k] ------------------ 8396| 487k| NAMED *tem = *(iter->p)++; 8397| 487k| if (tem) ------------------ | Branch (8397:9): [True: 15.3k, False: 471k] ------------------ 8398| 15.3k| return tem; 8399| 487k| } 8400| 12.0k| return NULL; 8401| 27.4k|} xmlparse.c:storeAtts: 4136| 59.5k| enum XML_Account account) { 4137| 59.5k| DTD *const dtd = parser->m_dtd; /* save one level of indirection */ 4138| 59.5k| int attIndex = 0; 4139| 59.5k| XML_Char *uri; 4140| 59.5k| int nPrefixes = 0; 4141| 59.5k| BINDING *binding; 4142| 59.5k| const XML_Char *localPart; 4143| | 4144| | /* lookup the element type name */ 4145| 59.5k| ELEMENT_TYPE *elementType 4146| 59.5k| = (ELEMENT_TYPE *)lookup(parser, &dtd->elementTypes, tagNamePtr->str, 0); 4147| 59.5k| if (! elementType) { ------------------ | Branch (4147:7): [True: 14.1k, False: 45.4k] ------------------ 4148| 14.1k| const XML_Char *name = poolCopyString(&dtd->pool, tagNamePtr->str); 4149| 14.1k| if (! name) ------------------ | Branch (4149:9): [True: 0, False: 14.1k] ------------------ 4150| 0| return XML_ERROR_NO_MEMORY; 4151| 14.1k| elementType = (ELEMENT_TYPE *)lookup(parser, &dtd->elementTypes, name, 4152| 14.1k| sizeof(ELEMENT_TYPE)); 4153| 14.1k| if (! elementType) ------------------ | Branch (4153:9): [True: 0, False: 14.1k] ------------------ 4154| 0| return XML_ERROR_NO_MEMORY; 4155| 14.1k| if (! elementType->defaultAttForName.parser) ------------------ | Branch (4155:9): [True: 14.1k, False: 0] ------------------ 4156| 14.1k| hashTableInit(&(elementType->defaultAttForName), parser); 4157| 14.1k| if (parser->m_ns && ! setElementTypePrefix(parser, elementType)) ------------------ | Branch (4157:9): [True: 5.82k, False: 8.34k] | Branch (4157:25): [True: 0, False: 5.82k] ------------------ 4158| 0| return XML_ERROR_NO_MEMORY; 4159| 14.1k| } 4160| 59.5k| const size_t nDefaultAtts = elementType->nDefaultAtts; 4161| | 4162| | /* Detect and prevent integer overflow. */ 4163| 59.5k| if (parser->m_attsSize > (size_t)INT_MAX) ------------------ | Branch (4163:7): [True: 0, False: 59.5k] ------------------ 4164| 0| return XML_ERROR_NO_MEMORY; 4165| | 4166| | /* get the attributes from the tokenizer */ 4167| 59.5k| size_t n = (size_t)XmlGetAttributes(enc, attStr, (int)parser->m_attsSize, ------------------ | | 261| 59.5k| (((enc)->getAtts)(enc, ptr, attsMax, atts)) ------------------ 4168| 59.5k| parser->m_atts); 4169| | 4170| | /* Detect and prevent integer overflow */ 4171| 59.5k| if (n > SIZE_MAX - nDefaultAtts) { ------------------ | Branch (4171:7): [True: 0, False: 59.5k] ------------------ 4172| 0| return XML_ERROR_NO_MEMORY; 4173| 0| } 4174| | 4175| 59.5k| if (n + nDefaultAtts > parser->m_attsSize) { ------------------ | Branch (4175:7): [True: 181, False: 59.4k] ------------------ 4176| 181| size_t oldAttsSize = parser->m_attsSize; 4177| | 4178| | /* Detect and prevent integer overflow */ 4179| 181| if ((nDefaultAtts > SIZE_MAX - INIT_ATTS_SIZE) ------------------ | | 255| 181|#define INIT_ATTS_SIZE 16 ------------------ | Branch (4179:9): [True: 0, False: 181] ------------------ 4180| 181| || (n > SIZE_MAX - (nDefaultAtts + INIT_ATTS_SIZE))) { ------------------ | | 255| 181|#define INIT_ATTS_SIZE 16 ------------------ | Branch (4180:12): [True: 0, False: 181] ------------------ 4181| 0| return XML_ERROR_NO_MEMORY; 4182| 0| } 4183| | 4184| 181| parser->m_attsSize = n + nDefaultAtts + INIT_ATTS_SIZE; ------------------ | | 255| 181|#define INIT_ATTS_SIZE 16 ------------------ 4185| | 4186| | /* Detect and prevent integer overflow. */ 4187| 181| if (parser->m_attsSize > SIZE_MAX / sizeof(ATTRIBUTE)) { ------------------ | Branch (4187:9): [True: 0, False: 181] ------------------ 4188| 0| parser->m_attsSize = oldAttsSize; 4189| 0| return XML_ERROR_NO_MEMORY; 4190| 0| } 4191| | 4192| 181| ATTRIBUTE *const temp = REALLOC(parser, parser->m_atts, ------------------ | | 836| 181|# define REALLOC(parser, p, s) (expat_realloc((parser), (p), (s), __LINE__)) ------------------ 4193| 181| parser->m_attsSize * sizeof(ATTRIBUTE)); 4194| 181| if (temp == NULL) { ------------------ | Branch (4194:9): [True: 0, False: 181] ------------------ 4195| 0| parser->m_attsSize = oldAttsSize; 4196| 0| return XML_ERROR_NO_MEMORY; 4197| 0| } 4198| 181| parser->m_atts = temp; 4199| 181| if (n > oldAttsSize) { ------------------ | Branch (4199:9): [True: 168, False: 13] ------------------ 4200| | /* Detect and prevent integer overflow. */ 4201| 168| if (n > (size_t)INT_MAX) ------------------ | Branch (4201:11): [True: 0, False: 168] ------------------ 4202| 0| return XML_ERROR_NO_MEMORY; 4203| 168| XmlGetAttributes(enc, attStr, (int)n, parser->m_atts); ------------------ | | 261| 168| (((enc)->getAtts)(enc, ptr, attsMax, atts)) ------------------ 4204| 168| } 4205| 181| } 4206| | 4207| | /* the attribute list for the application */ 4208| 59.5k| const XML_Char **const appAtts = (const XML_Char **)parser->m_atts; 4209| 93.1k| for (size_t i = 0; i < n; i++) { ------------------ | Branch (4209:22): [True: 33.8k, False: 59.2k] ------------------ 4210| 33.8k| ATTRIBUTE *currAtt = &parser->m_atts[i]; 4211| | /* add the name and value to the attribute list */ 4212| 33.8k| ATTRIBUTE_ID *attId 4213| 33.8k| = getAttributeId(parser, enc, currAtt->name, 4214| 33.8k| currAtt->name + XmlNameLength(enc, currAtt->name)); ------------------ | | 256| 33.8k|# define XmlNameLength(enc, ptr) (((enc)->nameLength)(enc, ptr)) ------------------ 4215| 33.8k| if (! attId) ------------------ | Branch (4215:9): [True: 0, False: 33.8k] ------------------ 4216| 0| return XML_ERROR_NO_MEMORY; 4217| | /* Detect duplicate attributes by their QNames. This does not work when 4218| | namespace processing is turned on and different prefixes for the same 4219| | namespace are used. For this case we have a check further down. 4220| | */ 4221| 33.8k| if ((attId->name)[-1]) { ------------------ | Branch (4221:9): [True: 168, False: 33.6k] ------------------ 4222| 168| if (enc == parser->m_encoding) ------------------ | Branch (4222:11): [True: 167, False: 1] ------------------ 4223| 167| parser->m_eventPtr = parser->m_atts[i].name; 4224| 168| return XML_ERROR_DUPLICATE_ATTRIBUTE; 4225| 168| } 4226| 33.6k| (attId->name)[-1] = 1; 4227| 33.6k| appAtts[attIndex++] = attId->name; 4228| 33.6k| if (! parser->m_atts[i].normalized) { ------------------ | Branch (4228:9): [True: 5.75k, False: 27.9k] ------------------ 4229| 5.75k| bool isCdata = true; 4230| | 4231| | /* figure out whether declared as other than CDATA */ 4232| 5.75k| if (attId->maybeTokenized) { ------------------ | Branch (4232:11): [True: 638, False: 5.11k] ------------------ 4233| 638| NAME_AND_DEFAULT_ATTRIBUTE *const nameAndDefaultAttribute 4234| 638| = (NAME_AND_DEFAULT_ATTRIBUTE *)lookup( 4235| 638| parser, &(elementType->defaultAttForName), attId->name, 0); 4236| 638| if (nameAndDefaultAttribute != NULL) { ------------------ | Branch (4236:13): [True: 444, False: 194] ------------------ 4237| 444| assert(nameAndDefaultAttribute->attIndex < elementType->nDefaultAtts); ------------------ | Branch (4237:11): [True: 0, False: 444] | Branch (4237:11): [True: 444, False: 0] ------------------ 4238| 444| const DEFAULT_ATTRIBUTE *const att 4239| 444| = elementType->defaultAtts + nameAndDefaultAttribute->attIndex; 4240| 444| isCdata = att->isCdata; 4241| 444| } 4242| 638| } 4243| | 4244| | /* normalize the attribute value */ 4245| 5.75k| const enum XML_Error result = storeAttributeValue( 4246| 5.75k| parser, enc, isCdata, parser->m_atts[i].valuePtr, 4247| 5.75k| parser->m_atts[i].valueEnd, &parser->m_tempPool, account); 4248| 5.75k| if (result) ------------------ | Branch (4248:11): [True: 113, False: 5.64k] ------------------ 4249| 113| return result; 4250| 5.64k| appAtts[attIndex] = poolStart(&parser->m_tempPool); ------------------ | | 671| 5.64k|#define poolStart(pool) ((pool)->start) ------------------ 4251| 5.64k| poolFinish(&parser->m_tempPool); ------------------ | | 676| 5.64k|#define poolFinish(pool) ((pool)->start = (pool)->ptr) ------------------ 4252| 27.9k| } else { 4253| | /* the value did not need normalizing */ 4254| 27.9k| appAtts[attIndex] = poolStoreString(&parser->m_tempPool, enc, 4255| 27.9k| parser->m_atts[i].valuePtr, 4256| 27.9k| parser->m_atts[i].valueEnd); 4257| 27.9k| if (appAtts[attIndex] == 0) ------------------ | Branch (4257:11): [True: 0, False: 27.9k] ------------------ 4258| 0| return XML_ERROR_NO_MEMORY; 4259| 27.9k| poolFinish(&parser->m_tempPool); ------------------ | | 676| 27.9k|#define poolFinish(pool) ((pool)->start = (pool)->ptr) ------------------ 4260| 27.9k| } 4261| | /* handle prefixed attribute names */ 4262| 33.5k| if (attId->prefix) { ------------------ | Branch (4262:9): [True: 19.9k, False: 13.6k] ------------------ 4263| 19.9k| if (attId->xmlns) { ------------------ | Branch (4263:11): [True: 1.86k, False: 18.0k] ------------------ 4264| | /* deal with namespace declarations here */ 4265| 1.86k| enum XML_Error result = addBinding(parser, attId->prefix, attId, 4266| 1.86k| appAtts[attIndex], bindingsPtr); 4267| 1.86k| if (result) ------------------ | Branch (4267:13): [True: 22, False: 1.84k] ------------------ 4268| 22| return result; 4269| 1.84k| --attIndex; 4270| 18.0k| } else { 4271| | /* deal with other prefixed names later */ 4272| 18.0k| attIndex++; 4273| 18.0k| nPrefixes++; 4274| 18.0k| (attId->name)[-1] = 2; 4275| 18.0k| } 4276| 19.9k| } else 4277| 13.6k| attIndex++; 4278| 33.5k| } 4279| | 4280| | /* set-up for XML_GetSpecifiedAttributeCount and XML_GetIdAttributeIndex */ 4281| 59.2k| parser->m_nSpecifiedAtts = attIndex; 4282| 59.2k| if (elementType->idAtt && (elementType->idAtt->name)[-1]) { ------------------ | Branch (4282:7): [True: 421, False: 58.8k] | Branch (4282:29): [True: 213, False: 208] ------------------ 4283| 279| for (int i = 0; i < attIndex; i += 2) ------------------ | Branch (4283:21): [True: 279, False: 0] ------------------ 4284| 279| if (appAtts[i] == elementType->idAtt->name) { ------------------ | Branch (4284:11): [True: 213, False: 66] ------------------ 4285| 213| parser->m_idAttIndex = i; 4286| 213| break; 4287| 213| } 4288| 213| } else 4289| 59.0k| parser->m_idAttIndex = -1; 4290| | 4291| | /* do attribute defaulting */ 4292| 76.4k| for (size_t i = 0; i < nDefaultAtts; i++) { ------------------ | Branch (4292:22): [True: 17.1k, False: 59.2k] ------------------ 4293| 17.1k| const DEFAULT_ATTRIBUTE *da = elementType->defaultAtts + i; 4294| 17.1k| if (! (da->id->name)[-1] && da->value) { ------------------ | Branch (4294:9): [True: 16.3k, False: 779] | Branch (4294:33): [True: 15.9k, False: 480] ------------------ 4295| 15.9k| if (da->id->prefix) { ------------------ | Branch (4295:11): [True: 14.9k, False: 960] ------------------ 4296| 14.9k| if (da->id->xmlns) { ------------------ | Branch (4296:13): [True: 11.8k, False: 3.15k] ------------------ 4297| 11.8k| enum XML_Error result = addBinding(parser, da->id->prefix, da->id, 4298| 11.8k| da->value, bindingsPtr); 4299| 11.8k| if (result) ------------------ | Branch (4299:15): [True: 3, False: 11.7k] ------------------ 4300| 3| return result; 4301| 11.8k| } else { 4302| 3.15k| (da->id->name)[-1] = 2; 4303| 3.15k| nPrefixes++; 4304| 3.15k| appAtts[attIndex++] = da->id->name; 4305| 3.15k| appAtts[attIndex++] = da->value; 4306| 3.15k| } 4307| 14.9k| } else { 4308| 960| (da->id->name)[-1] = 1; 4309| 960| appAtts[attIndex++] = da->id->name; 4310| 960| appAtts[attIndex++] = da->value; 4311| 960| } 4312| 15.9k| } 4313| 17.1k| } 4314| 59.2k| appAtts[attIndex] = 0; 4315| | 4316| | /* expand prefixed attribute names, check for duplicates, 4317| | and clear flags that say whether attributes were specified */ 4318| 59.2k| int i = 0; 4319| 59.2k| if (nPrefixes) { ------------------ | Branch (4319:7): [True: 18.2k, False: 41.0k] ------------------ 4320| 18.2k| unsigned int j; /* hash table index */ 4321| 18.2k| unsigned long version = parser->m_nsAttsVersion; 4322| | 4323| | /* Detect and prevent invalid shift */ 4324| 18.2k| if (parser->m_nsAttsPower >= sizeof(unsigned int) * 8 /* bits per byte */) { ------------------ | Branch (4324:9): [True: 0, False: 18.2k] ------------------ 4325| 0| return XML_ERROR_NO_MEMORY; 4326| 0| } 4327| | 4328| 18.2k| unsigned int nsAttsSize = 1u << parser->m_nsAttsPower; 4329| 18.2k| unsigned char oldNsAttsPower = parser->m_nsAttsPower; 4330| | /* size of hash table must be at least 2 * (# of prefixed attributes) */ 4331| 18.2k| if (parser->m_nsAttsPower == 0 ------------------ | Branch (4331:9): [True: 243, False: 17.9k] ------------------ 4332| 17.9k| || (nPrefixes >> (parser->m_nsAttsPower - 1))) { ------------------ | Branch (4332:12): [True: 16, False: 17.9k] ------------------ 4333| | /* hash table size must also be a power of 2 and >= 8 */ 4334| 748| while (nPrefixes >> parser->m_nsAttsPower++) ------------------ | Branch (4334:14): [True: 489, False: 259] ------------------ 4335| 489| ; 4336| 259| if (parser->m_nsAttsPower < 3) ------------------ | Branch (4336:11): [True: 122, False: 137] ------------------ 4337| 122| parser->m_nsAttsPower = 3; 4338| | 4339| | /* Detect and prevent invalid shift */ 4340| 259| if (parser->m_nsAttsPower >= sizeof(nsAttsSize) * 8 /* bits per byte */) { ------------------ | Branch (4340:11): [True: 0, False: 259] ------------------ 4341| | /* Restore actual size of memory in m_nsAtts */ 4342| 0| parser->m_nsAttsPower = oldNsAttsPower; 4343| 0| return XML_ERROR_NO_MEMORY; 4344| 0| } 4345| | 4346| 259| nsAttsSize = 1u << parser->m_nsAttsPower; 4347| | 4348| | /* Detect and prevent integer overflow. 4349| | * The preprocessor guard addresses the "always false" warning 4350| | * from -Wtype-limits on platforms where 4351| | * sizeof(unsigned int) < sizeof(size_t), e.g. on x86_64. */ 4352| |#if UINT_MAX >= SIZE_MAX 4353| | if (nsAttsSize > SIZE_MAX / sizeof(NS_ATT)) { 4354| | /* Restore actual size of memory in m_nsAtts */ 4355| | parser->m_nsAttsPower = oldNsAttsPower; 4356| | return XML_ERROR_NO_MEMORY; 4357| | } 4358| |#endif 4359| | 4360| 259| NS_ATT *const temp 4361| 259| = REALLOC(parser, parser->m_nsAtts, nsAttsSize * sizeof(NS_ATT)); ------------------ | | 836| 259|# define REALLOC(parser, p, s) (expat_realloc((parser), (p), (s), __LINE__)) ------------------ 4362| 259| if (! temp) { ------------------ | Branch (4362:11): [True: 0, False: 259] ------------------ 4363| | /* Restore actual size of memory in m_nsAtts */ 4364| 0| parser->m_nsAttsPower = oldNsAttsPower; 4365| 0| return XML_ERROR_NO_MEMORY; 4366| 0| } 4367| 259| parser->m_nsAtts = temp; 4368| 259| version = 0; /* force re-initialization of m_nsAtts hash table */ 4369| 259| } 4370| | /* using a version flag saves us from initializing m_nsAtts every time */ 4371| 18.2k| if (! version) { /* initialize version flags when version wraps around */ ------------------ | Branch (4371:9): [True: 259, False: 17.9k] ------------------ 4372| 259| version = INIT_ATTS_VERSION; ------------------ | | 256| 259|#define INIT_ATTS_VERSION 0xFFFFFFFF ------------------ 4373| 4.26k| for (j = nsAttsSize; j != 0;) ------------------ | Branch (4373:28): [True: 4.00k, False: 259] ------------------ 4374| 4.00k| parser->m_nsAtts[--j].version = version; 4375| 259| } 4376| 18.2k| parser->m_nsAttsVersion = --version; 4377| | 4378| | /* expand prefixed names and check for duplicates */ 4379| 21.3k| for (; i < attIndex; i += 2) { ------------------ | Branch (4379:12): [True: 21.3k, False: 0] ------------------ 4380| 21.3k| const XML_Char *s = appAtts[i]; 4381| 21.3k| if (s[-1] == 2) { /* prefixed */ ------------------ | Branch (4381:11): [True: 21.0k, False: 238] ------------------ 4382| 21.0k| struct siphash sip_state; 4383| 21.0k| struct sipkey sip_key; 4384| | 4385| 21.0k| copy_salt_to_sipkey(parser, &sip_key); 4386| 21.0k| sip24_init(&sip_state, &sip_key); 4387| | 4388| 21.0k| ((XML_Char *)s)[-1] = 0; /* clear flag */ 4389| 21.0k| ATTRIBUTE_ID *const id 4390| 21.0k| = (ATTRIBUTE_ID *)lookup(parser, &dtd->attributeIds, s, 0); 4391| 21.0k| if (! id || ! id->prefix) { ------------------ | Branch (4391:13): [True: 0, False: 21.0k] | Branch (4391:21): [True: 0, False: 21.0k] ------------------ 4392| | /* This code is walking through the appAtts array, dealing 4393| | * with (in this case) a prefixed attribute name. To be in 4394| | * the array, the attribute must have already been bound, so 4395| | * has to have passed through the hash table lookup once 4396| | * already. That implies that an entry for it already 4397| | * exists, so the lookup above will return a pointer to 4398| | * already allocated memory. There is no opportunity for 4399| | * the allocator to fail, so the condition above cannot be 4400| | * fulfilled. 4401| | * 4402| | * Since it is difficult to be certain that the above 4403| | * analysis is complete, we retain the test and merely 4404| | * remove the code from coverage tests. 4405| | */ 4406| 0| return XML_ERROR_NO_MEMORY; /* LCOV_EXCL_LINE */ 4407| 0| } 4408| 21.0k| const BINDING *const b = id->prefix->binding; 4409| 21.0k| if (! b) ------------------ | Branch (4409:13): [True: 54, False: 21.0k] ------------------ 4410| 54| return XML_ERROR_UNBOUND_PREFIX; 4411| | 4412| 21.0k| if (! poolAppendChars(&parser->m_tempPool, b->uri, b->uriLen)) ------------------ | Branch (4412:13): [True: 0, False: 21.0k] ------------------ 4413| 0| return XML_ERROR_NO_MEMORY; 4414| | 4415| 21.0k| sip24_update(&sip_state, b->uri, b->uriLen * sizeof(XML_Char)); 4416| | 4417| 82.4k| while (*s++ != XML_T(ASCII_COLON)) ------------------ | | 220| 82.4k|# define XML_T(x) x ------------------ | Branch (4417:16): [True: 61.4k, False: 21.0k] ------------------ 4418| 61.4k| ; 4419| | 4420| 21.0k| sip24_update(&sip_state, s, keylen(s) * sizeof(XML_Char)); 4421| | 4422| 21.0k| { 4423| 21.0k| const size_t len = xcslen(s) + /*null terminator*/ 1; 4424| 21.0k| if (! poolAppendChars(&parser->m_tempPool, s, len)) ------------------ | Branch (4424:15): [True: 0, False: 21.0k] ------------------ 4425| 0| return XML_ERROR_NO_MEMORY; 4426| 21.0k| } 4427| | 4428| 21.0k| const unsigned long uriHash = (unsigned long)sip24_final(&sip_state); 4429| | 4430| 21.0k| { /* Check hash table for duplicate of expanded name (uriName). 4431| | Derived from code in lookup(parser, HASH_TABLE *table, ...). 4432| | */ 4433| 21.0k| unsigned char step = 0; 4434| 21.0k| unsigned long mask = nsAttsSize - 1; 4435| 21.0k| j = uriHash & mask; /* index into hash table */ 4436| 21.2k| while (parser->m_nsAtts[j].version == version) { ------------------ | Branch (4436:18): [True: 297, False: 20.9k] ------------------ 4437| | /* for speed we compare stored hash values first */ 4438| 297| if (uriHash == parser->m_nsAtts[j].hash) { ------------------ | Branch (4438:17): [True: 11, False: 286] ------------------ 4439| 11| const XML_Char *s1 = poolStart(&parser->m_tempPool); ------------------ | | 671| 11|#define poolStart(pool) ((pool)->start) ------------------ 4440| 11| const XML_Char *s2 = parser->m_nsAtts[j].uriName; 4441| | /* s1 is null terminated, but not s2 */ 4442| 1.01k| for (; *s1 == *s2 && *s1 != 0; s1++, s2++) ------------------ | Branch (4442:22): [True: 1.01k, False: 0] | Branch (4442:36): [True: 1.00k, False: 11] ------------------ 4443| 1.00k| ; 4444| 11| if (*s1 == 0) ------------------ | Branch (4444:19): [True: 11, False: 0] ------------------ 4445| 11| return XML_ERROR_DUPLICATE_ATTRIBUTE; 4446| 11| } 4447| 286| if (! step) ------------------ | Branch (4447:17): [True: 251, False: 35] ------------------ 4448| 251| step = PROBE_STEP(uriHash, mask, parser->m_nsAttsPower); ------------------ | | 251| 251| ((unsigned char)((SECOND_HASH(hash, mask, power)) | 1)) | | ------------------ | | | | 249| 251| ((((hash) & ~(mask)) >> ((power) - 1)) & ((mask) >> 2)) | | ------------------ ------------------ 4449| 286| j < step ? (j += nsAttsSize - step) : (j -= step); ------------------ | Branch (4449:13): [True: 20, False: 266] ------------------ 4450| 286| } 4451| 21.0k| } 4452| | 4453| 20.9k| if (parser->m_ns_triplets) { /* append namespace separator and prefix */ ------------------ | Branch (4453:13): [True: 0, False: 20.9k] ------------------ 4454| 0| parser->m_tempPool.ptr[-1] = parser->m_namespaceSeparator; 4455| 0| s = b->prefix->name; 4456| 0| const size_t len = xcslen(s) + /*null terminator*/ 1; 4457| 0| if (! poolAppendChars(&parser->m_tempPool, s, len)) ------------------ | Branch (4457:15): [True: 0, False: 0] ------------------ 4458| 0| return XML_ERROR_NO_MEMORY; 4459| 0| } 4460| | 4461| | /* store expanded name in attribute list */ 4462| 20.9k| s = poolStart(&parser->m_tempPool); ------------------ | | 671| 20.9k|#define poolStart(pool) ((pool)->start) ------------------ 4463| 20.9k| poolFinish(&parser->m_tempPool); ------------------ | | 676| 20.9k|#define poolFinish(pool) ((pool)->start = (pool)->ptr) ------------------ 4464| 20.9k| appAtts[i] = s; 4465| | 4466| | /* fill empty slot with new version, uriName and hash value */ 4467| 20.9k| parser->m_nsAtts[j].version = version; 4468| 20.9k| parser->m_nsAtts[j].hash = uriHash; 4469| 20.9k| parser->m_nsAtts[j].uriName = s; 4470| | 4471| 20.9k| if (! --nPrefixes) { ------------------ | Branch (4471:13): [True: 18.1k, False: 2.83k] ------------------ 4472| 18.1k| i += 2; 4473| 18.1k| break; 4474| 18.1k| } 4475| 20.9k| } else /* not prefixed */ 4476| 238| ((XML_Char *)s)[-1] = 0; /* clear flag */ 4477| 21.3k| } 4478| 18.2k| } 4479| | /* clear flags for the remaining attributes */ 4480| 72.5k| for (; i < attIndex; i += 2) ------------------ | Branch (4480:10): [True: 13.3k, False: 59.2k] ------------------ 4481| 13.3k| ((XML_Char *)(appAtts[i]))[-1] = 0; 4482| 72.7k| for (binding = *bindingsPtr; binding; binding = binding->nextTagBinding) ------------------ | Branch (4482:32): [True: 13.5k, False: 59.2k] ------------------ 4483| 13.5k| binding->attId->name[-1] = 0; 4484| | 4485| 59.2k| if (! parser->m_ns) ------------------ | Branch (4485:7): [True: 22.5k, False: 36.6k] ------------------ 4486| 22.5k| return XML_ERROR_NONE; 4487| | 4488| | /* expand the element type name */ 4489| 36.6k| if (elementType->prefix) { ------------------ | Branch (4489:7): [True: 1.58k, False: 35.1k] ------------------ 4490| 1.58k| binding = elementType->prefix->binding; 4491| 1.58k| if (! binding) ------------------ | Branch (4491:9): [True: 44, False: 1.54k] ------------------ 4492| 44| return XML_ERROR_UNBOUND_PREFIX; 4493| 1.54k| localPart = tagNamePtr->str; 4494| 6.14k| while (*localPart++ != XML_T(ASCII_COLON)) ------------------ | | 220| 6.14k|# define XML_T(x) x ------------------ | Branch (4494:12): [True: 4.59k, False: 1.54k] ------------------ 4495| 4.59k| ; 4496| 35.1k| } else if (dtd->defaultPrefix.binding) { ------------------ | Branch (4496:14): [True: 2.94k, False: 32.1k] ------------------ 4497| 2.94k| binding = dtd->defaultPrefix.binding; 4498| 2.94k| localPart = tagNamePtr->str; 4499| 2.94k| } else 4500| 32.1k| return XML_ERROR_NONE; 4501| 4.49k| size_t prefixLen = 0; 4502| 4.49k| if (parser->m_ns_triplets && binding->prefix->name) ------------------ | Branch (4502:7): [True: 0, False: 4.49k] | Branch (4502:32): [True: 0, False: 0] ------------------ 4503| 0| prefixLen = xcslen(binding->prefix->name) + /*null terminator*/ 1; 4504| 4.49k| tagNamePtr->localPart = localPart; 4505| 4.49k| tagNamePtr->uriLen = binding->uriLen; 4506| 4.49k| tagNamePtr->prefix = binding->prefix->name; 4507| 4.49k| tagNamePtr->prefixLen = prefixLen; 4508| | 4509| 4.49k| const size_t localPartLen = xcslen(localPart) + /*null terminator*/ 1; 4510| | 4511| | /* Detect and prevent integer overflow */ 4512| 4.49k| if (binding->uriLen > SIZE_MAX - prefixLen ------------------ | Branch (4512:7): [True: 0, False: 4.49k] ------------------ 4513| 4.49k| || localPartLen > SIZE_MAX - (binding->uriLen + prefixLen)) { ------------------ | Branch (4513:10): [True: 0, False: 4.49k] ------------------ 4514| 0| return XML_ERROR_NO_MEMORY; 4515| 0| } 4516| | 4517| 4.49k| const size_t totalLen = localPartLen + binding->uriLen + prefixLen; 4518| 4.49k| if (totalLen > binding->uriAlloc) { ------------------ | Branch (4518:7): [True: 169, False: 4.32k] ------------------ 4519| | /* Detect and prevent integer overflow */ 4520| 169| if (totalLen > SIZE_MAX - EXPAND_SPARE ------------------ | | 260| 338|#define EXPAND_SPARE 24 ------------------ | Branch (4520:9): [True: 0, False: 169] ------------------ 4521| 169| || totalLen + EXPAND_SPARE > SIZE_MAX / sizeof(XML_Char)) { ------------------ | | 260| 169|#define EXPAND_SPARE 24 ------------------ | Branch (4521:12): [True: 0, False: 169] ------------------ 4522| 0| return XML_ERROR_NO_MEMORY; 4523| 0| } 4524| | 4525| 169| uri = MALLOC(parser, (totalLen + EXPAND_SPARE) * sizeof(XML_Char)); ------------------ | | 835| 169|# define MALLOC(parser, s) (expat_malloc((parser), (s), __LINE__)) ------------------ 4526| 169| if (! uri) ------------------ | Branch (4526:9): [True: 0, False: 169] ------------------ 4527| 0| return XML_ERROR_NO_MEMORY; 4528| 169| binding->uriAlloc = totalLen + EXPAND_SPARE; ------------------ | | 260| 169|#define EXPAND_SPARE 24 ------------------ 4529| 169| memcpy(uri, binding->uri, binding->uriLen * sizeof(XML_Char)); 4530| 2.25k| for (TAG *p = parser->m_tagStack; p; p = p->parent) ------------------ | Branch (4530:39): [True: 2.08k, False: 169] ------------------ 4531| 2.08k| if (p->name.str == binding->uri) ------------------ | Branch (4531:11): [True: 338, False: 1.74k] ------------------ 4532| 338| p->name.str = uri; 4533| 169| FREE(parser, binding->uri); ------------------ | | 837| 169|# define FREE(parser, p) (expat_free((parser), (p), __LINE__)) ------------------ 4534| 169| binding->uri = uri; 4535| 169| } 4536| | /* if m_namespaceSeparator != '\0' then uri includes it already */ 4537| 4.49k| uri = binding->uri + binding->uriLen; 4538| | /* Detect and prevent integer overflow */ 4539| 4.49k| if (localPartLen > SIZE_MAX / sizeof(XML_Char)) { ------------------ | Branch (4539:7): [True: 0, False: 4.49k] ------------------ 4540| 0| return XML_ERROR_NO_MEMORY; 4541| 0| } 4542| 4.49k| memcpy(uri, localPart, localPartLen * sizeof(XML_Char)); 4543| | /* we always have a namespace separator between localPart and prefix */ 4544| 4.49k| if (prefixLen) { ------------------ | Branch (4544:7): [True: 0, False: 4.49k] ------------------ 4545| 0| uri += localPartLen - 1; 4546| 0| *uri = parser->m_namespaceSeparator; /* replace null terminator */ 4547| 0| memcpy(uri + 1, binding->prefix->name, prefixLen * sizeof(XML_Char)); 4548| 0| } 4549| 4.49k| tagNamePtr->str = binding->uri; 4550| 4.49k| return XML_ERROR_NONE; 4551| 4.49k|} xmlparse.c:setElementTypePrefix: 7592| 7.02k|setElementTypePrefix(XML_Parser parser, ELEMENT_TYPE *elementType) { 7593| 7.02k| DTD *const dtd = parser->m_dtd; /* save one level of indirection */ 7594| 7.02k| const XML_Char *name; 7595| 23.0k| for (name = elementType->name; *name; name++) { ------------------ | Branch (7595:34): [True: 16.5k, False: 6.50k] ------------------ 7596| 16.5k| if (*name == XML_T(ASCII_COLON)) { ------------------ | | 220| 16.5k|# define XML_T(x) x ------------------ | Branch (7596:9): [True: 523, False: 16.0k] ------------------ 7597| 523| PREFIX *prefix; 7598| 523| const XML_Char *s; 7599| 1.72k| for (s = elementType->name; s != name; s++) { ------------------ | Branch (7599:35): [True: 1.19k, False: 523] ------------------ 7600| 1.19k| if (! poolAppendChar(&dtd->pool, *s)) ------------------ | Branch (7600:13): [True: 0, False: 1.19k] ------------------ 7601| 0| return 0; 7602| 1.19k| } 7603| 523| if (! poolAppendChar(&dtd->pool, XML_T('\0'))) ------------------ | | 220| 523|# define XML_T(x) x ------------------ | Branch (7603:11): [True: 0, False: 523] ------------------ 7604| 0| return 0; 7605| 523| prefix = (PREFIX *)lookup(parser, &dtd->prefixes, poolStart(&dtd->pool), ------------------ | | 671| 523|#define poolStart(pool) ((pool)->start) ------------------ 7606| 523| sizeof(PREFIX)); 7607| 523| if (! prefix) ------------------ | Branch (7607:11): [True: 0, False: 523] ------------------ 7608| 0| return 0; 7609| 523| if (prefix->name == poolStart(&dtd->pool)) ------------------ | | 671| 523|#define poolStart(pool) ((pool)->start) ------------------ | Branch (7609:11): [True: 245, False: 278] ------------------ 7610| 245| poolFinish(&dtd->pool); ------------------ | | 676| 245|#define poolFinish(pool) ((pool)->start = (pool)->ptr) ------------------ 7611| 278| else 7612| 278| poolDiscard(&dtd->pool); ------------------ | | 675| 278|#define poolDiscard(pool) ((pool)->ptr = (pool)->start) ------------------ 7613| 523| elementType->prefix = prefix; 7614| 523| break; 7615| 523| } 7616| 16.5k| } 7617| 7.02k| return 1; 7618| 7.02k|} xmlparse.c:addBinding: 4669| 18.4k| const XML_Char *uri, BINDING **bindingsPtr) { 4670| | // "http://www.w3.org/XML/1998/namespace" 4671| 18.4k| static const XML_Char xmlNamespace[] 4672| 18.4k| = {ASCII_h, ASCII_t, ASCII_t, ASCII_p, ASCII_COLON, ------------------ | | 72| 18.4k|#define ASCII_h 0x68 ------------------ = {ASCII_h, ASCII_t, ASCII_t, ASCII_p, ASCII_COLON, ------------------ | | 84| 18.4k|#define ASCII_t 0x74 ------------------ = {ASCII_h, ASCII_t, ASCII_t, ASCII_p, ASCII_COLON, ------------------ | | 84| 18.4k|#define ASCII_t 0x74 ------------------ = {ASCII_h, ASCII_t, ASCII_t, ASCII_p, ASCII_COLON, ------------------ | | 80| 18.4k|#define ASCII_p 0x70 ------------------ = {ASCII_h, ASCII_t, ASCII_t, ASCII_p, ASCII_COLON, ------------------ | | 111| 18.4k|#define ASCII_COLON 0x3A ------------------ 4673| 18.4k| ASCII_SLASH, ASCII_SLASH, ASCII_w, ASCII_w, ASCII_w, ------------------ | | 122| 18.4k|#define ASCII_SLASH 0x2F ------------------ ASCII_SLASH, ASCII_SLASH, ASCII_w, ASCII_w, ASCII_w, ------------------ | | 122| 18.4k|#define ASCII_SLASH 0x2F ------------------ ASCII_SLASH, ASCII_SLASH, ASCII_w, ASCII_w, ASCII_w, ------------------ | | 87| 18.4k|#define ASCII_w 0x77 ------------------ ASCII_SLASH, ASCII_SLASH, ASCII_w, ASCII_w, ASCII_w, ------------------ | | 87| 18.4k|#define ASCII_w 0x77 ------------------ ASCII_SLASH, ASCII_SLASH, ASCII_w, ASCII_w, ASCII_w, ------------------ | | 87| 18.4k|#define ASCII_w 0x77 ------------------ 4674| 18.4k| ASCII_PERIOD, ASCII_w, ASCII_3, ASCII_PERIOD, ASCII_o, ------------------ | | 110| 18.4k|#define ASCII_PERIOD 0x2E ------------------ ASCII_PERIOD, ASCII_w, ASCII_3, ASCII_PERIOD, ASCII_o, ------------------ | | 87| 18.4k|#define ASCII_w 0x77 ------------------ ASCII_PERIOD, ASCII_w, ASCII_3, ASCII_PERIOD, ASCII_o, ------------------ | | 95| 18.4k|#define ASCII_3 0x33 ------------------ ASCII_PERIOD, ASCII_w, ASCII_3, ASCII_PERIOD, ASCII_o, ------------------ | | 110| 18.4k|#define ASCII_PERIOD 0x2E ------------------ ASCII_PERIOD, ASCII_w, ASCII_3, ASCII_PERIOD, ASCII_o, ------------------ | | 79| 18.4k|#define ASCII_o 0x6F ------------------ 4675| 18.4k| ASCII_r, ASCII_g, ASCII_SLASH, ASCII_X, ASCII_M, ------------------ | | 82| 18.4k|#define ASCII_r 0x72 ------------------ ASCII_r, ASCII_g, ASCII_SLASH, ASCII_X, ASCII_M, ------------------ | | 71| 18.4k|#define ASCII_g 0x67 ------------------ ASCII_r, ASCII_g, ASCII_SLASH, ASCII_X, ASCII_M, ------------------ | | 122| 18.4k|#define ASCII_SLASH 0x2F ------------------ ASCII_r, ASCII_g, ASCII_SLASH, ASCII_X, ASCII_M, ------------------ | | 61| 18.4k|#define ASCII_X 0x58 ------------------ ASCII_r, ASCII_g, ASCII_SLASH, ASCII_X, ASCII_M, ------------------ | | 50| 18.4k|#define ASCII_M 0x4D ------------------ 4676| 18.4k| ASCII_L, ASCII_SLASH, ASCII_1, ASCII_9, ASCII_9, ------------------ | | 49| 18.4k|#define ASCII_L 0x4C ------------------ ASCII_L, ASCII_SLASH, ASCII_1, ASCII_9, ASCII_9, ------------------ | | 122| 18.4k|#define ASCII_SLASH 0x2F ------------------ ASCII_L, ASCII_SLASH, ASCII_1, ASCII_9, ASCII_9, ------------------ | | 93| 18.4k|#define ASCII_1 0x31 ------------------ ASCII_L, ASCII_SLASH, ASCII_1, ASCII_9, ASCII_9, ------------------ | | 101| 18.4k|#define ASCII_9 0x39 ------------------ ASCII_L, ASCII_SLASH, ASCII_1, ASCII_9, ASCII_9, ------------------ | | 101| 18.4k|#define ASCII_9 0x39 ------------------ 4677| 18.4k| ASCII_8, ASCII_SLASH, ASCII_n, ASCII_a, ASCII_m, ------------------ | | 100| 18.4k|#define ASCII_8 0x38 ------------------ ASCII_8, ASCII_SLASH, ASCII_n, ASCII_a, ASCII_m, ------------------ | | 122| 18.4k|#define ASCII_SLASH 0x2F ------------------ ASCII_8, ASCII_SLASH, ASCII_n, ASCII_a, ASCII_m, ------------------ | | 78| 18.4k|#define ASCII_n 0x6E ------------------ ASCII_8, ASCII_SLASH, ASCII_n, ASCII_a, ASCII_m, ------------------ | | 65| 18.4k|#define ASCII_a 0x61 ------------------ ASCII_8, ASCII_SLASH, ASCII_n, ASCII_a, ASCII_m, ------------------ | | 77| 18.4k|#define ASCII_m 0x6D ------------------ 4678| 18.4k| ASCII_e, ASCII_s, ASCII_p, ASCII_a, ASCII_c, ------------------ | | 69| 18.4k|#define ASCII_e 0x65 ------------------ ASCII_e, ASCII_s, ASCII_p, ASCII_a, ASCII_c, ------------------ | | 83| 18.4k|#define ASCII_s 0x73 ------------------ ASCII_e, ASCII_s, ASCII_p, ASCII_a, ASCII_c, ------------------ | | 80| 18.4k|#define ASCII_p 0x70 ------------------ ASCII_e, ASCII_s, ASCII_p, ASCII_a, ASCII_c, ------------------ | | 65| 18.4k|#define ASCII_a 0x61 ------------------ ASCII_e, ASCII_s, ASCII_p, ASCII_a, ASCII_c, ------------------ | | 67| 18.4k|#define ASCII_c 0x63 ------------------ 4679| 18.4k| ASCII_e, '\0'}; ------------------ | | 69| 18.4k|#define ASCII_e 0x65 ------------------ 4680| 18.4k| static const size_t xmlLen = sizeof(xmlNamespace) / sizeof(XML_Char) - 1; 4681| | // "http://www.w3.org/2000/xmlns/" 4682| 18.4k| static const XML_Char xmlnsNamespace[] 4683| 18.4k| = {ASCII_h, ASCII_t, ASCII_t, ASCII_p, ASCII_COLON, ASCII_SLASH, ------------------ | | 72| 18.4k|#define ASCII_h 0x68 ------------------ = {ASCII_h, ASCII_t, ASCII_t, ASCII_p, ASCII_COLON, ASCII_SLASH, ------------------ | | 84| 18.4k|#define ASCII_t 0x74 ------------------ = {ASCII_h, ASCII_t, ASCII_t, ASCII_p, ASCII_COLON, ASCII_SLASH, ------------------ | | 84| 18.4k|#define ASCII_t 0x74 ------------------ = {ASCII_h, ASCII_t, ASCII_t, ASCII_p, ASCII_COLON, ASCII_SLASH, ------------------ | | 80| 18.4k|#define ASCII_p 0x70 ------------------ = {ASCII_h, ASCII_t, ASCII_t, ASCII_p, ASCII_COLON, ASCII_SLASH, ------------------ | | 111| 18.4k|#define ASCII_COLON 0x3A ------------------ = {ASCII_h, ASCII_t, ASCII_t, ASCII_p, ASCII_COLON, ASCII_SLASH, ------------------ | | 122| 18.4k|#define ASCII_SLASH 0x2F ------------------ 4684| 18.4k| ASCII_SLASH, ASCII_w, ASCII_w, ASCII_w, ASCII_PERIOD, ASCII_w, ------------------ | | 122| 18.4k|#define ASCII_SLASH 0x2F ------------------ ASCII_SLASH, ASCII_w, ASCII_w, ASCII_w, ASCII_PERIOD, ASCII_w, ------------------ | | 87| 18.4k|#define ASCII_w 0x77 ------------------ ASCII_SLASH, ASCII_w, ASCII_w, ASCII_w, ASCII_PERIOD, ASCII_w, ------------------ | | 87| 18.4k|#define ASCII_w 0x77 ------------------ ASCII_SLASH, ASCII_w, ASCII_w, ASCII_w, ASCII_PERIOD, ASCII_w, ------------------ | | 87| 18.4k|#define ASCII_w 0x77 ------------------ ASCII_SLASH, ASCII_w, ASCII_w, ASCII_w, ASCII_PERIOD, ASCII_w, ------------------ | | 110| 18.4k|#define ASCII_PERIOD 0x2E ------------------ ASCII_SLASH, ASCII_w, ASCII_w, ASCII_w, ASCII_PERIOD, ASCII_w, ------------------ | | 87| 18.4k|#define ASCII_w 0x77 ------------------ 4685| 18.4k| ASCII_3, ASCII_PERIOD, ASCII_o, ASCII_r, ASCII_g, ASCII_SLASH, ------------------ | | 95| 18.4k|#define ASCII_3 0x33 ------------------ ASCII_3, ASCII_PERIOD, ASCII_o, ASCII_r, ASCII_g, ASCII_SLASH, ------------------ | | 110| 18.4k|#define ASCII_PERIOD 0x2E ------------------ ASCII_3, ASCII_PERIOD, ASCII_o, ASCII_r, ASCII_g, ASCII_SLASH, ------------------ | | 79| 18.4k|#define ASCII_o 0x6F ------------------ ASCII_3, ASCII_PERIOD, ASCII_o, ASCII_r, ASCII_g, ASCII_SLASH, ------------------ | | 82| 18.4k|#define ASCII_r 0x72 ------------------ ASCII_3, ASCII_PERIOD, ASCII_o, ASCII_r, ASCII_g, ASCII_SLASH, ------------------ | | 71| 18.4k|#define ASCII_g 0x67 ------------------ ASCII_3, ASCII_PERIOD, ASCII_o, ASCII_r, ASCII_g, ASCII_SLASH, ------------------ | | 122| 18.4k|#define ASCII_SLASH 0x2F ------------------ 4686| 18.4k| ASCII_2, ASCII_0, ASCII_0, ASCII_0, ASCII_SLASH, ASCII_x, ------------------ | | 94| 18.4k|#define ASCII_2 0x32 ------------------ ASCII_2, ASCII_0, ASCII_0, ASCII_0, ASCII_SLASH, ASCII_x, ------------------ | | 92| 18.4k|#define ASCII_0 0x30 ------------------ ASCII_2, ASCII_0, ASCII_0, ASCII_0, ASCII_SLASH, ASCII_x, ------------------ | | 92| 18.4k|#define ASCII_0 0x30 ------------------ ASCII_2, ASCII_0, ASCII_0, ASCII_0, ASCII_SLASH, ASCII_x, ------------------ | | 92| 18.4k|#define ASCII_0 0x30 ------------------ ASCII_2, ASCII_0, ASCII_0, ASCII_0, ASCII_SLASH, ASCII_x, ------------------ | | 122| 18.4k|#define ASCII_SLASH 0x2F ------------------ ASCII_2, ASCII_0, ASCII_0, ASCII_0, ASCII_SLASH, ASCII_x, ------------------ | | 88| 18.4k|#define ASCII_x 0x78 ------------------ 4687| 18.4k| ASCII_m, ASCII_l, ASCII_n, ASCII_s, ASCII_SLASH, '\0'}; ------------------ | | 77| 18.4k|#define ASCII_m 0x6D ------------------ ASCII_m, ASCII_l, ASCII_n, ASCII_s, ASCII_SLASH, '\0'}; ------------------ | | 76| 18.4k|#define ASCII_l 0x6C ------------------ ASCII_m, ASCII_l, ASCII_n, ASCII_s, ASCII_SLASH, '\0'}; ------------------ | | 78| 18.4k|#define ASCII_n 0x6E ------------------ ASCII_m, ASCII_l, ASCII_n, ASCII_s, ASCII_SLASH, '\0'}; ------------------ | | 83| 18.4k|#define ASCII_s 0x73 ------------------ ASCII_m, ASCII_l, ASCII_n, ASCII_s, ASCII_SLASH, '\0'}; ------------------ | | 122| 18.4k|#define ASCII_SLASH 0x2F ------------------ 4688| 18.4k| static const size_t xmlnsLen = sizeof(xmlnsNamespace) / sizeof(XML_Char) - 1; 4689| | 4690| 18.4k| XML_Bool mustBeXML = XML_FALSE; ------------------ | | 64| 18.4k|# define XML_FALSE ((XML_Bool)0) ------------------ 4691| 18.4k| XML_Bool isXML = XML_TRUE; ------------------ | | 63| 18.4k|# define XML_TRUE ((XML_Bool)1) ------------------ 4692| 18.4k| XML_Bool isXMLNS = XML_TRUE; ------------------ | | 63| 18.4k|# define XML_TRUE ((XML_Bool)1) ------------------ 4693| | 4694| 18.4k| BINDING *b; 4695| 18.4k| size_t len; 4696| | 4697| | /* empty URI is only valid for default namespace per XML NS 1.0 (not 1.1) */ 4698| 18.4k| if (*uri == XML_T('\0') && prefix->name) ------------------ | | 220| 36.8k|# define XML_T(x) x ------------------ | Branch (4698:7): [True: 2.10k, False: 16.3k] | Branch (4698:30): [True: 4, False: 2.09k] ------------------ 4699| 4| return XML_ERROR_UNDECLARING_PREFIX; 4700| | 4701| 18.4k| if (prefix->name && prefix->name[0] == XML_T(ASCII_x) ------------------ | | 220| 32.3k|# define XML_T(x) x ------------------ | Branch (4701:7): [True: 13.9k, False: 4.52k] | Branch (4701:23): [True: 6.60k, False: 7.29k] ------------------ 4702| 6.60k| && prefix->name[1] == XML_T(ASCII_m) ------------------ | | 220| 25.0k|# define XML_T(x) x ------------------ | Branch (4702:10): [True: 5.59k, False: 1.01k] ------------------ 4703| 5.59k| && prefix->name[2] == XML_T(ASCII_l)) { ------------------ | | 220| 5.59k|# define XML_T(x) x ------------------ | Branch (4703:10): [True: 5.38k, False: 209] ------------------ 4704| | /* Not allowed to bind xmlns */ 4705| 5.38k| if (prefix->name[3] == XML_T(ASCII_n) && prefix->name[4] == XML_T(ASCII_s) ------------------ | | 220| 10.7k|# define XML_T(x) x ------------------ if (prefix->name[3] == XML_T(ASCII_n) && prefix->name[4] == XML_T(ASCII_s) ------------------ | | 220| 5.79k|# define XML_T(x) x ------------------ | Branch (4705:9): [True: 406, False: 4.98k] | Branch (4705:46): [True: 200, False: 206] ------------------ 4706| 200| && prefix->name[5] == XML_T('\0')) ------------------ | | 220| 200|# define XML_T(x) x ------------------ | Branch (4706:12): [True: 2, False: 198] ------------------ 4707| 2| return XML_ERROR_RESERVED_PREFIX_XMLNS; 4708| | 4709| 5.38k| if (prefix->name[3] == XML_T('\0')) ------------------ | | 220| 5.38k|# define XML_T(x) x ------------------ | Branch (4709:9): [True: 4.77k, False: 609] ------------------ 4710| 4.77k| mustBeXML = XML_TRUE; ------------------ | | 63| 4.77k|# define XML_TRUE ((XML_Bool)1) ------------------ 4711| 5.38k| } 4712| | 4713| 1.19M| for (len = 0; uri[len]; len++) { ------------------ | Branch (4713:17): [True: 1.17M, False: 18.4k] ------------------ 4714| | /* Detect and prevent integer overflow */ 4715| 1.17M| if (len == SIZE_MAX) { ------------------ | Branch (4715:9): [True: 0, False: 1.17M] ------------------ 4716| 0| return XML_ERROR_NO_MEMORY; 4717| 0| } 4718| 1.17M| if (isXML && (len > xmlLen || uri[len] != xmlNamespace[len])) ------------------ | Branch (4718:9): [True: 185k, False: 993k] | Branch (4718:19): [True: 0, False: 185k] | Branch (4718:35): [True: 10.5k, False: 174k] ------------------ 4719| 10.5k| isXML = XML_FALSE; ------------------ | | 64| 10.5k|# define XML_FALSE ((XML_Bool)0) ------------------ 4720| | 4721| 1.17M| if (! mustBeXML && isXMLNS ------------------ | Branch (4721:9): [True: 973k, False: 205k] | Branch (4721:24): [True: 14.1k, False: 959k] ------------------ 4722| 14.1k| && (len > xmlnsLen || uri[len] != xmlnsNamespace[len])) ------------------ | Branch (4722:13): [True: 0, False: 14.1k] | Branch (4722:31): [True: 10.5k, False: 3.61k] ------------------ 4723| 10.5k| isXMLNS = XML_FALSE; ------------------ | | 64| 10.5k|# define XML_FALSE ((XML_Bool)0) ------------------ 4724| | 4725| | // NOTE: While Expat does not validate namespace URIs against RFC 3986 4726| | // today (and is not REQUIRED to do so with regard to the XML 1.0 4727| | // namespaces specification) we have to at least make sure, that 4728| | // the application on top of Expat (that is likely splitting expanded 4729| | // element names ("qualified names") of form 4730| | // "[uri sep] local [sep prefix] '\0'" back into 1, 2 or 3 pieces 4731| | // in its element handler code) cannot be confused by an attacker 4732| | // putting additional namespace separator characters into namespace 4733| | // declarations. That would be ambiguous and not to be expected. 4734| | // 4735| | // While the HTML API docs of function XML_ParserCreateNS have been 4736| | // advising against use of a namespace separator character that can 4737| | // appear in a URI for >20 years now, some widespread applications 4738| | // are using URI characters (':' (colon) in particular) for a 4739| | // namespace separator, in practice. To keep these applications 4740| | // functional, we only reject namespaces URIs containing the 4741| | // application-chosen namespace separator if the chosen separator 4742| | // is a non-URI character with regard to RFC 3986. 4743| 1.17M| if (parser->m_ns && (uri[len] == parser->m_namespaceSeparator) ------------------ | Branch (4743:9): [True: 1.17M, False: 0] | Branch (4743:25): [True: 1, False: 1.17M] ------------------ 4744| 1| && ! is_rfc3986_uri_char(uri[len])) { ------------------ | Branch (4744:12): [True: 1, False: 0] ------------------ 4745| 1| return XML_ERROR_SYNTAX; 4746| 1| } 4747| 1.17M| } 4748| 18.4k| isXML = isXML && len == xmlLen; ------------------ | Branch (4748:11): [True: 7.83k, False: 10.5k] | Branch (4748:20): [True: 4.76k, False: 3.07k] ------------------ 4749| 18.4k| isXMLNS = isXMLNS && len == xmlnsLen; ------------------ | Branch (4749:13): [True: 7.85k, False: 10.5k] | Branch (4749:24): [True: 1, False: 7.85k] ------------------ 4750| | 4751| 18.4k| if (mustBeXML != isXML) ------------------ | Branch (4751:7): [True: 17, False: 18.4k] ------------------ 4752| 17| return mustBeXML ? XML_ERROR_RESERVED_PREFIX_XML ------------------ | Branch (4752:12): [True: 17, False: 0] ------------------ 4753| 17| : XML_ERROR_RESERVED_NAMESPACE_URI; 4754| | 4755| 18.4k| if (isXMLNS) ------------------ | Branch (4755:7): [True: 1, False: 18.4k] ------------------ 4756| 1| return XML_ERROR_RESERVED_NAMESPACE_URI; 4757| | 4758| 18.4k| if (parser->m_namespaceSeparator) { ------------------ | Branch (4758:7): [True: 18.4k, False: 0] ------------------ 4759| | /* Detect and prevent integer overflow */ 4760| 18.4k| if (len == SIZE_MAX) { ------------------ | Branch (4760:9): [True: 0, False: 18.4k] ------------------ 4761| 0| return XML_ERROR_NO_MEMORY; 4762| 0| } 4763| 18.4k| len++; 4764| 18.4k| } 4765| 18.4k| if (parser->m_freeBindingList) { ------------------ | Branch (4765:7): [True: 1.87k, False: 16.5k] ------------------ 4766| 1.87k| b = parser->m_freeBindingList; 4767| 1.87k| if (len > b->uriAlloc) { ------------------ | Branch (4767:9): [True: 95, False: 1.78k] ------------------ 4768| | /* Detect and prevent integer overflow */ 4769| 95| if (len > SIZE_MAX - EXPAND_SPARE ------------------ | | 260| 190|#define EXPAND_SPARE 24 ------------------ | Branch (4769:11): [True: 0, False: 95] ------------------ 4770| 95| || len + EXPAND_SPARE > SIZE_MAX / sizeof(XML_Char)) { ------------------ | | 260| 95|#define EXPAND_SPARE 24 ------------------ | Branch (4770:14): [True: 0, False: 95] ------------------ 4771| 0| return XML_ERROR_NO_MEMORY; 4772| 0| } 4773| | 4774| 95| XML_Char *temp 4775| 95| = REALLOC(parser, b->uri, sizeof(XML_Char) * (len + EXPAND_SPARE)); ------------------ | | 836| 95|# define REALLOC(parser, p, s) (expat_realloc((parser), (p), (s), __LINE__)) ------------------ 4776| 95| if (temp == NULL) ------------------ | Branch (4776:11): [True: 0, False: 95] ------------------ 4777| 0| return XML_ERROR_NO_MEMORY; 4778| 95| b->uri = temp; 4779| 95| b->uriAlloc = len + EXPAND_SPARE; ------------------ | | 260| 95|#define EXPAND_SPARE 24 ------------------ 4780| 95| } 4781| 1.87k| parser->m_freeBindingList = b->nextTagBinding; 4782| 16.5k| } else { 4783| 16.5k| b = MALLOC(parser, sizeof(BINDING)); ------------------ | | 835| 16.5k|# define MALLOC(parser, s) (expat_malloc((parser), (s), __LINE__)) ------------------ 4784| 16.5k| if (! b) ------------------ | Branch (4784:9): [True: 0, False: 16.5k] ------------------ 4785| 0| return XML_ERROR_NO_MEMORY; 4786| | 4787| | /* Detect and prevent integer overflow */ 4788| 16.5k| if (len > SIZE_MAX - EXPAND_SPARE ------------------ | | 260| 33.0k|#define EXPAND_SPARE 24 ------------------ | Branch (4788:9): [True: 0, False: 16.5k] ------------------ 4789| 16.5k| || len + EXPAND_SPARE > SIZE_MAX / sizeof(XML_Char)) { ------------------ | | 260| 16.5k|#define EXPAND_SPARE 24 ------------------ | Branch (4789:12): [True: 0, False: 16.5k] ------------------ 4790| 0| FREE(parser, b); ------------------ | | 837| 0|# define FREE(parser, p) (expat_free((parser), (p), __LINE__)) ------------------ 4791| 0| return XML_ERROR_NO_MEMORY; 4792| 0| } 4793| | 4794| 16.5k| b->uri = MALLOC(parser, sizeof(XML_Char) * (len + EXPAND_SPARE)); ------------------ | | 835| 16.5k|# define MALLOC(parser, s) (expat_malloc((parser), (s), __LINE__)) ------------------ 4795| 16.5k| if (! b->uri) { ------------------ | Branch (4795:9): [True: 0, False: 16.5k] ------------------ 4796| 0| FREE(parser, b); ------------------ | | 837| 0|# define FREE(parser, p) (expat_free((parser), (p), __LINE__)) ------------------ 4797| 0| return XML_ERROR_NO_MEMORY; 4798| 0| } 4799| 16.5k| b->uriAlloc = len + EXPAND_SPARE; ------------------ | | 260| 16.5k|#define EXPAND_SPARE 24 ------------------ 4800| 16.5k| } 4801| 18.4k| b->uriLen = len; 4802| 18.4k| memcpy(b->uri, uri, len * sizeof(XML_Char)); 4803| 18.4k| if (parser->m_namespaceSeparator) ------------------ | Branch (4803:7): [True: 18.4k, False: 0] ------------------ 4804| 18.4k| b->uri[len - 1] = parser->m_namespaceSeparator; 4805| 18.4k| b->prefix = prefix; 4806| 18.4k| b->attId = attId; 4807| 18.4k| b->prevPrefixBinding = prefix->binding; 4808| | /* NULL binding when default namespace undeclared */ 4809| 18.4k| if (*uri == XML_T('\0') && prefix == &parser->m_dtd->defaultPrefix) ------------------ | | 220| 36.8k|# define XML_T(x) x ------------------ | Branch (4809:7): [True: 2.09k, False: 16.3k] | Branch (4809:30): [True: 2.09k, False: 0] ------------------ 4810| 2.09k| prefix->binding = NULL; 4811| 16.3k| else 4812| 16.3k| prefix->binding = b; 4813| 18.4k| b->nextTagBinding = *bindingsPtr; 4814| 18.4k| *bindingsPtr = b; 4815| | /* if attId == NULL then we are not starting a namespace scope */ 4816| 18.4k| if (attId && parser->m_startNamespaceDeclHandler) { ------------------ | Branch (4816:7): [True: 13.6k, False: 4.76k] | Branch (4816:16): [True: 0, False: 13.6k] ------------------ 4817| 0| beforeHandler(parser); 4818| 0| parser->m_startNamespaceDeclHandler(parser->m_handlerArg, prefix->name, 4819| 0| prefix->binding ? uri : 0); ------------------ | Branch (4819:41): [True: 0, False: 0] ------------------ 4820| 0| afterHandler(parser); 4821| 0| } 4822| 18.4k| return XML_ERROR_NONE; 4823| 18.4k|} xmlparse.c:is_rfc3986_uri_char: 4554| 1|is_rfc3986_uri_char(XML_Char candidate) { 4555| | // For the RFC 3986 ANBF grammar see 4556| | // https://datatracker.ietf.org/doc/html/rfc3986#appendix-A 4557| | 4558| 1| switch (candidate) { 4559| | // From rule "ALPHA" (uppercase half) 4560| 0| case 'A': ------------------ | Branch (4560:3): [True: 0, False: 1] ------------------ 4561| 0| case 'B': ------------------ | Branch (4561:3): [True: 0, False: 1] ------------------ 4562| 0| case 'C': ------------------ | Branch (4562:3): [True: 0, False: 1] ------------------ 4563| 0| case 'D': ------------------ | Branch (4563:3): [True: 0, False: 1] ------------------ 4564| 0| case 'E': ------------------ | Branch (4564:3): [True: 0, False: 1] ------------------ 4565| 0| case 'F': ------------------ | Branch (4565:3): [True: 0, False: 1] ------------------ 4566| 0| case 'G': ------------------ | Branch (4566:3): [True: 0, False: 1] ------------------ 4567| 0| case 'H': ------------------ | Branch (4567:3): [True: 0, False: 1] ------------------ 4568| 0| case 'I': ------------------ | Branch (4568:3): [True: 0, False: 1] ------------------ 4569| 0| case 'J': ------------------ | Branch (4569:3): [True: 0, False: 1] ------------------ 4570| 0| case 'K': ------------------ | Branch (4570:3): [True: 0, False: 1] ------------------ 4571| 0| case 'L': ------------------ | Branch (4571:3): [True: 0, False: 1] ------------------ 4572| 0| case 'M': ------------------ | Branch (4572:3): [True: 0, False: 1] ------------------ 4573| 0| case 'N': ------------------ | Branch (4573:3): [True: 0, False: 1] ------------------ 4574| 0| case 'O': ------------------ | Branch (4574:3): [True: 0, False: 1] ------------------ 4575| 0| case 'P': ------------------ | Branch (4575:3): [True: 0, False: 1] ------------------ 4576| 0| case 'Q': ------------------ | Branch (4576:3): [True: 0, False: 1] ------------------ 4577| 0| case 'R': ------------------ | Branch (4577:3): [True: 0, False: 1] ------------------ 4578| 0| case 'S': ------------------ | Branch (4578:3): [True: 0, False: 1] ------------------ 4579| 0| case 'T': ------------------ | Branch (4579:3): [True: 0, False: 1] ------------------ 4580| 0| case 'U': ------------------ | Branch (4580:3): [True: 0, False: 1] ------------------ 4581| 0| case 'V': ------------------ | Branch (4581:3): [True: 0, False: 1] ------------------ 4582| 0| case 'W': ------------------ | Branch (4582:3): [True: 0, False: 1] ------------------ 4583| 0| case 'X': ------------------ | Branch (4583:3): [True: 0, False: 1] ------------------ 4584| 0| case 'Y': ------------------ | Branch (4584:3): [True: 0, False: 1] ------------------ 4585| 0| case 'Z': ------------------ | Branch (4585:3): [True: 0, False: 1] ------------------ 4586| | 4587| | // From rule "ALPHA" (lowercase half) 4588| 0| case 'a': ------------------ | Branch (4588:3): [True: 0, False: 1] ------------------ 4589| 0| case 'b': ------------------ | Branch (4589:3): [True: 0, False: 1] ------------------ 4590| 0| case 'c': ------------------ | Branch (4590:3): [True: 0, False: 1] ------------------ 4591| 0| case 'd': ------------------ | Branch (4591:3): [True: 0, False: 1] ------------------ 4592| 0| case 'e': ------------------ | Branch (4592:3): [True: 0, False: 1] ------------------ 4593| 0| case 'f': ------------------ | Branch (4593:3): [True: 0, False: 1] ------------------ 4594| 0| case 'g': ------------------ | Branch (4594:3): [True: 0, False: 1] ------------------ 4595| 0| case 'h': ------------------ | Branch (4595:3): [True: 0, False: 1] ------------------ 4596| 0| case 'i': ------------------ | Branch (4596:3): [True: 0, False: 1] ------------------ 4597| 0| case 'j': ------------------ | Branch (4597:3): [True: 0, False: 1] ------------------ 4598| 0| case 'k': ------------------ | Branch (4598:3): [True: 0, False: 1] ------------------ 4599| 0| case 'l': ------------------ | Branch (4599:3): [True: 0, False: 1] ------------------ 4600| 0| case 'm': ------------------ | Branch (4600:3): [True: 0, False: 1] ------------------ 4601| 0| case 'n': ------------------ | Branch (4601:3): [True: 0, False: 1] ------------------ 4602| 0| case 'o': ------------------ | Branch (4602:3): [True: 0, False: 1] ------------------ 4603| 0| case 'p': ------------------ | Branch (4603:3): [True: 0, False: 1] ------------------ 4604| 0| case 'q': ------------------ | Branch (4604:3): [True: 0, False: 1] ------------------ 4605| 0| case 'r': ------------------ | Branch (4605:3): [True: 0, False: 1] ------------------ 4606| 0| case 's': ------------------ | Branch (4606:3): [True: 0, False: 1] ------------------ 4607| 0| case 't': ------------------ | Branch (4607:3): [True: 0, False: 1] ------------------ 4608| 0| case 'u': ------------------ | Branch (4608:3): [True: 0, False: 1] ------------------ 4609| 0| case 'v': ------------------ | Branch (4609:3): [True: 0, False: 1] ------------------ 4610| 0| case 'w': ------------------ | Branch (4610:3): [True: 0, False: 1] ------------------ 4611| 0| case 'x': ------------------ | Branch (4611:3): [True: 0, False: 1] ------------------ 4612| 0| case 'y': ------------------ | Branch (4612:3): [True: 0, False: 1] ------------------ 4613| 0| case 'z': ------------------ | Branch (4613:3): [True: 0, False: 1] ------------------ 4614| | 4615| | // From rule "DIGIT" 4616| 0| case '0': ------------------ | Branch (4616:3): [True: 0, False: 1] ------------------ 4617| 0| case '1': ------------------ | Branch (4617:3): [True: 0, False: 1] ------------------ 4618| 0| case '2': ------------------ | Branch (4618:3): [True: 0, False: 1] ------------------ 4619| 0| case '3': ------------------ | Branch (4619:3): [True: 0, False: 1] ------------------ 4620| 0| case '4': ------------------ | Branch (4620:3): [True: 0, False: 1] ------------------ 4621| 0| case '5': ------------------ | Branch (4621:3): [True: 0, False: 1] ------------------ 4622| 0| case '6': ------------------ | Branch (4622:3): [True: 0, False: 1] ------------------ 4623| 0| case '7': ------------------ | Branch (4623:3): [True: 0, False: 1] ------------------ 4624| 0| case '8': ------------------ | Branch (4624:3): [True: 0, False: 1] ------------------ 4625| 0| case '9': ------------------ | Branch (4625:3): [True: 0, False: 1] ------------------ 4626| | 4627| | // From rule "pct-encoded" 4628| 0| case '%': ------------------ | Branch (4628:3): [True: 0, False: 1] ------------------ 4629| | 4630| | // From rule "unreserved" 4631| 0| case '-': ------------------ | Branch (4631:3): [True: 0, False: 1] ------------------ 4632| 0| case '.': ------------------ | Branch (4632:3): [True: 0, False: 1] ------------------ 4633| 0| case '_': ------------------ | Branch (4633:3): [True: 0, False: 1] ------------------ 4634| 0| case '~': ------------------ | Branch (4634:3): [True: 0, False: 1] ------------------ 4635| | 4636| | // From rule "gen-delims" 4637| 0| case ':': ------------------ | Branch (4637:3): [True: 0, False: 1] ------------------ 4638| 0| case '/': ------------------ | Branch (4638:3): [True: 0, False: 1] ------------------ 4639| 0| case '?': ------------------ | Branch (4639:3): [True: 0, False: 1] ------------------ 4640| 0| case '#': ------------------ | Branch (4640:3): [True: 0, False: 1] ------------------ 4641| 0| case '[': ------------------ | Branch (4641:3): [True: 0, False: 1] ------------------ 4642| 0| case ']': ------------------ | Branch (4642:3): [True: 0, False: 1] ------------------ 4643| 0| case '@': ------------------ | Branch (4643:3): [True: 0, False: 1] ------------------ 4644| | 4645| | // From rule "sub-delims" 4646| 0| case '!': ------------------ | Branch (4646:3): [True: 0, False: 1] ------------------ 4647| 0| case '$': ------------------ | Branch (4647:3): [True: 0, False: 1] ------------------ 4648| 0| case '&': ------------------ | Branch (4648:3): [True: 0, False: 1] ------------------ 4649| 0| case '\'': ------------------ | Branch (4649:3): [True: 0, False: 1] ------------------ 4650| 0| case '(': ------------------ | Branch (4650:3): [True: 0, False: 1] ------------------ 4651| 0| case ')': ------------------ | Branch (4651:3): [True: 0, False: 1] ------------------ 4652| 0| case '*': ------------------ | Branch (4652:3): [True: 0, False: 1] ------------------ 4653| 0| case '+': ------------------ | Branch (4653:3): [True: 0, False: 1] ------------------ 4654| 0| case ',': ------------------ | Branch (4654:3): [True: 0, False: 1] ------------------ 4655| 0| case ';': ------------------ | Branch (4655:3): [True: 0, False: 1] ------------------ 4656| 0| case '=': ------------------ | Branch (4656:3): [True: 0, False: 1] ------------------ 4657| 0| return XML_TRUE; ------------------ | | 63| 0|# define XML_TRUE ((XML_Bool)1) ------------------ 4658| | 4659| 1| default: ------------------ | Branch (4659:3): [True: 1, False: 0] ------------------ 4660| 1| return XML_FALSE; ------------------ | | 64| 1|# define XML_FALSE ((XML_Bool)0) ------------------ 4661| 1| } 4662| 1|} xmlparse.c:freeBindings: 4103| 26.6k|freeBindings(XML_Parser parser, BINDING *bindings) { 4104| 28.1k| while (bindings) { ------------------ | Branch (4104:10): [True: 1.48k, False: 26.6k] ------------------ 4105| 1.48k| BINDING *b = bindings; 4106| | 4107| | /* m_startNamespaceDeclHandler will have been called for this 4108| | * binding in addBindings(), so call the end handler now. 4109| | */ 4110| 1.48k| if (parser->m_endNamespaceDeclHandler) { ------------------ | Branch (4110:9): [True: 0, False: 1.48k] ------------------ 4111| 0| beforeHandler(parser); 4112| 0| parser->m_endNamespaceDeclHandler(parser->m_handlerArg, b->prefix->name); 4113| 0| afterHandler(parser); 4114| 0| } 4115| | 4116| 1.48k| bindings = bindings->nextTagBinding; 4117| 1.48k| b->nextTagBinding = parser->m_freeBindingList; 4118| 1.48k| parser->m_freeBindingList = b; 4119| 1.48k| b->prefix->binding = b->prevPrefixBinding; 4120| 1.48k| } 4121| 26.6k|} xmlparse.c:epilogProcessor: 6613| 821| const char **nextPtr) { 6614| 821| parser->m_processor = epilogProcessor; 6615| 821| parser->m_eventPtr = s; 6616| 1.88k| for (;;) { 6617| 1.88k| const char *next = NULL; 6618| 1.88k| int tok = XmlPrologTok(parser->m_encoding, s, end, &next); ------------------ | | 226| 1.88k| XmlTok(enc, XML_PROLOG_STATE, ptr, end, nextTokPtr) | | ------------------ | | | | 223| 1.88k| (((enc)->scanners[state])(enc, ptr, end, nextTokPtr)) | | ------------------ ------------------ 6619| 1.88k|#if XML_GE == 1 6620| 1.88k| if (! accountingDiffTolerated(parser, tok, s, next, __LINE__, ------------------ | Branch (6620:9): [True: 0, False: 1.88k] ------------------ 6621| 1.88k| XML_ACCOUNT_DIRECT)) { 6622| 0| accountingOnAbort(parser); 6623| 0| return XML_ERROR_AMPLIFICATION_LIMIT_BREACH; 6624| 0| } 6625| 1.88k|#endif 6626| 1.88k| parser->m_eventEndPtr = next; 6627| 1.88k| switch (tok) { 6628| | /* report partial linebreak - it might be the last token */ 6629| 1| case -XML_TOK_PROLOG_S: ------------------ | | 82| 1|# define XML_TOK_PROLOG_S 15 ------------------ | Branch (6629:5): [True: 1, False: 1.88k] ------------------ 6630| 1| if (parser->m_defaultHandler) { ------------------ | Branch (6630:11): [True: 0, False: 1] ------------------ 6631| 0| reportDefault(parser, parser->m_encoding, s, next); 6632| 0| if (parser->m_parsingStatus.parsing == XML_FINISHED) ------------------ | Branch (6632:13): [True: 0, False: 0] ------------------ 6633| 0| return XML_ERROR_ABORTED; 6634| 0| } 6635| 1| *nextPtr = next; 6636| 1| return XML_ERROR_NONE; 6637| 250| case XML_TOK_NONE: ------------------ | | 51| 250|# define XML_TOK_NONE -4 /* The string to be scanned is empty */ ------------------ | Branch (6637:5): [True: 250, False: 1.63k] ------------------ 6638| 250| *nextPtr = s; 6639| 250| return XML_ERROR_NONE; 6640| 336| case XML_TOK_PROLOG_S: ------------------ | | 82| 336|# define XML_TOK_PROLOG_S 15 ------------------ | Branch (6640:5): [True: 336, False: 1.54k] ------------------ 6641| 336| if (parser->m_defaultHandler) ------------------ | Branch (6641:11): [True: 0, False: 336] ------------------ 6642| 0| reportDefault(parser, parser->m_encoding, s, next); 6643| 336| break; 6644| 531| case XML_TOK_PI: ------------------ | | 76| 531|# define XML_TOK_PI 11 /* processing instruction */ ------------------ | Branch (6644:5): [True: 531, False: 1.35k] ------------------ 6645| 531| if (! reportProcessingInstruction(parser, parser->m_encoding, s, next)) ------------------ | Branch (6645:11): [True: 0, False: 531] ------------------ 6646| 0| return XML_ERROR_NO_MEMORY; 6647| 531| break; 6648| 531| case XML_TOK_COMMENT: ------------------ | | 78| 195|# define XML_TOK_COMMENT 13 ------------------ | Branch (6648:5): [True: 195, False: 1.68k] ------------------ 6649| 195| if (! reportComment(parser, parser->m_encoding, s, next)) ------------------ | Branch (6649:11): [True: 0, False: 195] ------------------ 6650| 0| return XML_ERROR_NO_MEMORY; 6651| 195| break; 6652| 404| case XML_TOK_INVALID: ------------------ | | 57| 404|# define XML_TOK_INVALID 0 ------------------ | Branch (6652:5): [True: 404, False: 1.47k] ------------------ 6653| 404| parser->m_eventPtr = next; 6654| 404| return XML_ERROR_INVALID_TOKEN; 6655| 47| case XML_TOK_PARTIAL: ------------------ | | 56| 47|# define XML_TOK_PARTIAL -1 /* only part of a token */ ------------------ | Branch (6655:5): [True: 47, False: 1.83k] ------------------ 6656| 47| if (! parser->m_parsingStatus.finalBuffer) { ------------------ | Branch (6656:11): [True: 0, False: 47] ------------------ 6657| 0| *nextPtr = s; 6658| 0| return XML_ERROR_NONE; 6659| 0| } 6660| 47| return XML_ERROR_UNCLOSED_TOKEN; 6661| 5| case XML_TOK_PARTIAL_CHAR: ------------------ | | 55| 5|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ ------------------ | Branch (6661:5): [True: 5, False: 1.87k] ------------------ 6662| 5| if (! parser->m_parsingStatus.finalBuffer) { ------------------ | Branch (6662:11): [True: 0, False: 5] ------------------ 6663| 0| *nextPtr = s; 6664| 0| return XML_ERROR_NONE; 6665| 0| } 6666| 5| return XML_ERROR_PARTIAL_CHAR; 6667| 114| default: ------------------ | Branch (6667:5): [True: 114, False: 1.76k] ------------------ 6668| 114| return XML_ERROR_JUNK_AFTER_DOC_ELEMENT; 6669| 1.88k| } 6670| 1.06k| switch (parser->m_parsingStatus.parsing) { 6671| 0| case XML_SUSPENDED: ------------------ | Branch (6671:5): [True: 0, False: 1.06k] ------------------ 6672| 0| parser->m_eventPtr = next; 6673| 0| *nextPtr = next; 6674| 0| return XML_ERROR_NONE; 6675| 0| case XML_FINISHED: ------------------ | Branch (6675:5): [True: 0, False: 1.06k] ------------------ 6676| 0| parser->m_eventPtr = next; 6677| 0| return XML_ERROR_ABORTED; 6678| 1.06k| case XML_PARSING: ------------------ | Branch (6678:5): [True: 1.06k, False: 0] ------------------ 6679| 1.06k| if (parser->m_reenter) { ------------------ | Branch (6679:11): [True: 0, False: 1.06k] ------------------ 6680| 0| return XML_ERROR_UNEXPECTED_STATE; // LCOV_EXCL_LINE 6681| 0| } 6682| 1.06k| EXPAT_FALLTHROUGH; ------------------ | | 47| 1.06k|# define EXPAT_FALLTHROUGH __attribute__((fallthrough)) ------------------ 6683| 1.06k| default:; ------------------ | Branch (6683:5): [True: 0, False: 1.06k] ------------------ 6684| 1.06k| parser->m_eventPtr = s = next; 6685| 1.06k| } 6686| 1.06k| } 6687| 821|} xmlparse.c:doCdataSection: 4854| 1.38k| enum XML_Account account) { 4855| 1.38k| const char *s = *startPtr; 4856| 1.38k| const char **eventPP; 4857| 1.38k| const char **eventEndPP; 4858| 1.38k| if (enc == parser->m_encoding) { ------------------ | Branch (4858:7): [True: 557, False: 832] ------------------ 4859| 557| eventPP = &parser->m_eventPtr; 4860| 557| *eventPP = s; 4861| 557| eventEndPP = &parser->m_eventEndPtr; 4862| 832| } else { 4863| 832| eventPP = &(parser->m_openInternalEntities->internalEventPtr); 4864| 832| eventEndPP = &(parser->m_openInternalEntities->internalEventEndPtr); 4865| 832| } 4866| 1.38k| *eventPP = s; 4867| 1.38k| *startPtr = NULL; 4868| | 4869| 9.43k| for (;;) { 4870| 9.43k| const char *next = s; /* in case of XML_TOK_NONE or XML_TOK_PARTIAL */ 4871| 9.43k| int tok = XmlCdataSectionTok(enc, s, end, &next); ------------------ | | 232| 9.43k| XmlTok(enc, XML_CDATA_SECTION_STATE, ptr, end, nextTokPtr) | | ------------------ | | | | 223| 9.43k| (((enc)->scanners[state])(enc, ptr, end, nextTokPtr)) | | ------------------ ------------------ 4872| 9.43k|#if XML_GE == 1 4873| 9.43k| if (! accountingDiffTolerated(parser, tok, s, next, __LINE__, account)) { ------------------ | Branch (4873:9): [True: 0, False: 9.43k] ------------------ 4874| 0| accountingOnAbort(parser); 4875| 0| return XML_ERROR_AMPLIFICATION_LIMIT_BREACH; 4876| 0| } 4877| |#else 4878| | UNUSED_P(account); 4879| |#endif 4880| 9.43k| *eventEndPP = next; 4881| 9.43k| switch (tok) { 4882| 991| case XML_TOK_CDATA_SECT_CLOSE: ------------------ | | 113| 991|# define XML_TOK_CDATA_SECT_CLOSE 40 ------------------ | Branch (4882:5): [True: 991, False: 8.43k] ------------------ 4883| 991| if (parser->m_endCdataSectionHandler) { ------------------ | Branch (4883:11): [True: 0, False: 991] ------------------ 4884| 0| beforeHandler(parser); 4885| 0| parser->m_endCdataSectionHandler(parser->m_handlerArg); 4886| 0| afterHandler(parser); 4887| 0| } 4888| | /* BEGIN disabled code */ 4889| | /* see comment under XML_TOK_CDATA_SECT_OPEN */ 4890| 991| else if ((0) && parser->m_characterDataHandler) { ------------------ | Branch (4890:16): [Folded, False: 991] | Branch (4890:23): [True: 0, False: 0] ------------------ 4891| 0| beforeHandler(parser); 4892| 0| parser->m_characterDataHandler(parser->m_handlerArg, parser->m_dataBuf, 4893| 0| 0); 4894| 0| afterHandler(parser); 4895| | /* END disabled code */ 4896| 991| } else if (parser->m_defaultHandler) ------------------ | Branch (4896:18): [True: 0, False: 991] ------------------ 4897| 0| reportDefault(parser, enc, s, next); 4898| 991| *startPtr = next; 4899| 991| *nextPtr = next; 4900| 991| if (parser->m_parsingStatus.parsing == XML_FINISHED) ------------------ | Branch (4900:11): [True: 0, False: 991] ------------------ 4901| 0| return XML_ERROR_ABORTED; 4902| 991| else 4903| 991| return XML_ERROR_NONE; 4904| 2.83k| case XML_TOK_DATA_NEWLINE: ------------------ | | 68| 2.83k|# define XML_TOK_DATA_NEWLINE 7 ------------------ | Branch (4904:5): [True: 2.83k, False: 6.59k] ------------------ 4905| 2.83k| if (parser->m_characterDataHandler) { ------------------ | Branch (4905:11): [True: 0, False: 2.83k] ------------------ 4906| 0| XML_Char c = 0xA; 4907| 0| beforeHandler(parser); 4908| 0| parser->m_characterDataHandler(parser->m_handlerArg, &c, 1); 4909| 0| afterHandler(parser); 4910| 2.83k| } else if (parser->m_defaultHandler) ------------------ | Branch (4910:18): [True: 0, False: 2.83k] ------------------ 4911| 0| reportDefault(parser, enc, s, next); 4912| 2.83k| break; 4913| 5.20k| case XML_TOK_DATA_CHARS: { ------------------ | | 67| 5.20k|# define XML_TOK_DATA_CHARS 6 ------------------ | Branch (4913:5): [True: 5.20k, False: 4.22k] ------------------ 4914| 5.20k| XML_CharacterDataHandler charDataHandler = parser->m_characterDataHandler; 4915| 5.20k| if (charDataHandler) { ------------------ | Branch (4915:11): [True: 0, False: 5.20k] ------------------ 4916| 0| if (MUST_CONVERT(enc, s)) { ------------------ | | 194| 0|# define MUST_CONVERT(enc, s) (! (enc)->isUtf8) | | ------------------ | | | Branch (194:32): [True: 0, False: 0] | | ------------------ ------------------ 4917| 0| for (;;) { 4918| 0| ICHAR *dataPtr = (ICHAR *)parser->m_dataBuf; 4919| 0| const enum XML_Convert_Result convert_res = XmlConvert( ------------------ | | 190| 0|# define XmlConvert XmlUtf8Convert | | ------------------ | | | | 275| 0| (((enc)->utf8Convert)(enc, fromP, fromLim, toP, toLim)) | | ------------------ ------------------ 4920| 0| enc, &s, next, &dataPtr, (ICHAR *)parser->m_dataBufEnd); 4921| 0| *eventEndPP = next; 4922| 0| beforeHandler(parser); 4923| 0| charDataHandler(parser->m_handlerArg, parser->m_dataBuf, 4924| 0| (int)(dataPtr - (ICHAR *)parser->m_dataBuf)); 4925| 0| afterHandler(parser); 4926| 0| if ((convert_res == XML_CONVERT_COMPLETED) ------------------ | Branch (4926:17): [True: 0, False: 0] ------------------ 4927| 0| || (convert_res == XML_CONVERT_INPUT_INCOMPLETE)) ------------------ | Branch (4927:20): [True: 0, False: 0] ------------------ 4928| 0| break; 4929| 0| *eventPP = s; 4930| 0| } 4931| 0| } else { 4932| 0| beforeHandler(parser); 4933| 0| charDataHandler(parser->m_handlerArg, (const XML_Char *)s, 4934| 0| (int)((const XML_Char *)next - (const XML_Char *)s)); 4935| 0| afterHandler(parser); 4936| 0| } 4937| 5.20k| } else if (parser->m_defaultHandler) ------------------ | Branch (4937:18): [True: 0, False: 5.20k] ------------------ 4938| 0| reportDefault(parser, enc, s, next); 4939| 5.20k| } break; 4940| 84| case XML_TOK_INVALID: ------------------ | | 57| 84|# define XML_TOK_INVALID 0 ------------------ | Branch (4940:5): [True: 84, False: 9.34k] ------------------ 4941| 84| *eventPP = next; 4942| 84| return XML_ERROR_INVALID_TOKEN; 4943| 5| case XML_TOK_PARTIAL_CHAR: ------------------ | | 55| 5|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ ------------------ | Branch (4943:5): [True: 5, False: 9.42k] ------------------ 4944| 5| if (haveMore) { ------------------ | Branch (4944:11): [True: 0, False: 5] ------------------ 4945| 0| *nextPtr = s; 4946| 0| return XML_ERROR_NONE; 4947| 0| } 4948| 5| return XML_ERROR_PARTIAL_CHAR; 4949| 71| case XML_TOK_PARTIAL: ------------------ | | 56| 71|# define XML_TOK_PARTIAL -1 /* only part of a token */ ------------------ | Branch (4949:5): [True: 71, False: 9.35k] ------------------ 4950| 309| case XML_TOK_NONE: ------------------ | | 51| 309|# define XML_TOK_NONE -4 /* The string to be scanned is empty */ ------------------ | Branch (4950:5): [True: 238, False: 9.19k] ------------------ 4951| 309| if (haveMore) { ------------------ | Branch (4951:11): [True: 0, False: 309] ------------------ 4952| 0| *nextPtr = s; 4953| 0| return XML_ERROR_NONE; 4954| 0| } 4955| 309| return XML_ERROR_UNCLOSED_CDATA_SECTION; 4956| 0| default: ------------------ | Branch (4956:5): [True: 0, False: 9.43k] ------------------ 4957| | /* Every token returned by XmlCdataSectionTok() has its own 4958| | * explicit case, so this default case will never be executed. 4959| | * We retain it as a safety net and exclude it from the coverage 4960| | * statistics. 4961| | * 4962| | * LCOV_EXCL_START 4963| | */ 4964| 0| *eventPP = next; 4965| 0| return XML_ERROR_UNEXPECTED_STATE; 4966| | /* LCOV_EXCL_STOP */ 4967| 9.43k| } 4968| | 4969| 8.04k| switch (parser->m_parsingStatus.parsing) { 4970| 0| case XML_SUSPENDED: ------------------ | Branch (4970:5): [True: 0, False: 8.04k] ------------------ 4971| 0| *eventPP = next; 4972| 0| *nextPtr = next; 4973| 0| return XML_ERROR_NONE; 4974| 0| case XML_FINISHED: ------------------ | Branch (4974:5): [True: 0, False: 8.04k] ------------------ 4975| 0| *eventPP = next; 4976| 0| return XML_ERROR_ABORTED; 4977| 8.04k| case XML_PARSING: ------------------ | Branch (4977:5): [True: 8.04k, False: 0] ------------------ 4978| 8.04k| if (parser->m_reenter) { ------------------ | Branch (4978:11): [True: 0, False: 8.04k] ------------------ 4979| 0| return XML_ERROR_UNEXPECTED_STATE; // LCOV_EXCL_LINE 4980| 0| } 4981| 8.04k| EXPAT_FALLTHROUGH; ------------------ | | 47| 8.04k|# define EXPAT_FALLTHROUGH __attribute__((fallthrough)) ------------------ 4982| 8.04k| default:; ------------------ | Branch (4982:5): [True: 0, False: 8.04k] ------------------ 4983| 8.04k| *eventPP = s = next; 4984| 8.04k| } 4985| 8.04k| } 4986| | /* not reached */ 4987| 1.38k|} xmlparse.c:storeRawNames: 3395| 9.46k|storeRawNames(XML_Parser parser) { 3396| 9.46k| TAG *tag = parser->m_tagStack; 3397| 12.5k| while (tag) { ------------------ | Branch (3397:10): [True: 11.6k, False: 891] ------------------ 3398| 11.6k| size_t bufSize; 3399| 11.6k| size_t nameLen = sizeof(XML_Char) * (tag->name.strLen + 1); 3400| 11.6k| size_t rawNameLen; 3401| 11.6k| char *rawNameBuf = tag->buf.raw + nameLen; 3402| | /* Stop if already stored. Since m_tagStack is a stack, we can stop 3403| | at the first entry that has already been copied; everything 3404| | below it in the stack is already been accounted for in a 3405| | previous call to this function. 3406| | */ 3407| 11.6k| if (tag->rawName == rawNameBuf) ------------------ | Branch (3407:9): [True: 8.56k, False: 3.09k] ------------------ 3408| 8.56k| break; 3409| | /* For reuse purposes we need to ensure that the 3410| | size of tag->buf is a multiple of sizeof(XML_Char). 3411| | */ 3412| 3.09k| rawNameLen = ROUND_UP(tag->rawNameLength, sizeof(XML_Char)); ------------------ | | 226| 3.09k|#define ROUND_UP(n, sz) (((n) + ((sz) - 1)) & ~((sz) - 1)) ------------------ 3413| | /* Detect and prevent integer overflow. */ 3414| 3.09k| if (rawNameLen > SIZE_MAX - nameLen) ------------------ | Branch (3414:9): [True: 0, False: 3.09k] ------------------ 3415| 0| return XML_FALSE; ------------------ | | 64| 0|# define XML_FALSE ((XML_Bool)0) ------------------ 3416| 3.09k| bufSize = nameLen + rawNameLen; 3417| 3.09k| if (bufSize > (size_t)(tag->bufEnd - tag->buf.raw)) { ------------------ | Branch (3417:9): [True: 143, False: 2.95k] ------------------ 3418| 143| char *temp = REALLOC(parser, tag->buf.raw, bufSize); ------------------ | | 836| 143|# define REALLOC(parser, p, s) (expat_realloc((parser), (p), (s), __LINE__)) ------------------ 3419| 143| if (temp == NULL) ------------------ | Branch (3419:11): [True: 0, False: 143] ------------------ 3420| 0| return XML_FALSE; ------------------ | | 64| 0|# define XML_FALSE ((XML_Bool)0) ------------------ 3421| | /* if tag->name.str points to tag->buf.str (only when namespace 3422| | processing is off) then we have to update it 3423| | */ 3424| 143| if (tag->name.str == tag->buf.str) ------------------ | Branch (3424:11): [True: 72, False: 71] ------------------ 3425| 72| tag->name.str = (XML_Char *)temp; 3426| | /* if tag->name.localPart is set (when namespace processing is on) 3427| | then update it as well, since it will always point into tag->buf 3428| | */ 3429| 143| if (tag->name.localPart) ------------------ | Branch (3429:11): [True: 71, False: 72] ------------------ 3430| 71| tag->name.localPart 3431| 71| = (XML_Char *)temp + (tag->name.localPart - tag->buf.str); 3432| 143| tag->buf.raw = temp; 3433| 143| tag->bufEnd = temp + bufSize; 3434| 143| rawNameBuf = temp + nameLen; 3435| 143| } 3436| 3.09k| memcpy(rawNameBuf, tag->rawName, tag->rawNameLength); 3437| 3.09k| tag->rawName = rawNameBuf; 3438| 3.09k| tag = tag->parent; 3439| 3.09k| } 3440| 9.46k| return XML_TRUE; ------------------ | | 63| 9.46k|# define XML_TRUE ((XML_Bool)1) ------------------ 3441| 9.46k|} xmlparse.c:getElementType: 8888| 1.52k| const char *end) { 8889| 1.52k| DTD *const dtd = parser->m_dtd; /* save one level of indirection */ 8890| 1.52k| const XML_Char *name = poolStoreString(&dtd->pool, enc, ptr, end); 8891| 1.52k| ELEMENT_TYPE *ret; 8892| | 8893| 1.52k| if (! name) ------------------ | Branch (8893:7): [True: 0, False: 1.52k] ------------------ 8894| 0| return NULL; 8895| 1.52k| ret = (ELEMENT_TYPE *)lookup(parser, &dtd->elementTypes, name, 8896| 1.52k| sizeof(ELEMENT_TYPE)); 8897| 1.52k| if (! ret) ------------------ | Branch (8897:7): [True: 0, False: 1.52k] ------------------ 8898| 0| return NULL; 8899| 1.52k| if (! ret->defaultAttForName.parser) ------------------ | Branch (8899:7): [True: 1.20k, False: 325] ------------------ 8900| 1.20k| hashTableInit(&(ret->defaultAttForName), getRootParserOf(parser, NULL)); 8901| 1.52k| if (ret->name != name) ------------------ | Branch (8901:7): [True: 325, False: 1.20k] ------------------ 8902| 325| poolDiscard(&dtd->pool); ------------------ | | 675| 325|#define poolDiscard(pool) ((pool)->ptr = (pool)->start) ------------------ 8903| 1.20k| else { 8904| 1.20k| poolFinish(&dtd->pool); ------------------ | | 676| 1.20k|#define poolFinish(pool) ((pool)->start = (pool)->ptr) ------------------ 8905| 1.20k| if (! setElementTypePrefix(parser, ret)) ------------------ | Branch (8905:9): [True: 0, False: 1.20k] ------------------ 8906| 0| return NULL; 8907| 1.20k| } 8908| 1.52k| return ret; 8909| 1.52k|} xmlparse.c:getAttributeId: 7622| 37.6k| const char *end) { 7623| 37.6k| DTD *const dtd = parser->m_dtd; /* save one level of indirection */ 7624| 37.6k| ATTRIBUTE_ID *id; 7625| 37.6k| const XML_Char *name; 7626| 37.6k| if (! poolAppendChar(&dtd->pool, XML_T('\0'))) ------------------ | | 220| 37.6k|# define XML_T(x) x ------------------ | Branch (7626:7): [True: 0, False: 37.6k] ------------------ 7627| 0| return NULL; 7628| 37.6k| name = poolStoreString(&dtd->pool, enc, start, end); 7629| 37.6k| if (! name) ------------------ | Branch (7629:7): [True: 0, False: 37.6k] ------------------ 7630| 0| return NULL; 7631| | /* skip quotation mark - its storage will be reused (like in name[-1]) */ 7632| 37.6k| ++name; 7633| 37.6k| id = (ATTRIBUTE_ID *)lookup(parser, &dtd->attributeIds, name, 7634| 37.6k| sizeof(ATTRIBUTE_ID)); 7635| 37.6k| if (! id) ------------------ | Branch (7635:7): [True: 0, False: 37.6k] ------------------ 7636| 0| return NULL; 7637| 37.6k| if (id->name != name) ------------------ | Branch (7637:7): [True: 29.9k, False: 7.65k] ------------------ 7638| 29.9k| poolDiscard(&dtd->pool); ------------------ | | 675| 29.9k|#define poolDiscard(pool) ((pool)->ptr = (pool)->start) ------------------ 7639| 7.65k| else { 7640| 7.65k| poolFinish(&dtd->pool); ------------------ | | 676| 7.65k|#define poolFinish(pool) ((pool)->start = (pool)->ptr) ------------------ 7641| 7.65k| if (! parser->m_ns) ------------------ | Branch (7641:9): [True: 3.83k, False: 3.81k] ------------------ 7642| 3.83k| ; 7643| 3.81k| else if (name[0] == XML_T(ASCII_x) && name[1] == XML_T(ASCII_m) ------------------ | | 220| 7.63k|# define XML_T(x) x ------------------ else if (name[0] == XML_T(ASCII_x) && name[1] == XML_T(ASCII_m) ------------------ | | 220| 6.10k|# define XML_T(x) x ------------------ | Branch (7643:14): [True: 2.28k, False: 1.53k] | Branch (7643:43): [True: 1.23k, False: 1.05k] ------------------ 7644| 1.23k| && name[2] == XML_T(ASCII_l) && name[3] == XML_T(ASCII_n) ------------------ | | 220| 5.04k|# define XML_T(x) x ------------------ && name[2] == XML_T(ASCII_l) && name[3] == XML_T(ASCII_n) ------------------ | | 220| 5.00k|# define XML_T(x) x ------------------ | Branch (7644:17): [True: 1.18k, False: 47] | Branch (7644:46): [True: 840, False: 347] ------------------ 7645| 840| && name[4] == XML_T(ASCII_s) ------------------ | | 220| 4.65k|# define XML_T(x) x ------------------ | Branch (7645:17): [True: 815, False: 25] ------------------ 7646| 815| && (name[5] == XML_T('\0') || name[5] == XML_T(ASCII_COLON))) { ------------------ | | 220| 1.63k|# define XML_T(x) x ------------------ && (name[5] == XML_T('\0') || name[5] == XML_T(ASCII_COLON))) { ------------------ | | 220| 497|# define XML_T(x) x ------------------ | Branch (7646:18): [True: 318, False: 497] | Branch (7646:44): [True: 471, False: 26] ------------------ 7647| 789| if (name[5] == XML_T('\0')) ------------------ | | 220| 789|# define XML_T(x) x ------------------ | Branch (7647:11): [True: 318, False: 471] ------------------ 7648| 318| id->prefix = &dtd->defaultPrefix; 7649| 471| else 7650| 471| id->prefix = (PREFIX *)lookup(parser, &dtd->prefixes, name + 6, 7651| 471| sizeof(PREFIX)); 7652| 789| id->xmlns = true; 7653| 3.02k| } else { 7654| 3.02k| int i; 7655| 11.0k| for (i = 0; name[i]; i++) { ------------------ | Branch (7655:19): [True: 9.19k, False: 1.86k] ------------------ 7656| | /* Detect and prevent signed integer overflow */ 7657| 9.19k| if (i == INT_MAX) { ------------------ | Branch (7657:13): [True: 0, False: 9.19k] ------------------ 7658| 0| return NULL; 7659| 0| } 7660| | /* attributes without prefix are *not* in the default namespace */ 7661| 9.19k| if (name[i] == XML_T(ASCII_COLON)) { ------------------ | | 220| 9.19k|# define XML_T(x) x ------------------ | Branch (7661:13): [True: 1.16k, False: 8.03k] ------------------ 7662| 1.16k| if (! poolAppendChars(&dtd->pool, name, i)) ------------------ | Branch (7662:15): [True: 0, False: 1.16k] ------------------ 7663| 0| return NULL; 7664| 1.16k| if (! poolAppendChar(&dtd->pool, XML_T('\0'))) ------------------ | | 220| 1.16k|# define XML_T(x) x ------------------ | Branch (7664:15): [True: 0, False: 1.16k] ------------------ 7665| 0| return NULL; 7666| 1.16k| id->prefix = (PREFIX *)lookup(parser, &dtd->prefixes, 7667| 1.16k| poolStart(&dtd->pool), sizeof(PREFIX)); ------------------ | | 671| 1.16k|#define poolStart(pool) ((pool)->start) ------------------ 7668| 1.16k| if (! id->prefix) ------------------ | Branch (7668:15): [True: 0, False: 1.16k] ------------------ 7669| 0| return NULL; 7670| 1.16k| if (id->prefix->name == poolStart(&dtd->pool)) ------------------ | | 671| 1.16k|#define poolStart(pool) ((pool)->start) ------------------ | Branch (7670:15): [True: 149, False: 1.01k] ------------------ 7671| 149| poolFinish(&dtd->pool); ------------------ | | 676| 149|#define poolFinish(pool) ((pool)->start = (pool)->ptr) ------------------ 7672| 1.01k| else 7673| 1.01k| poolDiscard(&dtd->pool); ------------------ | | 675| 1.01k|#define poolDiscard(pool) ((pool)->ptr = (pool)->start) ------------------ 7674| 1.16k| break; 7675| 1.16k| } 7676| 9.19k| } 7677| 3.02k| } 7678| 7.65k| } 7679| 37.6k| return id; 7680| 37.6k|} xmlparse.c:poolAppend: 8450| 4.20M| const char *end) { 8451| 4.20M| if (! pool->ptr && ! poolGrow(pool)) ------------------ | Branch (8451:7): [True: 32.2k, False: 4.17M] | Branch (8451:22): [True: 0, False: 32.2k] ------------------ 8452| 0| return NULL; 8453| 4.20M| for (;;) { 8454| 4.20M| const enum XML_Convert_Result convert_res = XmlConvert( ------------------ | | 190| 4.20M|# define XmlConvert XmlUtf8Convert | | ------------------ | | | | 275| 4.20M| (((enc)->utf8Convert)(enc, fromP, fromLim, toP, toLim)) | | ------------------ ------------------ 8455| 4.20M| enc, &ptr, end, (ICHAR **)&(pool->ptr), (const ICHAR *)pool->end); 8456| 4.20M| if ((convert_res == XML_CONVERT_COMPLETED) ------------------ | Branch (8456:9): [True: 4.20M, False: 3.60k] ------------------ 8457| 3.60k| || (convert_res == XML_CONVERT_INPUT_INCOMPLETE)) ------------------ | Branch (8457:12): [True: 0, False: 3.60k] ------------------ 8458| 4.20M| break; 8459| 3.60k| if (! poolGrow(pool)) ------------------ | Branch (8459:9): [True: 0, False: 3.60k] ------------------ 8460| 0| return NULL; 8461| 3.60k| } 8462| 4.20M| return pool->start; 8463| 4.20M|} xmlparse.c:defineAttribute: 7527| 3.10k| bool isId, const XML_Char *value, XML_Parser parser) { 7528| 3.10k| DEFAULT_ATTRIBUTE *att; 7529| 3.10k| if (value || isId) { ------------------ | Branch (7529:7): [True: 2.39k, False: 708] | Branch (7529:16): [True: 417, False: 291] ------------------ 7530| | /* The handling of default attributes gets messed up if we have 7531| | a default which duplicates a non-default. */ 7532| 2.81k| NAMED *const nameFound 7533| 2.81k| = lookup(parser, &(type->defaultAttForName), attId->name, 0); 7534| 2.81k| if (nameFound) ------------------ | Branch (7534:9): [True: 918, False: 1.89k] ------------------ 7535| 918| return 1; 7536| 1.89k| if (isId && ! type->idAtt && ! attId->xmlns) ------------------ | Branch (7536:9): [True: 253, False: 1.64k] | Branch (7536:17): [True: 123, False: 130] | Branch (7536:34): [True: 113, False: 10] ------------------ 7537| 113| type->idAtt = attId; 7538| 1.89k| } 7539| 2.18k| if (type->nDefaultAtts == type->allocDefaultAtts) { ------------------ | Branch (7539:7): [True: 907, False: 1.27k] ------------------ 7540| | /* Detect and prevent integer overflow */ 7541| 907| if (type->allocDefaultAtts > SIZE_MAX / 2) { ------------------ | Branch (7541:9): [True: 0, False: 907] ------------------ 7542| 0| return 0; 7543| 0| } 7544| | 7545| 907| size_t count = type->allocDefaultAtts * 2; 7546| 907| if (count == 0) { ------------------ | Branch (7546:9): [True: 846, False: 61] ------------------ 7547| 846| count = 8; 7548| 846| } 7549| | 7550| | /* Detect and prevent integer overflow. */ 7551| 907| if (count > SIZE_MAX / sizeof(DEFAULT_ATTRIBUTE)) { ------------------ | Branch (7551:9): [True: 0, False: 907] ------------------ 7552| 0| return 0; 7553| 0| } 7554| | 7555| 907| DEFAULT_ATTRIBUTE *const temp = REALLOC( ------------------ | | 836| 907|# define REALLOC(parser, p, s) (expat_realloc((parser), (p), (s), __LINE__)) ------------------ 7556| 907| parser, type->defaultAtts, (count * sizeof(DEFAULT_ATTRIBUTE))); 7557| 907| if (temp == NULL) ------------------ | Branch (7557:9): [True: 0, False: 907] ------------------ 7558| 0| return 0; 7559| 907| type->allocDefaultAtts = count; 7560| 907| type->defaultAtts = temp; 7561| 907| } 7562| 2.18k| att = type->defaultAtts + type->nDefaultAtts; 7563| 2.18k| att->id = attId; 7564| 2.18k| att->value = value; 7565| 2.18k| att->isCdata = isCdata; 7566| 2.18k| if (! isCdata) ------------------ | Branch (7566:7): [True: 1.62k, False: 564] ------------------ 7567| 1.62k| attId->maybeTokenized = true; 7568| | 7569| 2.18k| NAME_AND_DEFAULT_ATTRIBUTE *const nameAndDefaultAttribute 7570| 2.18k| = (NAME_AND_DEFAULT_ATTRIBUTE *)lookup( 7571| 2.18k| parser, &(type->defaultAttForName), attId->name, 7572| 2.18k| sizeof(NAME_AND_DEFAULT_ATTRIBUTE)); 7573| 2.18k| if (! nameAndDefaultAttribute) ------------------ | Branch (7573:7): [True: 0, False: 2.18k] ------------------ 7574| 0| return 0; 7575| | 7576| 2.18k| assert(nameAndDefaultAttribute->name == attId->name); ------------------ | Branch (7576:3): [True: 0, False: 2.18k] | Branch (7576:3): [True: 2.18k, False: 0] ------------------ 7577| | 7578| | // NOTE: The XML 1.0r4 spec says: 7579| | // "When more than one definition is provided for the same attribute of a 7580| | // given element type, the first declaration is binding and later 7581| | // declarations are ignored." 7582| 2.18k| if (! nameAndDefaultAttribute->initialized) { ------------------ | Branch (7582:7): [True: 1.92k, False: 265] ------------------ 7583| 1.92k| nameAndDefaultAttribute->attIndex = type->nDefaultAtts; 7584| 1.92k| nameAndDefaultAttribute->initialized = true; 7585| 1.92k| } 7586| | 7587| 2.18k| type->nDefaultAtts += 1; 7588| 2.18k| return 1; 7589| 2.18k|} xmlparse.c:poolAppendChar: 679| 13.0M|poolAppendChar(STRING_POOL *pool, XML_Char c) { 680| 13.0M| if (pool->ptr == pool->end && ! poolGrow(pool)) ------------------ | Branch (680:7): [True: 11.7k, False: 12.9M] | Branch (680:33): [True: 0, False: 11.7k] ------------------ 681| 0| return false; 682| | 683| 13.0M| *(pool->ptr)++ = c; 684| | return true; 685| 13.0M|} xmlparse.c:storeAttributeValue: 6842| 8.17k| enum XML_Account account) { 6843| 8.17k| const char *next = ptr; 6844| 8.17k| enum XML_Error result = XML_ERROR_NONE; 6845| | 6846| 1.78M| while (1) { ------------------ | Branch (6846:10): [True: 1.78M, Folded] ------------------ 6847| 1.78M| if (! parser->m_openAttributeEntities) { ------------------ | Branch (6847:9): [True: 27.9k, False: 1.75M] ------------------ 6848| 27.9k| result = appendAttributeValue(parser, enc, isCdata, next, end, pool, 6849| 27.9k| account, &next); 6850| 1.75M| } else { 6851| 1.75M| OPEN_INTERNAL_ENTITY *const openEntity = parser->m_openAttributeEntities; 6852| 1.75M| if (! openEntity) ------------------ | Branch (6852:11): [True: 0, False: 1.75M] ------------------ 6853| 0| return XML_ERROR_UNEXPECTED_STATE; 6854| | 6855| 1.75M| ENTITY *const entity = openEntity->entity; 6856| 1.75M| const char *const textStart 6857| 1.75M| = ((const char *)entity->textPtr) + entity->processed; 6858| 1.75M| const char *const textEnd 6859| 1.75M| = (const char *)(entity->textPtr + entity->textLen); 6860| | /* Set a safe default value in case 'next' does not get set */ 6861| 1.75M| const char *nextInEntity = textStart; 6862| 1.75M| if (entity->hasMore) { ------------------ | Branch (6862:11): [True: 1.16M, False: 598k] ------------------ 6863| 1.16M| result = appendAttributeValue( 6864| 1.16M| parser, parser->m_internalEncoding, isCdata, textStart, textEnd, 6865| 1.16M| pool, XML_ACCOUNT_ENTITY_EXPANSION, &nextInEntity); 6866| 1.16M| if (result != XML_ERROR_NONE) ------------------ | Branch (6866:13): [True: 15, False: 1.16M] ------------------ 6867| 15| break; 6868| | // Check if entity is complete, if not, mark down how much of it is 6869| | // processed. A XML_SUSPENDED check here is not required as 6870| | // appendAttributeValue will never suspend the parser. 6871| 1.16M| if (nextInEntity < textEnd) { ------------------ | Branch (6871:13): [True: 562k, False: 598k] ------------------ 6872| 562k| entity->processed = nextInEntity - (const char *)entity->textPtr; 6873| 562k| continue; 6874| 562k| } 6875| 1.16M| assert(nextInEntity == textEnd); ------------------ | Branch (6875:9): [True: 0, False: 598k] | Branch (6875:9): [True: 598k, False: 0] ------------------ 6876| | 6877| | // Entity is complete. We cannot close it here since we need to first 6878| | // process its possible inner entities (which are added to the 6879| | // m_openAttributeEntities during appendAttributeValue) 6880| 598k| entity->hasMore = false; 6881| 598k| continue; 6882| 598k| } // End of entity processing, "if" block skips the rest 6883| | 6884| | // Remove fully processed openEntity from open entity list. 6885| 598k|#if XML_GE == 1 6886| 598k| entityTrackingOnClose(parser, entity, __LINE__); 6887| 598k|#endif 6888| | // openEntity is m_openAttributeEntities' head, since we set it at the 6889| | // start of this function and because we skipped appendAttributeValue call 6890| | // with hasMore set to false. This means we can directly remove the head 6891| | // of m_openAttributeEntities 6892| 598k| assert(parser->m_openAttributeEntities == openEntity); ------------------ | Branch (6892:7): [True: 0, False: 598k] | Branch (6892:7): [True: 598k, False: 0] ------------------ 6893| 598k| entity->open = false; 6894| 598k| parser->m_openAttributeEntities = parser->m_openAttributeEntities->next; 6895| | 6896| | /* put openEntity back in list of free instances */ 6897| 598k| openEntity->next = parser->m_freeEntities; 6898| 598k| parser->m_freeEntities = openEntity; 6899| 598k| } 6900| | 6901| | // Break if an error occurred or there is nothing left to process 6902| 626k| if (result || (parser->m_openAttributeEntities == NULL && end == next)) { ------------------ | Branch (6902:9): [True: 119, False: 626k] | Branch (6902:20): [True: 27.8k, False: 598k] | Branch (6902:63): [True: 8.03k, False: 19.8k] ------------------ 6903| 8.15k| break; 6904| 8.15k| } 6905| 626k| } 6906| | 6907| 8.17k| if (result) ------------------ | Branch (6907:7): [True: 134, False: 8.03k] ------------------ 6908| 134| return result; 6909| 8.03k| if (! isCdata && poolLength(pool) && poolLastChar(pool) == 0x20) ------------------ | | 672| 10.1k|#define poolLength(pool) ((pool)->ptr - (pool)->start) | | ------------------ | | | Branch (672:26): [True: 391, False: 1.73k] | | ------------------ ------------------ if (! isCdata && poolLength(pool) && poolLastChar(pool) == 0x20) ------------------ | | 674| 391|#define poolLastChar(pool) (((pool)->ptr)[-1]) ------------------ | Branch (6909:7): [True: 2.13k, False: 5.90k] | Branch (6909:40): [True: 124, False: 267] ------------------ 6910| 124| poolChop(pool); ------------------ | | 673| 124|#define poolChop(pool) ((void)--(pool->ptr)) ------------------ 6911| 8.03k| if (! poolAppendChar(pool, XML_T('\0'))) ------------------ | | 220| 8.03k|# define XML_T(x) x ------------------ | Branch (6911:7): [True: 0, False: 8.03k] ------------------ 6912| 0| return XML_ERROR_NO_MEMORY; 6913| 8.03k| return XML_ERROR_NONE; 6914| 8.03k|} xmlparse.c:appendAttributeValue: 6919| 1.18M| enum XML_Account account, const char **nextPtr) { 6920| 1.18M| DTD *const dtd = parser->m_dtd; /* save one level of indirection */ 6921| |#ifndef XML_DTD 6922| | UNUSED_P(account); 6923| |#endif 6924| | 6925| 16.5M| for (;;) { 6926| 16.5M| const char *next 6927| 16.5M| = ptr; /* XmlAttributeValueTok doesn't always set the last arg */ 6928| 16.5M| int tok = XmlAttributeValueTok(enc, ptr, end, &next); ------------------ | | 248| 16.5M| XmlLiteralTok(enc, XML_ATTRIBUTE_VALUE_LITERAL, ptr, end, nextTokPtr) | | ------------------ | | | | 245| 16.5M| (((enc)->literalScanners[literalType])(enc, ptr, end, nextTokPtr)) | | ------------------ ------------------ 6929| 16.5M|#if XML_GE == 1 6930| 16.5M| if (! accountingDiffTolerated(parser, tok, ptr, next, __LINE__, account)) { ------------------ | Branch (6930:9): [True: 0, False: 16.5M] ------------------ 6931| 0| accountingOnAbort(parser); 6932| 0| return XML_ERROR_AMPLIFICATION_LIMIT_BREACH; 6933| 0| } 6934| 16.5M|#endif 6935| 16.5M| switch (tok) { 6936| 590k| case XML_TOK_NONE: ------------------ | | 51| 590k|# define XML_TOK_NONE -4 /* The string to be scanned is empty */ ------------------ | Branch (6936:5): [True: 590k, False: 15.9M] ------------------ 6937| 590k| if (nextPtr) { ------------------ | Branch (6937:11): [True: 590k, False: 0] ------------------ 6938| 590k| *nextPtr = next; 6939| 590k| } 6940| 590k| return XML_ERROR_NONE; 6941| 12| case XML_TOK_INVALID: ------------------ | | 57| 12|# define XML_TOK_INVALID 0 ------------------ | Branch (6941:5): [True: 12, False: 16.5M] ------------------ 6942| 12| if (enc == parser->m_encoding) ------------------ | Branch (6942:11): [True: 7, False: 5] ------------------ 6943| 7| parser->m_eventPtr = next; 6944| 12| return XML_ERROR_INVALID_TOKEN; 6945| 7| case XML_TOK_PARTIAL: ------------------ | | 56| 7|# define XML_TOK_PARTIAL -1 /* only part of a token */ ------------------ | Branch (6945:5): [True: 7, False: 16.5M] ------------------ 6946| 7| if (enc == parser->m_encoding) ------------------ | Branch (6946:11): [True: 6, False: 1] ------------------ 6947| 6| parser->m_eventPtr = ptr; 6948| 7| return XML_ERROR_INVALID_TOKEN; 6949| 2.35k| case XML_TOK_CHAR_REF: { ------------------ | | 71| 2.35k|# define XML_TOK_CHAR_REF 10 /* numeric character reference */ ------------------ | Branch (6949:5): [True: 2.35k, False: 16.5M] ------------------ 6950| 2.35k| XML_Char buf[XML_ENCODE_MAX]; 6951| 2.35k| int n = XmlCharRefNumber(enc, ptr); ------------------ | | 263| 2.35k|# define XmlCharRefNumber(enc, ptr) (((enc)->charRefNumber)(enc, ptr)) ------------------ 6952| 2.35k| if (n < 0) { ------------------ | Branch (6952:11): [True: 19, False: 2.33k] ------------------ 6953| 19| if (enc == parser->m_encoding) ------------------ | Branch (6953:13): [True: 19, False: 0] ------------------ 6954| 19| parser->m_eventPtr = ptr; 6955| 19| return XML_ERROR_BAD_CHAR_REF; 6956| 19| } 6957| 2.33k| if (! isCdata && n == 0x20 /* space */ ------------------ | Branch (6957:11): [True: 681, False: 1.65k] | Branch (6957:24): [True: 466, False: 215] ------------------ 6958| 466| && (poolLength(pool) == 0 || poolLastChar(pool) == 0x20)) ------------------ | | 672| 466|#define poolLength(pool) ((pool)->ptr - (pool)->start) ------------------ && (poolLength(pool) == 0 || poolLastChar(pool) == 0x20)) ------------------ | | 674| 272|#define poolLastChar(pool) (((pool)->ptr)[-1]) ------------------ | Branch (6958:15): [True: 194, False: 272] | Branch (6958:40): [True: 194, False: 78] ------------------ 6959| 388| break; 6960| 1.94k| n = XmlEncode(n, (ICHAR *)buf); ------------------ | | 193| 1.94k|# define XmlEncode XmlUtf8Encode ------------------ 6961| | /* The XmlEncode() functions can never return 0 here. That 6962| | * error return happens if the code point passed in is either 6963| | * negative or greater than or equal to 0x110000. The 6964| | * XmlCharRefNumber() functions will all return a number 6965| | * strictly less than 0x110000 or a negative value if an error 6966| | * occurred. The negative value is intercepted above, so 6967| | * XmlEncode() is never passed a value it might return an 6968| | * error for. 6969| | */ 6970| | 6971| 1.94k| if (! poolAppendChars(pool, buf, n)) ------------------ | Branch (6971:11): [True: 0, False: 1.94k] ------------------ 6972| 0| return XML_ERROR_NO_MEMORY; 6973| 1.94k| } break; 6974| 3.37M| case XML_TOK_DATA_CHARS: ------------------ | | 67| 3.37M|# define XML_TOK_DATA_CHARS 6 ------------------ | Branch (6974:5): [True: 3.37M, False: 13.1M] ------------------ 6975| 3.37M| if (! poolAppend(pool, enc, ptr, next)) ------------------ | Branch (6975:11): [True: 0, False: 3.37M] ------------------ 6976| 0| return XML_ERROR_NO_MEMORY; 6977| 3.37M| break; 6978| 3.37M| case XML_TOK_TRAILING_CR: ------------------ | | 53| 154| -3 /* A CR at the end of the scan; \ ------------------ | Branch (6978:5): [True: 154, False: 16.5M] ------------------ 6979| 154| next = ptr + enc->minBytesPerChar; 6980| 154| EXPAT_FALLTHROUGH; ------------------ | | 47| 154|# define EXPAT_FALLTHROUGH __attribute__((fallthrough)) ------------------ 6981| 11.8M| case XML_TOK_ATTRIBUTE_VALUE_S: ------------------ | | 110| 11.8M|# define XML_TOK_ATTRIBUTE_VALUE_S 39 ------------------ | Branch (6981:5): [True: 11.8M, False: 4.62M] ------------------ 6982| 11.9M| case XML_TOK_DATA_NEWLINE: ------------------ | | 68| 11.9M|# define XML_TOK_DATA_NEWLINE 7 ------------------ | Branch (6982:5): [True: 27.9k, False: 16.4M] ------------------ 6983| 11.9M| if (! isCdata && (poolLength(pool) == 0 || poolLastChar(pool) == 0x20)) ------------------ | | 672| 29.2k|#define poolLength(pool) ((pool)->ptr - (pool)->start) ------------------ if (! isCdata && (poolLength(pool) == 0 || poolLastChar(pool) == 0x20)) ------------------ | | 674| 28.5k|#define poolLastChar(pool) (((pool)->ptr)[-1]) ------------------ | Branch (6983:11): [True: 29.2k, False: 11.8M] | Branch (6983:25): [True: 616, False: 28.5k] | Branch (6983:50): [True: 19.8k, False: 8.69k] ------------------ 6984| 20.5k| break; 6985| 11.9M| if (! poolAppendChar(pool, 0x20)) ------------------ | Branch (6985:11): [True: 0, False: 11.9M] ------------------ 6986| 0| return XML_ERROR_NO_MEMORY; 6987| 11.9M| break; 6988| 11.9M| case XML_TOK_ENTITY_REF: { ------------------ | | 70| 628k|# define XML_TOK_ENTITY_REF 9 ------------------ | Branch (6988:5): [True: 628k, False: 15.8M] ------------------ 6989| 628k| const XML_Char *name; 6990| 628k| ENTITY *entity; 6991| 628k| bool checkEntityDecl; 6992| 628k| XML_Char ch = (XML_Char)XmlPredefinedEntityName( ------------------ | | 266| 628k| (((enc)->predefinedEntityName)(enc, ptr, end)) ------------------ 6993| 628k| enc, ptr + enc->minBytesPerChar, next - enc->minBytesPerChar); 6994| 628k| if (ch) { ------------------ | Branch (6994:11): [True: 29.7k, False: 599k] ------------------ 6995| 29.7k|#if XML_GE == 1 6996| | /* NOTE: We are replacing 4-6 characters original input for 1 character 6997| | * so there is no amplification and hence recording without 6998| | * protection. */ 6999| 29.7k| accountingDiffTolerated(parser, tok, (char *)&ch, 7000| 29.7k| ((char *)&ch) + sizeof(XML_Char), __LINE__, 7001| 29.7k| XML_ACCOUNT_ENTITY_EXPANSION); 7002| 29.7k|#endif /* XML_GE == 1 */ 7003| 29.7k| if (! poolAppendChar(pool, ch)) ------------------ | Branch (7003:13): [True: 0, False: 29.7k] ------------------ 7004| 0| return XML_ERROR_NO_MEMORY; 7005| 29.7k| break; 7006| 29.7k| } 7007| 599k| name = poolStoreString(&parser->m_temp2Pool, enc, 7008| 599k| ptr + enc->minBytesPerChar, 7009| 599k| next - enc->minBytesPerChar); 7010| 599k| if (! name) ------------------ | Branch (7010:11): [True: 0, False: 599k] ------------------ 7011| 0| return XML_ERROR_NO_MEMORY; 7012| 599k| entity = (ENTITY *)lookup(parser, &dtd->generalEntities, name, 0); 7013| 599k| poolDiscard(&parser->m_temp2Pool); ------------------ | | 675| 599k|#define poolDiscard(pool) ((pool)->ptr = (pool)->start) ------------------ 7014| | /* First, determine if a check for an existing declaration is needed; 7015| | if yes, check that the entity exists, and that it is internal. 7016| | */ 7017| 599k| if (pool == &dtd->pool) /* are we called from prolog? */ ------------------ | Branch (7017:11): [True: 104k, False: 494k] ------------------ 7018| 104k| checkEntityDecl = 7019| 104k|#ifdef XML_DTD 7020| 104k| parser->m_prologState.documentEntity && ------------------ | Branch (7020:13): [True: 104k, False: 0] ------------------ 7021| 104k|#endif /* XML_DTD */ 7022| 104k| (dtd->standalone ? ! parser->m_openInternalEntities ------------------ | Branch (7022:13): [True: 104k, False: 152] | Branch (7022:14): [True: 0, False: 104k] ------------------ 7023| 104k| : ! dtd->hasParamEntityRefs); 7024| 494k| else /* if (pool == &parser->m_tempPool): we are called from content */ 7025| 494k| checkEntityDecl = ! dtd->hasParamEntityRefs || dtd->standalone; ------------------ | Branch (7025:27): [True: 487k, False: 6.64k] | Branch (7025:56): [True: 0, False: 6.64k] ------------------ 7026| 599k| if (checkEntityDecl) { ------------------ | Branch (7026:11): [True: 592k, False: 6.80k] ------------------ 7027| 592k| if (! entity) ------------------ | Branch (7027:13): [True: 88, False: 592k] ------------------ 7028| 88| return XML_ERROR_UNDEFINED_ENTITY; 7029| 592k| else if (! entity->is_internal) ------------------ | Branch (7029:18): [True: 0, False: 592k] ------------------ 7030| 0| return XML_ERROR_ENTITY_DECLARED_IN_PE; 7031| 592k| } else if (! entity) { ------------------ | Branch (7031:18): [True: 644, False: 6.15k] ------------------ 7032| | /* Cannot report skipped entity here - see comments on 7033| | parser->m_skippedEntityHandler. 7034| | if (parser->m_skippedEntityHandler) { 7035| | beforeHandler(parser); 7036| | parser->m_skippedEntityHandler(parser->m_handlerArg, name, 0); 7037| | afterHandler(parser); 7038| | } 7039| | */ 7040| | /* Cannot call the default handler because this would be 7041| | out of sync with the call to the startElementHandler. 7042| | if ((pool == &parser->m_tempPool) && parser->m_defaultHandler) 7043| | reportDefault(parser, enc, ptr, next); 7044| | */ 7045| 644| break; 7046| 644| } 7047| 598k| if (entity->open) { ------------------ | Branch (7047:11): [True: 4, False: 598k] ------------------ 7048| 4| if (enc == parser->m_encoding) { ------------------ | Branch (7048:13): [True: 0, False: 4] ------------------ 7049| | /* It does not appear that this line can be executed. 7050| | * 7051| | * The "if (entity->open)" check catches recursive entity 7052| | * definitions. In order to be called with an open 7053| | * entity, it must have gone through this code before and 7054| | * been through the recursive call to 7055| | * appendAttributeValue() some lines below. That call 7056| | * sets the local encoding ("enc") to the parser's 7057| | * internal encoding (internal_utf8 or internal_utf16), 7058| | * which can never be the same as the principle encoding. 7059| | * It doesn't appear there is another code path that gets 7060| | * here with entity->open being TRUE. 7061| | * 7062| | * Since it is not certain that this logic is watertight, 7063| | * we keep the line and merely exclude it from coverage 7064| | * tests. 7065| | */ 7066| 0| parser->m_eventPtr = ptr; /* LCOV_EXCL_LINE */ 7067| 0| } 7068| 4| return XML_ERROR_RECURSIVE_ENTITY_REF; 7069| 4| } 7070| 598k| if (entity->notation) { ------------------ | Branch (7070:11): [True: 2, False: 598k] ------------------ 7071| 2| if (enc == parser->m_encoding) ------------------ | Branch (7071:13): [True: 1, False: 1] ------------------ 7072| 1| parser->m_eventPtr = ptr; 7073| 2| return XML_ERROR_BINARY_ENTITY_REF; 7074| 2| } 7075| 598k| if (! entity->textPtr) { ------------------ | Branch (7075:11): [True: 2, False: 598k] ------------------ 7076| 2| if (enc == parser->m_encoding) ------------------ | Branch (7076:13): [True: 1, False: 1] ------------------ 7077| 1| parser->m_eventPtr = ptr; 7078| 2| return XML_ERROR_ATTRIBUTE_EXTERNAL_ENTITY_REF; 7079| 598k| } else { 7080| 598k| enum XML_Error result; 7081| 598k| result = processEntity(parser, entity, XML_FALSE, ENTITY_ATTRIBUTE); ------------------ | | 64| 598k|# define XML_FALSE ((XML_Bool)0) ------------------ 7082| 598k| if ((result == XML_ERROR_NONE) && (nextPtr != NULL)) { ------------------ | Branch (7082:13): [True: 598k, False: 0] | Branch (7082:43): [True: 598k, False: 0] ------------------ 7083| 598k| *nextPtr = next; 7084| 598k| } 7085| 598k| return result; 7086| 598k| } 7087| 598k| } break; 7088| 0| default: ------------------ | Branch (7088:5): [True: 0, False: 16.5M] ------------------ 7089| | /* The only token returned by XmlAttributeValueTok() that does 7090| | * not have an explicit case here is XML_TOK_PARTIAL_CHAR. 7091| | * Getting that would require an entity name to contain an 7092| | * incomplete XML character (e.g. \xE2\x82); however previous 7093| | * tokenisers will have already recognised and rejected such 7094| | * names before XmlAttributeValueTok() gets a look-in. This 7095| | * default case should be retained as a safety net, but the code 7096| | * excluded from coverage tests. 7097| | * 7098| | * LCOV_EXCL_START 7099| | */ 7100| 0| if (enc == parser->m_encoding) ------------------ | Branch (7100:11): [True: 0, False: 0] ------------------ 7101| 0| parser->m_eventPtr = ptr; 7102| 0| return XML_ERROR_UNEXPECTED_STATE; 7103| | /* LCOV_EXCL_STOP */ 7104| 16.5M| } 7105| 15.3M| ptr = next; 7106| 15.3M| } 7107| | /* not reached */ 7108| 1.18M|} xmlparse.c:callStoreEntityValue: 7303| 3.72k| enum XML_Account account) { 7304| 3.72k| const char *next = entityTextPtr; 7305| 3.72k| enum XML_Error result = XML_ERROR_NONE; 7306| 3.72k| while (1) { ------------------ | Branch (7306:10): [True: 3.72k, Folded] ------------------ 7307| 3.72k| if (! parser->m_openValueEntities) { ------------------ | Branch (7307:9): [True: 3.72k, False: 0] ------------------ 7308| 3.72k| result 7309| 3.72k| = storeEntityValue(parser, enc, next, entityTextEnd, account, &next); 7310| 3.72k| } else { 7311| 0| OPEN_INTERNAL_ENTITY *const openEntity = parser->m_openValueEntities; 7312| 0| if (! openEntity) ------------------ | Branch (7312:11): [True: 0, False: 0] ------------------ 7313| 0| return XML_ERROR_UNEXPECTED_STATE; 7314| | 7315| 0| ENTITY *const entity = openEntity->entity; 7316| 0| const char *const textStart 7317| 0| = ((const char *)entity->textPtr) + entity->processed; 7318| 0| const char *const textEnd 7319| 0| = (const char *)(entity->textPtr + entity->textLen); 7320| | /* Set a safe default value in case 'next' does not get set */ 7321| 0| const char *nextInEntity = textStart; 7322| 0| if (entity->hasMore) { ------------------ | Branch (7322:11): [True: 0, False: 0] ------------------ 7323| 0| result = storeEntityValue(parser, parser->m_internalEncoding, textStart, 7324| 0| textEnd, XML_ACCOUNT_ENTITY_EXPANSION, 7325| 0| &nextInEntity); 7326| 0| if (result != XML_ERROR_NONE) ------------------ | Branch (7326:13): [True: 0, False: 0] ------------------ 7327| 0| break; 7328| | // Check if entity is complete, if not, mark down how much of it is 7329| | // processed. A XML_SUSPENDED check here is not required as 7330| | // appendAttributeValue will never suspend the parser. 7331| 0| if (textEnd != nextInEntity) { ------------------ | Branch (7331:13): [True: 0, False: 0] ------------------ 7332| 0| entity->processed = nextInEntity - (const char *)entity->textPtr; 7333| 0| continue; 7334| 0| } 7335| | 7336| | // Entity is complete. We cannot close it here since we need to first 7337| | // process its possible inner entities (which are added to the 7338| | // m_openValueEntities during storeEntityValue) 7339| 0| entity->hasMore = false; 7340| 0| continue; 7341| 0| } // End of entity processing, "if" block skips the rest 7342| | 7343| | // Remove fully processed openEntity from open entity list. 7344| 0|# if XML_GE == 1 7345| 0| entityTrackingOnClose(parser, entity, __LINE__); 7346| 0|# endif 7347| | // openEntity is m_openValueEntities' head, since we set it at the 7348| | // start of this function and because we skipped storeEntityValue call 7349| | // with hasMore set to false. This means we can directly remove the head 7350| | // of m_openValueEntities 7351| 0| assert(parser->m_openValueEntities == openEntity); ------------------ | Branch (7351:7): [True: 0, False: 0] | Branch (7351:7): [True: 0, False: 0] ------------------ 7352| 0| entity->open = false; 7353| 0| parser->m_openValueEntities = parser->m_openValueEntities->next; 7354| | 7355| | /* put openEntity back in list of free instances */ 7356| 0| openEntity->next = parser->m_freeEntities; 7357| 0| parser->m_freeEntities = openEntity; 7358| 0| } 7359| | 7360| | // Break if an error occurred or there is nothing left to process 7361| 3.72k| if (result ------------------ | Branch (7361:9): [True: 23, False: 3.70k] ------------------ 7362| 3.72k| || (parser->m_openValueEntities == NULL && entityTextEnd == next)) { ------------------ | Branch (7362:13): [True: 3.70k, False: 0] | Branch (7362:52): [True: 3.70k, False: 0] ------------------ 7363| 3.72k| break; 7364| 3.72k| } 7365| 3.72k| } 7366| | 7367| 3.72k| return result; 7368| 3.72k|} xmlparse.c:storeEntityValue: 7114| 3.72k| enum XML_Account account, const char **nextPtr) { 7115| 3.72k| DTD *const dtd = parser->m_dtd; /* save one level of indirection */ 7116| 3.72k| STRING_POOL *pool = &(dtd->entityValuePool); 7117| 3.72k| enum XML_Error result = XML_ERROR_NONE; 7118| 3.72k|# ifdef XML_DTD 7119| 3.72k| int oldInEntityValue = parser->m_prologState.inEntityValue; 7120| 3.72k| parser->m_prologState.inEntityValue = 1; 7121| |# else 7122| | UNUSED_P(account); 7123| |# endif /* XML_DTD */ 7124| | /* never return Null for the value argument in EntityDeclHandler, 7125| | since this would indicate an external entity; therefore we 7126| | have to make sure that entityValuePool.start is not null */ 7127| 3.72k| if (! pool->blocks) { ------------------ | Branch (7127:7): [True: 1.71k, False: 2.00k] ------------------ 7128| 1.71k| if (! poolGrow(pool)) ------------------ | Branch (7128:9): [True: 0, False: 1.71k] ------------------ 7129| 0| return XML_ERROR_NO_MEMORY; 7130| 1.71k| } 7131| | 7132| 3.72k| const char *next = entityTextPtr; 7133| | 7134| | /* Nothing to tokenize. */ 7135| 3.72k| if (entityTextPtr >= entityTextEnd) { ------------------ | Branch (7135:7): [True: 1.18k, False: 2.53k] ------------------ 7136| 1.18k| result = XML_ERROR_NONE; 7137| 1.18k| goto endEntityValue; 7138| 1.18k| } 7139| | 7140| 26.9k| for (;;) { 7141| 26.9k| next 7142| 26.9k| = entityTextPtr; /* XmlEntityValueTok doesn't always set the last arg */ 7143| 26.9k| int tok = XmlEntityValueTok(enc, entityTextPtr, entityTextEnd, &next); ------------------ | | 251| 26.9k| XmlLiteralTok(enc, XML_ENTITY_VALUE_LITERAL, ptr, end, nextTokPtr) | | ------------------ | | | | 245| 26.9k| (((enc)->literalScanners[literalType])(enc, ptr, end, nextTokPtr)) | | ------------------ ------------------ 7144| | 7145| 26.9k| if (! accountingDiffTolerated(parser, tok, entityTextPtr, next, __LINE__, ------------------ | Branch (7145:9): [True: 0, False: 26.9k] ------------------ 7146| 26.9k| account)) { 7147| 0| accountingOnAbort(parser); 7148| 0| result = XML_ERROR_AMPLIFICATION_LIMIT_BREACH; 7149| 0| goto endEntityValue; 7150| 0| } 7151| | 7152| 26.9k| switch (tok) { 7153| 1| case XML_TOK_PARAM_ENTITY_REF: ------------------ | | 95| 1|# define XML_TOK_PARAM_ENTITY_REF 28 ------------------ | Branch (7153:5): [True: 1, False: 26.9k] ------------------ 7154| 1|# ifdef XML_DTD 7155| 1| if (parser->m_isParamEntity || enc != parser->m_encoding) { ------------------ | Branch (7155:11): [True: 0, False: 1] | Branch (7155:38): [True: 0, False: 1] ------------------ 7156| 0| const XML_Char *name; 7157| 0| ENTITY *entity; 7158| 0| name = poolStoreString(&parser->m_tempPool, enc, 7159| 0| entityTextPtr + enc->minBytesPerChar, 7160| 0| next - enc->minBytesPerChar); 7161| 0| if (! name) { ------------------ | Branch (7161:13): [True: 0, False: 0] ------------------ 7162| 0| result = XML_ERROR_NO_MEMORY; 7163| 0| goto endEntityValue; 7164| 0| } 7165| 0| entity = (ENTITY *)lookup(parser, &dtd->paramEntities, name, 0); 7166| 0| poolDiscard(&parser->m_tempPool); ------------------ | | 675| 0|#define poolDiscard(pool) ((pool)->ptr = (pool)->start) ------------------ 7167| 0| if (! entity) { ------------------ | Branch (7167:13): [True: 0, False: 0] ------------------ 7168| | /* not a well-formedness error - see XML 1.0: WFC Entity Declared */ 7169| | /* cannot report skipped entity here - see comments on 7170| | parser->m_skippedEntityHandler 7171| | if (parser->m_skippedEntityHandler) { 7172| | beforeHandler(parser); 7173| | parser->m_skippedEntityHandler(parser->m_handlerArg, name, 0); 7174| | afterHandler(parser); 7175| | } 7176| | */ 7177| 0| dtd->keepProcessing = dtd->standalone; 7178| 0| goto endEntityValue; 7179| 0| } 7180| 0| if (entity->open || (entity == parser->m_declEntity)) { ------------------ | Branch (7180:13): [True: 0, False: 0] | Branch (7180:29): [True: 0, False: 0] ------------------ 7181| 0| if (enc == parser->m_encoding) ------------------ | Branch (7181:15): [True: 0, False: 0] ------------------ 7182| 0| parser->m_eventPtr = entityTextPtr; 7183| 0| result = XML_ERROR_RECURSIVE_ENTITY_REF; 7184| 0| goto endEntityValue; 7185| 0| } 7186| 0| if (entity->systemId) { ------------------ | Branch (7186:13): [True: 0, False: 0] ------------------ 7187| 0| if (parser->m_externalEntityRefHandler) { ------------------ | Branch (7187:15): [True: 0, False: 0] ------------------ 7188| 0| dtd->paramEntityRead = false; 7189| 0| entity->open = true; 7190| 0| entityTrackingOnOpen(parser, entity, __LINE__); 7191| 0| beforeHandler(parser); 7192| 0| const int status = parser->m_externalEntityRefHandler( 7193| 0| parser->m_externalEntityRefHandlerArg, 0, entity->base, 7194| 0| entity->systemId, entity->publicId); 7195| 0| afterHandler(parser); 7196| 0| if (! status) { ------------------ | Branch (7196:17): [True: 0, False: 0] ------------------ 7197| 0| entityTrackingOnClose(parser, entity, __LINE__); 7198| 0| entity->open = false; 7199| 0| result = XML_ERROR_EXTERNAL_ENTITY_HANDLING; 7200| 0| goto endEntityValue; 7201| 0| } 7202| 0| entityTrackingOnClose(parser, entity, __LINE__); 7203| 0| entity->open = false; 7204| 0| if (! dtd->paramEntityRead) ------------------ | Branch (7204:17): [True: 0, False: 0] ------------------ 7205| 0| dtd->keepProcessing = dtd->standalone; 7206| 0| } else 7207| 0| dtd->keepProcessing = dtd->standalone; 7208| 0| } else { 7209| 0| result = processEntity(parser, entity, XML_FALSE, ENTITY_VALUE); ------------------ | | 64| 0|# define XML_FALSE ((XML_Bool)0) ------------------ 7210| 0| goto endEntityValue; 7211| 0| } 7212| 0| break; 7213| 0| } 7214| 1|# endif /* XML_DTD */ 7215| | /* In the internal subset, PE references are not legal 7216| | within markup declarations, e.g entity values in this case. */ 7217| 1| parser->m_eventPtr = entityTextPtr; 7218| 1| result = XML_ERROR_PARAM_ENTITY_REF; 7219| 1| goto endEntityValue; 7220| 2.51k| case XML_TOK_NONE: ------------------ | | 51| 2.51k|# define XML_TOK_NONE -4 /* The string to be scanned is empty */ ------------------ | Branch (7220:5): [True: 2.51k, False: 24.4k] ------------------ 7221| 2.51k| result = XML_ERROR_NONE; 7222| 2.51k| goto endEntityValue; 7223| 15.9k| case XML_TOK_ENTITY_REF: ------------------ | | 70| 15.9k|# define XML_TOK_ENTITY_REF 9 ------------------ | Branch (7223:5): [True: 15.9k, False: 11.0k] ------------------ 7224| 21.0k| case XML_TOK_DATA_CHARS: ------------------ | | 67| 21.0k|# define XML_TOK_DATA_CHARS 6 ------------------ | Branch (7224:5): [True: 5.09k, False: 21.8k] ------------------ 7225| 21.0k| if (! poolAppend(pool, enc, entityTextPtr, next)) { ------------------ | Branch (7225:11): [True: 0, False: 21.0k] ------------------ 7226| 0| result = XML_ERROR_NO_MEMORY; 7227| 0| goto endEntityValue; 7228| 0| } 7229| 21.0k| break; 7230| 21.0k| case XML_TOK_TRAILING_CR: ------------------ | | 53| 73| -3 /* A CR at the end of the scan; \ ------------------ | Branch (7230:5): [True: 73, False: 26.8k] ------------------ 7231| 73| next = entityTextPtr + enc->minBytesPerChar; 7232| 73| EXPAT_FALLTHROUGH; ------------------ | | 47| 73|# define EXPAT_FALLTHROUGH __attribute__((fallthrough)) ------------------ 7233| 2.25k| case XML_TOK_DATA_NEWLINE: ------------------ | | 68| 2.25k|# define XML_TOK_DATA_NEWLINE 7 ------------------ | Branch (7233:5): [True: 2.17k, False: 24.7k] ------------------ 7234| 2.25k| if (! poolAppendChar(pool, 0xA)) { ------------------ | Branch (7234:11): [True: 0, False: 2.25k] ------------------ 7235| 0| result = XML_ERROR_NO_MEMORY; 7236| 0| goto endEntityValue; 7237| 0| } 7238| 2.25k| break; 7239| 2.25k| case XML_TOK_CHAR_REF: { ------------------ | | 71| 1.15k|# define XML_TOK_CHAR_REF 10 /* numeric character reference */ ------------------ | Branch (7239:5): [True: 1.15k, False: 25.8k] ------------------ 7240| 1.15k| XML_Char buf[XML_ENCODE_MAX]; 7241| 1.15k| int n = XmlCharRefNumber(enc, entityTextPtr); ------------------ | | 263| 1.15k|# define XmlCharRefNumber(enc, ptr) (((enc)->charRefNumber)(enc, ptr)) ------------------ 7242| 1.15k| if (n < 0) { ------------------ | Branch (7242:11): [True: 2, False: 1.15k] ------------------ 7243| 2| if (enc == parser->m_encoding) ------------------ | Branch (7243:13): [True: 2, False: 0] ------------------ 7244| 2| parser->m_eventPtr = entityTextPtr; 7245| 2| result = XML_ERROR_BAD_CHAR_REF; 7246| 2| goto endEntityValue; 7247| 2| } 7248| 1.15k| n = XmlEncode(n, (ICHAR *)buf); ------------------ | | 193| 1.15k|# define XmlEncode XmlUtf8Encode ------------------ 7249| | /* The XmlEncode() functions can never return 0 here. That 7250| | * error return happens if the code point passed in is either 7251| | * negative or greater than or equal to 0x110000. The 7252| | * XmlCharRefNumber() functions will all return a number 7253| | * strictly less than 0x110000 or a negative value if an error 7254| | * occurred. The negative value is intercepted above, so 7255| | * XmlEncode() is never passed a value it might return an 7256| | * error for. 7257| | */ 7258| 1.15k| if (! poolAppendChars(pool, buf, n)) { ------------------ | Branch (7258:11): [True: 0, False: 1.15k] ------------------ 7259| 0| result = XML_ERROR_NO_MEMORY; 7260| 0| goto endEntityValue; 7261| 0| } 7262| 1.15k| } break; 7263| 1.15k| case XML_TOK_PARTIAL: ------------------ | | 56| 18|# define XML_TOK_PARTIAL -1 /* only part of a token */ ------------------ | Branch (7263:5): [True: 18, False: 26.9k] ------------------ 7264| 18| if (enc == parser->m_encoding) ------------------ | Branch (7264:11): [True: 18, False: 0] ------------------ 7265| 18| parser->m_eventPtr = entityTextPtr; 7266| 18| result = XML_ERROR_INVALID_TOKEN; 7267| 18| goto endEntityValue; 7268| 2| case XML_TOK_INVALID: ------------------ | | 57| 2|# define XML_TOK_INVALID 0 ------------------ | Branch (7268:5): [True: 2, False: 26.9k] ------------------ 7269| 2| if (enc == parser->m_encoding) ------------------ | Branch (7269:11): [True: 2, False: 0] ------------------ 7270| 2| parser->m_eventPtr = next; 7271| 2| result = XML_ERROR_INVALID_TOKEN; 7272| 2| goto endEntityValue; 7273| 0| default: ------------------ | Branch (7273:5): [True: 0, False: 26.9k] ------------------ 7274| | /* This default case should be unnecessary -- all the tokens 7275| | * that XmlEntityValueTok() can return have their own explicit 7276| | * cases -- but should be retained for safety. We do however 7277| | * exclude it from the coverage statistics. 7278| | * 7279| | * LCOV_EXCL_START 7280| | */ 7281| 0| if (enc == parser->m_encoding) ------------------ | Branch (7281:11): [True: 0, False: 0] ------------------ 7282| 0| parser->m_eventPtr = entityTextPtr; 7283| 0| result = XML_ERROR_UNEXPECTED_STATE; 7284| 0| goto endEntityValue; 7285| | /* LCOV_EXCL_STOP */ 7286| 26.9k| } 7287| 24.4k| entityTextPtr = next; 7288| 24.4k| } 7289| 3.72k|endEntityValue: 7290| 3.72k|# ifdef XML_DTD 7291| 3.72k| parser->m_prologState.inEntityValue = oldInEntityValue; 7292| 3.72k|# endif /* XML_DTD */ 7293| | // If 'nextPtr' is given, it should be updated during the processing 7294| 3.72k| if (nextPtr != NULL) { ------------------ | Branch (7294:7): [True: 3.72k, False: 0] ------------------ 7295| 3.72k| *nextPtr = next; 7296| 3.72k| } 7297| 3.72k| return result; 7298| 2.53k|} xmlparse.c:expat_realloc: 987| 5.02k|expat_realloc(XML_Parser parser, void *ptr, size_t size, int sourceLine) { 988| 5.02k| assert(parser != NULL); ------------------ | Branch (988:3): [True: 0, False: 5.02k] | Branch (988:3): [True: 5.02k, False: 0] ------------------ 989| | 990| 5.02k| if (ptr == NULL) { ------------------ | Branch (990:7): [True: 1.08k, False: 3.93k] ------------------ 991| 1.08k| return expat_malloc(parser, size, sourceLine); 992| 1.08k| } 993| | 994| 3.93k| if (size == 0) { ------------------ | Branch (994:7): [True: 0, False: 3.93k] ------------------ 995| 0| expat_free(parser, ptr, sourceLine); 996| 0| return NULL; 997| 0| } 998| | 999| 3.93k| const XML_Parser rootParser = getRootParserOf(parser, NULL); 1000| 3.93k| assert(rootParser->m_parentParser == NULL); ------------------ | Branch (1000:3): [True: 0, False: 3.93k] | Branch (1000:3): [True: 3.93k, False: 0] ------------------ 1001| | 1002| | // Extract original size (to the eyes of the caller) and the original 1003| | // pointer returned by malloc/realloc 1004| 3.93k| void *mallocedPtr = (char *)ptr - EXPAT_MALLOC_PADDING - sizeof(size_t); ------------------ | | 124| 3.93k|# define EXPAT_MALLOC_PADDING ((EXPAT_MALLOC_ALIGNMENT) - sizeof(size_t)) | | ------------------ | | | | 123| 3.93k|# define EXPAT_MALLOC_ALIGNMENT sizeof(union expat_align) | | ------------------ ------------------ 1005| 3.93k| const size_t prevSize = *(size_t *)mallocedPtr; 1006| | 1007| | // Classify upcoming change 1008| 3.93k| const bool isIncrease = (size > prevSize); 1009| 3.93k| const size_t absDiff 1010| 3.93k| = (size > prevSize) ? (size - prevSize) : (prevSize - size); ------------------ | Branch (1010:9): [True: 3.93k, False: 0] ------------------ 1011| | 1012| | // Ask for permission from accounting 1013| 3.93k| if (isIncrease) { ------------------ | Branch (1013:7): [True: 3.93k, False: 0] ------------------ 1014| 3.93k| if (! expat_heap_increase_tolerable(rootParser, absDiff, sourceLine)) { ------------------ | Branch (1014:9): [True: 0, False: 3.93k] ------------------ 1015| 0| return NULL; // i.e. signal violation as out-of-memory 1016| 0| } 1017| 3.93k| } 1018| | 1019| | // Detect and prevent integer overflow 1020| 3.93k| if (size > SIZE_MAX - sizeof(size_t) - EXPAT_MALLOC_PADDING) { ------------------ | | 124| 3.93k|# define EXPAT_MALLOC_PADDING ((EXPAT_MALLOC_ALIGNMENT) - sizeof(size_t)) | | ------------------ | | | | 123| 3.93k|# define EXPAT_MALLOC_ALIGNMENT sizeof(union expat_align) | | ------------------ ------------------ | Branch (1020:7): [True: 0, False: 3.93k] ------------------ 1021| 0| return NULL; 1022| 0| } 1023| | 1024| | // Actually allocate 1025| 3.93k| mallocedPtr = parser->m_mem.realloc_fcn( 1026| 3.93k| mallocedPtr, sizeof(size_t) + EXPAT_MALLOC_PADDING + size); ------------------ | | 124| 3.93k|# define EXPAT_MALLOC_PADDING ((EXPAT_MALLOC_ALIGNMENT) - sizeof(size_t)) | | ------------------ | | | | 123| 3.93k|# define EXPAT_MALLOC_ALIGNMENT sizeof(union expat_align) | | ------------------ ------------------ 1027| | 1028| 3.93k| if (mallocedPtr == NULL) { ------------------ | Branch (1028:7): [True: 0, False: 3.93k] ------------------ 1029| 0| return NULL; 1030| 0| } 1031| | 1032| | // Update accounting 1033| 3.93k| if (isIncrease) { ------------------ | Branch (1033:7): [True: 3.93k, False: 0] ------------------ 1034| 3.93k| assert(SIZE_MAX - rootParser->m_alloc_tracker.bytesAllocated >= absDiff); ------------------ | Branch (1034:5): [True: 0, False: 3.93k] | Branch (1034:5): [True: 3.93k, False: 0] ------------------ 1035| 3.93k| rootParser->m_alloc_tracker.bytesAllocated += absDiff; 1036| 3.93k| } else { // i.e. decrease 1037| 0| assert(rootParser->m_alloc_tracker.bytesAllocated >= absDiff); ------------------ | Branch (1037:5): [True: 0, False: 0] | Branch (1037:5): [True: 0, False: 0] ------------------ 1038| 0| rootParser->m_alloc_tracker.bytesAllocated -= absDiff; 1039| 0| } 1040| | 1041| | // Report as needed 1042| 3.93k| if (rootParser->m_alloc_tracker.debugLevel >= 2) { ------------------ | Branch (1042:7): [True: 0, False: 3.93k] ------------------ 1043| 0| if (rootParser->m_alloc_tracker.bytesAllocated ------------------ | Branch (1043:9): [True: 0, False: 0] ------------------ 1044| 0| > rootParser->m_alloc_tracker.peakBytesAllocated) { 1045| 0| rootParser->m_alloc_tracker.peakBytesAllocated 1046| 0| = rootParser->m_alloc_tracker.bytesAllocated; 1047| 0| } 1048| 0| expat_heap_stat(rootParser, isIncrease ? '+' : '-', absDiff, ------------------ | Branch (1048:33): [True: 0, False: 0] ------------------ 1049| 0| rootParser->m_alloc_tracker.bytesAllocated, 1050| 0| rootParser->m_alloc_tracker.peakBytesAllocated, sourceLine); 1051| 0| } 1052| | 1053| | // Update in-block recorded size 1054| 3.93k| *(size_t *)mallocedPtr = size; 1055| | 1056| 3.93k| return (char *)mallocedPtr + sizeof(size_t) + EXPAT_MALLOC_PADDING; ------------------ | | 124| 3.93k|# define EXPAT_MALLOC_PADDING ((EXPAT_MALLOC_ALIGNMENT) - sizeof(size_t)) | | ------------------ | | | | 123| 3.93k|# define EXPAT_MALLOC_ALIGNMENT sizeof(union expat_align) | | ------------------ ------------------ 1057| 3.93k|} xmlparse.c:processEntity: 6691| 704k| enum EntityType type) { 6692| 704k| OPEN_INTERNAL_ENTITY *openEntity, **openEntityList; 6693| 704k| OPEN_INTERNAL_ENTITY **const freeEntityList = &parser->m_freeEntities; 6694| 704k| switch (type) { 6695| 105k| case ENTITY_INTERNAL: ------------------ | Branch (6695:3): [True: 105k, False: 598k] ------------------ 6696| 105k| parser->m_processor = internalEntityProcessor; 6697| 105k| openEntityList = &parser->m_openInternalEntities; 6698| 105k| break; 6699| 598k| case ENTITY_ATTRIBUTE: ------------------ | Branch (6699:3): [True: 598k, False: 105k] ------------------ 6700| 598k| openEntityList = &parser->m_openAttributeEntities; 6701| 598k| break; 6702| 0| case ENTITY_VALUE: ------------------ | Branch (6702:3): [True: 0, False: 704k] ------------------ 6703| 0| openEntityList = &parser->m_openValueEntities; 6704| 0| break; 6705| | /* default case serves merely as a safety net in case of a 6706| | * wrong entityType. Therefore we exclude the following lines 6707| | * from the test coverage. 6708| | * 6709| | * LCOV_EXCL_START 6710| | */ 6711| 0| default: ------------------ | Branch (6711:3): [True: 0, False: 704k] ------------------ 6712| | // Should not reach here 6713| 0| assert(0); ------------------ | Branch (6713:5): [Folded, False: 0] | Branch (6713:5): [Folded, False: 0] ------------------ 6714| | /* LCOV_EXCL_STOP */ 6715| 704k| } 6716| | 6717| 704k| if (*freeEntityList) { ------------------ | Branch (6717:7): [True: 702k, False: 2.13k] ------------------ 6718| 702k| openEntity = *freeEntityList; 6719| 702k| *freeEntityList = openEntity->next; 6720| 702k| } else { 6721| 2.13k| openEntity = MALLOC(parser, sizeof(OPEN_INTERNAL_ENTITY)); ------------------ | | 835| 2.13k|# define MALLOC(parser, s) (expat_malloc((parser), (s), __LINE__)) ------------------ 6722| 2.13k| if (! openEntity) ------------------ | Branch (6722:9): [True: 0, False: 2.13k] ------------------ 6723| 0| return XML_ERROR_NO_MEMORY; 6724| 2.13k| } 6725| 704k| entity->open = true; 6726| 704k| entity->hasMore = true; 6727| 704k|#if XML_GE == 1 6728| 704k| entityTrackingOnOpen(parser, entity, __LINE__); 6729| 704k|#endif 6730| 704k| entity->processed = 0; 6731| 704k| openEntity->next = *openEntityList; 6732| 704k| *openEntityList = openEntity; 6733| 704k| openEntity->entity = entity; 6734| 704k| openEntity->type = type; 6735| 704k| openEntity->startTagLevel = parser->m_tagLevel; 6736| 704k| openEntity->betweenDecl = betweenDecl; 6737| 704k| openEntity->internalEventPtr = NULL; 6738| 704k| openEntity->internalEventEndPtr = NULL; 6739| | 6740| | // Only internal entities make use of the reenter flag 6741| | // therefore no need to set it for other entity types 6742| 704k| if (type == ENTITY_INTERNAL) { ------------------ | Branch (6742:7): [True: 105k, False: 598k] ------------------ 6743| 105k| triggerReenter(parser); 6744| 105k| } 6745| 704k| return XML_ERROR_NONE; 6746| 704k|} xmlparse.c:internalEntityProcessor: 6750| 304k| const char **nextPtr) { 6751| 304k| UNUSED_P(s); ------------------ | | 101| 304k|# define UNUSED_P(p) (void)p ------------------ 6752| 304k| UNUSED_P(end); ------------------ | | 101| 304k|# define UNUSED_P(p) (void)p ------------------ 6753| 304k| UNUSED_P(nextPtr); ------------------ | | 101| 304k|# define UNUSED_P(p) (void)p ------------------ 6754| 304k| ENTITY *entity; 6755| 304k| const char *textStart, *textEnd; 6756| 304k| const char *next; 6757| 304k| enum XML_Error result; 6758| 304k| OPEN_INTERNAL_ENTITY *openEntity = parser->m_openInternalEntities; 6759| 304k| if (! openEntity) ------------------ | Branch (6759:7): [True: 0, False: 304k] ------------------ 6760| 0| return XML_ERROR_UNEXPECTED_STATE; 6761| | 6762| 304k| entity = openEntity->entity; 6763| | 6764| | // This will return early 6765| 304k| if (entity->hasMore) { ------------------ | Branch (6765:7): [True: 198k, False: 105k] ------------------ 6766| 198k| textStart = ((const char *)entity->textPtr) + entity->processed; 6767| 198k| textEnd = (const char *)(entity->textPtr + entity->textLen); 6768| | /* Set a safe default value in case 'next' does not get set */ 6769| 198k| next = textStart; 6770| | 6771| 198k| if (entity->is_param) { ------------------ | Branch (6771:9): [True: 0, False: 198k] ------------------ 6772| 0| int tok 6773| 0| = XmlPrologTok(parser->m_internalEncoding, textStart, textEnd, &next); ------------------ | | 226| 0| XmlTok(enc, XML_PROLOG_STATE, ptr, end, nextTokPtr) | | ------------------ | | | | 223| 0| (((enc)->scanners[state])(enc, ptr, end, nextTokPtr)) | | ------------------ ------------------ 6774| 0| result = doProlog(parser, parser->m_internalEncoding, textStart, textEnd, 6775| 0| tok, next, &next, XML_FALSE, XML_FALSE, ------------------ | | 64| 0|# define XML_FALSE ((XML_Bool)0) ------------------ tok, next, &next, XML_FALSE, XML_FALSE, ------------------ | | 64| 0|# define XML_FALSE ((XML_Bool)0) ------------------ 6776| 0| XML_ACCOUNT_ENTITY_EXPANSION); 6777| 198k| } else { 6778| 198k| result = doContent(parser, openEntity->startTagLevel, 6779| 198k| parser->m_internalEncoding, textStart, textEnd, &next, 6780| 198k| XML_FALSE, XML_ACCOUNT_ENTITY_EXPANSION); ------------------ | | 64| 198k|# define XML_FALSE ((XML_Bool)0) ------------------ 6781| 198k| } 6782| | 6783| 198k| if (result != XML_ERROR_NONE) ------------------ | Branch (6783:9): [True: 93, False: 198k] ------------------ 6784| 93| return result; 6785| | // Check if entity is complete, if not, mark down how much of it is 6786| | // processed 6787| 198k| if (textEnd != next ------------------ | Branch (6787:9): [True: 92.6k, False: 105k] ------------------ 6788| 92.6k| && (parser->m_parsingStatus.parsing == XML_SUSPENDED ------------------ | Branch (6788:13): [True: 0, False: 92.6k] ------------------ 6789| 92.6k| || (parser->m_parsingStatus.parsing == XML_PARSING ------------------ | Branch (6789:17): [True: 92.6k, False: 0] ------------------ 6790| 92.6k| && parser->m_reenter))) { ------------------ | Branch (6790:20): [True: 92.6k, False: 0] ------------------ 6791| 92.6k| entity->processed = next - (const char *)entity->textPtr; 6792| 92.6k| return result; 6793| 92.6k| } 6794| | 6795| | // Entity is complete. We cannot close it here since we need to first 6796| | // process its possible inner entities (which are added to the 6797| | // m_openInternalEntities during doProlog or doContent calls above) 6798| 105k| entity->hasMore = false; 6799| 105k| if (! entity->is_param ------------------ | Branch (6799:9): [True: 105k, False: 0] ------------------ 6800| 105k| && (openEntity->startTagLevel != parser->m_tagLevel)) { ------------------ | Branch (6800:12): [True: 3, False: 105k] ------------------ 6801| 3| return XML_ERROR_ASYNC_ENTITY; 6802| 3| } 6803| 105k| triggerReenter(parser); 6804| 105k| return result; 6805| 105k| } // End of entity processing, "if" block will return here 6806| | 6807| | // Remove fully processed openEntity from open entity list. 6808| 105k|#if XML_GE == 1 6809| 105k| entityTrackingOnClose(parser, entity, __LINE__); 6810| 105k|#endif 6811| | // openEntity is m_openInternalEntities' head, as we set it at the start of 6812| | // this function and we skipped doProlog and doContent calls with hasMore set 6813| | // to false. This means we can directly remove the head of 6814| | // m_openInternalEntities 6815| 105k| assert(parser->m_openInternalEntities == openEntity); ------------------ | Branch (6815:3): [True: 0, False: 105k] | Branch (6815:3): [True: 105k, False: 0] ------------------ 6816| 105k| entity->open = false; 6817| 105k| parser->m_openInternalEntities = parser->m_openInternalEntities->next; 6818| | 6819| | /* put openEntity back in list of free instances */ 6820| 105k| openEntity->next = parser->m_freeEntities; 6821| 105k| parser->m_freeEntities = openEntity; 6822| | 6823| 105k| if (parser->m_openInternalEntities == NULL) { ------------------ | Branch (6823:7): [True: 9.11k, False: 96.6k] ------------------ 6824| 9.11k| parser->m_processor = entity->is_param ? prologProcessor : contentProcessor; ------------------ | Branch (6824:27): [True: 0, False: 9.11k] ------------------ 6825| 9.11k| } 6826| 105k| triggerReenter(parser); 6827| 105k| return XML_ERROR_NONE; 6828| 105k|} xmlparse.c:triggerReenter: 2617| 317k|triggerReenter(XML_Parser parser) { 2618| 317k| parser->m_reenter = XML_TRUE; ------------------ | | 63| 317k|# define XML_TRUE ((XML_Bool)1) ------------------ 2619| 317k|} xmlparse.c:entityTrackingOnOpen: 9120| 704k|entityTrackingOnOpen(XML_Parser originParser, ENTITY *entity, int sourceLine) { 9121| 704k| const XML_Parser rootParser = getRootParserOf(originParser, NULL); 9122| 704k| assert(! rootParser->m_parentParser); ------------------ | Branch (9122:3): [True: 0, False: 704k] | Branch (9122:3): [True: 704k, False: 0] ------------------ 9123| | 9124| 704k| rootParser->m_entity_stats.countEverOpened++; 9125| 704k| rootParser->m_entity_stats.currentDepth++; 9126| 704k| if (rootParser->m_entity_stats.currentDepth ------------------ | Branch (9126:7): [True: 2.13k, False: 702k] ------------------ 9127| 704k| > rootParser->m_entity_stats.maximumDepthSeen) { 9128| 2.13k| rootParser->m_entity_stats.maximumDepthSeen++; 9129| 2.13k| } 9130| | 9131| 704k| entityTrackingReportStats(rootParser, entity, "OPEN ", sourceLine); 9132| 704k|} xmlparse.c:entityTrackingReportStats: 9086| 1.40M| const char *action, int sourceLine) { 9087| 1.40M| assert(! rootParser->m_parentParser); ------------------ | Branch (9087:3): [True: 0, False: 1.40M] | Branch (9087:3): [True: 1.40M, False: 0] ------------------ 9088| 1.40M| if (rootParser->m_entity_stats.debugLevel == 0u) ------------------ | Branch (9088:7): [True: 1.40M, False: 0] ------------------ 9089| 1.40M| return; 9090| | 9091| |# if defined(XML_UNICODE) 9092| | const char *const entityName = "[..]"; 9093| |# else 9094| 0| const char *const entityName = entity->name; 9095| 0|# endif 9096| | 9097| 0| const bool limitingWanted = rootParser->m_entity_stats.debugLevel < 2; 9098| 0| const int maxLimitedDepth = 10; // somewhat arbitrary 9099| 0| const int candidateIndentDepth 9100| 0| = (int)rootParser->m_entity_stats.currentDepth - 1; 9101| 0| const bool limitingNeeded 9102| 0| = limitingWanted && (candidateIndentDepth > maxLimitedDepth); ------------------ | Branch (9102:9): [True: 0, False: 0] | Branch (9102:27): [True: 0, False: 0] ------------------ 9103| 0| const char *const ellipisOrEmpty = limitingNeeded ? " [..] " : ""; ------------------ | Branch (9103:38): [True: 0, False: 0] ------------------ 9104| 0| const int indentDepth 9105| 0| = limitingNeeded ? (maxLimitedDepth - /* make space for ellipis */ 2) ------------------ | Branch (9105:9): [True: 0, False: 0] ------------------ 9106| 0| : candidateIndentDepth; 9107| | 9108| 0| fprintf( 9109| 0| stderr, 9110| 0| "expat: Entities(%p): Count %9u, depth %2u/%2u %*s%s%s%s; %s length " EXPAT_FMT_SIZE_T( 9111| 0| "") " (xmlparse.c:%d)\n", 9112| 0| (void *)rootParser, rootParser->m_entity_stats.countEverOpened, 9113| 0| rootParser->m_entity_stats.currentDepth, 9114| 0| rootParser->m_entity_stats.maximumDepthSeen, indentDepth * 2, "", 9115| 0| ellipisOrEmpty, entity->is_param ? "%" : "&", entityName, action, ------------------ | Branch (9115:23): [True: 0, False: 0] ------------------ 9116| 0| entity->textLen, sourceLine); 9117| 0|} xmlparse.c:entityTrackingOnClose: 9135| 704k|entityTrackingOnClose(XML_Parser originParser, ENTITY *entity, int sourceLine) { 9136| 704k| const XML_Parser rootParser = getRootParserOf(originParser, NULL); 9137| 704k| assert(! rootParser->m_parentParser); ------------------ | Branch (9137:3): [True: 0, False: 704k] | Branch (9137:3): [True: 704k, False: 0] ------------------ 9138| | 9139| 704k| entityTrackingReportStats(rootParser, entity, "CLOSE", sourceLine); 9140| 704k| rootParser->m_entity_stats.currentDepth--; 9141| 704k|} xmlparse.c:reportProcessingInstruction: 7424| 7.48k| const char *start, const char *end) { 7425| 7.48k| const XML_Char *target; 7426| 7.48k| XML_Char *data; 7427| 7.48k| const char *tem; 7428| 7.48k| if (! parser->m_processingInstructionHandler) { ------------------ | Branch (7428:7): [True: 7.48k, False: 0] ------------------ 7429| 7.48k| if (parser->m_defaultHandler) ------------------ | Branch (7429:9): [True: 0, False: 7.48k] ------------------ 7430| 0| reportDefault(parser, enc, start, end); 7431| 7.48k| return 1; 7432| 7.48k| } 7433| 0| start += enc->minBytesPerChar * 2; 7434| 0| tem = start + XmlNameLength(enc, start); ------------------ | | 256| 0|# define XmlNameLength(enc, ptr) (((enc)->nameLength)(enc, ptr)) ------------------ 7435| 0| target = poolStoreString(&parser->m_tempPool, enc, start, tem); 7436| 0| if (! target) ------------------ | Branch (7436:7): [True: 0, False: 0] ------------------ 7437| 0| return 0; 7438| 0| poolFinish(&parser->m_tempPool); ------------------ | | 676| 0|#define poolFinish(pool) ((pool)->start = (pool)->ptr) ------------------ 7439| 0| data = poolStoreString(&parser->m_tempPool, enc, XmlSkipS(enc, tem), ------------------ | | 258| 0|# define XmlSkipS(enc, ptr) (((enc)->skipS)(enc, ptr)) ------------------ 7440| 0| end - enc->minBytesPerChar * 2); 7441| 0| if (! data) ------------------ | Branch (7441:7): [True: 0, False: 0] ------------------ 7442| 0| return 0; 7443| 0| normalizeLines(data); 7444| 0| beforeHandler(parser); 7445| 0| parser->m_processingInstructionHandler(parser->m_handlerArg, target, data); 7446| 0| afterHandler(parser); 7447| 0| poolClear(&parser->m_tempPool); 7448| 0| return 1; 7449| 0|} xmlparse.c:reportComment: 7453| 1.52k| const char *end) { 7454| 1.52k| XML_Char *data; 7455| 1.52k| if (! parser->m_commentHandler) { ------------------ | Branch (7455:7): [True: 1.52k, False: 0] ------------------ 7456| 1.52k| if (parser->m_defaultHandler) ------------------ | Branch (7456:9): [True: 0, False: 1.52k] ------------------ 7457| 0| reportDefault(parser, enc, start, end); 7458| 1.52k| return 1; 7459| 1.52k| } 7460| 0| data = poolStoreString(&parser->m_tempPool, enc, 7461| 0| start + enc->minBytesPerChar * 4, 7462| 0| end - enc->minBytesPerChar * 3); 7463| 0| if (! data) ------------------ | Branch (7463:7): [True: 0, False: 0] ------------------ 7464| 0| return 0; 7465| 0| normalizeLines(data); 7466| 0| beforeHandler(parser); 7467| 0| parser->m_commentHandler(parser->m_handlerArg, data); 7468| 0| afterHandler(parser); 7469| 0| poolClear(&parser->m_tempPool); 7470| 0| return 1; 7471| 0|} xmlparse.c:destroyBindings: 1853| 52.1k|destroyBindings(BINDING *bindings, XML_Parser parser) { 1854| 68.6k| for (;;) { 1855| 68.6k| BINDING *b = bindings; 1856| 68.6k| if (! b) ------------------ | Branch (1856:9): [True: 52.1k, False: 16.5k] ------------------ 1857| 52.1k| break; 1858| 16.5k| bindings = b->nextTagBinding; 1859| 16.5k| FREE(parser, b->uri); ------------------ | | 837| 16.5k|# define FREE(parser, p) (expat_free((parser), (p), __LINE__)) ------------------ 1860| 16.5k| FREE(parser, b); ------------------ | | 837| 16.5k|# define FREE(parser, p) (expat_free((parser), (p), __LINE__)) ------------------ 1861| 16.5k| } 1862| 52.1k|} xmlparse.c:ENTROPY_DEBUG: 1111| 12.0k|ENTROPY_DEBUG(const char *label, struct sipkey entropy_128) { 1112| 12.0k| if (getDebugLevel("EXPAT_ENTROPY_DEBUG", 0) >= 1u) { ------------------ | Branch (1112:7): [True: 0, False: 12.0k] ------------------ 1113| | fprintf(stderr, 1114| 0| "expat: Entropy: %s --> [0x" EXPAT_FMT_LLX( 1115| 0| "016") ", 0x" EXPAT_FMT_LLX("016") "] (16 bytes)\n", 1116| 0| label, (unsigned long long)entropy_128.k[0], 1117| 0| (unsigned long long)entropy_128.k[1]); 1118| 0| } 1119| 12.0k| return entropy_128; 1120| 12.0k|} xmlparse.c:startParsing: 1276| 12.0k|startParsing(XML_Parser parser) { 1277| | /* hash functions must be initialized before setContext() is called */ 1278| 12.0k| if (parser->m_hash_secret_salt_set != XML_TRUE) { ------------------ | | 63| 12.0k|# define XML_TRUE ((XML_Bool)1) ------------------ | Branch (1278:7): [True: 12.0k, False: 0] ------------------ 1279| 12.0k| parser->m_hash_secret_salt_128 = generate_hash_secret_salt(); 1280| 12.0k| parser->m_hash_secret_salt_set = XML_TRUE; ------------------ | | 63| 12.0k|# define XML_TRUE ((XML_Bool)1) ------------------ 1281| 12.0k| } 1282| 12.0k| if (parser->m_ns) { ------------------ | Branch (1282:7): [True: 4.76k, False: 7.30k] ------------------ 1283| | /* implicit context only set for root parser, since child 1284| | parsers (i.e. external entity parsers) will inherit it 1285| | */ 1286| 4.76k| return setContext(parser, implicitContext); 1287| 4.76k| } 1288| 7.30k| return XML_TRUE; ------------------ | | 63| 7.30k|# define XML_TRUE ((XML_Bool)1) ------------------ 1289| 12.0k|} xmlparse.c:generate_hash_secret_salt: 1123| 12.0k|generate_hash_secret_salt(void) { 1124| 12.0k| struct sipkey entropy; 1125| | 1126| | /* "Failproof" high quality providers: */ 1127| 12.0k|#if defined(HAVE_ARC4RANDOM_BUF) 1128| 12.0k| writeRandomBytes_arc4random_buf(&entropy, sizeof(entropy)); 1129| 12.0k| return ENTROPY_DEBUG("arc4random_buf", entropy); 1130| |#elif defined(HAVE_ARC4RANDOM) 1131| | writeRandomBytes_arc4random(&entropy, sizeof(entropy)); 1132| | return ENTROPY_DEBUG("arc4random", entropy); 1133| |#else 1134| | /* Try high quality providers first .. */ 1135| |# ifdef _WIN32 1136| | if (writeRandomBytes_rand_s(&entropy, sizeof(entropy))) { 1137| | return ENTROPY_DEBUG("rand_s", entropy); 1138| | } 1139| |# elif defined(HAVE_GETENTROPY) 1140| | if (writeRandomBytes_getentropy(&entropy, sizeof(entropy))) { 1141| | return ENTROPY_DEBUG("getentropy", entropy); 1142| | } 1143| | errno = 0; 1144| |# elif defined(HAVE_GETRANDOM) || defined(HAVE_SYSCALL_GETRANDOM) 1145| | if (writeRandomBytes_getrandom_nonblock(&entropy, sizeof(entropy))) { 1146| | return ENTROPY_DEBUG("getrandom", entropy); 1147| | } 1148| |# endif 1149| |# if ! defined(_WIN32) && defined(XML_DEV_URANDOM) 1150| | if (writeRandomBytes_dev_urandom(&entropy, sizeof(entropy))) { 1151| | return ENTROPY_DEBUG("/dev/urandom", entropy); 1152| | } 1153| |# endif /* ! defined(_WIN32) && defined(XML_DEV_URANDOM) */ 1154| | /* .. and self-made low quality for backup: */ 1155| | 1156| | entropy.k[0] = 0; 1157| | entropy.k[1] = gather_time_entropy(); 1158| |# if ! defined(__wasi__) 1159| | /* Process ID is 0 bits entropy if attacker has local access */ 1160| | entropy.k[1] ^= getpid(); 1161| |# endif 1162| | 1163| | /* Factors are 2^31-1 and 2^61-1 (Mersenne primes M31 and M61) */ 1164| | if (sizeof(unsigned long) == 4) { 1165| | entropy.k[1] *= 2147483647; 1166| | return ENTROPY_DEBUG("fallback(4)", entropy); 1167| | } else { 1168| | entropy.k[1] *= 2305843009213693951ULL; 1169| | return ENTROPY_DEBUG("fallback(8)", entropy); 1170| | } 1171| |#endif 1172| 12.0k|} xmlparse.c:callProcessor: 1212| 12.0k| const char **endPtr) { 1213| 12.0k| const size_t have_now = EXPAT_SAFE_PTR_DIFF(end, start); ------------------ | | 229| 12.0k|#define EXPAT_SAFE_PTR_DIFF(p, q) (((p) && (q)) ? ((p) - (q)) : 0) | | ------------------ | | | Branch (229:37): [True: 12.0k, False: 0] | | | Branch (229:44): [True: 12.0k, False: 0] | | ------------------ ------------------ 1214| | 1215| 12.0k| if (parser->m_reparseDeferralEnabled ------------------ | Branch (1215:7): [True: 12.0k, False: 0] ------------------ 1216| 12.0k| && ! parser->m_parsingStatus.finalBuffer) { ------------------ | Branch (1216:10): [True: 0, False: 12.0k] ------------------ 1217| | // Heuristic: don't try to parse a partial token again until the amount of 1218| | // available data has increased significantly. 1219| 0| const size_t had_before = parser->m_partialTokenBytesBefore; 1220| | // ...but *do* try anyway if we're close to causing a reallocation. 1221| 0| size_t available_buffer 1222| 0| = EXPAT_SAFE_PTR_DIFF(parser->m_bufferPtr, parser->m_buffer); ------------------ | | 229| 0|#define EXPAT_SAFE_PTR_DIFF(p, q) (((p) && (q)) ? ((p) - (q)) : 0) | | ------------------ | | | Branch (229:37): [True: 0, False: 0] | | | Branch (229:44): [True: 0, False: 0] | | ------------------ ------------------ 1223| 0|#if XML_CONTEXT_BYTES > 0 1224| 0| available_buffer -= EXPAT_MIN(available_buffer, XML_CONTEXT_BYTES); ------------------ | | 231| 0|#define EXPAT_MIN(a, b) (((a) < (b)) ? (a) : (b)) | | ------------------ | | | Branch (231:26): [True: 0, False: 0] | | ------------------ ------------------ 1225| 0|#endif 1226| 0| available_buffer 1227| 0| += EXPAT_SAFE_PTR_DIFF(parser->m_bufferLim, parser->m_bufferEnd); ------------------ | | 229| 0|#define EXPAT_SAFE_PTR_DIFF(p, q) (((p) && (q)) ? ((p) - (q)) : 0) | | ------------------ | | | Branch (229:37): [True: 0, False: 0] | | | Branch (229:44): [True: 0, False: 0] | | ------------------ ------------------ 1228| | // m_lastBufferRequestSize is never assigned a value < 0, so the cast is ok 1229| 0| const bool enough 1230| 0| = (have_now >= 2 * had_before) ------------------ | Branch (1230:11): [True: 0, False: 0] ------------------ 1231| 0| || ((size_t)parser->m_lastBufferRequestSize > available_buffer); ------------------ | Branch (1231:14): [True: 0, False: 0] ------------------ 1232| | 1233| 0| if (! enough) { ------------------ | Branch (1233:9): [True: 0, False: 0] ------------------ 1234| 0| *endPtr = start; // callers may expect this to be set 1235| 0| return XML_ERROR_NONE; 1236| 0| } 1237| 0| } 1238| |#if defined(XML_TESTING) 1239| | g_bytesScanned += (unsigned)have_now; 1240| |#endif 1241| | // Run in a loop to eliminate dangerous recursion depths 1242| 12.0k| enum XML_Error ret; 1243| 12.0k| *endPtr = start; 1244| 325k| while (1) { ------------------ | Branch (1244:10): [True: 325k, Folded] ------------------ 1245| | // Use endPtr as the new start in each iteration, since it will 1246| | // be set to the next start point by m_processor. 1247| 325k| ret = parser->m_processor(parser, *endPtr, end, endPtr); 1248| | 1249| | // Make parsing status (and in particular XML_SUSPENDED) take 1250| | // precedence over re-enter flag when they disagree 1251| 325k| if (parser->m_parsingStatus.parsing != XML_PARSING) { ------------------ | Branch (1251:9): [True: 0, False: 325k] ------------------ 1252| 0| parser->m_reenter = XML_FALSE; ------------------ | | 64| 0|# define XML_FALSE ((XML_Bool)0) ------------------ 1253| 0| } 1254| | 1255| 325k| if (! parser->m_reenter) { ------------------ | Branch (1255:9): [True: 12.0k, False: 313k] ------------------ 1256| 12.0k| break; 1257| 12.0k| } 1258| | 1259| 313k| parser->m_reenter = XML_FALSE; ------------------ | | 64| 313k|# define XML_FALSE ((XML_Bool)0) ------------------ 1260| 313k| if (ret != XML_ERROR_NONE) ------------------ | Branch (1260:9): [True: 3, False: 313k] ------------------ 1261| 3| return ret; 1262| 313k| } 1263| | 1264| 12.0k| if (ret == XML_ERROR_NONE) { ------------------ | Branch (1264:7): [True: 251, False: 11.8k] ------------------ 1265| | // if we consumed nothing, remember what we had on this parse attempt. 1266| 251| if (*endPtr == start) { ------------------ | Branch (1266:9): [True: 0, False: 251] ------------------ 1267| 0| parser->m_partialTokenBytesBefore = have_now; 1268| 251| } else { 1269| 251| parser->m_partialTokenBytesBefore = 0; 1270| 251| } 1271| 251| } 1272| 12.0k| return ret; 1273| 12.0k|} xmlparse.c:setParserBuffer: 2500| 12.0k|setParserBuffer(XML_Parser parser, char *newBuf, int newBufSize, int keep) { 2501| 12.0k| parser->m_bufferLim = newBuf + newBufSize; 2502| 12.0k| if (parser->m_bufferPtr) { ------------------ | Branch (2502:7): [True: 0, False: 12.0k] ------------------ 2503| 0| const int parsing 2504| 0| = (int)EXPAT_SAFE_PTR_DIFF(parser->m_bufferEnd, parser->m_bufferPtr); ------------------ | | 229| 0|#define EXPAT_SAFE_PTR_DIFF(p, q) (((p) && (q)) ? ((p) - (q)) : 0) | | ------------------ | | | Branch (229:37): [True: 0, False: 0] | | | Branch (229:44): [True: 0, False: 0] | | ------------------ ------------------ 2505| 0| memcpy(newBuf, parser->m_bufferPtr - keep, parsing + keep); 2506| | // NOTE: We are avoiding FREE(..) here because parser->m_buffer 2507| | // is not being allocated with MALLOC(..) but with plain 2508| | // .malloc_fcn(..). 2509| 0| parser->m_mem.free_fcn(parser->m_buffer); 2510| 0| parser->m_buffer = newBuf; 2511| 0| parser->m_bufferEnd = newBuf + parsing + keep; 2512| 0| parser->m_bufferPtr = newBuf + keep; 2513| 12.0k| } else { 2514| | /* This must be a brand new buffer with no data in it yet */ 2515| 12.0k| parser->m_buffer = newBuf; 2516| 12.0k| parser->m_bufferEnd = newBuf; 2517| 12.0k| parser->m_bufferPtr = newBuf; 2518| 12.0k| } 2519| 12.0k|} xmlparse.c:setContext: 7771| 4.76k|setContext(XML_Parser parser, const XML_Char *context) { 7772| 4.76k| if (context == NULL) { ------------------ | Branch (7772:7): [True: 0, False: 4.76k] ------------------ 7773| 0| return XML_FALSE; ------------------ | | 64| 0|# define XML_FALSE ((XML_Bool)0) ------------------ 7774| 0| } 7775| | 7776| 4.76k| DTD *const dtd = parser->m_dtd; /* save one level of indirection */ 7777| 4.76k| const XML_Char *s = context; 7778| | 7779| 23.8k| while (*context != XML_T('\0')) { ------------------ | | 220| 23.8k|# define XML_T(x) x ------------------ | Branch (7779:10): [True: 19.0k, False: 4.76k] ------------------ 7780| 19.0k| if (*s == CONTEXT_SEP || *s == XML_T('\0')) { ------------------ | | 7682| 19.0k|#define CONTEXT_SEP XML_T(ASCII_FF) | | ------------------ | | | | 220| 38.0k|# define XML_T(x) x | | ------------------ ------------------ if (*s == CONTEXT_SEP || *s == XML_T('\0')) { ------------------ | | 220| 19.0k|# define XML_T(x) x ------------------ | Branch (7780:9): [True: 0, False: 19.0k] | Branch (7780:30): [True: 0, False: 19.0k] ------------------ 7781| 0| ENTITY *e; 7782| 0| if (! poolAppendChar(&parser->m_tempPool, XML_T('\0'))) ------------------ | | 220| 0|# define XML_T(x) x ------------------ | Branch (7782:11): [True: 0, False: 0] ------------------ 7783| 0| return XML_FALSE; ------------------ | | 64| 0|# define XML_FALSE ((XML_Bool)0) ------------------ 7784| 0| e = (ENTITY *)lookup(parser, &dtd->generalEntities, 7785| 0| poolStart(&parser->m_tempPool), 0); ------------------ | | 671| 0|#define poolStart(pool) ((pool)->start) ------------------ 7786| 0| if (e) ------------------ | Branch (7786:11): [True: 0, False: 0] ------------------ 7787| 0| e->open = true; 7788| 0| if (*s != XML_T('\0')) ------------------ | | 220| 0|# define XML_T(x) x ------------------ | Branch (7788:11): [True: 0, False: 0] ------------------ 7789| 0| s++; 7790| 0| context = s; 7791| 0| poolDiscard(&parser->m_tempPool); ------------------ | | 675| 0|#define poolDiscard(pool) ((pool)->ptr = (pool)->start) ------------------ 7792| 19.0k| } else if (*s == XML_T(ASCII_EQUALS)) { ------------------ | | 220| 19.0k|# define XML_T(x) x ------------------ | Branch (7792:16): [True: 4.76k, False: 14.2k] ------------------ 7793| 4.76k| PREFIX *prefix; 7794| 4.76k| if (poolLength(&parser->m_tempPool) == 0) ------------------ | | 672| 4.76k|#define poolLength(pool) ((pool)->ptr - (pool)->start) ------------------ | Branch (7794:11): [True: 0, False: 4.76k] ------------------ 7795| 0| prefix = &dtd->defaultPrefix; 7796| 4.76k| else { 7797| 4.76k| if (! poolAppendChar(&parser->m_tempPool, XML_T('\0'))) ------------------ | | 220| 4.76k|# define XML_T(x) x ------------------ | Branch (7797:13): [True: 0, False: 4.76k] ------------------ 7798| 0| return XML_FALSE; ------------------ | | 64| 0|# define XML_FALSE ((XML_Bool)0) ------------------ 7799| 4.76k| const XML_Char *const prefixName = poolCopyStringNoFinish( 7800| 4.76k| &dtd->pool, poolStart(&parser->m_tempPool)); ------------------ | | 671| 4.76k|#define poolStart(pool) ((pool)->start) ------------------ 7801| 4.76k| if (! prefixName) { ------------------ | Branch (7801:13): [True: 0, False: 4.76k] ------------------ 7802| 0| return XML_FALSE; ------------------ | | 64| 0|# define XML_FALSE ((XML_Bool)0) ------------------ 7803| 0| } 7804| | 7805| 4.76k| prefix = (PREFIX *)lookup(parser, &dtd->prefixes, prefixName, 7806| 4.76k| sizeof(PREFIX)); 7807| | 7808| 4.76k| const bool prefixNameUsed = prefix && prefix->name == prefixName; ------------------ | Branch (7808:37): [True: 4.76k, False: 0] | Branch (7808:47): [True: 4.76k, False: 0] ------------------ 7809| 4.76k| if (prefixNameUsed) ------------------ | Branch (7809:13): [True: 4.76k, False: 0] ------------------ 7810| 4.76k| poolFinish(&dtd->pool); ------------------ | | 676| 4.76k|#define poolFinish(pool) ((pool)->start = (pool)->ptr) ------------------ 7811| 0| else 7812| 0| poolDiscard(&dtd->pool); ------------------ | | 675| 0|#define poolDiscard(pool) ((pool)->ptr = (pool)->start) ------------------ 7813| | 7814| 4.76k| if (! prefix) ------------------ | Branch (7814:13): [True: 0, False: 4.76k] ------------------ 7815| 0| return XML_FALSE; ------------------ | | 64| 0|# define XML_FALSE ((XML_Bool)0) ------------------ 7816| | 7817| 4.76k| poolDiscard(&parser->m_tempPool); ------------------ | | 675| 4.76k|#define poolDiscard(pool) ((pool)->ptr = (pool)->start) ------------------ 7818| 4.76k| } 7819| 176k| for (context = s + 1; *context != CONTEXT_SEP && *context != XML_T('\0'); ------------------ | | 7682| 176k|#define CONTEXT_SEP XML_T(ASCII_FF) | | ------------------ | | | | 220| 352k|# define XML_T(x) x | | ------------------ ------------------ for (context = s + 1; *context != CONTEXT_SEP && *context != XML_T('\0'); ------------------ | | 220| 176k|# define XML_T(x) x ------------------ | Branch (7819:29): [True: 176k, False: 0] | Branch (7819:56): [True: 171k, False: 4.76k] ------------------ 7820| 171k| context++) 7821| 171k| if (! poolAppendChar(&parser->m_tempPool, *context)) ------------------ | Branch (7821:13): [True: 0, False: 171k] ------------------ 7822| 0| return XML_FALSE; ------------------ | | 64| 4.76k|# define XML_FALSE ((XML_Bool)0) ------------------ 7823| 4.76k| if (! poolAppendChar(&parser->m_tempPool, XML_T('\0'))) ------------------ | | 220| 4.76k|# define XML_T(x) x ------------------ | Branch (7823:11): [True: 0, False: 4.76k] ------------------ 7824| 0| return XML_FALSE; ------------------ | | 64| 0|# define XML_FALSE ((XML_Bool)0) ------------------ 7825| 4.76k| if (addBinding(parser, prefix, NULL, poolStart(&parser->m_tempPool), ------------------ | | 671| 4.76k|#define poolStart(pool) ((pool)->start) ------------------ | Branch (7825:11): [True: 0, False: 4.76k] ------------------ 7826| 4.76k| &parser->m_inheritedBindings) 7827| 4.76k| != XML_ERROR_NONE) 7828| 0| return XML_FALSE; ------------------ | | 64| 0|# define XML_FALSE ((XML_Bool)0) ------------------ 7829| 4.76k| poolDiscard(&parser->m_tempPool); ------------------ | | 675| 4.76k|#define poolDiscard(pool) ((pool)->ptr = (pool)->start) ------------------ 7830| 4.76k| if (*context != XML_T('\0')) ------------------ | | 220| 4.76k|# define XML_T(x) x ------------------ | Branch (7830:11): [True: 0, False: 4.76k] ------------------ 7831| 0| ++context; 7832| 4.76k| s = context; 7833| 14.2k| } else { 7834| 14.2k| if (! poolAppendChar(&parser->m_tempPool, *s)) ------------------ | Branch (7834:11): [True: 0, False: 14.2k] ------------------ 7835| 0| return XML_FALSE; ------------------ | | 64| 0|# define XML_FALSE ((XML_Bool)0) ------------------ 7836| 14.2k| s++; 7837| 14.2k| } 7838| 19.0k| } 7839| 4.76k| return XML_TRUE; ------------------ | | 63| 4.76k|# define XML_TRUE ((XML_Bool)1) ------------------ 7840| 4.76k|} xmlparse.c:poolCopyStringNoFinish: 8477| 4.76k|poolCopyStringNoFinish(STRING_POOL *pool, const XML_Char *s) { 8478| 4.76k| const XML_Char *const original = s; 8479| 19.0k| do { 8480| 19.0k| if (! poolAppendChar(pool, *s)) { ------------------ | Branch (8480:9): [True: 0, False: 19.0k] ------------------ 8481| | // Revert any previously successful advancement 8482| 0| const ptrdiff_t advancedBy = s - original; 8483| 0| if (advancedBy > 0) ------------------ | Branch (8483:11): [True: 0, False: 0] ------------------ 8484| 0| pool->ptr -= advancedBy; 8485| 0| return NULL; 8486| 0| } 8487| 19.0k| } while (*s++); ------------------ | Branch (8487:12): [True: 14.2k, False: 4.76k] ------------------ 8488| 4.76k| return pool->start; 8489| 4.76k|} xmlparse.c:hashTableDestroy: 8371| 75.7k|hashTableDestroy(HASH_TABLE *table) { 8372| 75.7k| size_t i; 8373| 1.27M| for (i = 0; i < table->size; i++) ------------------ | Branch (8373:15): [True: 1.19M, False: 75.7k] ------------------ 8374| 1.19M| FREE(table->parser, table->v[i]); ------------------ | | 837| 1.19M|# define FREE(parser, p) (expat_free((parser), (p), __LINE__)) ------------------ 8375| 75.7k| FREE(table->parser, table->v); ------------------ | | 837| 75.7k|# define FREE(parser, p) (expat_free((parser), (p), __LINE__)) ------------------ 8376| 75.7k|} xmlparse.c:dtdDestroy: 7939| 12.0k|dtdDestroy(DTD *p, XML_Bool isDocEntity, XML_Parser parser) { 7940| 12.0k| HASH_TABLE_ITER iter; 7941| 12.0k| hashTableIterInit(&iter, &(p->elementTypes)); 7942| 27.4k| for (;;) { 7943| 27.4k| ELEMENT_TYPE *e = (ELEMENT_TYPE *)hashTableIterNext(&iter); 7944| 27.4k| if (! e) ------------------ | Branch (7944:9): [True: 12.0k, False: 15.3k] ------------------ 7945| 12.0k| break; 7946| 15.3k| hashTableDestroy(&(e->defaultAttForName)); 7947| 15.3k| FREE(parser, e->defaultAtts); ------------------ | | 837| 15.3k|# define FREE(parser, p) (expat_free((parser), (p), __LINE__)) ------------------ 7948| 15.3k| } 7949| 12.0k| hashTableDestroy(&(p->generalEntities)); 7950| 12.0k|#ifdef XML_DTD 7951| 12.0k| hashTableDestroy(&(p->paramEntities)); 7952| 12.0k|#endif /* XML_DTD */ 7953| 12.0k| hashTableDestroy(&(p->elementTypes)); 7954| 12.0k| hashTableDestroy(&(p->attributeIds)); 7955| 12.0k| hashTableDestroy(&(p->prefixes)); 7956| 12.0k| poolDestroy(&(p->pool)); 7957| 12.0k| poolDestroy(&(p->entityValuePool)); 7958| 12.0k| if (isDocEntity) { ------------------ | Branch (7958:7): [True: 12.0k, False: 0] ------------------ 7959| 12.0k| FREE(parser, p->scaffIndex); ------------------ | | 837| 12.0k|# define FREE(parser, p) (expat_free((parser), (p), __LINE__)) ------------------ 7960| 12.0k| FREE(parser, p->scaffold); ------------------ | | 837| 12.0k|# define FREE(parser, p) (expat_free((parser), (p), __LINE__)) ------------------ 7961| 12.0k| } 7962| 12.0k| FREE(parser, p); ------------------ | | 837| 12.0k|# define FREE(parser, p) (expat_free((parser), (p), __LINE__)) ------------------ 7963| 12.0k|} xmlparse.c:poolClear: 8414| 60.7k|poolClear(STRING_POOL *pool) { 8415| 60.7k| if (! pool->freeBlocks) ------------------ | Branch (8415:7): [True: 45.5k, False: 15.1k] ------------------ 8416| 45.5k| pool->freeBlocks = pool->blocks; 8417| 15.1k| else { 8418| 15.1k| BLOCK *p = pool->blocks; 8419| 16.0k| while (p) { ------------------ | Branch (8419:12): [True: 934, False: 15.1k] ------------------ 8420| 934| BLOCK *tem = p->next; 8421| 934| p->next = pool->freeBlocks; 8422| 934| pool->freeBlocks = p; 8423| 934| p = tem; 8424| 934| } 8425| 15.1k| } 8426| 60.7k| pool->blocks = NULL; 8427| 60.7k| pool->start = NULL; 8428| 60.7k| pool->ptr = NULL; 8429| | pool->end = NULL; 8430| 60.7k|} xmlparse.c:poolDestroy: 8433| 48.2k|poolDestroy(STRING_POOL *pool) { 8434| 48.2k| BLOCK *p = pool->blocks; 8435| 63.6k| while (p) { ------------------ | Branch (8435:10): [True: 15.3k, False: 48.2k] ------------------ 8436| 15.3k| BLOCK *tem = p->next; 8437| 15.3k| FREE(pool->parser, p); ------------------ | | 837| 15.3k|# define FREE(parser, p) (expat_free((parser), (p), __LINE__)) ------------------ 8438| 15.3k| p = tem; 8439| 15.3k| } 8440| 48.2k| p = pool->freeBlocks; 8441| 53.1k| while (p) { ------------------ | Branch (8441:10): [True: 4.88k, False: 48.2k] ------------------ 8442| 4.88k| BLOCK *tem = p->next; 8443| 4.88k| FREE(pool->parser, p); ------------------ | | 837| 4.88k|# define FREE(parser, p) (expat_free((parser), (p), __LINE__)) ------------------ 8444| 4.88k| p = tem; 8445| 4.88k| } 8446| 48.2k|} xmlparse.c:poolCopyString: 8466| 14.1k|poolCopyString(STRING_POOL *pool, const XML_Char *s) { 8467| 14.1k| if (! poolAppendChars(pool, s, xcslen(s) + /*null terminator*/ 1)) ------------------ | Branch (8467:7): [True: 0, False: 14.1k] ------------------ 8468| 0| return NULL; 8469| 14.1k| s = pool->start; 8470| 14.1k| poolFinish(pool); ------------------ | | 676| 14.1k|#define poolFinish(pool) ((pool)->start = (pool)->ptr) ------------------ 8471| 14.1k| return s; 8472| 14.1k|} xmlparse.c:copyString: 8912| 12.0k|copyString(const XML_Char *s, XML_Parser parser) { 8913| | /* First determine how long the string is */ 8914| 12.0k| const size_t charsRequired = xcslen(s) + /*null terminator*/ 1; 8915| | 8916| | /* Detect and prevent integer overflow */ 8917| 12.0k| if (charsRequired > SIZE_MAX / sizeof(XML_Char)) ------------------ | Branch (8917:7): [True: 0, False: 12.0k] ------------------ 8918| 0| return NULL; 8919| | 8920| 12.0k| const size_t bytesRequired = charsRequired * sizeof(XML_Char); 8921| | 8922| | /* Now allocate space for the copy */ 8923| 12.0k| XML_Char *const result = MALLOC(parser, bytesRequired); ------------------ | | 835| 12.0k|# define MALLOC(parser, s) (expat_malloc((parser), (s), __LINE__)) ------------------ 8924| | 8925| 12.0k| if (result == NULL) ------------------ | Branch (8925:7): [True: 0, False: 12.0k] ------------------ 8926| 0| return NULL; 8927| | 8928| | /* Copy the original into place */ 8929| 12.0k| memcpy(result, s, bytesRequired); 8930| | 8931| 12.0k| return result; 8932| 12.0k|} xmlparse.c:getRootParserOf: 9146| 19.2M|getRootParserOf(XML_Parser parser, unsigned int *outLevelDiff) { 9147| 19.2M| XML_Parser rootParser = parser; 9148| 19.2M| unsigned int stepsTakenUpwards = 0; 9149| 19.2M| while (rootParser->m_parentParser) { ------------------ | Branch (9149:10): [True: 0, False: 19.2M] ------------------ 9150| 0| rootParser = rootParser->m_parentParser; 9151| 0| stepsTakenUpwards++; 9152| 0| } 9153| 19.2M| assert(! rootParser->m_parentParser); ------------------ | Branch (9153:3): [True: 0, False: 19.2M] | Branch (9153:3): [True: 19.2M, False: 0] ------------------ 9154| 19.2M| if (outLevelDiff != NULL) { ------------------ | Branch (9154:7): [True: 16.5M, False: 2.74M] ------------------ 9155| 16.5M| *outLevelDiff = stepsTakenUpwards; 9156| 16.5M| } 9157| 19.2M| return rootParser; 9158| 19.2M|} XmlPrologStateInit: 1238| 12.0k|XmlPrologStateInit(PROLOG_STATE *state) { 1239| 12.0k| state->handler = prolog0; 1240| 12.0k|#ifdef XML_DTD 1241| 12.0k| state->documentEntity = 1; 1242| 12.0k| state->includeLevel = 0; 1243| 12.0k| state->inEntityValue = 0; 1244| 12.0k|#endif /* XML_DTD */ 1245| 12.0k|} xmlrole.c:prolog0: 143| 11.3k| const ENCODING *enc) { 144| 11.3k| switch (tok) { ------------------ | Branch (144:11): [True: 11.3k, False: 5] ------------------ 145| 0| case XML_TOK_PROLOG_S: ------------------ | | 82| 0|# define XML_TOK_PROLOG_S 15 ------------------ | Branch (145:3): [True: 0, False: 11.3k] ------------------ 146| 0| state->handler = prolog1; 147| 0| return XML_ROLE_NONE; 148| 481| case XML_TOK_XML_DECL: ------------------ | | 77| 481|# define XML_TOK_XML_DECL 12 /* XML decl or text decl */ ------------------ | Branch (148:3): [True: 481, False: 10.8k] ------------------ 149| 481| state->handler = prolog1; 150| 481| return XML_ROLE_XML_DECL; 151| 219| case XML_TOK_PI: ------------------ | | 76| 219|# define XML_TOK_PI 11 /* processing instruction */ ------------------ | Branch (151:3): [True: 219, False: 11.1k] ------------------ 152| 219| state->handler = prolog1; 153| 219| return XML_ROLE_PI; 154| 116| case XML_TOK_COMMENT: ------------------ | | 78| 116|# define XML_TOK_COMMENT 13 ------------------ | Branch (154:3): [True: 116, False: 11.2k] ------------------ 155| 116| state->handler = prolog1; 156| 116| return XML_ROLE_COMMENT; 157| 0| case XML_TOK_BOM: ------------------ | | 79| 0|# define XML_TOK_BOM 14 /* Byte order mark */ ------------------ | Branch (157:3): [True: 0, False: 11.3k] ------------------ 158| 0| return XML_ROLE_NONE; 159| 6.66k| case XML_TOK_DECL_OPEN: ------------------ | | 83| 6.66k|# define XML_TOK_DECL_OPEN 16 /* nameMatchesAscii)(enc, ptr1, end1, ptr2)) ------------------ | Branch (160:9): [True: 39, False: 6.62k] ------------------ 161| 6.66k| KW_DOCTYPE)) 162| 39| break; 163| 6.62k| state->handler = doctype0; 164| 6.62k| return XML_ROLE_DOCTYPE_NONE; 165| 3.84k| case XML_TOK_INSTANCE_START: ------------------ | | 96| 3.84k|# define XML_TOK_INSTANCE_START 29 ------------------ | Branch (165:3): [True: 3.84k, False: 7.48k] ------------------ 166| 3.84k| state->handler = error; 167| 3.84k| return XML_ROLE_INSTANCE_START; 168| 11.3k| } 169| 44| return common(state, tok); 170| 11.3k|} xmlrole.c:prolog1: 174| 3.00k| const ENCODING *enc) { 175| 3.00k| switch (tok) { ------------------ | Branch (175:11): [True: 2.98k, False: 25] ------------------ 176| 748| case XML_TOK_PROLOG_S: ------------------ | | 82| 748|# define XML_TOK_PROLOG_S 15 ------------------ | Branch (176:3): [True: 748, False: 2.26k] ------------------ 177| 748| return XML_ROLE_NONE; 178| 1.89k| case XML_TOK_PI: ------------------ | | 76| 1.89k|# define XML_TOK_PI 11 /* processing instruction */ ------------------ | Branch (178:3): [True: 1.89k, False: 1.11k] ------------------ 179| 1.89k| return XML_ROLE_PI; 180| 311| case XML_TOK_COMMENT: ------------------ | | 78| 311|# define XML_TOK_COMMENT 13 ------------------ | Branch (180:3): [True: 311, False: 2.69k] ------------------ 181| 311| return XML_ROLE_COMMENT; 182| 0| case XML_TOK_BOM: ------------------ | | 79| 0|# define XML_TOK_BOM 14 /* Byte order mark */ ------------------ | Branch (182:3): [True: 0, False: 3.00k] ------------------ 183| | /* This case can never arise. To reach this role function, the 184| | * parse must have passed through prolog0 and therefore have had 185| | * some form of input, even if only a space. At that point, a 186| | * byte order mark is no longer a valid character (though 187| | * technically it should be interpreted as a non-breaking space), 188| | * so will be rejected by the tokenizing stages. 189| | */ 190| 0| return XML_ROLE_NONE; /* LCOV_EXCL_LINE */ 191| 10| case XML_TOK_DECL_OPEN: ------------------ | | 83| 10|# define XML_TOK_DECL_OPEN 16 /* nameMatchesAscii)(enc, ptr1, end1, ptr2)) ------------------ | Branch (192:9): [True: 4, False: 6] ------------------ 193| 10| KW_DOCTYPE)) 194| 4| break; 195| 6| state->handler = doctype0; 196| 6| return XML_ROLE_DOCTYPE_NONE; 197| 20| case XML_TOK_INSTANCE_START: ------------------ | | 96| 20|# define XML_TOK_INSTANCE_START 29 ------------------ | Branch (197:3): [True: 20, False: 2.98k] ------------------ 198| 20| state->handler = error; 199| 20| return XML_ROLE_INSTANCE_START; 200| 3.00k| } 201| 29| return common(state, tok); 202| 3.00k|} xmlrole.c:doctype0: 226| 12.8k| const ENCODING *enc) { 227| 12.8k| UNUSED_P(ptr); ------------------ | | 101| 12.8k|# define UNUSED_P(p) (void)p ------------------ 228| 12.8k| UNUSED_P(end); ------------------ | | 101| 12.8k|# define UNUSED_P(p) (void)p ------------------ 229| 12.8k| UNUSED_P(enc); ------------------ | | 101| 12.8k|# define UNUSED_P(p) (void)p ------------------ 230| 12.8k| switch (tok) { ------------------ | Branch (230:11): [True: 12.6k, False: 203] ------------------ 231| 6.62k| case XML_TOK_PROLOG_S: ------------------ | | 82| 6.62k|# define XML_TOK_PROLOG_S 15 ------------------ | Branch (231:3): [True: 6.62k, False: 6.26k] ------------------ 232| 6.62k| return XML_ROLE_DOCTYPE_NONE; 233| 6.04k| case XML_TOK_NAME: ------------------ | | 85| 6.04k|# define XML_TOK_NAME 18 ------------------ | Branch (233:3): [True: 6.04k, False: 6.85k] ------------------ 234| 6.06k| case XML_TOK_PREFIXED_NAME: ------------------ | | 118| 6.06k|# define XML_TOK_PREFIXED_NAME 41 ------------------ | Branch (234:3): [True: 24, False: 12.8k] ------------------ 235| 6.06k| state->handler = doctype1; 236| 6.06k| return XML_ROLE_DOCTYPE_NAME; 237| 12.8k| } 238| 203| return common(state, tok); 239| 12.8k|} xmlrole.c:doctype1: 243| 8.08k| const ENCODING *enc) { 244| 8.08k| switch (tok) { ------------------ | Branch (244:11): [True: 8.06k, False: 11] ------------------ 245| 2.01k| case XML_TOK_PROLOG_S: ------------------ | | 82| 2.01k|# define XML_TOK_PROLOG_S 15 ------------------ | Branch (245:3): [True: 2.01k, False: 6.06k] ------------------ 246| 2.01k| return XML_ROLE_DOCTYPE_NONE; 247| 3.26k| case XML_TOK_OPEN_BRACKET: ------------------ | | 92| 3.26k|# define XML_TOK_OPEN_BRACKET 25 ------------------ | Branch (247:3): [True: 3.26k, False: 4.81k] ------------------ 248| 3.26k| state->handler = internalSubset; 249| 3.26k| return XML_ROLE_DOCTYPE_INTERNAL_SUBSET; 250| 2.38k| case XML_TOK_DECL_CLOSE: ------------------ | | 84| 2.38k|# define XML_TOK_DECL_CLOSE 17 /* > */ ------------------ | Branch (250:3): [True: 2.38k, False: 5.70k] ------------------ 251| 2.38k| state->handler = prolog2; 252| 2.38k| return XML_ROLE_DOCTYPE_CLOSE; 253| 409| case XML_TOK_NAME: ------------------ | | 85| 409|# define XML_TOK_NAME 18 ------------------ | Branch (253:3): [True: 409, False: 7.67k] ------------------ 254| 409| if (XmlNameMatchesAscii(enc, ptr, end, KW_SYSTEM)) { ------------------ | | 254| 409| (((enc)->nameMatchesAscii)(enc, ptr1, end1, ptr2)) | | ------------------ | | | Branch (254:5): [True: 142, False: 267] | | ------------------ ------------------ 255| 142| state->handler = doctype3; 256| 142| return XML_ROLE_DOCTYPE_NONE; 257| 142| } 258| 267| if (XmlNameMatchesAscii(enc, ptr, end, KW_PUBLIC)) { ------------------ | | 254| 267| (((enc)->nameMatchesAscii)(enc, ptr1, end1, ptr2)) | | ------------------ | | | Branch (254:5): [True: 256, False: 11] | | ------------------ ------------------ 259| 256| state->handler = doctype2; 260| 256| return XML_ROLE_DOCTYPE_NONE; 261| 256| } 262| 11| break; 263| 8.08k| } 264| 22| return common(state, tok); 265| 8.08k|} xmlrole.c:internalSubset: 336| 12.5k| const ENCODING *enc) { 337| 12.5k| switch (tok) { ------------------ | Branch (337:11): [True: 12.5k, False: 73] ------------------ 338| 407| case XML_TOK_PROLOG_S: ------------------ | | 82| 407|# define XML_TOK_PROLOG_S 15 ------------------ | Branch (338:3): [True: 407, False: 12.1k] ------------------ 339| 407| return XML_ROLE_NONE; 340| 9.13k| case XML_TOK_DECL_OPEN: ------------------ | | 83| 9.13k|# define XML_TOK_DECL_OPEN 16 /* nameMatchesAscii)(enc, ptr1, end1, ptr2)) | | ------------------ | | | Branch (254:5): [True: 5.16k, False: 3.97k] | | ------------------ ------------------ 342| 9.13k| KW_ENTITY)) { 343| 5.16k| state->handler = entity0; 344| 5.16k| return XML_ROLE_ENTITY_NONE; 345| 5.16k| } 346| 3.97k| if (XmlNameMatchesAscii(enc, ptr + 2 * MIN_BYTES_PER_CHAR(enc), end, ------------------ | | 254| 3.97k| (((enc)->nameMatchesAscii)(enc, ptr1, end1, ptr2)) | | ------------------ | | | Branch (254:5): [True: 1.53k, False: 2.43k] | | ------------------ ------------------ 347| 3.97k| KW_ATTLIST)) { 348| 1.53k| state->handler = attlist0; 349| 1.53k| return XML_ROLE_ATTLIST_NONE; 350| 1.53k| } 351| 2.43k| if (XmlNameMatchesAscii(enc, ptr + 2 * MIN_BYTES_PER_CHAR(enc), end, ------------------ | | 254| 2.43k| (((enc)->nameMatchesAscii)(enc, ptr1, end1, ptr2)) | | ------------------ | | | Branch (254:5): [True: 1.55k, False: 879] | | ------------------ ------------------ 352| 2.43k| KW_ELEMENT)) { 353| 1.55k| state->handler = element0; 354| 1.55k| return XML_ROLE_ELEMENT_NONE; 355| 1.55k| } 356| 879| if (XmlNameMatchesAscii(enc, ptr + 2 * MIN_BYTES_PER_CHAR(enc), end, ------------------ | | 254| 879| (((enc)->nameMatchesAscii)(enc, ptr1, end1, ptr2)) | | ------------------ | | | Branch (254:5): [True: 875, False: 4] | | ------------------ ------------------ 357| 879| KW_NOTATION)) { 358| 875| state->handler = notation0; 359| 875| return XML_ROLE_NOTATION_NONE; 360| 875| } 361| 4| break; 362| 443| case XML_TOK_PI: ------------------ | | 76| 443|# define XML_TOK_PI 11 /* processing instruction */ ------------------ | Branch (362:3): [True: 443, False: 12.1k] ------------------ 363| 443| return XML_ROLE_PI; 364| 194| case XML_TOK_COMMENT: ------------------ | | 78| 194|# define XML_TOK_COMMENT 13 ------------------ | Branch (364:3): [True: 194, False: 12.3k] ------------------ 365| 194| return XML_ROLE_COMMENT; 366| 789| case XML_TOK_PARAM_ENTITY_REF: ------------------ | | 95| 789|# define XML_TOK_PARAM_ENTITY_REF 28 ------------------ | Branch (366:3): [True: 789, False: 11.7k] ------------------ 367| 789| return XML_ROLE_PARAM_ENTITY_REF; 368| 1.53k| case XML_TOK_CLOSE_BRACKET: ------------------ | | 93| 1.53k|# define XML_TOK_CLOSE_BRACKET 26 ------------------ | Branch (368:3): [True: 1.53k, False: 11.0k] ------------------ 369| 1.53k| state->handler = doctype5; 370| 1.53k| return XML_ROLE_DOCTYPE_NONE; 371| 0| case XML_TOK_NONE: ------------------ | | 51| 0|# define XML_TOK_NONE -4 /* The string to be scanned is empty */ ------------------ | Branch (371:3): [True: 0, False: 12.5k] ------------------ 372| 0| return XML_ROLE_NONE; 373| 12.5k| } 374| 77| return common(state, tok); 375| 12.5k|} xmlrole.c:entity0: 418| 10.3k| const ENCODING *enc) { 419| 10.3k| UNUSED_P(ptr); ------------------ | | 101| 10.3k|# define UNUSED_P(p) (void)p ------------------ 420| 10.3k| UNUSED_P(end); ------------------ | | 101| 10.3k|# define UNUSED_P(p) (void)p ------------------ 421| 10.3k| UNUSED_P(enc); ------------------ | | 101| 10.3k|# define UNUSED_P(p) (void)p ------------------ 422| 10.3k| switch (tok) { ------------------ | Branch (422:11): [True: 10.3k, False: 13] ------------------ 423| 5.16k| case XML_TOK_PROLOG_S: ------------------ | | 82| 5.16k|# define XML_TOK_PROLOG_S 15 ------------------ | Branch (423:3): [True: 5.16k, False: 5.16k] ------------------ 424| 5.16k| return XML_ROLE_ENTITY_NONE; 425| 918| case XML_TOK_PERCENT: ------------------ | | 89| 918|# define XML_TOK_PERCENT 22 ------------------ | Branch (425:3): [True: 918, False: 9.40k] ------------------ 426| 918| state->handler = entity1; 427| 918| return XML_ROLE_ENTITY_NONE; 428| 4.23k| case XML_TOK_NAME: ------------------ | | 85| 4.23k|# define XML_TOK_NAME 18 ------------------ | Branch (428:3): [True: 4.23k, False: 6.09k] ------------------ 429| 4.23k| state->handler = entity2; 430| 4.23k| return XML_ROLE_GENERAL_ENTITY_NAME; 431| 10.3k| } 432| 13| return common(state, tok); 433| 10.3k|} xmlrole.c:entity1: 437| 1.83k| const ENCODING *enc) { 438| 1.83k| UNUSED_P(ptr); ------------------ | | 101| 1.83k|# define UNUSED_P(p) (void)p ------------------ 439| 1.83k| UNUSED_P(end); ------------------ | | 101| 1.83k|# define UNUSED_P(p) (void)p ------------------ 440| 1.83k| UNUSED_P(enc); ------------------ | | 101| 1.83k|# define UNUSED_P(p) (void)p ------------------ 441| 1.83k| switch (tok) { ------------------ | Branch (441:11): [True: 1.81k, False: 15] ------------------ 442| 916| case XML_TOK_PROLOG_S: ------------------ | | 82| 916|# define XML_TOK_PROLOG_S 15 ------------------ | Branch (442:3): [True: 916, False: 918] ------------------ 443| 916| return XML_ROLE_ENTITY_NONE; 444| 903| case XML_TOK_NAME: ------------------ | | 85| 903|# define XML_TOK_NAME 18 ------------------ | Branch (444:3): [True: 903, False: 931] ------------------ 445| 903| state->handler = entity7; 446| 903| return XML_ROLE_PARAM_ENTITY_NAME; 447| 1.83k| } 448| 15| return common(state, tok); 449| 1.83k|} xmlrole.c:entity7: 545| 1.77k| const ENCODING *enc) { 546| 1.77k| switch (tok) { ------------------ | Branch (546:11): [True: 1.75k, False: 18] ------------------ 547| 890| case XML_TOK_PROLOG_S: ------------------ | | 82| 890|# define XML_TOK_PROLOG_S 15 ------------------ | Branch (547:3): [True: 890, False: 886] ------------------ 548| 890| return XML_ROLE_ENTITY_NONE; 549| 350| case XML_TOK_NAME: ------------------ | | 85| 350|# define XML_TOK_NAME 18 ------------------ | Branch (549:3): [True: 350, False: 1.42k] ------------------ 550| 350| if (XmlNameMatchesAscii(enc, ptr, end, KW_SYSTEM)) { ------------------ | | 254| 350| (((enc)->nameMatchesAscii)(enc, ptr1, end1, ptr2)) | | ------------------ | | | Branch (254:5): [True: 222, False: 128] | | ------------------ ------------------ 551| 222| state->handler = entity9; 552| 222| return XML_ROLE_ENTITY_NONE; 553| 222| } 554| 128| if (XmlNameMatchesAscii(enc, ptr, end, KW_PUBLIC)) { ------------------ | | 254| 128| (((enc)->nameMatchesAscii)(enc, ptr1, end1, ptr2)) | | ------------------ | | | Branch (254:5): [True: 127, False: 1] | | ------------------ ------------------ 555| 127| state->handler = entity8; 556| 127| return XML_ROLE_ENTITY_NONE; 557| 127| } 558| 1| break; 559| 518| case XML_TOK_LITERAL: ------------------ | | 94| 518|# define XML_TOK_LITERAL 27 ------------------ | Branch (559:3): [True: 518, False: 1.25k] ------------------ 560| 518| state->handler = declClose; 561| 518| state->role_none = XML_ROLE_ENTITY_NONE; 562| 518| return XML_ROLE_ENTITY_VALUE; 563| 1.77k| } 564| 19| return common(state, tok); 565| 1.77k|} xmlrole.c:entity9: 585| 675| const ENCODING *enc) { 586| 675| UNUSED_P(ptr); ------------------ | | 101| 675|# define UNUSED_P(p) (void)p ------------------ 587| 675| UNUSED_P(end); ------------------ | | 101| 675|# define UNUSED_P(p) (void)p ------------------ 588| 675| UNUSED_P(enc); ------------------ | | 101| 675|# define UNUSED_P(p) (void)p ------------------ 589| 675| switch (tok) { ------------------ | Branch (589:11): [True: 664, False: 11] ------------------ 590| 336| case XML_TOK_PROLOG_S: ------------------ | | 82| 336|# define XML_TOK_PROLOG_S 15 ------------------ | Branch (590:3): [True: 336, False: 339] ------------------ 591| 336| return XML_ROLE_ENTITY_NONE; 592| 328| case XML_TOK_LITERAL: ------------------ | | 94| 328|# define XML_TOK_LITERAL 27 ------------------ | Branch (592:3): [True: 328, False: 347] ------------------ 593| 328| state->handler = entity10; 594| 328| return XML_ROLE_ENTITY_SYSTEM_ID; 595| 675| } 596| 11| return common(state, tok); 597| 675|} xmlrole.c:entity10: 601| 515| const ENCODING *enc) { 602| 515| UNUSED_P(ptr); ------------------ | | 101| 515|# define UNUSED_P(p) (void)p ------------------ 603| 515| UNUSED_P(end); ------------------ | | 101| 515|# define UNUSED_P(p) (void)p ------------------ 604| 515| UNUSED_P(enc); ------------------ | | 101| 515|# define UNUSED_P(p) (void)p ------------------ 605| 515| switch (tok) { ------------------ | Branch (605:11): [True: 514, False: 1] ------------------ 606| 187| case XML_TOK_PROLOG_S: ------------------ | | 82| 187|# define XML_TOK_PROLOG_S 15 ------------------ | Branch (606:3): [True: 187, False: 328] ------------------ 607| 187| return XML_ROLE_ENTITY_NONE; 608| 327| case XML_TOK_DECL_CLOSE: ------------------ | | 84| 327|# define XML_TOK_DECL_CLOSE 17 /* > */ ------------------ | Branch (608:3): [True: 327, False: 188] ------------------ 609| 327| setTopLevel(state); ------------------ | | 118| 327| ((state)->handler \ | | 119| 327| = ((state)->documentEntity ? internalSubset : externalSubset1)) | | ------------------ | | | Branch (119:9): [True: 327, False: 0] | | ------------------ ------------------ 610| 327| return XML_ROLE_ENTITY_COMPLETE; 611| 515| } 612| 1| return common(state, tok); 613| 515|} xmlrole.c:entity8: 569| 252| const ENCODING *enc) { 570| 252| UNUSED_P(ptr); ------------------ | | 101| 252|# define UNUSED_P(p) (void)p ------------------ 571| 252| UNUSED_P(end); ------------------ | | 101| 252|# define UNUSED_P(p) (void)p ------------------ 572| 252| UNUSED_P(enc); ------------------ | | 101| 252|# define UNUSED_P(p) (void)p ------------------ 573| 252| switch (tok) { ------------------ | Branch (573:11): [True: 247, False: 5] ------------------ 574| 126| case XML_TOK_PROLOG_S: ------------------ | | 82| 126|# define XML_TOK_PROLOG_S 15 ------------------ | Branch (574:3): [True: 126, False: 126] ------------------ 575| 126| return XML_ROLE_ENTITY_NONE; 576| 121| case XML_TOK_LITERAL: ------------------ | | 94| 121|# define XML_TOK_LITERAL 27 ------------------ | Branch (576:3): [True: 121, False: 131] ------------------ 577| 121| state->handler = entity9; 578| 121| return XML_ROLE_ENTITY_PUBLIC_ID; 579| 252| } 580| 5| return common(state, tok); 581| 252|} xmlrole.c:declClose: 1179| 5.97k| const ENCODING *enc) { 1180| 5.97k| UNUSED_P(ptr); ------------------ | | 101| 5.97k|# define UNUSED_P(p) (void)p ------------------ 1181| 5.97k| UNUSED_P(end); ------------------ | | 101| 5.97k|# define UNUSED_P(p) (void)p ------------------ 1182| 5.97k| UNUSED_P(enc); ------------------ | | 101| 5.97k|# define UNUSED_P(p) (void)p ------------------ 1183| 5.97k| switch (tok) { ------------------ | Branch (1183:11): [True: 5.87k, False: 99] ------------------ 1184| 302| case XML_TOK_PROLOG_S: ------------------ | | 82| 302|# define XML_TOK_PROLOG_S 15 ------------------ | Branch (1184:3): [True: 302, False: 5.67k] ------------------ 1185| 302| return state->role_none; 1186| 5.57k| case XML_TOK_DECL_CLOSE: ------------------ | | 84| 5.57k|# define XML_TOK_DECL_CLOSE 17 /* > */ ------------------ | Branch (1186:3): [True: 5.57k, False: 401] ------------------ 1187| 5.57k| setTopLevel(state); ------------------ | | 118| 5.57k| ((state)->handler \ | | 119| 5.57k| = ((state)->documentEntity ? internalSubset : externalSubset1)) | | ------------------ | | | Branch (119:9): [True: 5.57k, False: 0] | | ------------------ ------------------ 1188| 5.57k| return state->role_none; 1189| 5.97k| } 1190| 99| return common(state, tok); 1191| 5.97k|} xmlrole.c:entity2: 453| 8.40k| const ENCODING *enc) { 454| 8.40k| switch (tok) { ------------------ | Branch (454:11): [True: 8.38k, False: 24] ------------------ 455| 4.21k| case XML_TOK_PROLOG_S: ------------------ | | 82| 4.21k|# define XML_TOK_PROLOG_S 15 ------------------ | Branch (455:3): [True: 4.21k, False: 4.19k] ------------------ 456| 4.21k| return XML_ROLE_ENTITY_NONE; 457| 791| case XML_TOK_NAME: ------------------ | | 85| 791|# define XML_TOK_NAME 18 ------------------ | Branch (457:3): [True: 791, False: 7.61k] ------------------ 458| 791| if (XmlNameMatchesAscii(enc, ptr, end, KW_SYSTEM)) { ------------------ | | 254| 791| (((enc)->nameMatchesAscii)(enc, ptr1, end1, ptr2)) | | ------------------ | | | Branch (254:5): [True: 362, False: 429] | | ------------------ ------------------ 459| 362| state->handler = entity4; 460| 362| return XML_ROLE_ENTITY_NONE; 461| 362| } 462| 429| if (XmlNameMatchesAscii(enc, ptr, end, KW_PUBLIC)) { ------------------ | | 254| 429| (((enc)->nameMatchesAscii)(enc, ptr1, end1, ptr2)) | | ------------------ | | | Branch (254:5): [True: 427, False: 2] | | ------------------ ------------------ 463| 427| state->handler = entity3; 464| 427| return XML_ROLE_ENTITY_NONE; 465| 427| } 466| 2| break; 467| 3.37k| case XML_TOK_LITERAL: ------------------ | | 94| 3.37k|# define XML_TOK_LITERAL 27 ------------------ | Branch (467:3): [True: 3.37k, False: 5.03k] ------------------ 468| 3.37k| state->handler = declClose; 469| 3.37k| state->role_none = XML_ROLE_ENTITY_NONE; 470| 3.37k| return XML_ROLE_ENTITY_VALUE; 471| 8.40k| } 472| 26| return common(state, tok); 473| 8.40k|} xmlrole.c:entity4: 493| 1.52k| const ENCODING *enc) { 494| 1.52k| UNUSED_P(ptr); ------------------ | | 101| 1.52k|# define UNUSED_P(p) (void)p ------------------ 495| 1.52k| UNUSED_P(end); ------------------ | | 101| 1.52k|# define UNUSED_P(p) (void)p ------------------ 496| 1.52k| UNUSED_P(enc); ------------------ | | 101| 1.52k|# define UNUSED_P(p) (void)p ------------------ 497| 1.52k| switch (tok) { ------------------ | Branch (497:11): [True: 1.49k, False: 25] ------------------ 498| 765| case XML_TOK_PROLOG_S: ------------------ | | 82| 765|# define XML_TOK_PROLOG_S 15 ------------------ | Branch (498:3): [True: 765, False: 756] ------------------ 499| 765| return XML_ROLE_ENTITY_NONE; 500| 731| case XML_TOK_LITERAL: ------------------ | | 94| 731|# define XML_TOK_LITERAL 27 ------------------ | Branch (500:3): [True: 731, False: 790] ------------------ 501| 731| state->handler = entity5; 502| 731| return XML_ROLE_ENTITY_SYSTEM_ID; 503| 1.52k| } 504| 25| return common(state, tok); 505| 1.52k|} xmlrole.c:entity5: 509| 965| const ENCODING *enc) { 510| 965| switch (tok) { ------------------ | Branch (510:11): [True: 964, False: 1] ------------------ 511| 234| case XML_TOK_PROLOG_S: ------------------ | | 82| 234|# define XML_TOK_PROLOG_S 15 ------------------ | Branch (511:3): [True: 234, False: 731] ------------------ 512| 234| return XML_ROLE_ENTITY_NONE; 513| 508| case XML_TOK_DECL_CLOSE: ------------------ | | 84| 508|# define XML_TOK_DECL_CLOSE 17 /* > */ ------------------ | Branch (513:3): [True: 508, False: 457] ------------------ 514| 508| setTopLevel(state); ------------------ | | 118| 508| ((state)->handler \ | | 119| 508| = ((state)->documentEntity ? internalSubset : externalSubset1)) | | ------------------ | | | Branch (119:9): [True: 508, False: 0] | | ------------------ ------------------ 515| 508| return XML_ROLE_ENTITY_COMPLETE; 516| 222| case XML_TOK_NAME: ------------------ | | 85| 222|# define XML_TOK_NAME 18 ------------------ | Branch (516:3): [True: 222, False: 743] ------------------ 517| 222| if (XmlNameMatchesAscii(enc, ptr, end, KW_NDATA)) { ------------------ | | 254| 222| (((enc)->nameMatchesAscii)(enc, ptr1, end1, ptr2)) | | ------------------ | | | Branch (254:5): [True: 221, False: 1] | | ------------------ ------------------ 518| 221| state->handler = entity6; 519| 221| return XML_ROLE_ENTITY_NONE; 520| 221| } 521| 1| break; 522| 965| } 523| 2| return common(state, tok); 524| 965|} xmlrole.c:entity6: 528| 440| const ENCODING *enc) { 529| 440| UNUSED_P(ptr); ------------------ | | 101| 440|# define UNUSED_P(p) (void)p ------------------ 530| 440| UNUSED_P(end); ------------------ | | 101| 440|# define UNUSED_P(p) (void)p ------------------ 531| 440| UNUSED_P(enc); ------------------ | | 101| 440|# define UNUSED_P(p) (void)p ------------------ 532| 440| switch (tok) { ------------------ | Branch (532:11): [True: 437, False: 3] ------------------ 533| 219| case XML_TOK_PROLOG_S: ------------------ | | 82| 219|# define XML_TOK_PROLOG_S 15 ------------------ | Branch (533:3): [True: 219, False: 221] ------------------ 534| 219| return XML_ROLE_ENTITY_NONE; 535| 218| case XML_TOK_NAME: ------------------ | | 85| 218|# define XML_TOK_NAME 18 ------------------ | Branch (535:3): [True: 218, False: 222] ------------------ 536| 218| state->handler = declClose; 537| 218| state->role_none = XML_ROLE_ENTITY_NONE; 538| 218| return XML_ROLE_ENTITY_NOTATION_NAME; 539| 440| } 540| 3| return common(state, tok); 541| 440|} xmlrole.c:entity3: 477| 852| const ENCODING *enc) { 478| 852| UNUSED_P(ptr); ------------------ | | 101| 852|# define UNUSED_P(p) (void)p ------------------ 479| 852| UNUSED_P(end); ------------------ | | 101| 852|# define UNUSED_P(p) (void)p ------------------ 480| 852| UNUSED_P(enc); ------------------ | | 101| 852|# define UNUSED_P(p) (void)p ------------------ 481| 852| switch (tok) { ------------------ | Branch (481:11): [True: 846, False: 6] ------------------ 482| 425| case XML_TOK_PROLOG_S: ------------------ | | 82| 425|# define XML_TOK_PROLOG_S 15 ------------------ | Branch (482:3): [True: 425, False: 427] ------------------ 483| 425| return XML_ROLE_ENTITY_NONE; 484| 421| case XML_TOK_LITERAL: ------------------ | | 94| 421|# define XML_TOK_LITERAL 27 ------------------ | Branch (484:3): [True: 421, False: 431] ------------------ 485| 421| state->handler = entity4; 486| 421| return XML_ROLE_ENTITY_PUBLIC_ID; 487| 852| } 488| 6| return common(state, tok); 489| 852|} xmlrole.c:attlist0: 706| 3.06k| const ENCODING *enc) { 707| 3.06k| UNUSED_P(ptr); ------------------ | | 101| 3.06k|# define UNUSED_P(p) (void)p ------------------ 708| 3.06k| UNUSED_P(end); ------------------ | | 101| 3.06k|# define UNUSED_P(p) (void)p ------------------ 709| 3.06k| UNUSED_P(enc); ------------------ | | 101| 3.06k|# define UNUSED_P(p) (void)p ------------------ 710| 3.06k| switch (tok) { ------------------ | Branch (710:11): [True: 3.06k, False: 6] ------------------ 711| 1.53k| case XML_TOK_PROLOG_S: ------------------ | | 82| 1.53k|# define XML_TOK_PROLOG_S 15 ------------------ | Branch (711:3): [True: 1.53k, False: 1.53k] ------------------ 712| 1.53k| return XML_ROLE_ATTLIST_NONE; 713| 1.45k| case XML_TOK_NAME: ------------------ | | 85| 1.45k|# define XML_TOK_NAME 18 ------------------ | Branch (713:3): [True: 1.45k, False: 1.60k] ------------------ 714| 1.52k| case XML_TOK_PREFIXED_NAME: ------------------ | | 118| 1.52k|# define XML_TOK_PREFIXED_NAME 41 ------------------ | Branch (714:3): [True: 68, False: 2.99k] ------------------ 715| 1.52k| state->handler = attlist1; 716| 1.52k| return XML_ROLE_ATTLIST_ELEMENT_NAME; 717| 3.06k| } 718| 6| return common(state, tok); 719| 3.06k|} xmlrole.c:attlist1: 723| 8.82k| const ENCODING *enc) { 724| 8.82k| UNUSED_P(ptr); ------------------ | | 101| 8.82k|# define UNUSED_P(p) (void)p ------------------ 725| 8.82k| UNUSED_P(end); ------------------ | | 101| 8.82k|# define UNUSED_P(p) (void)p ------------------ 726| 8.82k| UNUSED_P(enc); ------------------ | | 101| 8.82k|# define UNUSED_P(p) (void)p ------------------ 727| 8.82k| switch (tok) { ------------------ | Branch (727:11): [True: 8.78k, False: 36] ------------------ 728| 3.88k| case XML_TOK_PROLOG_S: ------------------ | | 82| 3.88k|# define XML_TOK_PROLOG_S 15 ------------------ | Branch (728:3): [True: 3.88k, False: 4.93k] ------------------ 729| 3.88k| return XML_ROLE_ATTLIST_NONE; 730| 1.07k| case XML_TOK_DECL_CLOSE: ------------------ | | 84| 1.07k|# define XML_TOK_DECL_CLOSE 17 /* > */ ------------------ | Branch (730:3): [True: 1.07k, False: 7.74k] ------------------ 731| 1.07k| setTopLevel(state); ------------------ | | 118| 1.07k| ((state)->handler \ | | 119| 1.07k| = ((state)->documentEntity ? internalSubset : externalSubset1)) | | ------------------ | | | Branch (119:9): [True: 1.07k, False: 0] | | ------------------ ------------------ 732| 1.07k| return XML_ROLE_ATTLIST_NONE; 733| 3.44k| case XML_TOK_NAME: ------------------ | | 85| 3.44k|# define XML_TOK_NAME 18 ------------------ | Branch (733:3): [True: 3.44k, False: 5.38k] ------------------ 734| 3.82k| case XML_TOK_PREFIXED_NAME: ------------------ | | 118| 3.82k|# define XML_TOK_PREFIXED_NAME 41 ------------------ | Branch (734:3): [True: 379, False: 8.44k] ------------------ 735| 3.82k| state->handler = attlist2; 736| 3.82k| return XML_ROLE_ATTRIBUTE_NAME; 737| 8.82k| } 738| 36| return common(state, tok); 739| 8.82k|} xmlrole.c:attlist2: 743| 7.60k| const ENCODING *enc) { 744| 7.60k| switch (tok) { ------------------ | Branch (744:11): [True: 7.57k, False: 36] ------------------ 745| 3.79k| case XML_TOK_PROLOG_S: ------------------ | | 82| 3.79k|# define XML_TOK_PROLOG_S 15 ------------------ | Branch (745:3): [True: 3.79k, False: 3.80k] ------------------ 746| 3.79k| return XML_ROLE_ATTLIST_NONE; 747| 3.11k| case XML_TOK_NAME: { ------------------ | | 85| 3.11k|# define XML_TOK_NAME 18 ------------------ | Branch (747:3): [True: 3.11k, False: 4.49k] ------------------ 748| 3.11k| static const char *const types[] = { 749| 3.11k| KW_CDATA, KW_ID, KW_IDREF, KW_IDREFS, 750| 3.11k| KW_ENTITY, KW_ENTITIES, KW_NMTOKEN, KW_NMTOKENS, 751| 3.11k| }; 752| 3.11k| int i; 753| 8.61k| for (i = 0; i < (int)(sizeof(types) / sizeof(types[0])); i++) ------------------ | Branch (753:17): [True: 8.47k, False: 142] ------------------ 754| 8.47k| if (XmlNameMatchesAscii(enc, ptr, end, types[i])) { ------------------ | | 254| 8.47k| (((enc)->nameMatchesAscii)(enc, ptr1, end1, ptr2)) | | ------------------ | | | Branch (254:5): [True: 2.97k, False: 5.50k] | | ------------------ ------------------ 755| 2.97k| state->handler = attlist8; 756| 2.97k| return XML_ROLE_ATTRIBUTE_TYPE_CDATA + i; 757| 2.97k| } 758| 3.11k| } 759| 142| if (XmlNameMatchesAscii(enc, ptr, end, KW_NOTATION)) { ------------------ | | 254| 142| (((enc)->nameMatchesAscii)(enc, ptr1, end1, ptr2)) | | ------------------ | | | Branch (254:5): [True: 128, False: 14] | | ------------------ ------------------ 760| 128| state->handler = attlist5; 761| 128| return XML_ROLE_ATTLIST_NONE; 762| 128| } 763| 14| break; 764| 657| case XML_TOK_OPEN_PAREN: ------------------ | | 90| 657|# define XML_TOK_OPEN_PAREN 23 ------------------ | Branch (764:3): [True: 657, False: 6.95k] ------------------ 765| 657| state->handler = attlist3; 766| 657| return XML_ROLE_ATTLIST_NONE; 767| 7.60k| } 768| 50| return common(state, tok); 769| 7.60k|} xmlrole.c:attlist8: 862| 7.14k| const ENCODING *enc) { 863| 7.14k| switch (tok) { ------------------ | Branch (863:11): [True: 7.07k, False: 62] ------------------ 864| 3.56k| case XML_TOK_PROLOG_S: ------------------ | | 82| 3.56k|# define XML_TOK_PROLOG_S 15 ------------------ | Branch (864:3): [True: 3.56k, False: 3.57k] ------------------ 865| 3.56k| return XML_ROLE_ATTLIST_NONE; 866| 925| case XML_TOK_POUND_NAME: ------------------ | | 87| 925|# define XML_TOK_POUND_NAME 20 /* #name */ ------------------ | Branch (866:3): [True: 925, False: 6.21k] ------------------ 867| 925| if (XmlNameMatchesAscii(enc, ptr + MIN_BYTES_PER_CHAR(enc), end, ------------------ | | 254| 925| (((enc)->nameMatchesAscii)(enc, ptr1, end1, ptr2)) | | ------------------ | | | Branch (254:5): [True: 693, False: 232] | | ------------------ ------------------ 868| 925| KW_IMPLIED)) { 869| 693| state->handler = attlist1; 870| 693| return XML_ROLE_IMPLIED_ATTRIBUTE_VALUE; 871| 693| } 872| 232| if (XmlNameMatchesAscii(enc, ptr + MIN_BYTES_PER_CHAR(enc), end, ------------------ | | 254| 232| (((enc)->nameMatchesAscii)(enc, ptr1, end1, ptr2)) | | ------------------ | | | Branch (254:5): [True: 81, False: 151] | | ------------------ ------------------ 873| 232| KW_REQUIRED)) { 874| 81| state->handler = attlist1; 875| 81| return XML_ROLE_REQUIRED_ATTRIBUTE_VALUE; 876| 81| } 877| 151| if (XmlNameMatchesAscii(enc, ptr + MIN_BYTES_PER_CHAR(enc), end, ------------------ | | 254| 151| (((enc)->nameMatchesAscii)(enc, ptr1, end1, ptr2)) | | ------------------ | | | Branch (254:5): [True: 150, False: 1] | | ------------------ ------------------ 878| 151| KW_FIXED)) { 879| 150| state->handler = attlist9; 880| 150| return XML_ROLE_ATTLIST_NONE; 881| 150| } 882| 1| break; 883| 2.58k| case XML_TOK_LITERAL: ------------------ | | 94| 2.58k|# define XML_TOK_LITERAL 27 ------------------ | Branch (883:3): [True: 2.58k, False: 4.55k] ------------------ 884| 2.58k| state->handler = attlist1; 885| 2.58k| return XML_ROLE_DEFAULT_ATTRIBUTE_VALUE; 886| 7.14k| } 887| 63| return common(state, tok); 888| 7.14k|} xmlrole.c:attlist9: 892| 297| const ENCODING *enc) { 893| 297| UNUSED_P(ptr); ------------------ | | 101| 297|# define UNUSED_P(p) (void)p ------------------ 894| 297| UNUSED_P(end); ------------------ | | 101| 297|# define UNUSED_P(p) (void)p ------------------ 895| 297| UNUSED_P(enc); ------------------ | | 101| 297|# define UNUSED_P(p) (void)p ------------------ 896| 297| switch (tok) { ------------------ | Branch (896:11): [True: 283, False: 14] ------------------ 897| 147| case XML_TOK_PROLOG_S: ------------------ | | 82| 147|# define XML_TOK_PROLOG_S 15 ------------------ | Branch (897:3): [True: 147, False: 150] ------------------ 898| 147| return XML_ROLE_ATTLIST_NONE; 899| 136| case XML_TOK_LITERAL: ------------------ | | 94| 136|# define XML_TOK_LITERAL 27 ------------------ | Branch (899:3): [True: 136, False: 161] ------------------ 900| 136| state->handler = attlist1; 901| 136| return XML_ROLE_FIXED_ATTRIBUTE_VALUE; 902| 297| } 903| 14| return common(state, tok); 904| 297|} xmlrole.c:attlist5: 810| 253| const ENCODING *enc) { 811| 253| UNUSED_P(ptr); ------------------ | | 101| 253|# define UNUSED_P(p) (void)p ------------------ 812| 253| UNUSED_P(end); ------------------ | | 101| 253|# define UNUSED_P(p) (void)p ------------------ 813| 253| UNUSED_P(enc); ------------------ | | 101| 253|# define UNUSED_P(p) (void)p ------------------ 814| 253| switch (tok) { ------------------ | Branch (814:11): [True: 247, False: 6] ------------------ 815| 126| case XML_TOK_PROLOG_S: ------------------ | | 82| 126|# define XML_TOK_PROLOG_S 15 ------------------ | Branch (815:3): [True: 126, False: 127] ------------------ 816| 126| return XML_ROLE_ATTLIST_NONE; 817| 121| case XML_TOK_OPEN_PAREN: ------------------ | | 90| 121|# define XML_TOK_OPEN_PAREN 23 ------------------ | Branch (817:3): [True: 121, False: 132] ------------------ 818| 121| state->handler = attlist6; 819| 121| return XML_ROLE_ATTLIST_NONE; 820| 253| } 821| 6| return common(state, tok); 822| 253|} xmlrole.c:attlist6: 826| 1.07k| const ENCODING *enc) { 827| 1.07k| UNUSED_P(ptr); ------------------ | | 101| 1.07k|# define UNUSED_P(p) (void)p ------------------ 828| 1.07k| UNUSED_P(end); ------------------ | | 101| 1.07k|# define UNUSED_P(p) (void)p ------------------ 829| 1.07k| UNUSED_P(enc); ------------------ | | 101| 1.07k|# define UNUSED_P(p) (void)p ------------------ 830| 1.07k| switch (tok) { ------------------ | Branch (830:11): [True: 1.05k, False: 19] ------------------ 831| 260| case XML_TOK_PROLOG_S: ------------------ | | 82| 260|# define XML_TOK_PROLOG_S 15 ------------------ | Branch (831:3): [True: 260, False: 815] ------------------ 832| 260| return XML_ROLE_ATTLIST_NONE; 833| 796| case XML_TOK_NAME: ------------------ | | 85| 796|# define XML_TOK_NAME 18 ------------------ | Branch (833:3): [True: 796, False: 279] ------------------ 834| 796| state->handler = attlist7; 835| 796| return XML_ROLE_ATTRIBUTE_NOTATION_VALUE; 836| 1.07k| } 837| 19| return common(state, tok); 838| 1.07k|} xmlrole.c:attlist7: 842| 1.05k| const ENCODING *enc) { 843| 1.05k| UNUSED_P(ptr); ------------------ | | 101| 1.05k|# define UNUSED_P(p) (void)p ------------------ 844| 1.05k| UNUSED_P(end); ------------------ | | 101| 1.05k|# define UNUSED_P(p) (void)p ------------------ 845| 1.05k| UNUSED_P(enc); ------------------ | | 101| 1.05k|# define UNUSED_P(p) (void)p ------------------ 846| 1.05k| switch (tok) { ------------------ | Branch (846:11): [True: 1.04k, False: 9] ------------------ 847| 258| case XML_TOK_PROLOG_S: ------------------ | | 82| 258|# define XML_TOK_PROLOG_S 15 ------------------ | Branch (847:3): [True: 258, False: 796] ------------------ 848| 258| return XML_ROLE_ATTLIST_NONE; 849| 92| case XML_TOK_CLOSE_PAREN: ------------------ | | 91| 92|# define XML_TOK_CLOSE_PAREN 24 ------------------ | Branch (849:3): [True: 92, False: 962] ------------------ 850| 92| state->handler = attlist8; 851| 92| return XML_ROLE_ATTLIST_NONE; 852| 695| case XML_TOK_OR: ------------------ | | 88| 695|# define XML_TOK_OR 21 /* | */ ------------------ | Branch (852:3): [True: 695, False: 359] ------------------ 853| 695| state->handler = attlist6; 854| 695| return XML_ROLE_ATTLIST_NONE; 855| 1.05k| } 856| 9| return common(state, tok); 857| 1.05k|} xmlrole.c:attlist3: 773| 4.24k| const ENCODING *enc) { 774| 4.24k| UNUSED_P(ptr); ------------------ | | 101| 4.24k|# define UNUSED_P(p) (void)p ------------------ 775| 4.24k| UNUSED_P(end); ------------------ | | 101| 4.24k|# define UNUSED_P(p) (void)p ------------------ 776| 4.24k| UNUSED_P(enc); ------------------ | | 101| 4.24k|# define UNUSED_P(p) (void)p ------------------ 777| 4.24k| switch (tok) { ------------------ | Branch (777:11): [True: 4.21k, False: 29] ------------------ 778| 335| case XML_TOK_PROLOG_S: ------------------ | | 82| 335|# define XML_TOK_PROLOG_S 15 ------------------ | Branch (778:3): [True: 335, False: 3.90k] ------------------ 779| 335| return XML_ROLE_ATTLIST_NONE; 780| 1.85k| case XML_TOK_NMTOKEN: ------------------ | | 86| 1.85k|# define XML_TOK_NMTOKEN 19 ------------------ | Branch (780:3): [True: 1.85k, False: 2.38k] ------------------ 781| 3.47k| case XML_TOK_NAME: ------------------ | | 85| 3.47k|# define XML_TOK_NAME 18 ------------------ | Branch (781:3): [True: 1.62k, False: 2.62k] ------------------ 782| 3.87k| case XML_TOK_PREFIXED_NAME: ------------------ | | 118| 3.87k|# define XML_TOK_PREFIXED_NAME 41 ------------------ | Branch (782:3): [True: 405, False: 3.83k] ------------------ 783| 3.87k| state->handler = attlist4; 784| 3.87k| return XML_ROLE_ATTRIBUTE_ENUM_VALUE; 785| 4.24k| } 786| 29| return common(state, tok); 787| 4.24k|} xmlrole.c:attlist4: 791| 4.25k| const ENCODING *enc) { 792| 4.25k| UNUSED_P(ptr); ------------------ | | 101| 4.25k|# define UNUSED_P(p) (void)p ------------------ 793| 4.25k| UNUSED_P(end); ------------------ | | 101| 4.25k|# define UNUSED_P(p) (void)p ------------------ 794| 4.25k| UNUSED_P(enc); ------------------ | | 101| 4.25k|# define UNUSED_P(p) (void)p ------------------ 795| 4.25k| switch (tok) { ------------------ | Branch (795:11): [True: 4.15k, False: 97] ------------------ 796| 379| case XML_TOK_PROLOG_S: ------------------ | | 82| 379|# define XML_TOK_PROLOG_S 15 ------------------ | Branch (796:3): [True: 379, False: 3.87k] ------------------ 797| 379| return XML_ROLE_ATTLIST_NONE; 798| 527| case XML_TOK_CLOSE_PAREN: ------------------ | | 91| 527|# define XML_TOK_CLOSE_PAREN 24 ------------------ | Branch (798:3): [True: 527, False: 3.72k] ------------------ 799| 527| state->handler = attlist8; 800| 527| return XML_ROLE_ATTLIST_NONE; 801| 3.25k| case XML_TOK_OR: ------------------ | | 88| 3.25k|# define XML_TOK_OR 21 /* | */ ------------------ | Branch (801:3): [True: 3.25k, False: 1.00k] ------------------ 802| 3.25k| state->handler = attlist3; 803| 3.25k| return XML_ROLE_ATTLIST_NONE; 804| 4.25k| } 805| 97| return common(state, tok); 806| 4.25k|} xmlrole.c:element0: 908| 3.10k| const ENCODING *enc) { 909| 3.10k| UNUSED_P(ptr); ------------------ | | 101| 3.10k|# define UNUSED_P(p) (void)p ------------------ 910| 3.10k| UNUSED_P(end); ------------------ | | 101| 3.10k|# define UNUSED_P(p) (void)p ------------------ 911| 3.10k| UNUSED_P(enc); ------------------ | | 101| 3.10k|# define UNUSED_P(p) (void)p ------------------ 912| 3.10k| switch (tok) { ------------------ | Branch (912:11): [True: 3.10k, False: 4] ------------------ 913| 1.55k| case XML_TOK_PROLOG_S: ------------------ | | 82| 1.55k|# define XML_TOK_PROLOG_S 15 ------------------ | Branch (913:3): [True: 1.55k, False: 1.55k] ------------------ 914| 1.55k| return XML_ROLE_ELEMENT_NONE; 915| 1.48k| case XML_TOK_NAME: ------------------ | | 85| 1.48k|# define XML_TOK_NAME 18 ------------------ | Branch (915:3): [True: 1.48k, False: 1.62k] ------------------ 916| 1.55k| case XML_TOK_PREFIXED_NAME: ------------------ | | 118| 1.55k|# define XML_TOK_PREFIXED_NAME 41 ------------------ | Branch (916:3): [True: 67, False: 3.04k] ------------------ 917| 1.55k| state->handler = element1; 918| 1.55k| return XML_ROLE_ELEMENT_NAME; 919| 3.10k| } 920| 4| return common(state, tok); 921| 3.10k|} xmlrole.c:element1: 925| 3.09k| const ENCODING *enc) { 926| 3.09k| switch (tok) { ------------------ | Branch (926:11): [True: 3.08k, False: 12] ------------------ 927| 1.54k| case XML_TOK_PROLOG_S: ------------------ | | 82| 1.54k|# define XML_TOK_PROLOG_S 15 ------------------ | Branch (927:3): [True: 1.54k, False: 1.55k] ------------------ 928| 1.54k| return XML_ROLE_ELEMENT_NONE; 929| 149| case XML_TOK_NAME: ------------------ | | 85| 149|# define XML_TOK_NAME 18 ------------------ | Branch (929:3): [True: 149, False: 2.94k] ------------------ 930| 149| if (XmlNameMatchesAscii(enc, ptr, end, KW_EMPTY)) { ------------------ | | 254| 149| (((enc)->nameMatchesAscii)(enc, ptr1, end1, ptr2)) | | ------------------ | | | Branch (254:5): [True: 66, False: 83] | | ------------------ ------------------ 931| 66| state->handler = declClose; 932| 66| state->role_none = XML_ROLE_ELEMENT_NONE; 933| 66| return XML_ROLE_CONTENT_EMPTY; 934| 66| } 935| 83| if (XmlNameMatchesAscii(enc, ptr, end, KW_ANY)) { ------------------ | | 254| 83| (((enc)->nameMatchesAscii)(enc, ptr1, end1, ptr2)) | | ------------------ | | | Branch (254:5): [True: 82, False: 1] | | ------------------ ------------------ 936| 82| state->handler = declClose; 937| 82| state->role_none = XML_ROLE_ELEMENT_NONE; 938| 82| return XML_ROLE_CONTENT_ANY; 939| 82| } 940| 1| break; 941| 1.38k| case XML_TOK_OPEN_PAREN: ------------------ | | 90| 1.38k|# define XML_TOK_OPEN_PAREN 23 ------------------ | Branch (941:3): [True: 1.38k, False: 1.70k] ------------------ 942| 1.38k| state->handler = element2; 943| 1.38k| state->level = 1; 944| 1.38k| return XML_ROLE_GROUP_OPEN; 945| 3.09k| } 946| 13| return common(state, tok); 947| 3.09k|} xmlrole.c:element2: 951| 1.46k| const ENCODING *enc) { 952| 1.46k| switch (tok) { ------------------ | Branch (952:11): [True: 1.44k, False: 14] ------------------ 953| 83| case XML_TOK_PROLOG_S: ------------------ | | 82| 83|# define XML_TOK_PROLOG_S 15 ------------------ | Branch (953:3): [True: 83, False: 1.37k] ------------------ 954| 83| return XML_ROLE_ELEMENT_NONE; 955| 301| case XML_TOK_POUND_NAME: ------------------ | | 87| 301|# define XML_TOK_POUND_NAME 20 /* #name */ ------------------ | Branch (955:3): [True: 301, False: 1.15k] ------------------ 956| 301| if (XmlNameMatchesAscii(enc, ptr + MIN_BYTES_PER_CHAR(enc), end, ------------------ | | 254| 301| (((enc)->nameMatchesAscii)(enc, ptr1, end1, ptr2)) | | ------------------ | | | Branch (254:5): [True: 300, False: 1] | | ------------------ ------------------ 957| 301| KW_PCDATA)) { 958| 300| state->handler = element3; 959| 300| return XML_ROLE_CONTENT_PCDATA; 960| 300| } 961| 1| break; 962| 226| case XML_TOK_OPEN_PAREN: ------------------ | | 90| 226|# define XML_TOK_OPEN_PAREN 23 ------------------ | Branch (962:3): [True: 226, False: 1.23k] ------------------ 963| 226| state->level = 2; 964| 226| state->handler = element6; 965| 226| return XML_ROLE_GROUP_OPEN; 966| 540| case XML_TOK_NAME: ------------------ | | 85| 540|# define XML_TOK_NAME 18 ------------------ | Branch (966:3): [True: 540, False: 920] ------------------ 967| 636| case XML_TOK_PREFIXED_NAME: ------------------ | | 118| 636|# define XML_TOK_PREFIXED_NAME 41 ------------------ | Branch (967:3): [True: 96, False: 1.36k] ------------------ 968| 636| state->handler = element7; 969| 636| return XML_ROLE_CONTENT_ELEMENT; 970| 72| case XML_TOK_NAME_QUESTION: ------------------ | | 99| 72|# define XML_TOK_NAME_QUESTION 30 /* name? */ ------------------ | Branch (970:3): [True: 72, False: 1.38k] ------------------ 971| 72| state->handler = element7; 972| 72| return XML_ROLE_CONTENT_ELEMENT_OPT; 973| 50| case XML_TOK_NAME_ASTERISK: ------------------ | | 100| 50|# define XML_TOK_NAME_ASTERISK 31 /* name* */ ------------------ | Branch (973:3): [True: 50, False: 1.41k] ------------------ 974| 50| state->handler = element7; 975| 50| return XML_ROLE_CONTENT_ELEMENT_REP; 976| 78| case XML_TOK_NAME_PLUS: ------------------ | | 101| 78|# define XML_TOK_NAME_PLUS 32 /* name+ */ ------------------ | Branch (976:3): [True: 78, False: 1.38k] ------------------ 977| 78| state->handler = element7; 978| 78| return XML_ROLE_CONTENT_ELEMENT_PLUS; 979| 1.46k| } 980| 15| return common(state, tok); 981| 1.46k|} xmlrole.c:element3: 985| 383| const ENCODING *enc) { 986| 383| UNUSED_P(ptr); ------------------ | | 101| 383|# define UNUSED_P(p) (void)p ------------------ 987| 383| UNUSED_P(end); ------------------ | | 101| 383|# define UNUSED_P(p) (void)p ------------------ 988| 383| UNUSED_P(enc); ------------------ | | 101| 383|# define UNUSED_P(p) (void)p ------------------ 989| 383| switch (tok) { ------------------ | Branch (989:11): [True: 368, False: 15] ------------------ 990| 84| case XML_TOK_PROLOG_S: ------------------ | | 82| 84|# define XML_TOK_PROLOG_S 15 ------------------ | Branch (990:3): [True: 84, False: 299] ------------------ 991| 84| return XML_ROLE_ELEMENT_NONE; 992| 142| case XML_TOK_CLOSE_PAREN: ------------------ | | 91| 142|# define XML_TOK_CLOSE_PAREN 24 ------------------ | Branch (992:3): [True: 142, False: 241] ------------------ 993| 142| state->handler = declClose; 994| 142| state->role_none = XML_ROLE_ELEMENT_NONE; 995| 142| return XML_ROLE_GROUP_CLOSE; 996| 34| case XML_TOK_CLOSE_PAREN_ASTERISK: ------------------ | | 105| 34|# define XML_TOK_CLOSE_PAREN_ASTERISK 36 /* )* */ ------------------ | Branch (996:3): [True: 34, False: 349] ------------------ 997| 34| state->handler = declClose; 998| 34| state->role_none = XML_ROLE_ELEMENT_NONE; 999| 34| return XML_ROLE_GROUP_CLOSE_REP; 1000| 108| case XML_TOK_OR: ------------------ | | 88| 108|# define XML_TOK_OR 21 /* | */ ------------------ | Branch (1000:3): [True: 108, False: 275] ------------------ 1001| 108| state->handler = element4; 1002| 108| return XML_ROLE_ELEMENT_NONE; 1003| 383| } 1004| 15| return common(state, tok); 1005| 383|} xmlrole.c:element4: 1009| 1.35k| const ENCODING *enc) { 1010| 1.35k| UNUSED_P(ptr); ------------------ | | 101| 1.35k|# define UNUSED_P(p) (void)p ------------------ 1011| 1.35k| UNUSED_P(end); ------------------ | | 101| 1.35k|# define UNUSED_P(p) (void)p ------------------ 1012| 1.35k| UNUSED_P(enc); ------------------ | | 101| 1.35k|# define UNUSED_P(p) (void)p ------------------ 1013| 1.35k| switch (tok) { ------------------ | Branch (1013:11): [True: 1.32k, False: 29] ------------------ 1014| 274| case XML_TOK_PROLOG_S: ------------------ | | 82| 274|# define XML_TOK_PROLOG_S 15 ------------------ | Branch (1014:3): [True: 274, False: 1.08k] ------------------ 1015| 274| return XML_ROLE_ELEMENT_NONE; 1016| 857| case XML_TOK_NAME: ------------------ | | 85| 857|# define XML_TOK_NAME 18 ------------------ | Branch (1016:3): [True: 857, False: 497] ------------------ 1017| 1.05k| case XML_TOK_PREFIXED_NAME: ------------------ | | 118| 1.05k|# define XML_TOK_PREFIXED_NAME 41 ------------------ | Branch (1017:3): [True: 194, False: 1.16k] ------------------ 1018| 1.05k| state->handler = element5; 1019| 1.05k| return XML_ROLE_CONTENT_ELEMENT; 1020| 1.35k| } 1021| 29| return common(state, tok); 1022| 1.35k|} xmlrole.c:element5: 1026| 1.37k| const ENCODING *enc) { 1027| 1.37k| UNUSED_P(ptr); ------------------ | | 101| 1.37k|# define UNUSED_P(p) (void)p ------------------ 1028| 1.37k| UNUSED_P(end); ------------------ | | 101| 1.37k|# define UNUSED_P(p) (void)p ------------------ 1029| 1.37k| UNUSED_P(enc); ------------------ | | 101| 1.37k|# define UNUSED_P(p) (void)p ------------------ 1030| 1.37k| switch (tok) { ------------------ | Branch (1030:11): [True: 1.34k, False: 22] ------------------ 1031| 320| case XML_TOK_PROLOG_S: ------------------ | | 82| 320|# define XML_TOK_PROLOG_S 15 ------------------ | Branch (1031:3): [True: 320, False: 1.05k] ------------------ 1032| 320| return XML_ROLE_ELEMENT_NONE; 1033| 56| case XML_TOK_CLOSE_PAREN_ASTERISK: ------------------ | | 105| 56|# define XML_TOK_CLOSE_PAREN_ASTERISK 36 /* )* */ ------------------ | Branch (1033:3): [True: 56, False: 1.31k] ------------------ 1034| 56| state->handler = declClose; 1035| 56| state->role_none = XML_ROLE_ELEMENT_NONE; 1036| 56| return XML_ROLE_GROUP_CLOSE_REP; 1037| 973| case XML_TOK_OR: ------------------ | | 88| 973|# define XML_TOK_OR 21 /* | */ ------------------ | Branch (1037:3): [True: 973, False: 398] ------------------ 1038| 973| state->handler = element4; 1039| 973| return XML_ROLE_ELEMENT_NONE; 1040| 1.37k| } 1041| 22| return common(state, tok); 1042| 1.37k|} xmlrole.c:element6: 1046| 10.8k| const ENCODING *enc) { 1047| 10.8k| UNUSED_P(ptr); ------------------ | | 101| 10.8k|# define UNUSED_P(p) (void)p ------------------ 1048| 10.8k| UNUSED_P(end); ------------------ | | 101| 10.8k|# define UNUSED_P(p) (void)p ------------------ 1049| 10.8k| UNUSED_P(enc); ------------------ | | 101| 10.8k|# define UNUSED_P(p) (void)p ------------------ 1050| 10.8k| switch (tok) { ------------------ | Branch (1050:11): [True: 10.8k, False: 68] ------------------ 1051| 649| case XML_TOK_PROLOG_S: ------------------ | | 82| 649|# define XML_TOK_PROLOG_S 15 ------------------ | Branch (1051:3): [True: 649, False: 10.2k] ------------------ 1052| 649| return XML_ROLE_ELEMENT_NONE; 1053| 6.76k| case XML_TOK_OPEN_PAREN: ------------------ | | 90| 6.76k|# define XML_TOK_OPEN_PAREN 23 ------------------ | Branch (1053:3): [True: 6.76k, False: 4.11k] ------------------ 1054| 6.76k| state->level += 1; 1055| 6.76k| return XML_ROLE_GROUP_OPEN; 1056| 2.08k| case XML_TOK_NAME: ------------------ | | 85| 2.08k|# define XML_TOK_NAME 18 ------------------ | Branch (1056:3): [True: 2.08k, False: 8.78k] ------------------ 1057| 2.69k| case XML_TOK_PREFIXED_NAME: ------------------ | | 118| 2.69k|# define XML_TOK_PREFIXED_NAME 41 ------------------ | Branch (1057:3): [True: 603, False: 10.2k] ------------------ 1058| 2.69k| state->handler = element7; 1059| 2.69k| return XML_ROLE_CONTENT_ELEMENT; 1060| 205| case XML_TOK_NAME_QUESTION: ------------------ | | 99| 205|# define XML_TOK_NAME_QUESTION 30 /* name? */ ------------------ | Branch (1060:3): [True: 205, False: 10.6k] ------------------ 1061| 205| state->handler = element7; 1062| 205| return XML_ROLE_CONTENT_ELEMENT_OPT; 1063| 245| case XML_TOK_NAME_ASTERISK: ------------------ | | 100| 245|# define XML_TOK_NAME_ASTERISK 31 /* name* */ ------------------ | Branch (1063:3): [True: 245, False: 10.6k] ------------------ 1064| 245| state->handler = element7; 1065| 245| return XML_ROLE_CONTENT_ELEMENT_REP; 1066| 255| case XML_TOK_NAME_PLUS: ------------------ | | 101| 255|# define XML_TOK_NAME_PLUS 32 /* name+ */ ------------------ | Branch (1066:3): [True: 255, False: 10.6k] ------------------ 1067| 255| state->handler = element7; 1068| 255| return XML_ROLE_CONTENT_ELEMENT_PLUS; 1069| 10.8k| } 1070| 68| return common(state, tok); 1071| 10.8k|} xmlrole.c:element7: 1075| 6.92k| const ENCODING *enc) { 1076| 6.92k| UNUSED_P(ptr); ------------------ | | 101| 6.92k|# define UNUSED_P(p) (void)p ------------------ 1077| 6.92k| UNUSED_P(end); ------------------ | | 101| 6.92k|# define UNUSED_P(p) (void)p ------------------ 1078| 6.92k| UNUSED_P(enc); ------------------ | | 101| 6.92k|# define UNUSED_P(p) (void)p ------------------ 1079| 6.92k| switch (tok) { ------------------ | Branch (1079:11): [True: 6.74k, False: 180] ------------------ 1080| 1.03k| case XML_TOK_PROLOG_S: ------------------ | | 82| 1.03k|# define XML_TOK_PROLOG_S 15 ------------------ | Branch (1080:3): [True: 1.03k, False: 5.89k] ------------------ 1081| 1.03k| return XML_ROLE_ELEMENT_NONE; 1082| 1.70k| case XML_TOK_CLOSE_PAREN: ------------------ | | 91| 1.70k|# define XML_TOK_CLOSE_PAREN 24 ------------------ | Branch (1082:3): [True: 1.70k, False: 5.22k] ------------------ 1083| 1.70k| state->level -= 1; 1084| 1.70k| if (state->level == 0) { ------------------ | Branch (1084:9): [True: 490, False: 1.21k] ------------------ 1085| 490| state->handler = declClose; 1086| 490| state->role_none = XML_ROLE_ELEMENT_NONE; 1087| 490| } 1088| 1.70k| return XML_ROLE_GROUP_CLOSE; 1089| 189| case XML_TOK_CLOSE_PAREN_ASTERISK: ------------------ | | 105| 189|# define XML_TOK_CLOSE_PAREN_ASTERISK 36 /* )* */ ------------------ | Branch (1089:3): [True: 189, False: 6.73k] ------------------ 1090| 189| state->level -= 1; 1091| 189| if (state->level == 0) { ------------------ | Branch (1091:9): [True: 76, False: 113] ------------------ 1092| 76| state->handler = declClose; 1093| 76| state->role_none = XML_ROLE_ELEMENT_NONE; 1094| 76| } 1095| 189| return XML_ROLE_GROUP_CLOSE_REP; 1096| 253| case XML_TOK_CLOSE_PAREN_QUESTION: ------------------ | | 104| 253|# define XML_TOK_CLOSE_PAREN_QUESTION 35 /* )? */ ------------------ | Branch (1096:3): [True: 253, False: 6.67k] ------------------ 1097| 253| state->level -= 1; 1098| 253| if (state->level == 0) { ------------------ | Branch (1098:9): [True: 146, False: 107] ------------------ 1099| 146| state->handler = declClose; 1100| 146| state->role_none = XML_ROLE_ELEMENT_NONE; 1101| 146| } 1102| 253| return XML_ROLE_GROUP_CLOSE_OPT; 1103| 326| case XML_TOK_CLOSE_PAREN_PLUS: ------------------ | | 106| 326|# define XML_TOK_CLOSE_PAREN_PLUS 37 /* )+ */ ------------------ | Branch (1103:3): [True: 326, False: 6.60k] ------------------ 1104| 326| state->level -= 1; 1105| 326| if (state->level == 0) { ------------------ | Branch (1105:9): [True: 90, False: 236] ------------------ 1106| 90| state->handler = declClose; 1107| 90| state->role_none = XML_ROLE_ELEMENT_NONE; 1108| 90| } 1109| 326| return XML_ROLE_GROUP_CLOSE_PLUS; 1110| 1.63k| case XML_TOK_COMMA: ------------------ | | 107| 1.63k|# define XML_TOK_COMMA 38 ------------------ | Branch (1110:3): [True: 1.63k, False: 5.29k] ------------------ 1111| 1.63k| state->handler = element6; 1112| 1.63k| return XML_ROLE_GROUP_SEQUENCE; 1113| 1.61k| case XML_TOK_OR: ------------------ | | 88| 1.61k|# define XML_TOK_OR 21 /* | */ ------------------ | Branch (1113:3): [True: 1.61k, False: 5.31k] ------------------ 1114| 1.61k| state->handler = element6; 1115| 1.61k| return XML_ROLE_GROUP_CHOICE; 1116| 6.92k| } 1117| 180| return common(state, tok); 1118| 6.92k|} xmlrole.c:notation0: 617| 1.74k| const ENCODING *enc) { 618| 1.74k| UNUSED_P(ptr); ------------------ | | 101| 1.74k|# define UNUSED_P(p) (void)p ------------------ 619| 1.74k| UNUSED_P(end); ------------------ | | 101| 1.74k|# define UNUSED_P(p) (void)p ------------------ 620| 1.74k| UNUSED_P(enc); ------------------ | | 101| 1.74k|# define UNUSED_P(p) (void)p ------------------ 621| 1.74k| switch (tok) { ------------------ | Branch (621:11): [True: 1.74k, False: 4] ------------------ 622| 874| case XML_TOK_PROLOG_S: ------------------ | | 82| 874|# define XML_TOK_PROLOG_S 15 ------------------ | Branch (622:3): [True: 874, False: 870] ------------------ 623| 874| return XML_ROLE_NOTATION_NONE; 624| 866| case XML_TOK_NAME: ------------------ | | 85| 866|# define XML_TOK_NAME 18 ------------------ | Branch (624:3): [True: 866, False: 878] ------------------ 625| 866| state->handler = notation1; 626| 866| return XML_ROLE_NOTATION_NAME; 627| 1.74k| } 628| 4| return common(state, tok); 629| 1.74k|} xmlrole.c:notation1: 633| 1.72k| const ENCODING *enc) { 634| 1.72k| switch (tok) { ------------------ | Branch (634:11): [True: 1.72k, False: 7] ------------------ 635| 863| case XML_TOK_PROLOG_S: ------------------ | | 82| 863|# define XML_TOK_PROLOG_S 15 ------------------ | Branch (635:3): [True: 863, False: 865] ------------------ 636| 863| return XML_ROLE_NOTATION_NONE; 637| 858| case XML_TOK_NAME: ------------------ | | 85| 858|# define XML_TOK_NAME 18 ------------------ | Branch (637:3): [True: 858, False: 870] ------------------ 638| 858| if (XmlNameMatchesAscii(enc, ptr, end, KW_SYSTEM)) { ------------------ | | 254| 858| (((enc)->nameMatchesAscii)(enc, ptr1, end1, ptr2)) | | ------------------ | | | Branch (254:5): [True: 317, False: 541] | | ------------------ ------------------ 639| 317| state->handler = notation3; 640| 317| return XML_ROLE_NOTATION_NONE; 641| 317| } 642| 541| if (XmlNameMatchesAscii(enc, ptr, end, KW_PUBLIC)) { ------------------ | | 254| 541| (((enc)->nameMatchesAscii)(enc, ptr1, end1, ptr2)) | | ------------------ | | | Branch (254:5): [True: 540, False: 1] | | ------------------ ------------------ 643| 540| state->handler = notation2; 644| 540| return XML_ROLE_NOTATION_NONE; 645| 540| } 646| 1| break; 647| 1.72k| } 648| 8| return common(state, tok); 649| 1.72k|} xmlrole.c:notation3: 669| 624| const ENCODING *enc) { 670| 624| UNUSED_P(ptr); ------------------ | | 101| 624|# define UNUSED_P(p) (void)p ------------------ 671| 624| UNUSED_P(end); ------------------ | | 101| 624|# define UNUSED_P(p) (void)p ------------------ 672| 624| UNUSED_P(enc); ------------------ | | 101| 624|# define UNUSED_P(p) (void)p ------------------ 673| 624| switch (tok) { ------------------ | Branch (673:11): [True: 618, False: 6] ------------------ 674| 315| case XML_TOK_PROLOG_S: ------------------ | | 82| 315|# define XML_TOK_PROLOG_S 15 ------------------ | Branch (674:3): [True: 315, False: 309] ------------------ 675| 315| return XML_ROLE_NOTATION_NONE; 676| 303| case XML_TOK_LITERAL: ------------------ | | 94| 303|# define XML_TOK_LITERAL 27 ------------------ | Branch (676:3): [True: 303, False: 321] ------------------ 677| 303| state->handler = declClose; 678| 303| state->role_none = XML_ROLE_NOTATION_NONE; 679| 303| return XML_ROLE_NOTATION_SYSTEM_ID; 680| 624| } 681| 6| return common(state, tok); 682| 624|} xmlrole.c:notation2: 653| 1.07k| const ENCODING *enc) { 654| 1.07k| UNUSED_P(ptr); ------------------ | | 101| 1.07k|# define UNUSED_P(p) (void)p ------------------ 655| 1.07k| UNUSED_P(end); ------------------ | | 101| 1.07k|# define UNUSED_P(p) (void)p ------------------ 656| 1.07k| UNUSED_P(enc); ------------------ | | 101| 1.07k|# define UNUSED_P(p) (void)p ------------------ 657| 1.07k| switch (tok) { ------------------ | Branch (657:11): [True: 1.07k, False: 7] ------------------ 658| 538| case XML_TOK_PROLOG_S: ------------------ | | 82| 538|# define XML_TOK_PROLOG_S 15 ------------------ | Branch (658:3): [True: 538, False: 540] ------------------ 659| 538| return XML_ROLE_NOTATION_NONE; 660| 533| case XML_TOK_LITERAL: ------------------ | | 94| 533|# define XML_TOK_LITERAL 27 ------------------ | Branch (660:3): [True: 533, False: 545] ------------------ 661| 533| state->handler = notation4; 662| 533| return XML_ROLE_NOTATION_PUBLIC_ID; 663| 1.07k| } 664| 7| return common(state, tok); 665| 1.07k|} xmlrole.c:notation4: 686| 700| const ENCODING *enc) { 687| 700| UNUSED_P(ptr); ------------------ | | 101| 700|# define UNUSED_P(p) (void)p ------------------ 688| 700| UNUSED_P(end); ------------------ | | 101| 700|# define UNUSED_P(p) (void)p ------------------ 689| 700| UNUSED_P(enc); ------------------ | | 101| 700|# define UNUSED_P(p) (void)p ------------------ 690| 700| switch (tok) { ------------------ | Branch (690:11): [True: 699, False: 1] ------------------ 691| 187| case XML_TOK_PROLOG_S: ------------------ | | 82| 187|# define XML_TOK_PROLOG_S 15 ------------------ | Branch (691:3): [True: 187, False: 513] ------------------ 692| 187| return XML_ROLE_NOTATION_NONE; 693| 101| case XML_TOK_LITERAL: ------------------ | | 94| 101|# define XML_TOK_LITERAL 27 ------------------ | Branch (693:3): [True: 101, False: 599] ------------------ 694| 101| state->handler = declClose; 695| 101| state->role_none = XML_ROLE_NOTATION_NONE; 696| 101| return XML_ROLE_NOTATION_SYSTEM_ID; 697| 411| case XML_TOK_DECL_CLOSE: ------------------ | | 84| 411|# define XML_TOK_DECL_CLOSE 17 /* > */ ------------------ | Branch (697:3): [True: 411, False: 289] ------------------ 698| 411| setTopLevel(state); ------------------ | | 118| 411| ((state)->handler \ | | 119| 411| = ((state)->documentEntity ? internalSubset : externalSubset1)) | | ------------------ | | | Branch (119:9): [True: 411, False: 0] | | ------------------ ------------------ 699| 411| return XML_ROLE_NOTATION_NO_SYSTEM_ID; 700| 700| } 701| 1| return common(state, tok); 702| 700|} xmlrole.c:doctype5: 320| 1.54k| const ENCODING *enc) { 321| 1.54k| UNUSED_P(ptr); ------------------ | | 101| 1.54k|# define UNUSED_P(p) (void)p ------------------ 322| 1.54k| UNUSED_P(end); ------------------ | | 101| 1.54k|# define UNUSED_P(p) (void)p ------------------ 323| 1.54k| UNUSED_P(enc); ------------------ | | 101| 1.54k|# define UNUSED_P(p) (void)p ------------------ 324| 1.54k| switch (tok) { ------------------ | Branch (324:11): [True: 1.54k, False: 6] ------------------ 325| 9| case XML_TOK_PROLOG_S: ------------------ | | 82| 9|# define XML_TOK_PROLOG_S 15 ------------------ | Branch (325:3): [True: 9, False: 1.53k] ------------------ 326| 9| return XML_ROLE_DOCTYPE_NONE; 327| 1.53k| case XML_TOK_DECL_CLOSE: ------------------ | | 84| 1.53k|# define XML_TOK_DECL_CLOSE 17 /* > */ ------------------ | Branch (327:3): [True: 1.53k, False: 15] ------------------ 328| 1.53k| state->handler = prolog2; 329| 1.53k| return XML_ROLE_DOCTYPE_CLOSE; 330| 1.54k| } 331| 6| return common(state, tok); 332| 1.54k|} xmlrole.c:prolog2: 206| 4.88k| const ENCODING *enc) { 207| 4.88k| UNUSED_P(ptr); ------------------ | | 101| 4.88k|# define UNUSED_P(p) (void)p ------------------ 208| 4.88k| UNUSED_P(end); ------------------ | | 101| 4.88k|# define UNUSED_P(p) (void)p ------------------ 209| 4.88k| UNUSED_P(enc); ------------------ | | 101| 4.88k|# define UNUSED_P(p) (void)p ------------------ 210| 4.88k| switch (tok) { ------------------ | Branch (210:11): [True: 4.87k, False: 15] ------------------ 211| 282| case XML_TOK_PROLOG_S: ------------------ | | 82| 282|# define XML_TOK_PROLOG_S 15 ------------------ | Branch (211:3): [True: 282, False: 4.60k] ------------------ 212| 282| return XML_ROLE_NONE; 213| 572| case XML_TOK_PI: ------------------ | | 76| 572|# define XML_TOK_PI 11 /* processing instruction */ ------------------ | Branch (213:3): [True: 572, False: 4.31k] ------------------ 214| 572| return XML_ROLE_PI; 215| 203| case XML_TOK_COMMENT: ------------------ | | 78| 203|# define XML_TOK_COMMENT 13 ------------------ | Branch (215:3): [True: 203, False: 4.68k] ------------------ 216| 203| return XML_ROLE_COMMENT; 217| 3.81k| case XML_TOK_INSTANCE_START: ------------------ | | 96| 3.81k|# define XML_TOK_INSTANCE_START 29 ------------------ | Branch (217:3): [True: 3.81k, False: 1.07k] ------------------ 218| 3.81k| state->handler = error; 219| 3.81k| return XML_ROLE_INSTANCE_START; 220| 4.88k| } 221| 15| return common(state, tok); 222| 4.88k|} xmlrole.c:doctype3: 285| 560| const ENCODING *enc) { 286| 560| UNUSED_P(ptr); ------------------ | | 101| 560|# define UNUSED_P(p) (void)p ------------------ 287| 560| UNUSED_P(end); ------------------ | | 101| 560|# define UNUSED_P(p) (void)p ------------------ 288| 560| UNUSED_P(enc); ------------------ | | 101| 560|# define UNUSED_P(p) (void)p ------------------ 289| 560| switch (tok) { ------------------ | Branch (289:11): [True: 361, False: 199] ------------------ 290| 183| case XML_TOK_PROLOG_S: ------------------ | | 82| 183|# define XML_TOK_PROLOG_S 15 ------------------ | Branch (290:3): [True: 183, False: 377] ------------------ 291| 183| return XML_ROLE_DOCTYPE_NONE; 292| 178| case XML_TOK_LITERAL: ------------------ | | 94| 178|# define XML_TOK_LITERAL 27 ------------------ | Branch (292:3): [True: 178, False: 382] ------------------ 293| 178| state->handler = doctype4; 294| 178| return XML_ROLE_DOCTYPE_SYSTEM_ID; 295| 560| } 296| 199| return common(state, tok); 297| 560|} xmlrole.c:doctype4: 301| 261| const ENCODING *enc) { 302| 261| UNUSED_P(ptr); ------------------ | | 101| 261|# define UNUSED_P(p) (void)p ------------------ 303| 261| UNUSED_P(end); ------------------ | | 101| 261|# define UNUSED_P(p) (void)p ------------------ 304| 261| UNUSED_P(enc); ------------------ | | 101| 261|# define UNUSED_P(p) (void)p ------------------ 305| 261| switch (tok) { ------------------ | Branch (305:11): [True: 255, False: 6] ------------------ 306| 84| case XML_TOK_PROLOG_S: ------------------ | | 82| 84|# define XML_TOK_PROLOG_S 15 ------------------ | Branch (306:3): [True: 84, False: 177] ------------------ 307| 84| return XML_ROLE_DOCTYPE_NONE; 308| 85| case XML_TOK_OPEN_BRACKET: ------------------ | | 92| 85|# define XML_TOK_OPEN_BRACKET 25 ------------------ | Branch (308:3): [True: 85, False: 176] ------------------ 309| 85| state->handler = internalSubset; 310| 85| return XML_ROLE_DOCTYPE_INTERNAL_SUBSET; 311| 86| case XML_TOK_DECL_CLOSE: ------------------ | | 84| 86|# define XML_TOK_DECL_CLOSE 17 /* > */ ------------------ | Branch (311:3): [True: 86, False: 175] ------------------ 312| 86| state->handler = prolog2; 313| 86| return XML_ROLE_DOCTYPE_CLOSE; 314| 261| } 315| 6| return common(state, tok); 316| 261|} xmlrole.c:doctype2: 269| 510| const ENCODING *enc) { 270| 510| UNUSED_P(ptr); ------------------ | | 101| 510|# define UNUSED_P(p) (void)p ------------------ 271| 510| UNUSED_P(end); ------------------ | | 101| 510|# define UNUSED_P(p) (void)p ------------------ 272| 510| UNUSED_P(enc); ------------------ | | 101| 510|# define UNUSED_P(p) (void)p ------------------ 273| 510| switch (tok) { ------------------ | Branch (273:11): [True: 508, False: 2] ------------------ 274| 256| case XML_TOK_PROLOG_S: ------------------ | | 82| 256|# define XML_TOK_PROLOG_S 15 ------------------ | Branch (274:3): [True: 256, False: 254] ------------------ 275| 256| return XML_ROLE_DOCTYPE_NONE; 276| 252| case XML_TOK_LITERAL: ------------------ | | 94| 252|# define XML_TOK_LITERAL 27 ------------------ | Branch (276:3): [True: 252, False: 258] ------------------ 277| 252| state->handler = doctype3; 278| 252| return XML_ROLE_DOCTYPE_PUBLIC_ID; 279| 510| } 280| 2| return common(state, tok); 281| 510|} xmlrole.c:common: 1226| 1.52k|common(PROLOG_STATE *state, int tok) { 1227| 1.52k|#ifdef XML_DTD 1228| 1.52k| if (! state->documentEntity && tok == XML_TOK_PARAM_ENTITY_REF) ------------------ | | 95| 0|# define XML_TOK_PARAM_ENTITY_REF 28 ------------------ | Branch (1228:7): [True: 0, False: 1.52k] | Branch (1228:34): [True: 0, False: 0] ------------------ 1229| 0| return XML_ROLE_INNER_PARAM_ENTITY_REF; 1230| |#else 1231| | UNUSED_P(tok); 1232| |#endif 1233| 1.52k| state->handler = error; 1234| 1.52k| return XML_ROLE_ERROR; 1235| 1.52k|} _INTERNAL_trim_to_complete_utf8_characters: 272| 4.17M| const char **fromLimRef) { 273| 4.17M| const char *fromLim = *fromLimRef; 274| 4.17M| size_t walked = 0; 275| 4.18M| for (; fromLim > from; fromLim--, walked++) { ------------------ | Branch (275:10): [True: 4.16M, False: 23.4k] ------------------ 276| 4.16M| const unsigned char prev = (unsigned char)fromLim[-1]; 277| 4.16M| if ((prev & 0xf8u) ------------------ | Branch (277:9): [True: 2.26k, False: 4.16M] ------------------ 278| 4.16M| == 0xf0u) { /* 4-byte character, lead by 0b11110xxx byte */ 279| 2.26k| if (walked + 1 >= 4) { ------------------ | Branch (279:11): [True: 2.18k, False: 85] ------------------ 280| 2.18k| fromLim += 4 - 1; 281| 2.18k| break; 282| 2.18k| } else { 283| 85| walked = 0; 284| 85| } 285| 4.16M| } else if ((prev & 0xf0u) ------------------ | Branch (285:16): [True: 2.45k, False: 4.16M] ------------------ 286| 4.16M| == 0xe0u) { /* 3-byte character, lead by 0b1110xxxx byte */ 287| 2.45k| if (walked + 1 >= 3) { ------------------ | Branch (287:11): [True: 2.35k, False: 97] ------------------ 288| 2.35k| fromLim += 3 - 1; 289| 2.35k| break; 290| 2.35k| } else { 291| 97| walked = 0; 292| 97| } 293| 4.16M| } else if ((prev & 0xe0u) ------------------ | Branch (293:16): [True: 3.79k, False: 4.15M] ------------------ 294| 4.16M| == 0xc0u) { /* 2-byte character, lead by 0b110xxxxx byte */ 295| 3.79k| if (walked + 1 >= 2) { ------------------ | Branch (295:11): [True: 3.66k, False: 132] ------------------ 296| 3.66k| fromLim += 2 - 1; 297| 3.66k| break; 298| 3.66k| } else { 299| 132| walked = 0; 300| 132| } 301| 4.15M| } else if ((prev & 0x80u) ------------------ | Branch (301:16): [True: 4.14M, False: 15.0k] ------------------ 302| 4.15M| == 0x00u) { /* 1-byte character, matching 0b0xxxxxxx */ 303| 4.14M| break; 304| 4.14M| } 305| 4.16M| } 306| 4.17M| *fromLimRef = fromLim; 307| 4.17M|} XmlUtf8Encode: 1181| 3.09k|XmlUtf8Encode(int c, char *buf) { 1182| 3.09k| enum { 1183| | /* minN is minimum legal resulting value for N byte sequence */ 1184| 3.09k| min2 = 0x80, 1185| 3.09k| min3 = 0x800, 1186| 3.09k| min4 = 0x10000 1187| 3.09k| }; 1188| | 1189| 3.09k| if (c < 0) ------------------ | Branch (1189:7): [True: 0, False: 3.09k] ------------------ 1190| 0| return 0; /* LCOV_EXCL_LINE: this case is always eliminated beforehand */ 1191| 3.09k| if (c < min2) { ------------------ | Branch (1191:7): [True: 1.18k, False: 1.90k] ------------------ 1192| 1.18k| buf[0] = (char)(c | UTF8_cval1); 1193| 1.18k| return 1; 1194| 1.18k| } 1195| 1.90k| if (c < min3) { ------------------ | Branch (1195:7): [True: 547, False: 1.36k] ------------------ 1196| 547| buf[0] = (char)((c >> 6) | UTF8_cval2); 1197| 547| buf[1] = (char)((c & 0x3f) | 0x80); 1198| 547| return 2; 1199| 547| } 1200| 1.36k| if (c < min4) { ------------------ | Branch (1200:7): [True: 841, False: 520] ------------------ 1201| 841| buf[0] = (char)((c >> 12) | UTF8_cval3); 1202| 841| buf[1] = (char)(((c >> 6) & 0x3f) | 0x80); 1203| 841| buf[2] = (char)((c & 0x3f) | 0x80); 1204| 841| return 3; 1205| 841| } 1206| 520| if (c < 0x110000) { ------------------ | Branch (1206:7): [True: 520, False: 0] ------------------ 1207| 520| buf[0] = (char)((c >> 18) | UTF8_cval4); 1208| 520| buf[1] = (char)(((c >> 12) & 0x3f) | 0x80); 1209| 520| buf[2] = (char)(((c >> 6) & 0x3f) | 0x80); 1210| 520| buf[3] = (char)((c & 0x3f) | 0x80); 1211| 520| return 4; 1212| 520| } 1213| 0| return 0; /* LCOV_EXCL_LINE: this case too is eliminated before calling */ 1214| 520|} xmltok.c:latin1_toUtf8: 448| 57.0k| char **toP, const char *toLim) { 449| 57.0k| UNUSED_P(enc); ------------------ | | 101| 57.0k|# define UNUSED_P(p) (void)p ------------------ 450| 213k| for (;;) { 451| 213k| unsigned char c; 452| 213k| if (*fromP == fromLim) ------------------ | Branch (452:9): [True: 52.3k, False: 160k] ------------------ 453| 52.3k| return XML_CONVERT_COMPLETED; 454| 160k| c = (unsigned char)**fromP; 455| 160k| if (c & 0x80) { ------------------ | Branch (455:9): [True: 8.82k, False: 152k] ------------------ 456| 8.82k| if (toLim - *toP < 2) ------------------ | Branch (456:11): [True: 96, False: 8.72k] ------------------ 457| 96| return XML_CONVERT_OUTPUT_EXHAUSTED; 458| 8.72k| *(*toP)++ = (char)((c >> 6) | UTF8_cval2); 459| 8.72k| *(*toP)++ = (char)((c & 0x3f) | 0x80); 460| 8.72k| (*fromP)++; 461| 152k| } else { 462| 152k| if (*toP == toLim) ------------------ | Branch (462:11): [True: 4.70k, False: 147k] ------------------ 463| 4.70k| return XML_CONVERT_OUTPUT_EXHAUSTED; 464| 147k| *(*toP)++ = *(*fromP)++; 465| 147k| } 466| 160k| } 467| 57.0k|} xmltok.c:checkCharRefNumber: 1157| 5.81k|checkCharRefNumber(int result) { 1158| 5.81k| switch (result >> 8) { ------------------ | Branch (1158:11): [True: 2.86k, False: 2.95k] ------------------ 1159| 2| case 0xD8: ------------------ | Branch (1159:3): [True: 2, False: 5.81k] ------------------ 1160| 4| case 0xD9: ------------------ | Branch (1160:3): [True: 2, False: 5.81k] ------------------ 1161| 6| case 0xDA: ------------------ | Branch (1161:3): [True: 2, False: 5.81k] ------------------ 1162| 8| case 0xDB: ------------------ | Branch (1162:3): [True: 2, False: 5.81k] ------------------ 1163| 10| case 0xDC: ------------------ | Branch (1163:3): [True: 2, False: 5.81k] ------------------ 1164| 16| case 0xDD: ------------------ | Branch (1164:3): [True: 6, False: 5.81k] ------------------ 1165| 18| case 0xDE: ------------------ | Branch (1165:3): [True: 2, False: 5.81k] ------------------ 1166| 20| case 0xDF: ------------------ | Branch (1166:3): [True: 2, False: 5.81k] ------------------ 1167| 20| return -1; 1168| 2.43k| case 0: ------------------ | Branch (1168:3): [True: 2.43k, False: 3.38k] ------------------ 1169| 2.43k| if (latin1_encoding.type[result] == BT_NONXML) ------------------ | Branch (1169:9): [True: 70, False: 2.36k] ------------------ 1170| 70| return -1; 1171| 2.36k| break; 1172| 2.36k| case 0xFF: ------------------ | Branch (1172:3): [True: 408, False: 5.41k] ------------------ 1173| 408| if (result == 0xFFFE || result == 0xFFFF) ------------------ | Branch (1173:9): [True: 2, False: 406] | Branch (1173:29): [True: 6, False: 400] ------------------ 1174| 8| return -1; 1175| 400| break; 1176| 5.81k| } 1177| 5.72k| return result; 1178| 5.81k|} xmltok.c:utf8_toUtf8: 311| 4.17M| char **toP, const char *toLim) { 312| 4.17M| bool input_incomplete = false; 313| 4.17M| bool output_exhausted = false; 314| | 315| | /* Avoid copying partial characters (due to limited space). */ 316| 4.17M| const ptrdiff_t bytesAvailable = fromLim - *fromP; 317| 4.17M| const ptrdiff_t bytesStorable = toLim - *toP; 318| 4.17M| UNUSED_P(enc); ------------------ | | 101| 4.17M|# define UNUSED_P(p) (void)p ------------------ 319| 4.17M| if (bytesAvailable > bytesStorable) { ------------------ | Branch (319:7): [True: 10.8k, False: 4.16M] ------------------ 320| 10.8k| fromLim = *fromP + bytesStorable; 321| 10.8k| output_exhausted = true; 322| 10.8k| } 323| | 324| | /* Avoid copying partial characters (from incomplete input). */ 325| 4.17M| { 326| 4.17M| const char *const fromLimBefore = fromLim; 327| 4.17M| _INTERNAL_trim_to_complete_utf8_characters(*fromP, &fromLim); 328| 4.17M| if (fromLim < fromLimBefore) { ------------------ | Branch (328:9): [True: 314, False: 4.17M] ------------------ 329| 314| input_incomplete = true; 330| 314| } 331| 4.17M| } 332| | 333| 4.17M| { 334| 4.17M| const ptrdiff_t bytesToCopy = fromLim - *fromP; 335| 4.17M| memcpy(*toP, *fromP, bytesToCopy); 336| 4.17M| *fromP += bytesToCopy; 337| 4.17M| *toP += bytesToCopy; 338| 4.17M| } 339| | 340| 4.17M| if (output_exhausted) /* needs to go first */ ------------------ | Branch (340:7): [True: 10.8k, False: 4.16M] ------------------ 341| 10.8k| return XML_CONVERT_OUTPUT_EXHAUSTED; 342| 4.16M| else if (input_incomplete) ------------------ | Branch (342:12): [True: 0, False: 4.16M] ------------------ 343| 0| return XML_CONVERT_INPUT_INCOMPLETE; 344| 4.16M| else 345| 4.16M| return XML_CONVERT_COMPLETED; 346| 4.17M|} xmltok.c:utf8_isName2: 148| 26.2k|utf8_isName2(const ENCODING *enc, const char *p) { 149| 26.2k| UNUSED_P(enc); ------------------ | | 101| 26.2k|# define UNUSED_P(p) (void)p ------------------ 150| 26.2k| return UTF8_GET_NAMING2(namePages, (const unsigned char *)p); ------------------ | | 94| 26.2k| (namingBitmap[((pages)[(((byte)[0]) >> 2) & 7] << 3) \ | | 95| 26.2k| + ((((byte)[0]) & 3) << 1) + ((((byte)[1]) >> 5) & 1)] \ | | 96| 26.2k| & (1u << (((byte)[1]) & 0x1F))) ------------------ 151| 26.2k|} xmltok.c:utf8_isName3: 154| 1.26k|utf8_isName3(const ENCODING *enc, const char *p) { 155| 1.26k| UNUSED_P(enc); ------------------ | | 101| 1.26k|# define UNUSED_P(p) (void)p ------------------ 156| 1.26k| return UTF8_GET_NAMING3(namePages, (const unsigned char *)p); ------------------ | | 104| 1.26k| (namingBitmap \ | | 105| 1.26k| [((pages)[((((byte)[0]) & 0xF) << 4) + ((((byte)[1]) >> 2) & 0xF)] \ | | 106| 1.26k| << 3) \ | | 107| 1.26k| + ((((byte)[1]) & 3) << 1) + ((((byte)[2]) >> 5) & 1)] \ | | 108| 1.26k| & (1u << (((byte)[2]) & 0x1F))) ------------------ 157| 1.26k|} xmltok.c:isNever: 141| 21|isNever(const ENCODING *enc, const char *p) { 142| 21| UNUSED_P(enc); ------------------ | | 101| 21|# define UNUSED_P(p) (void)p ------------------ 143| 21| UNUSED_P(p); ------------------ | | 101| 21|# define UNUSED_P(p) (void)p ------------------ 144| 21| return 0; 145| 21|} xmltok.c:utf8_isNmstrt2: 162| 3.03k|utf8_isNmstrt2(const ENCODING *enc, const char *p) { 163| 3.03k| UNUSED_P(enc); ------------------ | | 101| 3.03k|# define UNUSED_P(p) (void)p ------------------ 164| 3.03k| return UTF8_GET_NAMING2(nmstrtPages, (const unsigned char *)p); ------------------ | | 94| 3.03k| (namingBitmap[((pages)[(((byte)[0]) >> 2) & 7] << 3) \ | | 95| 3.03k| + ((((byte)[0]) & 3) << 1) + ((((byte)[1]) >> 5) & 1)] \ | | 96| 3.03k| & (1u << (((byte)[1]) & 0x1F))) ------------------ 165| 3.03k|} xmltok.c:utf8_isNmstrt3: 168| 1.80k|utf8_isNmstrt3(const ENCODING *enc, const char *p) { 169| 1.80k| UNUSED_P(enc); ------------------ | | 101| 1.80k|# define UNUSED_P(p) (void)p ------------------ 170| 1.80k| return UTF8_GET_NAMING3(nmstrtPages, (const unsigned char *)p); ------------------ | | 104| 1.80k| (namingBitmap \ | | 105| 1.80k| [((pages)[((((byte)[0]) & 0xF) << 4) + ((((byte)[1]) >> 2) & 0xF)] \ | | 106| 1.80k| << 3) \ | | 107| 1.80k| + ((((byte)[1]) & 3) << 1) + ((((byte)[2]) >> 5) & 1)] \ | | 108| 1.80k| & (1u << (((byte)[2]) & 0x1F))) ------------------ 171| 1.80k|} xmltok.c:utf8_isInvalid2: 176| 36.8k|utf8_isInvalid2(const ENCODING *enc, const char *p) { 177| 36.8k| UNUSED_P(enc); ------------------ | | 101| 36.8k|# define UNUSED_P(p) (void)p ------------------ 178| 36.8k| return UTF8_INVALID2((const unsigned char *)p); ------------------ | | 121| 36.8k| ((*p) < 0xC2 || ((p)[1] & 0x80) == 0 || ((p)[1] & 0xC0) == 0xC0) | | ------------------ | | | Branch (121:4): [True: 18, False: 36.8k] | | | Branch (121:19): [True: 189, False: 36.6k] | | | Branch (121:43): [True: 9, False: 36.6k] | | ------------------ ------------------ 179| 36.8k|} xmltok.c:utf8_isInvalid3: 182| 5.66k|utf8_isInvalid3(const ENCODING *enc, const char *p) { 183| 5.66k| UNUSED_P(enc); ------------------ | | 101| 5.66k|# define UNUSED_P(p) (void)p ------------------ 184| 5.66k| return UTF8_INVALID3((const unsigned char *)p); ------------------ | | 124| 5.66k| (((p)[2] & 0x80) == 0 \ | | ------------------ | | | Branch (124:4): [True: 183, False: 5.48k] | | ------------------ | | 125| 5.66k| || ((*p) == 0xEF && (p)[1] == 0xBF ? (p)[2] > 0xBD \ | | ------------------ | | | Branch (125:7): [True: 15, False: 5.46k] | | | Branch (125:8): [True: 464, False: 5.01k] | | | Branch (125:24): [True: 238, False: 226] | | ------------------ | | 126| 5.48k| : ((p)[2] & 0xC0) == 0xC0) \ | | 127| 5.66k| || ((*p) == 0xE0 \ | | ------------------ | | | Branch (127:7): [True: 41, False: 5.42k] | | | Branch (127:8): [True: 1.60k, False: 3.85k] | | ------------------ | | 128| 5.46k| ? (p)[1] < 0xA0 || ((p)[1] & 0xC0) == 0xC0 \ | | ------------------ | | | Branch (128:14): [True: 17, False: 1.59k] | | | Branch (128:31): [True: 0, False: 1.59k] | | ------------------ | | 129| 5.46k| : ((p)[1] & 0x80) == 0 \ | | ------------------ | | | Branch (129:14): [True: 16, False: 3.84k] | | ------------------ | | 130| 3.85k| || ((*p) == 0xED ? (p)[1] > 0x9F : ((p)[1] & 0xC0) == 0xC0))) | | ------------------ | | | Branch (130:21): [True: 8, False: 3.83k] | | | Branch (130:22): [True: 807, False: 3.03k] | | ------------------ ------------------ 185| 5.66k|} xmltok.c:utf8_isInvalid4: 188| 2.16k|utf8_isInvalid4(const ENCODING *enc, const char *p) { 189| 2.16k| UNUSED_P(enc); ------------------ | | 101| 2.16k|# define UNUSED_P(p) (void)p ------------------ 190| 2.16k| return UTF8_INVALID4((const unsigned char *)p); ------------------ | | 133| 2.16k| (((p)[3] & 0x80) == 0 || ((p)[3] & 0xC0) == 0xC0 || ((p)[2] & 0x80) == 0 \ | | ------------------ | | | Branch (133:4): [True: 148, False: 2.02k] | | | Branch (133:28): [True: 9, False: 2.01k] | | | Branch (133:55): [True: 8, False: 2.00k] | | ------------------ | | 134| 2.16k| || ((p)[2] & 0xC0) == 0xC0 \ | | ------------------ | | | Branch (134:7): [True: 4, False: 1.99k] | | ------------------ | | 135| 2.16k| || ((*p) == 0xF0 \ | | ------------------ | | | Branch (135:7): [True: 28, False: 1.97k] | | | Branch (135:8): [True: 1.02k, False: 972] | | ------------------ | | 136| 1.99k| ? (p)[1] < 0x90 || ((p)[1] & 0xC0) == 0xC0 \ | | ------------------ | | | Branch (136:14): [True: 11, False: 1.01k] | | | Branch (136:31): [True: 1, False: 1.01k] | | ------------------ | | 137| 1.99k| : ((p)[1] & 0x80) == 0 \ | | ------------------ | | | Branch (137:14): [True: 5, False: 967] | | ------------------ | | 138| 972| || ((*p) == 0xF4 ? (p)[1] > 0x8F : ((p)[1] & 0xC0) == 0xC0))) | | ------------------ | | | Branch (138:21): [True: 11, False: 956] | | | Branch (138:22): [True: 283, False: 684] | | ------------------ ------------------ 191| 2.16k|} xmltok.c:unicode_byte_type: 540| 97.5k|unicode_byte_type(char hi, char lo) { 541| 97.5k| switch ((unsigned char)hi) { ------------------ | Branch (541:11): [True: 10.2k, False: 87.2k] ------------------ 542| | /* 0xD800-0xDBFF first 16-bit code unit or high surrogate (W1) */ 543| 2.75k| case 0xD8: ------------------ | Branch (543:3): [True: 2.75k, False: 94.8k] ------------------ 544| 4.32k| case 0xD9: ------------------ | Branch (544:3): [True: 1.57k, False: 95.9k] ------------------ 545| 5.66k| case 0xDA: ------------------ | Branch (545:3): [True: 1.34k, False: 96.2k] ------------------ 546| 6.79k| case 0xDB: ------------------ | Branch (546:3): [True: 1.12k, False: 96.4k] ------------------ 547| 6.79k| return BT_LEAD4; 548| | /* 0xDC00-0xDFFF second 16-bit code unit or low surrogate (W2) */ 549| 56| case 0xDC: ------------------ | Branch (549:3): [True: 56, False: 97.5k] ------------------ 550| 104| case 0xDD: ------------------ | Branch (550:3): [True: 48, False: 97.5k] ------------------ 551| 162| case 0xDE: ------------------ | Branch (551:3): [True: 58, False: 97.5k] ------------------ 552| 227| case 0xDF: ------------------ | Branch (552:3): [True: 65, False: 97.4k] ------------------ 553| 227| return BT_TRAIL; 554| 3.25k| case 0xFF: ------------------ | Branch (554:3): [True: 3.25k, False: 94.3k] ------------------ 555| 3.25k| switch ((unsigned char)lo) { ------------------ | Branch (555:13): [True: 58, False: 3.19k] ------------------ 556| 57| case 0xFF: /* noncharacter-FFFF */ ------------------ | Branch (556:5): [True: 57, False: 3.20k] ------------------ 557| 58| case 0xFE: /* noncharacter-FFFE */ ------------------ | Branch (557:5): [True: 1, False: 3.25k] ------------------ 558| 58| return BT_NONXML; 559| 3.25k| } 560| 3.19k| break; 561| 97.5k| } 562| 90.4k| return BT_NONASCII; 563| 97.5k|} xmltok.c:little2_toUtf8: 568| 9.02k| char **toP, const char *toLim) { \ 569| 9.02k| const char *from = *fromP; \ 570| 9.02k| UNUSED_P(enc); \ ------------------ | | 101| 9.02k|# define UNUSED_P(p) (void)p ------------------ 571| 9.02k| fromLim = from + (((fromLim - from) >> 1) << 1); /* shrink to even */ \ 572| 34.3k| for (; from < fromLim; from += 2) { \ ------------------ | Branch (572:12): [True: 25.8k, False: 8.49k] ------------------ 573| 25.8k| int plane; \ 574| 25.8k| unsigned char lo2; \ 575| 25.8k| unsigned char lo = GET_LO(from); \ ------------------ | | 664| 25.8k|#define GET_LO(ptr) ((unsigned char)(ptr)[0]) ------------------ 576| 25.8k| unsigned char hi = GET_HI(from); \ ------------------ | | 665| 25.8k|#define GET_HI(ptr) ((unsigned char)(ptr)[1]) ------------------ 577| 25.8k| switch (hi) { \ 578| 5.63k| case 0: \ ------------------ | Branch (578:7): [True: 5.63k, False: 20.2k] ------------------ 579| 5.63k| if (lo < 0x80) { \ ------------------ | Branch (579:13): [True: 5.38k, False: 259] ------------------ 580| 5.38k| if (*toP == toLim) { \ ------------------ | Branch (580:15): [True: 300, False: 5.08k] ------------------ 581| 300| *fromP = from; \ 582| 300| return XML_CONVERT_OUTPUT_EXHAUSTED; \ 583| 300| } \ 584| 5.38k| *(*toP)++ = lo; \ 585| 5.08k| break; \ 586| 5.38k| } \ 587| 5.63k| EXPAT_FALLTHROUGH; \ ------------------ | | 47| 259|# define EXPAT_FALLTHROUGH __attribute__((fallthrough)) ------------------ 588| 541| case 0x1: \ ------------------ | Branch (588:7): [True: 282, False: 25.5k] ------------------ 589| 746| case 0x2: \ ------------------ | Branch (589:7): [True: 205, False: 25.6k] ------------------ 590| 1.06k| case 0x3: \ ------------------ | Branch (590:7): [True: 321, False: 25.5k] ------------------ 591| 1.43k| case 0x4: \ ------------------ | Branch (591:7): [True: 366, False: 25.4k] ------------------ 592| 1.67k| case 0x5: \ ------------------ | Branch (592:7): [True: 239, False: 25.6k] ------------------ 593| 1.87k| case 0x6: \ ------------------ | Branch (593:7): [True: 202, False: 25.6k] ------------------ 594| 2.07k| case 0x7: \ ------------------ | Branch (594:7): [True: 196, False: 25.6k] ------------------ 595| 2.07k| if (toLim - *toP < 2) { \ ------------------ | Branch (595:13): [True: 89, False: 1.98k] ------------------ 596| 89| *fromP = from; \ 597| 89| return XML_CONVERT_OUTPUT_EXHAUSTED; \ 598| 89| } \ 599| 2.07k| *(*toP)++ = ((lo >> 6) | (hi << 2) | UTF8_cval2); \ 600| 1.98k| *(*toP)++ = ((lo & 0x3f) | 0x80); \ 601| 1.98k| break; \ 602| 17.4k| default: \ ------------------ | Branch (602:7): [True: 17.4k, False: 8.40k] ------------------ 603| 17.4k| if (toLim - *toP < 3) { \ ------------------ | Branch (603:13): [True: 135, False: 17.3k] ------------------ 604| 135| *fromP = from; \ 605| 135| return XML_CONVERT_OUTPUT_EXHAUSTED; \ 606| 135| } \ 607| 17.4k| /* 16 bits divided 4, 6, 6 amongst 3 bytes */ \ 608| 17.4k| *(*toP)++ = ((hi >> 4) | UTF8_cval3); \ 609| 17.3k| *(*toP)++ = (((hi & 0xf) << 2) | (lo >> 6) | 0x80); \ 610| 17.3k| *(*toP)++ = ((lo & 0x3f) | 0x80); \ 611| 17.3k| break; \ 612| 17.4k| case 0xD8: \ ------------------ | Branch (612:7): [True: 452, False: 25.4k] ------------------ 613| 622| case 0xD9: \ ------------------ | Branch (613:7): [True: 170, False: 25.6k] ------------------ 614| 823| case 0xDA: \ ------------------ | Branch (614:7): [True: 201, False: 25.6k] ------------------ 615| 959| case 0xDB: \ ------------------ | Branch (615:7): [True: 136, False: 25.7k] ------------------ 616| 959| if (toLim - *toP < 4) { \ ------------------ | Branch (616:13): [True: 12, False: 947] ------------------ 617| 12| *fromP = from; \ 618| 12| return XML_CONVERT_OUTPUT_EXHAUSTED; \ 619| 12| } \ 620| 959| if (fromLim - from < 4) { \ ------------------ | Branch (620:13): [True: 0, False: 947] ------------------ 621| 0| *fromP = from; \ 622| 0| return XML_CONVERT_INPUT_INCOMPLETE; \ 623| 0| } \ 624| 947| plane = (((hi & 0x3) << 2) | ((lo >> 6) & 0x3)) + 1; \ 625| 947| *(*toP)++ = (char)((plane >> 2) | UTF8_cval4); \ 626| 947| *(*toP)++ = (((lo >> 2) & 0xF) | ((plane & 0x3) << 4) | 0x80); \ 627| 947| from += 2; \ 628| 947| lo2 = GET_LO(from); \ ------------------ | | 664| 947|#define GET_LO(ptr) ((unsigned char)(ptr)[0]) ------------------ 629| 947| *(*toP)++ = (((lo & 0x3) << 4) | ((GET_HI(from) & 0x3) << 2) \ ------------------ | | 665| 947|#define GET_HI(ptr) ((unsigned char)(ptr)[1]) ------------------ 630| 947| | (lo2 >> 6) | 0x80); \ 631| 947| *(*toP)++ = ((lo2 & 0x3f) | 0x80); \ 632| 947| break; \ 633| 25.8k| } \ 634| 25.8k| } \ 635| 9.02k| *fromP = from; \ 636| 8.49k| if (from < fromLim) \ ------------------ | Branch (636:9): [True: 0, False: 8.49k] ------------------ 637| 8.49k| return XML_CONVERT_INPUT_INCOMPLETE; \ 638| 8.49k| else \ 639| 8.49k| return XML_CONVERT_COMPLETED; \ 640| 8.49k| } xmltok.c:getEncodingIndex: 1428| 24.2k|getEncodingIndex(const char *name) { 1429| 24.2k| static const char *const encodingNames[] = { 1430| 24.2k| KW_ISO_8859_1, KW_US_ASCII, KW_UTF_8, KW_UTF_16, KW_UTF_16BE, KW_UTF_16LE, 1431| 24.2k| }; 1432| 24.2k| int i; 1433| 24.2k| if (name == NULL) ------------------ | Branch (1433:7): [True: 12.0k, False: 12.1k] ------------------ 1434| 12.0k| return NO_ENC; 1435| 33.8k| for (i = 0; i < (int)(sizeof(encodingNames) / sizeof(encodingNames[0])); i++) ------------------ | Branch (1435:15): [True: 33.8k, False: 61] ------------------ 1436| 33.8k| if (streqci(name, encodingNames[i])) ------------------ | Branch (1436:9): [True: 12.0k, False: 21.7k] ------------------ 1437| 12.0k| return i; 1438| 61| return UNKNOWN_ENC; 1439| 12.1k|} xmltok.c:streqci: 887| 33.8k|streqci(const char *s1, const char *s2) { 888| 140k| for (;;) { 889| 140k| char c1 = *s1++; 890| 140k| char c2 = *s2++; 891| 140k| if (ASCII_a <= c1 && c1 <= ASCII_z) ------------------ | | 65| 140k|#define ASCII_a 0x61 ------------------ if (ASCII_a <= c1 && c1 <= ASCII_z) ------------------ | | 90| 279|#define ASCII_z 0x7A ------------------ | Branch (891:9): [True: 279, False: 140k] | Branch (891:26): [True: 279, False: 0] ------------------ 892| 279| c1 += ASCII_A - ASCII_a; ------------------ | | 38| 279|#define ASCII_A 0x41 ------------------ c1 += ASCII_A - ASCII_a; ------------------ | | 65| 279|#define ASCII_a 0x61 ------------------ 893| 140k| if (ASCII_a <= c2 && c2 <= ASCII_z) ------------------ | | 65| 140k|#define ASCII_a 0x61 ------------------ if (ASCII_a <= c2 && c2 <= ASCII_z) ------------------ | | 90| 0|#define ASCII_z 0x7A ------------------ | Branch (893:9): [True: 0, False: 140k] | Branch (893:26): [True: 0, False: 0] ------------------ 894| | /* The following line will never get executed. streqci() is 895| | * only called from two places, both of which guarantee to put 896| | * upper-case strings into s2. 897| | */ 898| 0| c2 += ASCII_A - ASCII_a; /* LCOV_EXCL_LINE */ ------------------ | | 38| 0|#define ASCII_A 0x41 ------------------ c2 += ASCII_A - ASCII_a; /* LCOV_EXCL_LINE */ ------------------ | | 65| 0|#define ASCII_a 0x61 ------------------ 899| 140k| if (c1 != c2) ------------------ | Branch (899:9): [True: 21.8k, False: 118k] ------------------ 900| 21.8k| return 0; 901| 118k| if (! c1) ------------------ | Branch (901:9): [True: 12.0k, False: 106k] ------------------ 902| 12.0k| break; 903| 118k| } 904| 12.0k| return 1; 905| 33.8k|} xmltok.c:initScan: 1457| 12.0k| int state, const char *ptr, const char *end, const char **nextTokPtr) { 1458| 12.0k| const ENCODING **encPtr; 1459| | 1460| 12.0k| if (ptr >= end) ------------------ | Branch (1460:7): [True: 0, False: 12.0k] ------------------ 1461| 0| return XML_TOK_NONE; ------------------ | | 51| 0|# define XML_TOK_NONE -4 /* The string to be scanned is empty */ ------------------ 1462| 12.0k| encPtr = enc->encPtr; 1463| 12.0k| if (ptr + 1 == end) { ------------------ | Branch (1463:7): [True: 0, False: 12.0k] ------------------ 1464| | /* only a single byte available for auto-detection */ 1465| |#ifndef XML_DTD /* FIXME */ 1466| | /* a well-formed document entity must have more than one byte */ 1467| | if (state != XML_CONTENT_STATE) 1468| | return XML_TOK_PARTIAL; 1469| |#endif 1470| | /* so we're parsing an external text entity... */ 1471| | /* if UTF-16 was externally specified, then we need at least 2 bytes */ 1472| 0| switch (INIT_ENC_INDEX(enc)) { ------------------ | | 1445| 0|#define INIT_ENC_INDEX(enc) ((int)(enc)->initEnc.isUtf16) | | ------------------ | | | Branch (1445:29): [True: 0, False: 0] | | ------------------ ------------------ 1473| 0| case UTF_16_ENC: ------------------ | Branch (1473:5): [True: 0, False: 0] ------------------ 1474| 0| case UTF_16LE_ENC: ------------------ | Branch (1474:5): [True: 0, False: 0] ------------------ 1475| 0| case UTF_16BE_ENC: ------------------ | Branch (1475:5): [True: 0, False: 0] ------------------ 1476| 0| return XML_TOK_PARTIAL; ------------------ | | 56| 0|# define XML_TOK_PARTIAL -1 /* only part of a token */ ------------------ 1477| 0| } 1478| 0| switch ((unsigned char)*ptr) { ------------------ | Branch (1478:13): [True: 0, False: 0] ------------------ 1479| 0| case 0xFE: ------------------ | Branch (1479:5): [True: 0, False: 0] ------------------ 1480| 0| case 0xFF: ------------------ | Branch (1480:5): [True: 0, False: 0] ------------------ 1481| 0| case 0xEF: /* possibly first byte of UTF-8 BOM */ ------------------ | Branch (1481:5): [True: 0, False: 0] ------------------ 1482| 0| if (INIT_ENC_INDEX(enc) == ISO_8859_1_ENC && state == XML_CONTENT_STATE) ------------------ | | 1445| 0|#define INIT_ENC_INDEX(enc) ((int)(enc)->initEnc.isUtf16) ------------------ if (INIT_ENC_INDEX(enc) == ISO_8859_1_ENC && state == XML_CONTENT_STATE) ------------------ | | 131| 0|# define XML_CONTENT_STATE 1 ------------------ | Branch (1482:11): [True: 0, False: 0] | Branch (1482:52): [True: 0, False: 0] ------------------ 1483| 0| break; 1484| 0| EXPAT_FALLTHROUGH; ------------------ | | 47| 0|# define EXPAT_FALLTHROUGH __attribute__((fallthrough)) ------------------ 1485| 0| case 0x00: ------------------ | Branch (1485:5): [True: 0, False: 0] ------------------ 1486| 0| case 0x3C: ------------------ | Branch (1486:5): [True: 0, False: 0] ------------------ 1487| 0| return XML_TOK_PARTIAL; ------------------ | | 56| 0|# define XML_TOK_PARTIAL -1 /* only part of a token */ ------------------ 1488| 0| } 1489| 12.0k| } else { 1490| 12.0k| switch (((unsigned char)ptr[0] << 8) | (unsigned char)ptr[1]) { 1491| 0| case 0xFEFF: ------------------ | Branch (1491:5): [True: 0, False: 12.0k] ------------------ 1492| 0| if (INIT_ENC_INDEX(enc) == ISO_8859_1_ENC && state == XML_CONTENT_STATE) ------------------ | | 1445| 0|#define INIT_ENC_INDEX(enc) ((int)(enc)->initEnc.isUtf16) ------------------ if (INIT_ENC_INDEX(enc) == ISO_8859_1_ENC && state == XML_CONTENT_STATE) ------------------ | | 131| 0|# define XML_CONTENT_STATE 1 ------------------ | Branch (1492:11): [True: 0, False: 0] | Branch (1492:52): [True: 0, False: 0] ------------------ 1493| 0| break; 1494| 0| *nextTokPtr = ptr + 2; 1495| 0| *encPtr = encodingTable[UTF_16BE_ENC]; 1496| 0| return XML_TOK_BOM; ------------------ | | 79| 0|# define XML_TOK_BOM 14 /* Byte order mark */ ------------------ 1497| | /* 00 3C is handled in the default case */ 1498| 3.75k| case 0x3C00: ------------------ | Branch (1498:5): [True: 3.75k, False: 8.31k] ------------------ 1499| 3.75k| if ((INIT_ENC_INDEX(enc) == UTF_16BE_ENC ------------------ | | 1445| 3.75k|#define INIT_ENC_INDEX(enc) ((int)(enc)->initEnc.isUtf16) ------------------ | Branch (1499:12): [True: 1, False: 3.75k] ------------------ 1500| 3.75k| || INIT_ENC_INDEX(enc) == UTF_16_ENC) ------------------ | | 1445| 3.75k|#define INIT_ENC_INDEX(enc) ((int)(enc)->initEnc.isUtf16) ------------------ | Branch (1500:15): [True: 3.62k, False: 128] ------------------ 1501| 3.62k| && state == XML_CONTENT_STATE) ------------------ | | 131| 3.62k|# define XML_CONTENT_STATE 1 ------------------ | Branch (1501:14): [True: 0, False: 3.62k] ------------------ 1502| 0| break; 1503| 3.75k| *encPtr = encodingTable[UTF_16LE_ENC]; 1504| 3.75k| return XmlTok(*encPtr, state, ptr, end, nextTokPtr); ------------------ | | 223| 3.75k| (((enc)->scanners[state])(enc, ptr, end, nextTokPtr)) ------------------ 1505| 0| case 0xFFFE: ------------------ | Branch (1505:5): [True: 0, False: 12.0k] ------------------ 1506| 0| if (INIT_ENC_INDEX(enc) == ISO_8859_1_ENC && state == XML_CONTENT_STATE) ------------------ | | 1445| 0|#define INIT_ENC_INDEX(enc) ((int)(enc)->initEnc.isUtf16) ------------------ if (INIT_ENC_INDEX(enc) == ISO_8859_1_ENC && state == XML_CONTENT_STATE) ------------------ | | 131| 0|# define XML_CONTENT_STATE 1 ------------------ | Branch (1506:11): [True: 0, False: 0] | Branch (1506:52): [True: 0, False: 0] ------------------ 1507| 0| break; 1508| 0| *nextTokPtr = ptr + 2; 1509| 0| *encPtr = encodingTable[UTF_16LE_ENC]; 1510| 0| return XML_TOK_BOM; ------------------ | | 79| 0|# define XML_TOK_BOM 14 /* Byte order mark */ ------------------ 1511| 0| case 0xEFBB: ------------------ | Branch (1511:5): [True: 0, False: 12.0k] ------------------ 1512| | /* Maybe a UTF-8 BOM (EF BB BF) */ 1513| | /* If there's an explicitly specified (external) encoding 1514| | of ISO-8859-1 or some flavour of UTF-16 1515| | and this is an external text entity, 1516| | don't look for the BOM, 1517| | because it might be a legal data. 1518| | */ 1519| 0| if (state == XML_CONTENT_STATE) { ------------------ | | 131| 0|# define XML_CONTENT_STATE 1 ------------------ | Branch (1519:11): [True: 0, False: 0] ------------------ 1520| 0| int e = INIT_ENC_INDEX(enc); ------------------ | | 1445| 0|#define INIT_ENC_INDEX(enc) ((int)(enc)->initEnc.isUtf16) ------------------ 1521| 0| if (e == ISO_8859_1_ENC || e == UTF_16BE_ENC || e == UTF_16LE_ENC ------------------ | Branch (1521:13): [True: 0, False: 0] | Branch (1521:36): [True: 0, False: 0] | Branch (1521:57): [True: 0, False: 0] ------------------ 1522| 0| || e == UTF_16_ENC) ------------------ | Branch (1522:16): [True: 0, False: 0] ------------------ 1523| 0| break; 1524| 0| } 1525| 0| if (ptr + 2 == end) ------------------ | Branch (1525:11): [True: 0, False: 0] ------------------ 1526| 0| return XML_TOK_PARTIAL; ------------------ | | 56| 0|# define XML_TOK_PARTIAL -1 /* only part of a token */ ------------------ 1527| 0| if ((unsigned char)ptr[2] == 0xBF) { ------------------ | Branch (1527:11): [True: 0, False: 0] ------------------ 1528| 0| *nextTokPtr = ptr + 3; 1529| 0| *encPtr = encodingTable[UTF_8_ENC]; 1530| 0| return XML_TOK_BOM; ------------------ | | 79| 0|# define XML_TOK_BOM 14 /* Byte order mark */ ------------------ 1531| 0| } 1532| 0| break; 1533| 8.31k| default: ------------------ | Branch (1533:5): [True: 8.31k, False: 3.75k] ------------------ 1534| 8.31k| if (ptr[0] == '\0') { ------------------ | Branch (1534:11): [True: 0, False: 8.31k] ------------------ 1535| | /* 0 isn't a legal data character. Furthermore a document 1536| | entity can only start with ASCII characters. So the only 1537| | way this can fail to be big-endian UTF-16 if it it's an 1538| | external parsed general entity that's labelled as 1539| | UTF-16LE. 1540| | */ 1541| 0| if (state == XML_CONTENT_STATE && INIT_ENC_INDEX(enc) == UTF_16LE_ENC) ------------------ | | 131| 0|# define XML_CONTENT_STATE 1 ------------------ if (state == XML_CONTENT_STATE && INIT_ENC_INDEX(enc) == UTF_16LE_ENC) ------------------ | | 1445| 0|#define INIT_ENC_INDEX(enc) ((int)(enc)->initEnc.isUtf16) ------------------ | Branch (1541:13): [True: 0, False: 0] | Branch (1541:43): [True: 0, False: 0] ------------------ 1542| 0| break; 1543| 0| *encPtr = encodingTable[UTF_16BE_ENC]; 1544| 0| return XmlTok(*encPtr, state, ptr, end, nextTokPtr); ------------------ | | 223| 0| (((enc)->scanners[state])(enc, ptr, end, nextTokPtr)) ------------------ 1545| 8.31k| } else if (ptr[1] == '\0') { ------------------ | Branch (1545:18): [True: 0, False: 8.31k] ------------------ 1546| | /* We could recover here in the case: 1547| | - parsing an external entity 1548| | - second byte is 0 1549| | - no externally specified encoding 1550| | - no encoding declaration 1551| | by assuming UTF-16LE. But we don't, because this would mean when 1552| | presented just with a single byte, we couldn't reliably determine 1553| | whether we needed further bytes. 1554| | */ 1555| 0| if (state == XML_CONTENT_STATE) ------------------ | | 131| 0|# define XML_CONTENT_STATE 1 ------------------ | Branch (1555:13): [True: 0, False: 0] ------------------ 1556| 0| break; 1557| 0| *encPtr = encodingTable[UTF_16LE_ENC]; 1558| 0| return XmlTok(*encPtr, state, ptr, end, nextTokPtr); ------------------ | | 223| 0| (((enc)->scanners[state])(enc, ptr, end, nextTokPtr)) ------------------ 1559| 0| } 1560| 8.31k| break; 1561| 12.0k| } 1562| 12.0k| } 1563| 8.31k| *encPtr = encodingTable[INIT_ENC_INDEX(enc)]; ------------------ | | 1445| 8.31k|#define INIT_ENC_INDEX(enc) ((int)(enc)->initEnc.isUtf16) ------------------ 1564| 8.31k| return XmlTok(*encPtr, state, ptr, end, nextTokPtr); ------------------ | | 223| 8.31k| (((enc)->scanners[state])(enc, ptr, end, nextTokPtr)) ------------------ 1565| 12.0k|} xmltok.c:ascii_toUtf8: 506| 16.0k| char **toP, const char *toLim) { 507| 16.0k| UNUSED_P(enc); ------------------ | | 101| 16.0k|# define UNUSED_P(p) (void)p ------------------ 508| 54.4k| while (*fromP < fromLim && *toP < toLim) ------------------ | Branch (508:10): [True: 40.5k, False: 13.8k] | Branch (508:30): [True: 38.4k, False: 2.14k] ------------------ 509| 38.4k| *(*toP)++ = *(*fromP)++; 510| | 511| 16.0k| if ((*toP == toLim) && (*fromP < fromLim)) ------------------ | Branch (511:7): [True: 2.36k, False: 13.6k] | Branch (511:26): [True: 2.14k, False: 224] ------------------ 512| 2.14k| return XML_CONVERT_OUTPUT_EXHAUSTED; 513| 13.8k| else 514| 13.8k| return XML_CONVERT_COMPLETED; 515| 16.0k|} xmltok.c:doParseXmlDecl: 1065| 481| const ENCODING **encoding, int *standalone) { 1066| 481| const char *val = NULL; 1067| 481| const char *name = NULL; 1068| 481| const char *nameEnd = NULL; 1069| 481| ptr += 5 * enc->minBytesPerChar; 1070| 481| end -= 2 * enc->minBytesPerChar; 1071| 481| if (! parsePseudoAttribute(enc, ptr, end, &name, &nameEnd, &val, &ptr) ------------------ | Branch (1071:7): [True: 131, False: 350] ------------------ 1072| 350| || ! name) { ------------------ | Branch (1072:10): [True: 9, False: 341] ------------------ 1073| 140| *badPtr = ptr; 1074| 140| return 0; 1075| 140| } 1076| 341| if (! XmlNameMatchesAscii(enc, name, nameEnd, KW_version)) { ------------------ | | 254| 341| (((enc)->nameMatchesAscii)(enc, ptr1, end1, ptr2)) ------------------ | Branch (1076:7): [True: 2, False: 339] ------------------ 1077| 2| if (! isGeneralTextEntity) { ------------------ | Branch (1077:9): [True: 2, False: 0] ------------------ 1078| 2| *badPtr = name; 1079| 2| return 0; 1080| 2| } 1081| 339| } else { 1082| 339| if (versionPtr) ------------------ | Branch (1082:9): [True: 339, False: 0] ------------------ 1083| 339| *versionPtr = val; 1084| 339| if (versionEndPtr) ------------------ | Branch (1084:9): [True: 339, False: 0] ------------------ 1085| 339| *versionEndPtr = ptr; 1086| | /* The version number must not be empty; VersionNum requires at least 1087| | one character. The encoding and standalone pseudo-attributes below 1088| | already reject an empty value, so keep version consistent. */ 1089| 339| if (val == ptr - enc->minBytesPerChar) { ------------------ | Branch (1089:9): [True: 19, False: 320] ------------------ 1090| 19| *badPtr = val; 1091| 19| return 0; 1092| 19| } 1093| | /* Expat implements XML 1.0 only, so any version outside the "1.0"/"1.x" 1094| | family is rejected. Following the Fifth Edition's VersionNum 1095| | production (rather than the Fourth Edition's exact "1.0") avoids 1096| | rejecting "1.1" now only to have to revert that once Expat tracks 1097| | the newer edition. */ 1098| 320| if (! checkXmlDeclVersionNum(enc, val, ptr - enc->minBytesPerChar)) { ------------------ | Branch (1098:9): [True: 82, False: 238] ------------------ 1099| 82| *badPtr = val; 1100| 82| return 0; 1101| 82| } 1102| 238| if (! parsePseudoAttribute(enc, ptr, end, &name, &nameEnd, &val, &ptr)) { ------------------ | Branch (1102:9): [True: 87, False: 151] ------------------ 1103| 87| *badPtr = ptr; 1104| 87| return 0; 1105| 87| } 1106| 151| if (! name) { ------------------ | Branch (1106:9): [True: 74, False: 77] ------------------ 1107| 74| if (isGeneralTextEntity) { ------------------ | Branch (1107:11): [True: 0, False: 74] ------------------ 1108| | /* a TextDecl must have an EncodingDecl */ 1109| 0| *badPtr = ptr; 1110| 0| return 0; 1111| 0| } 1112| 74| return 1; 1113| 74| } 1114| 151| } 1115| 77| if (XmlNameMatchesAscii(enc, name, nameEnd, KW_encoding)) { ------------------ | | 254| 77| (((enc)->nameMatchesAscii)(enc, ptr1, end1, ptr2)) | | ------------------ | | | Branch (254:5): [True: 75, False: 2] | | ------------------ ------------------ 1116| 75| int c = toAscii(enc, val, end); 1117| 75| if (! (ASCII_a <= c && c <= ASCII_z) && ! (ASCII_A <= c && c <= ASCII_Z)) { ------------------ | | 65| 75|#define ASCII_a 0x61 ------------------ if (! (ASCII_a <= c && c <= ASCII_z) && ! (ASCII_A <= c && c <= ASCII_Z)) { ------------------ | | 90| 27|#define ASCII_z 0x7A ------------------ if (! (ASCII_a <= c && c <= ASCII_z) && ! (ASCII_A <= c && c <= ASCII_Z)) { ------------------ | | 38| 48|#define ASCII_A 0x41 ------------------ if (! (ASCII_a <= c && c <= ASCII_z) && ! (ASCII_A <= c && c <= ASCII_Z)) { ------------------ | | 63| 42|#define ASCII_Z 0x5A ------------------ | Branch (1117:12): [True: 27, False: 48] | Branch (1117:28): [True: 27, False: 0] | Branch (1117:48): [True: 42, False: 6] | Branch (1117:64): [True: 41, False: 1] ------------------ 1118| 7| *badPtr = val; 1119| 7| return 0; 1120| 7| } 1121| 68| if (encodingName) ------------------ | Branch (1121:9): [True: 68, False: 0] ------------------ 1122| 68| *encodingName = val; 1123| 68| if (encoding) ------------------ | Branch (1123:9): [True: 68, False: 0] ------------------ 1124| 68| *encoding = encodingFinder(enc, val, ptr - enc->minBytesPerChar); 1125| 68| if (! parsePseudoAttribute(enc, ptr, end, &name, &nameEnd, &val, &ptr)) { ------------------ | Branch (1125:9): [True: 4, False: 64] ------------------ 1126| 4| *badPtr = ptr; 1127| 4| return 0; 1128| 4| } 1129| 64| if (! name) ------------------ | Branch (1129:9): [True: 63, False: 1] ------------------ 1130| 63| return 1; 1131| 64| } 1132| 3| if (! XmlNameMatchesAscii(enc, name, nameEnd, KW_standalone) ------------------ | | 254| 6| (((enc)->nameMatchesAscii)(enc, ptr1, end1, ptr2)) ------------------ | Branch (1132:7): [True: 3, False: 0] ------------------ 1133| 3| || isGeneralTextEntity) { ------------------ | Branch (1133:10): [True: 0, False: 0] ------------------ 1134| 3| *badPtr = name; 1135| 3| return 0; 1136| 3| } 1137| 0| if (XmlNameMatchesAscii(enc, val, ptr - enc->minBytesPerChar, KW_yes)) { ------------------ | | 254| 0| (((enc)->nameMatchesAscii)(enc, ptr1, end1, ptr2)) | | ------------------ | | | Branch (254:5): [True: 0, False: 0] | | ------------------ ------------------ 1138| 0| if (standalone) ------------------ | Branch (1138:9): [True: 0, False: 0] ------------------ 1139| 0| *standalone = 1; 1140| 0| } else if (XmlNameMatchesAscii(enc, val, ptr - enc->minBytesPerChar, KW_no)) { ------------------ | | 254| 0| (((enc)->nameMatchesAscii)(enc, ptr1, end1, ptr2)) | | ------------------ | | | Branch (254:5): [True: 0, False: 0] | | ------------------ ------------------ 1141| 0| if (standalone) ------------------ | Branch (1141:9): [True: 0, False: 0] ------------------ 1142| 0| *standalone = 0; 1143| 0| } else { 1144| 0| *badPtr = val; 1145| 0| return 0; 1146| 0| } 1147| 0| while (isSpace(toAscii(enc, ptr, end))) ------------------ | Branch (1147:10): [True: 0, False: 0] ------------------ 1148| 0| ptr += enc->minBytesPerChar; 1149| 0| if (ptr != end) { ------------------ | Branch (1149:7): [True: 0, False: 0] ------------------ 1150| 0| *badPtr = ptr; 1151| 0| return 0; 1152| 0| } 1153| 0| return 1; 1154| 0|} xmltok.c:parsePseudoAttribute: 943| 787| const char **valPtr, const char **nextTokPtr) { 944| 787| int c; 945| 787| char open; 946| 787| if (ptr == end) { ------------------ | Branch (946:7): [True: 131, False: 656] ------------------ 947| 131| *namePtr = NULL; 948| 131| return 1; 949| 131| } 950| 656| if (! isSpace(toAscii(enc, ptr, end))) { ------------------ | Branch (950:7): [True: 9, False: 647] ------------------ 951| 9| *nextTokPtr = ptr; 952| 9| return 0; 953| 9| } 954| 1.10k| do { 955| 1.10k| ptr += enc->minBytesPerChar; 956| 1.10k| } while (isSpace(toAscii(enc, ptr, end))); ------------------ | Branch (956:12): [True: 459, False: 647] ------------------ 957| 647| if (ptr == end) { ------------------ | Branch (957:7): [True: 15, False: 632] ------------------ 958| 15| *namePtr = NULL; 959| 15| return 1; 960| 15| } 961| 632| *namePtr = ptr; 962| 5.18k| for (;;) { 963| 5.18k| c = toAscii(enc, ptr, end); 964| 5.18k| if (c == -1) { ------------------ | Branch (964:9): [True: 50, False: 5.13k] ------------------ 965| 50| *nextTokPtr = ptr; 966| 50| return 0; 967| 50| } 968| 5.13k| if (c == ASCII_EQUALS) { ------------------ | | 114| 5.13k|#define ASCII_EQUALS 0x3D ------------------ | Branch (968:9): [True: 549, False: 4.58k] ------------------ 969| 549| *nameEndPtr = ptr; 970| 549| break; 971| 549| } 972| 4.58k| if (isSpace(c)) { ------------------ | Branch (972:9): [True: 33, False: 4.55k] ------------------ 973| 33| *nameEndPtr = ptr; 974| 302| do { 975| 302| ptr += enc->minBytesPerChar; 976| 302| } while (isSpace(c = toAscii(enc, ptr, end))); ------------------ | Branch (976:16): [True: 269, False: 33] ------------------ 977| 33| if (c != ASCII_EQUALS) { ------------------ | | 114| 33|#define ASCII_EQUALS 0x3D ------------------ | Branch (977:11): [True: 31, False: 2] ------------------ 978| 31| *nextTokPtr = ptr; 979| 31| return 0; 980| 31| } 981| 2| break; 982| 33| } 983| 4.55k| ptr += enc->minBytesPerChar; 984| 4.55k| } 985| 551| if (ptr == *namePtr) { ------------------ | Branch (985:7): [True: 5, False: 546] ------------------ 986| 5| *nextTokPtr = ptr; 987| 5| return 0; 988| 5| } 989| 546| ptr += enc->minBytesPerChar; 990| 546| c = toAscii(enc, ptr, end); 991| 762| while (isSpace(c)) { ------------------ | Branch (991:10): [True: 216, False: 546] ------------------ 992| 216| ptr += enc->minBytesPerChar; 993| 216| c = toAscii(enc, ptr, end); 994| 216| } 995| 546| if (c != ASCII_QUOT && c != ASCII_APOS) { ------------------ | | 106| 1.09k|#define ASCII_QUOT 0x22 ------------------ if (c != ASCII_QUOT && c != ASCII_APOS) { ------------------ | | 108| 96|#define ASCII_APOS 0x27 ------------------ | Branch (995:7): [True: 96, False: 450] | Branch (995:26): [True: 14, False: 82] ------------------ 996| 14| *nextTokPtr = ptr; 997| 14| return 0; 998| 14| } 999| 532| open = (char)c; 1000| 532| ptr += enc->minBytesPerChar; 1001| 532| *valPtr = ptr; 1002| 5.76k| for (;; ptr += enc->minBytesPerChar) { 1003| 5.76k| c = toAscii(enc, ptr, end); 1004| 5.76k| if (c == open) ------------------ | Branch (1004:9): [True: 419, False: 5.34k] ------------------ 1005| 419| break; 1006| 5.34k| if (! (ASCII_a <= c && c <= ASCII_z) && ! (ASCII_A <= c && c <= ASCII_Z) ------------------ | | 65| 5.34k|#define ASCII_a 0x61 ------------------ if (! (ASCII_a <= c && c <= ASCII_z) && ! (ASCII_A <= c && c <= ASCII_Z) ------------------ | | 90| 1.86k|#define ASCII_z 0x7A ------------------ if (! (ASCII_a <= c && c <= ASCII_z) && ! (ASCII_A <= c && c <= ASCII_Z) ------------------ | | 38| 3.48k|#define ASCII_A 0x41 ------------------ if (! (ASCII_a <= c && c <= ASCII_z) && ! (ASCII_A <= c && c <= ASCII_Z) ------------------ | | 63| 903|#define ASCII_Z 0x5A ------------------ | Branch (1006:12): [True: 1.86k, False: 3.48k] | Branch (1006:28): [True: 1.85k, False: 2] | Branch (1006:48): [True: 903, False: 2.58k] | Branch (1006:64): [True: 444, False: 459] ------------------ 1007| 3.04k| && ! (ASCII_0 <= c && c <= ASCII_9) && c != ASCII_PERIOD ------------------ | | 92| 3.04k|#define ASCII_0 0x30 ------------------ && ! (ASCII_0 <= c && c <= ASCII_9) && c != ASCII_PERIOD ------------------ | | 101| 1.98k|#define ASCII_9 0x39 ------------------ && ! (ASCII_0 <= c && c <= ASCII_9) && c != ASCII_PERIOD ------------------ | | 110| 6.88k|#define ASCII_PERIOD 0x2E ------------------ | Branch (1007:15): [True: 1.98k, False: 1.05k] | Branch (1007:31): [True: 1.50k, False: 481] | Branch (1007:48): [True: 805, False: 732] ------------------ 1008| 805| && c != ASCII_MINUS && c != ASCII_UNDERSCORE) { ------------------ | | 109| 6.14k|#define ASCII_MINUS 0x2D ------------------ && c != ASCII_MINUS && c != ASCII_UNDERSCORE) { ------------------ | | 118| 565|#define ASCII_UNDERSCORE 0x5F ------------------ | Branch (1008:12): [True: 565, False: 240] | Branch (1008:32): [True: 113, False: 452] ------------------ 1009| 113| *nextTokPtr = ptr; 1010| 113| return 0; 1011| 113| } 1012| 5.34k| } 1013| 419| *nextTokPtr = ptr + enc->minBytesPerChar; 1014| 419| return 1; 1015| 532|} xmltok.c:checkXmlDeclVersionNum: 1043| 320| const char *valEnd) { 1044| 320| if (valEnd - val < 2 * enc->minBytesPerChar ------------------ | Branch (1044:7): [True: 11, False: 309] ------------------ 1045| 309| || ! XmlNameMatchesAscii(enc, val, val + 2 * enc->minBytesPerChar, ------------------ | | 254| 309| (((enc)->nameMatchesAscii)(enc, ptr1, end1, ptr2)) ------------------ | Branch (1045:10): [True: 60, False: 249] ------------------ 1046| 320| KW_1_dot)) 1047| 71| return false; 1048| 249| val += 2 * enc->minBytesPerChar; 1049| 249| if (val == valEnd) ------------------ | Branch (1049:7): [True: 1, False: 248] ------------------ 1050| 1| return false; 1051| 1.27k| for (; val != valEnd; val += enc->minBytesPerChar) { ------------------ | Branch (1051:10): [True: 1.03k, False: 238] ------------------ 1052| 1.03k| int c = toAscii(enc, val, valEnd); 1053| 1.03k| if (c < ASCII_0 || c > ASCII_9) ------------------ | | 92| 2.06k|#define ASCII_0 0x30 ------------------ if (c < ASCII_0 || c > ASCII_9) ------------------ | | 101| 1.03k|#define ASCII_9 0x39 ------------------ | Branch (1053:9): [True: 2, False: 1.03k] | Branch (1053:24): [True: 8, False: 1.02k] ------------------ 1054| 10| return false; 1055| 1.03k| } 1056| 238| return true; 1057| 248|} xmltok.c:toAscii: 915| 14.8k|toAscii(const ENCODING *enc, const char *ptr, const char *end) { 916| 14.8k| char buf[1]; 917| 14.8k| char *p = buf; 918| 14.8k| XmlUtf8Convert(enc, &ptr, end, &p, p + 1); ------------------ | | 275| 14.8k| (((enc)->utf8Convert)(enc, fromP, fromLim, toP, toLim)) ------------------ 919| 14.8k| if (p == buf) ------------------ | Branch (919:7): [True: 161, False: 14.7k] ------------------ 920| 161| return -1; 921| 14.7k| else 922| 14.7k| return buf[0]; 923| 14.8k|} xmltok.c:isSpace: 926| 7.41k|isSpace(int c) { 927| 7.41k| switch (c) { ------------------ | Branch (927:11): [True: 1.62k, False: 5.78k] ------------------ 928| 1.55k| case 0x20: ------------------ | Branch (928:3): [True: 1.55k, False: 5.86k] ------------------ 929| 1.58k| case 0xD: ------------------ | Branch (929:3): [True: 31, False: 7.38k] ------------------ 930| 1.60k| case 0xA: ------------------ | Branch (930:3): [True: 21, False: 7.39k] ------------------ 931| 1.62k| case 0x9: ------------------ | Branch (931:3): [True: 20, False: 7.39k] ------------------ 932| 1.62k| return 1; 933| 7.41k| } 934| 5.78k| return 0; 935| 7.41k|} xmltok.c:normal_prologTok: 1018| 160k| const char **nextTokPtr) { 1019| 160k| int tok; 1020| 160k| if (ptr >= end) ------------------ | Branch (1020:7): [True: 255, False: 159k] ------------------ 1021| 255| return XML_TOK_NONE; ------------------ | | 51| 255|# define XML_TOK_NONE -4 /* The string to be scanned is empty */ ------------------ 1022| 159k| if (MINBPC(enc) > 1) { ------------------ | | 228| 159k|#define MINBPC(enc) 1 ------------------ | Branch (1022:7): [Folded, False: 159k] ------------------ 1023| 0| size_t n = end - ptr; 1024| 0| if (n & (MINBPC(enc) - 1)) { ------------------ | | 228| 0|#define MINBPC(enc) 1 ------------------ | Branch (1024:9): [True: 0, False: 0] ------------------ 1025| 0| n &= ~(MINBPC(enc) - 1); ------------------ | | 228| 0|#define MINBPC(enc) 1 ------------------ 1026| 0| if (n == 0) ------------------ | Branch (1026:11): [True: 0, False: 0] ------------------ 1027| 0| return XML_TOK_PARTIAL; ------------------ | | 56| 0|# define XML_TOK_PARTIAL -1 /* only part of a token */ ------------------ 1028| 0| end = ptr + n; 1029| 0| } 1030| 0| } 1031| 159k| switch (BYTE_TYPE(enc, ptr)) { ------------------ | | 233| 159k|#define BYTE_TYPE(enc, p) SB_BYTE_TYPE(enc, p) | | ------------------ | | | | 231| 159k| (((const struct normal_encoding *)(enc))->type[(unsigned char)*(p)]) | | ------------------ ------------------ 1032| 1.12k| case BT_QUOT: ------------------ | Branch (1032:3): [True: 1.12k, False: 158k] ------------------ 1033| 1.12k| return PREFIX(scanLit)(BT_QUOT, enc, ptr + MINBPC(enc), end, nextTokPtr); ------------------ | | 248| 1.12k|#define PREFIX(ident) normal_##ident ------------------ return PREFIX(scanLit)(BT_QUOT, enc, ptr + MINBPC(enc), end, nextTokPtr); ------------------ | | 228| 1.12k|#define MINBPC(enc) 1 ------------------ 1034| 8.68k| case BT_APOS: ------------------ | Branch (1034:3): [True: 8.68k, False: 151k] ------------------ 1035| 8.68k| return PREFIX(scanLit)(BT_APOS, enc, ptr + MINBPC(enc), end, nextTokPtr); ------------------ | | 248| 8.68k|#define PREFIX(ident) normal_##ident ------------------ return PREFIX(scanLit)(BT_APOS, enc, ptr + MINBPC(enc), end, nextTokPtr); ------------------ | | 228| 8.68k|#define MINBPC(enc) 1 ------------------ 1036| 25.7k| case BT_LT: { ------------------ | Branch (1036:3): [True: 25.7k, False: 133k] ------------------ 1037| 25.7k| ptr += MINBPC(enc); ------------------ | | 228| 25.7k|#define MINBPC(enc) 1 ------------------ 1038| 25.7k| REQUIRE_CHAR(enc, ptr, end); ------------------ | | 140| 25.7k|# define REQUIRE_CHAR(enc, ptr, end) REQUIRE_CHARS(enc, ptr, end, 1) | | ------------------ | | | | 134| 25.7k| { \ | | | | 135| 25.7k| if (! HAS_CHARS(enc, ptr, end, count)) { \ | | | | ------------------ | | | | | | 129| 25.7k| ((end) - (ptr) >= ((count) * MINBPC(enc))) | | | | | | ------------------ | | | | | | | | 228| 25.7k|#define MINBPC(enc) 1 | | | | | | ------------------ | | | | ------------------ | | | | | Branch (135:11): [True: 0, False: 25.7k] | | | | ------------------ | | | | 136| 0| return XML_TOK_PARTIAL; \ | | | | ------------------ | | | | | | 56| 0|# define XML_TOK_PARTIAL -1 /* only part of a token */ | | | | ------------------ | | | | 137| 0| } \ | | | | 138| 25.7k| } | | ------------------ ------------------ 1039| 25.7k| switch (BYTE_TYPE(enc, ptr)) { ------------------ | | 233| 25.7k|#define BYTE_TYPE(enc, p) SB_BYTE_TYPE(enc, p) | | ------------------ | | | | 231| 25.7k| (((const struct normal_encoding *)(enc))->type[(unsigned char)*(p)]) | | | | ------------------ | | | | | Branch (231:3): [True: 24.9k, False: 831] | | | | ------------------ | | ------------------ ------------------ 1040| 16.7k| case BT_EXCL: ------------------ | Branch (1040:5): [True: 16.7k, False: 8.98k] ------------------ 1041| 16.7k| return PREFIX(scanDecl)(enc, ptr + MINBPC(enc), end, nextTokPtr); ------------------ | | 248| 16.7k|#define PREFIX(ident) normal_##ident ------------------ return PREFIX(scanDecl)(enc, ptr + MINBPC(enc), end, nextTokPtr); ------------------ | | 228| 16.7k|#define MINBPC(enc) 1 ------------------ 1042| 3.54k| case BT_QUEST: ------------------ | Branch (1042:5): [True: 3.54k, False: 22.2k] ------------------ 1043| 3.54k| return PREFIX(scanPi)(enc, ptr + MINBPC(enc), end, nextTokPtr); ------------------ | | 248| 3.54k|#define PREFIX(ident) normal_##ident ------------------ return PREFIX(scanPi)(enc, ptr + MINBPC(enc), end, nextTokPtr); ------------------ | | 228| 3.54k|#define MINBPC(enc) 1 ------------------ 1044| 4.02k| case BT_NMSTRT: ------------------ | Branch (1044:5): [True: 4.02k, False: 21.7k] ------------------ 1045| 4.57k| case BT_HEX: ------------------ | Branch (1045:5): [True: 550, False: 25.2k] ------------------ 1046| 4.57k| case BT_NONASCII: ------------------ | Branch (1046:5): [True: 0, False: 25.7k] ------------------ 1047| 4.59k| case BT_LEAD2: ------------------ | Branch (1047:5): [True: 25, False: 25.7k] ------------------ 1048| 4.61k| case BT_LEAD3: ------------------ | Branch (1048:5): [True: 19, False: 25.7k] ------------------ 1049| 4.61k| case BT_LEAD4: ------------------ | Branch (1049:5): [True: 3, False: 25.7k] ------------------ 1050| 4.61k| *nextTokPtr = ptr - MINBPC(enc); ------------------ | | 228| 4.61k|#define MINBPC(enc) 1 ------------------ 1051| 4.61k| return XML_TOK_INSTANCE_START; ------------------ | | 96| 4.61k|# define XML_TOK_INSTANCE_START 29 ------------------ 1052| 25.7k| } 1053| 831| *nextTokPtr = ptr; 1054| 831| return XML_TOK_INVALID; ------------------ | | 57| 831|# define XML_TOK_INVALID 0 ------------------ 1055| 25.7k| } 1056| 668| case BT_CR: ------------------ | Branch (1056:3): [True: 668, False: 159k] ------------------ 1057| 668| if (ptr + MINBPC(enc) == end) { ------------------ | | 228| 668|#define MINBPC(enc) 1 ------------------ | Branch (1057:9): [True: 0, False: 668] ------------------ 1058| 0| *nextTokPtr = end; 1059| | /* indicate that this might be part of a CR/LF pair */ 1060| 0| return -XML_TOK_PROLOG_S; ------------------ | | 82| 0|# define XML_TOK_PROLOG_S 15 ------------------ 1061| 0| } 1062| 668| EXPAT_FALLTHROUGH; ------------------ | | 47| 668|# define EXPAT_FALLTHROUGH __attribute__((fallthrough)) ------------------ 1063| 46.2k| case BT_S: ------------------ | Branch (1063:3): [True: 45.5k, False: 114k] ------------------ 1064| 46.9k| case BT_LF: ------------------ | Branch (1064:3): [True: 688, False: 159k] ------------------ 1065| 47.7k| for (;;) { 1066| 47.7k| ptr += MINBPC(enc); ------------------ | | 228| 47.7k|#define MINBPC(enc) 1 ------------------ 1067| 47.7k| if (! HAS_CHAR(enc, ptr, end)) ------------------ | | 131| 47.7k|# define HAS_CHAR(enc, ptr, end) HAS_CHARS(enc, ptr, end, 1) | | ------------------ | | | | 129| 47.7k| ((end) - (ptr) >= ((count) * MINBPC(enc))) | | | | ------------------ | | | | | | 228| 47.7k|#define MINBPC(enc) 1 | | | | ------------------ | | ------------------ ------------------ | Branch (1067:11): [True: 0, False: 47.7k] ------------------ 1068| 0| break; 1069| 47.7k| switch (BYTE_TYPE(enc, ptr)) { ------------------ | | 233| 47.7k|#define BYTE_TYPE(enc, p) SB_BYTE_TYPE(enc, p) | | ------------------ | | | | 231| 47.7k| (((const struct normal_encoding *)(enc))->type[(unsigned char)*(p)]) | | ------------------ ------------------ 1070| 469| case BT_S: ------------------ | Branch (1070:7): [True: 469, False: 47.3k] ------------------ 1071| 667| case BT_LF: ------------------ | Branch (1071:7): [True: 198, False: 47.5k] ------------------ 1072| 667| break; 1073| 197| case BT_CR: ------------------ | Branch (1073:7): [True: 197, False: 47.5k] ------------------ 1074| | /* don't split CR/LF pair */ 1075| 197| if (ptr + MINBPC(enc) != end) ------------------ | | 228| 197|#define MINBPC(enc) 1 ------------------ | Branch (1075:13): [True: 197, False: 0] ------------------ 1076| 197| break; 1077| 0| EXPAT_FALLTHROUGH; ------------------ | | 47| 0|# define EXPAT_FALLTHROUGH __attribute__((fallthrough)) ------------------ 1078| 46.9k| default: ------------------ | Branch (1078:7): [True: 46.9k, False: 864] ------------------ 1079| 46.9k| *nextTokPtr = ptr; 1080| 46.9k| return XML_TOK_PROLOG_S; ------------------ | | 82| 46.9k|# define XML_TOK_PROLOG_S 15 ------------------ 1081| 47.7k| } 1082| 47.7k| } 1083| 0| *nextTokPtr = ptr; 1084| 0| return XML_TOK_PROLOG_S; ------------------ | | 82| 0|# define XML_TOK_PROLOG_S 15 ------------------ 1085| 1.95k| case BT_PERCNT: ------------------ | Branch (1085:3): [True: 1.95k, False: 157k] ------------------ 1086| 1.95k| return PREFIX(scanPercent)(enc, ptr + MINBPC(enc), end, nextTokPtr); ------------------ | | 248| 1.95k|#define PREFIX(ident) normal_##ident ------------------ return PREFIX(scanPercent)(enc, ptr + MINBPC(enc), end, nextTokPtr); ------------------ | | 228| 1.95k|#define MINBPC(enc) 1 ------------------ 1087| 1.64k| case BT_COMMA: ------------------ | Branch (1087:3): [True: 1.64k, False: 158k] ------------------ 1088| 1.64k| *nextTokPtr = ptr + MINBPC(enc); ------------------ | | 228| 1.64k|#define MINBPC(enc) 1 ------------------ 1089| 1.64k| return XML_TOK_COMMA; ------------------ | | 107| 1.64k|# define XML_TOK_COMMA 38 ------------------ 1090| 3.35k| case BT_LSQB: ------------------ | Branch (1090:3): [True: 3.35k, False: 156k] ------------------ 1091| 3.35k| *nextTokPtr = ptr + MINBPC(enc); ------------------ | | 228| 3.35k|#define MINBPC(enc) 1 ------------------ 1092| 3.35k| return XML_TOK_OPEN_BRACKET; ------------------ | | 92| 3.35k|# define XML_TOK_OPEN_BRACKET 25 ------------------ 1093| 1.65k| case BT_RSQB: ------------------ | Branch (1093:3): [True: 1.65k, False: 158k] ------------------ 1094| 1.65k| ptr += MINBPC(enc); ------------------ | | 228| 1.65k|#define MINBPC(enc) 1 ------------------ 1095| 1.65k| if (! HAS_CHAR(enc, ptr, end)) ------------------ | | 131| 1.65k|# define HAS_CHAR(enc, ptr, end) HAS_CHARS(enc, ptr, end, 1) | | ------------------ | | | | 129| 1.65k| ((end) - (ptr) >= ((count) * MINBPC(enc))) | | | | ------------------ | | | | | | 228| 1.65k|#define MINBPC(enc) 1 | | | | ------------------ | | ------------------ ------------------ | Branch (1095:9): [True: 0, False: 1.65k] ------------------ 1096| 0| return -XML_TOK_CLOSE_BRACKET; ------------------ | | 93| 0|# define XML_TOK_CLOSE_BRACKET 26 ------------------ 1097| 1.65k| if (CHAR_MATCHES(enc, ptr, ASCII_RSQB)) { ------------------ | | 246| 1.65k|#define CHAR_MATCHES(enc, p, c) (*(p) == (c)) | | ------------------ | | | Branch (246:33): [True: 19, False: 1.64k] | | ------------------ ------------------ 1098| 19| REQUIRE_CHARS(enc, ptr, end, 2); ------------------ | | 134| 19| { \ | | 135| 19| if (! HAS_CHARS(enc, ptr, end, count)) { \ | | ------------------ | | | | 129| 19| ((end) - (ptr) >= ((count) * MINBPC(enc))) | | | | ------------------ | | | | | | 228| 19|#define MINBPC(enc) 1 | | | | ------------------ | | ------------------ | | | Branch (135:11): [True: 0, False: 19] | | ------------------ | | 136| 0| return XML_TOK_PARTIAL; \ | | ------------------ | | | | 56| 0|# define XML_TOK_PARTIAL -1 /* only part of a token */ | | ------------------ | | 137| 0| } \ | | 138| 19| } ------------------ 1099| 19| if (CHAR_MATCHES(enc, ptr + MINBPC(enc), ASCII_GT)) { ------------------ | | 246| 19|#define CHAR_MATCHES(enc, p, c) (*(p) == (c)) | | ------------------ | | | Branch (246:33): [True: 1, False: 18] | | ------------------ ------------------ 1100| 1| *nextTokPtr = ptr + 2 * MINBPC(enc); ------------------ | | 228| 1|#define MINBPC(enc) 1 ------------------ 1101| 1| return XML_TOK_COND_SECT_CLOSE; ------------------ | | 103| 1|# define XML_TOK_COND_SECT_CLOSE 34 /* ]]> */ ------------------ 1102| 1| } 1103| 19| } 1104| 1.65k| *nextTokPtr = ptr; 1105| 1.65k| return XML_TOK_CLOSE_BRACKET; ------------------ | | 93| 1.65k|# define XML_TOK_CLOSE_BRACKET 26 ------------------ 1106| 9.16k| case BT_LPAR: ------------------ | Branch (1106:3): [True: 9.16k, False: 150k] ------------------ 1107| 9.16k| *nextTokPtr = ptr + MINBPC(enc); ------------------ | | 228| 9.16k|#define MINBPC(enc) 1 ------------------ 1108| 9.16k| return XML_TOK_OPEN_PAREN; ------------------ | | 90| 9.16k|# define XML_TOK_OPEN_PAREN 23 ------------------ 1109| 3.39k| case BT_RPAR: ------------------ | Branch (1109:3): [True: 3.39k, False: 156k] ------------------ 1110| 3.39k| ptr += MINBPC(enc); ------------------ | | 228| 3.39k|#define MINBPC(enc) 1 ------------------ 1111| 3.39k| if (! HAS_CHAR(enc, ptr, end)) ------------------ | | 131| 3.39k|# define HAS_CHAR(enc, ptr, end) HAS_CHARS(enc, ptr, end, 1) | | ------------------ | | | | 129| 3.39k| ((end) - (ptr) >= ((count) * MINBPC(enc))) | | | | ------------------ | | | | | | 228| 3.39k|#define MINBPC(enc) 1 | | | | ------------------ | | ------------------ ------------------ | Branch (1111:9): [True: 0, False: 3.39k] ------------------ 1112| 0| return -XML_TOK_CLOSE_PAREN; ------------------ | | 91| 0|# define XML_TOK_CLOSE_PAREN 24 ------------------ 1113| 3.39k| switch (BYTE_TYPE(enc, ptr)) { ------------------ | | 233| 3.39k|#define BYTE_TYPE(enc, p) SB_BYTE_TYPE(enc, p) | | ------------------ | | | | 231| 3.39k| (((const struct normal_encoding *)(enc))->type[(unsigned char)*(p)]) | | | | ------------------ | | | | | Branch (231:3): [True: 3.38k, False: 8] | | | | ------------------ | | ------------------ ------------------ 1114| 285| case BT_AST: ------------------ | Branch (1114:5): [True: 285, False: 3.10k] ------------------ 1115| 285| *nextTokPtr = ptr + MINBPC(enc); ------------------ | | 228| 285|#define MINBPC(enc) 1 ------------------ 1116| 285| return XML_TOK_CLOSE_PAREN_ASTERISK; ------------------ | | 105| 285|# define XML_TOK_CLOSE_PAREN_ASTERISK 36 /* )* */ ------------------ 1117| 258| case BT_QUEST: ------------------ | Branch (1117:5): [True: 258, False: 3.13k] ------------------ 1118| 258| *nextTokPtr = ptr + MINBPC(enc); ------------------ | | 228| 258|#define MINBPC(enc) 1 ------------------ 1119| 258| return XML_TOK_CLOSE_PAREN_QUESTION; ------------------ | | 104| 258|# define XML_TOK_CLOSE_PAREN_QUESTION 35 /* )? */ ------------------ 1120| 331| case BT_PLUS: ------------------ | Branch (1120:5): [True: 331, False: 3.06k] ------------------ 1121| 331| *nextTokPtr = ptr + MINBPC(enc); ------------------ | | 228| 331|#define MINBPC(enc) 1 ------------------ 1122| 331| return XML_TOK_CLOSE_PAREN_PLUS; ------------------ | | 106| 331|# define XML_TOK_CLOSE_PAREN_PLUS 37 /* )+ */ ------------------ 1123| 66| case BT_CR: ------------------ | Branch (1123:5): [True: 66, False: 3.32k] ------------------ 1124| 132| case BT_LF: ------------------ | Branch (1124:5): [True: 66, False: 3.32k] ------------------ 1125| 813| case BT_S: ------------------ | Branch (1125:5): [True: 681, False: 2.71k] ------------------ 1126| 1.44k| case BT_GT: ------------------ | Branch (1126:5): [True: 627, False: 2.76k] ------------------ 1127| 1.64k| case BT_COMMA: ------------------ | Branch (1127:5): [True: 206, False: 3.18k] ------------------ 1128| 1.85k| case BT_VERBAR: ------------------ | Branch (1128:5): [True: 211, False: 3.18k] ------------------ 1129| 2.51k| case BT_RPAR: ------------------ | Branch (1129:5): [True: 653, False: 2.73k] ------------------ 1130| 2.51k| *nextTokPtr = ptr; 1131| 2.51k| return XML_TOK_CLOSE_PAREN; ------------------ | | 91| 2.51k|# define XML_TOK_CLOSE_PAREN 24 ------------------ 1132| 3.39k| } 1133| 8| *nextTokPtr = ptr; 1134| 8| return XML_TOK_INVALID; ------------------ | | 57| 8|# define XML_TOK_INVALID 0 ------------------ 1135| 6.64k| case BT_VERBAR: ------------------ | Branch (1135:3): [True: 6.64k, False: 153k] ------------------ 1136| 6.64k| *nextTokPtr = ptr + MINBPC(enc); ------------------ | | 228| 6.64k|#define MINBPC(enc) 1 ------------------ 1137| 6.64k| return XML_TOK_OR; ------------------ | | 88| 6.64k|# define XML_TOK_OR 21 /* | */ ------------------ 1138| 12.7k| case BT_GT: ------------------ | Branch (1138:3): [True: 12.7k, False: 147k] ------------------ 1139| 12.7k| *nextTokPtr = ptr + MINBPC(enc); ------------------ | | 228| 12.7k|#define MINBPC(enc) 1 ------------------ 1140| 12.7k| return XML_TOK_DECL_CLOSE; ------------------ | | 84| 12.7k|# define XML_TOK_DECL_CLOSE 17 /* > */ ------------------ 1141| 1.36k| case BT_NUM: ------------------ | Branch (1141:3): [True: 1.36k, False: 158k] ------------------ 1142| 1.36k| return PREFIX(scanPoundName)(enc, ptr + MINBPC(enc), end, nextTokPtr); ------------------ | | 248| 1.36k|#define PREFIX(ident) normal_##ident ------------------ return PREFIX(scanPoundName)(enc, ptr + MINBPC(enc), end, nextTokPtr); ------------------ | | 228| 1.36k|#define MINBPC(enc) 1 ------------------ 1143| 0|# define LEAD_CASE(n) \ 1144| 0| case BT_LEAD##n: \ 1145| 0| if (end - ptr < n) \ 1146| 0| return XML_TOK_PARTIAL_CHAR; \ 1147| 0| if (IS_INVALID_CHAR(enc, ptr, n)) { \ 1148| 0| *nextTokPtr = ptr; \ 1149| 0| return XML_TOK_INVALID; \ 1150| 0| } \ 1151| 0| if (IS_NMSTRT_CHAR(enc, ptr, n)) { \ 1152| 0| ptr += n; \ 1153| 0| tok = XML_TOK_NAME; \ 1154| 0| break; \ 1155| 0| } \ 1156| 0| if (IS_NAME_CHAR(enc, ptr, n)) { \ 1157| 0| ptr += n; \ 1158| 0| tok = XML_TOK_NMTOKEN; \ 1159| 0| break; \ 1160| 0| } \ 1161| 0| *nextTokPtr = ptr; \ 1162| 0| return XML_TOK_INVALID; 1163| 490| LEAD_CASE(2) ------------------ | | 1144| 142| case BT_LEAD##n: \ | | ------------------ | | | Branch (1144:3): [True: 142, False: 159k] | | ------------------ | | 1145| 142| if (end - ptr < n) \ | | ------------------ | | | Branch (1145:9): [True: 0, False: 142] | | ------------------ | | 1146| 1| return XML_TOK_PARTIAL_CHAR; \ | | ------------------ | | | | 55| 0|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | ------------------ | | 1147| 142| if (IS_INVALID_CHAR(enc, ptr, n)) { \ | | ------------------ | | | | 240| 142| (AS_NORMAL_ENCODING(enc)->isInvalid##n(enc, p)) | | | | ------------------ | | | | | | 207| 142|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | ------------------ | | | | | Branch (240:3): [True: 5, False: 137] | | | | ------------------ | | ------------------ | | 1148| 5| *nextTokPtr = ptr; \ | | 1149| 5| return XML_TOK_INVALID; \ | | ------------------ | | | | 57| 5|# define XML_TOK_INVALID 0 | | ------------------ | | 1150| 5| } \ | | 1151| 142| if (IS_NMSTRT_CHAR(enc, ptr, n)) { \ | | ------------------ | | | | 238| 137|#define IS_NMSTRT_CHAR(enc, p, n) (AS_NORMAL_ENCODING(enc)->isNmstrt##n(enc, p)) | | | | ------------------ | | | | | | 207| 137|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | ------------------ | | | | | Branch (238:35): [True: 68, False: 69] | | | | ------------------ | | ------------------ | | 1152| 68| ptr += n; \ | | 1153| 68| tok = XML_TOK_NAME; \ | | ------------------ | | | | 85| 68|# define XML_TOK_NAME 18 | | ------------------ | | 1154| 68| break; \ | | 1155| 68| } \ | | 1156| 137| if (IS_NAME_CHAR(enc, ptr, n)) { \ | | ------------------ | | | | 237| 69|#define IS_NAME_CHAR(enc, p, n) (AS_NORMAL_ENCODING(enc)->isName##n(enc, p)) | | | | ------------------ | | | | | | 207| 69|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | ------------------ | | | | | Branch (237:33): [True: 68, False: 1] | | | | ------------------ | | ------------------ | | 1157| 68| ptr += n; \ | | 1158| 68| tok = XML_TOK_NMTOKEN; \ | | ------------------ | | | | 86| 68|# define XML_TOK_NMTOKEN 19 | | ------------------ | | 1159| 68| break; \ | | 1160| 68| } \ | | 1161| 69| *nextTokPtr = ptr; \ | | 1162| 1| return XML_TOK_INVALID; | | ------------------ | | | | 57| 1|# define XML_TOK_INVALID 0 | | ------------------ ------------------ 1164| 498| LEAD_CASE(3) ------------------ | | 1144| 146| case BT_LEAD##n: \ | | ------------------ | | | Branch (1144:3): [True: 146, False: 159k] | | ------------------ | | 1145| 146| if (end - ptr < n) \ | | ------------------ | | | Branch (1145:9): [True: 0, False: 146] | | ------------------ | | 1146| 1| return XML_TOK_PARTIAL_CHAR; \ | | ------------------ | | | | 55| 0|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | ------------------ | | 1147| 146| if (IS_INVALID_CHAR(enc, ptr, n)) { \ | | ------------------ | | | | 240| 146| (AS_NORMAL_ENCODING(enc)->isInvalid##n(enc, p)) | | | | ------------------ | | | | | | 207| 146|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | ------------------ | | | | | Branch (240:3): [True: 10, False: 136] | | | | ------------------ | | ------------------ | | 1148| 10| *nextTokPtr = ptr; \ | | 1149| 10| return XML_TOK_INVALID; \ | | ------------------ | | | | 57| 10|# define XML_TOK_INVALID 0 | | ------------------ | | 1150| 10| } \ | | 1151| 146| if (IS_NMSTRT_CHAR(enc, ptr, n)) { \ | | ------------------ | | | | 238| 136|#define IS_NMSTRT_CHAR(enc, p, n) (AS_NORMAL_ENCODING(enc)->isNmstrt##n(enc, p)) | | | | ------------------ | | | | | | 207| 136|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | ------------------ | | | | | Branch (238:35): [True: 66, False: 70] | | | | ------------------ | | ------------------ | | 1152| 66| ptr += n; \ | | 1153| 66| tok = XML_TOK_NAME; \ | | ------------------ | | | | 85| 66|# define XML_TOK_NAME 18 | | ------------------ | | 1154| 66| break; \ | | 1155| 66| } \ | | 1156| 136| if (IS_NAME_CHAR(enc, ptr, n)) { \ | | ------------------ | | | | 237| 70|#define IS_NAME_CHAR(enc, p, n) (AS_NORMAL_ENCODING(enc)->isName##n(enc, p)) | | | | ------------------ | | | | | | 207| 70|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | ------------------ | | | | | Branch (237:33): [True: 69, False: 1] | | | | ------------------ | | ------------------ | | 1157| 69| ptr += n; \ | | 1158| 69| tok = XML_TOK_NMTOKEN; \ | | ------------------ | | | | 86| 69|# define XML_TOK_NMTOKEN 19 | | ------------------ | | 1159| 69| break; \ | | 1160| 69| } \ | | 1161| 70| *nextTokPtr = ptr; \ | | 1162| 1| return XML_TOK_INVALID; | | ------------------ | | | | 57| 1|# define XML_TOK_INVALID 0 | | ------------------ ------------------ 1165| 9| LEAD_CASE(4) ------------------ | | 1144| 4| case BT_LEAD##n: \ | | ------------------ | | | Branch (1144:3): [True: 4, False: 159k] | | ------------------ | | 1145| 4| if (end - ptr < n) \ | | ------------------ | | | Branch (1145:9): [True: 1, False: 3] | | ------------------ | | 1146| 1| return XML_TOK_PARTIAL_CHAR; \ | | ------------------ | | | | 55| 1|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | ------------------ | | 1147| 3| if (IS_INVALID_CHAR(enc, ptr, n)) { \ | | ------------------ | | | | 240| 3| (AS_NORMAL_ENCODING(enc)->isInvalid##n(enc, p)) | | | | ------------------ | | | | | | 207| 3|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | ------------------ | | | | | Branch (240:3): [True: 2, False: 1] | | | | ------------------ | | ------------------ | | 1148| 2| *nextTokPtr = ptr; \ | | 1149| 2| return XML_TOK_INVALID; \ | | ------------------ | | | | 57| 2|# define XML_TOK_INVALID 0 | | ------------------ | | 1150| 2| } \ | | 1151| 3| if (IS_NMSTRT_CHAR(enc, ptr, n)) { \ | | ------------------ | | | | 238| 1|#define IS_NMSTRT_CHAR(enc, p, n) (AS_NORMAL_ENCODING(enc)->isNmstrt##n(enc, p)) | | | | ------------------ | | | | | | 207| 1|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | ------------------ | | | | | Branch (238:35): [True: 0, False: 1] | | | | ------------------ | | ------------------ | | 1152| 0| ptr += n; \ | | 1153| 0| tok = XML_TOK_NAME; \ | | ------------------ | | | | 85| 0|# define XML_TOK_NAME 18 | | ------------------ | | 1154| 0| break; \ | | 1155| 0| } \ | | 1156| 1| if (IS_NAME_CHAR(enc, ptr, n)) { \ | | ------------------ | | | | 237| 1|#define IS_NAME_CHAR(enc, p, n) (AS_NORMAL_ENCODING(enc)->isName##n(enc, p)) | | | | ------------------ | | | | | | 207| 1|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | ------------------ | | | | | Branch (237:33): [True: 0, False: 1] | | | | ------------------ | | ------------------ | | 1157| 0| ptr += n; \ | | 1158| 0| tok = XML_TOK_NMTOKEN; \ | | ------------------ | | | | 86| 0|# define XML_TOK_NMTOKEN 19 | | ------------------ | | 1159| 0| break; \ | | 1160| 0| } \ | | 1161| 1| *nextTokPtr = ptr; \ | | 1162| 1| return XML_TOK_INVALID; | | ------------------ | | | | 57| 1|# define XML_TOK_INVALID 0 | | ------------------ ------------------ 1166| 0|# undef LEAD_CASE 1167| 27.0k| case BT_NMSTRT: ------------------ | Branch (1167:3): [True: 27.0k, False: 132k] ------------------ 1168| 33.6k| case BT_HEX: ------------------ | Branch (1168:3): [True: 6.65k, False: 153k] ------------------ 1169| 33.6k| tok = XML_TOK_NAME; ------------------ | | 85| 33.6k|# define XML_TOK_NAME 18 ------------------ 1170| 33.6k| ptr += MINBPC(enc); ------------------ | | 228| 33.6k|#define MINBPC(enc) 1 ------------------ 1171| 33.6k| break; 1172| 271| case BT_DIGIT: ------------------ | Branch (1172:3): [True: 271, False: 159k] ------------------ 1173| 478| case BT_NAME: ------------------ | Branch (1173:3): [True: 207, False: 159k] ------------------ 1174| 916| case BT_MINUS: ------------------ | Branch (1174:3): [True: 438, False: 159k] ------------------ 1175| 916|# ifdef XML_NS 1176| 1.33k| case BT_COLON: ------------------ | Branch (1176:3): [True: 417, False: 159k] ------------------ 1177| 1.33k|# endif 1178| 1.33k| tok = XML_TOK_NMTOKEN; ------------------ | | 86| 1.33k|# define XML_TOK_NMTOKEN 19 ------------------ 1179| 1.33k| ptr += MINBPC(enc); ------------------ | | 228| 1.33k|#define MINBPC(enc) 1 ------------------ 1180| 1.33k| break; 1181| 0| case BT_NONASCII: ------------------ | Branch (1181:3): [True: 0, False: 159k] ------------------ 1182| 0| if (IS_NMSTRT_CHAR_MINBPC(enc, ptr)) { ------------------ | | 243| 0|#define IS_NMSTRT_CHAR_MINBPC(enc, p) (0) | | ------------------ | | | Branch (243:39): [Folded, False: 0] | | ------------------ ------------------ 1183| 0| ptr += MINBPC(enc); ------------------ | | 228| 0|#define MINBPC(enc) 1 ------------------ 1184| 0| tok = XML_TOK_NAME; ------------------ | | 85| 0|# define XML_TOK_NAME 18 ------------------ 1185| 0| break; 1186| 0| } 1187| 0| if (IS_NAME_CHAR_MINBPC(enc, ptr)) { ------------------ | | 242| 0|#define IS_NAME_CHAR_MINBPC(enc, p) (0) | | ------------------ | | | Branch (242:37): [Folded, False: 0] | | ------------------ ------------------ 1188| 0| ptr += MINBPC(enc); ------------------ | | 228| 0|#define MINBPC(enc) 1 ------------------ 1189| 0| tok = XML_TOK_NMTOKEN; ------------------ | | 86| 0|# define XML_TOK_NMTOKEN 19 ------------------ 1190| 0| break; 1191| 0| } 1192| 0| EXPAT_FALLTHROUGH; ------------------ | | 47| 0|# define EXPAT_FALLTHROUGH __attribute__((fallthrough)) ------------------ 1193| 42| default: ------------------ | Branch (1193:3): [True: 42, False: 159k] ------------------ 1194| 42| *nextTokPtr = ptr; 1195| 42| return XML_TOK_INVALID; ------------------ | | 57| 42|# define XML_TOK_INVALID 0 ------------------ 1196| 159k| } 1197| 65.0k| while (HAS_CHAR(enc, ptr, end)) { 1198| 65.0k| switch (BYTE_TYPE(enc, ptr)) { ------------------ | | 233| 65.0k|#define BYTE_TYPE(enc, p) SB_BYTE_TYPE(enc, p) | | ------------------ | | | | 231| 65.0k| (((const struct normal_encoding *)(enc))->type[(unsigned char)*(p)]) | | ------------------ ------------------ 1199| 94.8k| CHECK_NAME_CASES(enc, ptr, end, nextTokPtr) ------------------ | | 81| 26.6k| case BT_NONASCII: \ | | ------------------ | | | Branch (81:3): [True: 0, False: 65.0k] | | ------------------ | | 82| 26.6k| if (! IS_NAME_CHAR_MINBPC(enc, ptr)) { \ | | ------------------ | | | | 242| 0|#define IS_NAME_CHAR_MINBPC(enc, p) (0) | | ------------------ | | | Branch (82:9): [True: 0, Folded] | | ------------------ | | 83| 0| *nextTokPtr = ptr; \ | | 84| 0| return XML_TOK_INVALID; \ | | ------------------ | | | | 57| 0|# define XML_TOK_INVALID 0 | | ------------------ | | 85| 0| } \ | | 86| 26.6k| EXPAT_FALLTHROUGH; \ | | ------------------ | | | | 47| 0|# define EXPAT_FALLTHROUGH __attribute__((fallthrough)) | | ------------------ | | 87| 16.1k| case BT_NMSTRT: \ | | ------------------ | | | Branch (87:3): [True: 16.1k, False: 48.9k] | | ------------------ | | 88| 25.7k| case BT_HEX: \ | | ------------------ | | | Branch (88:3): [True: 9.64k, False: 55.3k] | | ------------------ | | 89| 26.2k| case BT_DIGIT: \ | | ------------------ | | | Branch (89:3): [True: 418, False: 64.6k] | | ------------------ | | 90| 26.4k| case BT_NAME: \ | | ------------------ | | | Branch (90:3): [True: 212, False: 64.8k] | | ------------------ | | 91| 26.6k| case BT_MINUS: \ | | ------------------ | | | Branch (91:3): [True: 282, False: 64.7k] | | ------------------ | | 92| 26.6k| ptr += MINBPC(enc); \ | | ------------------ | | | | 228| 26.6k|#define MINBPC(enc) 1 | | ------------------ | | 93| 26.6k| break; \ | | 94| 26.6k| CHECK_NAME_CASE(2, enc, ptr, end, nextTokPtr) \ | | ------------------ | | | | 70| 83| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (70:3): [True: 83, False: 64.9k] | | | | ------------------ | | | | 71| 83| if (end - ptr < n) \ | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 83] | | | | ------------------ | | | | 72| 75| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 0|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 73| 83| if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NAME_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 240| 166| (AS_NORMAL_ENCODING(enc)->isInvalid##n(enc, p)) | | | | | | ------------------ | | | | | | | | 207| 83|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | | | ------------------ | | | | | | | Branch (240:3): [True: 7, False: 76] | | | | | | ------------------ | | | | ------------------ | | | | if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NAME_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 237| 76|#define IS_NAME_CHAR(enc, p, n) (AS_NORMAL_ENCODING(enc)->isName##n(enc, p)) | | | | | | ------------------ | | | | | | | | 207| 76|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (73:41): [True: 1, False: 75] | | | | ------------------ | | | | 74| 8| *nextTokPtr = ptr; \ | | | | 75| 8| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 8|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 76| 8| } \ | | | | 77| 83| ptr += n; \ | | | | 78| 75| break; | | ------------------ | | 95| 78| CHECK_NAME_CASE(3, enc, ptr, end, nextTokPtr) \ | | ------------------ | | | | 70| 78| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (70:3): [True: 78, False: 64.9k] | | | | ------------------ | | | | 71| 78| if (end - ptr < n) \ | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 78] | | | | ------------------ | | | | 72| 72| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 0|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 73| 78| if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NAME_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 240| 156| (AS_NORMAL_ENCODING(enc)->isInvalid##n(enc, p)) | | | | | | ------------------ | | | | | | | | 207| 78|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | | | ------------------ | | | | | | | Branch (240:3): [True: 5, False: 73] | | | | | | ------------------ | | | | ------------------ | | | | if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NAME_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 237| 73|#define IS_NAME_CHAR(enc, p, n) (AS_NORMAL_ENCODING(enc)->isName##n(enc, p)) | | | | | | ------------------ | | | | | | | | 207| 73|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (73:41): [True: 1, False: 72] | | | | ------------------ | | | | 74| 6| *nextTokPtr = ptr; \ | | | | 75| 6| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 6|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 76| 6| } \ | | | | 77| 78| ptr += n; \ | | | | 78| 72| break; | | ------------------ | | 96| 72| CHECK_NAME_CASE(4, enc, ptr, end, nextTokPtr) | | ------------------ | | | | 70| 5| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (70:3): [True: 5, False: 65.0k] | | | | ------------------ | | | | 71| 5| if (end - ptr < n) \ | | | | ------------------ | | | | | Branch (71:9): [True: 1, False: 4] | | | | ------------------ | | | | 72| 1| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 1|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 73| 4| if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NAME_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 240| 8| (AS_NORMAL_ENCODING(enc)->isInvalid##n(enc, p)) | | | | | | ------------------ | | | | | | | | 207| 4|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | | | ------------------ | | | | | | | Branch (240:3): [True: 3, False: 1] | | | | | | ------------------ | | | | ------------------ | | | | if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NAME_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 237| 1|#define IS_NAME_CHAR(enc, p, n) (AS_NORMAL_ENCODING(enc)->isName##n(enc, p)) | | | | | | ------------------ | | | | | | | | 207| 1|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (73:41): [True: 1, False: 0] | | | | ------------------ | | | | 74| 4| *nextTokPtr = ptr; \ | | | | 75| 4| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 4|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 76| 4| } \ | | | | 77| 4| ptr += n; \ | | | | 78| 0| break; | | ------------------ ------------------ 1200| 3.49k| case BT_GT: ------------------ | Branch (1200:5): [True: 3.49k, False: 61.5k] ------------------ 1201| 5.23k| case BT_RPAR: ------------------ | Branch (1201:5): [True: 1.74k, False: 63.3k] ------------------ 1202| 5.80k| case BT_COMMA: ------------------ | Branch (1202:5): [True: 573, False: 64.4k] ------------------ 1203| 10.5k| case BT_VERBAR: ------------------ | Branch (1203:5): [True: 4.76k, False: 60.2k] ------------------ 1204| 12.2k| case BT_LSQB: ------------------ | Branch (1204:5): [True: 1.66k, False: 63.3k] ------------------ 1205| 12.2k| case BT_PERCNT: ------------------ | Branch (1205:5): [True: 10, False: 65.0k] ------------------ 1206| 33.7k| case BT_S: ------------------ | Branch (1206:5): [True: 21.5k, False: 43.5k] ------------------ 1207| 33.9k| case BT_CR: ------------------ | Branch (1207:5): [True: 220, False: 64.8k] ------------------ 1208| 34.2k| case BT_LF: ------------------ | Branch (1208:5): [True: 288, False: 64.7k] ------------------ 1209| 34.2k| *nextTokPtr = ptr; 1210| 34.2k| return tok; 1211| 0|# ifdef XML_NS 1212| 2.95k| case BT_COLON: ------------------ | Branch (1212:5): [True: 2.95k, False: 62.0k] ------------------ 1213| 2.95k| ptr += MINBPC(enc); ------------------ | | 228| 2.95k|#define MINBPC(enc) 1 ------------------ 1214| 2.95k| switch (tok) { ------------------ | Branch (1214:15): [True: 2.69k, False: 266] ------------------ 1215| 2.38k| case XML_TOK_NAME: ------------------ | | 85| 2.38k|# define XML_TOK_NAME 18 ------------------ | Branch (1215:7): [True: 2.38k, False: 568] ------------------ 1216| 2.38k| REQUIRE_CHAR(enc, ptr, end); ------------------ | | 140| 2.38k|# define REQUIRE_CHAR(enc, ptr, end) REQUIRE_CHARS(enc, ptr, end, 1) | | ------------------ | | | | 134| 2.38k| { \ | | | | 135| 2.38k| if (! HAS_CHARS(enc, ptr, end, count)) { \ | | | | ------------------ | | | | | | 129| 2.38k| ((end) - (ptr) >= ((count) * MINBPC(enc))) | | | | | | ------------------ | | | | | | | | 228| 2.38k|#define MINBPC(enc) 1 | | | | | | ------------------ | | | | ------------------ | | | | | Branch (135:11): [True: 0, False: 2.38k] | | | | ------------------ | | | | 136| 0| return XML_TOK_PARTIAL; \ | | | | ------------------ | | | | | | 56| 0|# define XML_TOK_PARTIAL -1 /* only part of a token */ | | | | ------------------ | | | | 137| 0| } \ | | | | 138| 2.38k| } | | ------------------ ------------------ 1217| 2.38k| tok = XML_TOK_PREFIXED_NAME; ------------------ | | 118| 2.38k|# define XML_TOK_PREFIXED_NAME 41 ------------------ 1218| 2.38k| switch (BYTE_TYPE(enc, ptr)) { ------------------ | | 233| 2.38k|#define BYTE_TYPE(enc, p) SB_BYTE_TYPE(enc, p) | | ------------------ | | | | 231| 2.38k| (((const struct normal_encoding *)(enc))->type[(unsigned char)*(p)]) | | ------------------ ------------------ 1219| 5.44k| CHECK_NAME_CASES(enc, ptr, end, nextTokPtr) ------------------ | | 81| 2.02k| case BT_NONASCII: \ | | ------------------ | | | Branch (81:3): [True: 0, False: 2.38k] | | ------------------ | | 82| 2.02k| if (! IS_NAME_CHAR_MINBPC(enc, ptr)) { \ | | ------------------ | | | | 242| 0|#define IS_NAME_CHAR_MINBPC(enc, p) (0) | | ------------------ | | | Branch (82:9): [True: 0, Folded] | | ------------------ | | 83| 0| *nextTokPtr = ptr; \ | | 84| 0| return XML_TOK_INVALID; \ | | ------------------ | | | | 57| 0|# define XML_TOK_INVALID 0 | | ------------------ | | 85| 0| } \ | | 86| 2.02k| EXPAT_FALLTHROUGH; \ | | ------------------ | | | | 47| 0|# define EXPAT_FALLTHROUGH __attribute__((fallthrough)) | | ------------------ | | 87| 714| case BT_NMSTRT: \ | | ------------------ | | | Branch (87:3): [True: 714, False: 1.67k] | | ------------------ | | 88| 1.13k| case BT_HEX: \ | | ------------------ | | | Branch (88:3): [True: 417, False: 1.97k] | | ------------------ | | 89| 1.46k| case BT_DIGIT: \ | | ------------------ | | | Branch (89:3): [True: 338, False: 2.05k] | | ------------------ | | 90| 1.79k| case BT_NAME: \ | | ------------------ | | | Branch (90:3): [True: 325, False: 2.06k] | | ------------------ | | 91| 2.02k| case BT_MINUS: \ | | ------------------ | | | Branch (91:3): [True: 227, False: 2.16k] | | ------------------ | | 92| 2.02k| ptr += MINBPC(enc); \ | | ------------------ | | | | 228| 2.02k|#define MINBPC(enc) 1 | | ------------------ | | 93| 2.02k| break; \ | | 94| 2.02k| CHECK_NAME_CASE(2, enc, ptr, end, nextTokPtr) \ | | ------------------ | | | | 70| 77| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (70:3): [True: 77, False: 2.31k] | | | | ------------------ | | | | 71| 77| if (end - ptr < n) \ | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 77] | | | | ------------------ | | | | 72| 66| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 0|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 73| 77| if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NAME_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 240| 154| (AS_NORMAL_ENCODING(enc)->isInvalid##n(enc, p)) | | | | | | ------------------ | | | | | | | | 207| 77|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | | | ------------------ | | | | | | | Branch (240:3): [True: 10, False: 67] | | | | | | ------------------ | | | | ------------------ | | | | if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NAME_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 237| 67|#define IS_NAME_CHAR(enc, p, n) (AS_NORMAL_ENCODING(enc)->isName##n(enc, p)) | | | | | | ------------------ | | | | | | | | 207| 67|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (73:41): [True: 1, False: 66] | | | | ------------------ | | | | 74| 11| *nextTokPtr = ptr; \ | | | | 75| 11| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 11|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 76| 11| } \ | | | | 77| 77| ptr += n; \ | | | | 78| 66| break; | | ------------------ | | 95| 78| CHECK_NAME_CASE(3, enc, ptr, end, nextTokPtr) \ | | ------------------ | | | | 70| 78| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (70:3): [True: 78, False: 2.31k] | | | | ------------------ | | | | 71| 78| if (end - ptr < n) \ | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 78] | | | | ------------------ | | | | 72| 66| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 0|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 73| 78| if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NAME_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 240| 156| (AS_NORMAL_ENCODING(enc)->isInvalid##n(enc, p)) | | | | | | ------------------ | | | | | | | | 207| 78|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | | | ------------------ | | | | | | | Branch (240:3): [True: 11, False: 67] | | | | | | ------------------ | | | | ------------------ | | | | if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NAME_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 237| 67|#define IS_NAME_CHAR(enc, p, n) (AS_NORMAL_ENCODING(enc)->isName##n(enc, p)) | | | | | | ------------------ | | | | | | | | 207| 67|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (73:41): [True: 1, False: 66] | | | | ------------------ | | | | 74| 12| *nextTokPtr = ptr; \ | | | | 75| 12| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 12|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 76| 12| } \ | | | | 77| 78| ptr += n; \ | | | | 78| 66| break; | | ------------------ | | 96| 66| CHECK_NAME_CASE(4, enc, ptr, end, nextTokPtr) | | ------------------ | | | | 70| 12| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (70:3): [True: 12, False: 2.37k] | | | | ------------------ | | | | 71| 12| if (end - ptr < n) \ | | | | ------------------ | | | | | Branch (71:9): [True: 1, False: 11] | | | | ------------------ | | | | 72| 1| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 1|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 73| 11| if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NAME_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 240| 22| (AS_NORMAL_ENCODING(enc)->isInvalid##n(enc, p)) | | | | | | ------------------ | | | | | | | | 207| 11|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | | | ------------------ | | | | | | | Branch (240:3): [True: 10, False: 1] | | | | | | ------------------ | | | | ------------------ | | | | if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NAME_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 237| 1|#define IS_NAME_CHAR(enc, p, n) (AS_NORMAL_ENCODING(enc)->isName##n(enc, p)) | | | | | | ------------------ | | | | | | | | 207| 1|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (73:41): [True: 1, False: 0] | | | | ------------------ | | | | 74| 11| *nextTokPtr = ptr; \ | | | | 75| 11| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 11|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 76| 11| } \ | | | | 77| 11| ptr += n; \ | | | | 78| 0| break; | | ------------------ ------------------ 1220| 200| default: ------------------ | Branch (1220:9): [True: 200, False: 2.18k] ------------------ 1221| 200| tok = XML_TOK_NMTOKEN; ------------------ | | 86| 200|# define XML_TOK_NMTOKEN 19 ------------------ 1222| 200| break; 1223| 2.38k| } 1224| 2.35k| break; 1225| 2.35k| case XML_TOK_PREFIXED_NAME: ------------------ | | 118| 302|# define XML_TOK_PREFIXED_NAME 41 ------------------ | Branch (1225:7): [True: 302, False: 2.65k] ------------------ 1226| 302| tok = XML_TOK_NMTOKEN; ------------------ | | 86| 302|# define XML_TOK_NMTOKEN 19 ------------------ 1227| 302| break; 1228| 2.95k| } 1229| 2.92k| break; 1230| 2.92k|# endif 1231| 2.92k| case BT_PLUS: ------------------ | Branch (1231:5): [True: 339, False: 64.7k] ------------------ 1232| 339| if (tok == XML_TOK_NMTOKEN) { ------------------ | | 86| 339|# define XML_TOK_NMTOKEN 19 ------------------ | Branch (1232:11): [True: 1, False: 338] ------------------ 1233| 1| *nextTokPtr = ptr; 1234| 1| return XML_TOK_INVALID; ------------------ | | 57| 1|# define XML_TOK_INVALID 0 ------------------ 1235| 1| } 1236| 338| *nextTokPtr = ptr + MINBPC(enc); ------------------ | | 228| 338|#define MINBPC(enc) 1 ------------------ 1237| 338| return XML_TOK_NAME_PLUS; ------------------ | | 101| 338|# define XML_TOK_NAME_PLUS 32 /* name+ */ ------------------ 1238| 303| case BT_AST: ------------------ | Branch (1238:5): [True: 303, False: 64.7k] ------------------ 1239| 303| if (tok == XML_TOK_NMTOKEN) { ------------------ | | 86| 303|# define XML_TOK_NMTOKEN 19 ------------------ | Branch (1239:11): [True: 1, False: 302] ------------------ 1240| 1| *nextTokPtr = ptr; 1241| 1| return XML_TOK_INVALID; ------------------ | | 57| 1|# define XML_TOK_INVALID 0 ------------------ 1242| 1| } 1243| 302| *nextTokPtr = ptr + MINBPC(enc); ------------------ | | 228| 302|#define MINBPC(enc) 1 ------------------ 1244| 302| return XML_TOK_NAME_ASTERISK; ------------------ | | 100| 302|# define XML_TOK_NAME_ASTERISK 31 /* name* */ ------------------ 1245| 285| case BT_QUEST: ------------------ | Branch (1245:5): [True: 285, False: 64.7k] ------------------ 1246| 285| if (tok == XML_TOK_NMTOKEN) { ------------------ | | 86| 285|# define XML_TOK_NMTOKEN 19 ------------------ | Branch (1246:11): [True: 2, False: 283] ------------------ 1247| 2| *nextTokPtr = ptr; 1248| 2| return XML_TOK_INVALID; ------------------ | | 57| 2|# define XML_TOK_INVALID 0 ------------------ 1249| 2| } 1250| 283| *nextTokPtr = ptr + MINBPC(enc); ------------------ | | 228| 283|#define MINBPC(enc) 1 ------------------ 1251| 283| return XML_TOK_NAME_QUESTION; ------------------ | | 99| 283|# define XML_TOK_NAME_QUESTION 30 /* name? */ ------------------ 1252| 24| default: ------------------ | Branch (1252:5): [True: 24, False: 65.0k] ------------------ 1253| 24| *nextTokPtr = ptr; 1254| 24| return XML_TOK_INVALID; ------------------ | | 57| 24|# define XML_TOK_INVALID 0 ------------------ 1255| 65.0k| } 1256| 65.0k| } 1257| 0| return -tok; 1258| 35.2k|} xmltok.c:normal_scanLit: 984| 9.80k| const char **nextTokPtr) { 985| 196k| while (HAS_CHAR(enc, ptr, end)) { 986| 196k| int t = BYTE_TYPE(enc, ptr); ------------------ | | 233| 196k|#define BYTE_TYPE(enc, p) SB_BYTE_TYPE(enc, p) | | ------------------ | | | | 231| 196k| (((const struct normal_encoding *)(enc))->type[(unsigned char)*(p)]) | | ------------------ ------------------ 987| 196k| switch (t) { 988| 1.90k| INVALID_CASES(ptr, nextTokPtr) ------------------ | | 60| 394| INVALID_LEAD_CASE(2, ptr, nextTokPtr) \ | | ------------------ | | | | 49| 394| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (49:3): [True: 394, False: 195k] | | | | ------------------ | | | | 50| 394| if (end - ptr < n) \ | | | | ------------------ | | | | | Branch (50:9): [True: 0, False: 394] | | | | ------------------ | | | | 51| 392| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 0|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 52| 394| if (IS_INVALID_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 240| 394| (AS_NORMAL_ENCODING(enc)->isInvalid##n(enc, p)) | | | | | | ------------------ | | | | | | | | 207| 394|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | | | ------------------ | | | | | | | Branch (240:3): [True: 2, False: 392] | | | | | | ------------------ | | | | ------------------ | | | | 53| 2| *(nextTokPtr) = (ptr); \ | | | | 54| 2| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 2|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 55| 2| } \ | | | | 56| 394| ptr += n; \ | | | | 57| 392| break; | | ------------------ | | 61| 410| INVALID_LEAD_CASE(3, ptr, nextTokPtr) \ | | ------------------ | | | | 49| 410| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (49:3): [True: 410, False: 195k] | | | | ------------------ | | | | 50| 410| if (end - ptr < n) \ | | | | ------------------ | | | | | Branch (50:9): [True: 0, False: 410] | | | | ------------------ | | | | 51| 408| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 0|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 52| 410| if (IS_INVALID_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 240| 410| (AS_NORMAL_ENCODING(enc)->isInvalid##n(enc, p)) | | | | | | ------------------ | | | | | | | | 207| 410|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | | | ------------------ | | | | | | | Branch (240:3): [True: 2, False: 408] | | | | | | ------------------ | | | | ------------------ | | | | 53| 2| *(nextTokPtr) = (ptr); \ | | | | 54| 2| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 2|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 55| 2| } \ | | | | 56| 410| ptr += n; \ | | | | 57| 408| break; | | ------------------ | | 62| 408| INVALID_LEAD_CASE(4, ptr, nextTokPtr) \ | | ------------------ | | | | 49| 147| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (49:3): [True: 147, False: 195k] | | | | ------------------ | | | | 50| 147| if (end - ptr < n) \ | | | | ------------------ | | | | | Branch (50:9): [True: 1, False: 146] | | | | ------------------ | | | | 51| 137| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 1|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 52| 146| if (IS_INVALID_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 240| 146| (AS_NORMAL_ENCODING(enc)->isInvalid##n(enc, p)) | | | | | | ------------------ | | | | | | | | 207| 146|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | | | ------------------ | | | | | | | Branch (240:3): [True: 9, False: 137] | | | | | | ------------------ | | | | ------------------ | | | | 53| 9| *(nextTokPtr) = (ptr); \ | | | | 54| 9| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 9|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 55| 9| } \ | | | | 56| 146| ptr += n; \ | | | | 57| 137| break; | | ------------------ | | 63| 137| case BT_NONXML: \ | | ------------------ | | | Branch (63:3): [True: 1, False: 196k] | | ------------------ | | 64| 2| case BT_MALFORM: \ | | ------------------ | | | Branch (64:3): [True: 1, False: 196k] | | ------------------ | | 65| 3| case BT_TRAIL: \ | | ------------------ | | | Branch (65:3): [True: 1, False: 196k] | | ------------------ | | 66| 3| *(nextTokPtr) = (ptr); \ | | 67| 3| return XML_TOK_INVALID; | | ------------------ | | | | 57| 3|# define XML_TOK_INVALID 0 | | ------------------ ------------------ 989| 1.93k| case BT_QUOT: ------------------ | Branch (989:5): [True: 1.93k, False: 194k] ------------------ 990| 10.8k| case BT_APOS: ------------------ | Branch (990:5): [True: 8.89k, False: 187k] ------------------ 991| 10.8k| ptr += MINBPC(enc); ------------------ | | 228| 10.8k|#define MINBPC(enc) 1 ------------------ 992| 10.8k| if (t != open) ------------------ | Branch (992:11): [True: 1.21k, False: 9.60k] ------------------ 993| 1.21k| break; 994| 9.60k| if (! HAS_CHAR(enc, ptr, end)) ------------------ | | 131| 9.60k|# define HAS_CHAR(enc, ptr, end) HAS_CHARS(enc, ptr, end, 1) | | ------------------ | | | | 129| 9.60k| ((end) - (ptr) >= ((count) * MINBPC(enc))) | | | | ------------------ | | | | | | 228| 9.60k|#define MINBPC(enc) 1 | | | | ------------------ | | ------------------ ------------------ | Branch (994:11): [True: 0, False: 9.60k] ------------------ 995| 0| return -XML_TOK_LITERAL; ------------------ | | 94| 0|# define XML_TOK_LITERAL 27 ------------------ 996| 9.60k| *nextTokPtr = ptr; 997| 9.60k| switch (BYTE_TYPE(enc, ptr)) { ------------------ | | 233| 9.60k|#define BYTE_TYPE(enc, p) SB_BYTE_TYPE(enc, p) | | ------------------ | | | | 231| 9.60k| (((const struct normal_encoding *)(enc))->type[(unsigned char)*(p)]) | | ------------------ ------------------ 998| 3.54k| case BT_S: ------------------ | Branch (998:7): [True: 3.54k, False: 6.05k] ------------------ 999| 3.61k| case BT_CR: ------------------ | Branch (999:7): [True: 69, False: 9.53k] ------------------ 1000| 3.68k| case BT_LF: ------------------ | Branch (1000:7): [True: 68, False: 9.53k] ------------------ 1001| 9.53k| case BT_GT: ------------------ | Branch (1001:7): [True: 5.84k, False: 3.75k] ------------------ 1002| 9.59k| case BT_PERCNT: ------------------ | Branch (1002:7): [True: 59, False: 9.54k] ------------------ 1003| 9.60k| case BT_LSQB: ------------------ | Branch (1003:7): [True: 13, False: 9.59k] ------------------ 1004| 9.60k| return XML_TOK_LITERAL; ------------------ | | 94| 9.60k|# define XML_TOK_LITERAL 27 ------------------ 1005| 1| default: ------------------ | Branch (1005:7): [True: 1, False: 9.60k] ------------------ 1006| 1| return XML_TOK_INVALID; ------------------ | | 57| 1|# define XML_TOK_INVALID 0 ------------------ 1007| 9.60k| } 1008| 184k| default: ------------------ | Branch (1008:5): [True: 184k, False: 11.7k] ------------------ 1009| 184k| ptr += MINBPC(enc); ------------------ | | 228| 184k|#define MINBPC(enc) 1 ------------------ 1010| 184k| break; 1011| 196k| } 1012| 196k| } 1013| 184| return XML_TOK_PARTIAL; ------------------ | | 56| 184|# define XML_TOK_PARTIAL -1 /* only part of a token */ ------------------ 1014| 9.80k|} xmltok.c:normal_scanDecl: 183| 16.7k| const char **nextTokPtr) { 184| 16.7k| REQUIRE_CHAR(enc, ptr, end); ------------------ | | 140| 16.7k|# define REQUIRE_CHAR(enc, ptr, end) REQUIRE_CHARS(enc, ptr, end, 1) | | ------------------ | | | | 134| 16.7k| { \ | | | | 135| 16.7k| if (! HAS_CHARS(enc, ptr, end, count)) { \ | | | | ------------------ | | | | | | 129| 16.7k| ((end) - (ptr) >= ((count) * MINBPC(enc))) | | | | | | ------------------ | | | | | | | | 228| 16.7k|#define MINBPC(enc) 1 | | | | | | ------------------ | | | | ------------------ | | | | | Branch (135:11): [True: 0, False: 16.7k] | | | | ------------------ | | | | 136| 0| return XML_TOK_PARTIAL; \ | | | | ------------------ | | | | | | 56| 0|# define XML_TOK_PARTIAL -1 /* only part of a token */ | | | | ------------------ | | | | 137| 0| } \ | | | | 138| 16.7k| } | | ------------------ ------------------ 185| 16.7k| switch (BYTE_TYPE(enc, ptr)) { ------------------ | | 233| 16.7k|#define BYTE_TYPE(enc, p) SB_BYTE_TYPE(enc, p) | | ------------------ | | | | 231| 16.7k| (((const struct normal_encoding *)(enc))->type[(unsigned char)*(p)]) | | ------------------ ------------------ 186| 967| case BT_MINUS: ------------------ | Branch (186:3): [True: 967, False: 15.8k] ------------------ 187| 967| return PREFIX(scanComment)(enc, ptr + MINBPC(enc), end, nextTokPtr); ------------------ | | 248| 967|#define PREFIX(ident) normal_##ident ------------------ return PREFIX(scanComment)(enc, ptr + MINBPC(enc), end, nextTokPtr); ------------------ | | 228| 967|#define MINBPC(enc) 1 ------------------ 188| 3| case BT_LSQB: ------------------ | Branch (188:3): [True: 3, False: 16.7k] ------------------ 189| 3| *nextTokPtr = ptr + MINBPC(enc); ------------------ | | 228| 3|#define MINBPC(enc) 1 ------------------ 190| 3| return XML_TOK_COND_SECT_OPEN; ------------------ | | 102| 3|# define XML_TOK_COND_SECT_OPEN 33 /* type[(unsigned char)*(p)]) | | ------------------ ------------------ 201| 14| case BT_PERCNT: ------------------ | Branch (201:5): [True: 14, False: 106k] ------------------ 202| 14| REQUIRE_CHARS(enc, ptr, end, 2); ------------------ | | 134| 14| { \ | | 135| 14| if (! HAS_CHARS(enc, ptr, end, count)) { \ | | ------------------ | | | | 129| 14| ((end) - (ptr) >= ((count) * MINBPC(enc))) | | | | ------------------ | | | | | | 228| 14|#define MINBPC(enc) 1 | | | | ------------------ | | ------------------ | | | Branch (135:11): [True: 0, False: 14] | | ------------------ | | 136| 0| return XML_TOK_PARTIAL; \ | | ------------------ | | | | 56| 0|# define XML_TOK_PARTIAL -1 /* only part of a token */ | | ------------------ | | 137| 0| } \ | | 138| 14| } ------------------ 203| | /* don't allow */ 204| 14| switch (BYTE_TYPE(enc, ptr + MINBPC(enc))) { ------------------ | | 233| 14|#define BYTE_TYPE(enc, p) SB_BYTE_TYPE(enc, p) | | ------------------ | | | | 231| 14| (((const struct normal_encoding *)(enc))->type[(unsigned char)*(p)]) | | | | ------------------ | | | | | Branch (231:3): [True: 4, False: 10] | | | | ------------------ | | ------------------ ------------------ 205| 1| case BT_S: ------------------ | Branch (205:7): [True: 1, False: 13] ------------------ 206| 2| case BT_CR: ------------------ | Branch (206:7): [True: 1, False: 13] ------------------ 207| 3| case BT_LF: ------------------ | Branch (207:7): [True: 1, False: 13] ------------------ 208| 4| case BT_PERCNT: ------------------ | Branch (208:7): [True: 1, False: 13] ------------------ 209| 4| *nextTokPtr = ptr; 210| 4| return XML_TOK_INVALID; ------------------ | | 57| 4|# define XML_TOK_INVALID 0 ------------------ 211| 14| } 212| 10| EXPAT_FALLTHROUGH; ------------------ | | 47| 10|# define EXPAT_FALLTHROUGH __attribute__((fallthrough)) ------------------ 213| 15.6k| case BT_S: ------------------ | Branch (213:5): [True: 15.6k, False: 91.2k] ------------------ 214| 15.7k| case BT_CR: ------------------ | Branch (214:5): [True: 71, False: 106k] ------------------ 215| 15.7k| case BT_LF: ------------------ | Branch (215:5): [True: 68, False: 106k] ------------------ 216| 15.7k| *nextTokPtr = ptr; 217| 15.7k| return XML_TOK_DECL_OPEN; ------------------ | | 83| 15.7k|# define XML_TOK_DECL_OPEN 16 /* = ((count) * MINBPC(enc))) | | | | ------------------ | | | | | | 228| 1.42k|#define MINBPC(enc) 1 | | | | ------------------ | | | | | Branch (129:5): [True: 1.42k, False: 1] | | | | ------------------ | | ------------------ ------------------ 148| 1.42k| if (! CHAR_MATCHES(enc, ptr, ASCII_MINUS)) { ------------------ | | 246| 1.42k|#define CHAR_MATCHES(enc, p, c) (*(p) == (c)) ------------------ | Branch (148:9): [True: 18, False: 1.40k] ------------------ 149| 18| *nextTokPtr = ptr; 150| 18| return XML_TOK_INVALID; ------------------ | | 57| 18|# define XML_TOK_INVALID 0 ------------------ 151| 18| } 152| 1.40k| ptr += MINBPC(enc); ------------------ | | 228| 1.40k|#define MINBPC(enc) 1 ------------------ 153| 2.75k| while (HAS_CHAR(enc, ptr, end)) { 154| 2.75k| switch (BYTE_TYPE(enc, ptr)) { ------------------ | | 233| 2.75k|#define BYTE_TYPE(enc, p) SB_BYTE_TYPE(enc, p) | | ------------------ | | | | 231| 2.75k| (((const struct normal_encoding *)(enc))->type[(unsigned char)*(p)]) | | ------------------ ------------------ 155| 1.21k| INVALID_CASES(ptr, nextTokPtr) ------------------ | | 60| 198| INVALID_LEAD_CASE(2, ptr, nextTokPtr) \ | | ------------------ | | | | 49| 198| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (49:3): [True: 198, False: 2.55k] | | | | ------------------ | | | | 50| 198| if (end - ptr < n) \ | | | | ------------------ | | | | | Branch (50:9): [True: 0, False: 198] | | | | ------------------ | | | | 51| 197| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 0|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 52| 198| if (IS_INVALID_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 240| 198| (AS_NORMAL_ENCODING(enc)->isInvalid##n(enc, p)) | | | | | | ------------------ | | | | | | | | 207| 198|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | | | ------------------ | | | | | | | Branch (240:3): [True: 1, False: 197] | | | | | | ------------------ | | | | ------------------ | | | | 53| 1| *(nextTokPtr) = (ptr); \ | | | | 54| 1| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 1|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 55| 1| } \ | | | | 56| 198| ptr += n; \ | | | | 57| 197| break; | | ------------------ | | 61| 201| INVALID_LEAD_CASE(3, ptr, nextTokPtr) \ | | ------------------ | | | | 49| 201| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (49:3): [True: 201, False: 2.55k] | | | | ------------------ | | | | 50| 201| if (end - ptr < n) \ | | | | ------------------ | | | | | Branch (50:9): [True: 0, False: 201] | | | | ------------------ | | | | 51| 198| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 0|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 52| 201| if (IS_INVALID_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 240| 201| (AS_NORMAL_ENCODING(enc)->isInvalid##n(enc, p)) | | | | | | ------------------ | | | | | | | | 207| 201|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | | | ------------------ | | | | | | | Branch (240:3): [True: 3, False: 198] | | | | | | ------------------ | | | | ------------------ | | | | 53| 3| *(nextTokPtr) = (ptr); \ | | | | 54| 3| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 3|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 55| 3| } \ | | | | 56| 201| ptr += n; \ | | | | 57| 198| break; | | ------------------ | | 62| 208| INVALID_LEAD_CASE(4, ptr, nextTokPtr) \ | | ------------------ | | | | 49| 208| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (49:3): [True: 208, False: 2.54k] | | | | ------------------ | | | | 50| 208| if (end - ptr < n) \ | | | | ------------------ | | | | | Branch (50:9): [True: 1, False: 207] | | | | ------------------ | | | | 51| 199| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 1|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 52| 207| if (IS_INVALID_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 240| 207| (AS_NORMAL_ENCODING(enc)->isInvalid##n(enc, p)) | | | | | | ------------------ | | | | | | | | 207| 207|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | | | ------------------ | | | | | | | Branch (240:3): [True: 8, False: 199] | | | | | | ------------------ | | | | ------------------ | | | | 53| 8| *(nextTokPtr) = (ptr); \ | | | | 54| 8| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 8|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 55| 8| } \ | | | | 56| 207| ptr += n; \ | | | | 57| 199| break; | | ------------------ | | 63| 199| case BT_NONXML: \ | | ------------------ | | | Branch (63:3): [True: 2, False: 2.75k] | | ------------------ | | 64| 3| case BT_MALFORM: \ | | ------------------ | | | Branch (64:3): [True: 1, False: 2.75k] | | ------------------ | | 65| 4| case BT_TRAIL: \ | | ------------------ | | | Branch (65:3): [True: 1, False: 2.75k] | | ------------------ | | 66| 4| *(nextTokPtr) = (ptr); \ | | 67| 4| return XML_TOK_INVALID; | | ------------------ | | | | 57| 4|# define XML_TOK_INVALID 0 | | ------------------ ------------------ 156| 1.59k| case BT_MINUS: ------------------ | Branch (156:7): [True: 1.59k, False: 1.16k] ------------------ 157| 1.59k| ptr += MINBPC(enc); ------------------ | | 228| 1.59k|#define MINBPC(enc) 1 ------------------ 158| 1.59k| REQUIRE_CHAR(enc, ptr, end); ------------------ | | 140| 1.59k|# define REQUIRE_CHAR(enc, ptr, end) REQUIRE_CHARS(enc, ptr, end, 1) | | ------------------ | | | | 134| 1.59k| { \ | | | | 135| 1.59k| if (! HAS_CHARS(enc, ptr, end, count)) { \ | | | | ------------------ | | | | | | 129| 1.59k| ((end) - (ptr) >= ((count) * MINBPC(enc))) | | | | | | ------------------ | | | | | | | | 228| 1.59k|#define MINBPC(enc) 1 | | | | | | ------------------ | | | | ------------------ | | | | | Branch (135:11): [True: 1, False: 1.59k] | | | | ------------------ | | | | 136| 1| return XML_TOK_PARTIAL; \ | | | | ------------------ | | | | | | 56| 1|# define XML_TOK_PARTIAL -1 /* only part of a token */ | | | | ------------------ | | | | 137| 1| } \ | | | | 138| 1.59k| } | | ------------------ ------------------ 159| 1.59k| if (CHAR_MATCHES(enc, ptr, ASCII_MINUS)) { ------------------ | | 246| 1.59k|#define CHAR_MATCHES(enc, p, c) (*(p) == (c)) | | ------------------ | | | Branch (246:33): [True: 1.36k, False: 222] | | ------------------ ------------------ 160| 1.36k| ptr += MINBPC(enc); ------------------ | | 228| 1.36k|#define MINBPC(enc) 1 ------------------ 161| 1.36k| REQUIRE_CHAR(enc, ptr, end); ------------------ | | 140| 1.36k|# define REQUIRE_CHAR(enc, ptr, end) REQUIRE_CHARS(enc, ptr, end, 1) | | ------------------ | | | | 134| 1.36k| { \ | | | | 135| 1.36k| if (! HAS_CHARS(enc, ptr, end, count)) { \ | | | | ------------------ | | | | | | 129| 1.36k| ((end) - (ptr) >= ((count) * MINBPC(enc))) | | | | | | ------------------ | | | | | | | | 228| 1.36k|#define MINBPC(enc) 1 | | | | | | ------------------ | | | | ------------------ | | | | | Branch (135:11): [True: 1, False: 1.36k] | | | | ------------------ | | | | 136| 1| return XML_TOK_PARTIAL; \ | | | | ------------------ | | | | | | 56| 1|# define XML_TOK_PARTIAL -1 /* only part of a token */ | | | | ------------------ | | | | 137| 1| } \ | | | | 138| 1.36k| } | | ------------------ ------------------ 162| 1.36k| if (! CHAR_MATCHES(enc, ptr, ASCII_GT)) { ------------------ | | 246| 1.36k|#define CHAR_MATCHES(enc, p, c) (*(p) == (c)) ------------------ | Branch (162:15): [True: 6, False: 1.36k] ------------------ 163| 6| *nextTokPtr = ptr; 164| 6| return XML_TOK_INVALID; ------------------ | | 57| 6|# define XML_TOK_INVALID 0 ------------------ 165| 6| } 166| 1.36k| *nextTokPtr = ptr + MINBPC(enc); ------------------ | | 228| 1.36k|#define MINBPC(enc) 1 ------------------ 167| 1.36k| return XML_TOK_COMMENT; ------------------ | | 78| 1.36k|# define XML_TOK_COMMENT 13 ------------------ 168| 1.36k| } 169| 222| break; 170| 551| default: ------------------ | Branch (170:7): [True: 551, False: 2.20k] ------------------ 171| 551| ptr += MINBPC(enc); ------------------ | | 228| 551|#define MINBPC(enc) 1 ------------------ 172| 551| break; 173| 2.75k| } 174| 2.75k| } 175| 1.40k| } 176| 17| return XML_TOK_PARTIAL; ------------------ | | 56| 17|# define XML_TOK_PARTIAL -1 /* only part of a token */ ------------------ 177| 1.42k|} xmltok.c:normal_scanPi: 277| 6.67k| const char **nextTokPtr) { 278| 6.67k| int tok; 279| 6.67k| const char *target = ptr; 280| 6.67k| REQUIRE_CHAR(enc, ptr, end); ------------------ | | 140| 6.67k|# define REQUIRE_CHAR(enc, ptr, end) REQUIRE_CHARS(enc, ptr, end, 1) | | ------------------ | | | | 134| 6.67k| { \ | | | | 135| 6.67k| if (! HAS_CHARS(enc, ptr, end, count)) { \ | | | | ------------------ | | | | | | 129| 6.67k| ((end) - (ptr) >= ((count) * MINBPC(enc))) | | | | | | ------------------ | | | | | | | | 228| 6.67k|#define MINBPC(enc) 1 | | | | | | ------------------ | | | | ------------------ | | | | | Branch (135:11): [True: 1, False: 6.67k] | | | | ------------------ | | | | 136| 1| return XML_TOK_PARTIAL; \ | | | | ------------------ | | | | | | 56| 1|# define XML_TOK_PARTIAL -1 /* only part of a token */ | | | | ------------------ | | | | 137| 1| } \ | | | | 138| 6.67k| } | | ------------------ ------------------ 281| 6.67k| switch (BYTE_TYPE(enc, ptr)) { ------------------ | | 233| 6.67k|#define BYTE_TYPE(enc, p) SB_BYTE_TYPE(enc, p) | | ------------------ | | | | 231| 6.67k| (((const struct normal_encoding *)(enc))->type[(unsigned char)*(p)]) | | ------------------ ------------------ 282| 6.14k| CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr) ------------------ | | 110| 6.23k| case BT_NONASCII: \ | | ------------------ | | | Branch (110:3): [True: 0, False: 6.67k] | | ------------------ | | 111| 6.23k| if (! IS_NMSTRT_CHAR_MINBPC(enc, ptr)) { \ | | ------------------ | | | | 243| 0|#define IS_NMSTRT_CHAR_MINBPC(enc, p) (0) | | ------------------ | | | Branch (111:9): [True: 0, Folded] | | ------------------ | | 112| 0| *nextTokPtr = ptr; \ | | 113| 0| return XML_TOK_INVALID; \ | | ------------------ | | | | 57| 0|# define XML_TOK_INVALID 0 | | ------------------ | | 114| 0| } \ | | 115| 6.23k| EXPAT_FALLTHROUGH; \ | | ------------------ | | | | 47| 0|# define EXPAT_FALLTHROUGH __attribute__((fallthrough)) | | ------------------ | | 116| 5.29k| case BT_NMSTRT: \ | | ------------------ | | | Branch (116:3): [True: 5.29k, False: 1.37k] | | ------------------ | | 117| 6.23k| case BT_HEX: \ | | ------------------ | | | Branch (117:3): [True: 939, False: 5.73k] | | ------------------ | | 118| 6.23k| ptr += MINBPC(enc); \ | | ------------------ | | | | 228| 6.23k|#define MINBPC(enc) 1 | | ------------------ | | 119| 6.23k| break; \ | | 120| 6.23k| CHECK_NMSTRT_CASE(2, enc, ptr, end, nextTokPtr) \ | | ------------------ | | | | 99| 209| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (99:3): [True: 209, False: 6.46k] | | | | ------------------ | | | | 100| 209| if ((end) - (ptr) < (n)) \ | | | | ------------------ | | | | | Branch (100:9): [True: 0, False: 209] | | | | ------------------ | | | | 101| 205| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 0|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 102| 209| if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NMSTRT_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 240| 418| (AS_NORMAL_ENCODING(enc)->isInvalid##n(enc, p)) | | | | | | ------------------ | | | | | | | | 207| 209|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | | | ------------------ | | | | | | | Branch (240:3): [True: 3, False: 206] | | | | | | ------------------ | | | | ------------------ | | | | if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NMSTRT_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 238| 206|#define IS_NMSTRT_CHAR(enc, p, n) (AS_NORMAL_ENCODING(enc)->isNmstrt##n(enc, p)) | | | | | | ------------------ | | | | | | | | 207| 206|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (102:41): [True: 1, False: 205] | | | | ------------------ | | | | 103| 4| *nextTokPtr = ptr; \ | | | | 104| 4| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 4|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 105| 4| } \ | | | | 106| 209| ptr += n; \ | | | | 107| 205| break; | | ------------------ | | 121| 206| CHECK_NMSTRT_CASE(3, enc, ptr, end, nextTokPtr) \ | | ------------------ | | | | 99| 206| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (99:3): [True: 206, False: 6.46k] | | | | ------------------ | | | | 100| 206| if ((end) - (ptr) < (n)) \ | | | | ------------------ | | | | | Branch (100:9): [True: 0, False: 206] | | | | ------------------ | | | | 101| 194| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 0|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 102| 206| if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NMSTRT_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 240| 412| (AS_NORMAL_ENCODING(enc)->isInvalid##n(enc, p)) | | | | | | ------------------ | | | | | | | | 207| 206|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | | | ------------------ | | | | | | | Branch (240:3): [True: 11, False: 195] | | | | | | ------------------ | | | | ------------------ | | | | if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NMSTRT_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 238| 195|#define IS_NMSTRT_CHAR(enc, p, n) (AS_NORMAL_ENCODING(enc)->isNmstrt##n(enc, p)) | | | | | | ------------------ | | | | | | | | 207| 195|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (102:41): [True: 1, False: 194] | | | | ------------------ | | | | 103| 12| *nextTokPtr = ptr; \ | | | | 104| 12| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 12|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 105| 12| } \ | | | | 106| 206| ptr += n; \ | | | | 107| 194| break; | | ------------------ | | 122| 194| CHECK_NMSTRT_CASE(4, enc, ptr, end, nextTokPtr) | | ------------------ | | | | 99| 10| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (99:3): [True: 10, False: 6.66k] | | | | ------------------ | | | | 100| 10| if ((end) - (ptr) < (n)) \ | | | | ------------------ | | | | | Branch (100:9): [True: 1, False: 9] | | | | ------------------ | | | | 101| 1| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 1|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 102| 9| if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NMSTRT_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 240| 18| (AS_NORMAL_ENCODING(enc)->isInvalid##n(enc, p)) | | | | | | ------------------ | | | | | | | | 207| 9|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | | | ------------------ | | | | | | | Branch (240:3): [True: 8, False: 1] | | | | | | ------------------ | | | | ------------------ | | | | if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NMSTRT_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 238| 1|#define IS_NMSTRT_CHAR(enc, p, n) (AS_NORMAL_ENCODING(enc)->isNmstrt##n(enc, p)) | | | | | | ------------------ | | | | | | | | 207| 1|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (102:41): [True: 1, False: 0] | | | | ------------------ | | | | 103| 9| *nextTokPtr = ptr; \ | | | | 104| 9| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 9|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 105| 9| } \ | | | | 106| 9| ptr += n; \ | | | | 107| 0| break; | | ------------------ ------------------ 283| 12| default: ------------------ | Branch (283:3): [True: 12, False: 6.66k] ------------------ 284| 12| *nextTokPtr = ptr; 285| 12| return XML_TOK_INVALID; ------------------ | | 57| 12|# define XML_TOK_INVALID 0 ------------------ 286| 6.67k| } 287| 14.4k| while (HAS_CHAR(enc, ptr, end)) { 288| 14.4k| switch (BYTE_TYPE(enc, ptr)) { ------------------ | | 233| 14.4k|#define BYTE_TYPE(enc, p) SB_BYTE_TYPE(enc, p) | | ------------------ | | | | 231| 14.4k| (((const struct normal_encoding *)(enc))->type[(unsigned char)*(p)]) | | ------------------ ------------------ 289| 26.8k| CHECK_NAME_CASES(enc, ptr, end, nextTokPtr) ------------------ | | 81| 7.40k| case BT_NONASCII: \ | | ------------------ | | | Branch (81:3): [True: 0, False: 14.4k] | | ------------------ | | 82| 7.40k| if (! IS_NAME_CHAR_MINBPC(enc, ptr)) { \ | | ------------------ | | | | 242| 0|#define IS_NAME_CHAR_MINBPC(enc, p) (0) | | ------------------ | | | Branch (82:9): [True: 0, Folded] | | ------------------ | | 83| 0| *nextTokPtr = ptr; \ | | 84| 0| return XML_TOK_INVALID; \ | | ------------------ | | | | 57| 0|# define XML_TOK_INVALID 0 | | ------------------ | | 85| 0| } \ | | 86| 7.40k| EXPAT_FALLTHROUGH; \ | | ------------------ | | | | 47| 0|# define EXPAT_FALLTHROUGH __attribute__((fallthrough)) | | ------------------ | | 87| 5.38k| case BT_NMSTRT: \ | | ------------------ | | | Branch (87:3): [True: 5.38k, False: 9.07k] | | ------------------ | | 88| 6.53k| case BT_HEX: \ | | ------------------ | | | Branch (88:3): [True: 1.15k, False: 13.3k] | | ------------------ | | 89| 6.83k| case BT_DIGIT: \ | | ------------------ | | | Branch (89:3): [True: 293, False: 14.1k] | | ------------------ | | 90| 7.20k| case BT_NAME: \ | | ------------------ | | | Branch (90:3): [True: 373, False: 14.0k] | | ------------------ | | 91| 7.40k| case BT_MINUS: \ | | ------------------ | | | Branch (91:3): [True: 197, False: 14.2k] | | ------------------ | | 92| 7.40k| ptr += MINBPC(enc); \ | | ------------------ | | | | 228| 7.40k|#define MINBPC(enc) 1 | | ------------------ | | 93| 7.40k| break; \ | | 94| 7.40k| CHECK_NAME_CASE(2, enc, ptr, end, nextTokPtr) \ | | ------------------ | | | | 70| 247| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (70:3): [True: 247, False: 14.2k] | | | | ------------------ | | | | 71| 247| if (end - ptr < n) \ | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 247] | | | | ------------------ | | | | 72| 236| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 0|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 73| 247| if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NAME_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 240| 494| (AS_NORMAL_ENCODING(enc)->isInvalid##n(enc, p)) | | | | | | ------------------ | | | | | | | | 207| 247|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | | | ------------------ | | | | | | | Branch (240:3): [True: 10, False: 237] | | | | | | ------------------ | | | | ------------------ | | | | if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NAME_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 237| 237|#define IS_NAME_CHAR(enc, p, n) (AS_NORMAL_ENCODING(enc)->isName##n(enc, p)) | | | | | | ------------------ | | | | | | | | 207| 237|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (73:41): [True: 1, False: 236] | | | | ------------------ | | | | 74| 11| *nextTokPtr = ptr; \ | | | | 75| 11| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 11|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 76| 11| } \ | | | | 77| 247| ptr += n; \ | | | | 78| 236| break; | | ------------------ | | 95| 236| CHECK_NAME_CASE(3, enc, ptr, end, nextTokPtr) \ | | ------------------ | | | | 70| 204| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (70:3): [True: 204, False: 14.2k] | | | | ------------------ | | | | 71| 204| if (end - ptr < n) \ | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 204] | | | | ------------------ | | | | 72| 194| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 0|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 73| 204| if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NAME_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 240| 408| (AS_NORMAL_ENCODING(enc)->isInvalid##n(enc, p)) | | | | | | ------------------ | | | | | | | | 207| 204|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | | | ------------------ | | | | | | | Branch (240:3): [True: 9, False: 195] | | | | | | ------------------ | | | | ------------------ | | | | if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NAME_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 237| 195|#define IS_NAME_CHAR(enc, p, n) (AS_NORMAL_ENCODING(enc)->isName##n(enc, p)) | | | | | | ------------------ | | | | | | | | 207| 195|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (73:41): [True: 1, False: 194] | | | | ------------------ | | | | 74| 10| *nextTokPtr = ptr; \ | | | | 75| 10| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 10|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 76| 10| } \ | | | | 77| 204| ptr += n; \ | | | | 78| 194| break; | | ------------------ | | 96| 194| CHECK_NAME_CASE(4, enc, ptr, end, nextTokPtr) | | ------------------ | | | | 70| 12| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (70:3): [True: 12, False: 14.4k] | | | | ------------------ | | | | 71| 12| if (end - ptr < n) \ | | | | ------------------ | | | | | Branch (71:9): [True: 1, False: 11] | | | | ------------------ | | | | 72| 1| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 1|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 73| 11| if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NAME_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 240| 22| (AS_NORMAL_ENCODING(enc)->isInvalid##n(enc, p)) | | | | | | ------------------ | | | | | | | | 207| 11|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | | | ------------------ | | | | | | | Branch (240:3): [True: 10, False: 1] | | | | | | ------------------ | | | | ------------------ | | | | if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NAME_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 237| 1|#define IS_NAME_CHAR(enc, p, n) (AS_NORMAL_ENCODING(enc)->isName##n(enc, p)) | | | | | | ------------------ | | | | | | | | 207| 1|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (73:41): [True: 1, False: 0] | | | | ------------------ | | | | 74| 11| *nextTokPtr = ptr; \ | | | | 75| 11| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 11|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 76| 11| } \ | | | | 77| 11| ptr += n; \ | | | | 78| 0| break; | | ------------------ ------------------ 290| 2.15k| case BT_S: ------------------ | Branch (290:5): [True: 2.15k, False: 12.3k] ------------------ 291| 2.35k| case BT_CR: ------------------ | Branch (291:5): [True: 197, False: 14.2k] ------------------ 292| 2.55k| case BT_LF: ------------------ | Branch (292:5): [True: 196, False: 14.2k] ------------------ 293| 2.55k| if (! PREFIX(checkPiTarget)(enc, target, ptr, &tok)) { ------------------ | | 248| 2.55k|#define PREFIX(ident) normal_##ident ------------------ | Branch (293:11): [True: 3, False: 2.54k] ------------------ 294| 3| *nextTokPtr = ptr; 295| 3| return XML_TOK_INVALID; ------------------ | | 57| 3|# define XML_TOK_INVALID 0 ------------------ 296| 3| } 297| 2.54k| ptr += MINBPC(enc); ------------------ | | 228| 2.54k|#define MINBPC(enc) 1 ------------------ 298| 21.2k| while (HAS_CHAR(enc, ptr, end)) { 299| 21.2k| switch (BYTE_TYPE(enc, ptr)) { ------------------ | | 233| 21.2k|#define BYTE_TYPE(enc, p) SB_BYTE_TYPE(enc, p) | | ------------------ | | | | 231| 21.2k| (((const struct normal_encoding *)(enc))->type[(unsigned char)*(p)]) | | ------------------ ------------------ 300| 1.69k| INVALID_CASES(ptr, nextTokPtr) ------------------ | | 60| 229| INVALID_LEAD_CASE(2, ptr, nextTokPtr) \ | | ------------------ | | | | 49| 229| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (49:3): [True: 229, False: 20.9k] | | | | ------------------ | | | | 50| 229| if (end - ptr < n) \ | | | | ------------------ | | | | | Branch (50:9): [True: 0, False: 229] | | | | ------------------ | | | | 51| 206| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 0|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 52| 229| if (IS_INVALID_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 240| 229| (AS_NORMAL_ENCODING(enc)->isInvalid##n(enc, p)) | | | | | | ------------------ | | | | | | | | 207| 229|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | | | ------------------ | | | | | | | Branch (240:3): [True: 23, False: 206] | | | | | | ------------------ | | | | ------------------ | | | | 53| 23| *(nextTokPtr) = (ptr); \ | | | | 54| 23| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 23|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 55| 23| } \ | | | | 56| 229| ptr += n; \ | | | | 57| 206| break; | | ------------------ | | 61| 329| INVALID_LEAD_CASE(3, ptr, nextTokPtr) \ | | ------------------ | | | | 49| 329| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (49:3): [True: 329, False: 20.8k] | | | | ------------------ | | | | 50| 329| if (end - ptr < n) \ | | | | ------------------ | | | | | Branch (50:9): [True: 0, False: 329] | | | | ------------------ | | | | 51| 274| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 0|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 52| 329| if (IS_INVALID_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 240| 329| (AS_NORMAL_ENCODING(enc)->isInvalid##n(enc, p)) | | | | | | ------------------ | | | | | | | | 207| 329|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | | | ------------------ | | | | | | | Branch (240:3): [True: 55, False: 274] | | | | | | ------------------ | | | | ------------------ | | | | 53| 55| *(nextTokPtr) = (ptr); \ | | | | 54| 55| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 55|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 55| 55| } \ | | | | 56| 329| ptr += n; \ | | | | 57| 274| break; | | ------------------ | | 62| 285| INVALID_LEAD_CASE(4, ptr, nextTokPtr) \ | | ------------------ | | | | 49| 285| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (49:3): [True: 285, False: 20.9k] | | | | ------------------ | | | | 50| 285| if (end - ptr < n) \ | | | | ------------------ | | | | | Branch (50:9): [True: 1, False: 284] | | | | ------------------ | | | | 51| 239| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 1|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 52| 284| if (IS_INVALID_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 240| 284| (AS_NORMAL_ENCODING(enc)->isInvalid##n(enc, p)) | | | | | | ------------------ | | | | | | | | 207| 284|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | | | ------------------ | | | | | | | Branch (240:3): [True: 45, False: 239] | | | | | | ------------------ | | | | ------------------ | | | | 53| 45| *(nextTokPtr) = (ptr); \ | | | | 54| 45| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 45|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 55| 45| } \ | | | | 56| 284| ptr += n; \ | | | | 57| 239| break; | | ------------------ | | 63| 239| case BT_NONXML: \ | | ------------------ | | | Branch (63:3): [True: 2, False: 21.2k] | | ------------------ | | 64| 4| case BT_MALFORM: \ | | ------------------ | | | Branch (64:3): [True: 2, False: 21.2k] | | ------------------ | | 65| 9| case BT_TRAIL: \ | | ------------------ | | | Branch (65:3): [True: 5, False: 21.2k] | | ------------------ | | 66| 9| *(nextTokPtr) = (ptr); \ | | 67| 9| return XML_TOK_INVALID; | | ------------------ | | | | 57| 9|# define XML_TOK_INVALID 0 | | ------------------ ------------------ 301| 2.64k| case BT_QUEST: ------------------ | Branch (301:9): [True: 2.64k, False: 18.5k] ------------------ 302| 2.64k| ptr += MINBPC(enc); ------------------ | | 228| 2.64k|#define MINBPC(enc) 1 ------------------ 303| 2.64k| REQUIRE_CHAR(enc, ptr, end); ------------------ | | 140| 2.64k|# define REQUIRE_CHAR(enc, ptr, end) REQUIRE_CHARS(enc, ptr, end, 1) | | ------------------ | | | | 134| 2.64k| { \ | | | | 135| 2.64k| if (! HAS_CHARS(enc, ptr, end, count)) { \ | | | | ------------------ | | | | | | 129| 2.64k| ((end) - (ptr) >= ((count) * MINBPC(enc))) | | | | | | ------------------ | | | | | | | | 228| 2.64k|#define MINBPC(enc) 1 | | | | | | ------------------ | | | | ------------------ | | | | | Branch (135:11): [True: 1, False: 2.64k] | | | | ------------------ | | | | 136| 1| return XML_TOK_PARTIAL; \ | | | | ------------------ | | | | | | 56| 1|# define XML_TOK_PARTIAL -1 /* only part of a token */ | | | | ------------------ | | | | 137| 1| } \ | | | | 138| 2.64k| } | | ------------------ ------------------ 304| 2.64k| if (CHAR_MATCHES(enc, ptr, ASCII_GT)) { ------------------ | | 246| 2.64k|#define CHAR_MATCHES(enc, p, c) (*(p) == (c)) | | ------------------ | | | Branch (246:33): [True: 2.34k, False: 301] | | ------------------ ------------------ 305| 2.34k| *nextTokPtr = ptr + MINBPC(enc); ------------------ | | 228| 2.34k|#define MINBPC(enc) 1 ------------------ 306| 2.34k| return tok; 307| 2.34k| } 308| 301| break; 309| 17.7k| default: ------------------ | Branch (309:9): [True: 17.7k, False: 3.49k] ------------------ 310| 17.7k| ptr += MINBPC(enc); ------------------ | | 228| 17.7k|#define MINBPC(enc) 1 ------------------ 311| 17.7k| break; 312| 21.2k| } 313| 21.2k| } 314| 73| return XML_TOK_PARTIAL; ------------------ | | 56| 73|# define XML_TOK_PARTIAL -1 /* only part of a token */ ------------------ 315| 4.00k| case BT_QUEST: ------------------ | Branch (315:5): [True: 4.00k, False: 10.4k] ------------------ 316| 4.00k| if (! PREFIX(checkPiTarget)(enc, target, ptr, &tok)) { ------------------ | | 248| 4.00k|#define PREFIX(ident) normal_##ident ------------------ | Branch (316:11): [True: 3, False: 4.00k] ------------------ 317| 3| *nextTokPtr = ptr; 318| 3| return XML_TOK_INVALID; ------------------ | | 57| 3|# define XML_TOK_INVALID 0 ------------------ 319| 3| } 320| 4.00k| ptr += MINBPC(enc); ------------------ | | 228| 4.00k|#define MINBPC(enc) 1 ------------------ 321| 4.00k| REQUIRE_CHAR(enc, ptr, end); ------------------ | | 140| 4.00k|# define REQUIRE_CHAR(enc, ptr, end) REQUIRE_CHARS(enc, ptr, end, 1) | | ------------------ | | | | 134| 4.00k| { \ | | | | 135| 4.00k| if (! HAS_CHARS(enc, ptr, end, count)) { \ | | | | ------------------ | | | | | | 129| 4.00k| ((end) - (ptr) >= ((count) * MINBPC(enc))) | | | | | | ------------------ | | | | | | | | 228| 4.00k|#define MINBPC(enc) 1 | | | | | | ------------------ | | | | ------------------ | | | | | Branch (135:11): [True: 1, False: 4.00k] | | | | ------------------ | | | | 136| 1| return XML_TOK_PARTIAL; \ | | | | ------------------ | | | | | | 56| 1|# define XML_TOK_PARTIAL -1 /* only part of a token */ | | | | ------------------ | | | | 137| 1| } \ | | | | 138| 4.00k| } | | ------------------ ------------------ 322| 4.00k| if (CHAR_MATCHES(enc, ptr, ASCII_GT)) { ------------------ | | 246| 4.00k|#define CHAR_MATCHES(enc, p, c) (*(p) == (c)) | | ------------------ | | | Branch (246:33): [True: 3.98k, False: 15] | | ------------------ ------------------ 323| 3.98k| *nextTokPtr = ptr + MINBPC(enc); ------------------ | | 228| 3.98k|#define MINBPC(enc) 1 ------------------ 324| 3.98k| return tok; 325| 3.98k| } 326| 15| EXPAT_FALLTHROUGH; ------------------ | | 47| 15|# define EXPAT_FALLTHROUGH __attribute__((fallthrough)) ------------------ 327| 60| default: ------------------ | Branch (327:5): [True: 45, False: 14.4k] ------------------ 328| 60| *nextTokPtr = ptr; 329| 60| return XML_TOK_INVALID; ------------------ | | 57| 60|# define XML_TOK_INVALID 0 ------------------ 330| 14.4k| } 331| 14.4k| } 332| 2| return XML_TOK_PARTIAL; ------------------ | | 56| 2|# define XML_TOK_PARTIAL -1 /* only part of a token */ ------------------ 333| 6.63k|} xmltok.c:normal_checkPiTarget: 232| 6.55k| int *tokPtr) { 233| 6.55k| int upper = 0; 234| 6.55k| UNUSED_P(enc); ------------------ | | 101| 6.55k|# define UNUSED_P(p) (void)p ------------------ 235| 6.55k| *tokPtr = XML_TOK_PI; ------------------ | | 76| 6.55k|# define XML_TOK_PI 11 /* processing instruction */ ------------------ 236| 6.55k| if (end - ptr != MINBPC(enc) * 3) ------------------ | | 228| 6.55k|#define MINBPC(enc) 1 ------------------ | Branch (236:7): [True: 4.15k, False: 2.40k] ------------------ 237| 4.15k| return 1; 238| 2.40k| switch (BYTE_TO_ASCII(enc, ptr)) { ------------------ | | 235| 2.40k|#define BYTE_TO_ASCII(enc, p) (*(p)) ------------------ 239| 1.29k| case ASCII_x: ------------------ | | 88| 1.29k|#define ASCII_x 0x78 ------------------ | Branch (239:3): [True: 1.29k, False: 1.10k] ------------------ 240| 1.29k| break; 241| 517| case ASCII_X: ------------------ | | 61| 517|#define ASCII_X 0x58 ------------------ | Branch (241:3): [True: 517, False: 1.88k] ------------------ 242| 517| upper = 1; 243| 517| break; 244| 591| default: ------------------ | Branch (244:3): [True: 591, False: 1.81k] ------------------ 245| 591| return 1; 246| 2.40k| } 247| 1.81k| ptr += MINBPC(enc); ------------------ | | 228| 1.81k|#define MINBPC(enc) 1 ------------------ 248| 1.81k| switch (BYTE_TO_ASCII(enc, ptr)) { ------------------ | | 235| 1.81k|#define BYTE_TO_ASCII(enc, p) (*(p)) ------------------ 249| 992| case ASCII_m: ------------------ | | 77| 992|#define ASCII_m 0x6D ------------------ | Branch (249:3): [True: 992, False: 821] ------------------ 250| 992| break; 251| 395| case ASCII_M: ------------------ | | 50| 395|#define ASCII_M 0x4D ------------------ | Branch (251:3): [True: 395, False: 1.41k] ------------------ 252| 395| upper = 1; 253| 395| break; 254| 426| default: ------------------ | Branch (254:3): [True: 426, False: 1.38k] ------------------ 255| 426| return 1; 256| 1.81k| } 257| 1.38k| ptr += MINBPC(enc); ------------------ | | 228| 1.38k|#define MINBPC(enc) 1 ------------------ 258| 1.38k| switch (BYTE_TO_ASCII(enc, ptr)) { ------------------ | | 235| 1.38k|#define BYTE_TO_ASCII(enc, p) (*(p)) ------------------ 259| 594| case ASCII_l: ------------------ | | 76| 594|#define ASCII_l 0x6C ------------------ | Branch (259:3): [True: 594, False: 793] ------------------ 260| 594| break; 261| 4| case ASCII_L: ------------------ | | 49| 4|#define ASCII_L 0x4C ------------------ | Branch (261:3): [True: 4, False: 1.38k] ------------------ 262| 4| upper = 1; 263| 4| break; 264| 789| default: ------------------ | Branch (264:3): [True: 789, False: 598] ------------------ 265| 789| return 1; 266| 1.38k| } 267| 598| if (upper) ------------------ | Branch (267:7): [True: 6, False: 592] ------------------ 268| 6| return 0; 269| 592| *tokPtr = XML_TOK_XML_DECL; ------------------ | | 77| 592|# define XML_TOK_XML_DECL 12 /* XML decl or text decl */ ------------------ 270| 592| return 1; 271| 598|} xmltok.c:normal_scanPercent: 924| 1.96k| const char **nextTokPtr) { 925| 1.96k| REQUIRE_CHAR(enc, ptr, end); ------------------ | | 140| 1.96k|# define REQUIRE_CHAR(enc, ptr, end) REQUIRE_CHARS(enc, ptr, end, 1) | | ------------------ | | | | 134| 1.96k| { \ | | | | 135| 1.96k| if (! HAS_CHARS(enc, ptr, end, count)) { \ | | | | ------------------ | | | | | | 129| 1.96k| ((end) - (ptr) >= ((count) * MINBPC(enc))) | | | | | | ------------------ | | | | | | | | 228| 1.96k|#define MINBPC(enc) 1 | | | | | | ------------------ | | | | ------------------ | | | | | Branch (135:11): [True: 1, False: 1.96k] | | | | ------------------ | | | | 136| 1| return XML_TOK_PARTIAL; \ | | | | ------------------ | | | | | | 56| 1|# define XML_TOK_PARTIAL -1 /* only part of a token */ | | | | ------------------ | | | | 137| 1| } \ | | | | 138| 1.96k| } | | ------------------ ------------------ 926| 1.96k| switch (BYTE_TYPE(enc, ptr)) { ------------------ | | 233| 1.96k|#define BYTE_TYPE(enc, p) SB_BYTE_TYPE(enc, p) | | ------------------ | | | | 231| 1.96k| (((const struct normal_encoding *)(enc))->type[(unsigned char)*(p)]) | | ------------------ ------------------ 927| 601| CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr) ------------------ | | 110| 812| case BT_NONASCII: \ | | ------------------ | | | Branch (110:3): [True: 0, False: 1.96k] | | ------------------ | | 111| 812| if (! IS_NMSTRT_CHAR_MINBPC(enc, ptr)) { \ | | ------------------ | | | | 243| 0|#define IS_NMSTRT_CHAR_MINBPC(enc, p) (0) | | ------------------ | | | Branch (111:9): [True: 0, Folded] | | ------------------ | | 112| 0| *nextTokPtr = ptr; \ | | 113| 0| return XML_TOK_INVALID; \ | | ------------------ | | | | 57| 0|# define XML_TOK_INVALID 0 | | ------------------ | | 114| 0| } \ | | 115| 812| EXPAT_FALLTHROUGH; \ | | ------------------ | | | | 47| 0|# define EXPAT_FALLTHROUGH __attribute__((fallthrough)) | | ------------------ | | 116| 292| case BT_NMSTRT: \ | | ------------------ | | | Branch (116:3): [True: 292, False: 1.66k] | | ------------------ | | 117| 812| case BT_HEX: \ | | ------------------ | | | Branch (117:3): [True: 520, False: 1.44k] | | ------------------ | | 118| 812| ptr += MINBPC(enc); \ | | ------------------ | | | | 228| 812|#define MINBPC(enc) 1 | | ------------------ | | 119| 812| break; \ | | 120| 812| CHECK_NMSTRT_CASE(2, enc, ptr, end, nextTokPtr) \ | | ------------------ | | | | 99| 73| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (99:3): [True: 73, False: 1.88k] | | | | ------------------ | | | | 100| 73| if ((end) - (ptr) < (n)) \ | | | | ------------------ | | | | | Branch (100:9): [True: 0, False: 73] | | | | ------------------ | | | | 101| 66| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 0|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 102| 73| if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NMSTRT_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 240| 146| (AS_NORMAL_ENCODING(enc)->isInvalid##n(enc, p)) | | | | | | ------------------ | | | | | | | | 207| 73|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | | | ------------------ | | | | | | | Branch (240:3): [True: 6, False: 67] | | | | | | ------------------ | | | | ------------------ | | | | if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NMSTRT_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 238| 67|#define IS_NMSTRT_CHAR(enc, p, n) (AS_NORMAL_ENCODING(enc)->isNmstrt##n(enc, p)) | | | | | | ------------------ | | | | | | | | 207| 67|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (102:41): [True: 1, False: 66] | | | | ------------------ | | | | 103| 7| *nextTokPtr = ptr; \ | | | | 104| 7| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 7|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 105| 7| } \ | | | | 106| 73| ptr += n; \ | | | | 107| 66| break; | | ------------------ | | 121| 76| CHECK_NMSTRT_CASE(3, enc, ptr, end, nextTokPtr) \ | | ------------------ | | | | 99| 76| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (99:3): [True: 76, False: 1.88k] | | | | ------------------ | | | | 100| 76| if ((end) - (ptr) < (n)) \ | | | | ------------------ | | | | | Branch (100:9): [True: 0, False: 76] | | | | ------------------ | | | | 101| 66| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 0|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 102| 76| if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NMSTRT_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 240| 152| (AS_NORMAL_ENCODING(enc)->isInvalid##n(enc, p)) | | | | | | ------------------ | | | | | | | | 207| 76|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | | | ------------------ | | | | | | | Branch (240:3): [True: 9, False: 67] | | | | | | ------------------ | | | | ------------------ | | | | if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NMSTRT_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 238| 67|#define IS_NMSTRT_CHAR(enc, p, n) (AS_NORMAL_ENCODING(enc)->isNmstrt##n(enc, p)) | | | | | | ------------------ | | | | | | | | 207| 67|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (102:41): [True: 1, False: 66] | | | | ------------------ | | | | 103| 10| *nextTokPtr = ptr; \ | | | | 104| 10| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 10|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 105| 10| } \ | | | | 106| 76| ptr += n; \ | | | | 107| 66| break; | | ------------------ | | 122| 66| CHECK_NMSTRT_CASE(4, enc, ptr, end, nextTokPtr) | | ------------------ | | | | 99| 6| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (99:3): [True: 6, False: 1.95k] | | | | ------------------ | | | | 100| 6| if ((end) - (ptr) < (n)) \ | | | | ------------------ | | | | | Branch (100:9): [True: 1, False: 5] | | | | ------------------ | | | | 101| 1| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 1|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 102| 5| if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NMSTRT_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 240| 10| (AS_NORMAL_ENCODING(enc)->isInvalid##n(enc, p)) | | | | | | ------------------ | | | | | | | | 207| 5|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | | | ------------------ | | | | | | | Branch (240:3): [True: 4, False: 1] | | | | | | ------------------ | | | | ------------------ | | | | if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NMSTRT_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 238| 1|#define IS_NMSTRT_CHAR(enc, p, n) (AS_NORMAL_ENCODING(enc)->isNmstrt##n(enc, p)) | | | | | | ------------------ | | | | | | | | 207| 1|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (102:41): [True: 1, False: 0] | | | | ------------------ | | | | 103| 5| *nextTokPtr = ptr; \ | | | | 104| 5| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 5|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 105| 5| } \ | | | | 106| 5| ptr += n; \ | | | | 107| 0| break; | | ------------------ ------------------ 928| 799| case BT_S: ------------------ | Branch (928:3): [True: 799, False: 1.16k] ------------------ 929| 865| case BT_LF: ------------------ | Branch (929:3): [True: 66, False: 1.89k] ------------------ 930| 932| case BT_CR: ------------------ | Branch (930:3): [True: 67, False: 1.89k] ------------------ 931| 938| case BT_PERCNT: ------------------ | Branch (931:3): [True: 6, False: 1.95k] ------------------ 932| 938| *nextTokPtr = ptr; 933| 938| return XML_TOK_PERCENT; ------------------ | | 89| 938|# define XML_TOK_PERCENT 22 ------------------ 934| 55| default: ------------------ | Branch (934:3): [True: 55, False: 1.90k] ------------------ 935| 55| *nextTokPtr = ptr; 936| 55| return XML_TOK_INVALID; ------------------ | | 57| 55|# define XML_TOK_INVALID 0 ------------------ 937| 1.96k| } 938| 2.14k| while (HAS_CHAR(enc, ptr, end)) { 939| 2.14k| switch (BYTE_TYPE(enc, ptr)) { ------------------ | | 233| 2.14k|#define BYTE_TYPE(enc, p) SB_BYTE_TYPE(enc, p) | | ------------------ | | | | 231| 2.14k| (((const struct normal_encoding *)(enc))->type[(unsigned char)*(p)]) | | ------------------ ------------------ 940| 2.54k| CHECK_NAME_CASES(enc, ptr, end, nextTokPtr) ------------------ | | 81| 1.07k| case BT_NONASCII: \ | | ------------------ | | | Branch (81:3): [True: 0, False: 2.14k] | | ------------------ | | 82| 1.07k| if (! IS_NAME_CHAR_MINBPC(enc, ptr)) { \ | | ------------------ | | | | 242| 0|#define IS_NAME_CHAR_MINBPC(enc, p) (0) | | ------------------ | | | Branch (82:9): [True: 0, Folded] | | ------------------ | | 83| 0| *nextTokPtr = ptr; \ | | 84| 0| return XML_TOK_INVALID; \ | | ------------------ | | | | 57| 0|# define XML_TOK_INVALID 0 | | ------------------ | | 85| 0| } \ | | 86| 1.07k| EXPAT_FALLTHROUGH; \ | | ------------------ | | | | 47| 0|# define EXPAT_FALLTHROUGH __attribute__((fallthrough)) | | ------------------ | | 87| 231| case BT_NMSTRT: \ | | ------------------ | | | Branch (87:3): [True: 231, False: 1.91k] | | ------------------ | | 88| 465| case BT_HEX: \ | | ------------------ | | | Branch (88:3): [True: 234, False: 1.90k] | | ------------------ | | 89| 671| case BT_DIGIT: \ | | ------------------ | | | Branch (89:3): [True: 206, False: 1.93k] | | ------------------ | | 90| 871| case BT_NAME: \ | | ------------------ | | | Branch (90:3): [True: 200, False: 1.94k] | | ------------------ | | 91| 1.07k| case BT_MINUS: \ | | ------------------ | | | Branch (91:3): [True: 199, False: 1.94k] | | ------------------ | | 92| 1.07k| ptr += MINBPC(enc); \ | | ------------------ | | | | 228| 1.07k|#define MINBPC(enc) 1 | | ------------------ | | 93| 1.07k| break; \ | | 94| 1.07k| CHECK_NAME_CASE(2, enc, ptr, end, nextTokPtr) \ | | ------------------ | | | | 70| 75| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (70:3): [True: 75, False: 2.06k] | | | | ------------------ | | | | 71| 75| if (end - ptr < n) \ | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 75] | | | | ------------------ | | | | 72| 66| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 0|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 73| 75| if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NAME_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 240| 150| (AS_NORMAL_ENCODING(enc)->isInvalid##n(enc, p)) | | | | | | ------------------ | | | | | | | | 207| 75|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | | | ------------------ | | | | | | | Branch (240:3): [True: 8, False: 67] | | | | | | ------------------ | | | | ------------------ | | | | if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NAME_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 237| 67|#define IS_NAME_CHAR(enc, p, n) (AS_NORMAL_ENCODING(enc)->isName##n(enc, p)) | | | | | | ------------------ | | | | | | | | 207| 67|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (73:41): [True: 1, False: 66] | | | | ------------------ | | | | 74| 9| *nextTokPtr = ptr; \ | | | | 75| 9| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 9|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 76| 9| } \ | | | | 77| 75| ptr += n; \ | | | | 78| 66| break; | | ------------------ | | 95| 73| CHECK_NAME_CASE(3, enc, ptr, end, nextTokPtr) \ | | ------------------ | | | | 70| 73| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (70:3): [True: 73, False: 2.07k] | | | | ------------------ | | | | 71| 73| if (end - ptr < n) \ | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 73] | | | | ------------------ | | | | 72| 66| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 0|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 73| 73| if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NAME_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 240| 146| (AS_NORMAL_ENCODING(enc)->isInvalid##n(enc, p)) | | | | | | ------------------ | | | | | | | | 207| 73|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | | | ------------------ | | | | | | | Branch (240:3): [True: 6, False: 67] | | | | | | ------------------ | | | | ------------------ | | | | if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NAME_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 237| 67|#define IS_NAME_CHAR(enc, p, n) (AS_NORMAL_ENCODING(enc)->isName##n(enc, p)) | | | | | | ------------------ | | | | | | | | 207| 67|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (73:41): [True: 1, False: 66] | | | | ------------------ | | | | 74| 7| *nextTokPtr = ptr; \ | | | | 75| 7| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 7|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 76| 7| } \ | | | | 77| 73| ptr += n; \ | | | | 78| 66| break; | | ------------------ | | 96| 66| CHECK_NAME_CASE(4, enc, ptr, end, nextTokPtr) | | ------------------ | | | | 70| 4| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (70:3): [True: 4, False: 2.13k] | | | | ------------------ | | | | 71| 4| if (end - ptr < n) \ | | | | ------------------ | | | | | Branch (71:9): [True: 1, False: 3] | | | | ------------------ | | | | 72| 1| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 1|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 73| 3| if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NAME_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 240| 6| (AS_NORMAL_ENCODING(enc)->isInvalid##n(enc, p)) | | | | | | ------------------ | | | | | | | | 207| 3|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | | | ------------------ | | | | | | | Branch (240:3): [True: 2, False: 1] | | | | | | ------------------ | | | | ------------------ | | | | if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NAME_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 237| 1|#define IS_NAME_CHAR(enc, p, n) (AS_NORMAL_ENCODING(enc)->isName##n(enc, p)) | | | | | | ------------------ | | | | | | | | 207| 1|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (73:41): [True: 1, False: 0] | | | | ------------------ | | | | 74| 3| *nextTokPtr = ptr; \ | | | | 75| 3| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 3|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 76| 3| } \ | | | | 77| 3| ptr += n; \ | | | | 78| 0| break; | | ------------------ ------------------ 941| 831| case BT_SEMI: ------------------ | Branch (941:5): [True: 831, False: 1.31k] ------------------ 942| 831| *nextTokPtr = ptr + MINBPC(enc); ------------------ | | 228| 831|#define MINBPC(enc) 1 ------------------ 943| 831| return XML_TOK_PARAM_ENTITY_REF; ------------------ | | 95| 831|# define XML_TOK_PARAM_ENTITY_REF 28 ------------------ 944| 90| default: ------------------ | Branch (944:5): [True: 90, False: 2.05k] ------------------ 945| 90| *nextTokPtr = ptr; 946| 90| return XML_TOK_INVALID; ------------------ | | 57| 90|# define XML_TOK_INVALID 0 ------------------ 947| 2.14k| } 948| 2.14k| } 949| 3| return XML_TOK_PARTIAL; ------------------ | | 56| 3|# define XML_TOK_PARTIAL -1 /* only part of a token */ ------------------ 950| 944|} xmltok.c:normal_scanPoundName: 954| 1.36k| const char **nextTokPtr) { 955| 1.36k| REQUIRE_CHAR(enc, ptr, end); ------------------ | | 140| 1.36k|# define REQUIRE_CHAR(enc, ptr, end) REQUIRE_CHARS(enc, ptr, end, 1) | | ------------------ | | | | 134| 1.36k| { \ | | | | 135| 1.36k| if (! HAS_CHARS(enc, ptr, end, count)) { \ | | | | ------------------ | | | | | | 129| 1.36k| ((end) - (ptr) >= ((count) * MINBPC(enc))) | | | | | | ------------------ | | | | | | | | 228| 1.36k|#define MINBPC(enc) 1 | | | | | | ------------------ | | | | ------------------ | | | | | Branch (135:11): [True: 0, False: 1.36k] | | | | ------------------ | | | | 136| 0| return XML_TOK_PARTIAL; \ | | | | ------------------ | | | | | | 56| 0|# define XML_TOK_PARTIAL -1 /* only part of a token */ | | | | ------------------ | | | | 137| 0| } \ | | | | 138| 1.36k| } | | ------------------ ------------------ 956| 1.36k| switch (BYTE_TYPE(enc, ptr)) { ------------------ | | 233| 1.36k|#define BYTE_TYPE(enc, p) SB_BYTE_TYPE(enc, p) | | ------------------ | | | | 231| 1.36k| (((const struct normal_encoding *)(enc))->type[(unsigned char)*(p)]) | | ------------------ ------------------ 957| 1.18k| CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr) ------------------ | | 110| 1.34k| case BT_NONASCII: \ | | ------------------ | | | Branch (110:3): [True: 0, False: 1.36k] | | ------------------ | | 111| 1.34k| if (! IS_NMSTRT_CHAR_MINBPC(enc, ptr)) { \ | | ------------------ | | | | 243| 0|#define IS_NMSTRT_CHAR_MINBPC(enc, p) (0) | | ------------------ | | | Branch (111:9): [True: 0, Folded] | | ------------------ | | 112| 0| *nextTokPtr = ptr; \ | | 113| 0| return XML_TOK_INVALID; \ | | ------------------ | | | | 57| 0|# define XML_TOK_INVALID 0 | | ------------------ | | 114| 0| } \ | | 115| 1.34k| EXPAT_FALLTHROUGH; \ | | ------------------ | | | | 47| 0|# define EXPAT_FALLTHROUGH __attribute__((fallthrough)) | | ------------------ | | 116| 1.15k| case BT_NMSTRT: \ | | ------------------ | | | Branch (116:3): [True: 1.15k, False: 205] | | ------------------ | | 117| 1.34k| case BT_HEX: \ | | ------------------ | | | Branch (117:3): [True: 187, False: 1.17k] | | ------------------ | | 118| 1.34k| ptr += MINBPC(enc); \ | | ------------------ | | | | 228| 1.34k|#define MINBPC(enc) 1 | | ------------------ | | 119| 1.34k| break; \ | | 120| 1.34k| CHECK_NMSTRT_CASE(2, enc, ptr, end, nextTokPtr) \ | | ------------------ | | | | 99| 5| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (99:3): [True: 5, False: 1.35k] | | | | ------------------ | | | | 100| 5| if ((end) - (ptr) < (n)) \ | | | | ------------------ | | | | | Branch (100:9): [True: 0, False: 5] | | | | ------------------ | | | | 101| 1| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 0|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 102| 5| if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NMSTRT_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 240| 10| (AS_NORMAL_ENCODING(enc)->isInvalid##n(enc, p)) | | | | | | ------------------ | | | | | | | | 207| 5|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | | | ------------------ | | | | | | | Branch (240:3): [True: 3, False: 2] | | | | | | ------------------ | | | | ------------------ | | | | if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NMSTRT_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 238| 2|#define IS_NMSTRT_CHAR(enc, p, n) (AS_NORMAL_ENCODING(enc)->isNmstrt##n(enc, p)) | | | | | | ------------------ | | | | | | | | 207| 2|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (102:41): [True: 1, False: 1] | | | | ------------------ | | | | 103| 4| *nextTokPtr = ptr; \ | | | | 104| 4| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 4|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 105| 4| } \ | | | | 106| 5| ptr += n; \ | | | | 107| 1| break; | | ------------------ | | 121| 6| CHECK_NMSTRT_CASE(3, enc, ptr, end, nextTokPtr) \ | | ------------------ | | | | 99| 6| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (99:3): [True: 6, False: 1.35k] | | | | ------------------ | | | | 100| 6| if ((end) - (ptr) < (n)) \ | | | | ------------------ | | | | | Branch (100:9): [True: 0, False: 6] | | | | ------------------ | | | | 101| 1| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 0|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 102| 6| if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NMSTRT_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 240| 12| (AS_NORMAL_ENCODING(enc)->isInvalid##n(enc, p)) | | | | | | ------------------ | | | | | | | | 207| 6|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | | | ------------------ | | | | | | | Branch (240:3): [True: 4, False: 2] | | | | | | ------------------ | | | | ------------------ | | | | if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NMSTRT_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 238| 2|#define IS_NMSTRT_CHAR(enc, p, n) (AS_NORMAL_ENCODING(enc)->isNmstrt##n(enc, p)) | | | | | | ------------------ | | | | | | | | 207| 2|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (102:41): [True: 1, False: 1] | | | | ------------------ | | | | 103| 5| *nextTokPtr = ptr; \ | | | | 104| 5| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 5|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 105| 5| } \ | | | | 106| 6| ptr += n; \ | | | | 107| 1| break; | | ------------------ | | 122| 3| CHECK_NMSTRT_CASE(4, enc, ptr, end, nextTokPtr) | | ------------------ | | | | 99| 3| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (99:3): [True: 3, False: 1.36k] | | | | ------------------ | | | | 100| 3| if ((end) - (ptr) < (n)) \ | | | | ------------------ | | | | | Branch (100:9): [True: 1, False: 2] | | | | ------------------ | | | | 101| 1| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 1|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 102| 2| if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NMSTRT_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 240| 4| (AS_NORMAL_ENCODING(enc)->isInvalid##n(enc, p)) | | | | | | ------------------ | | | | | | | | 207| 2|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | | | ------------------ | | | | | | | Branch (240:3): [True: 1, False: 1] | | | | | | ------------------ | | | | ------------------ | | | | if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NMSTRT_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 238| 1|#define IS_NMSTRT_CHAR(enc, p, n) (AS_NORMAL_ENCODING(enc)->isNmstrt##n(enc, p)) | | | | | | ------------------ | | | | | | | | 207| 1|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (102:41): [True: 1, False: 0] | | | | ------------------ | | | | 103| 2| *nextTokPtr = ptr; \ | | | | 104| 2| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 2|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 105| 2| } \ | | | | 106| 2| ptr += n; \ | | | | 107| 0| break; | | ------------------ ------------------ 958| 4| default: ------------------ | Branch (958:3): [True: 4, False: 1.36k] ------------------ 959| 4| *nextTokPtr = ptr; 960| 4| return XML_TOK_INVALID; ------------------ | | 57| 4|# define XML_TOK_INVALID 0 ------------------ 961| 1.36k| } 962| 9.45k| while (HAS_CHAR(enc, ptr, end)) { 963| 9.45k| switch (BYTE_TYPE(enc, ptr)) { ------------------ | | 233| 9.45k|#define BYTE_TYPE(enc, p) SB_BYTE_TYPE(enc, p) | | ------------------ | | | | 231| 9.45k| (((const struct normal_encoding *)(enc))->type[(unsigned char)*(p)]) | | ------------------ ------------------ 964| 26.8k| CHECK_NAME_CASES(enc, ptr, end, nextTokPtr) ------------------ | | 81| 7.97k| case BT_NONASCII: \ | | ------------------ | | | Branch (81:3): [True: 0, False: 9.45k] | | ------------------ | | 82| 7.97k| if (! IS_NAME_CHAR_MINBPC(enc, ptr)) { \ | | ------------------ | | | | 242| 0|#define IS_NAME_CHAR_MINBPC(enc, p) (0) | | ------------------ | | | Branch (82:9): [True: 0, Folded] | | ------------------ | | 83| 0| *nextTokPtr = ptr; \ | | 84| 0| return XML_TOK_INVALID; \ | | ------------------ | | | | 57| 0|# define XML_TOK_INVALID 0 | | ------------------ | | 85| 0| } \ | | 86| 7.97k| EXPAT_FALLTHROUGH; \ | | ------------------ | | | | 47| 0|# define EXPAT_FALLTHROUGH __attribute__((fallthrough)) | | ------------------ | | 87| 3.92k| case BT_NMSTRT: \ | | ------------------ | | | Branch (87:3): [True: 3.92k, False: 5.53k] | | ------------------ | | 88| 7.29k| case BT_HEX: \ | | ------------------ | | | Branch (88:3): [True: 3.37k, False: 6.08k] | | ------------------ | | 89| 7.56k| case BT_DIGIT: \ | | ------------------ | | | Branch (89:3): [True: 264, False: 9.19k] | | ------------------ | | 90| 7.75k| case BT_NAME: \ | | ------------------ | | | Branch (90:3): [True: 198, False: 9.25k] | | ------------------ | | 91| 7.97k| case BT_MINUS: \ | | ------------------ | | | Branch (91:3): [True: 218, False: 9.23k] | | ------------------ | | 92| 7.97k| ptr += MINBPC(enc); \ | | ------------------ | | | | 228| 7.97k|#define MINBPC(enc) 1 | | ------------------ | | 93| 7.97k| break; \ | | 94| 7.97k| CHECK_NAME_CASE(2, enc, ptr, end, nextTokPtr) \ | | ------------------ | | | | 70| 68| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (70:3): [True: 68, False: 9.38k] | | | | ------------------ | | | | 71| 68| if (end - ptr < n) \ | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 68] | | | | ------------------ | | | | 72| 66| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 0|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 73| 68| if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NAME_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 240| 136| (AS_NORMAL_ENCODING(enc)->isInvalid##n(enc, p)) | | | | | | ------------------ | | | | | | | | 207| 68|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | | | ------------------ | | | | | | | Branch (240:3): [True: 1, False: 67] | | | | | | ------------------ | | | | ------------------ | | | | if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NAME_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 237| 67|#define IS_NAME_CHAR(enc, p, n) (AS_NORMAL_ENCODING(enc)->isName##n(enc, p)) | | | | | | ------------------ | | | | | | | | 207| 67|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (73:41): [True: 1, False: 66] | | | | ------------------ | | | | 74| 2| *nextTokPtr = ptr; \ | | | | 75| 2| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 2|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 76| 2| } \ | | | | 77| 68| ptr += n; \ | | | | 78| 66| break; | | ------------------ | | 95| 69| CHECK_NAME_CASE(3, enc, ptr, end, nextTokPtr) \ | | ------------------ | | | | 70| 69| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (70:3): [True: 69, False: 9.38k] | | | | ------------------ | | | | 71| 69| if (end - ptr < n) \ | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 69] | | | | ------------------ | | | | 72| 66| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 0|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 73| 69| if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NAME_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 240| 138| (AS_NORMAL_ENCODING(enc)->isInvalid##n(enc, p)) | | | | | | ------------------ | | | | | | | | 207| 69|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | | | ------------------ | | | | | | | Branch (240:3): [True: 2, False: 67] | | | | | | ------------------ | | | | ------------------ | | | | if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NAME_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 237| 67|#define IS_NAME_CHAR(enc, p, n) (AS_NORMAL_ENCODING(enc)->isName##n(enc, p)) | | | | | | ------------------ | | | | | | | | 207| 67|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (73:41): [True: 1, False: 66] | | | | ------------------ | | | | 74| 3| *nextTokPtr = ptr; \ | | | | 75| 3| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 3|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 76| 3| } \ | | | | 77| 69| ptr += n; \ | | | | 78| 66| break; | | ------------------ | | 96| 66| CHECK_NAME_CASE(4, enc, ptr, end, nextTokPtr) | | ------------------ | | | | 70| 7| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (70:3): [True: 7, False: 9.45k] | | | | ------------------ | | | | 71| 7| if (end - ptr < n) \ | | | | ------------------ | | | | | Branch (71:9): [True: 1, False: 6] | | | | ------------------ | | | | 72| 1| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 1|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 73| 6| if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NAME_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 240| 12| (AS_NORMAL_ENCODING(enc)->isInvalid##n(enc, p)) | | | | | | ------------------ | | | | | | | | 207| 6|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | | | ------------------ | | | | | | | Branch (240:3): [True: 5, False: 1] | | | | | | ------------------ | | | | ------------------ | | | | if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NAME_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 237| 1|#define IS_NAME_CHAR(enc, p, n) (AS_NORMAL_ENCODING(enc)->isName##n(enc, p)) | | | | | | ------------------ | | | | | | | | 207| 1|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (73:41): [True: 1, False: 0] | | | | ------------------ | | | | 74| 6| *nextTokPtr = ptr; \ | | | | 75| 6| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 6|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 76| 6| } \ | | | | 77| 6| ptr += n; \ | | | | 78| 0| break; | | ------------------ ------------------ 965| 18| case BT_CR: ------------------ | Branch (965:5): [True: 18, False: 9.43k] ------------------ 966| 84| case BT_LF: ------------------ | Branch (966:5): [True: 66, False: 9.39k] ------------------ 967| 854| case BT_S: ------------------ | Branch (967:5): [True: 770, False: 8.68k] ------------------ 968| 966| case BT_RPAR: ------------------ | Branch (968:5): [True: 112, False: 9.34k] ------------------ 969| 1.21k| case BT_GT: ------------------ | Branch (969:5): [True: 251, False: 9.20k] ------------------ 970| 1.22k| case BT_PERCNT: ------------------ | Branch (970:5): [True: 3, False: 9.45k] ------------------ 971| 1.33k| case BT_VERBAR: ------------------ | Branch (971:5): [True: 112, False: 9.34k] ------------------ 972| 1.33k| *nextTokPtr = ptr; 973| 1.33k| return XML_TOK_POUND_NAME; ------------------ | | 87| 1.33k|# define XML_TOK_POUND_NAME 20 /* #name */ ------------------ 974| 4| default: ------------------ | Branch (974:5): [True: 4, False: 9.45k] ------------------ 975| 4| *nextTokPtr = ptr; 976| 4| return XML_TOK_INVALID; ------------------ | | 57| 4|# define XML_TOK_INVALID 0 ------------------ 977| 9.45k| } 978| 9.45k| } 979| 0| return -XML_TOK_POUND_NAME; ------------------ | | 87| 0|# define XML_TOK_POUND_NAME 20 /* #name */ ------------------ 980| 1.34k|} xmltok.c:normal_contentTok: 824| 463k| const char **nextTokPtr) { 825| 463k| if (ptr >= end) ------------------ | Branch (825:7): [True: 102k, False: 361k] ------------------ 826| 102k| return XML_TOK_NONE; ------------------ | | 51| 102k|# define XML_TOK_NONE -4 /* The string to be scanned is empty */ ------------------ 827| 361k| if (MINBPC(enc) > 1) { ------------------ | | 228| 361k|#define MINBPC(enc) 1 ------------------ | Branch (827:7): [Folded, False: 361k] ------------------ 828| 0| size_t n = end - ptr; 829| 0| if (n & (MINBPC(enc) - 1)) { ------------------ | | 228| 0|#define MINBPC(enc) 1 ------------------ | Branch (829:9): [True: 0, False: 0] ------------------ 830| 0| n &= ~(MINBPC(enc) - 1); ------------------ | | 228| 0|#define MINBPC(enc) 1 ------------------ 831| 0| if (n == 0) ------------------ | Branch (831:11): [True: 0, False: 0] ------------------ 832| 0| return XML_TOK_PARTIAL; ------------------ | | 56| 0|# define XML_TOK_PARTIAL -1 /* only part of a token */ ------------------ 833| 0| end = ptr + n; 834| 0| } 835| 0| } 836| 361k| switch (BYTE_TYPE(enc, ptr)) { ------------------ | | 233| 361k|#define BYTE_TYPE(enc, p) SB_BYTE_TYPE(enc, p) | | ------------------ | | | | 231| 361k| (((const struct normal_encoding *)(enc))->type[(unsigned char)*(p)]) | | ------------------ ------------------ 837| 66.7k| case BT_LT: ------------------ | Branch (837:3): [True: 66.7k, False: 294k] ------------------ 838| 66.7k| return PREFIX(scanLt)(enc, ptr + MINBPC(enc), end, nextTokPtr); ------------------ | | 248| 66.7k|#define PREFIX(ident) normal_##ident ------------------ return PREFIX(scanLt)(enc, ptr + MINBPC(enc), end, nextTokPtr); ------------------ | | 228| 66.7k|#define MINBPC(enc) 1 ------------------ 839| 146k| case BT_AMP: ------------------ | Branch (839:3): [True: 146k, False: 214k] ------------------ 840| 146k| return PREFIX(scanRef)(enc, ptr + MINBPC(enc), end, nextTokPtr); ------------------ | | 248| 146k|#define PREFIX(ident) normal_##ident ------------------ return PREFIX(scanRef)(enc, ptr + MINBPC(enc), end, nextTokPtr); ------------------ | | 228| 146k|#define MINBPC(enc) 1 ------------------ 841| 614| case BT_CR: ------------------ | Branch (841:3): [True: 614, False: 360k] ------------------ 842| 614| ptr += MINBPC(enc); ------------------ | | 228| 614|#define MINBPC(enc) 1 ------------------ 843| 614| if (! HAS_CHAR(enc, ptr, end)) ------------------ | | 131| 614|# define HAS_CHAR(enc, ptr, end) HAS_CHARS(enc, ptr, end, 1) | | ------------------ | | | | 129| 614| ((end) - (ptr) >= ((count) * MINBPC(enc))) | | | | ------------------ | | | | | | 228| 614|#define MINBPC(enc) 1 | | | | ------------------ | | ------------------ ------------------ | Branch (843:9): [True: 0, False: 614] ------------------ 844| 0| return XML_TOK_TRAILING_CR; ------------------ | | 53| 0| -3 /* A CR at the end of the scan; \ ------------------ 845| 614| if (BYTE_TYPE(enc, ptr) == BT_LF) ------------------ | | 233| 614|#define BYTE_TYPE(enc, p) SB_BYTE_TYPE(enc, p) | | ------------------ | | | | 231| 614| (((const struct normal_encoding *)(enc))->type[(unsigned char)*(p)]) | | ------------------ ------------------ | Branch (845:9): [True: 194, False: 420] ------------------ 846| 194| ptr += MINBPC(enc); ------------------ | | 228| 194|#define MINBPC(enc) 1 ------------------ 847| 614| *nextTokPtr = ptr; 848| 614| return XML_TOK_DATA_NEWLINE; ------------------ | | 68| 614|# define XML_TOK_DATA_NEWLINE 7 ------------------ 849| 515| case BT_LF: ------------------ | Branch (849:3): [True: 515, False: 360k] ------------------ 850| 515| *nextTokPtr = ptr + MINBPC(enc); ------------------ | | 228| 515|#define MINBPC(enc) 1 ------------------ 851| 515| return XML_TOK_DATA_NEWLINE; ------------------ | | 68| 515|# define XML_TOK_DATA_NEWLINE 7 ------------------ 852| 1.94k| case BT_RSQB: ------------------ | Branch (852:3): [True: 1.94k, False: 359k] ------------------ 853| 1.94k| ptr += MINBPC(enc); ------------------ | | 228| 1.94k|#define MINBPC(enc) 1 ------------------ 854| 1.94k| if (! HAS_CHAR(enc, ptr, end)) ------------------ | | 131| 1.94k|# define HAS_CHAR(enc, ptr, end) HAS_CHARS(enc, ptr, end, 1) | | ------------------ | | | | 129| 1.94k| ((end) - (ptr) >= ((count) * MINBPC(enc))) | | | | ------------------ | | | | | | 228| 1.94k|#define MINBPC(enc) 1 | | | | ------------------ | | ------------------ ------------------ | Branch (854:9): [True: 293, False: 1.65k] ------------------ 855| 293| return XML_TOK_TRAILING_RSQB; ------------------ | | 46| 293| -5 /* ] or ]] at the end of the scan; might be \ ------------------ 856| 1.65k| if (! CHAR_MATCHES(enc, ptr, ASCII_RSQB)) ------------------ | | 246| 1.65k|#define CHAR_MATCHES(enc, p, c) (*(p) == (c)) ------------------ | Branch (856:9): [True: 985, False: 665] ------------------ 857| 985| break; 858| 665| ptr += MINBPC(enc); ------------------ | | 228| 665|#define MINBPC(enc) 1 ------------------ 859| 665| if (! HAS_CHAR(enc, ptr, end)) ------------------ | | 131| 665|# define HAS_CHAR(enc, ptr, end) HAS_CHARS(enc, ptr, end, 1) | | ------------------ | | | | 129| 665| ((end) - (ptr) >= ((count) * MINBPC(enc))) | | | | ------------------ | | | | | | 228| 665|#define MINBPC(enc) 1 | | | | ------------------ | | ------------------ ------------------ | Branch (859:9): [True: 387, False: 278] ------------------ 860| 387| return XML_TOK_TRAILING_RSQB; ------------------ | | 46| 387| -5 /* ] or ]] at the end of the scan; might be \ ------------------ 861| 278| if (! CHAR_MATCHES(enc, ptr, ASCII_GT)) { ------------------ | | 246| 278|#define CHAR_MATCHES(enc, p, c) (*(p) == (c)) ------------------ | Branch (861:9): [True: 277, False: 1] ------------------ 862| 277| ptr -= MINBPC(enc); ------------------ | | 228| 277|#define MINBPC(enc) 1 ------------------ 863| 277| break; 864| 277| } 865| 1| *nextTokPtr = ptr; 866| 1| return XML_TOK_INVALID; ------------------ | | 57| 1|# define XML_TOK_INVALID 0 ------------------ 867| 2.93k| INVALID_CASES(ptr, nextTokPtr) ------------------ | | 60| 281| INVALID_LEAD_CASE(2, ptr, nextTokPtr) \ | | ------------------ | | | | 49| 281| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (49:3): [True: 281, False: 360k] | | | | ------------------ | | | | 50| 281| if (end - ptr < n) \ | | | | ------------------ | | | | | Branch (50:9): [True: 0, False: 281] | | | | ------------------ | | | | 51| 263| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 0|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 52| 281| if (IS_INVALID_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 240| 281| (AS_NORMAL_ENCODING(enc)->isInvalid##n(enc, p)) | | | | | | ------------------ | | | | | | | | 207| 281|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | | | ------------------ | | | | | | | Branch (240:3): [True: 18, False: 263] | | | | | | ------------------ | | | | ------------------ | | | | 53| 18| *(nextTokPtr) = (ptr); \ | | | | 54| 18| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 18|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 55| 18| } \ | | | | 56| 281| ptr += n; \ | | | | 57| 263| break; | | ------------------ | | 61| 674| INVALID_LEAD_CASE(3, ptr, nextTokPtr) \ | | ------------------ | | | | 49| 674| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (49:3): [True: 674, False: 360k] | | | | ------------------ | | | | 50| 674| if (end - ptr < n) \ | | | | ------------------ | | | | | Branch (50:9): [True: 0, False: 674] | | | | ------------------ | | | | 51| 658| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 0|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 52| 674| if (IS_INVALID_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 240| 674| (AS_NORMAL_ENCODING(enc)->isInvalid##n(enc, p)) | | | | | | ------------------ | | | | | | | | 207| 674|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | | | ------------------ | | | | | | | Branch (240:3): [True: 16, False: 658] | | | | | | ------------------ | | | | ------------------ | | | | 53| 16| *(nextTokPtr) = (ptr); \ | | | | 54| 16| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 16|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 55| 16| } \ | | | | 56| 674| ptr += n; \ | | | | 57| 658| break; | | ------------------ | | 62| 658| INVALID_LEAD_CASE(4, ptr, nextTokPtr) \ | | ------------------ | | | | 49| 508| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (49:3): [True: 508, False: 360k] | | | | ------------------ | | | | 50| 508| if (end - ptr < n) \ | | | | ------------------ | | | | | Branch (50:9): [True: 1, False: 507] | | | | ------------------ | | | | 51| 490| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 1|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 52| 507| if (IS_INVALID_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 240| 507| (AS_NORMAL_ENCODING(enc)->isInvalid##n(enc, p)) | | | | | | ------------------ | | | | | | | | 207| 507|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | | | ------------------ | | | | | | | Branch (240:3): [True: 17, False: 490] | | | | | | ------------------ | | | | ------------------ | | | | 53| 17| *(nextTokPtr) = (ptr); \ | | | | 54| 17| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 17|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 55| 17| } \ | | | | 56| 507| ptr += n; \ | | | | 57| 490| break; | | ------------------ | | 63| 490| case BT_NONXML: \ | | ------------------ | | | Branch (63:3): [True: 4, False: 361k] | | ------------------ | | 64| 7| case BT_MALFORM: \ | | ------------------ | | | Branch (64:3): [True: 3, False: 361k] | | ------------------ | | 65| 12| case BT_TRAIL: \ | | ------------------ | | | Branch (65:3): [True: 5, False: 361k] | | ------------------ | | 66| 12| *(nextTokPtr) = (ptr); \ | | 67| 12| return XML_TOK_INVALID; | | ------------------ | | | | 57| 12|# define XML_TOK_INVALID 0 | | ------------------ ------------------ 868| 143k| default: ------------------ | Branch (868:3): [True: 143k, False: 217k] ------------------ 869| 143k| ptr += MINBPC(enc); ------------------ | | 228| 143k|#define MINBPC(enc) 1 ------------------ 870| 143k| break; 871| 361k| } 872| 16.1M| while (HAS_CHAR(enc, ptr, end)) { 873| 16.1M| switch (BYTE_TYPE(enc, ptr)) { ------------------ | | 233| 16.1M|#define BYTE_TYPE(enc, p) SB_BYTE_TYPE(enc, p) | | ------------------ | | | | 231| 16.1M| (((const struct normal_encoding *)(enc))->type[(unsigned char)*(p)]) | | ------------------ ------------------ 874| 0|# define LEAD_CASE(n) \ 875| 0| case BT_LEAD##n: \ 876| 0| if (end - ptr < n || IS_INVALID_CHAR(enc, ptr, n)) { \ 877| 0| *nextTokPtr = ptr; \ 878| 0| return XML_TOK_DATA_CHARS; \ 879| 0| } \ 880| 0| ptr += n; \ 881| 0| break; 882| 5.57k| LEAD_CASE(2) ------------------ | | 875| 5.57k| case BT_LEAD##n: \ | | ------------------ | | | Branch (875:3): [True: 5.57k, False: 16.1M] | | ------------------ | | 876| 5.57k| if (end - ptr < n || IS_INVALID_CHAR(enc, ptr, n)) { \ | | ------------------ | | | | 240| 5.57k| (AS_NORMAL_ENCODING(enc)->isInvalid##n(enc, p)) | | | | ------------------ | | | | | | 207| 5.57k|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | ------------------ | | | | | Branch (240:3): [True: 11, False: 5.56k] | | | | ------------------ | | ------------------ | | | Branch (876:9): [True: 0, False: 5.57k] | | ------------------ | | 877| 11| *nextTokPtr = ptr; \ | | 878| 11| return XML_TOK_DATA_CHARS; \ | | ------------------ | | | | 67| 11|# define XML_TOK_DATA_CHARS 6 | | ------------------ | | 879| 11| } \ | | 880| 5.56k| ptr += n; \ | | 881| 5.56k| break; ------------------ 883| 303| LEAD_CASE(3) ------------------ | | 875| 303| case BT_LEAD##n: \ | | ------------------ | | | Branch (875:3): [True: 303, False: 16.1M] | | ------------------ | | 876| 303| if (end - ptr < n || IS_INVALID_CHAR(enc, ptr, n)) { \ | | ------------------ | | | | 240| 303| (AS_NORMAL_ENCODING(enc)->isInvalid##n(enc, p)) | | | | ------------------ | | | | | | 207| 303|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | ------------------ | | | | | Branch (240:3): [True: 13, False: 290] | | | | ------------------ | | ------------------ | | | Branch (876:9): [True: 0, False: 303] | | ------------------ | | 877| 13| *nextTokPtr = ptr; \ | | 878| 13| return XML_TOK_DATA_CHARS; \ | | ------------------ | | | | 67| 13|# define XML_TOK_DATA_CHARS 6 | | ------------------ | | 879| 13| } \ | | 880| 290| ptr += n; \ | | 881| 290| break; ------------------ 884| 301| LEAD_CASE(4) ------------------ | | 875| 301| case BT_LEAD##n: \ | | ------------------ | | | Branch (875:3): [True: 301, False: 16.1M] | | ------------------ | | 876| 301| if (end - ptr < n || IS_INVALID_CHAR(enc, ptr, n)) { \ | | ------------------ | | | | 240| 300| (AS_NORMAL_ENCODING(enc)->isInvalid##n(enc, p)) | | | | ------------------ | | | | | | 207| 300|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | ------------------ | | | | | Branch (240:3): [True: 10, False: 290] | | | | ------------------ | | ------------------ | | | Branch (876:9): [True: 1, False: 300] | | ------------------ | | 877| 11| *nextTokPtr = ptr; \ | | 878| 11| return XML_TOK_DATA_CHARS; \ | | ------------------ | | | | 67| 11|# define XML_TOK_DATA_CHARS 6 | | ------------------ | | 879| 11| } \ | | 880| 290| ptr += n; \ | | 881| 290| break; ------------------ 885| 0|# undef LEAD_CASE 886| 3.64k| case BT_RSQB: ------------------ | Branch (886:5): [True: 3.64k, False: 16.1M] ------------------ 887| 3.64k| if (HAS_CHARS(enc, ptr, end, 2)) { ------------------ | | 129| 3.64k| ((end) - (ptr) >= ((count) * MINBPC(enc))) | | ------------------ | | | | 228| 3.64k|#define MINBPC(enc) 1 | | ------------------ | | | Branch (129:5): [True: 3.44k, False: 202] | | ------------------ ------------------ 888| 3.44k| if (! CHAR_MATCHES(enc, ptr + MINBPC(enc), ASCII_RSQB)) { ------------------ | | 246| 3.44k|#define CHAR_MATCHES(enc, p, c) (*(p) == (c)) ------------------ | Branch (888:13): [True: 1.75k, False: 1.68k] ------------------ 889| 1.75k| ptr += MINBPC(enc); ------------------ | | 228| 1.75k|#define MINBPC(enc) 1 ------------------ 890| 1.75k| break; 891| 1.75k| } 892| 1.68k| if (HAS_CHARS(enc, ptr, end, 3)) { ------------------ | | 129| 1.68k| ((end) - (ptr) >= ((count) * MINBPC(enc))) | | ------------------ | | | | 228| 1.68k|#define MINBPC(enc) 1 | | ------------------ | | | Branch (129:5): [True: 1.49k, False: 198] | | ------------------ ------------------ 893| 1.49k| if (! CHAR_MATCHES(enc, ptr + 2 * MINBPC(enc), ASCII_GT)) { ------------------ | | 246| 1.49k|#define CHAR_MATCHES(enc, p, c) (*(p) == (c)) ------------------ | Branch (893:15): [True: 1.47k, False: 20] ------------------ 894| 1.47k| ptr += MINBPC(enc); ------------------ | | 228| 1.47k|#define MINBPC(enc) 1 ------------------ 895| 1.47k| break; 896| 1.47k| } 897| 20| *nextTokPtr = ptr + 2 * MINBPC(enc); ------------------ | | 228| 20|#define MINBPC(enc) 1 ------------------ 898| 20| return XML_TOK_INVALID; ------------------ | | 57| 20|# define XML_TOK_INVALID 0 ------------------ 899| 1.49k| } 900| 1.68k| } 901| 400| EXPAT_FALLTHROUGH; ------------------ | | 47| 400|# define EXPAT_FALLTHROUGH __attribute__((fallthrough)) ------------------ 902| 57.2k| case BT_AMP: ------------------ | Branch (902:5): [True: 56.8k, False: 16.0M] ------------------ 903| 61.7k| case BT_LT: ------------------ | Branch (903:5): [True: 4.55k, False: 16.1M] ------------------ 904| 61.7k| case BT_NONXML: ------------------ | Branch (904:5): [True: 1, False: 16.1M] ------------------ 905| 61.7k| case BT_MALFORM: ------------------ | Branch (905:5): [True: 3, False: 16.1M] ------------------ 906| 61.7k| case BT_TRAIL: ------------------ | Branch (906:5): [True: 2, False: 16.1M] ------------------ 907| 61.9k| case BT_CR: ------------------ | Branch (907:5): [True: 229, False: 16.1M] ------------------ 908| 62.3k| case BT_LF: ------------------ | Branch (908:5): [True: 315, False: 16.1M] ------------------ 909| 62.3k| *nextTokPtr = ptr; 910| 62.3k| return XML_TOK_DATA_CHARS; ------------------ | | 67| 62.3k|# define XML_TOK_DATA_CHARS 6 ------------------ 911| 16.0M| default: ------------------ | Branch (911:5): [True: 16.0M, False: 71.7k] ------------------ 912| 16.0M| ptr += MINBPC(enc); ------------------ | | 228| 16.0M|#define MINBPC(enc) 1 ------------------ 913| 16.0M| break; 914| 16.1M| } 915| 16.1M| } 916| 83.5k| *nextTokPtr = ptr; 917| 83.5k| return XML_TOK_DATA_CHARS; ------------------ | | 67| 83.5k|# define XML_TOK_DATA_CHARS 6 ------------------ 918| 145k|} xmltok.c:normal_scanLt: 726| 66.7k| const char **nextTokPtr) { 727| 66.7k|# ifdef XML_NS 728| 66.7k| int hadColon; 729| 66.7k|# endif 730| 66.7k| REQUIRE_CHAR(enc, ptr, end); ------------------ | | 140| 66.7k|# define REQUIRE_CHAR(enc, ptr, end) REQUIRE_CHARS(enc, ptr, end, 1) | | ------------------ | | | | 134| 66.7k| { \ | | | | 135| 66.7k| if (! HAS_CHARS(enc, ptr, end, count)) { \ | | | | ------------------ | | | | | | 129| 66.7k| ((end) - (ptr) >= ((count) * MINBPC(enc))) | | | | | | ------------------ | | | | | | | | 228| 66.7k|#define MINBPC(enc) 1 | | | | | | ------------------ | | | | ------------------ | | | | | Branch (135:11): [True: 6, False: 66.7k] | | | | ------------------ | | | | 136| 6| return XML_TOK_PARTIAL; \ | | | | ------------------ | | | | | | 56| 6|# define XML_TOK_PARTIAL -1 /* only part of a token */ | | | | ------------------ | | | | 137| 6| } \ | | | | 138| 66.7k| } | | ------------------ ------------------ 731| 66.7k| switch (BYTE_TYPE(enc, ptr)) { ------------------ | | 233| 66.7k|#define BYTE_TYPE(enc, p) SB_BYTE_TYPE(enc, p) | | ------------------ | | | | 231| 66.7k| (((const struct normal_encoding *)(enc))->type[(unsigned char)*(p)]) | | ------------------ ------------------ 732| 49.9k| CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr) ------------------ | | 110| 54.6k| case BT_NONASCII: \ | | ------------------ | | | Branch (110:3): [True: 0, False: 66.7k] | | ------------------ | | 111| 54.6k| if (! IS_NMSTRT_CHAR_MINBPC(enc, ptr)) { \ | | ------------------ | | | | 243| 0|#define IS_NMSTRT_CHAR_MINBPC(enc, p) (0) | | ------------------ | | | Branch (111:9): [True: 0, Folded] | | ------------------ | | 112| 0| *nextTokPtr = ptr; \ | | 113| 0| return XML_TOK_INVALID; \ | | ------------------ | | | | 57| 0|# define XML_TOK_INVALID 0 | | ------------------ | | 114| 0| } \ | | 115| 54.6k| EXPAT_FALLTHROUGH; \ | | ------------------ | | | | 47| 0|# define EXPAT_FALLTHROUGH __attribute__((fallthrough)) | | ------------------ | | 116| 47.9k| case BT_NMSTRT: \ | | ------------------ | | | Branch (116:3): [True: 47.9k, False: 18.8k] | | ------------------ | | 117| 54.6k| case BT_HEX: \ | | ------------------ | | | Branch (117:3): [True: 6.69k, False: 60.0k] | | ------------------ | | 118| 54.6k| ptr += MINBPC(enc); \ | | ------------------ | | | | 228| 54.6k|#define MINBPC(enc) 1 | | ------------------ | | 119| 54.6k| break; \ | | 120| 54.6k| CHECK_NMSTRT_CASE(2, enc, ptr, end, nextTokPtr) \ | | ------------------ | | | | 99| 691| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (99:3): [True: 691, False: 66.0k] | | | | ------------------ | | | | 100| 691| if ((end) - (ptr) < (n)) \ | | | | ------------------ | | | | | Branch (100:9): [True: 0, False: 691] | | | | ------------------ | | | | 101| 680| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 0|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 102| 691| if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NMSTRT_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 240| 1.38k| (AS_NORMAL_ENCODING(enc)->isInvalid##n(enc, p)) | | | | | | ------------------ | | | | | | | | 207| 691|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | | | ------------------ | | | | | | | Branch (240:3): [True: 9, False: 682] | | | | | | ------------------ | | | | ------------------ | | | | if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NMSTRT_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 238| 682|#define IS_NMSTRT_CHAR(enc, p, n) (AS_NORMAL_ENCODING(enc)->isNmstrt##n(enc, p)) | | | | | | ------------------ | | | | | | | | 207| 682|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (102:41): [True: 2, False: 680] | | | | ------------------ | | | | 103| 11| *nextTokPtr = ptr; \ | | | | 104| 11| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 11|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 105| 11| } \ | | | | 106| 691| ptr += n; \ | | | | 107| 680| break; | | ------------------ | | 121| 680| CHECK_NMSTRT_CASE(3, enc, ptr, end, nextTokPtr) \ | | ------------------ | | | | 99| 296| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (99:3): [True: 296, False: 66.4k] | | | | ------------------ | | | | 100| 296| if ((end) - (ptr) < (n)) \ | | | | ------------------ | | | | | Branch (100:9): [True: 0, False: 296] | | | | ------------------ | | | | 101| 286| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 0|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 102| 296| if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NMSTRT_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 240| 592| (AS_NORMAL_ENCODING(enc)->isInvalid##n(enc, p)) | | | | | | ------------------ | | | | | | | | 207| 296|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | | | ------------------ | | | | | | | Branch (240:3): [True: 9, False: 287] | | | | | | ------------------ | | | | ------------------ | | | | if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NMSTRT_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 238| 287|#define IS_NMSTRT_CHAR(enc, p, n) (AS_NORMAL_ENCODING(enc)->isNmstrt##n(enc, p)) | | | | | | ------------------ | | | | | | | | 207| 287|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (102:41): [True: 1, False: 286] | | | | ------------------ | | | | 103| 10| *nextTokPtr = ptr; \ | | | | 104| 10| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 10|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 105| 10| } \ | | | | 106| 296| ptr += n; \ | | | | 107| 286| break; | | ------------------ | | 122| 286| CHECK_NMSTRT_CASE(4, enc, ptr, end, nextTokPtr) | | ------------------ | | | | 99| 3| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (99:3): [True: 3, False: 66.7k] | | | | ------------------ | | | | 100| 3| if ((end) - (ptr) < (n)) \ | | | | ------------------ | | | | | Branch (100:9): [True: 1, False: 2] | | | | ------------------ | | | | 101| 1| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 1|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 102| 2| if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NMSTRT_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 240| 4| (AS_NORMAL_ENCODING(enc)->isInvalid##n(enc, p)) | | | | | | ------------------ | | | | | | | | 207| 2|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | | | ------------------ | | | | | | | Branch (240:3): [True: 1, False: 1] | | | | | | ------------------ | | | | ------------------ | | | | if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NMSTRT_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 238| 1|#define IS_NMSTRT_CHAR(enc, p, n) (AS_NORMAL_ENCODING(enc)->isNmstrt##n(enc, p)) | | | | | | ------------------ | | | | | | | | 207| 1|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (102:41): [True: 1, False: 0] | | | | ------------------ | | | | 103| 2| *nextTokPtr = ptr; \ | | | | 104| 2| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 2|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 105| 2| } \ | | | | 106| 2| ptr += n; \ | | | | 107| 0| break; | | ------------------ ------------------ 733| 1.55k| case BT_EXCL: ------------------ | Branch (733:3): [True: 1.55k, False: 65.2k] ------------------ 734| 1.55k| ptr += MINBPC(enc); ------------------ | | 228| 1.55k|#define MINBPC(enc) 1 ------------------ 735| 1.55k| REQUIRE_CHAR(enc, ptr, end); ------------------ | | 140| 1.55k|# define REQUIRE_CHAR(enc, ptr, end) REQUIRE_CHARS(enc, ptr, end, 1) | | ------------------ | | | | 134| 1.55k| { \ | | | | 135| 1.55k| if (! HAS_CHARS(enc, ptr, end, count)) { \ | | | | ------------------ | | | | | | 129| 1.55k| ((end) - (ptr) >= ((count) * MINBPC(enc))) | | | | | | ------------------ | | | | | | | | 228| 1.55k|#define MINBPC(enc) 1 | | | | | | ------------------ | | | | ------------------ | | | | | Branch (135:11): [True: 1, False: 1.54k] | | | | ------------------ | | | | 136| 1| return XML_TOK_PARTIAL; \ | | | | ------------------ | | | | | | 56| 1|# define XML_TOK_PARTIAL -1 /* only part of a token */ | | | | ------------------ | | | | 137| 1| } \ | | | | 138| 1.55k| } | | ------------------ ------------------ 736| 1.54k| switch (BYTE_TYPE(enc, ptr)) { ------------------ | | 233| 1.54k|#define BYTE_TYPE(enc, p) SB_BYTE_TYPE(enc, p) | | ------------------ | | | | 231| 1.54k| (((const struct normal_encoding *)(enc))->type[(unsigned char)*(p)]) | | | | ------------------ | | | | | Branch (231:3): [True: 1.54k, False: 2] | | | | ------------------ | | ------------------ ------------------ 737| 455| case BT_MINUS: ------------------ | Branch (737:5): [True: 455, False: 1.09k] ------------------ 738| 455| return PREFIX(scanComment)(enc, ptr + MINBPC(enc), end, nextTokPtr); ------------------ | | 248| 455|#define PREFIX(ident) normal_##ident ------------------ return PREFIX(scanComment)(enc, ptr + MINBPC(enc), end, nextTokPtr); ------------------ | | 228| 455|#define MINBPC(enc) 1 ------------------ 739| 1.09k| case BT_LSQB: ------------------ | Branch (739:5): [True: 1.09k, False: 457] ------------------ 740| 1.09k| return PREFIX(scanCdataSection)(enc, ptr + MINBPC(enc), end, nextTokPtr); ------------------ | | 248| 1.09k|#define PREFIX(ident) normal_##ident ------------------ return PREFIX(scanCdataSection)(enc, ptr + MINBPC(enc), end, nextTokPtr); ------------------ | | 228| 1.09k|#define MINBPC(enc) 1 ------------------ 741| 1.54k| } 742| 2| *nextTokPtr = ptr; 743| 2| return XML_TOK_INVALID; ------------------ | | 57| 2|# define XML_TOK_INVALID 0 ------------------ 744| 3.13k| case BT_QUEST: ------------------ | Branch (744:3): [True: 3.13k, False: 63.6k] ------------------ 745| 3.13k| return PREFIX(scanPi)(enc, ptr + MINBPC(enc), end, nextTokPtr); ------------------ | | 248| 3.13k|#define PREFIX(ident) normal_##ident ------------------ return PREFIX(scanPi)(enc, ptr + MINBPC(enc), end, nextTokPtr); ------------------ | | 228| 3.13k|#define MINBPC(enc) 1 ------------------ 746| 6.43k| case BT_SOL: ------------------ | Branch (746:3): [True: 6.43k, False: 60.3k] ------------------ 747| 6.43k| return PREFIX(scanEndTag)(enc, ptr + MINBPC(enc), end, nextTokPtr); ------------------ | | 248| 6.43k|#define PREFIX(ident) normal_##ident ------------------ return PREFIX(scanEndTag)(enc, ptr + MINBPC(enc), end, nextTokPtr); ------------------ | | 228| 6.43k|#define MINBPC(enc) 1 ------------------ 748| 7| default: ------------------ | Branch (748:3): [True: 7, False: 66.7k] ------------------ 749| 7| *nextTokPtr = ptr; 750| 7| return XML_TOK_INVALID; ------------------ | | 57| 7|# define XML_TOK_INVALID 0 ------------------ 751| 66.7k| } 752| 55.6k|# ifdef XML_NS 753| 55.6k| hadColon = 0; 754| 55.6k|# endif 755| | /* we have a start-tag */ 756| 115k| while (HAS_CHAR(enc, ptr, end)) { 757| 115k| switch (BYTE_TYPE(enc, ptr)) { ------------------ | | 233| 115k|#define BYTE_TYPE(enc, p) SB_BYTE_TYPE(enc, p) | | ------------------ | | | | 231| 115k| (((const struct normal_encoding *)(enc))->type[(unsigned char)*(p)]) | | ------------------ ------------------ 758| 167k| CHECK_NAME_CASES(enc, ptr, end, nextTokPtr) ------------------ | | 81| 33.5k| case BT_NONASCII: \ | | ------------------ | | | Branch (81:3): [True: 0, False: 115k] | | ------------------ | | 82| 33.5k| if (! IS_NAME_CHAR_MINBPC(enc, ptr)) { \ | | ------------------ | | | | 242| 0|#define IS_NAME_CHAR_MINBPC(enc, p) (0) | | ------------------ | | | Branch (82:9): [True: 0, Folded] | | ------------------ | | 83| 0| *nextTokPtr = ptr; \ | | 84| 0| return XML_TOK_INVALID; \ | | ------------------ | | | | 57| 0|# define XML_TOK_INVALID 0 | | ------------------ | | 85| 0| } \ | | 86| 33.5k| EXPAT_FALLTHROUGH; \ | | ------------------ | | | | 47| 0|# define EXPAT_FALLTHROUGH __attribute__((fallthrough)) | | ------------------ | | 87| 22.5k| case BT_NMSTRT: \ | | ------------------ | | | Branch (87:3): [True: 22.5k, False: 93.2k] | | ------------------ | | 88| 29.6k| case BT_HEX: \ | | ------------------ | | | Branch (88:3): [True: 7.02k, False: 108k] | | ------------------ | | 89| 32.2k| case BT_DIGIT: \ | | ------------------ | | | Branch (89:3): [True: 2.59k, False: 113k] | | ------------------ | | 90| 32.9k| case BT_NAME: \ | | ------------------ | | | Branch (90:3): [True: 716, False: 115k] | | ------------------ | | 91| 33.5k| case BT_MINUS: \ | | ------------------ | | | Branch (91:3): [True: 672, False: 115k] | | ------------------ | | 92| 33.5k| ptr += MINBPC(enc); \ | | ------------------ | | | | 228| 33.5k|#define MINBPC(enc) 1 | | ------------------ | | 93| 33.5k| break; \ | | 94| 33.5k| CHECK_NAME_CASE(2, enc, ptr, end, nextTokPtr) \ | | ------------------ | | | | 70| 24.9k| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (70:3): [True: 24.9k, False: 90.8k] | | | | ------------------ | | | | 71| 24.9k| if (end - ptr < n) \ | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 24.9k] | | | | ------------------ | | | | 72| 24.9k| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 0|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 73| 24.9k| if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NAME_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 240| 49.9k| (AS_NORMAL_ENCODING(enc)->isInvalid##n(enc, p)) | | | | | | ------------------ | | | | | | | | 207| 24.9k|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | | | ------------------ | | | | | | | Branch (240:3): [True: 9, False: 24.9k] | | | | | | ------------------ | | | | ------------------ | | | | if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NAME_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 237| 24.9k|#define IS_NAME_CHAR(enc, p, n) (AS_NORMAL_ENCODING(enc)->isName##n(enc, p)) | | | | | | ------------------ | | | | | | | | 207| 24.9k|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (73:41): [True: 1, False: 24.9k] | | | | ------------------ | | | | 74| 10| *nextTokPtr = ptr; \ | | | | 75| 10| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 10|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 76| 10| } \ | | | | 77| 24.9k| ptr += n; \ | | | | 78| 24.9k| break; | | ------------------ | | 95| 24.9k| CHECK_NAME_CASE(3, enc, ptr, end, nextTokPtr) \ | | ------------------ | | | | 70| 275| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (70:3): [True: 275, False: 115k] | | | | ------------------ | | | | 71| 275| if (end - ptr < n) \ | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 275] | | | | ------------------ | | | | 72| 266| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 0|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 73| 275| if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NAME_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 240| 550| (AS_NORMAL_ENCODING(enc)->isInvalid##n(enc, p)) | | | | | | ------------------ | | | | | | | | 207| 275|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | | | ------------------ | | | | | | | Branch (240:3): [True: 8, False: 267] | | | | | | ------------------ | | | | ------------------ | | | | if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NAME_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 237| 267|#define IS_NAME_CHAR(enc, p, n) (AS_NORMAL_ENCODING(enc)->isName##n(enc, p)) | | | | | | ------------------ | | | | | | | | 207| 267|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (73:41): [True: 1, False: 266] | | | | ------------------ | | | | 74| 9| *nextTokPtr = ptr; \ | | | | 75| 9| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 9|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 76| 9| } \ | | | | 77| 275| ptr += n; \ | | | | 78| 266| break; | | ------------------ | | 96| 266| CHECK_NAME_CASE(4, enc, ptr, end, nextTokPtr) | | ------------------ | | | | 70| 12| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (70:3): [True: 12, False: 115k] | | | | ------------------ | | | | 71| 12| if (end - ptr < n) \ | | | | ------------------ | | | | | Branch (71:9): [True: 1, False: 11] | | | | ------------------ | | | | 72| 1| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 1|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 73| 11| if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NAME_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 240| 22| (AS_NORMAL_ENCODING(enc)->isInvalid##n(enc, p)) | | | | | | ------------------ | | | | | | | | 207| 11|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | | | ------------------ | | | | | | | Branch (240:3): [True: 10, False: 1] | | | | | | ------------------ | | | | ------------------ | | | | if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NAME_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 237| 1|#define IS_NAME_CHAR(enc, p, n) (AS_NORMAL_ENCODING(enc)->isName##n(enc, p)) | | | | | | ------------------ | | | | | | | | 207| 1|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (73:41): [True: 1, False: 0] | | | | ------------------ | | | | 74| 11| *nextTokPtr = ptr; \ | | | | 75| 11| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 11|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 76| 11| } \ | | | | 77| 11| ptr += n; \ | | | | 78| 0| break; | | ------------------ ------------------ 759| 0|# ifdef XML_NS 760| 1.44k| case BT_COLON: ------------------ | Branch (760:5): [True: 1.44k, False: 114k] ------------------ 761| 1.44k| if (hadColon) { ------------------ | Branch (761:11): [True: 3, False: 1.44k] ------------------ 762| 3| *nextTokPtr = ptr; 763| 3| return XML_TOK_INVALID; ------------------ | | 57| 3|# define XML_TOK_INVALID 0 ------------------ 764| 3| } 765| 1.44k| hadColon = 1; 766| 1.44k| ptr += MINBPC(enc); ------------------ | | 228| 1.44k|#define MINBPC(enc) 1 ------------------ 767| 1.44k| REQUIRE_CHAR(enc, ptr, end); ------------------ | | 140| 1.44k|# define REQUIRE_CHAR(enc, ptr, end) REQUIRE_CHARS(enc, ptr, end, 1) | | ------------------ | | | | 134| 1.44k| { \ | | | | 135| 1.44k| if (! HAS_CHARS(enc, ptr, end, count)) { \ | | | | ------------------ | | | | | | 129| 1.44k| ((end) - (ptr) >= ((count) * MINBPC(enc))) | | | | | | ------------------ | | | | | | | | 228| 1.44k|#define MINBPC(enc) 1 | | | | | | ------------------ | | | | ------------------ | | | | | Branch (135:11): [True: 1, False: 1.43k] | | | | ------------------ | | | | 136| 1| return XML_TOK_PARTIAL; \ | | | | ------------------ | | | | | | 56| 1|# define XML_TOK_PARTIAL -1 /* only part of a token */ | | | | ------------------ | | | | 137| 1| } \ | | | | 138| 1.44k| } | | ------------------ ------------------ 768| 1.43k| switch (BYTE_TYPE(enc, ptr)) { ------------------ | | 233| 1.43k|#define BYTE_TYPE(enc, p) SB_BYTE_TYPE(enc, p) | | ------------------ | | | | 231| 1.43k| (((const struct normal_encoding *)(enc))->type[(unsigned char)*(p)]) | | ------------------ ------------------ 769| 1.52k| CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr) ------------------ | | 110| 888| case BT_NONASCII: \ | | ------------------ | | | Branch (110:3): [True: 0, False: 1.43k] | | ------------------ | | 111| 888| if (! IS_NMSTRT_CHAR_MINBPC(enc, ptr)) { \ | | ------------------ | | | | 243| 0|#define IS_NMSTRT_CHAR_MINBPC(enc, p) (0) | | ------------------ | | | Branch (111:9): [True: 0, Folded] | | ------------------ | | 112| 0| *nextTokPtr = ptr; \ | | 113| 0| return XML_TOK_INVALID; \ | | ------------------ | | | | 57| 0|# define XML_TOK_INVALID 0 | | ------------------ | | 114| 0| } \ | | 115| 888| EXPAT_FALLTHROUGH; \ | | ------------------ | | | | 47| 0|# define EXPAT_FALLTHROUGH __attribute__((fallthrough)) | | ------------------ | | 116| 438| case BT_NMSTRT: \ | | ------------------ | | | Branch (116:3): [True: 438, False: 1.00k] | | ------------------ | | 117| 888| case BT_HEX: \ | | ------------------ | | | Branch (117:3): [True: 450, False: 989] | | ------------------ | | 118| 888| ptr += MINBPC(enc); \ | | ------------------ | | | | 228| 888|#define MINBPC(enc) 1 | | ------------------ | | 119| 888| break; \ | | 120| 888| CHECK_NMSTRT_CASE(2, enc, ptr, end, nextTokPtr) \ | | ------------------ | | | | 99| 332| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (99:3): [True: 332, False: 1.10k] | | | | ------------------ | | | | 100| 332| if ((end) - (ptr) < (n)) \ | | | | ------------------ | | | | | Branch (100:9): [True: 0, False: 332] | | | | ------------------ | | | | 101| 322| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 0|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 102| 332| if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NMSTRT_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 240| 664| (AS_NORMAL_ENCODING(enc)->isInvalid##n(enc, p)) | | | | | | ------------------ | | | | | | | | 207| 332|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | | | ------------------ | | | | | | | Branch (240:3): [True: 9, False: 323] | | | | | | ------------------ | | | | ------------------ | | | | if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NMSTRT_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 238| 323|#define IS_NMSTRT_CHAR(enc, p, n) (AS_NORMAL_ENCODING(enc)->isNmstrt##n(enc, p)) | | | | | | ------------------ | | | | | | | | 207| 323|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (102:41): [True: 1, False: 322] | | | | ------------------ | | | | 103| 10| *nextTokPtr = ptr; \ | | | | 104| 10| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 10|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 105| 10| } \ | | | | 106| 332| ptr += n; \ | | | | 107| 322| break; | | ------------------ | | 121| 322| CHECK_NMSTRT_CASE(3, enc, ptr, end, nextTokPtr) \ | | ------------------ | | | | 99| 203| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (99:3): [True: 203, False: 1.23k] | | | | ------------------ | | | | 100| 203| if ((end) - (ptr) < (n)) \ | | | | ------------------ | | | | | Branch (100:9): [True: 0, False: 203] | | | | ------------------ | | | | 101| 194| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 0|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 102| 203| if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NMSTRT_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 240| 406| (AS_NORMAL_ENCODING(enc)->isInvalid##n(enc, p)) | | | | | | ------------------ | | | | | | | | 207| 203|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | | | ------------------ | | | | | | | Branch (240:3): [True: 8, False: 195] | | | | | | ------------------ | | | | ------------------ | | | | if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NMSTRT_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 238| 195|#define IS_NMSTRT_CHAR(enc, p, n) (AS_NORMAL_ENCODING(enc)->isNmstrt##n(enc, p)) | | | | | | ------------------ | | | | | | | | 207| 195|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (102:41): [True: 1, False: 194] | | | | ------------------ | | | | 103| 9| *nextTokPtr = ptr; \ | | | | 104| 9| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 9|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 105| 9| } \ | | | | 106| 203| ptr += n; \ | | | | 107| 194| break; | | ------------------ | | 122| 194| CHECK_NMSTRT_CASE(4, enc, ptr, end, nextTokPtr) | | ------------------ | | | | 99| 11| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (99:3): [True: 11, False: 1.42k] | | | | ------------------ | | | | 100| 11| if ((end) - (ptr) < (n)) \ | | | | ------------------ | | | | | Branch (100:9): [True: 1, False: 10] | | | | ------------------ | | | | 101| 1| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 1|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 102| 10| if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NMSTRT_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 240| 20| (AS_NORMAL_ENCODING(enc)->isInvalid##n(enc, p)) | | | | | | ------------------ | | | | | | | | 207| 10|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | | | ------------------ | | | | | | | Branch (240:3): [True: 9, False: 1] | | | | | | ------------------ | | | | ------------------ | | | | if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NMSTRT_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 238| 1|#define IS_NMSTRT_CHAR(enc, p, n) (AS_NORMAL_ENCODING(enc)->isNmstrt##n(enc, p)) | | | | | | ------------------ | | | | | | | | 207| 1|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (102:41): [True: 1, False: 0] | | | | ------------------ | | | | 103| 10| *nextTokPtr = ptr; \ | | | | 104| 10| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 10|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 105| 10| } \ | | | | 106| 10| ptr += n; \ | | | | 107| 0| break; | | ------------------ ------------------ 770| 5| default: ------------------ | Branch (770:7): [True: 5, False: 1.43k] ------------------ 771| 5| *nextTokPtr = ptr; 772| 5| return XML_TOK_INVALID; ------------------ | | 57| 5|# define XML_TOK_INVALID 0 ------------------ 773| 1.43k| } 774| 1.40k| break; 775| 1.40k|# endif 776| 27.7k| case BT_S: ------------------ | Branch (776:5): [True: 27.7k, False: 88.0k] ------------------ 777| 28.0k| case BT_CR: ------------------ | Branch (777:5): [True: 219, False: 115k] ------------------ 778| 28.2k| case BT_LF: { ------------------ | Branch (778:5): [True: 209, False: 115k] ------------------ 779| 28.2k| ptr += MINBPC(enc); ------------------ | | 228| 28.2k|#define MINBPC(enc) 1 ------------------ 780| 29.0k| while (HAS_CHAR(enc, ptr, end)) { 781| 29.0k| switch (BYTE_TYPE(enc, ptr)) { ------------------ | | 233| 29.0k|#define BYTE_TYPE(enc, p) SB_BYTE_TYPE(enc, p) | | ------------------ | | | | 231| 29.0k| (((const struct normal_encoding *)(enc))->type[(unsigned char)*(p)]) | | ------------------ ------------------ 782| 24.8k| CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr) ------------------ | | 110| 26.8k| case BT_NONASCII: \ | | ------------------ | | | Branch (110:3): [True: 0, False: 29.0k] | | ------------------ | | 111| 26.8k| if (! IS_NMSTRT_CHAR_MINBPC(enc, ptr)) { \ | | ------------------ | | | | 243| 0|#define IS_NMSTRT_CHAR_MINBPC(enc, p) (0) | | ------------------ | | | Branch (111:9): [True: 0, Folded] | | ------------------ | | 112| 0| *nextTokPtr = ptr; \ | | 113| 0| return XML_TOK_INVALID; \ | | ------------------ | | | | 57| 0|# define XML_TOK_INVALID 0 | | ------------------ | | 114| 0| } \ | | 115| 26.8k| EXPAT_FALLTHROUGH; \ | | ------------------ | | | | 47| 0|# define EXPAT_FALLTHROUGH __attribute__((fallthrough)) | | ------------------ | | 116| 23.7k| case BT_NMSTRT: \ | | ------------------ | | | Branch (116:3): [True: 23.7k, False: 5.36k] | | ------------------ | | 117| 26.8k| case BT_HEX: \ | | ------------------ | | | Branch (117:3): [True: 3.10k, False: 25.9k] | | ------------------ | | 118| 26.8k| ptr += MINBPC(enc); \ | | ------------------ | | | | 228| 26.8k|#define MINBPC(enc) 1 | | ------------------ | | 119| 26.8k| break; \ | | 120| 26.8k| CHECK_NMSTRT_CASE(2, enc, ptr, end, nextTokPtr) \ | | ------------------ | | | | 99| 362| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (99:3): [True: 362, False: 28.7k] | | | | ------------------ | | | | 100| 362| if ((end) - (ptr) < (n)) \ | | | | ------------------ | | | | | Branch (100:9): [True: 0, False: 362] | | | | ------------------ | | | | 101| 351| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 0|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 102| 362| if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NMSTRT_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 240| 724| (AS_NORMAL_ENCODING(enc)->isInvalid##n(enc, p)) | | | | | | ------------------ | | | | | | | | 207| 362|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | | | ------------------ | | | | | | | Branch (240:3): [True: 10, False: 352] | | | | | | ------------------ | | | | ------------------ | | | | if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NMSTRT_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 238| 352|#define IS_NMSTRT_CHAR(enc, p, n) (AS_NORMAL_ENCODING(enc)->isNmstrt##n(enc, p)) | | | | | | ------------------ | | | | | | | | 207| 352|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (102:41): [True: 1, False: 351] | | | | ------------------ | | | | 103| 11| *nextTokPtr = ptr; \ | | | | 104| 11| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 11|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 105| 11| } \ | | | | 106| 362| ptr += n; \ | | | | 107| 351| break; | | ------------------ | | 121| 351| CHECK_NMSTRT_CASE(3, enc, ptr, end, nextTokPtr) \ | | ------------------ | | | | 99| 200| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (99:3): [True: 200, False: 28.8k] | | | | ------------------ | | | | 100| 200| if ((end) - (ptr) < (n)) \ | | | | ------------------ | | | | | Branch (100:9): [True: 0, False: 200] | | | | ------------------ | | | | 101| 198| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 0|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 102| 200| if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NMSTRT_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 240| 400| (AS_NORMAL_ENCODING(enc)->isInvalid##n(enc, p)) | | | | | | ------------------ | | | | | | | | 207| 200|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | | | ------------------ | | | | | | | Branch (240:3): [True: 1, False: 199] | | | | | | ------------------ | | | | ------------------ | | | | if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NMSTRT_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 238| 199|#define IS_NMSTRT_CHAR(enc, p, n) (AS_NORMAL_ENCODING(enc)->isNmstrt##n(enc, p)) | | | | | | ------------------ | | | | | | | | 207| 199|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (102:41): [True: 1, False: 198] | | | | ------------------ | | | | 103| 2| *nextTokPtr = ptr; \ | | | | 104| 2| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 2|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 105| 2| } \ | | | | 106| 200| ptr += n; \ | | | | 107| 198| break; | | ------------------ | | 122| 198| CHECK_NMSTRT_CASE(4, enc, ptr, end, nextTokPtr) | | ------------------ | | | | 99| 13| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (99:3): [True: 13, False: 29.0k] | | | | ------------------ | | | | 100| 13| if ((end) - (ptr) < (n)) \ | | | | ------------------ | | | | | Branch (100:9): [True: 1, False: 12] | | | | ------------------ | | | | 101| 1| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 1|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 102| 12| if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NMSTRT_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 240| 24| (AS_NORMAL_ENCODING(enc)->isInvalid##n(enc, p)) | | | | | | ------------------ | | | | | | | | 207| 12|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | | | ------------------ | | | | | | | Branch (240:3): [True: 11, False: 1] | | | | | | ------------------ | | | | ------------------ | | | | if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NMSTRT_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 238| 1|#define IS_NMSTRT_CHAR(enc, p, n) (AS_NORMAL_ENCODING(enc)->isNmstrt##n(enc, p)) | | | | | | ------------------ | | | | | | | | 207| 1|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (102:41): [True: 1, False: 0] | | | | ------------------ | | | | 103| 12| *nextTokPtr = ptr; \ | | | | 104| 12| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 12|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 105| 12| } \ | | | | 106| 12| ptr += n; \ | | | | 107| 0| break; | | ------------------ ------------------ 783| 437| case BT_GT: ------------------ | Branch (783:9): [True: 437, False: 28.6k] ------------------ 784| 437| goto gt; 785| 375| case BT_SOL: ------------------ | Branch (785:9): [True: 375, False: 28.7k] ------------------ 786| 375| goto sol; 787| 244| case BT_S: ------------------ | Branch (787:9): [True: 244, False: 28.8k] ------------------ 788| 497| case BT_CR: ------------------ | Branch (788:9): [True: 253, False: 28.8k] ------------------ 789| 874| case BT_LF: ------------------ | Branch (789:9): [True: 377, False: 28.7k] ------------------ 790| 874| ptr += MINBPC(enc); ------------------ | | 228| 874|#define MINBPC(enc) 1 ------------------ 791| 874| continue; 792| 2| default: ------------------ | Branch (792:9): [True: 2, False: 29.0k] ------------------ 793| 2| *nextTokPtr = ptr; 794| 2| return XML_TOK_INVALID; ------------------ | | 57| 2|# define XML_TOK_INVALID 0 ------------------ 795| 29.0k| } 796| 27.3k| return PREFIX(scanAtts)(enc, ptr, end, nextTokPtr); ------------------ | | 248| 27.3k|#define PREFIX(ident) normal_##ident ------------------ 797| 29.0k| } 798| 2| return XML_TOK_PARTIAL; ------------------ | | 56| 2|# define XML_TOK_PARTIAL -1 /* only part of a token */ ------------------ 799| 28.2k| } 800| 23.9k| case BT_GT: ------------------ | Branch (800:5): [True: 23.9k, False: 91.9k] ------------------ 801| 24.3k| gt: 802| 24.3k| *nextTokPtr = ptr + MINBPC(enc); ------------------ | | 228| 24.3k|#define MINBPC(enc) 1 ------------------ 803| 24.3k| return XML_TOK_START_TAG_NO_ATTS; ------------------ | | 63| 24.3k|# define XML_TOK_START_TAG_NO_ATTS 2 ------------------ 804| 3.40k| case BT_SOL: ------------------ | Branch (804:5): [True: 3.40k, False: 112k] ------------------ 805| 3.77k| sol: 806| 3.77k| ptr += MINBPC(enc); ------------------ | | 228| 3.77k|#define MINBPC(enc) 1 ------------------ 807| 3.77k| REQUIRE_CHAR(enc, ptr, end); ------------------ | | 140| 3.77k|# define REQUIRE_CHAR(enc, ptr, end) REQUIRE_CHARS(enc, ptr, end, 1) | | ------------------ | | | | 134| 3.77k| { \ | | | | 135| 3.77k| if (! HAS_CHARS(enc, ptr, end, count)) { \ | | | | ------------------ | | | | | | 129| 3.77k| ((end) - (ptr) >= ((count) * MINBPC(enc))) | | | | | | ------------------ | | | | | | | | 228| 3.77k|#define MINBPC(enc) 1 | | | | | | ------------------ | | | | ------------------ | | | | | Branch (135:11): [True: 1, False: 3.77k] | | | | ------------------ | | | | 136| 1| return XML_TOK_PARTIAL; \ | | | | ------------------ | | | | | | 56| 1|# define XML_TOK_PARTIAL -1 /* only part of a token */ | | | | ------------------ | | | | 137| 1| } \ | | | | 138| 3.77k| } | | ------------------ ------------------ 808| 3.77k| if (! CHAR_MATCHES(enc, ptr, ASCII_GT)) { ------------------ | | 246| 3.77k|#define CHAR_MATCHES(enc, p, c) (*(p) == (c)) ------------------ | Branch (808:11): [True: 5, False: 3.76k] ------------------ 809| 5| *nextTokPtr = ptr; 810| 5| return XML_TOK_INVALID; ------------------ | | 57| 5|# define XML_TOK_INVALID 0 ------------------ 811| 5| } 812| 3.76k| *nextTokPtr = ptr + MINBPC(enc); ------------------ | | 228| 3.76k|#define MINBPC(enc) 1 ------------------ 813| 3.76k| return XML_TOK_EMPTY_ELEMENT_NO_ATTS; ------------------ | | 65| 3.76k|# define XML_TOK_EMPTY_ELEMENT_NO_ATTS 4 ------------------ 814| 16| default: ------------------ | Branch (814:5): [True: 16, False: 115k] ------------------ 815| 16| *nextTokPtr = ptr; 816| 16| return XML_TOK_INVALID; ------------------ | | 57| 16|# define XML_TOK_INVALID 0 ------------------ 817| 115k| } 818| 115k| } 819| 2| return XML_TOK_PARTIAL; ------------------ | | 56| 2|# define XML_TOK_PARTIAL -1 /* only part of a token */ ------------------ 820| 55.6k|} xmltok.c:normal_scanCdataSection: 337| 1.09k| const char **nextTokPtr) { 338| 1.09k| static const char CDATA_LSQB[] 339| 1.09k| = {ASCII_C, ASCII_D, ASCII_A, ASCII_T, ASCII_A, ASCII_LSQB}; ------------------ | | 40| 1.09k|#define ASCII_C 0x43 ------------------ = {ASCII_C, ASCII_D, ASCII_A, ASCII_T, ASCII_A, ASCII_LSQB}; ------------------ | | 41| 1.09k|#define ASCII_D 0x44 ------------------ = {ASCII_C, ASCII_D, ASCII_A, ASCII_T, ASCII_A, ASCII_LSQB}; ------------------ | | 38| 1.09k|#define ASCII_A 0x41 ------------------ = {ASCII_C, ASCII_D, ASCII_A, ASCII_T, ASCII_A, ASCII_LSQB}; ------------------ | | 57| 1.09k|#define ASCII_T 0x54 ------------------ = {ASCII_C, ASCII_D, ASCII_A, ASCII_T, ASCII_A, ASCII_LSQB}; ------------------ | | 38| 1.09k|#define ASCII_A 0x41 ------------------ = {ASCII_C, ASCII_D, ASCII_A, ASCII_T, ASCII_A, ASCII_LSQB}; ------------------ | | 116| 1.09k|#define ASCII_LSQB 0x5B ------------------ 340| 1.09k| int i; 341| 1.09k| UNUSED_P(enc); ------------------ | | 101| 1.09k|# define UNUSED_P(p) (void)p ------------------ 342| | /* CDATA[ */ 343| 1.09k| REQUIRE_CHARS(enc, ptr, end, 6); ------------------ | | 134| 1.09k| { \ | | 135| 1.09k| if (! HAS_CHARS(enc, ptr, end, count)) { \ | | ------------------ | | | | 129| 1.09k| ((end) - (ptr) >= ((count) * MINBPC(enc))) | | | | ------------------ | | | | | | 228| 1.09k|#define MINBPC(enc) 1 | | | | ------------------ | | ------------------ | | | Branch (135:11): [True: 3, False: 1.08k] | | ------------------ | | 136| 3| return XML_TOK_PARTIAL; \ | | ------------------ | | | | 56| 3|# define XML_TOK_PARTIAL -1 /* only part of a token */ | | ------------------ | | 137| 3| } \ | | 138| 1.09k| } ------------------ 344| 7.57k| for (i = 0; i < 6; i++, ptr += MINBPC(enc)) { ------------------ | | 228| 6.49k|#define MINBPC(enc) 1 ------------------ | Branch (344:15): [True: 6.50k, False: 1.07k] ------------------ 345| 6.50k| if (! CHAR_MATCHES(enc, ptr, CDATA_LSQB[i])) { ------------------ | | 246| 6.50k|#define CHAR_MATCHES(enc, p, c) (*(p) == (c)) ------------------ | Branch (345:9): [True: 13, False: 6.49k] ------------------ 346| 13| *nextTokPtr = ptr; 347| 13| return XML_TOK_INVALID; ------------------ | | 57| 13|# define XML_TOK_INVALID 0 ------------------ 348| 13| } 349| 6.50k| } 350| 1.07k| *nextTokPtr = ptr; 351| 1.07k| return XML_TOK_CDATA_SECT_OPEN; ------------------ | | 69| 1.07k|# define XML_TOK_CDATA_SECT_OPEN 8 ------------------ 352| 1.08k|} xmltok.c:normal_scanEndTag: 432| 6.43k| const char **nextTokPtr) { 433| 6.43k| REQUIRE_CHAR(enc, ptr, end); ------------------ | | 140| 6.43k|# define REQUIRE_CHAR(enc, ptr, end) REQUIRE_CHARS(enc, ptr, end, 1) | | ------------------ | | | | 134| 6.43k| { \ | | | | 135| 6.43k| if (! HAS_CHARS(enc, ptr, end, count)) { \ | | | | ------------------ | | | | | | 129| 6.43k| ((end) - (ptr) >= ((count) * MINBPC(enc))) | | | | | | ------------------ | | | | | | | | 228| 6.43k|#define MINBPC(enc) 1 | | | | | | ------------------ | | | | ------------------ | | | | | Branch (135:11): [True: 1, False: 6.43k] | | | | ------------------ | | | | 136| 1| return XML_TOK_PARTIAL; \ | | | | ------------------ | | | | | | 56| 1|# define XML_TOK_PARTIAL -1 /* only part of a token */ | | | | ------------------ | | | | 137| 1| } \ | | | | 138| 6.43k| } | | ------------------ ------------------ 434| 6.43k| switch (BYTE_TYPE(enc, ptr)) { ------------------ | | 233| 6.43k|#define BYTE_TYPE(enc, p) SB_BYTE_TYPE(enc, p) | | ------------------ | | | | 231| 6.43k| (((const struct normal_encoding *)(enc))->type[(unsigned char)*(p)]) | | ------------------ ------------------ 435| 5.32k| CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr) ------------------ | | 110| 4.69k| case BT_NONASCII: \ | | ------------------ | | | Branch (110:3): [True: 0, False: 6.43k] | | ------------------ | | 111| 4.69k| if (! IS_NMSTRT_CHAR_MINBPC(enc, ptr)) { \ | | ------------------ | | | | 243| 0|#define IS_NMSTRT_CHAR_MINBPC(enc, p) (0) | | ------------------ | | | Branch (111:9): [True: 0, Folded] | | ------------------ | | 112| 0| *nextTokPtr = ptr; \ | | 113| 0| return XML_TOK_INVALID; \ | | ------------------ | | | | 57| 0|# define XML_TOK_INVALID 0 | | ------------------ | | 114| 0| } \ | | 115| 4.69k| EXPAT_FALLTHROUGH; \ | | ------------------ | | | | 47| 0|# define EXPAT_FALLTHROUGH __attribute__((fallthrough)) | | ------------------ | | 116| 4.22k| case BT_NMSTRT: \ | | ------------------ | | | Branch (116:3): [True: 4.22k, False: 2.20k] | | ------------------ | | 117| 4.69k| case BT_HEX: \ | | ------------------ | | | Branch (117:3): [True: 465, False: 5.96k] | | ------------------ | | 118| 4.69k| ptr += MINBPC(enc); \ | | ------------------ | | | | 228| 4.69k|#define MINBPC(enc) 1 | | ------------------ | | 119| 4.69k| break; \ | | 120| 4.69k| CHECK_NMSTRT_CASE(2, enc, ptr, end, nextTokPtr) \ | | ------------------ | | | | 99| 476| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (99:3): [True: 476, False: 5.95k] | | | | ------------------ | | | | 100| 476| if ((end) - (ptr) < (n)) \ | | | | ------------------ | | | | | Branch (100:9): [True: 0, False: 476] | | | | ------------------ | | | | 101| 467| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 0|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 102| 476| if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NMSTRT_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 240| 952| (AS_NORMAL_ENCODING(enc)->isInvalid##n(enc, p)) | | | | | | ------------------ | | | | | | | | 207| 476|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | | | ------------------ | | | | | | | Branch (240:3): [True: 8, False: 468] | | | | | | ------------------ | | | | ------------------ | | | | if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NMSTRT_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 238| 468|#define IS_NMSTRT_CHAR(enc, p, n) (AS_NORMAL_ENCODING(enc)->isNmstrt##n(enc, p)) | | | | | | ------------------ | | | | | | | | 207| 468|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (102:41): [True: 1, False: 467] | | | | ------------------ | | | | 103| 9| *nextTokPtr = ptr; \ | | | | 104| 9| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 9|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 105| 9| } \ | | | | 106| 476| ptr += n; \ | | | | 107| 467| break; | | ------------------ | | 121| 467| CHECK_NMSTRT_CASE(3, enc, ptr, end, nextTokPtr) \ | | ------------------ | | | | 99| 68| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (99:3): [True: 68, False: 6.36k] | | | | ------------------ | | | | 100| 68| if ((end) - (ptr) < (n)) \ | | | | ------------------ | | | | | Branch (100:9): [True: 0, False: 68] | | | | ------------------ | | | | 101| 66| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 0|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 102| 68| if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NMSTRT_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 240| 136| (AS_NORMAL_ENCODING(enc)->isInvalid##n(enc, p)) | | | | | | ------------------ | | | | | | | | 207| 68|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | | | ------------------ | | | | | | | Branch (240:3): [True: 1, False: 67] | | | | | | ------------------ | | | | ------------------ | | | | if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NMSTRT_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 238| 67|#define IS_NMSTRT_CHAR(enc, p, n) (AS_NORMAL_ENCODING(enc)->isNmstrt##n(enc, p)) | | | | | | ------------------ | | | | | | | | 207| 67|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (102:41): [True: 1, False: 66] | | | | ------------------ | | | | 103| 2| *nextTokPtr = ptr; \ | | | | 104| 2| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 2|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 105| 2| } \ | | | | 106| 68| ptr += n; \ | | | | 107| 66| break; | | ------------------ | | 122| 66| CHECK_NMSTRT_CASE(4, enc, ptr, end, nextTokPtr) | | ------------------ | | | | 99| 3| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (99:3): [True: 3, False: 6.42k] | | | | ------------------ | | | | 100| 3| if ((end) - (ptr) < (n)) \ | | | | ------------------ | | | | | Branch (100:9): [True: 1, False: 2] | | | | ------------------ | | | | 101| 1| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 1|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 102| 2| if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NMSTRT_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 240| 4| (AS_NORMAL_ENCODING(enc)->isInvalid##n(enc, p)) | | | | | | ------------------ | | | | | | | | 207| 2|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | | | ------------------ | | | | | | | Branch (240:3): [True: 1, False: 1] | | | | | | ------------------ | | | | ------------------ | | | | if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NMSTRT_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 238| 1|#define IS_NMSTRT_CHAR(enc, p, n) (AS_NORMAL_ENCODING(enc)->isNmstrt##n(enc, p)) | | | | | | ------------------ | | | | | | | | 207| 1|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (102:41): [True: 1, False: 0] | | | | ------------------ | | | | 103| 2| *nextTokPtr = ptr; \ | | | | 104| 2| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 2|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 105| 2| } \ | | | | 106| 2| ptr += n; \ | | | | 107| 0| break; | | ------------------ ------------------ 436| 1.19k| default: ------------------ | Branch (436:3): [True: 1.19k, False: 5.24k] ------------------ 437| 1.19k| *nextTokPtr = ptr; 438| 1.19k| return XML_TOK_INVALID; ------------------ | | 57| 1.19k|# define XML_TOK_INVALID 0 ------------------ 439| 6.43k| } 440| 10.0k| while (HAS_CHAR(enc, ptr, end)) { 441| 10.0k| switch (BYTE_TYPE(enc, ptr)) { ------------------ | | 233| 10.0k|#define BYTE_TYPE(enc, p) SB_BYTE_TYPE(enc, p) | | ------------------ | | | | 231| 10.0k| (((const struct normal_encoding *)(enc))->type[(unsigned char)*(p)]) | | ------------------ ------------------ 442| 13.4k| CHECK_NAME_CASES(enc, ptr, end, nextTokPtr) ------------------ | | 81| 4.18k| case BT_NONASCII: \ | | ------------------ | | | Branch (81:3): [True: 0, False: 10.0k] | | ------------------ | | 82| 4.18k| if (! IS_NAME_CHAR_MINBPC(enc, ptr)) { \ | | ------------------ | | | | 242| 0|#define IS_NAME_CHAR_MINBPC(enc, p) (0) | | ------------------ | | | Branch (82:9): [True: 0, Folded] | | ------------------ | | 83| 0| *nextTokPtr = ptr; \ | | 84| 0| return XML_TOK_INVALID; \ | | ------------------ | | | | 57| 0|# define XML_TOK_INVALID 0 | | ------------------ | | 85| 0| } \ | | 86| 4.18k| EXPAT_FALLTHROUGH; \ | | ------------------ | | | | 47| 0|# define EXPAT_FALLTHROUGH __attribute__((fallthrough)) | | ------------------ | | 87| 2.31k| case BT_NMSTRT: \ | | ------------------ | | | Branch (87:3): [True: 2.31k, False: 7.74k] | | ------------------ | | 88| 3.12k| case BT_HEX: \ | | ------------------ | | | Branch (88:3): [True: 812, False: 9.24k] | | ------------------ | | 89| 3.44k| case BT_DIGIT: \ | | ------------------ | | | Branch (89:3): [True: 321, False: 9.73k] | | ------------------ | | 90| 3.92k| case BT_NAME: \ | | ------------------ | | | Branch (90:3): [True: 482, False: 9.57k] | | ------------------ | | 91| 4.18k| case BT_MINUS: \ | | ------------------ | | | Branch (91:3): [True: 261, False: 9.79k] | | ------------------ | | 92| 4.18k| ptr += MINBPC(enc); \ | | ------------------ | | | | 228| 4.18k|#define MINBPC(enc) 1 | | ------------------ | | 93| 4.18k| break; \ | | 94| 4.18k| CHECK_NAME_CASE(2, enc, ptr, end, nextTokPtr) \ | | ------------------ | | | | 70| 236| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (70:3): [True: 236, False: 9.82k] | | | | ------------------ | | | | 71| 236| if (end - ptr < n) \ | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 236] | | | | ------------------ | | | | 72| 226| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 0|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 73| 236| if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NAME_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 240| 472| (AS_NORMAL_ENCODING(enc)->isInvalid##n(enc, p)) | | | | | | ------------------ | | | | | | | | 207| 236|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | | | ------------------ | | | | | | | Branch (240:3): [True: 9, False: 227] | | | | | | ------------------ | | | | ------------------ | | | | if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NAME_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 237| 227|#define IS_NAME_CHAR(enc, p, n) (AS_NORMAL_ENCODING(enc)->isName##n(enc, p)) | | | | | | ------------------ | | | | | | | | 207| 227|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (73:41): [True: 1, False: 226] | | | | ------------------ | | | | 74| 10| *nextTokPtr = ptr; \ | | | | 75| 10| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 10|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 76| 10| } \ | | | | 77| 236| ptr += n; \ | | | | 78| 226| break; | | ------------------ | | 95| 226| CHECK_NAME_CASE(3, enc, ptr, end, nextTokPtr) \ | | ------------------ | | | | 70| 69| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (70:3): [True: 69, False: 9.99k] | | | | ------------------ | | | | 71| 69| if (end - ptr < n) \ | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 69] | | | | ------------------ | | | | 72| 66| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 0|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 73| 69| if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NAME_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 240| 138| (AS_NORMAL_ENCODING(enc)->isInvalid##n(enc, p)) | | | | | | ------------------ | | | | | | | | 207| 69|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | | | ------------------ | | | | | | | Branch (240:3): [True: 2, False: 67] | | | | | | ------------------ | | | | ------------------ | | | | if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NAME_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 237| 67|#define IS_NAME_CHAR(enc, p, n) (AS_NORMAL_ENCODING(enc)->isName##n(enc, p)) | | | | | | ------------------ | | | | | | | | 207| 67|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (73:41): [True: 1, False: 66] | | | | ------------------ | | | | 74| 3| *nextTokPtr = ptr; \ | | | | 75| 3| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 3|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 76| 3| } \ | | | | 77| 69| ptr += n; \ | | | | 78| 66| break; | | ------------------ | | 96| 66| CHECK_NAME_CASE(4, enc, ptr, end, nextTokPtr) | | ------------------ | | | | 70| 6| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (70:3): [True: 6, False: 10.0k] | | | | ------------------ | | | | 71| 6| if (end - ptr < n) \ | | | | ------------------ | | | | | Branch (71:9): [True: 1, False: 5] | | | | ------------------ | | | | 72| 1| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 1|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 73| 5| if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NAME_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 240| 10| (AS_NORMAL_ENCODING(enc)->isInvalid##n(enc, p)) | | | | | | ------------------ | | | | | | | | 207| 5|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | | | ------------------ | | | | | | | Branch (240:3): [True: 4, False: 1] | | | | | | ------------------ | | | | ------------------ | | | | if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NAME_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 237| 1|#define IS_NAME_CHAR(enc, p, n) (AS_NORMAL_ENCODING(enc)->isName##n(enc, p)) | | | | | | ------------------ | | | | | | | | 207| 1|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (73:41): [True: 1, False: 0] | | | | ------------------ | | | | 74| 5| *nextTokPtr = ptr; \ | | | | 75| 5| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 5|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 76| 5| } \ | | | | 77| 5| ptr += n; \ | | | | 78| 0| break; | | ------------------ ------------------ 443| 359| case BT_S: ------------------ | Branch (443:5): [True: 359, False: 9.70k] ------------------ 444| 559| case BT_CR: ------------------ | Branch (444:5): [True: 200, False: 9.85k] ------------------ 445| 756| case BT_LF: ------------------ | Branch (445:5): [True: 197, False: 9.86k] ------------------ 446| 1.33k| for (ptr += MINBPC(enc); HAS_CHAR(enc, ptr, end); ptr += MINBPC(enc)) { ------------------ | | 228| 756|#define MINBPC(enc) 1 ------------------ for (ptr += MINBPC(enc); HAS_CHAR(enc, ptr, end); ptr += MINBPC(enc)) { ------------------ | | 228| 585|#define MINBPC(enc) 1 ------------------ 447| 1.33k| switch (BYTE_TYPE(enc, ptr)) { ------------------ | | 233| 1.33k|#define BYTE_TYPE(enc, p) SB_BYTE_TYPE(enc, p) | | ------------------ | | | | 231| 1.33k| (((const struct normal_encoding *)(enc))->type[(unsigned char)*(p)]) | | ------------------ ------------------ 448| 195| case BT_S: ------------------ | Branch (448:9): [True: 195, False: 1.14k] ------------------ 449| 391| case BT_CR: ------------------ | Branch (449:9): [True: 196, False: 1.14k] ------------------ 450| 585| case BT_LF: ------------------ | Branch (450:9): [True: 194, False: 1.14k] ------------------ 451| 585| break; 452| 700| case BT_GT: ------------------ | Branch (452:9): [True: 700, False: 639] ------------------ 453| 700| *nextTokPtr = ptr + MINBPC(enc); ------------------ | | 228| 700|#define MINBPC(enc) 1 ------------------ 454| 700| return XML_TOK_END_TAG; ------------------ | | 66| 700|# define XML_TOK_END_TAG 5 ------------------ 455| 54| default: ------------------ | Branch (455:9): [True: 54, False: 1.28k] ------------------ 456| 54| *nextTokPtr = ptr; 457| 54| return XML_TOK_INVALID; ------------------ | | 57| 54|# define XML_TOK_INVALID 0 ------------------ 458| 1.33k| } 459| 1.33k| } 460| 2| return XML_TOK_PARTIAL; ------------------ | | 56| 2|# define XML_TOK_PARTIAL -1 /* only part of a token */ ------------------ 461| 0|# ifdef XML_NS 462| 358| case BT_COLON: ------------------ | Branch (462:5): [True: 358, False: 9.70k] ------------------ 463| | /* no need to check qname syntax here, 464| | since end-tag must match exactly */ 465| 358| ptr += MINBPC(enc); ------------------ | | 228| 358|#define MINBPC(enc) 1 ------------------ 466| 358| break; 467| 0|# endif 468| 4.44k| case BT_GT: ------------------ | Branch (468:5): [True: 4.44k, False: 5.61k] ------------------ 469| 4.44k| *nextTokPtr = ptr + MINBPC(enc); ------------------ | | 228| 4.44k|#define MINBPC(enc) 1 ------------------ 470| 4.44k| return XML_TOK_END_TAG; ------------------ | | 66| 4.44k|# define XML_TOK_END_TAG 5 ------------------ 471| 5| default: ------------------ | Branch (471:5): [True: 5, False: 10.0k] ------------------ 472| 5| *nextTokPtr = ptr; 473| 5| return XML_TOK_INVALID; ------------------ | | 57| 5|# define XML_TOK_INVALID 0 ------------------ 474| 10.0k| } 475| 10.0k| } 476| 5| return XML_TOK_PARTIAL; ------------------ | | 56| 5|# define XML_TOK_PARTIAL -1 /* only part of a token */ ------------------ 477| 5.22k|} xmltok.c:normal_scanAtts: 573| 27.3k| const char **nextTokPtr) { 574| 27.3k|# ifdef XML_NS 575| 27.3k| int hadColon = 0; 576| 27.3k|# endif 577| 101k| while (HAS_CHAR(enc, ptr, end)) { 578| 101k| switch (BYTE_TYPE(enc, ptr)) { ------------------ | | 233| 101k|#define BYTE_TYPE(enc, p) SB_BYTE_TYPE(enc, p) | | ------------------ | | | | 231| 101k| (((const struct normal_encoding *)(enc))->type[(unsigned char)*(p)]) | | ------------------ ------------------ 579| 185k| CHECK_NAME_CASES(enc, ptr, end, nextTokPtr) ------------------ | | 81| 47.4k| case BT_NONASCII: \ | | ------------------ | | | Branch (81:3): [True: 0, False: 101k] | | ------------------ | | 82| 47.4k| if (! IS_NAME_CHAR_MINBPC(enc, ptr)) { \ | | ------------------ | | | | 242| 0|#define IS_NAME_CHAR_MINBPC(enc, p) (0) | | ------------------ | | | Branch (82:9): [True: 0, Folded] | | ------------------ | | 83| 0| *nextTokPtr = ptr; \ | | 84| 0| return XML_TOK_INVALID; \ | | ------------------ | | | | 57| 0|# define XML_TOK_INVALID 0 | | ------------------ | | 85| 0| } \ | | 86| 47.4k| EXPAT_FALLTHROUGH; \ | | ------------------ | | | | 47| 0|# define EXPAT_FALLTHROUGH __attribute__((fallthrough)) | | ------------------ | | 87| 44.1k| case BT_NMSTRT: \ | | ------------------ | | | Branch (87:3): [True: 44.1k, False: 57.6k] | | ------------------ | | 88| 46.4k| case BT_HEX: \ | | ------------------ | | | Branch (88:3): [True: 2.32k, False: 99.4k] | | ------------------ | | 89| 46.9k| case BT_DIGIT: \ | | ------------------ | | | Branch (89:3): [True: 537, False: 101k] | | ------------------ | | 90| 47.2k| case BT_NAME: \ | | ------------------ | | | Branch (90:3): [True: 226, False: 101k] | | ------------------ | | 91| 47.4k| case BT_MINUS: \ | | ------------------ | | | Branch (91:3): [True: 247, False: 101k] | | ------------------ | | 92| 47.4k| ptr += MINBPC(enc); \ | | ------------------ | | | | 228| 47.4k|#define MINBPC(enc) 1 | | ------------------ | | 93| 47.4k| break; \ | | 94| 47.4k| CHECK_NAME_CASE(2, enc, ptr, end, nextTokPtr) \ | | ------------------ | | | | 70| 209| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (70:3): [True: 209, False: 101k] | | | | ------------------ | | | | 71| 209| if (end - ptr < n) \ | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 209] | | | | ------------------ | | | | 72| 198| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 0|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 73| 209| if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NAME_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 240| 418| (AS_NORMAL_ENCODING(enc)->isInvalid##n(enc, p)) | | | | | | ------------------ | | | | | | | | 207| 209|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | | | ------------------ | | | | | | | Branch (240:3): [True: 10, False: 199] | | | | | | ------------------ | | | | ------------------ | | | | if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NAME_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 237| 199|#define IS_NAME_CHAR(enc, p, n) (AS_NORMAL_ENCODING(enc)->isName##n(enc, p)) | | | | | | ------------------ | | | | | | | | 207| 199|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (73:41): [True: 1, False: 198] | | | | ------------------ | | | | 74| 11| *nextTokPtr = ptr; \ | | | | 75| 11| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 11|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 76| 11| } \ | | | | 77| 209| ptr += n; \ | | | | 78| 198| break; | | ------------------ | | 95| 200| CHECK_NAME_CASE(3, enc, ptr, end, nextTokPtr) \ | | ------------------ | | | | 70| 200| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (70:3): [True: 200, False: 101k] | | | | ------------------ | | | | 71| 200| if (end - ptr < n) \ | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 200] | | | | ------------------ | | | | 72| 194| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 0|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 73| 200| if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NAME_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 240| 400| (AS_NORMAL_ENCODING(enc)->isInvalid##n(enc, p)) | | | | | | ------------------ | | | | | | | | 207| 200|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | | | ------------------ | | | | | | | Branch (240:3): [True: 5, False: 195] | | | | | | ------------------ | | | | ------------------ | | | | if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NAME_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 237| 195|#define IS_NAME_CHAR(enc, p, n) (AS_NORMAL_ENCODING(enc)->isName##n(enc, p)) | | | | | | ------------------ | | | | | | | | 207| 195|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (73:41): [True: 1, False: 194] | | | | ------------------ | | | | 74| 6| *nextTokPtr = ptr; \ | | | | 75| 6| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 6|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 76| 6| } \ | | | | 77| 200| ptr += n; \ | | | | 78| 194| break; | | ------------------ | | 96| 194| CHECK_NAME_CASE(4, enc, ptr, end, nextTokPtr) | | ------------------ | | | | 70| 11| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (70:3): [True: 11, False: 101k] | | | | ------------------ | | | | 71| 11| if (end - ptr < n) \ | | | | ------------------ | | | | | Branch (71:9): [True: 2, False: 9] | | | | ------------------ | | | | 72| 2| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 2|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 73| 9| if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NAME_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 240| 18| (AS_NORMAL_ENCODING(enc)->isInvalid##n(enc, p)) | | | | | | ------------------ | | | | | | | | 207| 9|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | | | ------------------ | | | | | | | Branch (240:3): [True: 8, False: 1] | | | | | | ------------------ | | | | ------------------ | | | | if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NAME_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 237| 1|#define IS_NAME_CHAR(enc, p, n) (AS_NORMAL_ENCODING(enc)->isName##n(enc, p)) | | | | | | ------------------ | | | | | | | | 207| 1|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (73:41): [True: 1, False: 0] | | | | ------------------ | | | | 74| 9| *nextTokPtr = ptr; \ | | | | 75| 9| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 9|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 76| 9| } \ | | | | 77| 9| ptr += n; \ | | | | 78| 0| break; | | ------------------ ------------------ 580| 0|# ifdef XML_NS 581| 18.7k| case BT_COLON: ------------------ | Branch (581:5): [True: 18.7k, False: 82.9k] ------------------ 582| 18.7k| if (hadColon) { ------------------ | Branch (582:11): [True: 4, False: 18.7k] ------------------ 583| 4| *nextTokPtr = ptr; 584| 4| return XML_TOK_INVALID; ------------------ | | 57| 4|# define XML_TOK_INVALID 0 ------------------ 585| 4| } 586| 18.7k| hadColon = 1; 587| 18.7k| ptr += MINBPC(enc); ------------------ | | 228| 18.7k|#define MINBPC(enc) 1 ------------------ 588| 18.7k| REQUIRE_CHAR(enc, ptr, end); ------------------ | | 140| 18.7k|# define REQUIRE_CHAR(enc, ptr, end) REQUIRE_CHARS(enc, ptr, end, 1) | | ------------------ | | | | 134| 18.7k| { \ | | | | 135| 18.7k| if (! HAS_CHARS(enc, ptr, end, count)) { \ | | | | ------------------ | | | | | | 129| 18.7k| ((end) - (ptr) >= ((count) * MINBPC(enc))) | | | | | | ------------------ | | | | | | | | 228| 18.7k|#define MINBPC(enc) 1 | | | | | | ------------------ | | | | ------------------ | | | | | Branch (135:11): [True: 1, False: 18.7k] | | | | ------------------ | | | | 136| 1| return XML_TOK_PARTIAL; \ | | | | ------------------ | | | | | | 56| 1|# define XML_TOK_PARTIAL -1 /* only part of a token */ | | | | ------------------ | | | | 137| 1| } \ | | | | 138| 18.7k| } | | ------------------ ------------------ 589| 18.7k| switch (BYTE_TYPE(enc, ptr)) { ------------------ | | 233| 18.7k|#define BYTE_TYPE(enc, p) SB_BYTE_TYPE(enc, p) | | ------------------ | | | | 231| 18.7k| (((const struct normal_encoding *)(enc))->type[(unsigned char)*(p)]) | | ------------------ ------------------ 590| 13.9k| CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr) ------------------ | | 110| 18.3k| case BT_NONASCII: \ | | ------------------ | | | Branch (110:3): [True: 0, False: 18.7k] | | ------------------ | | 111| 18.3k| if (! IS_NMSTRT_CHAR_MINBPC(enc, ptr)) { \ | | ------------------ | | | | 243| 0|#define IS_NMSTRT_CHAR_MINBPC(enc, p) (0) | | ------------------ | | | Branch (111:9): [True: 0, Folded] | | ------------------ | | 112| 0| *nextTokPtr = ptr; \ | | 113| 0| return XML_TOK_INVALID; \ | | ------------------ | | | | 57| 0|# define XML_TOK_INVALID 0 | | ------------------ | | 114| 0| } \ | | 115| 18.3k| EXPAT_FALLTHROUGH; \ | | ------------------ | | | | 47| 0|# define EXPAT_FALLTHROUGH __attribute__((fallthrough)) | | ------------------ | | 116| 13.1k| case BT_NMSTRT: \ | | ------------------ | | | Branch (116:3): [True: 13.1k, False: 5.65k] | | ------------------ | | 117| 18.3k| case BT_HEX: \ | | ------------------ | | | Branch (117:3): [True: 5.24k, False: 13.5k] | | ------------------ | | 118| 18.3k| ptr += MINBPC(enc); \ | | ------------------ | | | | 228| 18.3k|#define MINBPC(enc) 1 | | ------------------ | | 119| 18.3k| break; \ | | 120| 18.3k| CHECK_NMSTRT_CASE(2, enc, ptr, end, nextTokPtr) \ | | ------------------ | | | | 99| 206| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (99:3): [True: 206, False: 18.5k] | | | | ------------------ | | | | 100| 206| if ((end) - (ptr) < (n)) \ | | | | ------------------ | | | | | Branch (100:9): [True: 0, False: 206] | | | | ------------------ | | | | 101| 195| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 0|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 102| 206| if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NMSTRT_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 240| 412| (AS_NORMAL_ENCODING(enc)->isInvalid##n(enc, p)) | | | | | | ------------------ | | | | | | | | 207| 206|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | | | ------------------ | | | | | | | Branch (240:3): [True: 10, False: 196] | | | | | | ------------------ | | | | ------------------ | | | | if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NMSTRT_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 238| 196|#define IS_NMSTRT_CHAR(enc, p, n) (AS_NORMAL_ENCODING(enc)->isNmstrt##n(enc, p)) | | | | | | ------------------ | | | | | | | | 207| 196|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (102:41): [True: 1, False: 195] | | | | ------------------ | | | | 103| 11| *nextTokPtr = ptr; \ | | | | 104| 11| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 11|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 105| 11| } \ | | | | 106| 206| ptr += n; \ | | | | 107| 195| break; | | ------------------ | | 121| 201| CHECK_NMSTRT_CASE(3, enc, ptr, end, nextTokPtr) \ | | ------------------ | | | | 99| 201| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (99:3): [True: 201, False: 18.5k] | | | | ------------------ | | | | 100| 201| if ((end) - (ptr) < (n)) \ | | | | ------------------ | | | | | Branch (100:9): [True: 0, False: 201] | | | | ------------------ | | | | 101| 194| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 0|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 102| 201| if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NMSTRT_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 240| 402| (AS_NORMAL_ENCODING(enc)->isInvalid##n(enc, p)) | | | | | | ------------------ | | | | | | | | 207| 201|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | | | ------------------ | | | | | | | Branch (240:3): [True: 6, False: 195] | | | | | | ------------------ | | | | ------------------ | | | | if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NMSTRT_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 238| 195|#define IS_NMSTRT_CHAR(enc, p, n) (AS_NORMAL_ENCODING(enc)->isNmstrt##n(enc, p)) | | | | | | ------------------ | | | | | | | | 207| 195|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (102:41): [True: 1, False: 194] | | | | ------------------ | | | | 103| 7| *nextTokPtr = ptr; \ | | | | 104| 7| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 7|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 105| 7| } \ | | | | 106| 201| ptr += n; \ | | | | 107| 194| break; | | ------------------ | | 122| 194| CHECK_NMSTRT_CASE(4, enc, ptr, end, nextTokPtr) | | ------------------ | | | | 99| 3| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (99:3): [True: 3, False: 18.7k] | | | | ------------------ | | | | 100| 3| if ((end) - (ptr) < (n)) \ | | | | ------------------ | | | | | Branch (100:9): [True: 1, False: 2] | | | | ------------------ | | | | 101| 1| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 1|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 102| 2| if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NMSTRT_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 240| 4| (AS_NORMAL_ENCODING(enc)->isInvalid##n(enc, p)) | | | | | | ------------------ | | | | | | | | 207| 2|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | | | ------------------ | | | | | | | Branch (240:3): [True: 1, False: 1] | | | | | | ------------------ | | | | ------------------ | | | | if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NMSTRT_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 238| 1|#define IS_NMSTRT_CHAR(enc, p, n) (AS_NORMAL_ENCODING(enc)->isNmstrt##n(enc, p)) | | | | | | ------------------ | | | | | | | | 207| 1|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (102:41): [True: 1, False: 0] | | | | ------------------ | | | | 103| 2| *nextTokPtr = ptr; \ | | | | 104| 2| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 2|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 105| 2| } \ | | | | 106| 2| ptr += n; \ | | | | 107| 0| break; | | ------------------ ------------------ 591| 2| default: ------------------ | Branch (591:7): [True: 2, False: 18.7k] ------------------ 592| 2| *nextTokPtr = ptr; 593| 2| return XML_TOK_INVALID; ------------------ | | 57| 2|# define XML_TOK_INVALID 0 ------------------ 594| 18.7k| } 595| 18.7k| break; 596| 18.7k|# endif 597| 18.7k| case BT_S: ------------------ | Branch (597:5): [True: 406, False: 101k] ------------------ 598| 601| case BT_CR: ------------------ | Branch (598:5): [True: 195, False: 101k] ------------------ 599| 795| case BT_LF: ------------------ | Branch (599:5): [True: 194, False: 101k] ------------------ 600| 1.39k| for (;;) { 601| 1.39k| int t; 602| | 603| 1.39k| ptr += MINBPC(enc); ------------------ | | 228| 1.39k|#define MINBPC(enc) 1 ------------------ 604| 1.39k| REQUIRE_CHAR(enc, ptr, end); ------------------ | | 140| 1.39k|# define REQUIRE_CHAR(enc, ptr, end) REQUIRE_CHARS(enc, ptr, end, 1) | | ------------------ | | | | 134| 1.39k| { \ | | | | 135| 1.39k| if (! HAS_CHARS(enc, ptr, end, count)) { \ | | | | ------------------ | | | | | | 129| 1.39k| ((end) - (ptr) >= ((count) * MINBPC(enc))) | | | | | | ------------------ | | | | | | | | 228| 1.39k|#define MINBPC(enc) 1 | | | | | | ------------------ | | | | ------------------ | | | | | Branch (135:11): [True: 3, False: 1.39k] | | | | ------------------ | | | | 136| 3| return XML_TOK_PARTIAL; \ | | | | ------------------ | | | | | | 56| 3|# define XML_TOK_PARTIAL -1 /* only part of a token */ | | | | ------------------ | | | | 137| 3| } \ | | | | 138| 1.39k| } | | ------------------ ------------------ 605| 1.39k| t = BYTE_TYPE(enc, ptr); ------------------ | | 233| 1.39k|#define BYTE_TYPE(enc, p) SB_BYTE_TYPE(enc, p) | | ------------------ | | | | 231| 1.39k| (((const struct normal_encoding *)(enc))->type[(unsigned char)*(p)]) | | ------------------ ------------------ 606| 1.39k| if (t == BT_EQUALS) ------------------ | Branch (606:13): [True: 754, False: 636] ------------------ 607| 754| break; 608| 636| switch (t) { 609| 208| case BT_S: ------------------ | Branch (609:9): [True: 208, False: 428] ------------------ 610| 402| case BT_LF: ------------------ | Branch (610:9): [True: 194, False: 442] ------------------ 611| 598| case BT_CR: ------------------ | Branch (611:9): [True: 196, False: 440] ------------------ 612| 598| break; 613| 38| default: ------------------ | Branch (613:9): [True: 38, False: 598] ------------------ 614| 38| *nextTokPtr = ptr; 615| 38| return XML_TOK_INVALID; ------------------ | | 57| 38|# define XML_TOK_INVALID 0 ------------------ 616| 636| } 617| 636| } 618| 754| EXPAT_FALLTHROUGH; ------------------ | | 47| 754|# define EXPAT_FALLTHROUGH __attribute__((fallthrough)) ------------------ 619| 34.9k| case BT_EQUALS: { ------------------ | Branch (619:5): [True: 34.2k, False: 67.5k] ------------------ 620| 34.9k| int open; 621| 34.9k|# ifdef XML_NS 622| 34.9k| hadColon = 0; 623| 34.9k|# endif 624| 35.6k| for (;;) { 625| 35.6k| ptr += MINBPC(enc); ------------------ | | 228| 35.6k|#define MINBPC(enc) 1 ------------------ 626| 35.6k| REQUIRE_CHAR(enc, ptr, end); ------------------ | | 140| 35.6k|# define REQUIRE_CHAR(enc, ptr, end) REQUIRE_CHARS(enc, ptr, end, 1) | | ------------------ | | | | 134| 35.6k| { \ | | | | 135| 35.6k| if (! HAS_CHARS(enc, ptr, end, count)) { \ | | | | ------------------ | | | | | | 129| 35.6k| ((end) - (ptr) >= ((count) * MINBPC(enc))) | | | | | | ------------------ | | | | | | | | 228| 35.6k|#define MINBPC(enc) 1 | | | | | | ------------------ | | | | ------------------ | | | | | Branch (135:11): [True: 2, False: 35.6k] | | | | ------------------ | | | | 136| 2| return XML_TOK_PARTIAL; \ | | | | ------------------ | | | | | | 56| 2|# define XML_TOK_PARTIAL -1 /* only part of a token */ | | | | ------------------ | | | | 137| 2| } \ | | | | 138| 35.6k| } | | ------------------ ------------------ 627| 35.6k| open = BYTE_TYPE(enc, ptr); ------------------ | | 233| 35.6k|#define BYTE_TYPE(enc, p) SB_BYTE_TYPE(enc, p) | | ------------------ | | | | 231| 35.6k| (((const struct normal_encoding *)(enc))->type[(unsigned char)*(p)]) | | ------------------ ------------------ 628| 35.6k| if (open == BT_QUOT || open == BT_APOS) ------------------ | Branch (628:13): [True: 33.5k, False: 2.06k] | Branch (628:32): [True: 1.37k, False: 693] ------------------ 629| 34.9k| break; 630| 693| switch (open) { 631| 256| case BT_S: ------------------ | Branch (631:9): [True: 256, False: 437] ------------------ 632| 462| case BT_LF: ------------------ | Branch (632:9): [True: 206, False: 487] ------------------ 633| 656| case BT_CR: ------------------ | Branch (633:9): [True: 194, False: 499] ------------------ 634| 656| break; 635| 37| default: ------------------ | Branch (635:9): [True: 37, False: 656] ------------------ 636| 37| *nextTokPtr = ptr; 637| 37| return XML_TOK_INVALID; ------------------ | | 57| 37|# define XML_TOK_INVALID 0 ------------------ 638| 693| } 639| 693| } 640| 34.9k| ptr += MINBPC(enc); ------------------ | | 228| 34.9k|#define MINBPC(enc) 1 ------------------ 641| | /* in attribute value */ 642| 89.0k| for (;;) { 643| 89.0k| int t; 644| 89.0k| REQUIRE_CHAR(enc, ptr, end); ------------------ | | 140| 89.0k|# define REQUIRE_CHAR(enc, ptr, end) REQUIRE_CHARS(enc, ptr, end, 1) | | ------------------ | | | | 134| 89.0k| { \ | | | | 135| 89.0k| if (! HAS_CHARS(enc, ptr, end, count)) { \ | | | | ------------------ | | | | | | 129| 89.0k| ((end) - (ptr) >= ((count) * MINBPC(enc))) | | | | | | ------------------ | | | | | | | | 228| 89.0k|#define MINBPC(enc) 1 | | | | | | ------------------ | | | | ------------------ | | | | | Branch (135:11): [True: 1, False: 89.0k] | | | | ------------------ | | | | 136| 1| return XML_TOK_PARTIAL; \ | | | | ------------------ | | | | | | 56| 1|# define XML_TOK_PARTIAL -1 /* only part of a token */ | | | | ------------------ | | | | 137| 1| } \ | | | | 138| 89.0k| } | | ------------------ ------------------ 645| 89.0k| t = BYTE_TYPE(enc, ptr); ------------------ | | 233| 89.0k|#define BYTE_TYPE(enc, p) SB_BYTE_TYPE(enc, p) | | ------------------ | | | | 231| 89.0k| (((const struct normal_encoding *)(enc))->type[(unsigned char)*(p)]) | | ------------------ ------------------ 646| 89.0k| if (t == open) ------------------ | Branch (646:13): [True: 34.8k, False: 54.1k] ------------------ 647| 34.8k| break; 648| 54.1k| switch (t) { 649| 1.41k| INVALID_CASES(ptr, nextTokPtr) ------------------ | | 60| 279| INVALID_LEAD_CASE(2, ptr, nextTokPtr) \ | | ------------------ | | | | 49| 279| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (49:3): [True: 279, False: 53.9k] | | | | ------------------ | | | | 50| 279| if (end - ptr < n) \ | | | | ------------------ | | | | | Branch (50:9): [True: 0, False: 279] | | | | ------------------ | | | | 51| 269| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 0|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 52| 279| if (IS_INVALID_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 240| 279| (AS_NORMAL_ENCODING(enc)->isInvalid##n(enc, p)) | | | | | | ------------------ | | | | | | | | 207| 279|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | | | ------------------ | | | | | | | Branch (240:3): [True: 10, False: 269] | | | | | | ------------------ | | | | ------------------ | | | | 53| 10| *(nextTokPtr) = (ptr); \ | | | | 54| 10| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 10|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 55| 10| } \ | | | | 56| 279| ptr += n; \ | | | | 57| 269| break; | | ------------------ | | 61| 269| INVALID_LEAD_CASE(3, ptr, nextTokPtr) \ | | ------------------ | | | | 49| 215| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (49:3): [True: 215, False: 53.9k] | | | | ------------------ | | | | 50| 215| if (end - ptr < n) \ | | | | ------------------ | | | | | Branch (50:9): [True: 0, False: 215] | | | | ------------------ | | | | 51| 204| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 0|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 52| 215| if (IS_INVALID_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 240| 215| (AS_NORMAL_ENCODING(enc)->isInvalid##n(enc, p)) | | | | | | ------------------ | | | | | | | | 207| 215|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | | | ------------------ | | | | | | | Branch (240:3): [True: 11, False: 204] | | | | | | ------------------ | | | | ------------------ | | | | 53| 11| *(nextTokPtr) = (ptr); \ | | | | 54| 11| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 11|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 55| 11| } \ | | | | 56| 215| ptr += n; \ | | | | 57| 204| break; | | ------------------ | | 62| 213| INVALID_LEAD_CASE(4, ptr, nextTokPtr) \ | | ------------------ | | | | 49| 213| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (49:3): [True: 213, False: 53.9k] | | | | ------------------ | | | | 50| 213| if (end - ptr < n) \ | | | | ------------------ | | | | | Branch (50:9): [True: 1, False: 212] | | | | ------------------ | | | | 51| 208| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 1|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 52| 212| if (IS_INVALID_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 240| 212| (AS_NORMAL_ENCODING(enc)->isInvalid##n(enc, p)) | | | | | | ------------------ | | | | | | | | 207| 212|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | | | ------------------ | | | | | | | Branch (240:3): [True: 4, False: 208] | | | | | | ------------------ | | | | ------------------ | | | | 53| 4| *(nextTokPtr) = (ptr); \ | | | | 54| 4| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 4|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 55| 4| } \ | | | | 56| 212| ptr += n; \ | | | | 57| 208| break; | | ------------------ | | 63| 208| case BT_NONXML: \ | | ------------------ | | | Branch (63:3): [True: 1, False: 54.1k] | | ------------------ | | 64| 2| case BT_MALFORM: \ | | ------------------ | | | Branch (64:3): [True: 1, False: 54.1k] | | ------------------ | | 65| 3| case BT_TRAIL: \ | | ------------------ | | | Branch (65:3): [True: 1, False: 54.1k] | | ------------------ | | 66| 3| *(nextTokPtr) = (ptr); \ | | 67| 3| return XML_TOK_INVALID; | | ------------------ | | | | 57| 3|# define XML_TOK_INVALID 0 | | ------------------ ------------------ 650| 21.4k| case BT_AMP: { ------------------ | Branch (650:9): [True: 21.4k, False: 32.7k] ------------------ 651| 21.4k| int tok = PREFIX(scanRef)(enc, ptr + MINBPC(enc), end, &ptr); ------------------ | | 248| 21.4k|#define PREFIX(ident) normal_##ident ------------------ int tok = PREFIX(scanRef)(enc, ptr + MINBPC(enc), end, &ptr); ------------------ | | 228| 21.4k|#define MINBPC(enc) 1 ------------------ 652| 21.4k| if (tok <= 0) { ------------------ | Branch (652:15): [True: 19, False: 21.4k] ------------------ 653| 19| if (tok == XML_TOK_INVALID) ------------------ | | 57| 19|# define XML_TOK_INVALID 0 ------------------ | Branch (653:17): [True: 15, False: 4] ------------------ 654| 15| *nextTokPtr = ptr; 655| 19| return tok; 656| 19| } 657| 21.4k| break; 658| 21.4k| } 659| 21.4k| case BT_LT: ------------------ | Branch (659:9): [True: 27, False: 54.1k] ------------------ 660| 27| *nextTokPtr = ptr; 661| 27| return XML_TOK_INVALID; ------------------ | | 57| 27|# define XML_TOK_INVALID 0 ------------------ 662| 32.0k| default: ------------------ | Branch (662:9): [True: 32.0k, False: 22.1k] ------------------ 663| 32.0k| ptr += MINBPC(enc); ------------------ | | 228| 32.0k|#define MINBPC(enc) 1 ------------------ 664| 32.0k| break; 665| 54.1k| } 666| 54.1k| } 667| 34.8k| ptr += MINBPC(enc); ------------------ | | 228| 34.8k|#define MINBPC(enc) 1 ------------------ 668| 34.8k| REQUIRE_CHAR(enc, ptr, end); ------------------ | | 140| 34.8k|# define REQUIRE_CHAR(enc, ptr, end) REQUIRE_CHARS(enc, ptr, end, 1) | | ------------------ | | | | 134| 34.8k| { \ | | | | 135| 34.8k| if (! HAS_CHARS(enc, ptr, end, count)) { \ | | | | ------------------ | | | | | | 129| 34.8k| ((end) - (ptr) >= ((count) * MINBPC(enc))) | | | | | | ------------------ | | | | | | | | 228| 34.8k|#define MINBPC(enc) 1 | | | | | | ------------------ | | | | ------------------ | | | | | Branch (135:11): [True: 1, False: 34.8k] | | | | ------------------ | | | | 136| 1| return XML_TOK_PARTIAL; \ | | | | ------------------ | | | | | | 56| 1|# define XML_TOK_PARTIAL -1 /* only part of a token */ | | | | ------------------ | | | | 137| 1| } \ | | | | 138| 34.8k| } | | ------------------ ------------------ 669| 34.8k| switch (BYTE_TYPE(enc, ptr)) { ------------------ | | 233| 34.8k|#define BYTE_TYPE(enc, p) SB_BYTE_TYPE(enc, p) | | ------------------ | | | | 231| 34.8k| (((const struct normal_encoding *)(enc))->type[(unsigned char)*(p)]) | | ------------------ ------------------ 670| 8.16k| case BT_S: ------------------ | Branch (670:7): [True: 8.16k, False: 26.6k] ------------------ 671| 8.36k| case BT_CR: ------------------ | Branch (671:7): [True: 196, False: 34.6k] ------------------ 672| 8.55k| case BT_LF: ------------------ | Branch (672:7): [True: 196, False: 34.6k] ------------------ 673| 8.55k| break; 674| 21.7k| case BT_SOL: ------------------ | Branch (674:7): [True: 21.7k, False: 13.1k] ------------------ 675| 21.7k| goto sol; 676| 4.58k| case BT_GT: ------------------ | Branch (676:7): [True: 4.58k, False: 30.2k] ------------------ 677| 4.58k| goto gt; 678| 1| default: ------------------ | Branch (678:7): [True: 1, False: 34.8k] ------------------ 679| 1| *nextTokPtr = ptr; 680| 1| return XML_TOK_INVALID; ------------------ | | 57| 1|# define XML_TOK_INVALID 0 ------------------ 681| 34.8k| } 682| | /* ptr points to closing quote */ 683| 9.20k| for (;;) { 684| 9.20k| ptr += MINBPC(enc); ------------------ | | 228| 9.20k|#define MINBPC(enc) 1 ------------------ 685| 9.20k| REQUIRE_CHAR(enc, ptr, end); ------------------ | | 140| 9.20k|# define REQUIRE_CHAR(enc, ptr, end) REQUIRE_CHARS(enc, ptr, end, 1) | | ------------------ | | | | 134| 9.20k| { \ | | | | 135| 9.20k| if (! HAS_CHARS(enc, ptr, end, count)) { \ | | | | ------------------ | | | | | | 129| 9.20k| ((end) - (ptr) >= ((count) * MINBPC(enc))) | | | | | | ------------------ | | | | | | | | 228| 9.20k|#define MINBPC(enc) 1 | | | | | | ------------------ | | | | ------------------ | | | | | Branch (135:11): [True: 2, False: 9.20k] | | | | ------------------ | | | | 136| 2| return XML_TOK_PARTIAL; \ | | | | ------------------ | | | | | | 56| 2|# define XML_TOK_PARTIAL -1 /* only part of a token */ | | | | ------------------ | | | | 137| 2| } \ | | | | 138| 9.20k| } | | ------------------ ------------------ 686| 9.20k| switch (BYTE_TYPE(enc, ptr)) { ------------------ | | 233| 9.20k|#define BYTE_TYPE(enc, p) SB_BYTE_TYPE(enc, p) | | ------------------ | | | | 231| 9.20k| (((const struct normal_encoding *)(enc))->type[(unsigned char)*(p)]) | | ------------------ ------------------ 687| 6.71k| CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr) ------------------ | | 110| 7.15k| case BT_NONASCII: \ | | ------------------ | | | Branch (110:3): [True: 0, False: 9.20k] | | ------------------ | | 111| 7.15k| if (! IS_NMSTRT_CHAR_MINBPC(enc, ptr)) { \ | | ------------------ | | | | 243| 0|#define IS_NMSTRT_CHAR_MINBPC(enc, p) (0) | | ------------------ | | | Branch (111:9): [True: 0, Folded] | | ------------------ | | 112| 0| *nextTokPtr = ptr; \ | | 113| 0| return XML_TOK_INVALID; \ | | ------------------ | | | | 57| 0|# define XML_TOK_INVALID 0 | | ------------------ | | 114| 0| } \ | | 115| 7.15k| EXPAT_FALLTHROUGH; \ | | ------------------ | | | | 47| 0|# define EXPAT_FALLTHROUGH __attribute__((fallthrough)) | | ------------------ | | 116| 5.45k| case BT_NMSTRT: \ | | ------------------ | | | Branch (116:3): [True: 5.45k, False: 3.74k] | | ------------------ | | 117| 7.15k| case BT_HEX: \ | | ------------------ | | | Branch (117:3): [True: 1.70k, False: 7.49k] | | ------------------ | | 118| 7.15k| ptr += MINBPC(enc); \ | | ------------------ | | | | 228| 7.15k|#define MINBPC(enc) 1 | | ------------------ | | 119| 7.15k| break; \ | | 120| 7.15k| CHECK_NMSTRT_CASE(2, enc, ptr, end, nextTokPtr) \ | | ------------------ | | | | 99| 355| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (99:3): [True: 355, False: 8.84k] | | | | ------------------ | | | | 100| 355| if ((end) - (ptr) < (n)) \ | | | | ------------------ | | | | | Branch (100:9): [True: 0, False: 355] | | | | ------------------ | | | | 101| 353| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 0|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 102| 355| if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NMSTRT_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 240| 710| (AS_NORMAL_ENCODING(enc)->isInvalid##n(enc, p)) | | | | | | ------------------ | | | | | | | | 207| 355|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | | | ------------------ | | | | | | | Branch (240:3): [True: 1, False: 354] | | | | | | ------------------ | | | | ------------------ | | | | if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NMSTRT_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 238| 354|#define IS_NMSTRT_CHAR(enc, p, n) (AS_NORMAL_ENCODING(enc)->isNmstrt##n(enc, p)) | | | | | | ------------------ | | | | | | | | 207| 354|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (102:41): [True: 1, False: 353] | | | | ------------------ | | | | 103| 2| *nextTokPtr = ptr; \ | | | | 104| 2| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 2|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 105| 2| } \ | | | | 106| 355| ptr += n; \ | | | | 107| 353| break; | | ------------------ | | 121| 353| CHECK_NMSTRT_CASE(3, enc, ptr, end, nextTokPtr) \ | | ------------------ | | | | 99| 273| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (99:3): [True: 273, False: 8.92k] | | | | ------------------ | | | | 100| 273| if ((end) - (ptr) < (n)) \ | | | | ------------------ | | | | | Branch (100:9): [True: 0, False: 273] | | | | ------------------ | | | | 101| 263| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 0|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 102| 273| if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NMSTRT_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 240| 546| (AS_NORMAL_ENCODING(enc)->isInvalid##n(enc, p)) | | | | | | ------------------ | | | | | | | | 207| 273|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | | | ------------------ | | | | | | | Branch (240:3): [True: 9, False: 264] | | | | | | ------------------ | | | | ------------------ | | | | if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NMSTRT_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 238| 264|#define IS_NMSTRT_CHAR(enc, p, n) (AS_NORMAL_ENCODING(enc)->isNmstrt##n(enc, p)) | | | | | | ------------------ | | | | | | | | 207| 264|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (102:41): [True: 1, False: 263] | | | | ------------------ | | | | 103| 10| *nextTokPtr = ptr; \ | | | | 104| 10| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 10|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 105| 10| } \ | | | | 106| 273| ptr += n; \ | | | | 107| 263| break; | | ------------------ | | 122| 263| CHECK_NMSTRT_CASE(4, enc, ptr, end, nextTokPtr) | | ------------------ | | | | 99| 3| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (99:3): [True: 3, False: 9.19k] | | | | ------------------ | | | | 100| 3| if ((end) - (ptr) < (n)) \ | | | | ------------------ | | | | | Branch (100:9): [True: 1, False: 2] | | | | ------------------ | | | | 101| 1| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 1|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 102| 2| if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NMSTRT_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 240| 4| (AS_NORMAL_ENCODING(enc)->isInvalid##n(enc, p)) | | | | | | ------------------ | | | | | | | | 207| 2|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | | | ------------------ | | | | | | | Branch (240:3): [True: 1, False: 1] | | | | | | ------------------ | | | | ------------------ | | | | if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NMSTRT_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 238| 1|#define IS_NMSTRT_CHAR(enc, p, n) (AS_NORMAL_ENCODING(enc)->isNmstrt##n(enc, p)) | | | | | | ------------------ | | | | | | | | 207| 1|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (102:41): [True: 1, False: 0] | | | | ------------------ | | | | 103| 2| *nextTokPtr = ptr; \ | | | | 104| 2| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 2|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 105| 2| } \ | | | | 106| 2| ptr += n; \ | | | | 107| 0| break; | | ------------------ ------------------ 688| 256| case BT_S: ------------------ | Branch (688:9): [True: 256, False: 8.94k] ------------------ 689| 454| case BT_CR: ------------------ | Branch (689:9): [True: 198, False: 9.00k] ------------------ 690| 648| case BT_LF: ------------------ | Branch (690:9): [True: 194, False: 9.00k] ------------------ 691| 648| continue; 692| 322| case BT_GT: ------------------ | Branch (692:9): [True: 322, False: 8.88k] ------------------ 693| 4.90k| gt: 694| 4.90k| *nextTokPtr = ptr + MINBPC(enc); ------------------ | | 228| 4.90k|#define MINBPC(enc) 1 ------------------ 695| 4.90k| return XML_TOK_START_TAG_WITH_ATTS; ------------------ | | 62| 4.90k|# define XML_TOK_START_TAG_WITH_ATTS 1 ------------------ 696| 442| case BT_SOL: ------------------ | Branch (696:9): [True: 442, False: 8.76k] ------------------ 697| 22.1k| sol: 698| 22.1k| ptr += MINBPC(enc); ------------------ | | 228| 22.1k|#define MINBPC(enc) 1 ------------------ 699| 22.1k| REQUIRE_CHAR(enc, ptr, end); ------------------ | | 140| 22.1k|# define REQUIRE_CHAR(enc, ptr, end) REQUIRE_CHARS(enc, ptr, end, 1) | | ------------------ | | | | 134| 22.1k| { \ | | | | 135| 22.1k| if (! HAS_CHARS(enc, ptr, end, count)) { \ | | | | ------------------ | | | | | | 129| 22.1k| ((end) - (ptr) >= ((count) * MINBPC(enc))) | | | | | | ------------------ | | | | | | | | 228| 22.1k|#define MINBPC(enc) 1 | | | | | | ------------------ | | | | ------------------ | | | | | Branch (135:11): [True: 1, False: 22.1k] | | | | ------------------ | | | | 136| 1| return XML_TOK_PARTIAL; \ | | | | ------------------ | | | | | | 56| 1|# define XML_TOK_PARTIAL -1 /* only part of a token */ | | | | ------------------ | | | | 137| 1| } \ | | | | 138| 22.1k| } | | ------------------ ------------------ 700| 22.1k| if (! CHAR_MATCHES(enc, ptr, ASCII_GT)) { ------------------ | | 246| 22.1k|#define CHAR_MATCHES(enc, p, c) (*(p) == (c)) ------------------ | Branch (700:15): [True: 9, False: 22.1k] ------------------ 701| 9| *nextTokPtr = ptr; 702| 9| return XML_TOK_INVALID; ------------------ | | 57| 9|# define XML_TOK_INVALID 0 ------------------ 703| 9| } 704| 22.1k| *nextTokPtr = ptr + MINBPC(enc); ------------------ | | 228| 22.1k|#define MINBPC(enc) 1 ------------------ 705| 22.1k| return XML_TOK_EMPTY_ELEMENT_WITH_ATTS; ------------------ | | 64| 22.1k|# define XML_TOK_EMPTY_ELEMENT_WITH_ATTS 3 /* empty element tag */ ------------------ 706| 1| default: ------------------ | Branch (706:9): [True: 1, False: 9.20k] ------------------ 707| 1| *nextTokPtr = ptr; 708| 1| return XML_TOK_INVALID; ------------------ | | 57| 1|# define XML_TOK_INVALID 0 ------------------ 709| 9.20k| } 710| 7.77k| break; 711| 9.20k| } 712| 7.77k| break; 713| 8.55k| } 714| 7.77k| default: ------------------ | Branch (714:5): [True: 96, False: 101k] ------------------ 715| 96| *nextTokPtr = ptr; 716| 96| return XML_TOK_INVALID; ------------------ | | 57| 96|# define XML_TOK_INVALID 0 ------------------ 717| 101k| } 718| 101k| } 719| 2| return XML_TOK_PARTIAL; ------------------ | | 56| 2|# define XML_TOK_PARTIAL -1 /* only part of a token */ ------------------ 720| 27.3k|} xmltok.c:normal_scanRef: 545| 816k| const char **nextTokPtr) { 546| 816k| REQUIRE_CHAR(enc, ptr, end); ------------------ | | 140| 816k|# define REQUIRE_CHAR(enc, ptr, end) REQUIRE_CHARS(enc, ptr, end, 1) | | ------------------ | | | | 134| 816k| { \ | | | | 135| 816k| if (! HAS_CHARS(enc, ptr, end, count)) { \ | | | | ------------------ | | | | | | 129| 816k| ((end) - (ptr) >= ((count) * MINBPC(enc))) | | | | | | ------------------ | | | | | | | | 228| 816k|#define MINBPC(enc) 1 | | | | | | ------------------ | | | | ------------------ | | | | | Branch (135:11): [True: 14, False: 816k] | | | | ------------------ | | | | 136| 14| return XML_TOK_PARTIAL; \ | | | | ------------------ | | | | | | 56| 14|# define XML_TOK_PARTIAL -1 /* only part of a token */ | | | | ------------------ | | | | 137| 14| } \ | | | | 138| 816k| } | | ------------------ ------------------ 547| 816k| switch (BYTE_TYPE(enc, ptr)) { ------------------ | | 233| 816k|#define BYTE_TYPE(enc, p) SB_BYTE_TYPE(enc, p) | | ------------------ | | | | 231| 816k| (((const struct normal_encoding *)(enc))->type[(unsigned char)*(p)]) | | ------------------ ------------------ 548| 806k| CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr) ------------------ | | 110| 808k| case BT_NONASCII: \ | | ------------------ | | | Branch (110:3): [True: 0, False: 816k] | | ------------------ | | 111| 808k| if (! IS_NMSTRT_CHAR_MINBPC(enc, ptr)) { \ | | ------------------ | | | | 243| 0|#define IS_NMSTRT_CHAR_MINBPC(enc, p) (0) | | ------------------ | | | Branch (111:9): [True: 0, Folded] | | ------------------ | | 112| 0| *nextTokPtr = ptr; \ | | 113| 0| return XML_TOK_INVALID; \ | | ------------------ | | | | 57| 0|# define XML_TOK_INVALID 0 | | ------------------ | | 114| 0| } \ | | 115| 808k| EXPAT_FALLTHROUGH; \ | | ------------------ | | | | 47| 0|# define EXPAT_FALLTHROUGH __attribute__((fallthrough)) | | ------------------ | | 116| 805k| case BT_NMSTRT: \ | | ------------------ | | | Branch (116:3): [True: 805k, False: 10.3k] | | ------------------ | | 117| 808k| case BT_HEX: \ | | ------------------ | | | Branch (117:3): [True: 3.06k, False: 812k] | | ------------------ | | 118| 808k| ptr += MINBPC(enc); \ | | ------------------ | | | | 228| 808k|#define MINBPC(enc) 1 | | ------------------ | | 119| 808k| break; \ | | 120| 808k| CHECK_NMSTRT_CASE(2, enc, ptr, end, nextTokPtr) \ | | ------------------ | | | | 99| 257| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (99:3): [True: 257, False: 815k] | | | | ------------------ | | | | 100| 257| if ((end) - (ptr) < (n)) \ | | | | ------------------ | | | | | Branch (100:9): [True: 0, False: 257] | | | | ------------------ | | | | 101| 244| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 0|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 102| 257| if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NMSTRT_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 240| 514| (AS_NORMAL_ENCODING(enc)->isInvalid##n(enc, p)) | | | | | | ------------------ | | | | | | | | 207| 257|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | | | ------------------ | | | | | | | Branch (240:3): [True: 11, False: 246] | | | | | | ------------------ | | | | ------------------ | | | | if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NMSTRT_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 238| 246|#define IS_NMSTRT_CHAR(enc, p, n) (AS_NORMAL_ENCODING(enc)->isNmstrt##n(enc, p)) | | | | | | ------------------ | | | | | | | | 207| 246|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (102:41): [True: 2, False: 244] | | | | ------------------ | | | | 103| 13| *nextTokPtr = ptr; \ | | | | 104| 13| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 13|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 105| 13| } \ | | | | 106| 257| ptr += n; \ | | | | 107| 244| break; | | ------------------ | | 121| 244| CHECK_NMSTRT_CASE(3, enc, ptr, end, nextTokPtr) \ | | ------------------ | | | | 99| 203| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (99:3): [True: 203, False: 815k] | | | | ------------------ | | | | 100| 203| if ((end) - (ptr) < (n)) \ | | | | ------------------ | | | | | Branch (100:9): [True: 0, False: 203] | | | | ------------------ | | | | 101| 197| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 0|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 102| 203| if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NMSTRT_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 240| 406| (AS_NORMAL_ENCODING(enc)->isInvalid##n(enc, p)) | | | | | | ------------------ | | | | | | | | 207| 203|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | | | ------------------ | | | | | | | Branch (240:3): [True: 5, False: 198] | | | | | | ------------------ | | | | ------------------ | | | | if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NMSTRT_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 238| 198|#define IS_NMSTRT_CHAR(enc, p, n) (AS_NORMAL_ENCODING(enc)->isNmstrt##n(enc, p)) | | | | | | ------------------ | | | | | | | | 207| 198|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (102:41): [True: 1, False: 197] | | | | ------------------ | | | | 103| 6| *nextTokPtr = ptr; \ | | | | 104| 6| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 6|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 105| 6| } \ | | | | 106| 203| ptr += n; \ | | | | 107| 197| break; | | ------------------ | | 122| 197| CHECK_NMSTRT_CASE(4, enc, ptr, end, nextTokPtr) | | ------------------ | | | | 99| 8| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (99:3): [True: 8, False: 816k] | | | | ------------------ | | | | 100| 8| if ((end) - (ptr) < (n)) \ | | | | ------------------ | | | | | Branch (100:9): [True: 1, False: 7] | | | | ------------------ | | | | 101| 1| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 1|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 102| 7| if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NMSTRT_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 240| 14| (AS_NORMAL_ENCODING(enc)->isInvalid##n(enc, p)) | | | | | | ------------------ | | | | | | | | 207| 7|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | | | ------------------ | | | | | | | Branch (240:3): [True: 6, False: 1] | | | | | | ------------------ | | | | ------------------ | | | | if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NMSTRT_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 238| 1|#define IS_NMSTRT_CHAR(enc, p, n) (AS_NORMAL_ENCODING(enc)->isNmstrt##n(enc, p)) | | | | | | ------------------ | | | | | | | | 207| 1|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (102:41): [True: 1, False: 0] | | | | ------------------ | | | | 103| 7| *nextTokPtr = ptr; \ | | | | 104| 7| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 7|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 105| 7| } \ | | | | 106| 7| ptr += n; \ | | | | 107| 0| break; | | ------------------ ------------------ 549| 6.79k| case BT_NUM: ------------------ | Branch (549:3): [True: 6.79k, False: 809k] ------------------ 550| 6.79k| return PREFIX(scanCharRef)(enc, ptr + MINBPC(enc), end, nextTokPtr); ------------------ | | 248| 6.79k|#define PREFIX(ident) normal_##ident ------------------ return PREFIX(scanCharRef)(enc, ptr + MINBPC(enc), end, nextTokPtr); ------------------ | | 228| 6.79k|#define MINBPC(enc) 1 ------------------ 551| 22| default: ------------------ | Branch (551:3): [True: 22, False: 816k] ------------------ 552| 22| *nextTokPtr = ptr; 553| 22| return XML_TOK_INVALID; ------------------ | | 57| 22|# define XML_TOK_INVALID 0 ------------------ 554| 816k| } 555| 883k| while (HAS_CHAR(enc, ptr, end)) { 556| 883k| switch (BYTE_TYPE(enc, ptr)) { ------------------ | | 233| 883k|#define BYTE_TYPE(enc, p) SB_BYTE_TYPE(enc, p) | | ------------------ | | | | 231| 883k| (((const struct normal_encoding *)(enc))->type[(unsigned char)*(p)]) | | ------------------ ------------------ 557| 292k| CHECK_NAME_CASES(enc, ptr, end, nextTokPtr) ------------------ | | 81| 74.3k| case BT_NONASCII: \ | | ------------------ | | | Branch (81:3): [True: 0, False: 883k] | | ------------------ | | 82| 74.3k| if (! IS_NAME_CHAR_MINBPC(enc, ptr)) { \ | | ------------------ | | | | 242| 0|#define IS_NAME_CHAR_MINBPC(enc, p) (0) | | ------------------ | | | Branch (82:9): [True: 0, Folded] | | ------------------ | | 83| 0| *nextTokPtr = ptr; \ | | 84| 0| return XML_TOK_INVALID; \ | | ------------------ | | | | 57| 0|# define XML_TOK_INVALID 0 | | ------------------ | | 85| 0| } \ | | 86| 74.3k| EXPAT_FALLTHROUGH; \ | | ------------------ | | | | 47| 0|# define EXPAT_FALLTHROUGH __attribute__((fallthrough)) | | ------------------ | | 87| 71.7k| case BT_NMSTRT: \ | | ------------------ | | | Branch (87:3): [True: 71.7k, False: 812k] | | ------------------ | | 88| 72.6k| case BT_HEX: \ | | ------------------ | | | Branch (88:3): [True: 881, False: 883k] | | ------------------ | | 89| 73.6k| case BT_DIGIT: \ | | ------------------ | | | Branch (89:3): [True: 1.01k, False: 882k] | | ------------------ | | 90| 73.8k| case BT_NAME: \ | | ------------------ | | | Branch (90:3): [True: 242, False: 883k] | | ------------------ | | 91| 74.3k| case BT_MINUS: \ | | ------------------ | | | Branch (91:3): [True: 469, False: 883k] | | ------------------ | | 92| 74.3k| ptr += MINBPC(enc); \ | | ------------------ | | | | 228| 74.3k|#define MINBPC(enc) 1 | | ------------------ | | 93| 74.3k| break; \ | | 94| 74.3k| CHECK_NAME_CASE(2, enc, ptr, end, nextTokPtr) \ | | ------------------ | | | | 70| 282| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (70:3): [True: 282, False: 883k] | | | | ------------------ | | | | 71| 282| if (end - ptr < n) \ | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 282] | | | | ------------------ | | | | 72| 271| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 0|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 73| 282| if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NAME_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 240| 564| (AS_NORMAL_ENCODING(enc)->isInvalid##n(enc, p)) | | | | | | ------------------ | | | | | | | | 207| 282|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | | | ------------------ | | | | | | | Branch (240:3): [True: 10, False: 272] | | | | | | ------------------ | | | | ------------------ | | | | if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NAME_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 237| 272|#define IS_NAME_CHAR(enc, p, n) (AS_NORMAL_ENCODING(enc)->isName##n(enc, p)) | | | | | | ------------------ | | | | | | | | 207| 272|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (73:41): [True: 1, False: 271] | | | | ------------------ | | | | 74| 11| *nextTokPtr = ptr; \ | | | | 75| 11| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 11|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 76| 11| } \ | | | | 77| 282| ptr += n; \ | | | | 78| 271| break; | | ------------------ | | 95| 271| CHECK_NAME_CASE(3, enc, ptr, end, nextTokPtr) \ | | ------------------ | | | | 70| 201| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (70:3): [True: 201, False: 883k] | | | | ------------------ | | | | 71| 201| if (end - ptr < n) \ | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 201] | | | | ------------------ | | | | 72| 196| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 0|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 73| 201| if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NAME_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 240| 402| (AS_NORMAL_ENCODING(enc)->isInvalid##n(enc, p)) | | | | | | ------------------ | | | | | | | | 207| 201|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | | | ------------------ | | | | | | | Branch (240:3): [True: 4, False: 197] | | | | | | ------------------ | | | | ------------------ | | | | if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NAME_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 237| 197|#define IS_NAME_CHAR(enc, p, n) (AS_NORMAL_ENCODING(enc)->isName##n(enc, p)) | | | | | | ------------------ | | | | | | | | 207| 197|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (73:41): [True: 1, False: 196] | | | | ------------------ | | | | 74| 5| *nextTokPtr = ptr; \ | | | | 75| 5| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 5|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 76| 5| } \ | | | | 77| 201| ptr += n; \ | | | | 78| 196| break; | | ------------------ | | 96| 196| CHECK_NAME_CASE(4, enc, ptr, end, nextTokPtr) | | ------------------ | | | | 70| 6| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (70:3): [True: 6, False: 883k] | | | | ------------------ | | | | 71| 6| if (end - ptr < n) \ | | | | ------------------ | | | | | Branch (71:9): [True: 4, False: 2] | | | | ------------------ | | | | 72| 4| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 4|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 73| 2| if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NAME_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 240| 4| (AS_NORMAL_ENCODING(enc)->isInvalid##n(enc, p)) | | | | | | ------------------ | | | | | | | | 207| 2|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | | | ------------------ | | | | | | | Branch (240:3): [True: 1, False: 1] | | | | | | ------------------ | | | | ------------------ | | | | if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NAME_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 237| 1|#define IS_NAME_CHAR(enc, p, n) (AS_NORMAL_ENCODING(enc)->isName##n(enc, p)) | | | | | | ------------------ | | | | | | | | 207| 1|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (73:41): [True: 1, False: 0] | | | | ------------------ | | | | 74| 2| *nextTokPtr = ptr; \ | | | | 75| 2| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 2|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 76| 2| } \ | | | | 77| 2| ptr += n; \ | | | | 78| 0| break; | | ------------------ ------------------ 558| 809k| case BT_SEMI: ------------------ | Branch (558:5): [True: 809k, False: 74.8k] ------------------ 559| 809k| *nextTokPtr = ptr + MINBPC(enc); ------------------ | | 228| 809k|#define MINBPC(enc) 1 ------------------ 560| 809k| return XML_TOK_ENTITY_REF; ------------------ | | 70| 809k|# define XML_TOK_ENTITY_REF 9 ------------------ 561| 46| default: ------------------ | Branch (561:5): [True: 46, False: 883k] ------------------ 562| 46| *nextTokPtr = ptr; 563| 46| return XML_TOK_INVALID; ------------------ | | 57| 46|# define XML_TOK_INVALID 0 ------------------ 564| 883k| } 565| 883k| } 566| 2| return XML_TOK_PARTIAL; ------------------ | | 56| 2|# define XML_TOK_PARTIAL -1 /* only part of a token */ ------------------ 567| 809k|} xmltok.c:normal_scanCharRef: 514| 6.79k| const char **nextTokPtr) { 515| 6.79k| if (HAS_CHAR(enc, ptr, end)) { ------------------ | | 131| 6.79k|# define HAS_CHAR(enc, ptr, end) HAS_CHARS(enc, ptr, end, 1) | | ------------------ | | | | 129| 6.79k| ((end) - (ptr) >= ((count) * MINBPC(enc))) | | | | ------------------ | | | | | | 228| 6.79k|#define MINBPC(enc) 1 | | | | ------------------ | | | | | Branch (129:5): [True: 6.79k, False: 1] | | | | ------------------ | | ------------------ ------------------ 516| 6.79k| if (CHAR_MATCHES(enc, ptr, ASCII_x)) ------------------ | | 246| 6.79k|#define CHAR_MATCHES(enc, p, c) (*(p) == (c)) | | ------------------ | | | Branch (246:33): [True: 5.44k, False: 1.34k] | | ------------------ ------------------ 517| 5.44k| return PREFIX(scanHexCharRef)(enc, ptr + MINBPC(enc), end, nextTokPtr); ------------------ | | 248| 5.44k|#define PREFIX(ident) normal_##ident ------------------ return PREFIX(scanHexCharRef)(enc, ptr + MINBPC(enc), end, nextTokPtr); ------------------ | | 228| 5.44k|#define MINBPC(enc) 1 ------------------ 518| 1.34k| switch (BYTE_TYPE(enc, ptr)) { ------------------ | | 233| 1.34k|#define BYTE_TYPE(enc, p) SB_BYTE_TYPE(enc, p) | | ------------------ | | | | 231| 1.34k| (((const struct normal_encoding *)(enc))->type[(unsigned char)*(p)]) | | ------------------ ------------------ 519| 1.33k| case BT_DIGIT: ------------------ | Branch (519:5): [True: 1.33k, False: 15] ------------------ 520| 1.33k| break; 521| 15| default: ------------------ | Branch (521:5): [True: 15, False: 1.33k] ------------------ 522| 15| *nextTokPtr = ptr; 523| 15| return XML_TOK_INVALID; ------------------ | | 57| 15|# define XML_TOK_INVALID 0 ------------------ 524| 1.34k| } 525| 3.22k| for (ptr += MINBPC(enc); HAS_CHAR(enc, ptr, end); ptr += MINBPC(enc)) { ------------------ | | 228| 1.33k|#define MINBPC(enc) 1 ------------------ for (ptr += MINBPC(enc); HAS_CHAR(enc, ptr, end); ptr += MINBPC(enc)) { ------------------ | | 228| 1.89k|#define MINBPC(enc) 1 ------------------ 526| 3.22k| switch (BYTE_TYPE(enc, ptr)) { ------------------ | | 233| 3.22k|#define BYTE_TYPE(enc, p) SB_BYTE_TYPE(enc, p) | | ------------------ | | | | 231| 3.22k| (((const struct normal_encoding *)(enc))->type[(unsigned char)*(p)]) | | ------------------ ------------------ 527| 1.89k| case BT_DIGIT: ------------------ | Branch (527:7): [True: 1.89k, False: 1.33k] ------------------ 528| 1.89k| break; 529| 1.32k| case BT_SEMI: ------------------ | Branch (529:7): [True: 1.32k, False: 1.89k] ------------------ 530| 1.32k| *nextTokPtr = ptr + MINBPC(enc); ------------------ | | 228| 1.32k|#define MINBPC(enc) 1 ------------------ 531| 1.32k| return XML_TOK_CHAR_REF; ------------------ | | 71| 1.32k|# define XML_TOK_CHAR_REF 10 /* numeric character reference */ ------------------ 532| 7| default: ------------------ | Branch (532:7): [True: 7, False: 3.21k] ------------------ 533| 7| *nextTokPtr = ptr; 534| 7| return XML_TOK_INVALID; ------------------ | | 57| 7|# define XML_TOK_INVALID 0 ------------------ 535| 3.22k| } 536| 3.22k| } 537| 1.33k| } 538| 2| return XML_TOK_PARTIAL; ------------------ | | 56| 2|# define XML_TOK_PARTIAL -1 /* only part of a token */ ------------------ 539| 6.79k|} xmltok.c:normal_scanHexCharRef: 483| 5.44k| const char **nextTokPtr) { 484| 5.44k| if (HAS_CHAR(enc, ptr, end)) { ------------------ | | 131| 5.44k|# define HAS_CHAR(enc, ptr, end) HAS_CHARS(enc, ptr, end, 1) | | ------------------ | | | | 129| 5.44k| ((end) - (ptr) >= ((count) * MINBPC(enc))) | | | | ------------------ | | | | | | 228| 5.44k|#define MINBPC(enc) 1 | | | | ------------------ | | | | | Branch (129:5): [True: 5.44k, False: 1] | | | | ------------------ | | ------------------ ------------------ 485| 5.44k| switch (BYTE_TYPE(enc, ptr)) { ------------------ | | 233| 5.44k|#define BYTE_TYPE(enc, p) SB_BYTE_TYPE(enc, p) | | ------------------ | | | | 231| 5.44k| (((const struct normal_encoding *)(enc))->type[(unsigned char)*(p)]) | | ------------------ ------------------ 486| 3.51k| case BT_DIGIT: ------------------ | Branch (486:5): [True: 3.51k, False: 1.93k] ------------------ 487| 5.44k| case BT_HEX: ------------------ | Branch (487:5): [True: 1.92k, False: 3.51k] ------------------ 488| 5.44k| break; 489| 5| default: ------------------ | Branch (489:5): [True: 5, False: 5.44k] ------------------ 490| 5| *nextTokPtr = ptr; 491| 5| return XML_TOK_INVALID; ------------------ | | 57| 5|# define XML_TOK_INVALID 0 ------------------ 492| 5.44k| } 493| 16.7k| for (ptr += MINBPC(enc); HAS_CHAR(enc, ptr, end); ptr += MINBPC(enc)) { ------------------ | | 228| 5.44k|#define MINBPC(enc) 1 ------------------ for (ptr += MINBPC(enc); HAS_CHAR(enc, ptr, end); ptr += MINBPC(enc)) { ------------------ | | 228| 11.3k|#define MINBPC(enc) 1 ------------------ 494| 16.7k| switch (BYTE_TYPE(enc, ptr)) { ------------------ | | 233| 16.7k|#define BYTE_TYPE(enc, p) SB_BYTE_TYPE(enc, p) | | ------------------ | | | | 231| 16.7k| (((const struct normal_encoding *)(enc))->type[(unsigned char)*(p)]) | | ------------------ ------------------ 495| 6.06k| case BT_DIGIT: ------------------ | Branch (495:7): [True: 6.06k, False: 10.7k] ------------------ 496| 11.3k| case BT_HEX: ------------------ | Branch (496:7): [True: 5.27k, False: 11.5k] ------------------ 497| 11.3k| break; 498| 5.41k| case BT_SEMI: ------------------ | Branch (498:7): [True: 5.41k, False: 11.3k] ------------------ 499| 5.41k| *nextTokPtr = ptr + MINBPC(enc); ------------------ | | 228| 5.41k|#define MINBPC(enc) 1 ------------------ 500| 5.41k| return XML_TOK_CHAR_REF; ------------------ | | 71| 5.41k|# define XML_TOK_CHAR_REF 10 /* numeric character reference */ ------------------ 501| 22| default: ------------------ | Branch (501:7): [True: 22, False: 16.7k] ------------------ 502| 22| *nextTokPtr = ptr; 503| 22| return XML_TOK_INVALID; ------------------ | | 57| 22|# define XML_TOK_INVALID 0 ------------------ 504| 16.7k| } 505| 16.7k| } 506| 5.44k| } 507| 3| return XML_TOK_PARTIAL; ------------------ | | 56| 3|# define XML_TOK_PARTIAL -1 /* only part of a token */ ------------------ 508| 5.44k|} xmltok.c:normal_cdataSectionTok: 356| 4.87k| const char **nextTokPtr) { 357| 4.87k| if (ptr >= end) ------------------ | Branch (357:7): [True: 129, False: 4.74k] ------------------ 358| 129| return XML_TOK_NONE; ------------------ | | 51| 129|# define XML_TOK_NONE -4 /* The string to be scanned is empty */ ------------------ 359| 4.74k| if (MINBPC(enc) > 1) { ------------------ | | 228| 4.74k|#define MINBPC(enc) 1 ------------------ | Branch (359:7): [Folded, False: 4.74k] ------------------ 360| 0| size_t n = end - ptr; 361| 0| if (n & (MINBPC(enc) - 1)) { ------------------ | | 228| 0|#define MINBPC(enc) 1 ------------------ | Branch (361:9): [True: 0, False: 0] ------------------ 362| 0| n &= ~(MINBPC(enc) - 1); ------------------ | | 228| 0|#define MINBPC(enc) 1 ------------------ 363| 0| if (n == 0) ------------------ | Branch (363:11): [True: 0, False: 0] ------------------ 364| 0| return XML_TOK_PARTIAL; ------------------ | | 56| 0|# define XML_TOK_PARTIAL -1 /* only part of a token */ ------------------ 365| 0| end = ptr + n; 366| 0| } 367| 0| } 368| 4.74k| switch (BYTE_TYPE(enc, ptr)) { ------------------ | | 233| 4.74k|#define BYTE_TYPE(enc, p) SB_BYTE_TYPE(enc, p) | | ------------------ | | | | 231| 4.74k| (((const struct normal_encoding *)(enc))->type[(unsigned char)*(p)]) | | ------------------ ------------------ 369| 2.16k| case BT_RSQB: ------------------ | Branch (369:3): [True: 2.16k, False: 2.57k] ------------------ 370| 2.16k| ptr += MINBPC(enc); ------------------ | | 228| 2.16k|#define MINBPC(enc) 1 ------------------ 371| 2.16k| REQUIRE_CHAR(enc, ptr, end); ------------------ | | 140| 2.16k|# define REQUIRE_CHAR(enc, ptr, end) REQUIRE_CHARS(enc, ptr, end, 1) | | ------------------ | | | | 134| 2.16k| { \ | | | | 135| 2.16k| if (! HAS_CHARS(enc, ptr, end, count)) { \ | | | | ------------------ | | | | | | 129| 2.16k| ((end) - (ptr) >= ((count) * MINBPC(enc))) | | | | | | ------------------ | | | | | | | | 228| 2.16k|#define MINBPC(enc) 1 | | | | | | ------------------ | | | | ------------------ | | | | | Branch (135:11): [True: 1, False: 2.16k] | | | | ------------------ | | | | 136| 1| return XML_TOK_PARTIAL; \ | | | | ------------------ | | | | | | 56| 1|# define XML_TOK_PARTIAL -1 /* only part of a token */ | | | | ------------------ | | | | 137| 1| } \ | | | | 138| 2.16k| } | | ------------------ ------------------ 372| 2.16k| if (! CHAR_MATCHES(enc, ptr, ASCII_RSQB)) ------------------ | | 246| 2.16k|#define CHAR_MATCHES(enc, p, c) (*(p) == (c)) ------------------ | Branch (372:9): [True: 405, False: 1.76k] ------------------ 373| 405| break; 374| 1.76k| ptr += MINBPC(enc); ------------------ | | 228| 1.76k|#define MINBPC(enc) 1 ------------------ 375| 1.76k| REQUIRE_CHAR(enc, ptr, end); ------------------ | | 140| 1.76k|# define REQUIRE_CHAR(enc, ptr, end) REQUIRE_CHARS(enc, ptr, end, 1) | | ------------------ | | | | 134| 1.76k| { \ | | | | 135| 1.76k| if (! HAS_CHARS(enc, ptr, end, count)) { \ | | | | ------------------ | | | | | | 129| 1.76k| ((end) - (ptr) >= ((count) * MINBPC(enc))) | | | | | | ------------------ | | | | | | | | 228| 1.76k|#define MINBPC(enc) 1 | | | | | | ------------------ | | | | ------------------ | | | | | Branch (135:11): [True: 1, False: 1.75k] | | | | ------------------ | | | | 136| 1| return XML_TOK_PARTIAL; \ | | | | ------------------ | | | | | | 56| 1|# define XML_TOK_PARTIAL -1 /* only part of a token */ | | | | ------------------ | | | | 137| 1| } \ | | | | 138| 1.76k| } | | ------------------ ------------------ 376| 1.75k| if (! CHAR_MATCHES(enc, ptr, ASCII_GT)) { ------------------ | | 246| 1.75k|#define CHAR_MATCHES(enc, p, c) (*(p) == (c)) ------------------ | Branch (376:9): [True: 836, False: 923] ------------------ 377| 836| ptr -= MINBPC(enc); ------------------ | | 228| 836|#define MINBPC(enc) 1 ------------------ 378| 836| break; 379| 836| } 380| 923| *nextTokPtr = ptr + MINBPC(enc); ------------------ | | 228| 923|#define MINBPC(enc) 1 ------------------ 381| 923| return XML_TOK_CDATA_SECT_CLOSE; ------------------ | | 113| 923|# define XML_TOK_CDATA_SECT_CLOSE 40 ------------------ 382| 625| case BT_CR: ------------------ | Branch (382:3): [True: 625, False: 4.11k] ------------------ 383| 625| ptr += MINBPC(enc); ------------------ | | 228| 625|#define MINBPC(enc) 1 ------------------ 384| 625| REQUIRE_CHAR(enc, ptr, end); ------------------ | | 140| 625|# define REQUIRE_CHAR(enc, ptr, end) REQUIRE_CHARS(enc, ptr, end, 1) | | ------------------ | | | | 134| 625| { \ | | | | 135| 625| if (! HAS_CHARS(enc, ptr, end, count)) { \ | | | | ------------------ | | | | | | 129| 625| ((end) - (ptr) >= ((count) * MINBPC(enc))) | | | | | | ------------------ | | | | | | | | 228| 625|#define MINBPC(enc) 1 | | | | | | ------------------ | | | | ------------------ | | | | | Branch (135:11): [True: 0, False: 625] | | | | ------------------ | | | | 136| 0| return XML_TOK_PARTIAL; \ | | | | ------------------ | | | | | | 56| 0|# define XML_TOK_PARTIAL -1 /* only part of a token */ | | | | ------------------ | | | | 137| 0| } \ | | | | 138| 625| } | | ------------------ ------------------ 385| 625| if (BYTE_TYPE(enc, ptr) == BT_LF) ------------------ | | 233| 625|#define BYTE_TYPE(enc, p) SB_BYTE_TYPE(enc, p) | | ------------------ | | | | 231| 625| (((const struct normal_encoding *)(enc))->type[(unsigned char)*(p)]) | | ------------------ ------------------ | Branch (385:9): [True: 194, False: 431] ------------------ 386| 194| ptr += MINBPC(enc); ------------------ | | 228| 194|#define MINBPC(enc) 1 ------------------ 387| 625| *nextTokPtr = ptr; 388| 625| return XML_TOK_DATA_NEWLINE; ------------------ | | 68| 625|# define XML_TOK_DATA_NEWLINE 7 ------------------ 389| 536| case BT_LF: ------------------ | Branch (389:3): [True: 536, False: 4.20k] ------------------ 390| 536| *nextTokPtr = ptr + MINBPC(enc); ------------------ | | 228| 536|#define MINBPC(enc) 1 ------------------ 391| 536| return XML_TOK_DATA_NEWLINE; ------------------ | | 68| 536|# define XML_TOK_DATA_NEWLINE 7 ------------------ 392| 1.29k| INVALID_CASES(ptr, nextTokPtr) ------------------ | | 60| 245| INVALID_LEAD_CASE(2, ptr, nextTokPtr) \ | | ------------------ | | | | 49| 245| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (49:3): [True: 245, False: 4.49k] | | | | ------------------ | | | | 50| 245| if (end - ptr < n) \ | | | | ------------------ | | | | | Branch (50:9): [True: 0, False: 245] | | | | ------------------ | | | | 51| 244| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 0|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 52| 245| if (IS_INVALID_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 240| 245| (AS_NORMAL_ENCODING(enc)->isInvalid##n(enc, p)) | | | | | | ------------------ | | | | | | | | 207| 245|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | | | ------------------ | | | | | | | Branch (240:3): [True: 1, False: 244] | | | | | | ------------------ | | | | ------------------ | | | | 53| 1| *(nextTokPtr) = (ptr); \ | | | | 54| 1| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 1|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 55| 1| } \ | | | | 56| 245| ptr += n; \ | | | | 57| 244| break; | | ------------------ | | 61| 244| INVALID_LEAD_CASE(3, ptr, nextTokPtr) \ | | ------------------ | | | | 49| 202| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (49:3): [True: 202, False: 4.54k] | | | | ------------------ | | | | 50| 202| if (end - ptr < n) \ | | | | ------------------ | | | | | Branch (50:9): [True: 0, False: 202] | | | | ------------------ | | | | 51| 194| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 0|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 52| 202| if (IS_INVALID_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 240| 202| (AS_NORMAL_ENCODING(enc)->isInvalid##n(enc, p)) | | | | | | ------------------ | | | | | | | | 207| 202|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | | | ------------------ | | | | | | | Branch (240:3): [True: 8, False: 194] | | | | | | ------------------ | | | | ------------------ | | | | 53| 8| *(nextTokPtr) = (ptr); \ | | | | 54| 8| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 8|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 55| 8| } \ | | | | 56| 202| ptr += n; \ | | | | 57| 194| break; | | ------------------ | | 62| 198| INVALID_LEAD_CASE(4, ptr, nextTokPtr) \ | | ------------------ | | | | 49| 198| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (49:3): [True: 198, False: 4.54k] | | | | ------------------ | | | | 50| 198| if (end - ptr < n) \ | | | | ------------------ | | | | | Branch (50:9): [True: 1, False: 197] | | | | ------------------ | | | | 51| 194| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 1|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 52| 197| if (IS_INVALID_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 240| 197| (AS_NORMAL_ENCODING(enc)->isInvalid##n(enc, p)) | | | | | | ------------------ | | | | | | | | 207| 197|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | | | ------------------ | | | | | | | Branch (240:3): [True: 3, False: 194] | | | | | | ------------------ | | | | ------------------ | | | | 53| 3| *(nextTokPtr) = (ptr); \ | | | | 54| 3| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 3|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 55| 3| } \ | | | | 56| 197| ptr += n; \ | | | | 57| 194| break; | | ------------------ | | 63| 194| case BT_NONXML: \ | | ------------------ | | | Branch (63:3): [True: 3, False: 4.73k] | | ------------------ | | 64| 5| case BT_MALFORM: \ | | ------------------ | | | Branch (64:3): [True: 2, False: 4.74k] | | ------------------ | | 65| 9| case BT_TRAIL: \ | | ------------------ | | | Branch (65:3): [True: 4, False: 4.73k] | | ------------------ | | 66| 9| *(nextTokPtr) = (ptr); \ | | 67| 9| return XML_TOK_INVALID; | | ------------------ | | | | 57| 9|# define XML_TOK_INVALID 0 | | ------------------ ------------------ 393| 761| default: ------------------ | Branch (393:3): [True: 761, False: 3.98k] ------------------ 394| 761| ptr += MINBPC(enc); ------------------ | | 228| 761|#define MINBPC(enc) 1 ------------------ 395| 761| break; 396| 4.74k| } 397| 9.57k| while (HAS_CHAR(enc, ptr, end)) { 398| 9.57k| switch (BYTE_TYPE(enc, ptr)) { ------------------ | | 233| 9.57k|#define BYTE_TYPE(enc, p) SB_BYTE_TYPE(enc, p) | | ------------------ | | | | 231| 9.57k| (((const struct normal_encoding *)(enc))->type[(unsigned char)*(p)]) | | ------------------ ------------------ 399| 0|# define LEAD_CASE(n) \ 400| 0| case BT_LEAD##n: \ 401| 0| if (end - ptr < n || IS_INVALID_CHAR(enc, ptr, n)) { \ 402| 0| *nextTokPtr = ptr; \ 403| 0| return XML_TOK_DATA_CHARS; \ 404| 0| } \ 405| 0| ptr += n; \ 406| 0| break; 407| 327| LEAD_CASE(2) ------------------ | | 400| 327| case BT_LEAD##n: \ | | ------------------ | | | Branch (400:3): [True: 327, False: 9.25k] | | ------------------ | | 401| 327| if (end - ptr < n || IS_INVALID_CHAR(enc, ptr, n)) { \ | | ------------------ | | | | 240| 327| (AS_NORMAL_ENCODING(enc)->isInvalid##n(enc, p)) | | | | ------------------ | | | | | | 207| 327|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | ------------------ | | | | | Branch (240:3): [True: 1, False: 326] | | | | ------------------ | | ------------------ | | | Branch (401:9): [True: 0, False: 327] | | ------------------ | | 402| 1| *nextTokPtr = ptr; \ | | 403| 1| return XML_TOK_DATA_CHARS; \ | | ------------------ | | | | 67| 1|# define XML_TOK_DATA_CHARS 6 | | ------------------ | | 404| 1| } \ | | 405| 326| ptr += n; \ | | 406| 326| break; ------------------ 408| 206| LEAD_CASE(3) ------------------ | | 400| 206| case BT_LEAD##n: \ | | ------------------ | | | Branch (400:3): [True: 206, False: 9.37k] | | ------------------ | | 401| 206| if (end - ptr < n || IS_INVALID_CHAR(enc, ptr, n)) { \ | | ------------------ | | | | 240| 206| (AS_NORMAL_ENCODING(enc)->isInvalid##n(enc, p)) | | | | ------------------ | | | | | | 207| 206|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | ------------------ | | | | | Branch (240:3): [True: 6, False: 200] | | | | ------------------ | | ------------------ | | | Branch (401:9): [True: 0, False: 206] | | ------------------ | | 402| 6| *nextTokPtr = ptr; \ | | 403| 6| return XML_TOK_DATA_CHARS; \ | | ------------------ | | | | 67| 6|# define XML_TOK_DATA_CHARS 6 | | ------------------ | | 404| 6| } \ | | 405| 200| ptr += n; \ | | 406| 200| break; ------------------ 409| 198| LEAD_CASE(4) ------------------ | | 400| 198| case BT_LEAD##n: \ | | ------------------ | | | Branch (400:3): [True: 198, False: 9.38k] | | ------------------ | | 401| 198| if (end - ptr < n || IS_INVALID_CHAR(enc, ptr, n)) { \ | | ------------------ | | | | 240| 197| (AS_NORMAL_ENCODING(enc)->isInvalid##n(enc, p)) | | | | ------------------ | | | | | | 207| 197|#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc)) | | | | ------------------ | | | | | Branch (240:3): [True: 3, False: 194] | | | | ------------------ | | ------------------ | | | Branch (401:9): [True: 1, False: 197] | | ------------------ | | 402| 4| *nextTokPtr = ptr; \ | | 403| 4| return XML_TOK_DATA_CHARS; \ | | ------------------ | | | | 67| 4|# define XML_TOK_DATA_CHARS 6 | | ------------------ | | 404| 4| } \ | | 405| 194| ptr += n; \ | | 406| 194| break; ------------------ 410| 0|# undef LEAD_CASE 411| 2| case BT_NONXML: ------------------ | Branch (411:5): [True: 2, False: 9.57k] ------------------ 412| 3| case BT_MALFORM: ------------------ | Branch (412:5): [True: 1, False: 9.57k] ------------------ 413| 5| case BT_TRAIL: ------------------ | Branch (413:5): [True: 2, False: 9.57k] ------------------ 414| 238| case BT_CR: ------------------ | Branch (414:5): [True: 233, False: 9.34k] ------------------ 415| 710| case BT_LF: ------------------ | Branch (415:5): [True: 472, False: 9.10k] ------------------ 416| 2.49k| case BT_RSQB: ------------------ | Branch (416:5): [True: 1.78k, False: 7.79k] ------------------ 417| 2.49k| *nextTokPtr = ptr; 418| 2.49k| return XML_TOK_DATA_CHARS; ------------------ | | 67| 2.49k|# define XML_TOK_DATA_CHARS 6 ------------------ 419| 6.35k| default: ------------------ | Branch (419:5): [True: 6.35k, False: 3.22k] ------------------ 420| 6.35k| ptr += MINBPC(enc); ------------------ | | 228| 6.35k|#define MINBPC(enc) 1 ------------------ 421| 6.35k| break; 422| 9.57k| } 423| 9.57k| } 424| 129| *nextTokPtr = ptr; 425| 129| return XML_TOK_DATA_CHARS; ------------------ | | 67| 129|# define XML_TOK_DATA_CHARS 6 ------------------ 426| 2.63k|} xmltok.c:normal_attributeValueTok: 1262| 16.5M| const char **nextTokPtr) { 1263| 16.5M| const char *start; 1264| 16.5M| if (ptr >= end) ------------------ | Branch (1264:7): [True: 590k, False: 15.9M] ------------------ 1265| 590k| return XML_TOK_NONE; ------------------ | | 51| 590k|# define XML_TOK_NONE -4 /* The string to be scanned is empty */ ------------------ 1266| 15.9M| else if (! HAS_CHAR(enc, ptr, end)) { ------------------ | | 131| 15.9M|# define HAS_CHAR(enc, ptr, end) HAS_CHARS(enc, ptr, end, 1) | | ------------------ | | | | 129| 15.9M| ((end) - (ptr) >= ((count) * MINBPC(enc))) | | | | ------------------ | | | | | | 228| 15.9M|#define MINBPC(enc) 1 | | | | ------------------ | | ------------------ ------------------ | Branch (1266:12): [True: 0, False: 15.9M] ------------------ 1267| | /* This line cannot be executed. The incoming data has already 1268| | * been tokenized once, so incomplete characters like this have 1269| | * already been eliminated from the input. Retaining the paranoia 1270| | * check is still valuable, however. 1271| | */ 1272| 0| return XML_TOK_PARTIAL; /* LCOV_EXCL_LINE */ ------------------ | | 56| 0|# define XML_TOK_PARTIAL -1 /* only part of a token */ ------------------ 1273| 0| } 1274| 15.9M| start = ptr; 1275| 106M| while (HAS_CHAR(enc, ptr, end)) { 1276| 106M| switch (BYTE_TYPE(enc, ptr)) { ------------------ | | 233| 106M|#define BYTE_TYPE(enc, p) SB_BYTE_TYPE(enc, p) | | ------------------ | | | | 231| 106M| (((const struct normal_encoding *)(enc))->type[(unsigned char)*(p)]) | | ------------------ ------------------ 1277| 0|# define LEAD_CASE(n) \ 1278| 0| case BT_LEAD##n: \ 1279| 0| ptr += n; /* NOTE: The encoding has already been validated. */ \ 1280| 0| break; 1281| 259k| LEAD_CASE(2) ------------------ | | 1278| 259k| case BT_LEAD##n: \ | | ------------------ | | | Branch (1278:3): [True: 259k, False: 106M] | | ------------------ | | 1279| 259k| ptr += n; /* NOTE: The encoding has already been validated. */ \ | | 1280| 259k| break; ------------------ 1282| 1.52k| LEAD_CASE(3) ------------------ | | 1278| 1.52k| case BT_LEAD##n: \ | | ------------------ | | | Branch (1278:3): [True: 1.52k, False: 106M] | | ------------------ | | 1279| 1.52k| ptr += n; /* NOTE: The encoding has already been validated. */ \ | | 1280| 1.52k| break; ------------------ 1283| 2.25k| LEAD_CASE(4) ------------------ | | 1278| 2.25k| case BT_LEAD##n: \ | | ------------------ | | | Branch (1278:3): [True: 2.25k, False: 106M] | | ------------------ | | 1279| 2.25k| ptr += n; /* NOTE: The encoding has already been validated. */ \ | | 1280| 2.25k| break; ------------------ 1284| 0|# undef LEAD_CASE 1285| 773k| case BT_AMP: ------------------ | Branch (1285:5): [True: 773k, False: 105M] ------------------ 1286| 773k| if (ptr == start) ------------------ | Branch (1286:11): [True: 630k, False: 143k] ------------------ 1287| 630k| return PREFIX(scanRef)(enc, ptr + MINBPC(enc), end, nextTokPtr); ------------------ | | 248| 630k|#define PREFIX(ident) normal_##ident ------------------ return PREFIX(scanRef)(enc, ptr + MINBPC(enc), end, nextTokPtr); ------------------ | | 228| 630k|#define MINBPC(enc) 1 ------------------ 1288| 143k| *nextTokPtr = ptr; 1289| 143k| return XML_TOK_DATA_CHARS; ------------------ | | 67| 143k|# define XML_TOK_DATA_CHARS 6 ------------------ 1290| 10| case BT_LT: ------------------ | Branch (1290:5): [True: 10, False: 106M] ------------------ 1291| | /* this is for inside entity references */ 1292| 10| *nextTokPtr = ptr; 1293| 10| return XML_TOK_INVALID; ------------------ | | 57| 10|# define XML_TOK_INVALID 0 ------------------ 1294| 52.2k| case BT_LF: ------------------ | Branch (1294:5): [True: 52.2k, False: 106M] ------------------ 1295| 52.2k| if (ptr == start) { ------------------ | Branch (1295:11): [True: 26.2k, False: 25.9k] ------------------ 1296| 26.2k| *nextTokPtr = ptr + MINBPC(enc); ------------------ | | 228| 26.2k|#define MINBPC(enc) 1 ------------------ 1297| 26.2k| return XML_TOK_DATA_NEWLINE; ------------------ | | 68| 26.2k|# define XML_TOK_DATA_NEWLINE 7 ------------------ 1298| 26.2k| } 1299| 25.9k| *nextTokPtr = ptr; 1300| 25.9k| return XML_TOK_DATA_CHARS; ------------------ | | 67| 25.9k|# define XML_TOK_DATA_CHARS 6 ------------------ 1301| 920| case BT_CR: ------------------ | Branch (1301:5): [True: 920, False: 106M] ------------------ 1302| 920| if (ptr == start) { ------------------ | Branch (1302:11): [True: 695, False: 225] ------------------ 1303| 695| ptr += MINBPC(enc); ------------------ | | 228| 695|#define MINBPC(enc) 1 ------------------ 1304| 695| if (! HAS_CHAR(enc, ptr, end)) ------------------ | | 131| 695|# define HAS_CHAR(enc, ptr, end) HAS_CHARS(enc, ptr, end, 1) | | ------------------ | | | | 129| 695| ((end) - (ptr) >= ((count) * MINBPC(enc))) | | | | ------------------ | | | | | | 228| 695|#define MINBPC(enc) 1 | | | | ------------------ | | ------------------ ------------------ | Branch (1304:13): [True: 81, False: 614] ------------------ 1305| 81| return XML_TOK_TRAILING_CR; ------------------ | | 53| 81| -3 /* A CR at the end of the scan; \ ------------------ 1306| 614| if (BYTE_TYPE(enc, ptr) == BT_LF) ------------------ | | 233| 614|#define BYTE_TYPE(enc, p) SB_BYTE_TYPE(enc, p) | | ------------------ | | | | 231| 614| (((const struct normal_encoding *)(enc))->type[(unsigned char)*(p)]) | | ------------------ ------------------ | Branch (1306:13): [True: 195, False: 419] ------------------ 1307| 195| ptr += MINBPC(enc); ------------------ | | 228| 195|#define MINBPC(enc) 1 ------------------ 1308| 614| *nextTokPtr = ptr; 1309| 614| return XML_TOK_DATA_NEWLINE; ------------------ | | 68| 614|# define XML_TOK_DATA_NEWLINE 7 ------------------ 1310| 695| } 1311| 225| *nextTokPtr = ptr; 1312| 225| return XML_TOK_DATA_CHARS; ------------------ | | 67| 225|# define XML_TOK_DATA_CHARS 6 ------------------ 1313| 14.5M| case BT_S: ------------------ | Branch (1313:5): [True: 14.5M, False: 91.9M] ------------------ 1314| 14.5M| if (ptr == start) { ------------------ | Branch (1314:11): [True: 11.8M, False: 2.62M] ------------------ 1315| 11.8M| *nextTokPtr = ptr + MINBPC(enc); ------------------ | | 228| 11.8M|#define MINBPC(enc) 1 ------------------ 1316| 11.8M| return XML_TOK_ATTRIBUTE_VALUE_S; ------------------ | | 110| 11.8M|# define XML_TOK_ATTRIBUTE_VALUE_S 39 ------------------ 1317| 11.8M| } 1318| 2.62M| *nextTokPtr = ptr; 1319| 2.62M| return XML_TOK_DATA_CHARS; ------------------ | | 67| 2.62M|# define XML_TOK_DATA_CHARS 6 ------------------ 1320| 90.9M| default: ------------------ | Branch (1320:5): [True: 90.9M, False: 15.6M] ------------------ 1321| 90.9M| ptr += MINBPC(enc); ------------------ | | 228| 90.9M|#define MINBPC(enc) 1 ------------------ 1322| 90.9M| break; 1323| 106M| } 1324| 106M| } 1325| 582k| *nextTokPtr = ptr; 1326| 582k| return XML_TOK_DATA_CHARS; ------------------ | | 67| 582k|# define XML_TOK_DATA_CHARS 6 ------------------ 1327| 15.9M|} xmltok.c:normal_entityValueTok: 1331| 26.9k| const char **nextTokPtr) { 1332| 26.9k| const char *start; 1333| 26.9k| if (ptr >= end) ------------------ | Branch (1333:7): [True: 2.51k, False: 24.4k] ------------------ 1334| 2.51k| return XML_TOK_NONE; ------------------ | | 51| 2.51k|# define XML_TOK_NONE -4 /* The string to be scanned is empty */ ------------------ 1335| 24.4k| else if (! HAS_CHAR(enc, ptr, end)) { ------------------ | | 131| 24.4k|# define HAS_CHAR(enc, ptr, end) HAS_CHARS(enc, ptr, end, 1) | | ------------------ | | | | 129| 24.4k| ((end) - (ptr) >= ((count) * MINBPC(enc))) | | | | ------------------ | | | | | | 228| 24.4k|#define MINBPC(enc) 1 | | | | ------------------ | | ------------------ ------------------ | Branch (1335:12): [True: 0, False: 24.4k] ------------------ 1336| | /* This line cannot be executed. The incoming data has already 1337| | * been tokenized once, so incomplete characters like this have 1338| | * already been eliminated from the input. Retaining the paranoia 1339| | * check is still valuable, however. 1340| | */ 1341| 0| return XML_TOK_PARTIAL; /* LCOV_EXCL_LINE */ ------------------ | | 56| 0|# define XML_TOK_PARTIAL -1 /* only part of a token */ ------------------ 1342| 0| } 1343| 24.4k| start = ptr; 1344| 122k| while (HAS_CHAR(enc, ptr, end)) { 1345| 122k| switch (BYTE_TYPE(enc, ptr)) { ------------------ | | 233| 122k|#define BYTE_TYPE(enc, p) SB_BYTE_TYPE(enc, p) | | ------------------ | | | | 231| 122k| (((const struct normal_encoding *)(enc))->type[(unsigned char)*(p)]) | | ------------------ ------------------ 1346| 0|# define LEAD_CASE(n) \ 1347| 0| case BT_LEAD##n: \ 1348| 0| ptr += n; /* NOTE: The encoding has already been validated. */ \ 1349| 0| break; 1350| 196| LEAD_CASE(2) ------------------ | | 1347| 196| case BT_LEAD##n: \ | | ------------------ | | | Branch (1347:3): [True: 196, False: 122k] | | ------------------ | | 1348| 196| ptr += n; /* NOTE: The encoding has already been validated. */ \ | | 1349| 196| break; ------------------ 1351| 208| LEAD_CASE(3) ------------------ | | 1347| 208| case BT_LEAD##n: \ | | ------------------ | | | Branch (1347:3): [True: 208, False: 122k] | | ------------------ | | 1348| 208| ptr += n; /* NOTE: The encoding has already been validated. */ \ | | 1349| 208| break; ------------------ 1352| 75| LEAD_CASE(4) ------------------ | | 1347| 75| case BT_LEAD##n: \ | | ------------------ | | | Branch (1347:3): [True: 75, False: 122k] | | ------------------ | | 1348| 75| ptr += n; /* NOTE: The encoding has already been validated. */ \ | | 1349| 75| break; ------------------ 1353| 0|# undef LEAD_CASE 1354| 19.9k| case BT_AMP: ------------------ | Branch (1354:5): [True: 19.9k, False: 102k] ------------------ 1355| 19.9k| if (ptr == start) ------------------ | Branch (1355:11): [True: 17.1k, False: 2.86k] ------------------ 1356| 17.1k| return PREFIX(scanRef)(enc, ptr + MINBPC(enc), end, nextTokPtr); ------------------ | | 248| 17.1k|#define PREFIX(ident) normal_##ident ------------------ return PREFIX(scanRef)(enc, ptr + MINBPC(enc), end, nextTokPtr); ------------------ | | 228| 17.1k|#define MINBPC(enc) 1 ------------------ 1357| 2.86k| *nextTokPtr = ptr; 1358| 2.86k| return XML_TOK_DATA_CHARS; ------------------ | | 67| 2.86k|# define XML_TOK_DATA_CHARS 6 ------------------ 1359| 9| case BT_PERCNT: ------------------ | Branch (1359:5): [True: 9, False: 122k] ------------------ 1360| 9| if (ptr == start) { ------------------ | Branch (1360:11): [True: 6, False: 3] ------------------ 1361| 6| int tok = PREFIX(scanPercent)(enc, ptr + MINBPC(enc), end, nextTokPtr); ------------------ | | 248| 6|#define PREFIX(ident) normal_##ident ------------------ int tok = PREFIX(scanPercent)(enc, ptr + MINBPC(enc), end, nextTokPtr); ------------------ | | 228| 6|#define MINBPC(enc) 1 ------------------ 1362| 6| return (tok == XML_TOK_PERCENT) ? XML_TOK_INVALID : tok; ------------------ | | 89| 6|# define XML_TOK_PERCENT 22 ------------------ return (tok == XML_TOK_PERCENT) ? XML_TOK_INVALID : tok; ------------------ | | 57| 1|# define XML_TOK_INVALID 0 ------------------ | Branch (1362:16): [True: 1, False: 5] ------------------ 1363| 6| } 1364| 3| *nextTokPtr = ptr; 1365| 3| return XML_TOK_DATA_CHARS; ------------------ | | 67| 3|# define XML_TOK_DATA_CHARS 6 ------------------ 1366| 812| case BT_LF: ------------------ | Branch (1366:5): [True: 812, False: 121k] ------------------ 1367| 812| if (ptr == start) { ------------------ | Branch (1367:11): [True: 534, False: 278] ------------------ 1368| 534| *nextTokPtr = ptr + MINBPC(enc); ------------------ | | 228| 534|#define MINBPC(enc) 1 ------------------ 1369| 534| return XML_TOK_DATA_NEWLINE; ------------------ | | 68| 534|# define XML_TOK_DATA_NEWLINE 7 ------------------ 1370| 534| } 1371| 278| *nextTokPtr = ptr; 1372| 278| return XML_TOK_DATA_CHARS; ------------------ | | 67| 278|# define XML_TOK_DATA_CHARS 6 ------------------ 1373| 2.13k| case BT_CR: ------------------ | Branch (1373:5): [True: 2.13k, False: 120k] ------------------ 1374| 2.13k| if (ptr == start) { ------------------ | Branch (1374:11): [True: 1.71k, False: 419] ------------------ 1375| 1.71k| ptr += MINBPC(enc); ------------------ | | 228| 1.71k|#define MINBPC(enc) 1 ------------------ 1376| 1.71k| if (! HAS_CHAR(enc, ptr, end)) ------------------ | | 131| 1.71k|# define HAS_CHAR(enc, ptr, end) HAS_CHARS(enc, ptr, end, 1) | | ------------------ | | | | 129| 1.71k| ((end) - (ptr) >= ((count) * MINBPC(enc))) | | | | ------------------ | | | | | | 228| 1.71k|#define MINBPC(enc) 1 | | | | ------------------ | | ------------------ ------------------ | Branch (1376:13): [True: 73, False: 1.64k] ------------------ 1377| 73| return XML_TOK_TRAILING_CR; ------------------ | | 53| 73| -3 /* A CR at the end of the scan; \ ------------------ 1378| 1.64k| if (BYTE_TYPE(enc, ptr) == BT_LF) ------------------ | | 233| 1.64k|#define BYTE_TYPE(enc, p) SB_BYTE_TYPE(enc, p) | | ------------------ | | | | 231| 1.64k| (((const struct normal_encoding *)(enc))->type[(unsigned char)*(p)]) | | ------------------ ------------------ | Branch (1378:13): [True: 194, False: 1.45k] ------------------ 1379| 194| ptr += MINBPC(enc); ------------------ | | 228| 194|#define MINBPC(enc) 1 ------------------ 1380| 1.64k| *nextTokPtr = ptr; 1381| 1.64k| return XML_TOK_DATA_NEWLINE; ------------------ | | 68| 1.64k|# define XML_TOK_DATA_NEWLINE 7 ------------------ 1382| 1.71k| } 1383| 419| *nextTokPtr = ptr; 1384| 419| return XML_TOK_DATA_CHARS; ------------------ | | 67| 419|# define XML_TOK_DATA_CHARS 6 ------------------ 1385| 99.3k| default: ------------------ | Branch (1385:5): [True: 99.3k, False: 23.4k] ------------------ 1386| 99.3k| ptr += MINBPC(enc); ------------------ | | 228| 99.3k|#define MINBPC(enc) 1 ------------------ 1387| 99.3k| break; 1388| 122k| } 1389| 122k| } 1390| 1.52k| *nextTokPtr = ptr; 1391| 1.52k| return XML_TOK_DATA_CHARS; ------------------ | | 67| 1.52k|# define XML_TOK_DATA_CHARS 6 ------------------ 1392| 24.4k|} xmltok.c:normal_nameMatchesAscii: 1715| 38.2k| const char *end1, const char *ptr2) { 1716| 38.2k| UNUSED_P(enc); ------------------ | | 101| 38.2k|# define UNUSED_P(p) (void)p ------------------ 1717| 187k| for (; *ptr2; ptr1 += MINBPC(enc), ptr2++) { ------------------ | | 228| 149k|#define MINBPC(enc) 1 ------------------ | Branch (1717:10): [True: 163k, False: 23.9k] ------------------ 1718| 163k| if (end1 - ptr1 < MINBPC(enc)) { ------------------ | | 228| 163k|#define MINBPC(enc) 1 ------------------ | Branch (1718:9): [True: 26, False: 163k] ------------------ 1719| | /* This line cannot be executed. The incoming data has already 1720| | * been tokenized once, so incomplete characters like this have 1721| | * already been eliminated from the input. Retaining the 1722| | * paranoia check is still valuable, however. 1723| | */ 1724| 26| return 0; /* LCOV_EXCL_LINE */ 1725| 26| } 1726| 163k| if (! CHAR_MATCHES(enc, ptr1, *ptr2)) ------------------ | | 246| 163k|#define CHAR_MATCHES(enc, p, c) (*(p) == (c)) ------------------ | Branch (1726:9): [True: 14.2k, False: 149k] ------------------ 1727| 14.2k| return 0; 1728| 163k| } 1729| 23.9k| return ptr1 == end1; 1730| 38.2k|} xmltok.c:normal_nameLength: 1733| 92.6k|PREFIX(nameLength)(const ENCODING *enc, const char *ptr) { 1734| 92.6k| const char *start = ptr; 1735| 335k| for (;;) { 1736| 335k| switch (BYTE_TYPE(enc, ptr)) { ------------------ | | 233| 335k|#define BYTE_TYPE(enc, p) SB_BYTE_TYPE(enc, p) | | ------------------ | | | | 231| 335k| (((const struct normal_encoding *)(enc))->type[(unsigned char)*(p)]) | | ------------------ ------------------ 1737| 0|# define LEAD_CASE(n) \ 1738| 0| case BT_LEAD##n: \ 1739| 0| ptr += n; /* NOTE: The encoding has already been validated. */ \ 1740| 0| break; 1741| 27.3k| LEAD_CASE(2) ------------------ | | 1738| 27.3k| case BT_LEAD##n: \ | | ------------------ | | | Branch (1738:3): [True: 27.3k, False: 308k] | | ------------------ | | 1739| 27.3k| ptr += n; /* NOTE: The encoding has already been validated. */ \ | | 1740| 27.3k| break; ------------------ 1742| 1.63k| LEAD_CASE(3) ------------------ | | 1738| 1.63k| case BT_LEAD##n: \ | | ------------------ | | | Branch (1738:3): [True: 1.63k, False: 333k] | | ------------------ | | 1739| 1.63k| ptr += n; /* NOTE: The encoding has already been validated. */ \ | | 1740| 1.63k| break; ------------------ 1743| 0| LEAD_CASE(4) ------------------ | | 1738| 0| case BT_LEAD##n: \ | | ------------------ | | | Branch (1738:3): [True: 0, False: 335k] | | ------------------ | | 1739| 0| ptr += n; /* NOTE: The encoding has already been validated. */ \ | | 1740| 0| break; ------------------ 1744| 0|# undef LEAD_CASE 1745| 0| case BT_NONASCII: ------------------ | Branch (1745:5): [True: 0, False: 335k] ------------------ 1746| 160k| case BT_NMSTRT: ------------------ | Branch (1746:5): [True: 160k, False: 174k] ------------------ 1747| 160k|# ifdef XML_NS 1748| 181k| case BT_COLON: ------------------ | Branch (1748:5): [True: 20.4k, False: 315k] ------------------ 1749| 181k|# endif 1750| 208k| case BT_HEX: ------------------ | Branch (1750:5): [True: 26.8k, False: 308k] ------------------ 1751| 211k| case BT_DIGIT: ------------------ | Branch (1751:5): [True: 3.29k, False: 332k] ------------------ 1752| 212k| case BT_NAME: ------------------ | Branch (1752:5): [True: 1.32k, False: 334k] ------------------ 1753| 213k| case BT_MINUS: ------------------ | Branch (1753:5): [True: 1.10k, False: 334k] ------------------ 1754| 213k| ptr += MINBPC(enc); ------------------ | | 228| 213k|#define MINBPC(enc) 1 ------------------ 1755| 213k| break; 1756| 92.6k| default: ------------------ | Branch (1756:5): [True: 92.6k, False: 242k] ------------------ 1757| 92.6k| return (int)(ptr - start); 1758| 335k| } 1759| 335k| } 1760| 92.6k|} xmltok.c:normal_getAtts: 1510| 55.2k| ATTRIBUTE *atts) { 1511| 55.2k| enum { other, inName, inValue } state = inName; 1512| 55.2k| int nAtts = 0; 1513| 55.2k| int open = 0; /* defined when state == inValue; 1514| | initialization just to shut up compilers */ 1515| | 1516| 558k| for (ptr += MINBPC(enc);; ptr += MINBPC(enc)) { ------------------ | | 228| 55.2k|#define MINBPC(enc) 1 ------------------ for (ptr += MINBPC(enc);; ptr += MINBPC(enc)) { ------------------ | | 228| 503k|#define MINBPC(enc) 1 ------------------ 1517| 558k| switch (BYTE_TYPE(enc, ptr)) { ------------------ | | 233| 558k|#define BYTE_TYPE(enc, p) SB_BYTE_TYPE(enc, p) | | ------------------ | | | | 231| 558k| (((const struct normal_encoding *)(enc))->type[(unsigned char)*(p)]) | | ------------------ ------------------ 1518| 0|# define START_NAME \ 1519| 0| if (state == other) { \ 1520| 0| if (nAtts < attsMax) { \ 1521| 0| atts[nAtts].name = ptr; \ 1522| 0| atts[nAtts].normalized = 1; \ 1523| 0| } \ 1524| 0| state = inName; \ 1525| 0| } 1526| 0|# define LEAD_CASE(n) \ 1527| 0| case BT_LEAD##n: /* NOTE: The encoding has already been validated. */ \ 1528| 0| START_NAME ptr += (n - MINBPC(enc)); \ 1529| 0| break; 1530| 27.3k| LEAD_CASE(2) ------------------ | | 1527| 27.3k| case BT_LEAD##n: /* NOTE: The encoding has already been validated. */ \ | | ------------------ | | | Branch (1527:3): [True: 27.3k, False: 531k] | | ------------------ | | 1528| 27.3k| START_NAME ptr += (n - MINBPC(enc)); \ | | ------------------ | | | | 1519| 27.3k| if (state == other) { \ | | | | ------------------ | | | | | Branch (1519:9): [True: 755, False: 26.5k] | | | | ------------------ | | | | 1520| 755| if (nAtts < attsMax) { \ | | | | ------------------ | | | | | Branch (1520:11): [True: 686, False: 69] | | | | ------------------ | | | | 1521| 686| atts[nAtts].name = ptr; \ | | | | 1522| 686| atts[nAtts].normalized = 1; \ | | | | 1523| 686| } \ | | | | 1524| 755| state = inName; \ | | | | 1525| 755| } | | ------------------ | | START_NAME ptr += (n - MINBPC(enc)); \ | | ------------------ | | | | 228| 27.3k|#define MINBPC(enc) 1 | | ------------------ | | 1529| 27.3k| break; ------------------ 1531| 1.84k| LEAD_CASE(3) ------------------ | | 1527| 1.84k| case BT_LEAD##n: /* NOTE: The encoding has already been validated. */ \ | | ------------------ | | | Branch (1527:3): [True: 1.84k, False: 557k] | | ------------------ | | 1528| 1.84k| START_NAME ptr += (n - MINBPC(enc)); \ | | ------------------ | | | | 1519| 1.84k| if (state == other) { \ | | | | ------------------ | | | | | Branch (1519:9): [True: 515, False: 1.32k] | | | | ------------------ | | | | 1520| 515| if (nAtts < attsMax) { \ | | | | ------------------ | | | | | Branch (1520:11): [True: 449, False: 66] | | | | ------------------ | | | | 1521| 449| atts[nAtts].name = ptr; \ | | | | 1522| 449| atts[nAtts].normalized = 1; \ | | | | 1523| 449| } \ | | | | 1524| 515| state = inName; \ | | | | 1525| 515| } | | ------------------ | | START_NAME ptr += (n - MINBPC(enc)); \ | | ------------------ | | | | 228| 1.84k|#define MINBPC(enc) 1 | | ------------------ | | 1529| 1.84k| break; ------------------ 1532| 207| LEAD_CASE(4) ------------------ | | 1527| 207| case BT_LEAD##n: /* NOTE: The encoding has already been validated. */ \ | | ------------------ | | | Branch (1527:3): [True: 207, False: 558k] | | ------------------ | | 1528| 207| START_NAME ptr += (n - MINBPC(enc)); \ | | ------------------ | | | | 1519| 207| if (state == other) { \ | | | | ------------------ | | | | | Branch (1519:9): [True: 0, False: 207] | | | | ------------------ | | | | 1520| 0| if (nAtts < attsMax) { \ | | | | ------------------ | | | | | Branch (1520:11): [True: 0, False: 0] | | | | ------------------ | | | | 1521| 0| atts[nAtts].name = ptr; \ | | | | 1522| 0| atts[nAtts].normalized = 1; \ | | | | 1523| 0| } \ | | | | 1524| 0| state = inName; \ | | | | 1525| 0| } | | ------------------ | | START_NAME ptr += (n - MINBPC(enc)); \ | | ------------------ | | | | 228| 207|#define MINBPC(enc) 1 | | ------------------ | | 1529| 207| break; ------------------ 1533| 0|# undef LEAD_CASE 1534| 0| case BT_NONASCII: ------------------ | Branch (1534:5): [True: 0, False: 558k] ------------------ 1535| 193k| case BT_NMSTRT: ------------------ | Branch (1535:5): [True: 193k, False: 365k] ------------------ 1536| 224k| case BT_HEX: ------------------ | Branch (1536:5): [True: 31.1k, False: 527k] ------------------ 1537| 224k| START_NAME ------------------ | | 1519| 224k| if (state == other) { \ | | ------------------ | | | Branch (1519:9): [True: 37.0k, False: 187k] | | ------------------ | | 1520| 37.0k| if (nAtts < attsMax) { \ | | ------------------ | | | Branch (1520:11): [True: 35.3k, False: 1.73k] | | ------------------ | | 1521| 35.3k| atts[nAtts].name = ptr; \ | | 1522| 35.3k| atts[nAtts].normalized = 1; \ | | 1523| 35.3k| } \ | | 1524| 37.0k| state = inName; \ | | 1525| 37.0k| } ------------------ 1538| 224k| break; 1539| 0|# undef START_NAME 1540| 73.3k| case BT_QUOT: ------------------ | Branch (1540:5): [True: 73.3k, False: 485k] ------------------ 1541| 73.3k| if (state != inValue) { ------------------ | Branch (1541:11): [True: 36.5k, False: 36.7k] ------------------ 1542| 36.5k| if (nAtts < attsMax) ------------------ | Branch (1542:13): [True: 34.9k, False: 1.62k] ------------------ 1543| 34.9k| atts[nAtts].valuePtr = ptr + MINBPC(enc); ------------------ | | 228| 34.9k|#define MINBPC(enc) 1 ------------------ 1544| 36.5k| state = inValue; 1545| 36.5k| open = BT_QUOT; 1546| 36.7k| } else if (open == BT_QUOT) { ------------------ | Branch (1546:18): [True: 36.5k, False: 201] ------------------ 1547| 36.5k| state = other; 1548| 36.5k| if (nAtts < attsMax) ------------------ | Branch (1548:13): [True: 34.9k, False: 1.62k] ------------------ 1549| 34.9k| atts[nAtts].valueEnd = ptr; 1550| 36.5k| nAtts++; 1551| 36.5k| } 1552| 73.3k| break; 1553| 3.86k| case BT_APOS: ------------------ | Branch (1553:5): [True: 3.86k, False: 555k] ------------------ 1554| 3.86k| if (state != inValue) { ------------------ | Branch (1554:11): [True: 1.81k, False: 2.05k] ------------------ 1555| 1.81k| if (nAtts < attsMax) ------------------ | Branch (1555:13): [True: 1.56k, False: 242] ------------------ 1556| 1.56k| atts[nAtts].valuePtr = ptr + MINBPC(enc); ------------------ | | 228| 1.56k|#define MINBPC(enc) 1 ------------------ 1557| 1.81k| state = inValue; 1558| 1.81k| open = BT_APOS; 1559| 2.05k| } else if (open == BT_APOS) { ------------------ | Branch (1559:18): [True: 1.81k, False: 241] ------------------ 1560| 1.81k| state = other; 1561| 1.81k| if (nAtts < attsMax) ------------------ | Branch (1561:13): [True: 1.56k, False: 242] ------------------ 1562| 1.56k| atts[nAtts].valueEnd = ptr; 1563| 1.81k| nAtts++; 1564| 1.81k| } 1565| 3.86k| break; 1566| 21.5k| case BT_AMP: ------------------ | Branch (1566:5): [True: 21.5k, False: 537k] ------------------ 1567| 21.5k| if (nAtts < attsMax) ------------------ | Branch (1567:11): [True: 21.3k, False: 267] ------------------ 1568| 21.3k| atts[nAtts].normalized = 0; 1569| 21.5k| break; 1570| 48.2k| case BT_S: ------------------ | Branch (1570:5): [True: 48.2k, False: 510k] ------------------ 1571| 48.2k| if (state == inName) ------------------ | Branch (1571:11): [True: 27.9k, False: 20.2k] ------------------ 1572| 27.9k| state = other; 1573| 20.2k| else if (state == inValue && nAtts < attsMax && atts[nAtts].normalized ------------------ | Branch (1573:16): [True: 7.91k, False: 12.3k] | Branch (1573:36): [True: 7.70k, False: 209] | Branch (1573:55): [True: 3.06k, False: 4.63k] ------------------ 1574| 3.06k| && (ptr == atts[nAtts].valuePtr ------------------ | Branch (1574:20): [True: 1.40k, False: 1.66k] ------------------ 1575| 1.66k| || BYTE_TO_ASCII(enc, ptr) != ASCII_SPACE ------------------ | | 235| 1.66k|#define BYTE_TO_ASCII(enc, p) (*(p)) ------------------ || BYTE_TO_ASCII(enc, ptr) != ASCII_SPACE ------------------ | | 104| 4.72k|#define ASCII_SPACE 0x20 ------------------ | Branch (1575:23): [True: 204, False: 1.45k] ------------------ 1576| 1.45k| || BYTE_TO_ASCII(enc, ptr + MINBPC(enc)) == ASCII_SPACE ------------------ | | 235| 1.45k|#define BYTE_TO_ASCII(enc, p) (*(p)) ------------------ || BYTE_TO_ASCII(enc, ptr + MINBPC(enc)) == ASCII_SPACE ------------------ | | 104| 4.52k|#define ASCII_SPACE 0x20 ------------------ | Branch (1576:23): [True: 691, False: 765] ------------------ 1577| 765| || BYTE_TYPE(enc, ptr + MINBPC(enc)) == open)) ------------------ | | 233| 765|#define BYTE_TYPE(enc, p) SB_BYTE_TYPE(enc, p) | | ------------------ | | | | 231| 765| (((const struct normal_encoding *)(enc))->type[(unsigned char)*(p)]) | | ------------------ ------------------ | Branch (1577:23): [True: 465, False: 300] ------------------ 1578| 2.76k| atts[nAtts].normalized = 0; 1579| 48.2k| break; 1580| 1.72k| case BT_CR: ------------------ | Branch (1580:5): [True: 1.72k, False: 557k] ------------------ 1581| 3.88k| case BT_LF: ------------------ | Branch (1581:5): [True: 2.16k, False: 556k] ------------------ 1582| | /* This case ensures that the first attribute name is counted 1583| | Apart from that we could just change state on the quote. */ 1584| 3.88k| if (state == inName) ------------------ | Branch (1584:11): [True: 803, False: 3.08k] ------------------ 1585| 803| state = other; 1586| 3.08k| else if (state == inValue && nAtts < attsMax) ------------------ | Branch (1586:16): [True: 1.24k, False: 1.84k] | Branch (1586:36): [True: 1.04k, False: 199] ------------------ 1587| 1.04k| atts[nAtts].normalized = 0; 1588| 3.88k| break; 1589| 30.6k| case BT_GT: ------------------ | Branch (1589:5): [True: 30.6k, False: 528k] ------------------ 1590| 56.8k| case BT_SOL: ------------------ | Branch (1590:5): [True: 26.2k, False: 532k] ------------------ 1591| 56.8k| if (state != inValue) ------------------ | Branch (1591:11): [True: 55.2k, False: 1.61k] ------------------ 1592| 55.2k| return nAtts; 1593| 1.61k| break; 1594| 96.9k| default: ------------------ | Branch (1594:5): [True: 96.9k, False: 461k] ------------------ 1595| 96.9k| break; 1596| 558k| } 1597| 558k| } 1598| | /* not reached */ 1599| 55.2k|} xmltok.c:normal_charRefNumber: 1602| 4.66k|PREFIX(charRefNumber)(const ENCODING *enc, const char *ptr) { 1603| 4.66k| int result = 0; 1604| | /* skip &# */ 1605| 4.66k| UNUSED_P(enc); ------------------ | | 101| 4.66k|# define UNUSED_P(p) (void)p ------------------ 1606| 4.66k| ptr += 2 * MINBPC(enc); ------------------ | | 228| 4.66k|#define MINBPC(enc) 1 ------------------ 1607| 4.66k| if (CHAR_MATCHES(enc, ptr, ASCII_x)) { ------------------ | | 246| 4.66k|#define CHAR_MATCHES(enc, p, c) (*(p) == (c)) | | ------------------ | | | Branch (246:33): [True: 3.72k, False: 940] | | ------------------ ------------------ 1608| 15.7k| for (ptr += MINBPC(enc); ! CHAR_MATCHES(enc, ptr, ASCII_SEMI); ------------------ | | 228| 3.72k|#define MINBPC(enc) 1 ------------------ for (ptr += MINBPC(enc); ! CHAR_MATCHES(enc, ptr, ASCII_SEMI); ------------------ | | 246| 15.7k|#define CHAR_MATCHES(enc, p, c) (*(p) == (c)) ------------------ | Branch (1608:30): [True: 12.0k, False: 3.70k] ------------------ 1609| 12.0k| ptr += MINBPC(enc)) { ------------------ | | 228| 12.0k|#define MINBPC(enc) 1 ------------------ 1610| 12.0k| int c = BYTE_TO_ASCII(enc, ptr); ------------------ | | 235| 12.0k|#define BYTE_TO_ASCII(enc, p) (*(p)) ------------------ 1611| 12.0k| switch (c) { ------------------ | Branch (1611:15): [True: 12.0k, False: 0] ------------------ 1612| 1.56k| case ASCII_0: ------------------ | | 92| 1.56k|#define ASCII_0 0x30 ------------------ | Branch (1612:7): [True: 1.56k, False: 10.4k] ------------------ 1613| 2.07k| case ASCII_1: ------------------ | | 93| 2.07k|#define ASCII_1 0x31 ------------------ | Branch (1613:7): [True: 511, False: 11.5k] ------------------ 1614| 3.24k| case ASCII_2: ------------------ | | 94| 3.24k|#define ASCII_2 0x32 ------------------ | Branch (1614:7): [True: 1.17k, False: 10.8k] ------------------ 1615| 3.70k| case ASCII_3: ------------------ | | 95| 3.70k|#define ASCII_3 0x33 ------------------ | Branch (1615:7): [True: 464, False: 11.5k] ------------------ 1616| 4.02k| case ASCII_4: ------------------ | | 96| 4.02k|#define ASCII_4 0x34 ------------------ | Branch (1616:7): [True: 311, False: 11.7k] ------------------ 1617| 4.33k| case ASCII_5: ------------------ | | 97| 4.33k|#define ASCII_5 0x35 ------------------ | Branch (1617:7): [True: 312, False: 11.7k] ------------------ 1618| 4.76k| case ASCII_6: ------------------ | | 98| 4.76k|#define ASCII_6 0x36 ------------------ | Branch (1618:7): [True: 433, False: 11.5k] ------------------ 1619| 5.17k| case ASCII_7: ------------------ | | 99| 5.17k|#define ASCII_7 0x37 ------------------ | Branch (1619:7): [True: 408, False: 11.6k] ------------------ 1620| 5.66k| case ASCII_8: ------------------ | | 100| 5.66k|#define ASCII_8 0x38 ------------------ | Branch (1620:7): [True: 495, False: 11.5k] ------------------ 1621| 6.33k| case ASCII_9: ------------------ | | 101| 6.33k|#define ASCII_9 0x39 ------------------ | Branch (1621:7): [True: 664, False: 11.3k] ------------------ 1622| 6.33k| result <<= 4; 1623| 6.33k| result |= (c - ASCII_0); ------------------ | | 92| 6.33k|#define ASCII_0 0x30 ------------------ 1624| 6.33k| break; 1625| 358| case ASCII_A: ------------------ | | 38| 358|#define ASCII_A 0x41 ------------------ | Branch (1625:7): [True: 358, False: 11.6k] ------------------ 1626| 729| case ASCII_B: ------------------ | | 39| 729|#define ASCII_B 0x42 ------------------ | Branch (1626:7): [True: 371, False: 11.6k] ------------------ 1627| 1.20k| case ASCII_C: ------------------ | | 40| 1.20k|#define ASCII_C 0x43 ------------------ | Branch (1627:7): [True: 477, False: 11.5k] ------------------ 1628| 1.51k| case ASCII_D: ------------------ | | 41| 1.51k|#define ASCII_D 0x44 ------------------ | Branch (1628:7): [True: 308, False: 11.7k] ------------------ 1629| 1.98k| case ASCII_E: ------------------ | | 42| 1.98k|#define ASCII_E 0x45 ------------------ | Branch (1629:7): [True: 469, False: 11.5k] ------------------ 1630| 3.04k| case ASCII_F: ------------------ | | 43| 3.04k|#define ASCII_F 0x46 ------------------ | Branch (1630:7): [True: 1.06k, False: 10.9k] ------------------ 1631| 3.04k| result <<= 4; 1632| 3.04k| result += 10 + (c - ASCII_A); ------------------ | | 38| 3.04k|#define ASCII_A 0x41 ------------------ 1633| 3.04k| break; 1634| 304| case ASCII_a: ------------------ | | 65| 304|#define ASCII_a 0x61 ------------------ | Branch (1634:7): [True: 304, False: 11.7k] ------------------ 1635| 558| case ASCII_b: ------------------ | | 66| 558|#define ASCII_b 0x62 ------------------ | Branch (1635:7): [True: 254, False: 11.7k] ------------------ 1636| 862| case ASCII_c: ------------------ | | 67| 862|#define ASCII_c 0x63 ------------------ | Branch (1636:7): [True: 304, False: 11.7k] ------------------ 1637| 1.41k| case ASCII_d: ------------------ | | 68| 1.41k|#define ASCII_d 0x64 ------------------ | Branch (1637:7): [True: 554, False: 11.4k] ------------------ 1638| 1.65k| case ASCII_e: ------------------ | | 69| 1.65k|#define ASCII_e 0x65 ------------------ | Branch (1638:7): [True: 240, False: 11.7k] ------------------ 1639| 2.65k| case ASCII_f: ------------------ | | 70| 2.65k|#define ASCII_f 0x66 ------------------ | Branch (1639:7): [True: 995, False: 11.0k] ------------------ 1640| 2.65k| result <<= 4; 1641| 2.65k| result += 10 + (c - ASCII_a); ------------------ | | 65| 2.65k|#define ASCII_a 0x61 ------------------ 1642| 2.65k| break; 1643| 12.0k| } 1644| 12.0k| if (result >= 0x110000) ------------------ | Branch (1644:11): [True: 18, False: 12.0k] ------------------ 1645| 18| return -1; 1646| 12.0k| } 1647| 3.72k| } else { 1648| 3.14k| for (; ! CHAR_MATCHES(enc, ptr, ASCII_SEMI); ptr += MINBPC(enc)) { ------------------ | | 246| 3.14k|#define CHAR_MATCHES(enc, p, c) (*(p) == (c)) ------------------ for (; ! CHAR_MATCHES(enc, ptr, ASCII_SEMI); ptr += MINBPC(enc)) { ------------------ | | 228| 2.20k|#define MINBPC(enc) 1 ------------------ | Branch (1648:12): [True: 2.21k, False: 932] ------------------ 1649| 2.21k| int c = BYTE_TO_ASCII(enc, ptr); ------------------ | | 235| 2.21k|#define BYTE_TO_ASCII(enc, p) (*(p)) ------------------ 1650| 2.21k| result *= 10; 1651| 2.21k| result += (c - ASCII_0); ------------------ | | 92| 2.21k|#define ASCII_0 0x30 ------------------ 1652| 2.21k| if (result >= 0x110000) ------------------ | Branch (1652:11): [True: 8, False: 2.20k] ------------------ 1653| 8| return -1; 1654| 2.21k| } 1655| 940| } 1656| 4.63k| return checkCharRefNumber(result); 1657| 4.66k|} xmltok.c:normal_predefinedEntityName: 1661| 778k| const char *end) { 1662| 778k| UNUSED_P(enc); ------------------ | | 101| 778k|# define UNUSED_P(p) (void)p ------------------ 1663| 778k| switch ((end - ptr) / MINBPC(enc)) { ------------------ | | 228| 778k|#define MINBPC(enc) 1 ------------------ | Branch (1663:11): [True: 68.4k, False: 709k] ------------------ 1664| 64.6k| case 2: ------------------ | Branch (1664:3): [True: 64.6k, False: 713k] ------------------ 1665| 64.6k| if (CHAR_MATCHES(enc, ptr + MINBPC(enc), ASCII_t)) { ------------------ | | 246| 64.6k|#define CHAR_MATCHES(enc, p, c) (*(p) == (c)) | | ------------------ | | | Branch (246:33): [True: 64.3k, False: 310] | | ------------------ ------------------ 1666| 64.3k| switch (BYTE_TO_ASCII(enc, ptr)) { ------------------ | | 235| 64.3k|#define BYTE_TO_ASCII(enc, p) (*(p)) | | ------------------ | | | Branch (235:31): [True: 64.3k, False: 13] | | ------------------ ------------------ 1667| 64.2k| case ASCII_l: ------------------ | | 76| 64.2k|#define ASCII_l 0x6C ------------------ | Branch (1667:7): [True: 64.2k, False: 129] ------------------ 1668| 64.2k| return ASCII_LT; ------------------ | | 113| 64.2k|#define ASCII_LT 0x3C ------------------ 1669| 116| case ASCII_g: ------------------ | | 71| 116|#define ASCII_g 0x67 ------------------ | Branch (1669:7): [True: 116, False: 64.2k] ------------------ 1670| 116| return ASCII_GT; ------------------ | | 115| 116|#define ASCII_GT 0x3E ------------------ 1671| 64.3k| } 1672| 64.3k| } 1673| 323| break; 1674| 1.65k| case 3: ------------------ | Branch (1674:3): [True: 1.65k, False: 776k] ------------------ 1675| 1.65k| if (CHAR_MATCHES(enc, ptr, ASCII_a)) { ------------------ | | 246| 1.65k|#define CHAR_MATCHES(enc, p, c) (*(p) == (c)) | | ------------------ | | | Branch (246:33): [True: 1.20k, False: 457] | | ------------------ ------------------ 1676| 1.20k| ptr += MINBPC(enc); ------------------ | | 228| 1.20k|#define MINBPC(enc) 1 ------------------ 1677| 1.20k| if (CHAR_MATCHES(enc, ptr, ASCII_m)) { ------------------ | | 246| 1.20k|#define CHAR_MATCHES(enc, p, c) (*(p) == (c)) | | ------------------ | | | Branch (246:33): [True: 975, False: 227] | | ------------------ ------------------ 1678| 975| ptr += MINBPC(enc); ------------------ | | 228| 975|#define MINBPC(enc) 1 ------------------ 1679| 975| if (CHAR_MATCHES(enc, ptr, ASCII_p)) ------------------ | | 246| 975|#define CHAR_MATCHES(enc, p, c) (*(p) == (c)) | | ------------------ | | | Branch (246:33): [True: 773, False: 202] | | ------------------ ------------------ 1680| 773| return ASCII_AMP; ------------------ | | 107| 773|#define ASCII_AMP 0x26 ------------------ 1681| 975| } 1682| 1.20k| } 1683| 886| break; 1684| 2.06k| case 4: ------------------ | Branch (1684:3): [True: 2.06k, False: 775k] ------------------ 1685| 2.06k| switch (BYTE_TO_ASCII(enc, ptr)) { ------------------ | | 235| 2.06k|#define BYTE_TO_ASCII(enc, p) (*(p)) | | ------------------ | | | Branch (235:31): [True: 1.73k, False: 329] | | ------------------ ------------------ 1686| 897| case ASCII_q: ------------------ | | 81| 897|#define ASCII_q 0x71 ------------------ | Branch (1686:5): [True: 897, False: 1.16k] ------------------ 1687| 897| ptr += MINBPC(enc); ------------------ | | 228| 897|#define MINBPC(enc) 1 ------------------ 1688| 897| if (CHAR_MATCHES(enc, ptr, ASCII_u)) { ------------------ | | 246| 897|#define CHAR_MATCHES(enc, p, c) (*(p) == (c)) | | ------------------ | | | Branch (246:33): [True: 663, False: 234] | | ------------------ ------------------ 1689| 663| ptr += MINBPC(enc); ------------------ | | 228| 663|#define MINBPC(enc) 1 ------------------ 1690| 663| if (CHAR_MATCHES(enc, ptr, ASCII_o)) { ------------------ | | 246| 663|#define CHAR_MATCHES(enc, p, c) (*(p) == (c)) | | ------------------ | | | Branch (246:33): [True: 462, False: 201] | | ------------------ ------------------ 1691| 462| ptr += MINBPC(enc); ------------------ | | 228| 462|#define MINBPC(enc) 1 ------------------ 1692| 462| if (CHAR_MATCHES(enc, ptr, ASCII_t)) ------------------ | | 246| 462|#define CHAR_MATCHES(enc, p, c) (*(p) == (c)) | | ------------------ | | | Branch (246:33): [True: 260, False: 202] | | ------------------ ------------------ 1693| 260| return ASCII_QUOT; ------------------ | | 106| 260|#define ASCII_QUOT 0x22 ------------------ 1694| 462| } 1695| 663| } 1696| 637| break; 1697| 839| case ASCII_a: ------------------ | | 65| 839|#define ASCII_a 0x61 ------------------ | Branch (1697:5): [True: 839, False: 1.22k] ------------------ 1698| 839| ptr += MINBPC(enc); ------------------ | | 228| 839|#define MINBPC(enc) 1 ------------------ 1699| 839| if (CHAR_MATCHES(enc, ptr, ASCII_p)) { ------------------ | | 246| 839|#define CHAR_MATCHES(enc, p, c) (*(p) == (c)) | | ------------------ | | | Branch (246:33): [True: 637, False: 202] | | ------------------ ------------------ 1700| 637| ptr += MINBPC(enc); ------------------ | | 228| 637|#define MINBPC(enc) 1 ------------------ 1701| 637| if (CHAR_MATCHES(enc, ptr, ASCII_o)) { ------------------ | | 246| 637|#define CHAR_MATCHES(enc, p, c) (*(p) == (c)) | | ------------------ | | | Branch (246:33): [True: 436, False: 201] | | ------------------ ------------------ 1702| 436| ptr += MINBPC(enc); ------------------ | | 228| 436|#define MINBPC(enc) 1 ------------------ 1703| 436| if (CHAR_MATCHES(enc, ptr, ASCII_s)) ------------------ | | 246| 436|#define CHAR_MATCHES(enc, p, c) (*(p) == (c)) | | ------------------ | | | Branch (246:33): [True: 234, False: 202] | | ------------------ ------------------ 1704| 234| return ASCII_APOS; ------------------ | | 108| 234|#define ASCII_APOS 0x27 ------------------ 1705| 436| } 1706| 637| } 1707| 605| break; 1708| 2.06k| } 1709| 778k| } 1710| 712k| return 0; 1711| 778k|} xmltok.c:normal_isPublicId: 1450| 1.32k| const char **badPtr) { 1451| 1.32k| ptr += MINBPC(enc); ------------------ | | 228| 1.32k|#define MINBPC(enc) 1 ------------------ 1452| 1.32k| end -= MINBPC(enc); ------------------ | | 228| 1.32k|#define MINBPC(enc) 1 ------------------ 1453| 6.56k| for (; HAS_CHAR(enc, ptr, end); ptr += MINBPC(enc)) { ------------------ | | 228| 6.54k|#define MINBPC(enc) 1 ------------------ 1454| 6.56k| switch (BYTE_TYPE(enc, ptr)) { ------------------ | | 233| 6.56k|#define BYTE_TYPE(enc, p) SB_BYTE_TYPE(enc, p) | | ------------------ | | | | 231| 6.56k| (((const struct normal_encoding *)(enc))->type[(unsigned char)*(p)]) | | ------------------ ------------------ 1455| 263| case BT_DIGIT: ------------------ | Branch (1455:5): [True: 263, False: 6.29k] ------------------ 1456| 564| case BT_HEX: ------------------ | Branch (1456:5): [True: 301, False: 6.26k] ------------------ 1457| 771| case BT_MINUS: ------------------ | Branch (1457:5): [True: 207, False: 6.35k] ------------------ 1458| 973| case BT_APOS: ------------------ | Branch (1458:5): [True: 202, False: 6.35k] ------------------ 1459| 1.33k| case BT_LPAR: ------------------ | Branch (1459:5): [True: 359, False: 6.20k] ------------------ 1460| 1.53k| case BT_RPAR: ------------------ | Branch (1460:5): [True: 202, False: 6.35k] ------------------ 1461| 1.73k| case BT_PLUS: ------------------ | Branch (1461:5): [True: 199, False: 6.36k] ------------------ 1462| 1.94k| case BT_COMMA: ------------------ | Branch (1462:5): [True: 209, False: 6.35k] ------------------ 1463| 2.15k| case BT_SOL: ------------------ | Branch (1463:5): [True: 212, False: 6.34k] ------------------ 1464| 2.35k| case BT_EQUALS: ------------------ | Branch (1464:5): [True: 203, False: 6.35k] ------------------ 1465| 2.58k| case BT_QUEST: ------------------ | Branch (1465:5): [True: 228, False: 6.33k] ------------------ 1466| 2.98k| case BT_CR: ------------------ | Branch (1466:5): [True: 404, False: 6.15k] ------------------ 1467| 3.18k| case BT_LF: ------------------ | Branch (1467:5): [True: 195, False: 6.36k] ------------------ 1468| 3.39k| case BT_SEMI: ------------------ | Branch (1468:5): [True: 208, False: 6.35k] ------------------ 1469| 3.59k| case BT_EXCL: ------------------ | Branch (1469:5): [True: 204, False: 6.35k] ------------------ 1470| 3.79k| case BT_AST: ------------------ | Branch (1470:5): [True: 198, False: 6.36k] ------------------ 1471| 4.00k| case BT_PERCNT: ------------------ | Branch (1471:5): [True: 211, False: 6.35k] ------------------ 1472| 4.27k| case BT_NUM: ------------------ | Branch (1472:5): [True: 272, False: 6.28k] ------------------ 1473| 4.27k|# ifdef XML_NS 1474| 4.53k| case BT_COLON: ------------------ | Branch (1474:5): [True: 256, False: 6.30k] ------------------ 1475| 4.53k|# endif 1476| 4.53k| break; 1477| 660| case BT_S: ------------------ | Branch (1477:5): [True: 660, False: 5.90k] ------------------ 1478| 660| if (CHAR_MATCHES(enc, ptr, ASCII_TAB)) { ------------------ | | 246| 660|#define CHAR_MATCHES(enc, p, c) (*(p) == (c)) | | ------------------ | | | Branch (246:33): [True: 1, False: 659] | | ------------------ ------------------ 1479| 1| *badPtr = ptr; 1480| 1| return 0; 1481| 1| } 1482| 659| break; 1483| 659| case BT_NAME: ------------------ | Branch (1483:5): [True: 201, False: 6.36k] ------------------ 1484| 944| case BT_NMSTRT: ------------------ | Branch (1484:5): [True: 743, False: 5.81k] ------------------ 1485| 944| if (! (BYTE_TO_ASCII(enc, ptr) & ~0x7f)) ------------------ | | 235| 944|#define BYTE_TO_ASCII(enc, p) (*(p)) ------------------ | Branch (1485:11): [True: 937, False: 7] ------------------ 1486| 937| break; 1487| 7| EXPAT_FALLTHROUGH; ------------------ | | 47| 7|# define EXPAT_FALLTHROUGH __attribute__((fallthrough)) ------------------ 1488| 431| default: ------------------ | Branch (1488:5): [True: 424, False: 6.13k] ------------------ 1489| 431| switch (BYTE_TO_ASCII(enc, ptr)) { ------------------ | | 235| 431|#define BYTE_TO_ASCII(enc, p) (*(p)) ------------------ 1490| 209| case 0x24: /* $ */ ------------------ | Branch (1490:7): [True: 209, False: 222] ------------------ 1491| 416| case 0x40: /* @ */ ------------------ | Branch (1491:7): [True: 207, False: 224] ------------------ 1492| 416| break; 1493| 15| default: ------------------ | Branch (1493:7): [True: 15, False: 416] ------------------ 1494| 15| *badPtr = ptr; 1495| 15| return 0; 1496| 431| } 1497| 416| break; 1498| 6.56k| } 1499| 6.56k| } 1500| 1.31k| return 1; 1501| 1.32k|} xmltok.c:little2_prologTok: 1018| 5.75k| const char **nextTokPtr) { 1019| 5.75k| int tok; 1020| 5.75k| if (ptr >= end) ------------------ | Branch (1020:7): [True: 0, False: 5.75k] ------------------ 1021| 0| return XML_TOK_NONE; ------------------ | | 51| 0|# define XML_TOK_NONE -4 /* The string to be scanned is empty */ ------------------ 1022| 5.75k| if (MINBPC(enc) > 1) { ------------------ | | 698| 5.75k|#define MINBPC(enc) 2 ------------------ | Branch (1022:7): [True: 5.75k, Folded] ------------------ 1023| 5.75k| size_t n = end - ptr; 1024| 5.75k| if (n & (MINBPC(enc) - 1)) { ------------------ | | 698| 5.75k|#define MINBPC(enc) 2 ------------------ | Branch (1024:9): [True: 2.71k, False: 3.03k] ------------------ 1025| 2.71k| n &= ~(MINBPC(enc) - 1); ------------------ | | 698| 2.71k|#define MINBPC(enc) 2 ------------------ 1026| 2.71k| if (n == 0) ------------------ | Branch (1026:11): [True: 5, False: 2.71k] ------------------ 1027| 5| return XML_TOK_PARTIAL; ------------------ | | 56| 5|# define XML_TOK_PARTIAL -1 /* only part of a token */ ------------------ 1028| 2.71k| end = ptr + n; 1029| 2.71k| } 1030| 5.75k| } 1031| 5.74k| switch (BYTE_TYPE(enc, ptr)) { ------------------ | | 700| 5.74k|#define BYTE_TYPE(enc, p) LITTLE2_BYTE_TYPE(enc, p) | | ------------------ | | | | 683| 5.74k| ((p)[1] == 0 ? SB_BYTE_TYPE(enc, p) : unicode_byte_type((p)[1], (p)[0])) | | | | ------------------ | | | | | | 231| 5.54k| (((const struct normal_encoding *)(enc))->type[(unsigned char)*(p)]) | | | | ------------------ | | | | | Branch (683:4): [True: 5.54k, False: 206] | | | | ------------------ | | ------------------ ------------------ 1032| 35| case BT_QUOT: ------------------ | Branch (1032:3): [True: 35, False: 5.71k] ------------------ 1033| 35| return PREFIX(scanLit)(BT_QUOT, enc, ptr + MINBPC(enc), end, nextTokPtr); ------------------ | | 697| 35|#define PREFIX(ident) little2_##ident ------------------ return PREFIX(scanLit)(BT_QUOT, enc, ptr + MINBPC(enc), end, nextTokPtr); ------------------ | | 698| 35|#define MINBPC(enc) 2 ------------------ 1034| 102| case BT_APOS: ------------------ | Branch (1034:3): [True: 102, False: 5.64k] ------------------ 1035| 102| return PREFIX(scanLit)(BT_APOS, enc, ptr + MINBPC(enc), end, nextTokPtr); ------------------ | | 697| 102|#define PREFIX(ident) little2_##ident ------------------ return PREFIX(scanLit)(BT_APOS, enc, ptr + MINBPC(enc), end, nextTokPtr); ------------------ | | 698| 102|#define MINBPC(enc) 2 ------------------ 1036| 4.69k| case BT_LT: { ------------------ | Branch (1036:3): [True: 4.69k, False: 1.05k] ------------------ 1037| 4.69k| ptr += MINBPC(enc); ------------------ | | 698| 4.69k|#define MINBPC(enc) 2 ------------------ 1038| 4.69k| REQUIRE_CHAR(enc, ptr, end); ------------------ | | 140| 4.69k|# define REQUIRE_CHAR(enc, ptr, end) REQUIRE_CHARS(enc, ptr, end, 1) | | ------------------ | | | | 134| 4.69k| { \ | | | | 135| 4.69k| if (! HAS_CHARS(enc, ptr, end, count)) { \ | | | | ------------------ | | | | | | 129| 4.69k| ((end) - (ptr) >= ((count) * MINBPC(enc))) | | | | | | ------------------ | | | | | | | | 698| 4.69k|#define MINBPC(enc) 2 | | | | | | ------------------ | | | | ------------------ | | | | | Branch (135:11): [True: 1, False: 4.69k] | | | | ------------------ | | | | 136| 1| return XML_TOK_PARTIAL; \ | | | | ------------------ | | | | | | 56| 1|# define XML_TOK_PARTIAL -1 /* only part of a token */ | | | | ------------------ | | | | 137| 1| } \ | | | | 138| 4.69k| } | | ------------------ ------------------ 1039| 4.69k| switch (BYTE_TYPE(enc, ptr)) { ------------------ | | 700| 4.69k|#define BYTE_TYPE(enc, p) LITTLE2_BYTE_TYPE(enc, p) | | ------------------ | | | | 683| 4.69k| ((p)[1] == 0 ? SB_BYTE_TYPE(enc, p) : unicode_byte_type((p)[1], (p)[0])) | | | | ------------------ | | | | | | 231| 1.67k| (((const struct normal_encoding *)(enc))->type[(unsigned char)*(p)]) | | | | ------------------ | | | | | Branch (683:3): [True: 4.68k, False: 5] | | | | | Branch (683:4): [True: 1.67k, False: 3.01k] | | | | ------------------ | | ------------------ ------------------ 1040| 348| case BT_EXCL: ------------------ | Branch (1040:5): [True: 348, False: 4.34k] ------------------ 1041| 348| return PREFIX(scanDecl)(enc, ptr + MINBPC(enc), end, nextTokPtr); ------------------ | | 697| 348|#define PREFIX(ident) little2_##ident ------------------ return PREFIX(scanDecl)(enc, ptr + MINBPC(enc), end, nextTokPtr); ------------------ | | 698| 348|#define MINBPC(enc) 2 ------------------ 1042| 1.25k| case BT_QUEST: ------------------ | Branch (1042:5): [True: 1.25k, False: 3.43k] ------------------ 1043| 1.25k| return PREFIX(scanPi)(enc, ptr + MINBPC(enc), end, nextTokPtr); ------------------ | | 697| 1.25k|#define PREFIX(ident) little2_##ident ------------------ return PREFIX(scanPi)(enc, ptr + MINBPC(enc), end, nextTokPtr); ------------------ | | 698| 1.25k|#define MINBPC(enc) 2 ------------------ 1044| 66| case BT_NMSTRT: ------------------ | Branch (1044:5): [True: 66, False: 4.62k] ------------------ 1045| 77| case BT_HEX: ------------------ | Branch (1045:5): [True: 11, False: 4.68k] ------------------ 1046| 3.07k| case BT_NONASCII: ------------------ | Branch (1046:5): [True: 2.99k, False: 1.69k] ------------------ 1047| 3.07k| case BT_LEAD2: ------------------ | Branch (1047:5): [True: 0, False: 4.69k] ------------------ 1048| 3.07k| case BT_LEAD3: ------------------ | Branch (1048:5): [True: 0, False: 4.69k] ------------------ 1049| 3.08k| case BT_LEAD4: ------------------ | Branch (1049:5): [True: 8, False: 4.68k] ------------------ 1050| 3.08k| *nextTokPtr = ptr - MINBPC(enc); ------------------ | | 698| 3.08k|#define MINBPC(enc) 2 ------------------ 1051| 3.08k| return XML_TOK_INSTANCE_START; ------------------ | | 96| 3.08k|# define XML_TOK_INSTANCE_START 29 ------------------ 1052| 4.69k| } 1053| 5| *nextTokPtr = ptr; 1054| 5| return XML_TOK_INVALID; ------------------ | | 57| 5|# define XML_TOK_INVALID 0 ------------------ 1055| 4.69k| } 1056| 85| case BT_CR: ------------------ | Branch (1056:3): [True: 85, False: 5.66k] ------------------ 1057| 85| if (ptr + MINBPC(enc) == end) { ------------------ | | 698| 85|#define MINBPC(enc) 2 ------------------ | Branch (1057:9): [True: 3, False: 82] ------------------ 1058| 3| *nextTokPtr = end; 1059| | /* indicate that this might be part of a CR/LF pair */ 1060| 3| return -XML_TOK_PROLOG_S; ------------------ | | 82| 3|# define XML_TOK_PROLOG_S 15 ------------------ 1061| 3| } 1062| 82| EXPAT_FALLTHROUGH; ------------------ | | 47| 82|# define EXPAT_FALLTHROUGH __attribute__((fallthrough)) ------------------ 1063| 343| case BT_S: ------------------ | Branch (1063:3): [True: 261, False: 5.48k] ------------------ 1064| 416| case BT_LF: ------------------ | Branch (1064:3): [True: 73, False: 5.67k] ------------------ 1065| 1.06k| for (;;) { 1066| 1.06k| ptr += MINBPC(enc); ------------------ | | 698| 1.06k|#define MINBPC(enc) 2 ------------------ 1067| 1.06k| if (! HAS_CHAR(enc, ptr, end)) ------------------ | | 131| 1.06k|# define HAS_CHAR(enc, ptr, end) HAS_CHARS(enc, ptr, end, 1) | | ------------------ | | | | 129| 1.06k| ((end) - (ptr) >= ((count) * MINBPC(enc))) | | | | ------------------ | | | | | | 698| 1.06k|#define MINBPC(enc) 2 | | | | ------------------ | | ------------------ ------------------ | Branch (1067:11): [True: 2, False: 1.06k] ------------------ 1068| 2| break; 1069| 1.06k| switch (BYTE_TYPE(enc, ptr)) { ------------------ | | 700| 1.06k|#define BYTE_TYPE(enc, p) LITTLE2_BYTE_TYPE(enc, p) | | ------------------ | | | | 683| 1.06k| ((p)[1] == 0 ? SB_BYTE_TYPE(enc, p) : unicode_byte_type((p)[1], (p)[0])) | | | | ------------------ | | | | | | 231| 1.02k| (((const struct normal_encoding *)(enc))->type[(unsigned char)*(p)]) | | | | ------------------ | | | | | Branch (683:4): [True: 1.02k, False: 38] | | | | ------------------ | | ------------------ ------------------ 1070| 248| case BT_S: ------------------ | Branch (1070:7): [True: 248, False: 815] ------------------ 1071| 443| case BT_LF: ------------------ | Branch (1071:7): [True: 195, False: 868] ------------------ 1072| 443| break; 1073| 208| case BT_CR: ------------------ | Branch (1073:7): [True: 208, False: 855] ------------------ 1074| | /* don't split CR/LF pair */ 1075| 208| if (ptr + MINBPC(enc) != end) ------------------ | | 698| 208|#define MINBPC(enc) 2 ------------------ | Branch (1075:13): [True: 206, False: 2] ------------------ 1076| 206| break; 1077| 2| EXPAT_FALLTHROUGH; ------------------ | | 47| 2|# define EXPAT_FALLTHROUGH __attribute__((fallthrough)) ------------------ 1078| 414| default: ------------------ | Branch (1078:7): [True: 412, False: 651] ------------------ 1079| 414| *nextTokPtr = ptr; 1080| 414| return XML_TOK_PROLOG_S; ------------------ | | 82| 414|# define XML_TOK_PROLOG_S 15 ------------------ 1081| 1.06k| } 1082| 1.06k| } 1083| 2| *nextTokPtr = ptr; 1084| 2| return XML_TOK_PROLOG_S; ------------------ | | 82| 2|# define XML_TOK_PROLOG_S 15 ------------------ 1085| 99| case BT_PERCNT: ------------------ | Branch (1085:3): [True: 99, False: 5.64k] ------------------ 1086| 99| return PREFIX(scanPercent)(enc, ptr + MINBPC(enc), end, nextTokPtr); ------------------ | | 697| 99|#define PREFIX(ident) little2_##ident ------------------ return PREFIX(scanPercent)(enc, ptr + MINBPC(enc), end, nextTokPtr); ------------------ | | 698| 99|#define MINBPC(enc) 2 ------------------ 1087| 1| case BT_COMMA: ------------------ | Branch (1087:3): [True: 1, False: 5.74k] ------------------ 1088| 1| *nextTokPtr = ptr + MINBPC(enc); ------------------ | | 698| 1|#define MINBPC(enc) 2 ------------------ 1089| 1| return XML_TOK_COMMA; ------------------ | | 107| 1|# define XML_TOK_COMMA 38 ------------------ 1090| 1| case BT_LSQB: ------------------ | Branch (1090:3): [True: 1, False: 5.74k] ------------------ 1091| 1| *nextTokPtr = ptr + MINBPC(enc); ------------------ | | 698| 1|#define MINBPC(enc) 2 ------------------ 1092| 1| return XML_TOK_OPEN_BRACKET; ------------------ | | 92| 1|# define XML_TOK_OPEN_BRACKET 25 ------------------ 1093| 30| case BT_RSQB: ------------------ | Branch (1093:3): [True: 30, False: 5.71k] ------------------ 1094| 30| ptr += MINBPC(enc); ------------------ | | 698| 30|#define MINBPC(enc) 2 ------------------ 1095| 30| if (! HAS_CHAR(enc, ptr, end)) ------------------ | | 131| 30|# define HAS_CHAR(enc, ptr, end) HAS_CHARS(enc, ptr, end, 1) | | ------------------ | | | | 129| 30| ((end) - (ptr) >= ((count) * MINBPC(enc))) | | | | ------------------ | | | | | | 698| 30|#define MINBPC(enc) 2 | | | | ------------------ | | ------------------ ------------------ | Branch (1095:9): [True: 1, False: 29] ------------------ 1096| 1| return -XML_TOK_CLOSE_BRACKET; ------------------ | | 93| 1|# define XML_TOK_CLOSE_BRACKET 26 ------------------ 1097| 29| if (CHAR_MATCHES(enc, ptr, ASCII_RSQB)) { ------------------ | | 702| 29|#define CHAR_MATCHES(enc, p, c) LITTLE2_CHAR_MATCHES(p, c) | | ------------------ | | | | 685| 29|#define LITTLE2_CHAR_MATCHES(p, c) ((p)[1] == 0 && (p)[0] == (c)) | | | | ------------------ | | | | | Branch (685:37): [True: 14, False: 15] | | | | | Branch (685:52): [True: 4, False: 10] | | | | ------------------ | | ------------------ ------------------ 1098| 4| REQUIRE_CHARS(enc, ptr, end, 2); ------------------ | | 134| 4| { \ | | 135| 4| if (! HAS_CHARS(enc, ptr, end, count)) { \ | | ------------------ | | | | 129| 4| ((end) - (ptr) >= ((count) * MINBPC(enc))) | | | | ------------------ | | | | | | 698| 4|#define MINBPC(enc) 2 | | | | ------------------ | | ------------------ | | | Branch (135:11): [True: 1, False: 3] | | ------------------ | | 136| 1| return XML_TOK_PARTIAL; \ | | ------------------ | | | | 56| 1|# define XML_TOK_PARTIAL -1 /* only part of a token */ | | ------------------ | | 137| 1| } \ | | 138| 4| } ------------------ 1099| 3| if (CHAR_MATCHES(enc, ptr + MINBPC(enc), ASCII_GT)) { ------------------ | | 702| 3|#define CHAR_MATCHES(enc, p, c) LITTLE2_CHAR_MATCHES(p, c) | | ------------------ | | | | 685| 3|#define LITTLE2_CHAR_MATCHES(p, c) ((p)[1] == 0 && (p)[0] == (c)) | | | | ------------------ | | | | | Branch (685:37): [True: 2, False: 1] | | | | | Branch (685:52): [True: 1, False: 1] | | | | ------------------ | | ------------------ ------------------ 1100| 1| *nextTokPtr = ptr + 2 * MINBPC(enc); ------------------ | | 698| 1|#define MINBPC(enc) 2 ------------------ 1101| 1| return XML_TOK_COND_SECT_CLOSE; ------------------ | | 103| 1|# define XML_TOK_COND_SECT_CLOSE 34 /* ]]> */ ------------------ 1102| 1| } 1103| 3| } 1104| 27| *nextTokPtr = ptr; 1105| 27| return XML_TOK_CLOSE_BRACKET; ------------------ | | 93| 27|# define XML_TOK_CLOSE_BRACKET 26 ------------------ 1106| 3| case BT_LPAR: ------------------ | Branch (1106:3): [True: 3, False: 5.74k] ------------------ 1107| 3| *nextTokPtr = ptr + MINBPC(enc); ------------------ | | 698| 3|#define MINBPC(enc) 2 ------------------ 1108| 3| return XML_TOK_OPEN_PAREN; ------------------ | | 90| 3|# define XML_TOK_OPEN_PAREN 23 ------------------ 1109| 39| case BT_RPAR: ------------------ | Branch (1109:3): [True: 39, False: 5.70k] ------------------ 1110| 39| ptr += MINBPC(enc); ------------------ | | 698| 39|#define MINBPC(enc) 2 ------------------ 1111| 39| if (! HAS_CHAR(enc, ptr, end)) ------------------ | | 131| 39|# define HAS_CHAR(enc, ptr, end) HAS_CHARS(enc, ptr, end, 1) | | ------------------ | | | | 129| 39| ((end) - (ptr) >= ((count) * MINBPC(enc))) | | | | ------------------ | | | | | | 698| 39|#define MINBPC(enc) 2 | | | | ------------------ | | ------------------ ------------------ | Branch (1111:9): [True: 2, False: 37] ------------------ 1112| 2| return -XML_TOK_CLOSE_PAREN; ------------------ | | 91| 2|# define XML_TOK_CLOSE_PAREN 24 ------------------ 1113| 37| switch (BYTE_TYPE(enc, ptr)) { ------------------ | | 700| 37|#define BYTE_TYPE(enc, p) LITTLE2_BYTE_TYPE(enc, p) | | ------------------ | | | | 683| 37| ((p)[1] == 0 ? SB_BYTE_TYPE(enc, p) : unicode_byte_type((p)[1], (p)[0])) | | | | ------------------ | | | | | | 231| 12| (((const struct normal_encoding *)(enc))->type[(unsigned char)*(p)]) | | | | ------------------ | | | | | Branch (683:3): [True: 12, False: 25] | | | | | Branch (683:4): [True: 12, False: 25] | | | | ------------------ | | ------------------ ------------------ 1114| 1| case BT_AST: ------------------ | Branch (1114:5): [True: 1, False: 36] ------------------ 1115| 1| *nextTokPtr = ptr + MINBPC(enc); ------------------ | | 698| 1|#define MINBPC(enc) 2 ------------------ 1116| 1| return XML_TOK_CLOSE_PAREN_ASTERISK; ------------------ | | 105| 1|# define XML_TOK_CLOSE_PAREN_ASTERISK 36 /* )* */ ------------------ 1117| 2| case BT_QUEST: ------------------ | Branch (1117:5): [True: 2, False: 35] ------------------ 1118| 2| *nextTokPtr = ptr + MINBPC(enc); ------------------ | | 698| 2|#define MINBPC(enc) 2 ------------------ 1119| 2| return XML_TOK_CLOSE_PAREN_QUESTION; ------------------ | | 104| 2|# define XML_TOK_CLOSE_PAREN_QUESTION 35 /* )? */ ------------------ 1120| 1| case BT_PLUS: ------------------ | Branch (1120:5): [True: 1, False: 36] ------------------ 1121| 1| *nextTokPtr = ptr + MINBPC(enc); ------------------ | | 698| 1|#define MINBPC(enc) 2 ------------------ 1122| 1| return XML_TOK_CLOSE_PAREN_PLUS; ------------------ | | 106| 1|# define XML_TOK_CLOSE_PAREN_PLUS 37 /* )+ */ ------------------ 1123| 2| case BT_CR: ------------------ | Branch (1123:5): [True: 2, False: 35] ------------------ 1124| 3| case BT_LF: ------------------ | Branch (1124:5): [True: 1, False: 36] ------------------ 1125| 4| case BT_S: ------------------ | Branch (1125:5): [True: 1, False: 36] ------------------ 1126| 5| case BT_GT: ------------------ | Branch (1126:5): [True: 1, False: 36] ------------------ 1127| 6| case BT_COMMA: ------------------ | Branch (1127:5): [True: 1, False: 36] ------------------ 1128| 7| case BT_VERBAR: ------------------ | Branch (1128:5): [True: 1, False: 36] ------------------ 1129| 8| case BT_RPAR: ------------------ | Branch (1129:5): [True: 1, False: 36] ------------------ 1130| 8| *nextTokPtr = ptr; 1131| 8| return XML_TOK_CLOSE_PAREN; ------------------ | | 91| 8|# define XML_TOK_CLOSE_PAREN 24 ------------------ 1132| 37| } 1133| 25| *nextTokPtr = ptr; 1134| 25| return XML_TOK_INVALID; ------------------ | | 57| 25|# define XML_TOK_INVALID 0 ------------------ 1135| 1| case BT_VERBAR: ------------------ | Branch (1135:3): [True: 1, False: 5.74k] ------------------ 1136| 1| *nextTokPtr = ptr + MINBPC(enc); ------------------ | | 698| 1|#define MINBPC(enc) 2 ------------------ 1137| 1| return XML_TOK_OR; ------------------ | | 88| 1|# define XML_TOK_OR 21 /* | */ ------------------ 1138| 2| case BT_GT: ------------------ | Branch (1138:3): [True: 2, False: 5.74k] ------------------ 1139| 2| *nextTokPtr = ptr + MINBPC(enc); ------------------ | | 698| 2|#define MINBPC(enc) 2 ------------------ 1140| 2| return XML_TOK_DECL_CLOSE; ------------------ | | 84| 2|# define XML_TOK_DECL_CLOSE 17 /* > */ ------------------ 1141| 97| case BT_NUM: ------------------ | Branch (1141:3): [True: 97, False: 5.65k] ------------------ 1142| 97| return PREFIX(scanPoundName)(enc, ptr + MINBPC(enc), end, nextTokPtr); ------------------ | | 697| 97|#define PREFIX(ident) little2_##ident ------------------ return PREFIX(scanPoundName)(enc, ptr + MINBPC(enc), end, nextTokPtr); ------------------ | | 698| 97|#define MINBPC(enc) 2 ------------------ 1143| 0|# define LEAD_CASE(n) \ 1144| 0| case BT_LEAD##n: \ 1145| 0| if (end - ptr < n) \ 1146| 0| return XML_TOK_PARTIAL_CHAR; \ 1147| 0| if (IS_INVALID_CHAR(enc, ptr, n)) { \ 1148| 0| *nextTokPtr = ptr; \ 1149| 0| return XML_TOK_INVALID; \ 1150| 0| } \ 1151| 0| if (IS_NMSTRT_CHAR(enc, ptr, n)) { \ 1152| 0| ptr += n; \ 1153| 0| tok = XML_TOK_NAME; \ 1154| 0| break; \ 1155| 0| } \ 1156| 0| if (IS_NAME_CHAR(enc, ptr, n)) { \ 1157| 0| ptr += n; \ 1158| 0| tok = XML_TOK_NMTOKEN; \ 1159| 0| break; \ 1160| 0| } \ 1161| 0| *nextTokPtr = ptr; \ 1162| 0| return XML_TOK_INVALID; 1163| 0| LEAD_CASE(2) ------------------ | | 1144| 0| case BT_LEAD##n: \ | | ------------------ | | | Branch (1144:3): [True: 0, False: 5.74k] | | ------------------ | | 1145| 0| if (end - ptr < n) \ | | ------------------ | | | Branch (1145:9): [True: 0, False: 0] | | ------------------ | | 1146| 0| return XML_TOK_PARTIAL_CHAR; \ | | ------------------ | | | | 55| 0|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | ------------------ | | 1147| 0| if (IS_INVALID_CHAR(enc, ptr, n)) { \ | | ------------------ | | | | 707| 0|#define IS_INVALID_CHAR(enc, p, n) LITTLE2_IS_INVALID_CHAR(p, n) | | | | ------------------ | | | | | | 694| 0| ((n) == 4 && ((unsigned char)(p)[3] & 0xFC) != 0xDC) | | | | | | ------------------ | | | | | | | Branch (694:4): [Folded, False: 0] | | | | | | | Branch (694:16): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1148| 0| *nextTokPtr = ptr; \ | | 1149| 0| return XML_TOK_INVALID; \ | | ------------------ | | | | 57| 0|# define XML_TOK_INVALID 0 | | ------------------ | | 1150| 0| } \ | | 1151| 0| if (IS_NMSTRT_CHAR(enc, ptr, n)) { \ | | ------------------ | | | | 705| 0|#define IS_NMSTRT_CHAR(enc, p, n) (0) | | | | ------------------ | | | | | Branch (705:35): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 1152| 0| ptr += n; \ | | 1153| 0| tok = XML_TOK_NAME; \ | | ------------------ | | | | 85| 0|# define XML_TOK_NAME 18 | | ------------------ | | 1154| 0| break; \ | | 1155| 0| } \ | | 1156| 0| if (IS_NAME_CHAR(enc, ptr, n)) { \ | | ------------------ | | | | 703| 0|#define IS_NAME_CHAR(enc, p, n) 0 | | | | ------------------ | | | | | Branch (703:33): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 1157| 0| ptr += n; \ | | 1158| 0| tok = XML_TOK_NMTOKEN; \ | | ------------------ | | | | 86| 0|# define XML_TOK_NMTOKEN 19 | | ------------------ | | 1159| 0| break; \ | | 1160| 0| } \ | | 1161| 0| *nextTokPtr = ptr; \ | | 1162| 0| return XML_TOK_INVALID; | | ------------------ | | | | 57| 0|# define XML_TOK_INVALID 0 | | ------------------ ------------------ 1164| 0| LEAD_CASE(3) ------------------ | | 1144| 0| case BT_LEAD##n: \ | | ------------------ | | | Branch (1144:3): [True: 0, False: 5.74k] | | ------------------ | | 1145| 0| if (end - ptr < n) \ | | ------------------ | | | Branch (1145:9): [True: 0, False: 0] | | ------------------ | | 1146| 0| return XML_TOK_PARTIAL_CHAR; \ | | ------------------ | | | | 55| 0|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | ------------------ | | 1147| 0| if (IS_INVALID_CHAR(enc, ptr, n)) { \ | | ------------------ | | | | 707| 0|#define IS_INVALID_CHAR(enc, p, n) LITTLE2_IS_INVALID_CHAR(p, n) | | | | ------------------ | | | | | | 694| 0| ((n) == 4 && ((unsigned char)(p)[3] & 0xFC) != 0xDC) | | | | | | ------------------ | | | | | | | Branch (694:4): [Folded, False: 0] | | | | | | | Branch (694:16): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1148| 0| *nextTokPtr = ptr; \ | | 1149| 0| return XML_TOK_INVALID; \ | | ------------------ | | | | 57| 0|# define XML_TOK_INVALID 0 | | ------------------ | | 1150| 0| } \ | | 1151| 0| if (IS_NMSTRT_CHAR(enc, ptr, n)) { \ | | ------------------ | | | | 705| 0|#define IS_NMSTRT_CHAR(enc, p, n) (0) | | | | ------------------ | | | | | Branch (705:35): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 1152| 0| ptr += n; \ | | 1153| 0| tok = XML_TOK_NAME; \ | | ------------------ | | | | 85| 0|# define XML_TOK_NAME 18 | | ------------------ | | 1154| 0| break; \ | | 1155| 0| } \ | | 1156| 0| if (IS_NAME_CHAR(enc, ptr, n)) { \ | | ------------------ | | | | 703| 0|#define IS_NAME_CHAR(enc, p, n) 0 | | | | ------------------ | | | | | Branch (703:33): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 1157| 0| ptr += n; \ | | 1158| 0| tok = XML_TOK_NMTOKEN; \ | | ------------------ | | | | 86| 0|# define XML_TOK_NMTOKEN 19 | | ------------------ | | 1159| 0| break; \ | | 1160| 0| } \ | | 1161| 0| *nextTokPtr = ptr; \ | | 1162| 0| return XML_TOK_INVALID; | | ------------------ | | | | 57| 0|# define XML_TOK_INVALID 0 | | ------------------ ------------------ 1165| 15| LEAD_CASE(4) ------------------ | | 1144| 7| case BT_LEAD##n: \ | | ------------------ | | | Branch (1144:3): [True: 7, False: 5.74k] | | ------------------ | | 1145| 7| if (end - ptr < n) \ | | ------------------ | | | Branch (1145:9): [True: 1, False: 6] | | ------------------ | | 1146| 1| return XML_TOK_PARTIAL_CHAR; \ | | ------------------ | | | | 55| 1|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | ------------------ | | 1147| 6| if (IS_INVALID_CHAR(enc, ptr, n)) { \ | | ------------------ | | | | 707| 6|#define IS_INVALID_CHAR(enc, p, n) LITTLE2_IS_INVALID_CHAR(p, n) | | | | ------------------ | | | | | | 694| 6| ((n) == 4 && ((unsigned char)(p)[3] & 0xFC) != 0xDC) | | | | | | ------------------ | | | | | | | Branch (694:4): [True: 6, Folded] | | | | | | | Branch (694:16): [True: 5, False: 1] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1148| 5| *nextTokPtr = ptr; \ | | 1149| 5| return XML_TOK_INVALID; \ | | ------------------ | | | | 57| 5|# define XML_TOK_INVALID 0 | | ------------------ | | 1150| 5| } \ | | 1151| 6| if (IS_NMSTRT_CHAR(enc, ptr, n)) { \ | | ------------------ | | | | 705| 1|#define IS_NMSTRT_CHAR(enc, p, n) (0) | | | | ------------------ | | | | | Branch (705:35): [Folded, False: 1] | | | | ------------------ | | ------------------ | | 1152| 0| ptr += n; \ | | 1153| 0| tok = XML_TOK_NAME; \ | | ------------------ | | | | 85| 0|# define XML_TOK_NAME 18 | | ------------------ | | 1154| 0| break; \ | | 1155| 0| } \ | | 1156| 1| if (IS_NAME_CHAR(enc, ptr, n)) { \ | | ------------------ | | | | 703| 1|#define IS_NAME_CHAR(enc, p, n) 0 | | | | ------------------ | | | | | Branch (703:33): [Folded, False: 1] | | | | ------------------ | | ------------------ | | 1157| 0| ptr += n; \ | | 1158| 0| tok = XML_TOK_NMTOKEN; \ | | ------------------ | | | | 86| 0|# define XML_TOK_NMTOKEN 19 | | ------------------ | | 1159| 0| break; \ | | 1160| 0| } \ | | 1161| 1| *nextTokPtr = ptr; \ | | 1162| 1| return XML_TOK_INVALID; | | ------------------ | | | | 57| 1|# define XML_TOK_INVALID 0 | | ------------------ ------------------ 1166| 0|# undef LEAD_CASE 1167| 9| case BT_NMSTRT: ------------------ | Branch (1167:3): [True: 9, False: 5.73k] ------------------ 1168| 13| case BT_HEX: ------------------ | Branch (1168:3): [True: 4, False: 5.74k] ------------------ 1169| 13| tok = XML_TOK_NAME; ------------------ | | 85| 13|# define XML_TOK_NAME 18 ------------------ 1170| 13| ptr += MINBPC(enc); ------------------ | | 698| 13|#define MINBPC(enc) 2 ------------------ 1171| 13| break; 1172| 3| case BT_DIGIT: ------------------ | Branch (1172:3): [True: 3, False: 5.74k] ------------------ 1173| 5| case BT_NAME: ------------------ | Branch (1173:3): [True: 2, False: 5.74k] ------------------ 1174| 7| case BT_MINUS: ------------------ | Branch (1174:3): [True: 2, False: 5.74k] ------------------ 1175| 7|# ifdef XML_NS 1176| 8| case BT_COLON: ------------------ | Branch (1176:3): [True: 1, False: 5.74k] ------------------ 1177| 8|# endif 1178| 8| tok = XML_TOK_NMTOKEN; ------------------ | | 86| 8|# define XML_TOK_NMTOKEN 19 ------------------ 1179| 8| ptr += MINBPC(enc); ------------------ | | 698| 8|#define MINBPC(enc) 2 ------------------ 1180| 8| break; 1181| 185| case BT_NONASCII: ------------------ | Branch (1181:3): [True: 185, False: 5.56k] ------------------ 1182| 185| if (IS_NMSTRT_CHAR_MINBPC(enc, ptr)) { ------------------ | | 706| 185|#define IS_NMSTRT_CHAR_MINBPC(enc, p) LITTLE2_IS_NMSTRT_CHAR_MINBPC(p) | | ------------------ | | | | 689| 185| UCS2_GET_NAMING(nmstrtPages, (unsigned char)p[1], (unsigned char)p[0]) | | | | ------------------ | | | | | | 87| 185| (namingBitmap[(pages[hi] << 3) + ((lo) >> 5)] & (1u << ((lo) & 0x1F))) | | | | | | ------------------ | | | | | | | Branch (87:3): [True: 124, False: 61] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1183| 124| ptr += MINBPC(enc); ------------------ | | 698| 124|#define MINBPC(enc) 2 ------------------ 1184| 124| tok = XML_TOK_NAME; ------------------ | | 85| 124|# define XML_TOK_NAME 18 ------------------ 1185| 124| break; 1186| 124| } 1187| 61| if (IS_NAME_CHAR_MINBPC(enc, ptr)) { ------------------ | | 704| 61|#define IS_NAME_CHAR_MINBPC(enc, p) LITTLE2_IS_NAME_CHAR_MINBPC(p) | | ------------------ | | | | 687| 61| UCS2_GET_NAMING(namePages, (unsigned char)p[1], (unsigned char)p[0]) | | | | ------------------ | | | | | | 87| 61| (namingBitmap[(pages[hi] << 3) + ((lo) >> 5)] & (1u << ((lo) & 0x1F))) | | | | | | ------------------ | | | | | | | Branch (87:3): [True: 16, False: 45] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1188| 16| ptr += MINBPC(enc); ------------------ | | 698| 16|#define MINBPC(enc) 2 ------------------ 1189| 16| tok = XML_TOK_NMTOKEN; ------------------ | | 86| 16|# define XML_TOK_NMTOKEN 19 ------------------ 1190| 16| break; 1191| 16| } 1192| 45| EXPAT_FALLTHROUGH; ------------------ | | 47| 45|# define EXPAT_FALLTHROUGH __attribute__((fallthrough)) ------------------ 1193| 59| default: ------------------ | Branch (1193:3): [True: 14, False: 5.73k] ------------------ 1194| 59| *nextTokPtr = ptr; 1195| 59| return XML_TOK_INVALID; ------------------ | | 57| 59|# define XML_TOK_INVALID 0 ------------------ 1196| 5.74k| } 1197| 1.98k| while (HAS_CHAR(enc, ptr, end)) { 1198| 1.98k| switch (BYTE_TYPE(enc, ptr)) { ------------------ | | 700| 1.98k|#define BYTE_TYPE(enc, p) LITTLE2_BYTE_TYPE(enc, p) | | ------------------ | | | | 683| 1.98k| ((p)[1] == 0 ? SB_BYTE_TYPE(enc, p) : unicode_byte_type((p)[1], (p)[0])) | | | | ------------------ | | | | | | 231| 1.38k| (((const struct normal_encoding *)(enc))->type[(unsigned char)*(p)]) | | | | ------------------ | | | | | Branch (683:4): [True: 1.38k, False: 598] | | | | ------------------ | | ------------------ ------------------ 1199| 5.49k| CHECK_NAME_CASES(enc, ptr, end, nextTokPtr) ------------------ | | 81| 1.63k| case BT_NONASCII: \ | | ------------------ | | | Branch (81:3): [True: 571, False: 1.41k] | | ------------------ | | 82| 1.63k| if (! IS_NAME_CHAR_MINBPC(enc, ptr)) { \ | | ------------------ | | | | 704| 571|#define IS_NAME_CHAR_MINBPC(enc, p) LITTLE2_IS_NAME_CHAR_MINBPC(p) | | | | ------------------ | | | | | | 687| 571| UCS2_GET_NAMING(namePages, (unsigned char)p[1], (unsigned char)p[0]) | | | | | | ------------------ | | | | | | | | 87| 571| (namingBitmap[(pages[hi] << 3) + ((lo) >> 5)] & (1u << ((lo) & 0x1F))) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (82:9): [True: 82, False: 489] | | ------------------ | | 83| 82| *nextTokPtr = ptr; \ | | 84| 82| return XML_TOK_INVALID; \ | | ------------------ | | | | 57| 82|# define XML_TOK_INVALID 0 | | ------------------ | | 85| 82| } \ | | 86| 1.63k| EXPAT_FALLTHROUGH; \ | | ------------------ | | | | 47| 489|# define EXPAT_FALLTHROUGH __attribute__((fallthrough)) | | ------------------ | | 87| 708| case BT_NMSTRT: \ | | ------------------ | | | Branch (87:3): [True: 219, False: 1.76k] | | ------------------ | | 88| 1.03k| case BT_HEX: \ | | ------------------ | | | Branch (88:3): [True: 329, False: 1.65k] | | ------------------ | | 89| 1.23k| case BT_DIGIT: \ | | ------------------ | | | Branch (89:3): [True: 197, False: 1.78k] | | ------------------ | | 90| 1.43k| case BT_NAME: \ | | ------------------ | | | Branch (90:3): [True: 197, False: 1.78k] | | ------------------ | | 91| 1.63k| case BT_MINUS: \ | | ------------------ | | | Branch (91:3): [True: 199, False: 1.78k] | | ------------------ | | 92| 1.63k| ptr += MINBPC(enc); \ | | ------------------ | | | | 698| 1.63k|#define MINBPC(enc) 2 | | ------------------ | | 93| 1.63k| break; \ | | 94| 1.63k| CHECK_NAME_CASE(2, enc, ptr, end, nextTokPtr) \ | | ------------------ | | | | 70| 0| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (70:3): [True: 0, False: 1.98k] | | | | ------------------ | | | | 71| 0| if (end - ptr < n) \ | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 0] | | | | ------------------ | | | | 72| 0| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 0|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 73| 0| if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NAME_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 707| 0|#define IS_INVALID_CHAR(enc, p, n) LITTLE2_IS_INVALID_CHAR(p, n) | | | | | | ------------------ | | | | | | | | 694| 0| ((n) == 4 && ((unsigned char)(p)[3] & 0xFC) != 0xDC) | | | | | | | | ------------------ | | | | | | | | | Branch (694:4): [Folded, False: 0] | | | | | | | | | Branch (694:16): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NAME_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 703| 0|#define IS_NAME_CHAR(enc, p, n) 0 | | | | ------------------ | | | | | Branch (73:41): [True: 0, Folded] | | | | ------------------ | | | | 74| 0| *nextTokPtr = ptr; \ | | | | 75| 0| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 0|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 76| 0| } \ | | | | 77| 0| ptr += n; \ | | | | 78| 0| break; | | ------------------ | | 95| 0| CHECK_NAME_CASE(3, enc, ptr, end, nextTokPtr) \ | | ------------------ | | | | 70| 0| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (70:3): [True: 0, False: 1.98k] | | | | ------------------ | | | | 71| 0| if (end - ptr < n) \ | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 0] | | | | ------------------ | | | | 72| 0| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 0|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 73| 0| if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NAME_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 707| 0|#define IS_INVALID_CHAR(enc, p, n) LITTLE2_IS_INVALID_CHAR(p, n) | | | | | | ------------------ | | | | | | | | 694| 0| ((n) == 4 && ((unsigned char)(p)[3] & 0xFC) != 0xDC) | | | | | | | | ------------------ | | | | | | | | | Branch (694:4): [Folded, False: 0] | | | | | | | | | Branch (694:16): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NAME_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 703| 0|#define IS_NAME_CHAR(enc, p, n) 0 | | | | ------------------ | | | | | Branch (73:41): [True: 0, Folded] | | | | ------------------ | | | | 74| 0| *nextTokPtr = ptr; \ | | | | 75| 0| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 0|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 76| 0| } \ | | | | 77| 0| ptr += n; \ | | | | 78| 0| break; | | ------------------ | | 96| 11| CHECK_NAME_CASE(4, enc, ptr, end, nextTokPtr) | | ------------------ | | | | 70| 11| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (70:3): [True: 11, False: 1.97k] | | | | ------------------ | | | | 71| 11| if (end - ptr < n) \ | | | | ------------------ | | | | | Branch (71:9): [True: 1, False: 10] | | | | ------------------ | | | | 72| 1| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 1|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 73| 10| if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NAME_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 707| 10|#define IS_INVALID_CHAR(enc, p, n) LITTLE2_IS_INVALID_CHAR(p, n) | | | | | | ------------------ | | | | | | | | 694| 20| ((n) == 4 && ((unsigned char)(p)[3] & 0xFC) != 0xDC) | | | | | | | | ------------------ | | | | | | | | | Branch (694:4): [True: 10, Folded] | | | | | | | | | Branch (694:16): [True: 10, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NAME_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 703| 0|#define IS_NAME_CHAR(enc, p, n) 0 | | | | ------------------ | | | | | Branch (73:41): [True: 0, Folded] | | | | ------------------ | | | | 74| 10| *nextTokPtr = ptr; \ | | | | 75| 10| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 10|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 76| 10| } \ | | | | 77| 10| ptr += n; \ | | | | 78| 0| break; | | ------------------ ------------------ 1200| 1| case BT_GT: ------------------ | Branch (1200:5): [True: 1, False: 1.98k] ------------------ 1201| 2| case BT_RPAR: ------------------ | Branch (1201:5): [True: 1, False: 1.98k] ------------------ 1202| 3| case BT_COMMA: ------------------ | Branch (1202:5): [True: 1, False: 1.98k] ------------------ 1203| 5| case BT_VERBAR: ------------------ | Branch (1203:5): [True: 2, False: 1.98k] ------------------ 1204| 6| case BT_LSQB: ------------------ | Branch (1204:5): [True: 1, False: 1.98k] ------------------ 1205| 7| case BT_PERCNT: ------------------ | Branch (1205:5): [True: 1, False: 1.98k] ------------------ 1206| 8| case BT_S: ------------------ | Branch (1206:5): [True: 1, False: 1.98k] ------------------ 1207| 9| case BT_CR: ------------------ | Branch (1207:5): [True: 1, False: 1.98k] ------------------ 1208| 10| case BT_LF: ------------------ | Branch (1208:5): [True: 1, False: 1.98k] ------------------ 1209| 10| *nextTokPtr = ptr; 1210| 10| return tok; 1211| 0|# ifdef XML_NS 1212| 224| case BT_COLON: ------------------ | Branch (1212:5): [True: 224, False: 1.76k] ------------------ 1213| 224| ptr += MINBPC(enc); ------------------ | | 698| 224|#define MINBPC(enc) 2 ------------------ 1214| 224| switch (tok) { ------------------ | Branch (1214:15): [True: 30, False: 194] ------------------ 1215| 29| case XML_TOK_NAME: ------------------ | | 85| 29|# define XML_TOK_NAME 18 ------------------ | Branch (1215:7): [True: 29, False: 195] ------------------ 1216| 29| REQUIRE_CHAR(enc, ptr, end); ------------------ | | 140| 29|# define REQUIRE_CHAR(enc, ptr, end) REQUIRE_CHARS(enc, ptr, end, 1) | | ------------------ | | | | 134| 29| { \ | | | | 135| 29| if (! HAS_CHARS(enc, ptr, end, count)) { \ | | | | ------------------ | | | | | | 129| 29| ((end) - (ptr) >= ((count) * MINBPC(enc))) | | | | | | ------------------ | | | | | | | | 698| 29|#define MINBPC(enc) 2 | | | | | | ------------------ | | | | ------------------ | | | | | Branch (135:11): [True: 1, False: 28] | | | | ------------------ | | | | 136| 1| return XML_TOK_PARTIAL; \ | | | | ------------------ | | | | | | 56| 1|# define XML_TOK_PARTIAL -1 /* only part of a token */ | | | | ------------------ | | | | 137| 1| } \ | | | | 138| 29| } | | ------------------ ------------------ 1217| 28| tok = XML_TOK_PREFIXED_NAME; ------------------ | | 118| 28|# define XML_TOK_PREFIXED_NAME 41 ------------------ 1218| 28| switch (BYTE_TYPE(enc, ptr)) { ------------------ | | 700| 28|#define BYTE_TYPE(enc, p) LITTLE2_BYTE_TYPE(enc, p) | | ------------------ | | | | 683| 28| ((p)[1] == 0 ? SB_BYTE_TYPE(enc, p) : unicode_byte_type((p)[1], (p)[0])) | | | | ------------------ | | | | | | 231| 6| (((const struct normal_encoding *)(enc))->type[(unsigned char)*(p)]) | | | | ------------------ | | | | | Branch (683:4): [True: 6, False: 22] | | | | ------------------ | | ------------------ ------------------ 1219| 65| CHECK_NAME_CASES(enc, ptr, end, nextTokPtr) ------------------ | | 81| 12| case BT_NONASCII: \ | | ------------------ | | | Branch (81:3): [True: 11, False: 17] | | ------------------ | | 82| 12| if (! IS_NAME_CHAR_MINBPC(enc, ptr)) { \ | | ------------------ | | | | 704| 11|#define IS_NAME_CHAR_MINBPC(enc, p) LITTLE2_IS_NAME_CHAR_MINBPC(p) | | | | ------------------ | | | | | | 687| 11| UCS2_GET_NAMING(namePages, (unsigned char)p[1], (unsigned char)p[0]) | | | | | | ------------------ | | | | | | | | 87| 11| (namingBitmap[(pages[hi] << 3) + ((lo) >> 5)] & (1u << ((lo) & 0x1F))) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (82:9): [True: 4, False: 7] | | ------------------ | | 83| 4| *nextTokPtr = ptr; \ | | 84| 4| return XML_TOK_INVALID; \ | | ------------------ | | | | 57| 4|# define XML_TOK_INVALID 0 | | ------------------ | | 85| 4| } \ | | 86| 12| EXPAT_FALLTHROUGH; \ | | ------------------ | | | | 47| 7|# define EXPAT_FALLTHROUGH __attribute__((fallthrough)) | | ------------------ | | 87| 8| case BT_NMSTRT: \ | | ------------------ | | | Branch (87:3): [True: 1, False: 27] | | ------------------ | | 88| 9| case BT_HEX: \ | | ------------------ | | | Branch (88:3): [True: 1, False: 27] | | ------------------ | | 89| 10| case BT_DIGIT: \ | | ------------------ | | | Branch (89:3): [True: 1, False: 27] | | ------------------ | | 90| 11| case BT_NAME: \ | | ------------------ | | | Branch (90:3): [True: 1, False: 27] | | ------------------ | | 91| 12| case BT_MINUS: \ | | ------------------ | | | Branch (91:3): [True: 1, False: 27] | | ------------------ | | 92| 12| ptr += MINBPC(enc); \ | | ------------------ | | | | 698| 12|#define MINBPC(enc) 2 | | ------------------ | | 93| 12| break; \ | | 94| 12| CHECK_NAME_CASE(2, enc, ptr, end, nextTokPtr) \ | | ------------------ | | | | 70| 0| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (70:3): [True: 0, False: 28] | | | | ------------------ | | | | 71| 0| if (end - ptr < n) \ | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 0] | | | | ------------------ | | | | 72| 0| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 0|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 73| 0| if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NAME_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 707| 0|#define IS_INVALID_CHAR(enc, p, n) LITTLE2_IS_INVALID_CHAR(p, n) | | | | | | ------------------ | | | | | | | | 694| 0| ((n) == 4 && ((unsigned char)(p)[3] & 0xFC) != 0xDC) | | | | | | | | ------------------ | | | | | | | | | Branch (694:4): [Folded, False: 0] | | | | | | | | | Branch (694:16): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NAME_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 703| 0|#define IS_NAME_CHAR(enc, p, n) 0 | | | | ------------------ | | | | | Branch (73:41): [True: 0, Folded] | | | | ------------------ | | | | 74| 0| *nextTokPtr = ptr; \ | | | | 75| 0| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 0|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 76| 0| } \ | | | | 77| 0| ptr += n; \ | | | | 78| 0| break; | | ------------------ | | 95| 0| CHECK_NAME_CASE(3, enc, ptr, end, nextTokPtr) \ | | ------------------ | | | | 70| 0| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (70:3): [True: 0, False: 28] | | | | ------------------ | | | | 71| 0| if (end - ptr < n) \ | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 0] | | | | ------------------ | | | | 72| 0| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 0|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 73| 0| if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NAME_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 707| 0|#define IS_INVALID_CHAR(enc, p, n) LITTLE2_IS_INVALID_CHAR(p, n) | | | | | | ------------------ | | | | | | | | 694| 0| ((n) == 4 && ((unsigned char)(p)[3] & 0xFC) != 0xDC) | | | | | | | | ------------------ | | | | | | | | | Branch (694:4): [Folded, False: 0] | | | | | | | | | Branch (694:16): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NAME_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 703| 0|#define IS_NAME_CHAR(enc, p, n) 0 | | | | ------------------ | | | | | Branch (73:41): [True: 0, Folded] | | | | ------------------ | | | | 74| 0| *nextTokPtr = ptr; \ | | | | 75| 0| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 0|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 76| 0| } \ | | | | 77| 0| ptr += n; \ | | | | 78| 0| break; | | ------------------ | | 96| 5| CHECK_NAME_CASE(4, enc, ptr, end, nextTokPtr) | | ------------------ | | | | 70| 5| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (70:3): [True: 5, False: 23] | | | | ------------------ | | | | 71| 5| if (end - ptr < n) \ | | | | ------------------ | | | | | Branch (71:9): [True: 1, False: 4] | | | | ------------------ | | | | 72| 1| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 1|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 73| 4| if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NAME_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 707| 4|#define IS_INVALID_CHAR(enc, p, n) LITTLE2_IS_INVALID_CHAR(p, n) | | | | | | ------------------ | | | | | | | | 694| 8| ((n) == 4 && ((unsigned char)(p)[3] & 0xFC) != 0xDC) | | | | | | | | ------------------ | | | | | | | | | Branch (694:4): [True: 4, Folded] | | | | | | | | | Branch (694:16): [True: 4, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NAME_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 703| 0|#define IS_NAME_CHAR(enc, p, n) 0 | | | | ------------------ | | | | | Branch (73:41): [True: 0, Folded] | | | | ------------------ | | | | 74| 4| *nextTokPtr = ptr; \ | | | | 75| 4| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 4|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 76| 4| } \ | | | | 77| 4| ptr += n; \ | | | | 78| 0| break; | | ------------------ ------------------ 1220| 7| default: ------------------ | Branch (1220:9): [True: 7, False: 21] ------------------ 1221| 7| tok = XML_TOK_NMTOKEN; ------------------ | | 86| 7|# define XML_TOK_NMTOKEN 19 ------------------ 1222| 7| break; 1223| 28| } 1224| 19| break; 1225| 19| case XML_TOK_PREFIXED_NAME: ------------------ | | 118| 1|# define XML_TOK_PREFIXED_NAME 41 ------------------ | Branch (1225:7): [True: 1, False: 223] ------------------ 1226| 1| tok = XML_TOK_NMTOKEN; ------------------ | | 86| 1|# define XML_TOK_NMTOKEN 19 ------------------ 1227| 1| break; 1228| 224| } 1229| 214| break; 1230| 214|# endif 1231| 214| case BT_PLUS: ------------------ | Branch (1231:5): [True: 3, False: 1.98k] ------------------ 1232| 3| if (tok == XML_TOK_NMTOKEN) { ------------------ | | 86| 3|# define XML_TOK_NMTOKEN 19 ------------------ | Branch (1232:11): [True: 1, False: 2] ------------------ 1233| 1| *nextTokPtr = ptr; 1234| 1| return XML_TOK_INVALID; ------------------ | | 57| 1|# define XML_TOK_INVALID 0 ------------------ 1235| 1| } 1236| 2| *nextTokPtr = ptr + MINBPC(enc); ------------------ | | 698| 2|#define MINBPC(enc) 2 ------------------ 1237| 2| return XML_TOK_NAME_PLUS; ------------------ | | 101| 2|# define XML_TOK_NAME_PLUS 32 /* name+ */ ------------------ 1238| 5| case BT_AST: ------------------ | Branch (1238:5): [True: 5, False: 1.98k] ------------------ 1239| 5| if (tok == XML_TOK_NMTOKEN) { ------------------ | | 86| 5|# define XML_TOK_NMTOKEN 19 ------------------ | Branch (1239:11): [True: 2, False: 3] ------------------ 1240| 2| *nextTokPtr = ptr; 1241| 2| return XML_TOK_INVALID; ------------------ | | 57| 2|# define XML_TOK_INVALID 0 ------------------ 1242| 2| } 1243| 3| *nextTokPtr = ptr + MINBPC(enc); ------------------ | | 698| 3|#define MINBPC(enc) 2 ------------------ 1244| 3| return XML_TOK_NAME_ASTERISK; ------------------ | | 100| 3|# define XML_TOK_NAME_ASTERISK 31 /* name* */ ------------------ 1245| 3| case BT_QUEST: ------------------ | Branch (1245:5): [True: 3, False: 1.98k] ------------------ 1246| 3| if (tok == XML_TOK_NMTOKEN) { ------------------ | | 86| 3|# define XML_TOK_NMTOKEN 19 ------------------ | Branch (1246:11): [True: 1, False: 2] ------------------ 1247| 1| *nextTokPtr = ptr; 1248| 1| return XML_TOK_INVALID; ------------------ | | 57| 1|# define XML_TOK_INVALID 0 ------------------ 1249| 1| } 1250| 2| *nextTokPtr = ptr + MINBPC(enc); ------------------ | | 698| 2|#define MINBPC(enc) 2 ------------------ 1251| 2| return XML_TOK_NAME_QUESTION; ------------------ | | 99| 2|# define XML_TOK_NAME_QUESTION 30 /* name? */ ------------------ 1252| 17| default: ------------------ | Branch (1252:5): [True: 17, False: 1.96k] ------------------ 1253| 17| *nextTokPtr = ptr; 1254| 17| return XML_TOK_INVALID; ------------------ | | 57| 17|# define XML_TOK_INVALID 0 ------------------ 1255| 1.98k| } 1256| 1.98k| } 1257| 20| return -tok; 1258| 161|} xmltok.c:little2_scanLit: 984| 137| const char **nextTokPtr) { 985| 2.47k| while (HAS_CHAR(enc, ptr, end)) { 986| 2.47k| int t = BYTE_TYPE(enc, ptr); ------------------ | | 700| 2.47k|#define BYTE_TYPE(enc, p) LITTLE2_BYTE_TYPE(enc, p) | | ------------------ | | | | 683| 2.47k| ((p)[1] == 0 ? SB_BYTE_TYPE(enc, p) : unicode_byte_type((p)[1], (p)[0])) | | | | ------------------ | | | | | | 231| 680| (((const struct normal_encoding *)(enc))->type[(unsigned char)*(p)]) | | | | ------------------ | | | | | Branch (683:4): [True: 680, False: 1.79k] | | | | ------------------ | | ------------------ ------------------ 987| 2.47k| switch (t) { 988| 895| INVALID_CASES(ptr, nextTokPtr) ------------------ | | 60| 0| INVALID_LEAD_CASE(2, ptr, nextTokPtr) \ | | ------------------ | | | | 49| 0| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (49:3): [True: 0, False: 2.47k] | | | | ------------------ | | | | 50| 0| if (end - ptr < n) \ | | | | ------------------ | | | | | Branch (50:9): [True: 0, False: 0] | | | | ------------------ | | | | 51| 0| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 0|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 52| 0| if (IS_INVALID_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 707| 0|#define IS_INVALID_CHAR(enc, p, n) LITTLE2_IS_INVALID_CHAR(p, n) | | | | | | ------------------ | | | | | | | | 694| 0| ((n) == 4 && ((unsigned char)(p)[3] & 0xFC) != 0xDC) | | | | | | | | ------------------ | | | | | | | | | Branch (694:4): [Folded, False: 0] | | | | | | | | | Branch (694:16): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 53| 0| *(nextTokPtr) = (ptr); \ | | | | 54| 0| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 0|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 55| 0| } \ | | | | 56| 0| ptr += n; \ | | | | 57| 0| break; | | ------------------ | | 61| 0| INVALID_LEAD_CASE(3, ptr, nextTokPtr) \ | | ------------------ | | | | 49| 0| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (49:3): [True: 0, False: 2.47k] | | | | ------------------ | | | | 50| 0| if (end - ptr < n) \ | | | | ------------------ | | | | | Branch (50:9): [True: 0, False: 0] | | | | ------------------ | | | | 51| 0| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 0|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 52| 0| if (IS_INVALID_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 707| 0|#define IS_INVALID_CHAR(enc, p, n) LITTLE2_IS_INVALID_CHAR(p, n) | | | | | | ------------------ | | | | | | | | 694| 0| ((n) == 4 && ((unsigned char)(p)[3] & 0xFC) != 0xDC) | | | | | | | | ------------------ | | | | | | | | | Branch (694:4): [Folded, False: 0] | | | | | | | | | Branch (694:16): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 53| 0| *(nextTokPtr) = (ptr); \ | | | | 54| 0| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 0|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 55| 0| } \ | | | | 56| 0| ptr += n; \ | | | | 57| 0| break; | | ------------------ | | 62| 444| INVALID_LEAD_CASE(4, ptr, nextTokPtr) \ | | ------------------ | | | | 49| 444| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (49:3): [True: 444, False: 2.03k] | | | | ------------------ | | | | 50| 444| if (end - ptr < n) \ | | | | ------------------ | | | | | Branch (50:9): [True: 1, False: 443] | | | | ------------------ | | | | 51| 402| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 1|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 52| 443| if (IS_INVALID_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 707| 443|#define IS_INVALID_CHAR(enc, p, n) LITTLE2_IS_INVALID_CHAR(p, n) | | | | | | ------------------ | | | | | | | | 694| 443| ((n) == 4 && ((unsigned char)(p)[3] & 0xFC) != 0xDC) | | | | | | | | ------------------ | | | | | | | | | Branch (694:4): [True: 443, Folded] | | | | | | | | | Branch (694:16): [True: 41, False: 402] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 53| 41| *(nextTokPtr) = (ptr); \ | | | | 54| 41| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 41|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 55| 41| } \ | | | | 56| 443| ptr += n; \ | | | | 57| 402| break; | | ------------------ | | 63| 402| case BT_NONXML: \ | | ------------------ | | | Branch (63:3): [True: 4, False: 2.47k] | | ------------------ | | 64| 4| case BT_MALFORM: \ | | ------------------ | | | Branch (64:3): [True: 0, False: 2.47k] | | ------------------ | | 65| 8| case BT_TRAIL: \ | | ------------------ | | | Branch (65:3): [True: 4, False: 2.47k] | | ------------------ | | 66| 8| *(nextTokPtr) = (ptr); \ | | 67| 8| return XML_TOK_INVALID; | | ------------------ | | | | 57| 8|# define XML_TOK_INVALID 0 | | ------------------ ------------------ 989| 203| case BT_QUOT: ------------------ | Branch (989:5): [True: 203, False: 2.27k] ------------------ 990| 435| case BT_APOS: ------------------ | Branch (990:5): [True: 232, False: 2.24k] ------------------ 991| 435| ptr += MINBPC(enc); ------------------ | | 698| 435|#define MINBPC(enc) 2 ------------------ 992| 435| if (t != open) ------------------ | Branch (992:11): [True: 388, False: 47] ------------------ 993| 388| break; 994| 47| if (! HAS_CHAR(enc, ptr, end)) ------------------ | | 131| 47|# define HAS_CHAR(enc, ptr, end) HAS_CHARS(enc, ptr, end, 1) | | ------------------ | | | | 129| 47| ((end) - (ptr) >= ((count) * MINBPC(enc))) | | | | ------------------ | | | | | | 698| 47|#define MINBPC(enc) 2 | | | | ------------------ | | ------------------ ------------------ | Branch (994:11): [True: 6, False: 41] ------------------ 995| 6| return -XML_TOK_LITERAL; ------------------ | | 94| 6|# define XML_TOK_LITERAL 27 ------------------ 996| 41| *nextTokPtr = ptr; 997| 41| switch (BYTE_TYPE(enc, ptr)) { ------------------ | | 700| 41|#define BYTE_TYPE(enc, p) LITTLE2_BYTE_TYPE(enc, p) | | ------------------ | | | | 683| 41| ((p)[1] == 0 ? SB_BYTE_TYPE(enc, p) : unicode_byte_type((p)[1], (p)[0])) | | | | ------------------ | | | | | | 231| 7| (((const struct normal_encoding *)(enc))->type[(unsigned char)*(p)]) | | | | ------------------ | | | | | Branch (683:4): [True: 7, False: 34] | | | | ------------------ | | ------------------ ------------------ 998| 1| case BT_S: ------------------ | Branch (998:7): [True: 1, False: 40] ------------------ 999| 2| case BT_CR: ------------------ | Branch (999:7): [True: 1, False: 40] ------------------ 1000| 3| case BT_LF: ------------------ | Branch (1000:7): [True: 1, False: 40] ------------------ 1001| 4| case BT_GT: ------------------ | Branch (1001:7): [True: 1, False: 40] ------------------ 1002| 5| case BT_PERCNT: ------------------ | Branch (1002:7): [True: 1, False: 40] ------------------ 1003| 6| case BT_LSQB: ------------------ | Branch (1003:7): [True: 1, False: 40] ------------------ 1004| 6| return XML_TOK_LITERAL; ------------------ | | 94| 6|# define XML_TOK_LITERAL 27 ------------------ 1005| 35| default: ------------------ | Branch (1005:7): [True: 35, False: 6] ------------------ 1006| 35| return XML_TOK_INVALID; ------------------ | | 57| 35|# define XML_TOK_INVALID 0 ------------------ 1007| 41| } 1008| 1.59k| default: ------------------ | Branch (1008:5): [True: 1.59k, False: 887] ------------------ 1009| 1.59k| ptr += MINBPC(enc); ------------------ | | 698| 1.59k|#define MINBPC(enc) 2 ------------------ 1010| 1.59k| break; 1011| 2.47k| } 1012| 2.47k| } 1013| 40| return XML_TOK_PARTIAL; ------------------ | | 56| 40|# define XML_TOK_PARTIAL -1 /* only part of a token */ ------------------ 1014| 137|} xmltok.c:little2_scanDecl: 183| 348| const char **nextTokPtr) { 184| 348| REQUIRE_CHAR(enc, ptr, end); ------------------ | | 140| 348|# define REQUIRE_CHAR(enc, ptr, end) REQUIRE_CHARS(enc, ptr, end, 1) | | ------------------ | | | | 134| 348| { \ | | | | 135| 348| if (! HAS_CHARS(enc, ptr, end, count)) { \ | | | | ------------------ | | | | | | 129| 348| ((end) - (ptr) >= ((count) * MINBPC(enc))) | | | | | | ------------------ | | | | | | | | 698| 348|#define MINBPC(enc) 2 | | | | | | ------------------ | | | | ------------------ | | | | | Branch (135:11): [True: 1, False: 347] | | | | ------------------ | | | | 136| 1| return XML_TOK_PARTIAL; \ | | | | ------------------ | | | | | | 56| 1|# define XML_TOK_PARTIAL -1 /* only part of a token */ | | | | ------------------ | | | | 137| 1| } \ | | | | 138| 348| } | | ------------------ ------------------ 185| 347| switch (BYTE_TYPE(enc, ptr)) { ------------------ | | 700| 347|#define BYTE_TYPE(enc, p) LITTLE2_BYTE_TYPE(enc, p) | | ------------------ | | | | 683| 347| ((p)[1] == 0 ? SB_BYTE_TYPE(enc, p) : unicode_byte_type((p)[1], (p)[0])) | | | | ------------------ | | | | | | 231| 323| (((const struct normal_encoding *)(enc))->type[(unsigned char)*(p)]) | | | | ------------------ | | | | | Branch (683:4): [True: 323, False: 24] | | | | ------------------ | | ------------------ ------------------ 186| 246| case BT_MINUS: ------------------ | Branch (186:3): [True: 246, False: 101] ------------------ 187| 246| return PREFIX(scanComment)(enc, ptr + MINBPC(enc), end, nextTokPtr); ------------------ | | 697| 246|#define PREFIX(ident) little2_##ident ------------------ return PREFIX(scanComment)(enc, ptr + MINBPC(enc), end, nextTokPtr); ------------------ | | 698| 246|#define MINBPC(enc) 2 ------------------ 188| 1| case BT_LSQB: ------------------ | Branch (188:3): [True: 1, False: 346] ------------------ 189| 1| *nextTokPtr = ptr + MINBPC(enc); ------------------ | | 698| 1|#define MINBPC(enc) 2 ------------------ 190| 1| return XML_TOK_COND_SECT_OPEN; ------------------ | | 102| 1|# define XML_TOK_COND_SECT_OPEN 33 /* type[(unsigned char)*(p)]) | | | | ------------------ | | | | | Branch (683:4): [True: 581, False: 29] | | | | ------------------ | | ------------------ ------------------ 201| 37| case BT_PERCNT: ------------------ | Branch (201:5): [True: 37, False: 573] ------------------ 202| 37| REQUIRE_CHARS(enc, ptr, end, 2); ------------------ | | 134| 37| { \ | | 135| 37| if (! HAS_CHARS(enc, ptr, end, count)) { \ | | ------------------ | | | | 129| 37| ((end) - (ptr) >= ((count) * MINBPC(enc))) | | | | ------------------ | | | | | | 698| 37|#define MINBPC(enc) 2 | | | | ------------------ | | ------------------ | | | Branch (135:11): [True: 1, False: 36] | | ------------------ | | 136| 1| return XML_TOK_PARTIAL; \ | | ------------------ | | | | 56| 1|# define XML_TOK_PARTIAL -1 /* only part of a token */ | | ------------------ | | 137| 1| } \ | | 138| 37| } ------------------ 203| | /* don't allow */ 204| 36| switch (BYTE_TYPE(enc, ptr + MINBPC(enc))) { ------------------ | | 700| 36|#define BYTE_TYPE(enc, p) LITTLE2_BYTE_TYPE(enc, p) | | ------------------ | | | | 683| 36| ((p)[1] == 0 ? SB_BYTE_TYPE(enc, p) : unicode_byte_type((p)[1], (p)[0])) | | | | ------------------ | | | | | | 231| 4| (((const struct normal_encoding *)(enc))->type[(unsigned char)*(p)]) | | | | ------------------ | | | | | Branch (683:3): [True: 4, False: 32] | | | | | Branch (683:4): [True: 4, False: 32] | | | | ------------------ | | ------------------ ------------------ 205| 1| case BT_S: ------------------ | Branch (205:7): [True: 1, False: 35] ------------------ 206| 2| case BT_CR: ------------------ | Branch (206:7): [True: 1, False: 35] ------------------ 207| 3| case BT_LF: ------------------ | Branch (207:7): [True: 1, False: 35] ------------------ 208| 4| case BT_PERCNT: ------------------ | Branch (208:7): [True: 1, False: 35] ------------------ 209| 4| *nextTokPtr = ptr; 210| 4| return XML_TOK_INVALID; ------------------ | | 57| 4|# define XML_TOK_INVALID 0 ------------------ 211| 36| } 212| 32| EXPAT_FALLTHROUGH; ------------------ | | 47| 32|# define EXPAT_FALLTHROUGH __attribute__((fallthrough)) ------------------ 213| 36| case BT_S: ------------------ | Branch (213:5): [True: 4, False: 606] ------------------ 214| 37| case BT_CR: ------------------ | Branch (214:5): [True: 1, False: 609] ------------------ 215| 40| case BT_LF: ------------------ | Branch (215:5): [True: 3, False: 607] ------------------ 216| 40| *nextTokPtr = ptr; 217| 40| return XML_TOK_DECL_OPEN; ------------------ | | 83| 40|# define XML_TOK_DECL_OPEN 16 /* = ((count) * MINBPC(enc))) | | | | ------------------ | | | | | | 698| 314|#define MINBPC(enc) 2 | | | | ------------------ | | | | | Branch (129:5): [True: 313, False: 1] | | | | ------------------ | | ------------------ ------------------ 148| 313| if (! CHAR_MATCHES(enc, ptr, ASCII_MINUS)) { ------------------ | | 702| 313|#define CHAR_MATCHES(enc, p, c) LITTLE2_CHAR_MATCHES(p, c) | | ------------------ | | | | 685| 313|#define LITTLE2_CHAR_MATCHES(p, c) ((p)[1] == 0 && (p)[0] == (c)) | | | | ------------------ | | | | | Branch (685:37): [True: 301, False: 12] | | | | | Branch (685:52): [True: 291, False: 10] | | | | ------------------ | | ------------------ ------------------ 149| 22| *nextTokPtr = ptr; 150| 22| return XML_TOK_INVALID; ------------------ | | 57| 22|# define XML_TOK_INVALID 0 ------------------ 151| 22| } 152| 291| ptr += MINBPC(enc); ------------------ | | 698| 291|#define MINBPC(enc) 2 ------------------ 153| 2.59k| while (HAS_CHAR(enc, ptr, end)) { 154| 2.59k| switch (BYTE_TYPE(enc, ptr)) { ------------------ | | 700| 2.59k|#define BYTE_TYPE(enc, p) LITTLE2_BYTE_TYPE(enc, p) | | ------------------ | | | | 683| 2.59k| ((p)[1] == 0 ? SB_BYTE_TYPE(enc, p) : unicode_byte_type((p)[1], (p)[0])) | | | | ------------------ | | | | | | 231| 724| (((const struct normal_encoding *)(enc))->type[(unsigned char)*(p)]) | | | | ------------------ | | | | | Branch (683:4): [True: 724, False: 1.86k] | | | | ------------------ | | ------------------ ------------------ 155| 891| INVALID_CASES(ptr, nextTokPtr) ------------------ | | 60| 0| INVALID_LEAD_CASE(2, ptr, nextTokPtr) \ | | ------------------ | | | | 49| 0| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (49:3): [True: 0, False: 2.59k] | | | | ------------------ | | | | 50| 0| if (end - ptr < n) \ | | | | ------------------ | | | | | Branch (50:9): [True: 0, False: 0] | | | | ------------------ | | | | 51| 0| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 0|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 52| 0| if (IS_INVALID_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 707| 0|#define IS_INVALID_CHAR(enc, p, n) LITTLE2_IS_INVALID_CHAR(p, n) | | | | | | ------------------ | | | | | | | | 694| 0| ((n) == 4 && ((unsigned char)(p)[3] & 0xFC) != 0xDC) | | | | | | | | ------------------ | | | | | | | | | Branch (694:4): [Folded, False: 0] | | | | | | | | | Branch (694:16): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 53| 0| *(nextTokPtr) = (ptr); \ | | | | 54| 0| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 0|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 55| 0| } \ | | | | 56| 0| ptr += n; \ | | | | 57| 0| break; | | ------------------ | | 61| 0| INVALID_LEAD_CASE(3, ptr, nextTokPtr) \ | | ------------------ | | | | 49| 0| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (49:3): [True: 0, False: 2.59k] | | | | ------------------ | | | | 50| 0| if (end - ptr < n) \ | | | | ------------------ | | | | | Branch (50:9): [True: 0, False: 0] | | | | ------------------ | | | | 51| 0| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 0|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 52| 0| if (IS_INVALID_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 707| 0|#define IS_INVALID_CHAR(enc, p, n) LITTLE2_IS_INVALID_CHAR(p, n) | | | | | | ------------------ | | | | | | | | 694| 0| ((n) == 4 && ((unsigned char)(p)[3] & 0xFC) != 0xDC) | | | | | | | | ------------------ | | | | | | | | | Branch (694:4): [Folded, False: 0] | | | | | | | | | Branch (694:16): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 53| 0| *(nextTokPtr) = (ptr); \ | | | | 54| 0| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 0|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 55| 0| } \ | | | | 56| 0| ptr += n; \ | | | | 57| 0| break; | | ------------------ | | 62| 444| INVALID_LEAD_CASE(4, ptr, nextTokPtr) \ | | ------------------ | | | | 49| 444| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (49:3): [True: 444, False: 2.14k] | | | | ------------------ | | | | 50| 444| if (end - ptr < n) \ | | | | ------------------ | | | | | Branch (50:9): [True: 1, False: 443] | | | | ------------------ | | | | 51| 402| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 1|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 52| 443| if (IS_INVALID_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 707| 443|#define IS_INVALID_CHAR(enc, p, n) LITTLE2_IS_INVALID_CHAR(p, n) | | | | | | ------------------ | | | | | | | | 694| 443| ((n) == 4 && ((unsigned char)(p)[3] & 0xFC) != 0xDC) | | | | | | | | ------------------ | | | | | | | | | Branch (694:4): [True: 443, Folded] | | | | | | | | | Branch (694:16): [True: 41, False: 402] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 53| 41| *(nextTokPtr) = (ptr); \ | | | | 54| 41| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 41|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 55| 41| } \ | | | | 56| 443| ptr += n; \ | | | | 57| 402| break; | | ------------------ | | 63| 402| case BT_NONXML: \ | | ------------------ | | | Branch (63:3): [True: 2, False: 2.59k] | | ------------------ | | 64| 2| case BT_MALFORM: \ | | ------------------ | | | Branch (64:3): [True: 0, False: 2.59k] | | ------------------ | | 65| 6| case BT_TRAIL: \ | | ------------------ | | | Branch (65:3): [True: 4, False: 2.58k] | | ------------------ | | 66| 6| *(nextTokPtr) = (ptr); \ | | 67| 6| return XML_TOK_INVALID; | | ------------------ | | | | 57| 6|# define XML_TOK_INVALID 0 | | ------------------ ------------------ 156| 334| case BT_MINUS: ------------------ | Branch (156:7): [True: 334, False: 2.25k] ------------------ 157| 334| ptr += MINBPC(enc); ------------------ | | 698| 334|#define MINBPC(enc) 2 ------------------ 158| 334| REQUIRE_CHAR(enc, ptr, end); ------------------ | | 140| 334|# define REQUIRE_CHAR(enc, ptr, end) REQUIRE_CHARS(enc, ptr, end, 1) | | ------------------ | | | | 134| 334| { \ | | | | 135| 334| if (! HAS_CHARS(enc, ptr, end, count)) { \ | | | | ------------------ | | | | | | 129| 334| ((end) - (ptr) >= ((count) * MINBPC(enc))) | | | | | | ------------------ | | | | | | | | 698| 334|#define MINBPC(enc) 2 | | | | | | ------------------ | | | | ------------------ | | | | | Branch (135:11): [True: 1, False: 333] | | | | ------------------ | | | | 136| 1| return XML_TOK_PARTIAL; \ | | | | ------------------ | | | | | | 56| 1|# define XML_TOK_PARTIAL -1 /* only part of a token */ | | | | ------------------ | | | | 137| 1| } \ | | | | 138| 334| } | | ------------------ ------------------ 159| 333| if (CHAR_MATCHES(enc, ptr, ASCII_MINUS)) { ------------------ | | 702| 333|#define CHAR_MATCHES(enc, p, c) LITTLE2_CHAR_MATCHES(p, c) | | ------------------ | | | | 685| 333|#define LITTLE2_CHAR_MATCHES(p, c) ((p)[1] == 0 && (p)[0] == (c)) | | | | ------------------ | | | | | Branch (685:37): [True: 264, False: 69] | | | | | Branch (685:52): [True: 188, False: 76] | | | | ------------------ | | ------------------ ------------------ 160| 188| ptr += MINBPC(enc); ------------------ | | 698| 188|#define MINBPC(enc) 2 ------------------ 161| 188| REQUIRE_CHAR(enc, ptr, end); ------------------ | | 140| 188|# define REQUIRE_CHAR(enc, ptr, end) REQUIRE_CHARS(enc, ptr, end, 1) | | ------------------ | | | | 134| 188| { \ | | | | 135| 188| if (! HAS_CHARS(enc, ptr, end, count)) { \ | | | | ------------------ | | | | | | 129| 188| ((end) - (ptr) >= ((count) * MINBPC(enc))) | | | | | | ------------------ | | | | | | | | 698| 188|#define MINBPC(enc) 2 | | | | | | ------------------ | | | | ------------------ | | | | | Branch (135:11): [True: 1, False: 187] | | | | ------------------ | | | | 136| 1| return XML_TOK_PARTIAL; \ | | | | ------------------ | | | | | | 56| 1|# define XML_TOK_PARTIAL -1 /* only part of a token */ | | | | ------------------ | | | | 137| 1| } \ | | | | 138| 188| } | | ------------------ ------------------ 162| 187| if (! CHAR_MATCHES(enc, ptr, ASCII_GT)) { ------------------ | | 702| 187|#define CHAR_MATCHES(enc, p, c) LITTLE2_CHAR_MATCHES(p, c) | | ------------------ | | | | 685| 187|#define LITTLE2_CHAR_MATCHES(p, c) ((p)[1] == 0 && (p)[0] == (c)) | | | | ------------------ | | | | | Branch (685:37): [True: 173, False: 14] | | | | | Branch (685:52): [True: 161, False: 12] | | | | ------------------ | | ------------------ ------------------ 163| 26| *nextTokPtr = ptr; 164| 26| return XML_TOK_INVALID; ------------------ | | 57| 26|# define XML_TOK_INVALID 0 ------------------ 165| 26| } 166| 161| *nextTokPtr = ptr + MINBPC(enc); ------------------ | | 698| 161|#define MINBPC(enc) 2 ------------------ 167| 161| return XML_TOK_COMMENT; ------------------ | | 78| 161|# define XML_TOK_COMMENT 13 ------------------ 168| 187| } 169| 145| break; 170| 1.80k| default: ------------------ | Branch (170:7): [True: 1.80k, False: 784] ------------------ 171| 1.80k| ptr += MINBPC(enc); ------------------ | | 698| 1.80k|#define MINBPC(enc) 2 ------------------ 172| 1.80k| break; 173| 2.59k| } 174| 2.59k| } 175| 291| } 176| 55| return XML_TOK_PARTIAL; ------------------ | | 56| 55|# define XML_TOK_PARTIAL -1 /* only part of a token */ ------------------ 177| 314|} xmltok.c:little2_scanPi: 277| 1.99k| const char **nextTokPtr) { 278| 1.99k| int tok; 279| 1.99k| const char *target = ptr; 280| 1.99k| REQUIRE_CHAR(enc, ptr, end); ------------------ | | 140| 1.99k|# define REQUIRE_CHAR(enc, ptr, end) REQUIRE_CHARS(enc, ptr, end, 1) | | ------------------ | | | | 134| 1.99k| { \ | | | | 135| 1.99k| if (! HAS_CHARS(enc, ptr, end, count)) { \ | | | | ------------------ | | | | | | 129| 1.99k| ((end) - (ptr) >= ((count) * MINBPC(enc))) | | | | | | ------------------ | | | | | | | | 698| 1.99k|#define MINBPC(enc) 2 | | | | | | ------------------ | | | | ------------------ | | | | | Branch (135:11): [True: 1, False: 1.99k] | | | | ------------------ | | | | 136| 1| return XML_TOK_PARTIAL; \ | | | | ------------------ | | | | | | 56| 1|# define XML_TOK_PARTIAL -1 /* only part of a token */ | | | | ------------------ | | | | 137| 1| } \ | | | | 138| 1.99k| } | | ------------------ ------------------ 281| 1.99k| switch (BYTE_TYPE(enc, ptr)) { ------------------ | | 700| 1.99k|#define BYTE_TYPE(enc, p) LITTLE2_BYTE_TYPE(enc, p) | | ------------------ | | | | 683| 1.99k| ((p)[1] == 0 ? SB_BYTE_TYPE(enc, p) : unicode_byte_type((p)[1], (p)[0])) | | | | ------------------ | | | | | | 231| 852| (((const struct normal_encoding *)(enc))->type[(unsigned char)*(p)]) | | | | ------------------ | | | | | Branch (683:4): [True: 852, False: 1.14k] | | | | ------------------ | | ------------------ ------------------ 282| 4.14k| CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr) ------------------ | | 110| 1.96k| case BT_NONASCII: \ | | ------------------ | | | Branch (110:3): [True: 1.12k, False: 867] | | ------------------ | | 111| 1.96k| if (! IS_NMSTRT_CHAR_MINBPC(enc, ptr)) { \ | | ------------------ | | | | 706| 1.12k|#define IS_NMSTRT_CHAR_MINBPC(enc, p) LITTLE2_IS_NMSTRT_CHAR_MINBPC(p) | | | | ------------------ | | | | | | 689| 1.12k| UCS2_GET_NAMING(nmstrtPages, (unsigned char)p[1], (unsigned char)p[0]) | | | | | | ------------------ | | | | | | | | 87| 1.12k| (namingBitmap[(pages[hi] << 3) + ((lo) >> 5)] & (1u << ((lo) & 0x1F))) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (111:9): [True: 18, False: 1.10k] | | ------------------ | | 112| 18| *nextTokPtr = ptr; \ | | 113| 18| return XML_TOK_INVALID; \ | | ------------------ | | | | 57| 18|# define XML_TOK_INVALID 0 | | ------------------ | | 114| 18| } \ | | 115| 1.96k| EXPAT_FALLTHROUGH; \ | | ------------------ | | | | 47| 1.10k|# define EXPAT_FALLTHROUGH __attribute__((fallthrough)) | | ------------------ | | 116| 1.89k| case BT_NMSTRT: \ | | ------------------ | | | Branch (116:3): [True: 783, False: 1.21k] | | ------------------ | | 117| 1.96k| case BT_HEX: \ | | ------------------ | | | Branch (117:3): [True: 69, False: 1.92k] | | ------------------ | | 118| 1.96k| ptr += MINBPC(enc); \ | | ------------------ | | | | 698| 1.96k|#define MINBPC(enc) 2 | | ------------------ | | 119| 1.96k| break; \ | | 120| 1.96k| CHECK_NMSTRT_CASE(2, enc, ptr, end, nextTokPtr) \ | | ------------------ | | | | 99| 0| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (99:3): [True: 0, False: 1.99k] | | | | ------------------ | | | | 100| 0| if ((end) - (ptr) < (n)) \ | | | | ------------------ | | | | | Branch (100:9): [True: 0, False: 0] | | | | ------------------ | | | | 101| 0| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 0|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 102| 0| if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NMSTRT_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 707| 0|#define IS_INVALID_CHAR(enc, p, n) LITTLE2_IS_INVALID_CHAR(p, n) | | | | | | ------------------ | | | | | | | | 694| 0| ((n) == 4 && ((unsigned char)(p)[3] & 0xFC) != 0xDC) | | | | | | | | ------------------ | | | | | | | | | Branch (694:4): [Folded, False: 0] | | | | | | | | | Branch (694:16): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NMSTRT_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 705| 0|#define IS_NMSTRT_CHAR(enc, p, n) (0) | | | | ------------------ | | | | | Branch (102:41): [True: 0, Folded] | | | | ------------------ | | | | 103| 0| *nextTokPtr = ptr; \ | | | | 104| 0| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 0|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 105| 0| } \ | | | | 106| 0| ptr += n; \ | | | | 107| 0| break; | | ------------------ | | 121| 0| CHECK_NMSTRT_CASE(3, enc, ptr, end, nextTokPtr) \ | | ------------------ | | | | 99| 0| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (99:3): [True: 0, False: 1.99k] | | | | ------------------ | | | | 100| 0| if ((end) - (ptr) < (n)) \ | | | | ------------------ | | | | | Branch (100:9): [True: 0, False: 0] | | | | ------------------ | | | | 101| 0| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 0|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 102| 0| if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NMSTRT_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 707| 0|#define IS_INVALID_CHAR(enc, p, n) LITTLE2_IS_INVALID_CHAR(p, n) | | | | | | ------------------ | | | | | | | | 694| 0| ((n) == 4 && ((unsigned char)(p)[3] & 0xFC) != 0xDC) | | | | | | | | ------------------ | | | | | | | | | Branch (694:4): [Folded, False: 0] | | | | | | | | | Branch (694:16): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NMSTRT_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 705| 0|#define IS_NMSTRT_CHAR(enc, p, n) (0) | | | | ------------------ | | | | | Branch (102:41): [True: 0, Folded] | | | | ------------------ | | | | 103| 0| *nextTokPtr = ptr; \ | | | | 104| 0| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 0|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 105| 0| } \ | | | | 106| 0| ptr += n; \ | | | | 107| 0| break; | | ------------------ | | 122| 10| CHECK_NMSTRT_CASE(4, enc, ptr, end, nextTokPtr) | | ------------------ | | | | 99| 10| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (99:3): [True: 10, False: 1.98k] | | | | ------------------ | | | | 100| 10| if ((end) - (ptr) < (n)) \ | | | | ------------------ | | | | | Branch (100:9): [True: 1, False: 9] | | | | ------------------ | | | | 101| 1| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 1|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 102| 9| if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NMSTRT_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 707| 9|#define IS_INVALID_CHAR(enc, p, n) LITTLE2_IS_INVALID_CHAR(p, n) | | | | | | ------------------ | | | | | | | | 694| 18| ((n) == 4 && ((unsigned char)(p)[3] & 0xFC) != 0xDC) | | | | | | | | ------------------ | | | | | | | | | Branch (694:4): [True: 9, Folded] | | | | | | | | | Branch (694:16): [True: 9, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NMSTRT_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 705| 0|#define IS_NMSTRT_CHAR(enc, p, n) (0) | | | | ------------------ | | | | | Branch (102:41): [True: 0, Folded] | | | | ------------------ | | | | 103| 9| *nextTokPtr = ptr; \ | | | | 104| 9| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 9|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 105| 9| } \ | | | | 106| 9| ptr += n; \ | | | | 107| 0| break; | | ------------------ ------------------ 283| 5| default: ------------------ | Branch (283:3): [True: 5, False: 1.98k] ------------------ 284| 5| *nextTokPtr = ptr; 285| 5| return XML_TOK_INVALID; ------------------ | | 57| 5|# define XML_TOK_INVALID 0 ------------------ 286| 1.99k| } 287| 5.65k| while (HAS_CHAR(enc, ptr, end)) { 288| 5.65k| switch (BYTE_TYPE(enc, ptr)) { ------------------ | | 700| 5.65k|#define BYTE_TYPE(enc, p) LITTLE2_BYTE_TYPE(enc, p) | | ------------------ | | | | 683| 5.65k| ((p)[1] == 0 ? SB_BYTE_TYPE(enc, p) : unicode_byte_type((p)[1], (p)[0])) | | | | ------------------ | | | | | | 231| 3.65k| (((const struct normal_encoding *)(enc))->type[(unsigned char)*(p)]) | | | | ------------------ | | | | | Branch (683:4): [True: 3.65k, False: 2.00k] | | | | ------------------ | | ------------------ ------------------ 289| 15.9k| CHECK_NAME_CASES(enc, ptr, end, nextTokPtr) ------------------ | | 81| 3.69k| case BT_NONASCII: \ | | ------------------ | | | Branch (81:3): [True: 1.98k, False: 3.66k] | | ------------------ | | 82| 3.69k| if (! IS_NAME_CHAR_MINBPC(enc, ptr)) { \ | | ------------------ | | | | 704| 1.98k|#define IS_NAME_CHAR_MINBPC(enc, p) LITTLE2_IS_NAME_CHAR_MINBPC(p) | | | | ------------------ | | | | | | 687| 1.98k| UCS2_GET_NAMING(namePages, (unsigned char)p[1], (unsigned char)p[0]) | | | | | | ------------------ | | | | | | | | 87| 1.98k| (namingBitmap[(pages[hi] << 3) + ((lo) >> 5)] & (1u << ((lo) & 0x1F))) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (82:9): [True: 45, False: 1.94k] | | ------------------ | | 83| 45| *nextTokPtr = ptr; \ | | 84| 45| return XML_TOK_INVALID; \ | | ------------------ | | | | 57| 45|# define XML_TOK_INVALID 0 | | ------------------ | | 85| 45| } \ | | 86| 3.69k| EXPAT_FALLTHROUGH; \ | | ------------------ | | | | 47| 1.94k|# define EXPAT_FALLTHROUGH __attribute__((fallthrough)) | | ------------------ | | 87| 2.62k| case BT_NMSTRT: \ | | ------------------ | | | Branch (87:3): [True: 684, False: 4.96k] | | ------------------ | | 88| 2.82k| case BT_HEX: \ | | ------------------ | | | Branch (88:3): [True: 204, False: 5.44k] | | ------------------ | | 89| 3.08k| case BT_DIGIT: \ | | ------------------ | | | Branch (89:3): [True: 259, False: 5.39k] | | ------------------ | | 90| 3.47k| case BT_NAME: \ | | ------------------ | | | Branch (90:3): [True: 390, False: 5.26k] | | ------------------ | | 91| 3.69k| case BT_MINUS: \ | | ------------------ | | | Branch (91:3): [True: 217, False: 5.43k] | | ------------------ | | 92| 3.69k| ptr += MINBPC(enc); \ | | ------------------ | | | | 698| 3.69k|#define MINBPC(enc) 2 | | ------------------ | | 93| 3.69k| break; \ | | 94| 3.69k| CHECK_NAME_CASE(2, enc, ptr, end, nextTokPtr) \ | | ------------------ | | | | 70| 0| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (70:3): [True: 0, False: 5.65k] | | | | ------------------ | | | | 71| 0| if (end - ptr < n) \ | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 0] | | | | ------------------ | | | | 72| 0| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 0|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 73| 0| if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NAME_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 707| 0|#define IS_INVALID_CHAR(enc, p, n) LITTLE2_IS_INVALID_CHAR(p, n) | | | | | | ------------------ | | | | | | | | 694| 0| ((n) == 4 && ((unsigned char)(p)[3] & 0xFC) != 0xDC) | | | | | | | | ------------------ | | | | | | | | | Branch (694:4): [Folded, False: 0] | | | | | | | | | Branch (694:16): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NAME_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 703| 0|#define IS_NAME_CHAR(enc, p, n) 0 | | | | ------------------ | | | | | Branch (73:41): [True: 0, Folded] | | | | ------------------ | | | | 74| 0| *nextTokPtr = ptr; \ | | | | 75| 0| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 0|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 76| 0| } \ | | | | 77| 0| ptr += n; \ | | | | 78| 0| break; | | ------------------ | | 95| 0| CHECK_NAME_CASE(3, enc, ptr, end, nextTokPtr) \ | | ------------------ | | | | 70| 0| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (70:3): [True: 0, False: 5.65k] | | | | ------------------ | | | | 71| 0| if (end - ptr < n) \ | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 0] | | | | ------------------ | | | | 72| 0| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 0|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 73| 0| if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NAME_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 707| 0|#define IS_INVALID_CHAR(enc, p, n) LITTLE2_IS_INVALID_CHAR(p, n) | | | | | | ------------------ | | | | | | | | 694| 0| ((n) == 4 && ((unsigned char)(p)[3] & 0xFC) != 0xDC) | | | | | | | | ------------------ | | | | | | | | | Branch (694:4): [Folded, False: 0] | | | | | | | | | Branch (694:16): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NAME_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 703| 0|#define IS_NAME_CHAR(enc, p, n) 0 | | | | ------------------ | | | | | Branch (73:41): [True: 0, Folded] | | | | ------------------ | | | | 74| 0| *nextTokPtr = ptr; \ | | | | 75| 0| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 0|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 76| 0| } \ | | | | 77| 0| ptr += n; \ | | | | 78| 0| break; | | ------------------ | | 96| 10| CHECK_NAME_CASE(4, enc, ptr, end, nextTokPtr) | | ------------------ | | | | 70| 10| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (70:3): [True: 10, False: 5.64k] | | | | ------------------ | | | | 71| 10| if (end - ptr < n) \ | | | | ------------------ | | | | | Branch (71:9): [True: 1, False: 9] | | | | ------------------ | | | | 72| 1| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 1|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 73| 9| if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NAME_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 707| 9|#define IS_INVALID_CHAR(enc, p, n) LITTLE2_IS_INVALID_CHAR(p, n) | | | | | | ------------------ | | | | | | | | 694| 18| ((n) == 4 && ((unsigned char)(p)[3] & 0xFC) != 0xDC) | | | | | | | | ------------------ | | | | | | | | | Branch (694:4): [True: 9, Folded] | | | | | | | | | Branch (694:16): [True: 9, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NAME_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 703| 0|#define IS_NAME_CHAR(enc, p, n) 0 | | | | ------------------ | | | | | Branch (73:41): [True: 0, Folded] | | | | ------------------ | | | | 74| 9| *nextTokPtr = ptr; \ | | | | 75| 9| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 9|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 76| 9| } \ | | | | 77| 9| ptr += n; \ | | | | 78| 0| break; | | ------------------ ------------------ 290| 689| case BT_S: ------------------ | Branch (290:5): [True: 689, False: 4.96k] ------------------ 291| 768| case BT_CR: ------------------ | Branch (291:5): [True: 79, False: 5.57k] ------------------ 292| 842| case BT_LF: ------------------ | Branch (292:5): [True: 74, False: 5.57k] ------------------ 293| 842| if (! PREFIX(checkPiTarget)(enc, target, ptr, &tok)) { ------------------ | | 697| 842|#define PREFIX(ident) little2_##ident ------------------ | Branch (293:11): [True: 1, False: 841] ------------------ 294| 1| *nextTokPtr = ptr; 295| 1| return XML_TOK_INVALID; ------------------ | | 57| 1|# define XML_TOK_INVALID 0 ------------------ 296| 1| } 297| 841| ptr += MINBPC(enc); ------------------ | | 698| 841|#define MINBPC(enc) 2 ------------------ 298| 4.45k| while (HAS_CHAR(enc, ptr, end)) { 299| 4.45k| switch (BYTE_TYPE(enc, ptr)) { ------------------ | | 700| 4.45k|#define BYTE_TYPE(enc, p) LITTLE2_BYTE_TYPE(enc, p) | | ------------------ | | | | 683| 4.45k| ((p)[1] == 0 ? SB_BYTE_TYPE(enc, p) : unicode_byte_type((p)[1], (p)[0])) | | | | ------------------ | | | | | | 231| 1.77k| (((const struct normal_encoding *)(enc))->type[(unsigned char)*(p)]) | | | | ------------------ | | | | | Branch (683:4): [True: 1.77k, False: 2.68k] | | | | ------------------ | | ------------------ ------------------ 300| 825| INVALID_CASES(ptr, nextTokPtr) ------------------ | | 60| 0| INVALID_LEAD_CASE(2, ptr, nextTokPtr) \ | | ------------------ | | | | 49| 0| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (49:3): [True: 0, False: 4.45k] | | | | ------------------ | | | | 50| 0| if (end - ptr < n) \ | | | | ------------------ | | | | | Branch (50:9): [True: 0, False: 0] | | | | ------------------ | | | | 51| 0| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 0|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 52| 0| if (IS_INVALID_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 707| 0|#define IS_INVALID_CHAR(enc, p, n) LITTLE2_IS_INVALID_CHAR(p, n) | | | | | | ------------------ | | | | | | | | 694| 0| ((n) == 4 && ((unsigned char)(p)[3] & 0xFC) != 0xDC) | | | | | | | | ------------------ | | | | | | | | | Branch (694:4): [Folded, False: 0] | | | | | | | | | Branch (694:16): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 53| 0| *(nextTokPtr) = (ptr); \ | | | | 54| 0| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 0|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 55| 0| } \ | | | | 56| 0| ptr += n; \ | | | | 57| 0| break; | | ------------------ | | 61| 0| INVALID_LEAD_CASE(3, ptr, nextTokPtr) \ | | ------------------ | | | | 49| 0| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (49:3): [True: 0, False: 4.45k] | | | | ------------------ | | | | 50| 0| if (end - ptr < n) \ | | | | ------------------ | | | | | Branch (50:9): [True: 0, False: 0] | | | | ------------------ | | | | 51| 0| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 0|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 52| 0| if (IS_INVALID_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 707| 0|#define IS_INVALID_CHAR(enc, p, n) LITTLE2_IS_INVALID_CHAR(p, n) | | | | | | ------------------ | | | | | | | | 694| 0| ((n) == 4 && ((unsigned char)(p)[3] & 0xFC) != 0xDC) | | | | | | | | ------------------ | | | | | | | | | Branch (694:4): [Folded, False: 0] | | | | | | | | | Branch (694:16): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 53| 0| *(nextTokPtr) = (ptr); \ | | | | 54| 0| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 0|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 55| 0| } \ | | | | 56| 0| ptr += n; \ | | | | 57| 0| break; | | ------------------ | | 62| 411| INVALID_LEAD_CASE(4, ptr, nextTokPtr) \ | | ------------------ | | | | 49| 411| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (49:3): [True: 411, False: 4.04k] | | | | ------------------ | | | | 50| 411| if (end - ptr < n) \ | | | | ------------------ | | | | | Branch (50:9): [True: 1, False: 410] | | | | ------------------ | | | | 51| 384| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 1|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 52| 410| if (IS_INVALID_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 707| 410|#define IS_INVALID_CHAR(enc, p, n) LITTLE2_IS_INVALID_CHAR(p, n) | | | | | | ------------------ | | | | | | | | 694| 410| ((n) == 4 && ((unsigned char)(p)[3] & 0xFC) != 0xDC) | | | | | | | | ------------------ | | | | | | | | | Branch (694:4): [True: 410, Folded] | | | | | | | | | Branch (694:16): [True: 26, False: 384] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 53| 26| *(nextTokPtr) = (ptr); \ | | | | 54| 26| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 26|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 55| 26| } \ | | | | 56| 410| ptr += n; \ | | | | 57| 384| break; | | ------------------ | | 63| 384| case BT_NONXML: \ | | ------------------ | | | Branch (63:3): [True: 2, False: 4.45k] | | ------------------ | | 64| 2| case BT_MALFORM: \ | | ------------------ | | | Branch (64:3): [True: 0, False: 4.45k] | | ------------------ | | 65| 9| case BT_TRAIL: \ | | ------------------ | | | Branch (65:3): [True: 7, False: 4.45k] | | ------------------ | | 66| 9| *(nextTokPtr) = (ptr); \ | | 67| 9| return XML_TOK_INVALID; | | ------------------ | | | | 57| 9|# define XML_TOK_INVALID 0 | | ------------------ ------------------ 301| 1.17k| case BT_QUEST: ------------------ | Branch (301:9): [True: 1.17k, False: 3.27k] ------------------ 302| 1.17k| ptr += MINBPC(enc); ------------------ | | 698| 1.17k|#define MINBPC(enc) 2 ------------------ 303| 1.17k| REQUIRE_CHAR(enc, ptr, end); ------------------ | | 140| 1.17k|# define REQUIRE_CHAR(enc, ptr, end) REQUIRE_CHARS(enc, ptr, end, 1) | | ------------------ | | | | 134| 1.17k| { \ | | | | 135| 1.17k| if (! HAS_CHARS(enc, ptr, end, count)) { \ | | | | ------------------ | | | | | | 129| 1.17k| ((end) - (ptr) >= ((count) * MINBPC(enc))) | | | | | | ------------------ | | | | | | | | 698| 1.17k|#define MINBPC(enc) 2 | | | | | | ------------------ | | | | ------------------ | | | | | Branch (135:11): [True: 8, False: 1.17k] | | | | ------------------ | | | | 136| 8| return XML_TOK_PARTIAL; \ | | | | ------------------ | | | | | | 56| 8|# define XML_TOK_PARTIAL -1 /* only part of a token */ | | | | ------------------ | | | | 137| 8| } \ | | | | 138| 1.17k| } | | ------------------ ------------------ 304| 1.17k| if (CHAR_MATCHES(enc, ptr, ASCII_GT)) { ------------------ | | 702| 1.17k|#define CHAR_MATCHES(enc, p, c) LITTLE2_CHAR_MATCHES(p, c) | | ------------------ | | | | 685| 1.17k|#define LITTLE2_CHAR_MATCHES(p, c) ((p)[1] == 0 && (p)[0] == (c)) | | | | ------------------ | | | | | Branch (685:37): [True: 880, False: 290] | | | | | Branch (685:52): [True: 635, False: 245] | | | | ------------------ | | ------------------ ------------------ 305| 635| *nextTokPtr = ptr + MINBPC(enc); ------------------ | | 698| 635|#define MINBPC(enc) 2 ------------------ 306| 635| return tok; 307| 635| } 308| 535| break; 309| 2.85k| default: ------------------ | Branch (309:9): [True: 2.85k, False: 1.59k] ------------------ 310| 2.85k| ptr += MINBPC(enc); ------------------ | | 698| 2.85k|#define MINBPC(enc) 2 ------------------ 311| 2.85k| break; 312| 4.45k| } 313| 4.45k| } 314| 162| return XML_TOK_PARTIAL; ------------------ | | 56| 162|# define XML_TOK_PARTIAL -1 /* only part of a token */ ------------------ 315| 1.05k| case BT_QUEST: ------------------ | Branch (315:5): [True: 1.05k, False: 4.59k] ------------------ 316| 1.05k| if (! PREFIX(checkPiTarget)(enc, target, ptr, &tok)) { ------------------ | | 697| 1.05k|#define PREFIX(ident) little2_##ident ------------------ | Branch (316:11): [True: 1, False: 1.05k] ------------------ 317| 1| *nextTokPtr = ptr; 318| 1| return XML_TOK_INVALID; ------------------ | | 57| 1|# define XML_TOK_INVALID 0 ------------------ 319| 1| } 320| 1.05k| ptr += MINBPC(enc); ------------------ | | 698| 1.05k|#define MINBPC(enc) 2 ------------------ 321| 1.05k| REQUIRE_CHAR(enc, ptr, end); ------------------ | | 140| 1.05k|# define REQUIRE_CHAR(enc, ptr, end) REQUIRE_CHARS(enc, ptr, end, 1) | | ------------------ | | | | 134| 1.05k| { \ | | | | 135| 1.05k| if (! HAS_CHARS(enc, ptr, end, count)) { \ | | | | ------------------ | | | | | | 129| 1.05k| ((end) - (ptr) >= ((count) * MINBPC(enc))) | | | | | | ------------------ | | | | | | | | 698| 1.05k|#define MINBPC(enc) 2 | | | | | | ------------------ | | | | ------------------ | | | | | Branch (135:11): [True: 1, False: 1.05k] | | | | ------------------ | | | | 136| 1| return XML_TOK_PARTIAL; \ | | | | ------------------ | | | | | | 56| 1|# define XML_TOK_PARTIAL -1 /* only part of a token */ | | | | ------------------ | | | | 137| 1| } \ | | | | 138| 1.05k| } | | ------------------ ------------------ 322| 1.05k| if (CHAR_MATCHES(enc, ptr, ASCII_GT)) { ------------------ | | 702| 1.05k|#define CHAR_MATCHES(enc, p, c) LITTLE2_CHAR_MATCHES(p, c) | | ------------------ | | | | 685| 1.05k|#define LITTLE2_CHAR_MATCHES(p, c) ((p)[1] == 0 && (p)[0] == (c)) | | | | ------------------ | | | | | Branch (685:37): [True: 1.02k, False: 31] | | | | | Branch (685:52): [True: 1.01k, False: 9] | | | | ------------------ | | ------------------ ------------------ 323| 1.01k| *nextTokPtr = ptr + MINBPC(enc); ------------------ | | 698| 1.01k|#define MINBPC(enc) 2 ------------------ 324| 1.01k| return tok; 325| 1.01k| } 326| 40| EXPAT_FALLTHROUGH; ------------------ | | 47| 40|# define EXPAT_FALLTHROUGH __attribute__((fallthrough)) ------------------ 327| 47| default: ------------------ | Branch (327:5): [True: 7, False: 5.64k] ------------------ 328| 47| *nextTokPtr = ptr; 329| 47| return XML_TOK_INVALID; ------------------ | | 57| 47|# define XML_TOK_INVALID 0 ------------------ 330| 5.65k| } 331| 5.65k| } 332| 2| return XML_TOK_PARTIAL; ------------------ | | 56| 2|# define XML_TOK_PARTIAL -1 /* only part of a token */ ------------------ 333| 1.96k|} xmltok.c:little2_checkPiTarget: 232| 1.89k| int *tokPtr) { 233| 1.89k| int upper = 0; 234| 1.89k| UNUSED_P(enc); ------------------ | | 101| 1.89k|# define UNUSED_P(p) (void)p ------------------ 235| 1.89k| *tokPtr = XML_TOK_PI; ------------------ | | 76| 1.89k|# define XML_TOK_PI 11 /* processing instruction */ ------------------ 236| 1.89k| if (end - ptr != MINBPC(enc) * 3) ------------------ | | 698| 1.89k|#define MINBPC(enc) 2 ------------------ | Branch (236:7): [True: 1.01k, False: 883] ------------------ 237| 1.01k| return 1; 238| 883| switch (BYTE_TO_ASCII(enc, ptr)) { ------------------ | | 701| 883|#define BYTE_TO_ASCII(enc, p) LITTLE2_BYTE_TO_ASCII(p) | | ------------------ | | | | 684| 883|#define LITTLE2_BYTE_TO_ASCII(p) ((p)[1] == 0 ? (p)[0] : -1) | | | | ------------------ | | | | | Branch (684:35): [True: 747, False: 136] | | | | ------------------ | | ------------------ ------------------ 239| 388| case ASCII_x: ------------------ | | 88| 388|#define ASCII_x 0x78 ------------------ | Branch (239:3): [True: 388, False: 495] ------------------ 240| 388| break; 241| 358| case ASCII_X: ------------------ | | 61| 358|#define ASCII_X 0x58 ------------------ | Branch (241:3): [True: 358, False: 525] ------------------ 242| 358| upper = 1; 243| 358| break; 244| 137| default: ------------------ | Branch (244:3): [True: 137, False: 746] ------------------ 245| 137| return 1; 246| 883| } 247| 746| ptr += MINBPC(enc); ------------------ | | 698| 746|#define MINBPC(enc) 2 ------------------ 248| 746| switch (BYTE_TO_ASCII(enc, ptr)) { ------------------ | | 701| 746|#define BYTE_TO_ASCII(enc, p) LITTLE2_BYTE_TO_ASCII(p) | | ------------------ | | | | 684| 746|#define LITTLE2_BYTE_TO_ASCII(p) ((p)[1] == 0 ? (p)[0] : -1) | | | | ------------------ | | | | | Branch (684:35): [True: 449, False: 297] | | | | ------------------ | | ------------------ ------------------ 249| 233| case ASCII_m: ------------------ | | 77| 233|#define ASCII_m 0x6D ------------------ | Branch (249:3): [True: 233, False: 513] ------------------ 250| 233| break; 251| 214| case ASCII_M: ------------------ | | 50| 214|#define ASCII_M 0x4D ------------------ | Branch (251:3): [True: 214, False: 532] ------------------ 252| 214| upper = 1; 253| 214| break; 254| 299| default: ------------------ | Branch (254:3): [True: 299, False: 447] ------------------ 255| 299| return 1; 256| 746| } 257| 447| ptr += MINBPC(enc); ------------------ | | 698| 447|#define MINBPC(enc) 2 ------------------ 258| 447| switch (BYTE_TO_ASCII(enc, ptr)) { ------------------ | | 701| 447|#define BYTE_TO_ASCII(enc, p) LITTLE2_BYTE_TO_ASCII(p) | | ------------------ | | | | 684| 447|#define LITTLE2_BYTE_TO_ASCII(p) ((p)[1] == 0 ? (p)[0] : -1) | | | | ------------------ | | | | | Branch (684:35): [True: 157, False: 290] | | | | ------------------ | | ------------------ ------------------ 259| 25| case ASCII_l: ------------------ | | 76| 25|#define ASCII_l 0x6C ------------------ | Branch (259:3): [True: 25, False: 422] ------------------ 260| 25| break; 261| 2| case ASCII_L: ------------------ | | 49| 2|#define ASCII_L 0x4C ------------------ | Branch (261:3): [True: 2, False: 445] ------------------ 262| 2| upper = 1; 263| 2| break; 264| 420| default: ------------------ | Branch (264:3): [True: 420, False: 27] ------------------ 265| 420| return 1; 266| 447| } 267| 27| if (upper) ------------------ | Branch (267:7): [True: 2, False: 25] ------------------ 268| 2| return 0; 269| 25| *tokPtr = XML_TOK_XML_DECL; ------------------ | | 77| 25|# define XML_TOK_XML_DECL 12 /* XML decl or text decl */ ------------------ 270| 25| return 1; 271| 27|} xmltok.c:little2_scanPercent: 924| 99| const char **nextTokPtr) { 925| 99| REQUIRE_CHAR(enc, ptr, end); ------------------ | | 140| 99|# define REQUIRE_CHAR(enc, ptr, end) REQUIRE_CHARS(enc, ptr, end, 1) | | ------------------ | | | | 134| 99| { \ | | | | 135| 99| if (! HAS_CHARS(enc, ptr, end, count)) { \ | | | | ------------------ | | | | | | 129| 99| ((end) - (ptr) >= ((count) * MINBPC(enc))) | | | | | | ------------------ | | | | | | | | 698| 99|#define MINBPC(enc) 2 | | | | | | ------------------ | | | | ------------------ | | | | | Branch (135:11): [True: 1, False: 98] | | | | ------------------ | | | | 136| 1| return XML_TOK_PARTIAL; \ | | | | ------------------ | | | | | | 56| 1|# define XML_TOK_PARTIAL -1 /* only part of a token */ | | | | ------------------ | | | | 137| 1| } \ | | | | 138| 99| } | | ------------------ ------------------ 926| 98| switch (BYTE_TYPE(enc, ptr)) { ------------------ | | 700| 98|#define BYTE_TYPE(enc, p) LITTLE2_BYTE_TYPE(enc, p) | | ------------------ | | | | 683| 98| ((p)[1] == 0 ? SB_BYTE_TYPE(enc, p) : unicode_byte_type((p)[1], (p)[0])) | | | | ------------------ | | | | | | 231| 12| (((const struct normal_encoding *)(enc))->type[(unsigned char)*(p)]) | | | | ------------------ | | | | | Branch (683:4): [True: 12, False: 86] | | | | ------------------ | | ------------------ ------------------ 927| 204| CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr) ------------------ | | 110| 65| case BT_NONASCII: \ | | ------------------ | | | Branch (110:3): [True: 74, False: 24] | | ------------------ | | 111| 74| if (! IS_NMSTRT_CHAR_MINBPC(enc, ptr)) { \ | | ------------------ | | | | 706| 74|#define IS_NMSTRT_CHAR_MINBPC(enc, p) LITTLE2_IS_NMSTRT_CHAR_MINBPC(p) | | | | ------------------ | | | | | | 689| 74| UCS2_GET_NAMING(nmstrtPages, (unsigned char)p[1], (unsigned char)p[0]) | | | | | | ------------------ | | | | | | | | 87| 74| (namingBitmap[(pages[hi] << 3) + ((lo) >> 5)] & (1u << ((lo) & 0x1F))) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (111:9): [True: 17, False: 57] | | ------------------ | | 112| 17| *nextTokPtr = ptr; \ | | 113| 17| return XML_TOK_INVALID; \ | | ------------------ | | | | 57| 17|# define XML_TOK_INVALID 0 | | ------------------ | | 114| 17| } \ | | 115| 65| EXPAT_FALLTHROUGH; \ | | ------------------ | | | | 47| 57|# define EXPAT_FALLTHROUGH __attribute__((fallthrough)) | | ------------------ | | 116| 60| case BT_NMSTRT: \ | | ------------------ | | | Branch (116:3): [True: 3, False: 95] | | ------------------ | | 117| 65| case BT_HEX: \ | | ------------------ | | | Branch (117:3): [True: 5, False: 93] | | ------------------ | | 118| 65| ptr += MINBPC(enc); \ | | ------------------ | | | | 698| 65|#define MINBPC(enc) 2 | | ------------------ | | 119| 65| break; \ | | 120| 65| CHECK_NMSTRT_CASE(2, enc, ptr, end, nextTokPtr) \ | | ------------------ | | | | 99| 0| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (99:3): [True: 0, False: 98] | | | | ------------------ | | | | 100| 0| if ((end) - (ptr) < (n)) \ | | | | ------------------ | | | | | Branch (100:9): [True: 0, False: 0] | | | | ------------------ | | | | 101| 0| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 0|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 102| 0| if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NMSTRT_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 707| 0|#define IS_INVALID_CHAR(enc, p, n) LITTLE2_IS_INVALID_CHAR(p, n) | | | | | | ------------------ | | | | | | | | 694| 0| ((n) == 4 && ((unsigned char)(p)[3] & 0xFC) != 0xDC) | | | | | | | | ------------------ | | | | | | | | | Branch (694:4): [Folded, False: 0] | | | | | | | | | Branch (694:16): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NMSTRT_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 705| 0|#define IS_NMSTRT_CHAR(enc, p, n) (0) | | | | ------------------ | | | | | Branch (102:41): [True: 0, Folded] | | | | ------------------ | | | | 103| 0| *nextTokPtr = ptr; \ | | | | 104| 0| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 0|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 105| 0| } \ | | | | 106| 0| ptr += n; \ | | | | 107| 0| break; | | ------------------ | | 121| 0| CHECK_NMSTRT_CASE(3, enc, ptr, end, nextTokPtr) \ | | ------------------ | | | | 99| 0| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (99:3): [True: 0, False: 98] | | | | ------------------ | | | | 100| 0| if ((end) - (ptr) < (n)) \ | | | | ------------------ | | | | | Branch (100:9): [True: 0, False: 0] | | | | ------------------ | | | | 101| 0| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 0|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 102| 0| if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NMSTRT_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 707| 0|#define IS_INVALID_CHAR(enc, p, n) LITTLE2_IS_INVALID_CHAR(p, n) | | | | | | ------------------ | | | | | | | | 694| 0| ((n) == 4 && ((unsigned char)(p)[3] & 0xFC) != 0xDC) | | | | | | | | ------------------ | | | | | | | | | Branch (694:4): [Folded, False: 0] | | | | | | | | | Branch (694:16): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NMSTRT_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 705| 0|#define IS_NMSTRT_CHAR(enc, p, n) (0) | | | | ------------------ | | | | | Branch (102:41): [True: 0, Folded] | | | | ------------------ | | | | 103| 0| *nextTokPtr = ptr; \ | | | | 104| 0| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 0|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 105| 0| } \ | | | | 106| 0| ptr += n; \ | | | | 107| 0| break; | | ------------------ | | 122| 7| CHECK_NMSTRT_CASE(4, enc, ptr, end, nextTokPtr) | | ------------------ | | | | 99| 7| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (99:3): [True: 7, False: 91] | | | | ------------------ | | | | 100| 7| if ((end) - (ptr) < (n)) \ | | | | ------------------ | | | | | Branch (100:9): [True: 1, False: 6] | | | | ------------------ | | | | 101| 1| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 1|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 102| 6| if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NMSTRT_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 707| 6|#define IS_INVALID_CHAR(enc, p, n) LITTLE2_IS_INVALID_CHAR(p, n) | | | | | | ------------------ | | | | | | | | 694| 12| ((n) == 4 && ((unsigned char)(p)[3] & 0xFC) != 0xDC) | | | | | | | | ------------------ | | | | | | | | | Branch (694:4): [True: 6, Folded] | | | | | | | | | Branch (694:16): [True: 6, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NMSTRT_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 705| 0|#define IS_NMSTRT_CHAR(enc, p, n) (0) | | | | ------------------ | | | | | Branch (102:41): [True: 0, Folded] | | | | ------------------ | | | | 103| 6| *nextTokPtr = ptr; \ | | | | 104| 6| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 6|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 105| 6| } \ | | | | 106| 6| ptr += n; \ | | | | 107| 0| break; | | ------------------ ------------------ 928| 1| case BT_S: ------------------ | Branch (928:3): [True: 1, False: 97] ------------------ 929| 2| case BT_LF: ------------------ | Branch (929:3): [True: 1, False: 97] ------------------ 930| 3| case BT_CR: ------------------ | Branch (930:3): [True: 1, False: 97] ------------------ 931| 4| case BT_PERCNT: ------------------ | Branch (931:3): [True: 1, False: 97] ------------------ 932| 4| *nextTokPtr = ptr; 933| 4| return XML_TOK_PERCENT; ------------------ | | 89| 4|# define XML_TOK_PERCENT 22 ------------------ 934| 5| default: ------------------ | Branch (934:3): [True: 5, False: 93] ------------------ 935| 5| *nextTokPtr = ptr; 936| 5| return XML_TOK_INVALID; ------------------ | | 57| 5|# define XML_TOK_INVALID 0 ------------------ 937| 98| } 938| 1.50k| while (HAS_CHAR(enc, ptr, end)) { 939| 1.50k| switch (BYTE_TYPE(enc, ptr)) { ------------------ | | 700| 1.50k|#define BYTE_TYPE(enc, p) LITTLE2_BYTE_TYPE(enc, p) | | ------------------ | | | | 683| 1.50k| ((p)[1] == 0 ? SB_BYTE_TYPE(enc, p) : unicode_byte_type((p)[1], (p)[0])) | | | | ------------------ | | | | | | 231| 1.12k| (((const struct normal_encoding *)(enc))->type[(unsigned char)*(p)]) | | | | ------------------ | | | | | Branch (683:4): [True: 1.12k, False: 379] | | | | ------------------ | | ------------------ ------------------ 940| 4.35k| CHECK_NAME_CASES(enc, ptr, end, nextTokPtr) ------------------ | | 81| 1.43k| case BT_NONASCII: \ | | ------------------ | | | Branch (81:3): [True: 363, False: 1.13k] | | ------------------ | | 82| 1.43k| if (! IS_NAME_CHAR_MINBPC(enc, ptr)) { \ | | ------------------ | | | | 704| 363|#define IS_NAME_CHAR_MINBPC(enc, p) LITTLE2_IS_NAME_CHAR_MINBPC(p) | | | | ------------------ | | | | | | 687| 363| UCS2_GET_NAMING(namePages, (unsigned char)p[1], (unsigned char)p[0]) | | | | | | ------------------ | | | | | | | | 87| 363| (namingBitmap[(pages[hi] << 3) + ((lo) >> 5)] & (1u << ((lo) & 0x1F))) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (82:9): [True: 43, False: 320] | | ------------------ | | 83| 43| *nextTokPtr = ptr; \ | | 84| 43| return XML_TOK_INVALID; \ | | ------------------ | | | | 57| 43|# define XML_TOK_INVALID 0 | | ------------------ | | 85| 43| } \ | | 86| 1.43k| EXPAT_FALLTHROUGH; \ | | ------------------ | | | | 47| 320|# define EXPAT_FALLTHROUGH __attribute__((fallthrough)) | | ------------------ | | 87| 526| case BT_NMSTRT: \ | | ------------------ | | | Branch (87:3): [True: 206, False: 1.29k] | | ------------------ | | 88| 846| case BT_HEX: \ | | ------------------ | | | Branch (88:3): [True: 320, False: 1.18k] | | ------------------ | | 89| 1.04k| case BT_DIGIT: \ | | ------------------ | | | Branch (89:3): [True: 202, False: 1.29k] | | ------------------ | | 90| 1.24k| case BT_NAME: \ | | ------------------ | | | Branch (90:3): [True: 194, False: 1.30k] | | ------------------ | | 91| 1.43k| case BT_MINUS: \ | | ------------------ | | | Branch (91:3): [True: 195, False: 1.30k] | | ------------------ | | 92| 1.43k| ptr += MINBPC(enc); \ | | ------------------ | | | | 698| 1.43k|#define MINBPC(enc) 2 | | ------------------ | | 93| 1.43k| break; \ | | 94| 1.43k| CHECK_NAME_CASE(2, enc, ptr, end, nextTokPtr) \ | | ------------------ | | | | 70| 0| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (70:3): [True: 0, False: 1.50k] | | | | ------------------ | | | | 71| 0| if (end - ptr < n) \ | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 0] | | | | ------------------ | | | | 72| 0| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 0|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 73| 0| if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NAME_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 707| 0|#define IS_INVALID_CHAR(enc, p, n) LITTLE2_IS_INVALID_CHAR(p, n) | | | | | | ------------------ | | | | | | | | 694| 0| ((n) == 4 && ((unsigned char)(p)[3] & 0xFC) != 0xDC) | | | | | | | | ------------------ | | | | | | | | | Branch (694:4): [Folded, False: 0] | | | | | | | | | Branch (694:16): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NAME_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 703| 0|#define IS_NAME_CHAR(enc, p, n) 0 | | | | ------------------ | | | | | Branch (73:41): [True: 0, Folded] | | | | ------------------ | | | | 74| 0| *nextTokPtr = ptr; \ | | | | 75| 0| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 0|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 76| 0| } \ | | | | 77| 0| ptr += n; \ | | | | 78| 0| break; | | ------------------ | | 95| 0| CHECK_NAME_CASE(3, enc, ptr, end, nextTokPtr) \ | | ------------------ | | | | 70| 0| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (70:3): [True: 0, False: 1.50k] | | | | ------------------ | | | | 71| 0| if (end - ptr < n) \ | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 0] | | | | ------------------ | | | | 72| 0| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 0|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 73| 0| if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NAME_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 707| 0|#define IS_INVALID_CHAR(enc, p, n) LITTLE2_IS_INVALID_CHAR(p, n) | | | | | | ------------------ | | | | | | | | 694| 0| ((n) == 4 && ((unsigned char)(p)[3] & 0xFC) != 0xDC) | | | | | | | | ------------------ | | | | | | | | | Branch (694:4): [Folded, False: 0] | | | | | | | | | Branch (694:16): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NAME_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 703| 0|#define IS_NAME_CHAR(enc, p, n) 0 | | | | ------------------ | | | | | Branch (73:41): [True: 0, Folded] | | | | ------------------ | | | | 74| 0| *nextTokPtr = ptr; \ | | | | 75| 0| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 0|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 76| 0| } \ | | | | 77| 0| ptr += n; \ | | | | 78| 0| break; | | ------------------ | | 96| 7| CHECK_NAME_CASE(4, enc, ptr, end, nextTokPtr) | | ------------------ | | | | 70| 7| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (70:3): [True: 7, False: 1.49k] | | | | ------------------ | | | | 71| 7| if (end - ptr < n) \ | | | | ------------------ | | | | | Branch (71:9): [True: 1, False: 6] | | | | ------------------ | | | | 72| 1| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 1|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 73| 6| if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NAME_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 707| 6|#define IS_INVALID_CHAR(enc, p, n) LITTLE2_IS_INVALID_CHAR(p, n) | | | | | | ------------------ | | | | | | | | 694| 12| ((n) == 4 && ((unsigned char)(p)[3] & 0xFC) != 0xDC) | | | | | | | | ------------------ | | | | | | | | | Branch (694:4): [True: 6, Folded] | | | | | | | | | Branch (694:16): [True: 6, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NAME_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 703| 0|#define IS_NAME_CHAR(enc, p, n) 0 | | | | ------------------ | | | | | Branch (73:41): [True: 0, Folded] | | | | ------------------ | | | | 74| 6| *nextTokPtr = ptr; \ | | | | 75| 6| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 6|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 76| 6| } \ | | | | 77| 6| ptr += n; \ | | | | 78| 0| break; | | ------------------ ------------------ 941| 1| case BT_SEMI: ------------------ | Branch (941:5): [True: 1, False: 1.49k] ------------------ 942| 1| *nextTokPtr = ptr + MINBPC(enc); ------------------ | | 698| 1|#define MINBPC(enc) 2 ------------------ 943| 1| return XML_TOK_PARAM_ENTITY_REF; ------------------ | | 95| 1|# define XML_TOK_PARAM_ENTITY_REF 28 ------------------ 944| 12| default: ------------------ | Branch (944:5): [True: 12, False: 1.48k] ------------------ 945| 12| *nextTokPtr = ptr; 946| 12| return XML_TOK_INVALID; ------------------ | | 57| 12|# define XML_TOK_INVALID 0 ------------------ 947| 1.50k| } 948| 1.50k| } 949| 2| return XML_TOK_PARTIAL; ------------------ | | 56| 2|# define XML_TOK_PARTIAL -1 /* only part of a token */ ------------------ 950| 65|} xmltok.c:little2_scanPoundName: 954| 97| const char **nextTokPtr) { 955| 97| REQUIRE_CHAR(enc, ptr, end); ------------------ | | 140| 97|# define REQUIRE_CHAR(enc, ptr, end) REQUIRE_CHARS(enc, ptr, end, 1) | | ------------------ | | | | 134| 97| { \ | | | | 135| 97| if (! HAS_CHARS(enc, ptr, end, count)) { \ | | | | ------------------ | | | | | | 129| 97| ((end) - (ptr) >= ((count) * MINBPC(enc))) | | | | | | ------------------ | | | | | | | | 698| 97|#define MINBPC(enc) 2 | | | | | | ------------------ | | | | ------------------ | | | | | Branch (135:11): [True: 1, False: 96] | | | | ------------------ | | | | 136| 1| return XML_TOK_PARTIAL; \ | | | | ------------------ | | | | | | 56| 1|# define XML_TOK_PARTIAL -1 /* only part of a token */ | | | | ------------------ | | | | 137| 1| } \ | | | | 138| 97| } | | ------------------ ------------------ 956| 96| switch (BYTE_TYPE(enc, ptr)) { ------------------ | | 700| 96|#define BYTE_TYPE(enc, p) LITTLE2_BYTE_TYPE(enc, p) | | ------------------ | | | | 683| 96| ((p)[1] == 0 ? SB_BYTE_TYPE(enc, p) : unicode_byte_type((p)[1], (p)[0])) | | | | ------------------ | | | | | | 231| 8| (((const struct normal_encoding *)(enc))->type[(unsigned char)*(p)]) | | | | ------------------ | | | | | Branch (683:4): [True: 8, False: 88] | | | | ------------------ | | ------------------ ------------------ 957| 239| CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr) ------------------ | | 110| 83| case BT_NONASCII: \ | | ------------------ | | | Branch (110:3): [True: 76, False: 20] | | ------------------ | | 111| 83| if (! IS_NMSTRT_CHAR_MINBPC(enc, ptr)) { \ | | ------------------ | | | | 706| 76|#define IS_NMSTRT_CHAR_MINBPC(enc, p) LITTLE2_IS_NMSTRT_CHAR_MINBPC(p) | | | | ------------------ | | | | | | 689| 76| UCS2_GET_NAMING(nmstrtPages, (unsigned char)p[1], (unsigned char)p[0]) | | | | | | ------------------ | | | | | | | | 87| 76| (namingBitmap[(pages[hi] << 3) + ((lo) >> 5)] & (1u << ((lo) & 0x1F))) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (111:9): [True: 1, False: 75] | | ------------------ | | 112| 1| *nextTokPtr = ptr; \ | | 113| 1| return XML_TOK_INVALID; \ | | ------------------ | | | | 57| 1|# define XML_TOK_INVALID 0 | | ------------------ | | 114| 1| } \ | | 115| 83| EXPAT_FALLTHROUGH; \ | | ------------------ | | | | 47| 75|# define EXPAT_FALLTHROUGH __attribute__((fallthrough)) | | ------------------ | | 116| 77| case BT_NMSTRT: \ | | ------------------ | | | Branch (116:3): [True: 2, False: 94] | | ------------------ | | 117| 83| case BT_HEX: \ | | ------------------ | | | Branch (117:3): [True: 6, False: 90] | | ------------------ | | 118| 83| ptr += MINBPC(enc); \ | | ------------------ | | | | 698| 83|#define MINBPC(enc) 2 | | ------------------ | | 119| 83| break; \ | | 120| 83| CHECK_NMSTRT_CASE(2, enc, ptr, end, nextTokPtr) \ | | ------------------ | | | | 99| 0| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (99:3): [True: 0, False: 96] | | | | ------------------ | | | | 100| 0| if ((end) - (ptr) < (n)) \ | | | | ------------------ | | | | | Branch (100:9): [True: 0, False: 0] | | | | ------------------ | | | | 101| 0| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 0|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 102| 0| if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NMSTRT_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 707| 0|#define IS_INVALID_CHAR(enc, p, n) LITTLE2_IS_INVALID_CHAR(p, n) | | | | | | ------------------ | | | | | | | | 694| 0| ((n) == 4 && ((unsigned char)(p)[3] & 0xFC) != 0xDC) | | | | | | | | ------------------ | | | | | | | | | Branch (694:4): [Folded, False: 0] | | | | | | | | | Branch (694:16): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NMSTRT_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 705| 0|#define IS_NMSTRT_CHAR(enc, p, n) (0) | | | | ------------------ | | | | | Branch (102:41): [True: 0, Folded] | | | | ------------------ | | | | 103| 0| *nextTokPtr = ptr; \ | | | | 104| 0| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 0|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 105| 0| } \ | | | | 106| 0| ptr += n; \ | | | | 107| 0| break; | | ------------------ | | 121| 0| CHECK_NMSTRT_CASE(3, enc, ptr, end, nextTokPtr) \ | | ------------------ | | | | 99| 0| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (99:3): [True: 0, False: 96] | | | | ------------------ | | | | 100| 0| if ((end) - (ptr) < (n)) \ | | | | ------------------ | | | | | Branch (100:9): [True: 0, False: 0] | | | | ------------------ | | | | 101| 0| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 0|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 102| 0| if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NMSTRT_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 707| 0|#define IS_INVALID_CHAR(enc, p, n) LITTLE2_IS_INVALID_CHAR(p, n) | | | | | | ------------------ | | | | | | | | 694| 0| ((n) == 4 && ((unsigned char)(p)[3] & 0xFC) != 0xDC) | | | | | | | | ------------------ | | | | | | | | | Branch (694:4): [Folded, False: 0] | | | | | | | | | Branch (694:16): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NMSTRT_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 705| 0|#define IS_NMSTRT_CHAR(enc, p, n) (0) | | | | ------------------ | | | | | Branch (102:41): [True: 0, Folded] | | | | ------------------ | | | | 103| 0| *nextTokPtr = ptr; \ | | | | 104| 0| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 0|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 105| 0| } \ | | | | 106| 0| ptr += n; \ | | | | 107| 0| break; | | ------------------ | | 122| 6| CHECK_NMSTRT_CASE(4, enc, ptr, end, nextTokPtr) | | ------------------ | | | | 99| 6| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (99:3): [True: 6, False: 90] | | | | ------------------ | | | | 100| 6| if ((end) - (ptr) < (n)) \ | | | | ------------------ | | | | | Branch (100:9): [True: 1, False: 5] | | | | ------------------ | | | | 101| 1| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 1|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 102| 5| if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NMSTRT_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 707| 5|#define IS_INVALID_CHAR(enc, p, n) LITTLE2_IS_INVALID_CHAR(p, n) | | | | | | ------------------ | | | | | | | | 694| 10| ((n) == 4 && ((unsigned char)(p)[3] & 0xFC) != 0xDC) | | | | | | | | ------------------ | | | | | | | | | Branch (694:4): [True: 5, Folded] | | | | | | | | | Branch (694:16): [True: 5, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NMSTRT_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 705| 0|#define IS_NMSTRT_CHAR(enc, p, n) (0) | | | | ------------------ | | | | | Branch (102:41): [True: 0, Folded] | | | | ------------------ | | | | 103| 5| *nextTokPtr = ptr; \ | | | | 104| 5| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 5|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 105| 5| } \ | | | | 106| 5| ptr += n; \ | | | | 107| 0| break; | | ------------------ ------------------ 958| 6| default: ------------------ | Branch (958:3): [True: 6, False: 90] ------------------ 959| 6| *nextTokPtr = ptr; 960| 6| return XML_TOK_INVALID; ------------------ | | 57| 6|# define XML_TOK_INVALID 0 ------------------ 961| 96| } 962| 1.37k| while (HAS_CHAR(enc, ptr, end)) { 963| 1.37k| switch (BYTE_TYPE(enc, ptr)) { ------------------ | | 700| 1.37k|#define BYTE_TYPE(enc, p) LITTLE2_BYTE_TYPE(enc, p) | | ------------------ | | | | 683| 1.37k| ((p)[1] == 0 ? SB_BYTE_TYPE(enc, p) : unicode_byte_type((p)[1], (p)[0])) | | | | ------------------ | | | | | | 231| 991| (((const struct normal_encoding *)(enc))->type[(unsigned char)*(p)]) | | | | ------------------ | | | | | Branch (683:4): [True: 991, False: 385] | | | | ------------------ | | ------------------ ------------------ 964| 3.93k| CHECK_NAME_CASES(enc, ptr, end, nextTokPtr) ------------------ | | 81| 1.29k| case BT_NONASCII: \ | | ------------------ | | | Branch (81:3): [True: 367, False: 1.00k] | | ------------------ | | 82| 1.29k| if (! IS_NAME_CHAR_MINBPC(enc, ptr)) { \ | | ------------------ | | | | 704| 367|#define IS_NAME_CHAR_MINBPC(enc, p) LITTLE2_IS_NAME_CHAR_MINBPC(p) | | | | ------------------ | | | | | | 687| 367| UCS2_GET_NAMING(namePages, (unsigned char)p[1], (unsigned char)p[0]) | | | | | | ------------------ | | | | | | | | 87| 367| (namingBitmap[(pages[hi] << 3) + ((lo) >> 5)] & (1u << ((lo) & 0x1F))) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (82:9): [True: 53, False: 314] | | ------------------ | | 83| 53| *nextTokPtr = ptr; \ | | 84| 53| return XML_TOK_INVALID; \ | | ------------------ | | | | 57| 53|# define XML_TOK_INVALID 0 | | ------------------ | | 85| 53| } \ | | 86| 1.29k| EXPAT_FALLTHROUGH; \ | | ------------------ | | | | 47| 314|# define EXPAT_FALLTHROUGH __attribute__((fallthrough)) | | ------------------ | | 87| 513| case BT_NMSTRT: \ | | ------------------ | | | Branch (87:3): [True: 199, False: 1.17k] | | ------------------ | | 88| 709| case BT_HEX: \ | | ------------------ | | | Branch (88:3): [True: 196, False: 1.18k] | | ------------------ | | 89| 906| case BT_DIGIT: \ | | ------------------ | | | Branch (89:3): [True: 197, False: 1.17k] | | ------------------ | | 90| 1.10k| case BT_NAME: \ | | ------------------ | | | Branch (90:3): [True: 194, False: 1.18k] | | ------------------ | | 91| 1.29k| case BT_MINUS: \ | | ------------------ | | | Branch (91:3): [True: 195, False: 1.18k] | | ------------------ | | 92| 1.29k| ptr += MINBPC(enc); \ | | ------------------ | | | | 698| 1.29k|#define MINBPC(enc) 2 | | ------------------ | | 93| 1.29k| break; \ | | 94| 1.29k| CHECK_NAME_CASE(2, enc, ptr, end, nextTokPtr) \ | | ------------------ | | | | 70| 0| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (70:3): [True: 0, False: 1.37k] | | | | ------------------ | | | | 71| 0| if (end - ptr < n) \ | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 0] | | | | ------------------ | | | | 72| 0| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 0|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 73| 0| if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NAME_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 707| 0|#define IS_INVALID_CHAR(enc, p, n) LITTLE2_IS_INVALID_CHAR(p, n) | | | | | | ------------------ | | | | | | | | 694| 0| ((n) == 4 && ((unsigned char)(p)[3] & 0xFC) != 0xDC) | | | | | | | | ------------------ | | | | | | | | | Branch (694:4): [Folded, False: 0] | | | | | | | | | Branch (694:16): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NAME_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 703| 0|#define IS_NAME_CHAR(enc, p, n) 0 | | | | ------------------ | | | | | Branch (73:41): [True: 0, Folded] | | | | ------------------ | | | | 74| 0| *nextTokPtr = ptr; \ | | | | 75| 0| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 0|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 76| 0| } \ | | | | 77| 0| ptr += n; \ | | | | 78| 0| break; | | ------------------ | | 95| 0| CHECK_NAME_CASE(3, enc, ptr, end, nextTokPtr) \ | | ------------------ | | | | 70| 0| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (70:3): [True: 0, False: 1.37k] | | | | ------------------ | | | | 71| 0| if (end - ptr < n) \ | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 0] | | | | ------------------ | | | | 72| 0| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 0|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 73| 0| if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NAME_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 707| 0|#define IS_INVALID_CHAR(enc, p, n) LITTLE2_IS_INVALID_CHAR(p, n) | | | | | | ------------------ | | | | | | | | 694| 0| ((n) == 4 && ((unsigned char)(p)[3] & 0xFC) != 0xDC) | | | | | | | | ------------------ | | | | | | | | | Branch (694:4): [Folded, False: 0] | | | | | | | | | Branch (694:16): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NAME_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 703| 0|#define IS_NAME_CHAR(enc, p, n) 0 | | | | ------------------ | | | | | Branch (73:41): [True: 0, Folded] | | | | ------------------ | | | | 74| 0| *nextTokPtr = ptr; \ | | | | 75| 0| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 0|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 76| 0| } \ | | | | 77| 0| ptr += n; \ | | | | 78| 0| break; | | ------------------ | | 96| 13| CHECK_NAME_CASE(4, enc, ptr, end, nextTokPtr) | | ------------------ | | | | 70| 13| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (70:3): [True: 13, False: 1.36k] | | | | ------------------ | | | | 71| 13| if (end - ptr < n) \ | | | | ------------------ | | | | | Branch (71:9): [True: 1, False: 12] | | | | ------------------ | | | | 72| 1| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 1|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 73| 12| if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NAME_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 707| 12|#define IS_INVALID_CHAR(enc, p, n) LITTLE2_IS_INVALID_CHAR(p, n) | | | | | | ------------------ | | | | | | | | 694| 24| ((n) == 4 && ((unsigned char)(p)[3] & 0xFC) != 0xDC) | | | | | | | | ------------------ | | | | | | | | | Branch (694:4): [True: 12, Folded] | | | | | | | | | Branch (694:16): [True: 10, False: 2] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NAME_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 703| 2|#define IS_NAME_CHAR(enc, p, n) 0 | | | | ------------------ | | | | | Branch (73:41): [True: 2, Folded] | | | | ------------------ | | | | 74| 12| *nextTokPtr = ptr; \ | | | | 75| 12| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 12|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 76| 12| } \ | | | | 77| 12| ptr += n; \ | | | | 78| 0| break; | | ------------------ ------------------ 965| 2| case BT_CR: ------------------ | Branch (965:5): [True: 2, False: 1.37k] ------------------ 966| 3| case BT_LF: ------------------ | Branch (966:5): [True: 1, False: 1.37k] ------------------ 967| 4| case BT_S: ------------------ | Branch (967:5): [True: 1, False: 1.37k] ------------------ 968| 6| case BT_RPAR: ------------------ | Branch (968:5): [True: 2, False: 1.37k] ------------------ 969| 8| case BT_GT: ------------------ | Branch (969:5): [True: 2, False: 1.37k] ------------------ 970| 9| case BT_PERCNT: ------------------ | Branch (970:5): [True: 1, False: 1.37k] ------------------ 971| 10| case BT_VERBAR: ------------------ | Branch (971:5): [True: 1, False: 1.37k] ------------------ 972| 10| *nextTokPtr = ptr; 973| 10| return XML_TOK_POUND_NAME; ------------------ | | 87| 10|# define XML_TOK_POUND_NAME 20 /* #name */ ------------------ 974| 5| default: ------------------ | Branch (974:5): [True: 5, False: 1.37k] ------------------ 975| 5| *nextTokPtr = ptr; 976| 5| return XML_TOK_INVALID; ------------------ | | 57| 5|# define XML_TOK_INVALID 0 ------------------ 977| 1.37k| } 978| 1.37k| } 979| 2| return -XML_TOK_POUND_NAME; ------------------ | | 87| 2|# define XML_TOK_POUND_NAME 20 /* #name */ ------------------ 980| 83|} xmltok.c:little2_contentTok: 824| 13.9k| const char **nextTokPtr) { 825| 13.9k| if (ptr >= end) ------------------ | Branch (825:7): [True: 411, False: 13.5k] ------------------ 826| 411| return XML_TOK_NONE; ------------------ | | 51| 411|# define XML_TOK_NONE -4 /* The string to be scanned is empty */ ------------------ 827| 13.5k| if (MINBPC(enc) > 1) { ------------------ | | 698| 13.5k|#define MINBPC(enc) 2 ------------------ | Branch (827:7): [True: 13.5k, Folded] ------------------ 828| 13.5k| size_t n = end - ptr; 829| 13.5k| if (n & (MINBPC(enc) - 1)) { ------------------ | | 698| 13.5k|#define MINBPC(enc) 2 ------------------ | Branch (829:9): [True: 8.92k, False: 4.60k] ------------------ 830| 8.92k| n &= ~(MINBPC(enc) - 1); ------------------ | | 698| 8.92k|#define MINBPC(enc) 2 ------------------ 831| 8.92k| if (n == 0) ------------------ | Branch (831:11): [True: 605, False: 8.32k] ------------------ 832| 605| return XML_TOK_PARTIAL; ------------------ | | 56| 605|# define XML_TOK_PARTIAL -1 /* only part of a token */ ------------------ 833| 8.32k| end = ptr + n; 834| 8.32k| } 835| 13.5k| } 836| 12.9k| switch (BYTE_TYPE(enc, ptr)) { ------------------ | | 700| 12.9k|#define BYTE_TYPE(enc, p) LITTLE2_BYTE_TYPE(enc, p) | | ------------------ | | | | 683| 12.9k| ((p)[1] == 0 ? SB_BYTE_TYPE(enc, p) : unicode_byte_type((p)[1], (p)[0])) | | | | ------------------ | | | | | | 231| 10.4k| (((const struct normal_encoding *)(enc))->type[(unsigned char)*(p)]) | | | | ------------------ | | | | | Branch (683:4): [True: 10.4k, False: 2.44k] | | | | ------------------ | | ------------------ ------------------ 837| 6.73k| case BT_LT: ------------------ | Branch (837:3): [True: 6.73k, False: 6.19k] ------------------ 838| 6.73k| return PREFIX(scanLt)(enc, ptr + MINBPC(enc), end, nextTokPtr); ------------------ | | 697| 6.73k|#define PREFIX(ident) little2_##ident ------------------ return PREFIX(scanLt)(enc, ptr + MINBPC(enc), end, nextTokPtr); ------------------ | | 698| 6.73k|#define MINBPC(enc) 2 ------------------ 839| 1.61k| case BT_AMP: ------------------ | Branch (839:3): [True: 1.61k, False: 11.3k] ------------------ 840| 1.61k| return PREFIX(scanRef)(enc, ptr + MINBPC(enc), end, nextTokPtr); ------------------ | | 697| 1.61k|#define PREFIX(ident) little2_##ident ------------------ return PREFIX(scanRef)(enc, ptr + MINBPC(enc), end, nextTokPtr); ------------------ | | 698| 1.61k|#define MINBPC(enc) 2 ------------------ 841| 1.06k| case BT_CR: ------------------ | Branch (841:3): [True: 1.06k, False: 11.8k] ------------------ 842| 1.06k| ptr += MINBPC(enc); ------------------ | | 698| 1.06k|#define MINBPC(enc) 2 ------------------ 843| 1.06k| if (! HAS_CHAR(enc, ptr, end)) ------------------ | | 131| 1.06k|# define HAS_CHAR(enc, ptr, end) HAS_CHARS(enc, ptr, end, 1) | | ------------------ | | | | 129| 1.06k| ((end) - (ptr) >= ((count) * MINBPC(enc))) | | | | ------------------ | | | | | | 698| 1.06k|#define MINBPC(enc) 2 | | | | ------------------ | | ------------------ ------------------ | Branch (843:9): [True: 5, False: 1.05k] ------------------ 844| 5| return XML_TOK_TRAILING_CR; ------------------ | | 53| 5| -3 /* A CR at the end of the scan; \ ------------------ 845| 1.05k| if (BYTE_TYPE(enc, ptr) == BT_LF) ------------------ | | 700| 1.05k|#define BYTE_TYPE(enc, p) LITTLE2_BYTE_TYPE(enc, p) | | ------------------ | | | | 683| 1.05k| ((p)[1] == 0 ? SB_BYTE_TYPE(enc, p) : unicode_byte_type((p)[1], (p)[0])) | | | | ------------------ | | | | | | 231| 564| (((const struct normal_encoding *)(enc))->type[(unsigned char)*(p)]) | | | | ------------------ | | | | | Branch (683:4): [True: 564, False: 493] | | | | ------------------ | | ------------------ ------------------ | Branch (845:9): [True: 67, False: 990] ------------------ 846| 67| ptr += MINBPC(enc); ------------------ | | 698| 67|#define MINBPC(enc) 2 ------------------ 847| 1.05k| *nextTokPtr = ptr; 848| 1.05k| return XML_TOK_DATA_NEWLINE; ------------------ | | 68| 1.05k|# define XML_TOK_DATA_NEWLINE 7 ------------------ 849| 616| case BT_LF: ------------------ | Branch (849:3): [True: 616, False: 12.3k] ------------------ 850| 616| *nextTokPtr = ptr + MINBPC(enc); ------------------ | | 698| 616|#define MINBPC(enc) 2 ------------------ 851| 616| return XML_TOK_DATA_NEWLINE; ------------------ | | 68| 616|# define XML_TOK_DATA_NEWLINE 7 ------------------ 852| 321| case BT_RSQB: ------------------ | Branch (852:3): [True: 321, False: 12.6k] ------------------ 853| 321| ptr += MINBPC(enc); ------------------ | | 698| 321|#define MINBPC(enc) 2 ------------------ 854| 321| if (! HAS_CHAR(enc, ptr, end)) ------------------ | | 131| 321|# define HAS_CHAR(enc, ptr, end) HAS_CHARS(enc, ptr, end, 1) | | ------------------ | | | | 129| 321| ((end) - (ptr) >= ((count) * MINBPC(enc))) | | | | ------------------ | | | | | | 698| 321|#define MINBPC(enc) 2 | | | | ------------------ | | ------------------ ------------------ | Branch (854:9): [True: 4, False: 317] ------------------ 855| 4| return XML_TOK_TRAILING_RSQB; ------------------ | | 46| 4| -5 /* ] or ]] at the end of the scan; might be \ ------------------ 856| 317| if (! CHAR_MATCHES(enc, ptr, ASCII_RSQB)) ------------------ | | 702| 317|#define CHAR_MATCHES(enc, p, c) LITTLE2_CHAR_MATCHES(p, c) | | ------------------ | | | | 685| 317|#define LITTLE2_CHAR_MATCHES(p, c) ((p)[1] == 0 && (p)[0] == (c)) | | | | ------------------ | | | | | Branch (685:37): [True: 240, False: 77] | | | | | Branch (685:52): [True: 162, False: 78] | | | | ------------------ | | ------------------ ------------------ 857| 155| break; 858| 162| ptr += MINBPC(enc); ------------------ | | 698| 162|#define MINBPC(enc) 2 ------------------ 859| 162| if (! HAS_CHAR(enc, ptr, end)) ------------------ | | 131| 162|# define HAS_CHAR(enc, ptr, end) HAS_CHARS(enc, ptr, end, 1) | | ------------------ | | | | 129| 162| ((end) - (ptr) >= ((count) * MINBPC(enc))) | | | | ------------------ | | | | | | 698| 162|#define MINBPC(enc) 2 | | | | ------------------ | | ------------------ ------------------ | Branch (859:9): [True: 4, False: 158] ------------------ 860| 4| return XML_TOK_TRAILING_RSQB; ------------------ | | 46| 4| -5 /* ] or ]] at the end of the scan; might be \ ------------------ 861| 158| if (! CHAR_MATCHES(enc, ptr, ASCII_GT)) { ------------------ | | 702| 158|#define CHAR_MATCHES(enc, p, c) LITTLE2_CHAR_MATCHES(p, c) | | ------------------ | | | | 685| 158|#define LITTLE2_CHAR_MATCHES(p, c) ((p)[1] == 0 && (p)[0] == (c)) | | | | ------------------ | | | | | Branch (685:37): [True: 79, False: 79] | | | | | Branch (685:52): [True: 1, False: 78] | | | | ------------------ | | ------------------ ------------------ 862| 157| ptr -= MINBPC(enc); ------------------ | | 698| 157|#define MINBPC(enc) 2 ------------------ 863| 157| break; 864| 157| } 865| 1| *nextTokPtr = ptr; 866| 1| return XML_TOK_INVALID; ------------------ | | 57| 1|# define XML_TOK_INVALID 0 ------------------ 867| 603| INVALID_CASES(ptr, nextTokPtr) ------------------ | | 60| 0| INVALID_LEAD_CASE(2, ptr, nextTokPtr) \ | | ------------------ | | | | 49| 0| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (49:3): [True: 0, False: 12.9k] | | | | ------------------ | | | | 50| 0| if (end - ptr < n) \ | | | | ------------------ | | | | | Branch (50:9): [True: 0, False: 0] | | | | ------------------ | | | | 51| 0| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 0|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 52| 0| if (IS_INVALID_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 707| 0|#define IS_INVALID_CHAR(enc, p, n) LITTLE2_IS_INVALID_CHAR(p, n) | | | | | | ------------------ | | | | | | | | 694| 0| ((n) == 4 && ((unsigned char)(p)[3] & 0xFC) != 0xDC) | | | | | | | | ------------------ | | | | | | | | | Branch (694:4): [Folded, False: 0] | | | | | | | | | Branch (694:16): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 53| 0| *(nextTokPtr) = (ptr); \ | | | | 54| 0| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 0|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 55| 0| } \ | | | | 56| 0| ptr += n; \ | | | | 57| 0| break; | | ------------------ | | 61| 0| INVALID_LEAD_CASE(3, ptr, nextTokPtr) \ | | ------------------ | | | | 49| 0| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (49:3): [True: 0, False: 12.9k] | | | | ------------------ | | | | 50| 0| if (end - ptr < n) \ | | | | ------------------ | | | | | Branch (50:9): [True: 0, False: 0] | | | | ------------------ | | | | 51| 0| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 0|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 52| 0| if (IS_INVALID_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 707| 0|#define IS_INVALID_CHAR(enc, p, n) LITTLE2_IS_INVALID_CHAR(p, n) | | | | | | ------------------ | | | | | | | | 694| 0| ((n) == 4 && ((unsigned char)(p)[3] & 0xFC) != 0xDC) | | | | | | | | ------------------ | | | | | | | | | Branch (694:4): [Folded, False: 0] | | | | | | | | | Branch (694:16): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 53| 0| *(nextTokPtr) = (ptr); \ | | | | 54| 0| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 0|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 55| 0| } \ | | | | 56| 0| ptr += n; \ | | | | 57| 0| break; | | ------------------ | | 62| 300| INVALID_LEAD_CASE(4, ptr, nextTokPtr) \ | | ------------------ | | | | 49| 300| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (49:3): [True: 300, False: 12.6k] | | | | ------------------ | | | | 50| 300| if (end - ptr < n) \ | | | | ------------------ | | | | | Branch (50:9): [True: 1, False: 299] | | | | ------------------ | | | | 51| 251| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 1|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 52| 299| if (IS_INVALID_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 707| 299|#define IS_INVALID_CHAR(enc, p, n) LITTLE2_IS_INVALID_CHAR(p, n) | | | | | | ------------------ | | | | | | | | 694| 299| ((n) == 4 && ((unsigned char)(p)[3] & 0xFC) != 0xDC) | | | | | | | | ------------------ | | | | | | | | | Branch (694:4): [True: 299, Folded] | | | | | | | | | Branch (694:16): [True: 48, False: 251] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 53| 48| *(nextTokPtr) = (ptr); \ | | | | 54| 48| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 48|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 55| 48| } \ | | | | 56| 299| ptr += n; \ | | | | 57| 251| break; | | ------------------ | | 63| 251| case BT_NONXML: \ | | ------------------ | | | Branch (63:3): [True: 2, False: 12.9k] | | ------------------ | | 64| 2| case BT_MALFORM: \ | | ------------------ | | | Branch (64:3): [True: 0, False: 12.9k] | | ------------------ | | 65| 10| case BT_TRAIL: \ | | ------------------ | | | Branch (65:3): [True: 8, False: 12.9k] | | ------------------ | | 66| 10| *(nextTokPtr) = (ptr); \ | | 67| 10| return XML_TOK_INVALID; | | ------------------ | | | | 57| 10|# define XML_TOK_INVALID 0 | | ------------------ ------------------ 868| 2.26k| default: ------------------ | Branch (868:3): [True: 2.26k, False: 10.6k] ------------------ 869| 2.26k| ptr += MINBPC(enc); ------------------ | | 698| 2.26k|#define MINBPC(enc) 2 ------------------ 870| 2.26k| break; 871| 12.9k| } 872| 12.0k| while (HAS_CHAR(enc, ptr, end)) { 873| 12.0k| switch (BYTE_TYPE(enc, ptr)) { ------------------ | | 700| 12.0k|#define BYTE_TYPE(enc, p) LITTLE2_BYTE_TYPE(enc, p) | | ------------------ | | | | 683| 12.0k| ((p)[1] == 0 ? SB_BYTE_TYPE(enc, p) : unicode_byte_type((p)[1], (p)[0])) | | | | ------------------ | | | | | | 231| 4.91k| (((const struct normal_encoding *)(enc))->type[(unsigned char)*(p)]) | | | | ------------------ | | | | | Branch (683:4): [True: 4.91k, False: 7.17k] | | | | ------------------ | | ------------------ ------------------ 874| 0|# define LEAD_CASE(n) \ 875| 0| case BT_LEAD##n: \ 876| 0| if (end - ptr < n || IS_INVALID_CHAR(enc, ptr, n)) { \ 877| 0| *nextTokPtr = ptr; \ 878| 0| return XML_TOK_DATA_CHARS; \ 879| 0| } \ 880| 0| ptr += n; \ 881| 0| break; 882| 0| LEAD_CASE(2) ------------------ | | 875| 0| case BT_LEAD##n: \ | | ------------------ | | | Branch (875:3): [True: 0, False: 12.0k] | | ------------------ | | 876| 0| if (end - ptr < n || IS_INVALID_CHAR(enc, ptr, n)) { \ | | ------------------ | | | | 707| 0|#define IS_INVALID_CHAR(enc, p, n) LITTLE2_IS_INVALID_CHAR(p, n) | | | | ------------------ | | | | | | 694| 0| ((n) == 4 && ((unsigned char)(p)[3] & 0xFC) != 0xDC) | | | | | | ------------------ | | | | | | | Branch (694:4): [Folded, False: 0] | | | | | | | Branch (694:16): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (876:9): [True: 0, False: 0] | | ------------------ | | 877| 0| *nextTokPtr = ptr; \ | | 878| 0| return XML_TOK_DATA_CHARS; \ | | ------------------ | | | | 67| 0|# define XML_TOK_DATA_CHARS 6 | | ------------------ | | 879| 0| } \ | | 880| 0| ptr += n; \ | | 881| 0| break; ------------------ 883| 0| LEAD_CASE(3) ------------------ | | 875| 0| case BT_LEAD##n: \ | | ------------------ | | | Branch (875:3): [True: 0, False: 12.0k] | | ------------------ | | 876| 0| if (end - ptr < n || IS_INVALID_CHAR(enc, ptr, n)) { \ | | ------------------ | | | | 707| 0|#define IS_INVALID_CHAR(enc, p, n) LITTLE2_IS_INVALID_CHAR(p, n) | | | | ------------------ | | | | | | 694| 0| ((n) == 4 && ((unsigned char)(p)[3] & 0xFC) != 0xDC) | | | | | | ------------------ | | | | | | | Branch (694:4): [Folded, False: 0] | | | | | | | Branch (694:16): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (876:9): [True: 0, False: 0] | | ------------------ | | 877| 0| *nextTokPtr = ptr; \ | | 878| 0| return XML_TOK_DATA_CHARS; \ | | ------------------ | | | | 67| 0|# define XML_TOK_DATA_CHARS 6 | | ------------------ | | 879| 0| } \ | | 880| 0| ptr += n; \ | | 881| 0| break; ------------------ 884| 439| LEAD_CASE(4) ------------------ | | 875| 439| case BT_LEAD##n: \ | | ------------------ | | | Branch (875:3): [True: 439, False: 11.6k] | | ------------------ | | 876| 439| if (end - ptr < n || IS_INVALID_CHAR(enc, ptr, n)) { \ | | ------------------ | | | | 707| 438|#define IS_INVALID_CHAR(enc, p, n) LITTLE2_IS_INVALID_CHAR(p, n) | | | | ------------------ | | | | | | 694| 438| ((n) == 4 && ((unsigned char)(p)[3] & 0xFC) != 0xDC) | | | | | | ------------------ | | | | | | | Branch (694:4): [True: 438, Folded] | | | | | | | Branch (694:16): [True: 42, False: 396] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (876:9): [True: 1, False: 438] | | ------------------ | | 877| 43| *nextTokPtr = ptr; \ | | 878| 43| return XML_TOK_DATA_CHARS; \ | | ------------------ | | | | 67| 43|# define XML_TOK_DATA_CHARS 6 | | ------------------ | | 879| 43| } \ | | 880| 396| ptr += n; \ | | 881| 396| break; ------------------ 885| 0|# undef LEAD_CASE 886| 1.23k| case BT_RSQB: ------------------ | Branch (886:5): [True: 1.23k, False: 10.8k] ------------------ 887| 1.23k| if (HAS_CHARS(enc, ptr, end, 2)) { ------------------ | | 129| 1.23k| ((end) - (ptr) >= ((count) * MINBPC(enc))) | | ------------------ | | | | 698| 1.23k|#define MINBPC(enc) 2 | | ------------------ | | | Branch (129:5): [True: 1.23k, False: 4] | | ------------------ ------------------ 888| 1.23k| if (! CHAR_MATCHES(enc, ptr + MINBPC(enc), ASCII_RSQB)) { ------------------ | | 702| 1.23k|#define CHAR_MATCHES(enc, p, c) LITTLE2_CHAR_MATCHES(p, c) | | ------------------ | | | | 685| 1.23k|#define LITTLE2_CHAR_MATCHES(p, c) ((p)[1] == 0 && (p)[0] == (c)) | | | | ------------------ | | | | | Branch (685:37): [True: 723, False: 508] | | | | | Branch (685:52): [True: 442, False: 281] | | | | ------------------ | | ------------------ ------------------ 889| 789| ptr += MINBPC(enc); ------------------ | | 698| 789|#define MINBPC(enc) 2 ------------------ 890| 789| break; 891| 789| } 892| 442| if (HAS_CHARS(enc, ptr, end, 3)) { ------------------ | | 129| 442| ((end) - (ptr) >= ((count) * MINBPC(enc))) | | ------------------ | | | | 698| 442|#define MINBPC(enc) 2 | | ------------------ | | | Branch (129:5): [True: 438, False: 4] | | ------------------ ------------------ 893| 438| if (! CHAR_MATCHES(enc, ptr + 2 * MINBPC(enc), ASCII_GT)) { ------------------ | | 702| 438|#define CHAR_MATCHES(enc, p, c) LITTLE2_CHAR_MATCHES(p, c) | | ------------------ | | | | 685| 438|#define LITTLE2_CHAR_MATCHES(p, c) ((p)[1] == 0 && (p)[0] == (c)) | | | | ------------------ | | | | | Branch (685:37): [True: 216, False: 222] | | | | | Branch (685:52): [True: 1, False: 215] | | | | ------------------ | | ------------------ ------------------ 894| 437| ptr += MINBPC(enc); ------------------ | | 698| 437|#define MINBPC(enc) 2 ------------------ 895| 437| break; 896| 437| } 897| 1| *nextTokPtr = ptr + 2 * MINBPC(enc); ------------------ | | 698| 1|#define MINBPC(enc) 2 ------------------ 898| 1| return XML_TOK_INVALID; ------------------ | | 57| 1|# define XML_TOK_INVALID 0 ------------------ 899| 438| } 900| 442| } 901| 8| EXPAT_FALLTHROUGH; ------------------ | | 47| 8|# define EXPAT_FALLTHROUGH __attribute__((fallthrough)) ------------------ 902| 371| case BT_AMP: ------------------ | Branch (902:5): [True: 363, False: 11.7k] ------------------ 903| 1.02k| case BT_LT: ------------------ | Branch (903:5): [True: 649, False: 11.4k] ------------------ 904| 1.02k| case BT_NONXML: ------------------ | Branch (904:5): [True: 2, False: 12.0k] ------------------ 905| 1.02k| case BT_MALFORM: ------------------ | Branch (905:5): [True: 0, False: 12.0k] ------------------ 906| 1.03k| case BT_TRAIL: ------------------ | Branch (906:5): [True: 8, False: 12.0k] ------------------ 907| 1.79k| case BT_CR: ------------------ | Branch (907:5): [True: 769, False: 11.3k] ------------------ 908| 2.22k| case BT_LF: ------------------ | Branch (908:5): [True: 427, False: 11.6k] ------------------ 909| 2.22k| *nextTokPtr = ptr; 910| 2.22k| return XML_TOK_DATA_CHARS; ------------------ | | 67| 2.22k|# define XML_TOK_DATA_CHARS 6 ------------------ 911| 8.19k| default: ------------------ | Branch (911:5): [True: 8.19k, False: 3.89k] ------------------ 912| 8.19k| ptr += MINBPC(enc); ------------------ | | 698| 8.19k|#define MINBPC(enc) 2 ------------------ 913| 8.19k| break; 914| 12.0k| } 915| 12.0k| } 916| 557| *nextTokPtr = ptr; 917| 557| return XML_TOK_DATA_CHARS; ------------------ | | 67| 557|# define XML_TOK_DATA_CHARS 6 ------------------ 918| 2.82k|} xmltok.c:little2_scanLt: 726| 6.73k| const char **nextTokPtr) { 727| 6.73k|# ifdef XML_NS 728| 6.73k| int hadColon; 729| 6.73k|# endif 730| 6.73k| REQUIRE_CHAR(enc, ptr, end); ------------------ | | 140| 6.73k|# define REQUIRE_CHAR(enc, ptr, end) REQUIRE_CHARS(enc, ptr, end, 1) | | ------------------ | | | | 134| 6.73k| { \ | | | | 135| 6.73k| if (! HAS_CHARS(enc, ptr, end, count)) { \ | | | | ------------------ | | | | | | 129| 6.73k| ((end) - (ptr) >= ((count) * MINBPC(enc))) | | | | | | ------------------ | | | | | | | | 698| 6.73k|#define MINBPC(enc) 2 | | | | | | ------------------ | | | | ------------------ | | | | | Branch (135:11): [True: 1, False: 6.73k] | | | | ------------------ | | | | 136| 1| return XML_TOK_PARTIAL; \ | | | | ------------------ | | | | | | 56| 1|# define XML_TOK_PARTIAL -1 /* only part of a token */ | | | | ------------------ | | | | 137| 1| } \ | | | | 138| 6.73k| } | | ------------------ ------------------ 731| 6.73k| switch (BYTE_TYPE(enc, ptr)) { ------------------ | | 700| 6.73k|#define BYTE_TYPE(enc, p) LITTLE2_BYTE_TYPE(enc, p) | | ------------------ | | | | 683| 6.73k| ((p)[1] == 0 ? SB_BYTE_TYPE(enc, p) : unicode_byte_type((p)[1], (p)[0])) | | | | ------------------ | | | | | | 231| 2.29k| (((const struct normal_encoding *)(enc))->type[(unsigned char)*(p)]) | | | | ------------------ | | | | | Branch (683:4): [True: 2.29k, False: 4.43k] | | | | ------------------ | | ------------------ ------------------ 732| 13.6k| CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr) ------------------ | | 110| 4.98k| case BT_NONASCII: \ | | ------------------ | | | Branch (110:3): [True: 4.42k, False: 2.31k] | | ------------------ | | 111| 4.98k| if (! IS_NMSTRT_CHAR_MINBPC(enc, ptr)) { \ | | ------------------ | | | | 706| 4.42k|#define IS_NMSTRT_CHAR_MINBPC(enc, p) LITTLE2_IS_NMSTRT_CHAR_MINBPC(p) | | | | ------------------ | | | | | | 689| 4.42k| UCS2_GET_NAMING(nmstrtPages, (unsigned char)p[1], (unsigned char)p[0]) | | | | | | ------------------ | | | | | | | | 87| 4.42k| (namingBitmap[(pages[hi] << 3) + ((lo) >> 5)] & (1u << ((lo) & 0x1F))) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (111:9): [True: 17, False: 4.40k] | | ------------------ | | 112| 17| *nextTokPtr = ptr; \ | | 113| 17| return XML_TOK_INVALID; \ | | ------------------ | | | | 57| 17|# define XML_TOK_INVALID 0 | | ------------------ | | 114| 17| } \ | | 115| 4.98k| EXPAT_FALLTHROUGH; \ | | ------------------ | | | | 47| 4.40k|# define EXPAT_FALLTHROUGH __attribute__((fallthrough)) | | ------------------ | | 116| 4.78k| case BT_NMSTRT: \ | | ------------------ | | | Branch (116:3): [True: 381, False: 6.35k] | | ------------------ | | 117| 4.98k| case BT_HEX: \ | | ------------------ | | | Branch (117:3): [True: 202, False: 6.53k] | | ------------------ | | 118| 4.98k| ptr += MINBPC(enc); \ | | ------------------ | | | | 698| 4.98k|#define MINBPC(enc) 2 | | ------------------ | | 119| 4.98k| break; \ | | 120| 4.98k| CHECK_NMSTRT_CASE(2, enc, ptr, end, nextTokPtr) \ | | ------------------ | | | | 99| 0| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (99:3): [True: 0, False: 6.73k] | | | | ------------------ | | | | 100| 0| if ((end) - (ptr) < (n)) \ | | | | ------------------ | | | | | Branch (100:9): [True: 0, False: 0] | | | | ------------------ | | | | 101| 0| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 0|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 102| 0| if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NMSTRT_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 707| 0|#define IS_INVALID_CHAR(enc, p, n) LITTLE2_IS_INVALID_CHAR(p, n) | | | | | | ------------------ | | | | | | | | 694| 0| ((n) == 4 && ((unsigned char)(p)[3] & 0xFC) != 0xDC) | | | | | | | | ------------------ | | | | | | | | | Branch (694:4): [Folded, False: 0] | | | | | | | | | Branch (694:16): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NMSTRT_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 705| 0|#define IS_NMSTRT_CHAR(enc, p, n) (0) | | | | ------------------ | | | | | Branch (102:41): [True: 0, Folded] | | | | ------------------ | | | | 103| 0| *nextTokPtr = ptr; \ | | | | 104| 0| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 0|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 105| 0| } \ | | | | 106| 0| ptr += n; \ | | | | 107| 0| break; | | ------------------ | | 121| 0| CHECK_NMSTRT_CASE(3, enc, ptr, end, nextTokPtr) \ | | ------------------ | | | | 99| 0| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (99:3): [True: 0, False: 6.73k] | | | | ------------------ | | | | 100| 0| if ((end) - (ptr) < (n)) \ | | | | ------------------ | | | | | Branch (100:9): [True: 0, False: 0] | | | | ------------------ | | | | 101| 0| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 0|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 102| 0| if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NMSTRT_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 707| 0|#define IS_INVALID_CHAR(enc, p, n) LITTLE2_IS_INVALID_CHAR(p, n) | | | | | | ------------------ | | | | | | | | 694| 0| ((n) == 4 && ((unsigned char)(p)[3] & 0xFC) != 0xDC) | | | | | | | | ------------------ | | | | | | | | | Branch (694:4): [Folded, False: 0] | | | | | | | | | Branch (694:16): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NMSTRT_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 705| 0|#define IS_NMSTRT_CHAR(enc, p, n) (0) | | | | ------------------ | | | | | Branch (102:41): [True: 0, Folded] | | | | ------------------ | | | | 103| 0| *nextTokPtr = ptr; \ | | | | 104| 0| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 0|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 105| 0| } \ | | | | 106| 0| ptr += n; \ | | | | 107| 0| break; | | ------------------ | | 122| 9| CHECK_NMSTRT_CASE(4, enc, ptr, end, nextTokPtr) | | ------------------ | | | | 99| 9| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (99:3): [True: 9, False: 6.72k] | | | | ------------------ | | | | 100| 9| if ((end) - (ptr) < (n)) \ | | | | ------------------ | | | | | Branch (100:9): [True: 1, False: 8] | | | | ------------------ | | | | 101| 1| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 1|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 102| 8| if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NMSTRT_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 707| 8|#define IS_INVALID_CHAR(enc, p, n) LITTLE2_IS_INVALID_CHAR(p, n) | | | | | | ------------------ | | | | | | | | 694| 16| ((n) == 4 && ((unsigned char)(p)[3] & 0xFC) != 0xDC) | | | | | | | | ------------------ | | | | | | | | | Branch (694:4): [True: 8, Folded] | | | | | | | | | Branch (694:16): [True: 8, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NMSTRT_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 705| 0|#define IS_NMSTRT_CHAR(enc, p, n) (0) | | | | ------------------ | | | | | Branch (102:41): [True: 0, Folded] | | | | ------------------ | | | | 103| 8| *nextTokPtr = ptr; \ | | | | 104| 8| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 8|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 105| 8| } \ | | | | 106| 8| ptr += n; \ | | | | 107| 0| break; | | ------------------ ------------------ 733| 426| case BT_EXCL: ------------------ | Branch (733:3): [True: 426, False: 6.30k] ------------------ 734| 426| ptr += MINBPC(enc); ------------------ | | 698| 426|#define MINBPC(enc) 2 ------------------ 735| 426| REQUIRE_CHAR(enc, ptr, end); ------------------ | | 140| 426|# define REQUIRE_CHAR(enc, ptr, end) REQUIRE_CHARS(enc, ptr, end, 1) | | ------------------ | | | | 134| 426| { \ | | | | 135| 426| if (! HAS_CHARS(enc, ptr, end, count)) { \ | | | | ------------------ | | | | | | 129| 426| ((end) - (ptr) >= ((count) * MINBPC(enc))) | | | | | | ------------------ | | | | | | | | 698| 426|#define MINBPC(enc) 2 | | | | | | ------------------ | | | | ------------------ | | | | | Branch (135:11): [True: 1, False: 425] | | | | ------------------ | | | | 136| 1| return XML_TOK_PARTIAL; \ | | | | ------------------ | | | | | | 56| 1|# define XML_TOK_PARTIAL -1 /* only part of a token */ | | | | ------------------ | | | | 137| 1| } \ | | | | 138| 426| } | | ------------------ ------------------ 736| 425| switch (BYTE_TYPE(enc, ptr)) { ------------------ | | 700| 425|#define BYTE_TYPE(enc, p) LITTLE2_BYTE_TYPE(enc, p) | | ------------------ | | | | 683| 425| ((p)[1] == 0 ? SB_BYTE_TYPE(enc, p) : unicode_byte_type((p)[1], (p)[0])) | | | | ------------------ | | | | | | 231| 402| (((const struct normal_encoding *)(enc))->type[(unsigned char)*(p)]) | | | | ------------------ | | | | | Branch (683:3): [True: 402, False: 23] | | | | | Branch (683:4): [True: 402, False: 23] | | | | ------------------ | | ------------------ ------------------ 737| 68| case BT_MINUS: ------------------ | Branch (737:5): [True: 68, False: 357] ------------------ 738| 68| return PREFIX(scanComment)(enc, ptr + MINBPC(enc), end, nextTokPtr); ------------------ | | 697| 68|#define PREFIX(ident) little2_##ident ------------------ return PREFIX(scanComment)(enc, ptr + MINBPC(enc), end, nextTokPtr); ------------------ | | 698| 68|#define MINBPC(enc) 2 ------------------ 739| 334| case BT_LSQB: ------------------ | Branch (739:5): [True: 334, False: 91] ------------------ 740| 334| return PREFIX(scanCdataSection)(enc, ptr + MINBPC(enc), end, nextTokPtr); ------------------ | | 697| 334|#define PREFIX(ident) little2_##ident ------------------ return PREFIX(scanCdataSection)(enc, ptr + MINBPC(enc), end, nextTokPtr); ------------------ | | 698| 334|#define MINBPC(enc) 2 ------------------ 741| 425| } 742| 23| *nextTokPtr = ptr; 743| 23| return XML_TOK_INVALID; ------------------ | | 57| 23|# define XML_TOK_INVALID 0 ------------------ 744| 741| case BT_QUEST: ------------------ | Branch (744:3): [True: 741, False: 5.99k] ------------------ 745| 741| return PREFIX(scanPi)(enc, ptr + MINBPC(enc), end, nextTokPtr); ------------------ | | 697| 741|#define PREFIX(ident) little2_##ident ------------------ return PREFIX(scanPi)(enc, ptr + MINBPC(enc), end, nextTokPtr); ------------------ | | 698| 741|#define MINBPC(enc) 2 ------------------ 746| 548| case BT_SOL: ------------------ | Branch (746:3): [True: 548, False: 6.18k] ------------------ 747| 548| return PREFIX(scanEndTag)(enc, ptr + MINBPC(enc), end, nextTokPtr); ------------------ | | 697| 548|#define PREFIX(ident) little2_##ident ------------------ return PREFIX(scanEndTag)(enc, ptr + MINBPC(enc), end, nextTokPtr); ------------------ | | 698| 548|#define MINBPC(enc) 2 ------------------ 748| 6| default: ------------------ | Branch (748:3): [True: 6, False: 6.72k] ------------------ 749| 6| *nextTokPtr = ptr; 750| 6| return XML_TOK_INVALID; ------------------ | | 57| 6|# define XML_TOK_INVALID 0 ------------------ 751| 6.73k| } 752| 4.98k|# ifdef XML_NS 753| 4.98k| hadColon = 0; 754| 4.98k|# endif 755| | /* we have a start-tag */ 756| 10.5k| while (HAS_CHAR(enc, ptr, end)) { 757| 10.5k| switch (BYTE_TYPE(enc, ptr)) { ------------------ | | 700| 10.5k|#define BYTE_TYPE(enc, p) LITTLE2_BYTE_TYPE(enc, p) | | ------------------ | | | | 683| 10.5k| ((p)[1] == 0 ? SB_BYTE_TYPE(enc, p) : unicode_byte_type((p)[1], (p)[0])) | | | | ------------------ | | | | | | 231| 6.83k| (((const struct normal_encoding *)(enc))->type[(unsigned char)*(p)]) | | | | ------------------ | | | | | Branch (683:4): [True: 6.83k, False: 3.75k] | | | | ------------------ | | ------------------ ------------------ 758| 26.4k| CHECK_NAME_CASES(enc, ptr, end, nextTokPtr) ------------------ | | 81| 5.39k| case BT_NONASCII: \ | | ------------------ | | | Branch (81:3): [True: 3.73k, False: 6.85k] | | ------------------ | | 82| 5.39k| if (! IS_NAME_CHAR_MINBPC(enc, ptr)) { \ | | ------------------ | | | | 704| 3.73k|#define IS_NAME_CHAR_MINBPC(enc, p) LITTLE2_IS_NAME_CHAR_MINBPC(p) | | | | ------------------ | | | | | | 687| 3.73k| UCS2_GET_NAMING(namePages, (unsigned char)p[1], (unsigned char)p[0]) | | | | | | ------------------ | | | | | | | | 87| 3.73k| (namingBitmap[(pages[hi] << 3) + ((lo) >> 5)] & (1u << ((lo) & 0x1F))) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (82:9): [True: 55, False: 3.68k] | | ------------------ | | 83| 55| *nextTokPtr = ptr; \ | | 84| 55| return XML_TOK_INVALID; \ | | ------------------ | | | | 57| 55|# define XML_TOK_INVALID 0 | | ------------------ | | 85| 55| } \ | | 86| 5.39k| EXPAT_FALLTHROUGH; \ | | ------------------ | | | | 47| 3.68k|# define EXPAT_FALLTHROUGH __attribute__((fallthrough)) | | ------------------ | | 87| 4.36k| case BT_NMSTRT: \ | | ------------------ | | | Branch (87:3): [True: 685, False: 9.90k] | | ------------------ | | 88| 4.61k| case BT_HEX: \ | | ------------------ | | | Branch (88:3): [True: 253, False: 10.3k] | | ------------------ | | 89| 4.83k| case BT_DIGIT: \ | | ------------------ | | | Branch (89:3): [True: 218, False: 10.3k] | | ------------------ | | 90| 5.15k| case BT_NAME: \ | | ------------------ | | | Branch (90:3): [True: 321, False: 10.2k] | | ------------------ | | 91| 5.39k| case BT_MINUS: \ | | ------------------ | | | Branch (91:3): [True: 241, False: 10.3k] | | ------------------ | | 92| 5.39k| ptr += MINBPC(enc); \ | | ------------------ | | | | 698| 5.39k|#define MINBPC(enc) 2 | | ------------------ | | 93| 5.39k| break; \ | | 94| 5.39k| CHECK_NAME_CASE(2, enc, ptr, end, nextTokPtr) \ | | ------------------ | | | | 70| 0| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (70:3): [True: 0, False: 10.5k] | | | | ------------------ | | | | 71| 0| if (end - ptr < n) \ | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 0] | | | | ------------------ | | | | 72| 0| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 0|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 73| 0| if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NAME_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 707| 0|#define IS_INVALID_CHAR(enc, p, n) LITTLE2_IS_INVALID_CHAR(p, n) | | | | | | ------------------ | | | | | | | | 694| 0| ((n) == 4 && ((unsigned char)(p)[3] & 0xFC) != 0xDC) | | | | | | | | ------------------ | | | | | | | | | Branch (694:4): [Folded, False: 0] | | | | | | | | | Branch (694:16): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NAME_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 703| 0|#define IS_NAME_CHAR(enc, p, n) 0 | | | | ------------------ | | | | | Branch (73:41): [True: 0, Folded] | | | | ------------------ | | | | 74| 0| *nextTokPtr = ptr; \ | | | | 75| 0| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 0|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 76| 0| } \ | | | | 77| 0| ptr += n; \ | | | | 78| 0| break; | | ------------------ | | 95| 0| CHECK_NAME_CASE(3, enc, ptr, end, nextTokPtr) \ | | ------------------ | | | | 70| 0| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (70:3): [True: 0, False: 10.5k] | | | | ------------------ | | | | 71| 0| if (end - ptr < n) \ | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 0] | | | | ------------------ | | | | 72| 0| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 0|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 73| 0| if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NAME_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 707| 0|#define IS_INVALID_CHAR(enc, p, n) LITTLE2_IS_INVALID_CHAR(p, n) | | | | | | ------------------ | | | | | | | | 694| 0| ((n) == 4 && ((unsigned char)(p)[3] & 0xFC) != 0xDC) | | | | | | | | ------------------ | | | | | | | | | Branch (694:4): [Folded, False: 0] | | | | | | | | | Branch (694:16): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NAME_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 703| 0|#define IS_NAME_CHAR(enc, p, n) 0 | | | | ------------------ | | | | | Branch (73:41): [True: 0, Folded] | | | | ------------------ | | | | 74| 0| *nextTokPtr = ptr; \ | | | | 75| 0| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 0|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 76| 0| } \ | | | | 77| 0| ptr += n; \ | | | | 78| 0| break; | | ------------------ | | 96| 13| CHECK_NAME_CASE(4, enc, ptr, end, nextTokPtr) | | ------------------ | | | | 70| 13| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (70:3): [True: 13, False: 10.5k] | | | | ------------------ | | | | 71| 13| if (end - ptr < n) \ | | | | ------------------ | | | | | Branch (71:9): [True: 1, False: 12] | | | | ------------------ | | | | 72| 1| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 1|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 73| 12| if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NAME_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 707| 12|#define IS_INVALID_CHAR(enc, p, n) LITTLE2_IS_INVALID_CHAR(p, n) | | | | | | ------------------ | | | | | | | | 694| 24| ((n) == 4 && ((unsigned char)(p)[3] & 0xFC) != 0xDC) | | | | | | | | ------------------ | | | | | | | | | Branch (694:4): [True: 12, Folded] | | | | | | | | | Branch (694:16): [True: 12, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NAME_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 703| 0|#define IS_NAME_CHAR(enc, p, n) 0 | | | | ------------------ | | | | | Branch (73:41): [True: 0, Folded] | | | | ------------------ | | | | 74| 12| *nextTokPtr = ptr; \ | | | | 75| 12| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 12|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 76| 12| } \ | | | | 77| 12| ptr += n; \ | | | | 78| 0| break; | | ------------------ ------------------ 759| 0|# ifdef XML_NS 760| 237| case BT_COLON: ------------------ | Branch (760:5): [True: 237, False: 10.3k] ------------------ 761| 237| if (hadColon) { ------------------ | Branch (761:11): [True: 1, False: 236] ------------------ 762| 1| *nextTokPtr = ptr; 763| 1| return XML_TOK_INVALID; ------------------ | | 57| 1|# define XML_TOK_INVALID 0 ------------------ 764| 1| } 765| 236| hadColon = 1; 766| 236| ptr += MINBPC(enc); ------------------ | | 698| 236|#define MINBPC(enc) 2 ------------------ 767| 236| REQUIRE_CHAR(enc, ptr, end); ------------------ | | 140| 236|# define REQUIRE_CHAR(enc, ptr, end) REQUIRE_CHARS(enc, ptr, end, 1) | | ------------------ | | | | 134| 236| { \ | | | | 135| 236| if (! HAS_CHARS(enc, ptr, end, count)) { \ | | | | ------------------ | | | | | | 129| 236| ((end) - (ptr) >= ((count) * MINBPC(enc))) | | | | | | ------------------ | | | | | | | | 698| 236|#define MINBPC(enc) 2 | | | | | | ------------------ | | | | ------------------ | | | | | Branch (135:11): [True: 1, False: 235] | | | | ------------------ | | | | 136| 1| return XML_TOK_PARTIAL; \ | | | | ------------------ | | | | | | 56| 1|# define XML_TOK_PARTIAL -1 /* only part of a token */ | | | | ------------------ | | | | 137| 1| } \ | | | | 138| 236| } | | ------------------ ------------------ 768| 235| switch (BYTE_TYPE(enc, ptr)) { ------------------ | | 700| 235|#define BYTE_TYPE(enc, p) LITTLE2_BYTE_TYPE(enc, p) | | ------------------ | | | | 683| 235| ((p)[1] == 0 ? SB_BYTE_TYPE(enc, p) : unicode_byte_type((p)[1], (p)[0])) | | | | ------------------ | | | | | | 231| 133| (((const struct normal_encoding *)(enc))->type[(unsigned char)*(p)]) | | | | ------------------ | | | | | Branch (683:4): [True: 133, False: 102] | | | | ------------------ | | ------------------ ------------------ 769| 329| CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr) ------------------ | | 110| 209| case BT_NONASCII: \ | | ------------------ | | | Branch (110:3): [True: 84, False: 151] | | ------------------ | | 111| 209| if (! IS_NMSTRT_CHAR_MINBPC(enc, ptr)) { \ | | ------------------ | | | | 706| 84|#define IS_NMSTRT_CHAR_MINBPC(enc, p) LITTLE2_IS_NMSTRT_CHAR_MINBPC(p) | | | | ------------------ | | | | | | 689| 84| UCS2_GET_NAMING(nmstrtPages, (unsigned char)p[1], (unsigned char)p[0]) | | | | | | ------------------ | | | | | | | | 87| 84| (namingBitmap[(pages[hi] << 3) + ((lo) >> 5)] & (1u << ((lo) & 0x1F))) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (111:9): [True: 7, False: 77] | | ------------------ | | 112| 7| *nextTokPtr = ptr; \ | | 113| 7| return XML_TOK_INVALID; \ | | ------------------ | | | | 57| 7|# define XML_TOK_INVALID 0 | | ------------------ | | 114| 7| } \ | | 115| 209| EXPAT_FALLTHROUGH; \ | | ------------------ | | | | 47| 77|# define EXPAT_FALLTHROUGH __attribute__((fallthrough)) | | ------------------ | | 116| 143| case BT_NMSTRT: \ | | ------------------ | | | Branch (116:3): [True: 66, False: 169] | | ------------------ | | 117| 209| case BT_HEX: \ | | ------------------ | | | Branch (117:3): [True: 66, False: 169] | | ------------------ | | 118| 209| ptr += MINBPC(enc); \ | | ------------------ | | | | 698| 209|#define MINBPC(enc) 2 | | ------------------ | | 119| 209| break; \ | | 120| 209| CHECK_NMSTRT_CASE(2, enc, ptr, end, nextTokPtr) \ | | ------------------ | | | | 99| 0| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (99:3): [True: 0, False: 235] | | | | ------------------ | | | | 100| 0| if ((end) - (ptr) < (n)) \ | | | | ------------------ | | | | | Branch (100:9): [True: 0, False: 0] | | | | ------------------ | | | | 101| 0| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 0|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 102| 0| if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NMSTRT_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 707| 0|#define IS_INVALID_CHAR(enc, p, n) LITTLE2_IS_INVALID_CHAR(p, n) | | | | | | ------------------ | | | | | | | | 694| 0| ((n) == 4 && ((unsigned char)(p)[3] & 0xFC) != 0xDC) | | | | | | | | ------------------ | | | | | | | | | Branch (694:4): [Folded, False: 0] | | | | | | | | | Branch (694:16): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NMSTRT_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 705| 0|#define IS_NMSTRT_CHAR(enc, p, n) (0) | | | | ------------------ | | | | | Branch (102:41): [True: 0, Folded] | | | | ------------------ | | | | 103| 0| *nextTokPtr = ptr; \ | | | | 104| 0| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 0|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 105| 0| } \ | | | | 106| 0| ptr += n; \ | | | | 107| 0| break; | | ------------------ | | 121| 0| CHECK_NMSTRT_CASE(3, enc, ptr, end, nextTokPtr) \ | | ------------------ | | | | 99| 0| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (99:3): [True: 0, False: 235] | | | | ------------------ | | | | 100| 0| if ((end) - (ptr) < (n)) \ | | | | ------------------ | | | | | Branch (100:9): [True: 0, False: 0] | | | | ------------------ | | | | 101| 0| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 0|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 102| 0| if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NMSTRT_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 707| 0|#define IS_INVALID_CHAR(enc, p, n) LITTLE2_IS_INVALID_CHAR(p, n) | | | | | | ------------------ | | | | | | | | 694| 0| ((n) == 4 && ((unsigned char)(p)[3] & 0xFC) != 0xDC) | | | | | | | | ------------------ | | | | | | | | | Branch (694:4): [Folded, False: 0] | | | | | | | | | Branch (694:16): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NMSTRT_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 705| 0|#define IS_NMSTRT_CHAR(enc, p, n) (0) | | | | ------------------ | | | | | Branch (102:41): [True: 0, Folded] | | | | ------------------ | | | | 103| 0| *nextTokPtr = ptr; \ | | | | 104| 0| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 0|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 105| 0| } \ | | | | 106| 0| ptr += n; \ | | | | 107| 0| break; | | ------------------ | | 122| 13| CHECK_NMSTRT_CASE(4, enc, ptr, end, nextTokPtr) | | ------------------ | | | | 99| 13| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (99:3): [True: 13, False: 222] | | | | ------------------ | | | | 100| 13| if ((end) - (ptr) < (n)) \ | | | | ------------------ | | | | | Branch (100:9): [True: 1, False: 12] | | | | ------------------ | | | | 101| 1| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 1|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 102| 12| if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NMSTRT_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 707| 12|#define IS_INVALID_CHAR(enc, p, n) LITTLE2_IS_INVALID_CHAR(p, n) | | | | | | ------------------ | | | | | | | | 694| 24| ((n) == 4 && ((unsigned char)(p)[3] & 0xFC) != 0xDC) | | | | | | | | ------------------ | | | | | | | | | Branch (694:4): [True: 12, Folded] | | | | | | | | | Branch (694:16): [True: 12, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NMSTRT_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 705| 0|#define IS_NMSTRT_CHAR(enc, p, n) (0) | | | | ------------------ | | | | | Branch (102:41): [True: 0, Folded] | | | | ------------------ | | | | 103| 12| *nextTokPtr = ptr; \ | | | | 104| 12| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 12|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 105| 12| } \ | | | | 106| 12| ptr += n; \ | | | | 107| 0| break; | | ------------------ ------------------ 770| 6| default: ------------------ | Branch (770:7): [True: 6, False: 229] ------------------ 771| 6| *nextTokPtr = ptr; 772| 6| return XML_TOK_INVALID; ------------------ | | 57| 6|# define XML_TOK_INVALID 0 ------------------ 773| 235| } 774| 209| break; 775| 209|# endif 776| 1.45k| case BT_S: ------------------ | Branch (776:5): [True: 1.45k, False: 9.13k] ------------------ 777| 1.63k| case BT_CR: ------------------ | Branch (777:5): [True: 173, False: 10.4k] ------------------ 778| 1.74k| case BT_LF: { ------------------ | Branch (778:5): [True: 117, False: 10.4k] ------------------ 779| 1.74k| ptr += MINBPC(enc); ------------------ | | 698| 1.74k|#define MINBPC(enc) 2 ------------------ 780| 2.60k| while (HAS_CHAR(enc, ptr, end)) { 781| 2.60k| switch (BYTE_TYPE(enc, ptr)) { ------------------ | | 700| 2.60k|#define BYTE_TYPE(enc, p) LITTLE2_BYTE_TYPE(enc, p) | | ------------------ | | | | 683| 2.60k| ((p)[1] == 0 ? SB_BYTE_TYPE(enc, p) : unicode_byte_type((p)[1], (p)[0])) | | | | ------------------ | | | | | | 231| 1.31k| (((const struct normal_encoding *)(enc))->type[(unsigned char)*(p)]) | | | | ------------------ | | | | | Branch (683:4): [True: 1.31k, False: 1.29k] | | | | ------------------ | | ------------------ ------------------ 782| 3.87k| CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr) ------------------ | | 110| 1.39k| case BT_NONASCII: \ | | ------------------ | | | Branch (110:3): [True: 1.27k, False: 1.33k] | | ------------------ | | 111| 1.39k| if (! IS_NMSTRT_CHAR_MINBPC(enc, ptr)) { \ | | ------------------ | | | | 706| 1.27k|#define IS_NMSTRT_CHAR_MINBPC(enc, p) LITTLE2_IS_NMSTRT_CHAR_MINBPC(p) | | | | ------------------ | | | | | | 689| 1.27k| UCS2_GET_NAMING(nmstrtPages, (unsigned char)p[1], (unsigned char)p[0]) | | | | | | ------------------ | | | | | | | | 87| 1.27k| (namingBitmap[(pages[hi] << 3) + ((lo) >> 5)] & (1u << ((lo) & 0x1F))) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (111:9): [True: 25, False: 1.25k] | | ------------------ | | 112| 25| *nextTokPtr = ptr; \ | | 113| 25| return XML_TOK_INVALID; \ | | ------------------ | | | | 57| 25|# define XML_TOK_INVALID 0 | | ------------------ | | 114| 25| } \ | | 115| 1.39k| EXPAT_FALLTHROUGH; \ | | ------------------ | | | | 47| 1.25k|# define EXPAT_FALLTHROUGH __attribute__((fallthrough)) | | ------------------ | | 116| 1.32k| case BT_NMSTRT: \ | | ------------------ | | | Branch (116:3): [True: 73, False: 2.53k] | | ------------------ | | 117| 1.39k| case BT_HEX: \ | | ------------------ | | | Branch (117:3): [True: 68, False: 2.54k] | | ------------------ | | 118| 1.39k| ptr += MINBPC(enc); \ | | ------------------ | | | | 698| 1.39k|#define MINBPC(enc) 2 | | ------------------ | | 119| 1.39k| break; \ | | 120| 1.39k| CHECK_NMSTRT_CASE(2, enc, ptr, end, nextTokPtr) \ | | ------------------ | | | | 99| 0| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (99:3): [True: 0, False: 2.60k] | | | | ------------------ | | | | 100| 0| if ((end) - (ptr) < (n)) \ | | | | ------------------ | | | | | Branch (100:9): [True: 0, False: 0] | | | | ------------------ | | | | 101| 0| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 0|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 102| 0| if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NMSTRT_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 707| 0|#define IS_INVALID_CHAR(enc, p, n) LITTLE2_IS_INVALID_CHAR(p, n) | | | | | | ------------------ | | | | | | | | 694| 0| ((n) == 4 && ((unsigned char)(p)[3] & 0xFC) != 0xDC) | | | | | | | | ------------------ | | | | | | | | | Branch (694:4): [Folded, False: 0] | | | | | | | | | Branch (694:16): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NMSTRT_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 705| 0|#define IS_NMSTRT_CHAR(enc, p, n) (0) | | | | ------------------ | | | | | Branch (102:41): [True: 0, Folded] | | | | ------------------ | | | | 103| 0| *nextTokPtr = ptr; \ | | | | 104| 0| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 0|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 105| 0| } \ | | | | 106| 0| ptr += n; \ | | | | 107| 0| break; | | ------------------ | | 121| 0| CHECK_NMSTRT_CASE(3, enc, ptr, end, nextTokPtr) \ | | ------------------ | | | | 99| 0| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (99:3): [True: 0, False: 2.60k] | | | | ------------------ | | | | 100| 0| if ((end) - (ptr) < (n)) \ | | | | ------------------ | | | | | Branch (100:9): [True: 0, False: 0] | | | | ------------------ | | | | 101| 0| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 0|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 102| 0| if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NMSTRT_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 707| 0|#define IS_INVALID_CHAR(enc, p, n) LITTLE2_IS_INVALID_CHAR(p, n) | | | | | | ------------------ | | | | | | | | 694| 0| ((n) == 4 && ((unsigned char)(p)[3] & 0xFC) != 0xDC) | | | | | | | | ------------------ | | | | | | | | | Branch (694:4): [Folded, False: 0] | | | | | | | | | Branch (694:16): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NMSTRT_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 705| 0|#define IS_NMSTRT_CHAR(enc, p, n) (0) | | | | ------------------ | | | | | Branch (102:41): [True: 0, Folded] | | | | ------------------ | | | | 103| 0| *nextTokPtr = ptr; \ | | | | 104| 0| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 0|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 105| 0| } \ | | | | 106| 0| ptr += n; \ | | | | 107| 0| break; | | ------------------ | | 122| 12| CHECK_NMSTRT_CASE(4, enc, ptr, end, nextTokPtr) | | ------------------ | | | | 99| 12| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (99:3): [True: 12, False: 2.59k] | | | | ------------------ | | | | 100| 12| if ((end) - (ptr) < (n)) \ | | | | ------------------ | | | | | Branch (100:9): [True: 1, False: 11] | | | | ------------------ | | | | 101| 1| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 1|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 102| 11| if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NMSTRT_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 707| 11|#define IS_INVALID_CHAR(enc, p, n) LITTLE2_IS_INVALID_CHAR(p, n) | | | | | | ------------------ | | | | | | | | 694| 22| ((n) == 4 && ((unsigned char)(p)[3] & 0xFC) != 0xDC) | | | | | | | | ------------------ | | | | | | | | | Branch (694:4): [True: 11, Folded] | | | | | | | | | Branch (694:16): [True: 11, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NMSTRT_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 705| 0|#define IS_NMSTRT_CHAR(enc, p, n) (0) | | | | ------------------ | | | | | Branch (102:41): [True: 0, Folded] | | | | ------------------ | | | | 103| 11| *nextTokPtr = ptr; \ | | | | 104| 11| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 11|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 105| 11| } \ | | | | 106| 11| ptr += n; \ | | | | 107| 0| break; | | ------------------ ------------------ 783| 243| case BT_GT: ------------------ | Branch (783:9): [True: 243, False: 2.36k] ------------------ 784| 243| goto gt; 785| 69| case BT_SOL: ------------------ | Branch (785:9): [True: 69, False: 2.54k] ------------------ 786| 69| goto sol; 787| 363| case BT_S: ------------------ | Branch (787:9): [True: 363, False: 2.24k] ------------------ 788| 601| case BT_CR: ------------------ | Branch (788:9): [True: 238, False: 2.37k] ------------------ 789| 862| case BT_LF: ------------------ | Branch (789:9): [True: 261, False: 2.34k] ------------------ 790| 862| ptr += MINBPC(enc); ------------------ | | 698| 862|#define MINBPC(enc) 2 ------------------ 791| 862| continue; 792| 6| default: ------------------ | Branch (792:9): [True: 6, False: 2.60k] ------------------ 793| 6| *nextTokPtr = ptr; 794| 6| return XML_TOK_INVALID; ------------------ | | 57| 6|# define XML_TOK_INVALID 0 ------------------ 795| 2.60k| } 796| 1.39k| return PREFIX(scanAtts)(enc, ptr, end, nextTokPtr); ------------------ | | 697| 1.39k|#define PREFIX(ident) little2_##ident ------------------ 797| 2.60k| } 798| 2| return XML_TOK_PARTIAL; ------------------ | | 56| 2|# define XML_TOK_PARTIAL -1 /* only part of a token */ ------------------ 799| 1.74k| } 800| 2.58k| case BT_GT: ------------------ | Branch (800:5): [True: 2.58k, False: 8.00k] ------------------ 801| 2.82k| gt: 802| 2.82k| *nextTokPtr = ptr + MINBPC(enc); ------------------ | | 698| 2.82k|#define MINBPC(enc) 2 ------------------ 803| 2.82k| return XML_TOK_START_TAG_NO_ATTS; ------------------ | | 63| 2.82k|# define XML_TOK_START_TAG_NO_ATTS 2 ------------------ 804| 546| case BT_SOL: ------------------ | Branch (804:5): [True: 546, False: 10.0k] ------------------ 805| 615| sol: 806| 615| ptr += MINBPC(enc); ------------------ | | 698| 615|#define MINBPC(enc) 2 ------------------ 807| 615| REQUIRE_CHAR(enc, ptr, end); ------------------ | | 140| 615|# define REQUIRE_CHAR(enc, ptr, end) REQUIRE_CHARS(enc, ptr, end, 1) | | ------------------ | | | | 134| 615| { \ | | | | 135| 615| if (! HAS_CHARS(enc, ptr, end, count)) { \ | | | | ------------------ | | | | | | 129| 615| ((end) - (ptr) >= ((count) * MINBPC(enc))) | | | | | | ------------------ | | | | | | | | 698| 615|#define MINBPC(enc) 2 | | | | | | ------------------ | | | | ------------------ | | | | | Branch (135:11): [True: 1, False: 614] | | | | ------------------ | | | | 136| 1| return XML_TOK_PARTIAL; \ | | | | ------------------ | | | | | | 56| 1|# define XML_TOK_PARTIAL -1 /* only part of a token */ | | | | ------------------ | | | | 137| 1| } \ | | | | 138| 615| } | | ------------------ ------------------ 808| 614| if (! CHAR_MATCHES(enc, ptr, ASCII_GT)) { ------------------ | | 702| 614|#define CHAR_MATCHES(enc, p, c) LITTLE2_CHAR_MATCHES(p, c) | | ------------------ | | | | 685| 614|#define LITTLE2_CHAR_MATCHES(p, c) ((p)[1] == 0 && (p)[0] == (c)) | | | | ------------------ | | | | | Branch (685:37): [True: 602, False: 12] | | | | | Branch (685:52): [True: 594, False: 8] | | | | ------------------ | | ------------------ ------------------ 809| 20| *nextTokPtr = ptr; 810| 20| return XML_TOK_INVALID; ------------------ | | 57| 20|# define XML_TOK_INVALID 0 ------------------ 811| 20| } 812| 594| *nextTokPtr = ptr + MINBPC(enc); ------------------ | | 698| 594|#define MINBPC(enc) 2 ------------------ 813| 594| return XML_TOK_EMPTY_ELEMENT_NO_ATTS; ------------------ | | 65| 594|# define XML_TOK_EMPTY_ELEMENT_NO_ATTS 4 ------------------ 814| 8| default: ------------------ | Branch (814:5): [True: 8, False: 10.5k] ------------------ 815| 8| *nextTokPtr = ptr; 816| 8| return XML_TOK_INVALID; ------------------ | | 57| 8|# define XML_TOK_INVALID 0 ------------------ 817| 10.5k| } 818| 10.5k| } 819| 4| return XML_TOK_PARTIAL; ------------------ | | 56| 4|# define XML_TOK_PARTIAL -1 /* only part of a token */ ------------------ 820| 4.98k|} xmltok.c:little2_scanCdataSection: 337| 334| const char **nextTokPtr) { 338| 334| static const char CDATA_LSQB[] 339| 334| = {ASCII_C, ASCII_D, ASCII_A, ASCII_T, ASCII_A, ASCII_LSQB}; ------------------ | | 40| 334|#define ASCII_C 0x43 ------------------ = {ASCII_C, ASCII_D, ASCII_A, ASCII_T, ASCII_A, ASCII_LSQB}; ------------------ | | 41| 334|#define ASCII_D 0x44 ------------------ = {ASCII_C, ASCII_D, ASCII_A, ASCII_T, ASCII_A, ASCII_LSQB}; ------------------ | | 38| 334|#define ASCII_A 0x41 ------------------ = {ASCII_C, ASCII_D, ASCII_A, ASCII_T, ASCII_A, ASCII_LSQB}; ------------------ | | 57| 334|#define ASCII_T 0x54 ------------------ = {ASCII_C, ASCII_D, ASCII_A, ASCII_T, ASCII_A, ASCII_LSQB}; ------------------ | | 38| 334|#define ASCII_A 0x41 ------------------ = {ASCII_C, ASCII_D, ASCII_A, ASCII_T, ASCII_A, ASCII_LSQB}; ------------------ | | 116| 334|#define ASCII_LSQB 0x5B ------------------ 340| 334| int i; 341| 334| UNUSED_P(enc); ------------------ | | 101| 334|# define UNUSED_P(p) (void)p ------------------ 342| | /* CDATA[ */ 343| 334| REQUIRE_CHARS(enc, ptr, end, 6); ------------------ | | 134| 334| { \ | | 135| 334| if (! HAS_CHARS(enc, ptr, end, count)) { \ | | ------------------ | | | | 129| 334| ((end) - (ptr) >= ((count) * MINBPC(enc))) | | | | ------------------ | | | | | | 698| 334|#define MINBPC(enc) 2 | | | | ------------------ | | ------------------ | | | Branch (135:11): [True: 4, False: 330] | | ------------------ | | 136| 4| return XML_TOK_PARTIAL; \ | | ------------------ | | | | 56| 4|# define XML_TOK_PARTIAL -1 /* only part of a token */ | | ------------------ | | 137| 4| } \ | | 138| 334| } ------------------ 344| 2.22k| for (i = 0; i < 6; i++, ptr += MINBPC(enc)) { ------------------ | | 698| 1.89k|#define MINBPC(enc) 2 ------------------ | Branch (344:15): [True: 1.91k, False: 313] ------------------ 345| 1.91k| if (! CHAR_MATCHES(enc, ptr, CDATA_LSQB[i])) { ------------------ | | 702| 1.91k|#define CHAR_MATCHES(enc, p, c) LITTLE2_CHAR_MATCHES(p, c) | | ------------------ | | | | 685| 1.91k|#define LITTLE2_CHAR_MATCHES(p, c) ((p)[1] == 0 && (p)[0] == (c)) | | | | ------------------ | | | | | Branch (685:37): [True: 1.90k, False: 8] | | | | | Branch (685:52): [True: 1.89k, False: 9] | | | | ------------------ | | ------------------ ------------------ 346| 17| *nextTokPtr = ptr; 347| 17| return XML_TOK_INVALID; ------------------ | | 57| 17|# define XML_TOK_INVALID 0 ------------------ 348| 17| } 349| 1.91k| } 350| 313| *nextTokPtr = ptr; 351| 313| return XML_TOK_CDATA_SECT_OPEN; ------------------ | | 69| 313|# define XML_TOK_CDATA_SECT_OPEN 8 ------------------ 352| 330|} xmltok.c:little2_scanEndTag: 432| 548| const char **nextTokPtr) { 433| 548| REQUIRE_CHAR(enc, ptr, end); ------------------ | | 140| 548|# define REQUIRE_CHAR(enc, ptr, end) REQUIRE_CHARS(enc, ptr, end, 1) | | ------------------ | | | | 134| 548| { \ | | | | 135| 548| if (! HAS_CHARS(enc, ptr, end, count)) { \ | | | | ------------------ | | | | | | 129| 548| ((end) - (ptr) >= ((count) * MINBPC(enc))) | | | | | | ------------------ | | | | | | | | 698| 548|#define MINBPC(enc) 2 | | | | | | ------------------ | | | | ------------------ | | | | | Branch (135:11): [True: 1, False: 547] | | | | ------------------ | | | | 136| 1| return XML_TOK_PARTIAL; \ | | | | ------------------ | | | | | | 56| 1|# define XML_TOK_PARTIAL -1 /* only part of a token */ | | | | ------------------ | | | | 137| 1| } \ | | | | 138| 548| } | | ------------------ ------------------ 434| 547| switch (BYTE_TYPE(enc, ptr)) { ------------------ | | 700| 547|#define BYTE_TYPE(enc, p) LITTLE2_BYTE_TYPE(enc, p) | | ------------------ | | | | 683| 547| ((p)[1] == 0 ? SB_BYTE_TYPE(enc, p) : unicode_byte_type((p)[1], (p)[0])) | | | | ------------------ | | | | | | 231| 197| (((const struct normal_encoding *)(enc))->type[(unsigned char)*(p)]) | | | | ------------------ | | | | | Branch (683:4): [True: 197, False: 350] | | | | ------------------ | | ------------------ ------------------ 435| 1.07k| CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr) ------------------ | | 110| 522| case BT_NONASCII: \ | | ------------------ | | | Branch (110:3): [True: 337, False: 210] | | ------------------ | | 111| 522| if (! IS_NMSTRT_CHAR_MINBPC(enc, ptr)) { \ | | ------------------ | | | | 706| 337|#define IS_NMSTRT_CHAR_MINBPC(enc, p) LITTLE2_IS_NMSTRT_CHAR_MINBPC(p) | | | | ------------------ | | | | | | 689| 337| UCS2_GET_NAMING(nmstrtPages, (unsigned char)p[1], (unsigned char)p[0]) | | | | | | ------------------ | | | | | | | | 87| 337| (namingBitmap[(pages[hi] << 3) + ((lo) >> 5)] & (1u << ((lo) & 0x1F))) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (111:9): [True: 12, False: 325] | | ------------------ | | 112| 12| *nextTokPtr = ptr; \ | | 113| 12| return XML_TOK_INVALID; \ | | ------------------ | | | | 57| 12|# define XML_TOK_INVALID 0 | | ------------------ | | 114| 12| } \ | | 115| 522| EXPAT_FALLTHROUGH; \ | | ------------------ | | | | 47| 325|# define EXPAT_FALLTHROUGH __attribute__((fallthrough)) | | ------------------ | | 116| 396| case BT_NMSTRT: \ | | ------------------ | | | Branch (116:3): [True: 71, False: 476] | | ------------------ | | 117| 522| case BT_HEX: \ | | ------------------ | | | Branch (117:3): [True: 126, False: 421] | | ------------------ | | 118| 522| ptr += MINBPC(enc); \ | | ------------------ | | | | 698| 522|#define MINBPC(enc) 2 | | ------------------ | | 119| 522| break; \ | | 120| 522| CHECK_NMSTRT_CASE(2, enc, ptr, end, nextTokPtr) \ | | ------------------ | | | | 99| 0| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (99:3): [True: 0, False: 547] | | | | ------------------ | | | | 100| 0| if ((end) - (ptr) < (n)) \ | | | | ------------------ | | | | | Branch (100:9): [True: 0, False: 0] | | | | ------------------ | | | | 101| 0| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 0|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 102| 0| if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NMSTRT_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 707| 0|#define IS_INVALID_CHAR(enc, p, n) LITTLE2_IS_INVALID_CHAR(p, n) | | | | | | ------------------ | | | | | | | | 694| 0| ((n) == 4 && ((unsigned char)(p)[3] & 0xFC) != 0xDC) | | | | | | | | ------------------ | | | | | | | | | Branch (694:4): [Folded, False: 0] | | | | | | | | | Branch (694:16): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NMSTRT_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 705| 0|#define IS_NMSTRT_CHAR(enc, p, n) (0) | | | | ------------------ | | | | | Branch (102:41): [True: 0, Folded] | | | | ------------------ | | | | 103| 0| *nextTokPtr = ptr; \ | | | | 104| 0| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 0|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 105| 0| } \ | | | | 106| 0| ptr += n; \ | | | | 107| 0| break; | | ------------------ | | 121| 0| CHECK_NMSTRT_CASE(3, enc, ptr, end, nextTokPtr) \ | | ------------------ | | | | 99| 0| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (99:3): [True: 0, False: 547] | | | | ------------------ | | | | 100| 0| if ((end) - (ptr) < (n)) \ | | | | ------------------ | | | | | Branch (100:9): [True: 0, False: 0] | | | | ------------------ | | | | 101| 0| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 0|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 102| 0| if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NMSTRT_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 707| 0|#define IS_INVALID_CHAR(enc, p, n) LITTLE2_IS_INVALID_CHAR(p, n) | | | | | | ------------------ | | | | | | | | 694| 0| ((n) == 4 && ((unsigned char)(p)[3] & 0xFC) != 0xDC) | | | | | | | | ------------------ | | | | | | | | | Branch (694:4): [Folded, False: 0] | | | | | | | | | Branch (694:16): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NMSTRT_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 705| 0|#define IS_NMSTRT_CHAR(enc, p, n) (0) | | | | ------------------ | | | | | Branch (102:41): [True: 0, Folded] | | | | ------------------ | | | | 103| 0| *nextTokPtr = ptr; \ | | | | 104| 0| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 0|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 105| 0| } \ | | | | 106| 0| ptr += n; \ | | | | 107| 0| break; | | ------------------ | | 122| 8| CHECK_NMSTRT_CASE(4, enc, ptr, end, nextTokPtr) | | ------------------ | | | | 99| 8| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (99:3): [True: 8, False: 539] | | | | ------------------ | | | | 100| 8| if ((end) - (ptr) < (n)) \ | | | | ------------------ | | | | | Branch (100:9): [True: 1, False: 7] | | | | ------------------ | | | | 101| 1| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 1|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 102| 7| if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NMSTRT_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 707| 7|#define IS_INVALID_CHAR(enc, p, n) LITTLE2_IS_INVALID_CHAR(p, n) | | | | | | ------------------ | | | | | | | | 694| 14| ((n) == 4 && ((unsigned char)(p)[3] & 0xFC) != 0xDC) | | | | | | | | ------------------ | | | | | | | | | Branch (694:4): [True: 7, Folded] | | | | | | | | | Branch (694:16): [True: 7, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NMSTRT_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 705| 0|#define IS_NMSTRT_CHAR(enc, p, n) (0) | | | | ------------------ | | | | | Branch (102:41): [True: 0, Folded] | | | | ------------------ | | | | 103| 7| *nextTokPtr = ptr; \ | | | | 104| 7| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 7|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 105| 7| } \ | | | | 106| 7| ptr += n; \ | | | | 107| 0| break; | | ------------------ ------------------ 436| 5| default: ------------------ | Branch (436:3): [True: 5, False: 542] ------------------ 437| 5| *nextTokPtr = ptr; 438| 5| return XML_TOK_INVALID; ------------------ | | 57| 5|# define XML_TOK_INVALID 0 ------------------ 439| 547| } 440| 2.07k| while (HAS_CHAR(enc, ptr, end)) { 441| 2.07k| switch (BYTE_TYPE(enc, ptr)) { ------------------ | | 700| 2.07k|#define BYTE_TYPE(enc, p) LITTLE2_BYTE_TYPE(enc, p) | | ------------------ | | | | 683| 2.07k| ((p)[1] == 0 ? SB_BYTE_TYPE(enc, p) : unicode_byte_type((p)[1], (p)[0])) | | | | ------------------ | | | | | | 231| 1.62k| (((const struct normal_encoding *)(enc))->type[(unsigned char)*(p)]) | | | | ------------------ | | | | | Branch (683:4): [True: 1.62k, False: 449] | | | | ------------------ | | ------------------ ------------------ 442| 4.23k| CHECK_NAME_CASES(enc, ptr, end, nextTokPtr) ------------------ | | 81| 1.35k| case BT_NONASCII: \ | | ------------------ | | | Branch (81:3): [True: 434, False: 1.63k] | | ------------------ | | 82| 1.35k| if (! IS_NAME_CHAR_MINBPC(enc, ptr)) { \ | | ------------------ | | | | 704| 434|#define IS_NAME_CHAR_MINBPC(enc, p) LITTLE2_IS_NAME_CHAR_MINBPC(p) | | | | ------------------ | | | | | | 687| 434| UCS2_GET_NAMING(namePages, (unsigned char)p[1], (unsigned char)p[0]) | | | | | | ------------------ | | | | | | | | 87| 434| (namingBitmap[(pages[hi] << 3) + ((lo) >> 5)] & (1u << ((lo) & 0x1F))) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (82:9): [True: 77, False: 357] | | ------------------ | | 83| 77| *nextTokPtr = ptr; \ | | 84| 77| return XML_TOK_INVALID; \ | | ------------------ | | | | 57| 77|# define XML_TOK_INVALID 0 | | ------------------ | | 85| 77| } \ | | 86| 1.35k| EXPAT_FALLTHROUGH; \ | | ------------------ | | | | 47| 357|# define EXPAT_FALLTHROUGH __attribute__((fallthrough)) | | ------------------ | | 87| 556| case BT_NMSTRT: \ | | ------------------ | | | Branch (87:3): [True: 199, False: 1.87k] | | ------------------ | | 88| 756| case BT_HEX: \ | | ------------------ | | | Branch (88:3): [True: 200, False: 1.87k] | | ------------------ | | 89| 952| case BT_DIGIT: \ | | ------------------ | | | Branch (89:3): [True: 196, False: 1.87k] | | ------------------ | | 90| 1.16k| case BT_NAME: \ | | ------------------ | | | Branch (90:3): [True: 211, False: 1.86k] | | ------------------ | | 91| 1.35k| case BT_MINUS: \ | | ------------------ | | | Branch (91:3): [True: 196, False: 1.87k] | | ------------------ | | 92| 1.35k| ptr += MINBPC(enc); \ | | ------------------ | | | | 698| 1.35k|#define MINBPC(enc) 2 | | ------------------ | | 93| 1.35k| break; \ | | 94| 1.35k| CHECK_NAME_CASE(2, enc, ptr, end, nextTokPtr) \ | | ------------------ | | | | 70| 0| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (70:3): [True: 0, False: 2.07k] | | | | ------------------ | | | | 71| 0| if (end - ptr < n) \ | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 0] | | | | ------------------ | | | | 72| 0| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 0|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 73| 0| if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NAME_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 707| 0|#define IS_INVALID_CHAR(enc, p, n) LITTLE2_IS_INVALID_CHAR(p, n) | | | | | | ------------------ | | | | | | | | 694| 0| ((n) == 4 && ((unsigned char)(p)[3] & 0xFC) != 0xDC) | | | | | | | | ------------------ | | | | | | | | | Branch (694:4): [Folded, False: 0] | | | | | | | | | Branch (694:16): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NAME_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 703| 0|#define IS_NAME_CHAR(enc, p, n) 0 | | | | ------------------ | | | | | Branch (73:41): [True: 0, Folded] | | | | ------------------ | | | | 74| 0| *nextTokPtr = ptr; \ | | | | 75| 0| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 0|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 76| 0| } \ | | | | 77| 0| ptr += n; \ | | | | 78| 0| break; | | ------------------ | | 95| 0| CHECK_NAME_CASE(3, enc, ptr, end, nextTokPtr) \ | | ------------------ | | | | 70| 0| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (70:3): [True: 0, False: 2.07k] | | | | ------------------ | | | | 71| 0| if (end - ptr < n) \ | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 0] | | | | ------------------ | | | | 72| 0| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 0|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 73| 0| if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NAME_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 707| 0|#define IS_INVALID_CHAR(enc, p, n) LITTLE2_IS_INVALID_CHAR(p, n) | | | | | | ------------------ | | | | | | | | 694| 0| ((n) == 4 && ((unsigned char)(p)[3] & 0xFC) != 0xDC) | | | | | | | | ------------------ | | | | | | | | | Branch (694:4): [Folded, False: 0] | | | | | | | | | Branch (694:16): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NAME_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 703| 0|#define IS_NAME_CHAR(enc, p, n) 0 | | | | ------------------ | | | | | Branch (73:41): [True: 0, Folded] | | | | ------------------ | | | | 74| 0| *nextTokPtr = ptr; \ | | | | 75| 0| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 0|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 76| 0| } \ | | | | 77| 0| ptr += n; \ | | | | 78| 0| break; | | ------------------ | | 96| 9| CHECK_NAME_CASE(4, enc, ptr, end, nextTokPtr) | | ------------------ | | | | 70| 9| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (70:3): [True: 9, False: 2.06k] | | | | ------------------ | | | | 71| 9| if (end - ptr < n) \ | | | | ------------------ | | | | | Branch (71:9): [True: 1, False: 8] | | | | ------------------ | | | | 72| 1| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 1|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 73| 8| if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NAME_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 707| 8|#define IS_INVALID_CHAR(enc, p, n) LITTLE2_IS_INVALID_CHAR(p, n) | | | | | | ------------------ | | | | | | | | 694| 16| ((n) == 4 && ((unsigned char)(p)[3] & 0xFC) != 0xDC) | | | | | | | | ------------------ | | | | | | | | | Branch (694:4): [True: 8, Folded] | | | | | | | | | Branch (694:16): [True: 8, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NAME_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 703| 0|#define IS_NAME_CHAR(enc, p, n) 0 | | | | ------------------ | | | | | Branch (73:41): [True: 0, Folded] | | | | ------------------ | | | | 74| 8| *nextTokPtr = ptr; \ | | | | 75| 8| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 8|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 76| 8| } \ | | | | 77| 8| ptr += n; \ | | | | 78| 0| break; | | ------------------ ------------------ 443| 125| case BT_S: ------------------ | Branch (443:5): [True: 125, False: 1.94k] ------------------ 444| 194| case BT_CR: ------------------ | Branch (444:5): [True: 69, False: 2.00k] ------------------ 445| 276| case BT_LF: ------------------ | Branch (445:5): [True: 82, False: 1.99k] ------------------ 446| 898| for (ptr += MINBPC(enc); HAS_CHAR(enc, ptr, end); ptr += MINBPC(enc)) { ------------------ | | 698| 276|#define MINBPC(enc) 2 ------------------ for (ptr += MINBPC(enc); HAS_CHAR(enc, ptr, end); ptr += MINBPC(enc)) { ------------------ | | 698| 624|#define MINBPC(enc) 2 ------------------ 447| 898| switch (BYTE_TYPE(enc, ptr)) { ------------------ | | 700| 898|#define BYTE_TYPE(enc, p) LITTLE2_BYTE_TYPE(enc, p) | | ------------------ | | | | 683| 898| ((p)[1] == 0 ? SB_BYTE_TYPE(enc, p) : unicode_byte_type((p)[1], (p)[0])) | | | | ------------------ | | | | | | 231| 859| (((const struct normal_encoding *)(enc))->type[(unsigned char)*(p)]) | | | | ------------------ | | | | | Branch (683:4): [True: 859, False: 39] | | | | ------------------ | | ------------------ ------------------ 448| 225| case BT_S: ------------------ | Branch (448:9): [True: 225, False: 673] ------------------ 449| 427| case BT_CR: ------------------ | Branch (449:9): [True: 202, False: 696] ------------------ 450| 624| case BT_LF: ------------------ | Branch (450:9): [True: 197, False: 701] ------------------ 451| 624| break; 452| 235| case BT_GT: ------------------ | Branch (452:9): [True: 235, False: 663] ------------------ 453| 235| *nextTokPtr = ptr + MINBPC(enc); ------------------ | | 698| 235|#define MINBPC(enc) 2 ------------------ 454| 235| return XML_TOK_END_TAG; ------------------ | | 66| 235|# define XML_TOK_END_TAG 5 ------------------ 455| 39| default: ------------------ | Branch (455:9): [True: 39, False: 859] ------------------ 456| 39| *nextTokPtr = ptr; 457| 39| return XML_TOK_INVALID; ------------------ | | 57| 39|# define XML_TOK_INVALID 0 ------------------ 458| 898| } 459| 898| } 460| 2| return XML_TOK_PARTIAL; ------------------ | | 56| 2|# define XML_TOK_PARTIAL -1 /* only part of a token */ ------------------ 461| 0|# ifdef XML_NS 462| 194| case BT_COLON: ------------------ | Branch (462:5): [True: 194, False: 1.87k] ------------------ 463| | /* no need to check qname syntax here, 464| | since end-tag must match exactly */ 465| 194| ptr += MINBPC(enc); ------------------ | | 698| 194|#define MINBPC(enc) 2 ------------------ 466| 194| break; 467| 0|# endif 468| 152| case BT_GT: ------------------ | Branch (468:5): [True: 152, False: 1.92k] ------------------ 469| 152| *nextTokPtr = ptr + MINBPC(enc); ------------------ | | 698| 152|#define MINBPC(enc) 2 ------------------ 470| 152| return XML_TOK_END_TAG; ------------------ | | 66| 152|# define XML_TOK_END_TAG 5 ------------------ 471| 6| default: ------------------ | Branch (471:5): [True: 6, False: 2.06k] ------------------ 472| 6| *nextTokPtr = ptr; 473| 6| return XML_TOK_INVALID; ------------------ | | 57| 6|# define XML_TOK_INVALID 0 ------------------ 474| 2.07k| } 475| 2.07k| } 476| 2| return XML_TOK_PARTIAL; ------------------ | | 56| 2|# define XML_TOK_PARTIAL -1 /* only part of a token */ ------------------ 477| 522|} xmltok.c:little2_scanAtts: 573| 1.39k| const char **nextTokPtr) { 574| 1.39k|# ifdef XML_NS 575| 1.39k| int hadColon = 0; 576| 1.39k|# endif 577| 5.68k| while (HAS_CHAR(enc, ptr, end)) { 578| 5.68k| switch (BYTE_TYPE(enc, ptr)) { ------------------ | | 700| 5.68k|#define BYTE_TYPE(enc, p) LITTLE2_BYTE_TYPE(enc, p) | | ------------------ | | | | 683| 5.68k| ((p)[1] == 0 ? SB_BYTE_TYPE(enc, p) : unicode_byte_type((p)[1], (p)[0])) | | | | ------------------ | | | | | | 231| 4.54k| (((const struct normal_encoding *)(enc))->type[(unsigned char)*(p)]) | | | | ------------------ | | | | | Branch (683:4): [True: 4.54k, False: 1.14k] | | | | ------------------ | | ------------------ ------------------ 579| 8.35k| CHECK_NAME_CASES(enc, ptr, end, nextTokPtr) ------------------ | | 81| 2.03k| case BT_NONASCII: \ | | ------------------ | | | Branch (81:3): [True: 1.13k, False: 4.55k] | | ------------------ | | 82| 2.03k| if (! IS_NAME_CHAR_MINBPC(enc, ptr)) { \ | | ------------------ | | | | 704| 1.13k|#define IS_NAME_CHAR_MINBPC(enc, p) LITTLE2_IS_NAME_CHAR_MINBPC(p) | | | | ------------------ | | | | | | 687| 1.13k| UCS2_GET_NAMING(namePages, (unsigned char)p[1], (unsigned char)p[0]) | | | | | | ------------------ | | | | | | | | 87| 1.13k| (namingBitmap[(pages[hi] << 3) + ((lo) >> 5)] & (1u << ((lo) & 0x1F))) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (82:9): [True: 90, False: 1.04k] | | ------------------ | | 83| 90| *nextTokPtr = ptr; \ | | 84| 90| return XML_TOK_INVALID; \ | | ------------------ | | | | 57| 90|# define XML_TOK_INVALID 0 | | ------------------ | | 85| 90| } \ | | 86| 2.03k| EXPAT_FALLTHROUGH; \ | | ------------------ | | | | 47| 1.04k|# define EXPAT_FALLTHROUGH __attribute__((fallthrough)) | | ------------------ | | 87| 1.24k| case BT_NMSTRT: \ | | ------------------ | | | Branch (87:3): [True: 209, False: 5.47k] | | ------------------ | | 88| 1.44k| case BT_HEX: \ | | ------------------ | | | Branch (88:3): [True: 196, False: 5.49k] | | ------------------ | | 89| 1.64k| case BT_DIGIT: \ | | ------------------ | | | Branch (89:3): [True: 197, False: 5.48k] | | ------------------ | | 90| 1.83k| case BT_NAME: \ | | ------------------ | | | Branch (90:3): [True: 195, False: 5.49k] | | ------------------ | | 91| 2.03k| case BT_MINUS: \ | | ------------------ | | | Branch (91:3): [True: 197, False: 5.48k] | | ------------------ | | 92| 2.03k| ptr += MINBPC(enc); \ | | ------------------ | | | | 698| 2.03k|#define MINBPC(enc) 2 | | ------------------ | | 93| 2.03k| break; \ | | 94| 2.03k| CHECK_NAME_CASE(2, enc, ptr, end, nextTokPtr) \ | | ------------------ | | | | 70| 0| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (70:3): [True: 0, False: 5.68k] | | | | ------------------ | | | | 71| 0| if (end - ptr < n) \ | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 0] | | | | ------------------ | | | | 72| 0| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 0|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 73| 0| if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NAME_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 707| 0|#define IS_INVALID_CHAR(enc, p, n) LITTLE2_IS_INVALID_CHAR(p, n) | | | | | | ------------------ | | | | | | | | 694| 0| ((n) == 4 && ((unsigned char)(p)[3] & 0xFC) != 0xDC) | | | | | | | | ------------------ | | | | | | | | | Branch (694:4): [Folded, False: 0] | | | | | | | | | Branch (694:16): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NAME_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 703| 0|#define IS_NAME_CHAR(enc, p, n) 0 | | | | ------------------ | | | | | Branch (73:41): [True: 0, Folded] | | | | ------------------ | | | | 74| 0| *nextTokPtr = ptr; \ | | | | 75| 0| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 0|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 76| 0| } \ | | | | 77| 0| ptr += n; \ | | | | 78| 0| break; | | ------------------ | | 95| 0| CHECK_NAME_CASE(3, enc, ptr, end, nextTokPtr) \ | | ------------------ | | | | 70| 0| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (70:3): [True: 0, False: 5.68k] | | | | ------------------ | | | | 71| 0| if (end - ptr < n) \ | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 0] | | | | ------------------ | | | | 72| 0| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 0|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 73| 0| if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NAME_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 707| 0|#define IS_INVALID_CHAR(enc, p, n) LITTLE2_IS_INVALID_CHAR(p, n) | | | | | | ------------------ | | | | | | | | 694| 0| ((n) == 4 && ((unsigned char)(p)[3] & 0xFC) != 0xDC) | | | | | | | | ------------------ | | | | | | | | | Branch (694:4): [Folded, False: 0] | | | | | | | | | Branch (694:16): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NAME_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 703| 0|#define IS_NAME_CHAR(enc, p, n) 0 | | | | ------------------ | | | | | Branch (73:41): [True: 0, Folded] | | | | ------------------ | | | | 74| 0| *nextTokPtr = ptr; \ | | | | 75| 0| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 0|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 76| 0| } \ | | | | 77| 0| ptr += n; \ | | | | 78| 0| break; | | ------------------ | | 96| 6| CHECK_NAME_CASE(4, enc, ptr, end, nextTokPtr) | | ------------------ | | | | 70| 6| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (70:3): [True: 6, False: 5.68k] | | | | ------------------ | | | | 71| 6| if (end - ptr < n) \ | | | | ------------------ | | | | | Branch (71:9): [True: 1, False: 5] | | | | ------------------ | | | | 72| 1| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 1|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 73| 5| if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NAME_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 707| 5|#define IS_INVALID_CHAR(enc, p, n) LITTLE2_IS_INVALID_CHAR(p, n) | | | | | | ------------------ | | | | | | | | 694| 10| ((n) == 4 && ((unsigned char)(p)[3] & 0xFC) != 0xDC) | | | | | | | | ------------------ | | | | | | | | | Branch (694:4): [True: 5, Folded] | | | | | | | | | Branch (694:16): [True: 5, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NAME_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 703| 0|#define IS_NAME_CHAR(enc, p, n) 0 | | | | ------------------ | | | | | Branch (73:41): [True: 0, Folded] | | | | ------------------ | | | | 74| 5| *nextTokPtr = ptr; \ | | | | 75| 5| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 5|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 76| 5| } \ | | | | 77| 5| ptr += n; \ | | | | 78| 0| break; | | ------------------ ------------------ 580| 0|# ifdef XML_NS 581| 203| case BT_COLON: ------------------ | Branch (581:5): [True: 203, False: 5.48k] ------------------ 582| 203| if (hadColon) { ------------------ | Branch (582:11): [True: 1, False: 202] ------------------ 583| 1| *nextTokPtr = ptr; 584| 1| return XML_TOK_INVALID; ------------------ | | 57| 1|# define XML_TOK_INVALID 0 ------------------ 585| 1| } 586| 202| hadColon = 1; 587| 202| ptr += MINBPC(enc); ------------------ | | 698| 202|#define MINBPC(enc) 2 ------------------ 588| 202| REQUIRE_CHAR(enc, ptr, end); ------------------ | | 140| 202|# define REQUIRE_CHAR(enc, ptr, end) REQUIRE_CHARS(enc, ptr, end, 1) | | ------------------ | | | | 134| 202| { \ | | | | 135| 202| if (! HAS_CHARS(enc, ptr, end, count)) { \ | | | | ------------------ | | | | | | 129| 202| ((end) - (ptr) >= ((count) * MINBPC(enc))) | | | | | | ------------------ | | | | | | | | 698| 202|#define MINBPC(enc) 2 | | | | | | ------------------ | | | | ------------------ | | | | | Branch (135:11): [True: 1, False: 201] | | | | ------------------ | | | | 136| 1| return XML_TOK_PARTIAL; \ | | | | ------------------ | | | | | | 56| 1|# define XML_TOK_PARTIAL -1 /* only part of a token */ | | | | ------------------ | | | | 137| 1| } \ | | | | 138| 202| } | | ------------------ ------------------ 589| 201| switch (BYTE_TYPE(enc, ptr)) { ------------------ | | 700| 201|#define BYTE_TYPE(enc, p) LITTLE2_BYTE_TYPE(enc, p) | | ------------------ | | | | 683| 201| ((p)[1] == 0 ? SB_BYTE_TYPE(enc, p) : unicode_byte_type((p)[1], (p)[0])) | | | | ------------------ | | | | | | 231| 103| (((const struct normal_encoding *)(enc))->type[(unsigned char)*(p)]) | | | | ------------------ | | | | | Branch (683:4): [True: 103, False: 98] | | | | ------------------ | | ------------------ ------------------ 590| 286| CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr) ------------------ | | 110| 178| case BT_NONASCII: \ | | ------------------ | | | Branch (110:3): [True: 84, False: 117] | | ------------------ | | 111| 178| if (! IS_NMSTRT_CHAR_MINBPC(enc, ptr)) { \ | | ------------------ | | | | 706| 84|#define IS_NMSTRT_CHAR_MINBPC(enc, p) LITTLE2_IS_NMSTRT_CHAR_MINBPC(p) | | | | ------------------ | | | | | | 689| 84| UCS2_GET_NAMING(nmstrtPages, (unsigned char)p[1], (unsigned char)p[0]) | | | | | | ------------------ | | | | | | | | 87| 84| (namingBitmap[(pages[hi] << 3) + ((lo) >> 5)] & (1u << ((lo) & 0x1F))) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (111:9): [True: 9, False: 75] | | ------------------ | | 112| 9| *nextTokPtr = ptr; \ | | 113| 9| return XML_TOK_INVALID; \ | | ------------------ | | | | 57| 9|# define XML_TOK_INVALID 0 | | ------------------ | | 114| 9| } \ | | 115| 178| EXPAT_FALLTHROUGH; \ | | ------------------ | | | | 47| 75|# define EXPAT_FALLTHROUGH __attribute__((fallthrough)) | | ------------------ | | 116| 110| case BT_NMSTRT: \ | | ------------------ | | | Branch (116:3): [True: 35, False: 166] | | ------------------ | | 117| 178| case BT_HEX: \ | | ------------------ | | | Branch (117:3): [True: 68, False: 133] | | ------------------ | | 118| 178| ptr += MINBPC(enc); \ | | ------------------ | | | | 698| 178|#define MINBPC(enc) 2 | | ------------------ | | 119| 178| break; \ | | 120| 178| CHECK_NMSTRT_CASE(2, enc, ptr, end, nextTokPtr) \ | | ------------------ | | | | 99| 0| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (99:3): [True: 0, False: 201] | | | | ------------------ | | | | 100| 0| if ((end) - (ptr) < (n)) \ | | | | ------------------ | | | | | Branch (100:9): [True: 0, False: 0] | | | | ------------------ | | | | 101| 0| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 0|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 102| 0| if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NMSTRT_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 707| 0|#define IS_INVALID_CHAR(enc, p, n) LITTLE2_IS_INVALID_CHAR(p, n) | | | | | | ------------------ | | | | | | | | 694| 0| ((n) == 4 && ((unsigned char)(p)[3] & 0xFC) != 0xDC) | | | | | | | | ------------------ | | | | | | | | | Branch (694:4): [Folded, False: 0] | | | | | | | | | Branch (694:16): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NMSTRT_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 705| 0|#define IS_NMSTRT_CHAR(enc, p, n) (0) | | | | ------------------ | | | | | Branch (102:41): [True: 0, Folded] | | | | ------------------ | | | | 103| 0| *nextTokPtr = ptr; \ | | | | 104| 0| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 0|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 105| 0| } \ | | | | 106| 0| ptr += n; \ | | | | 107| 0| break; | | ------------------ | | 121| 0| CHECK_NMSTRT_CASE(3, enc, ptr, end, nextTokPtr) \ | | ------------------ | | | | 99| 0| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (99:3): [True: 0, False: 201] | | | | ------------------ | | | | 100| 0| if ((end) - (ptr) < (n)) \ | | | | ------------------ | | | | | Branch (100:9): [True: 0, False: 0] | | | | ------------------ | | | | 101| 0| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 0|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 102| 0| if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NMSTRT_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 707| 0|#define IS_INVALID_CHAR(enc, p, n) LITTLE2_IS_INVALID_CHAR(p, n) | | | | | | ------------------ | | | | | | | | 694| 0| ((n) == 4 && ((unsigned char)(p)[3] & 0xFC) != 0xDC) | | | | | | | | ------------------ | | | | | | | | | Branch (694:4): [Folded, False: 0] | | | | | | | | | Branch (694:16): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NMSTRT_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 705| 0|#define IS_NMSTRT_CHAR(enc, p, n) (0) | | | | ------------------ | | | | | Branch (102:41): [True: 0, Folded] | | | | ------------------ | | | | 103| 0| *nextTokPtr = ptr; \ | | | | 104| 0| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 0|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 105| 0| } \ | | | | 106| 0| ptr += n; \ | | | | 107| 0| break; | | ------------------ | | 122| 9| CHECK_NMSTRT_CASE(4, enc, ptr, end, nextTokPtr) | | ------------------ | | | | 99| 9| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (99:3): [True: 9, False: 192] | | | | ------------------ | | | | 100| 9| if ((end) - (ptr) < (n)) \ | | | | ------------------ | | | | | Branch (100:9): [True: 1, False: 8] | | | | ------------------ | | | | 101| 1| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 1|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 102| 8| if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NMSTRT_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 707| 8|#define IS_INVALID_CHAR(enc, p, n) LITTLE2_IS_INVALID_CHAR(p, n) | | | | | | ------------------ | | | | | | | | 694| 16| ((n) == 4 && ((unsigned char)(p)[3] & 0xFC) != 0xDC) | | | | | | | | ------------------ | | | | | | | | | Branch (694:4): [True: 8, Folded] | | | | | | | | | Branch (694:16): [True: 8, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NMSTRT_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 705| 0|#define IS_NMSTRT_CHAR(enc, p, n) (0) | | | | ------------------ | | | | | Branch (102:41): [True: 0, Folded] | | | | ------------------ | | | | 103| 8| *nextTokPtr = ptr; \ | | | | 104| 8| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 8|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 105| 8| } \ | | | | 106| 8| ptr += n; \ | | | | 107| 0| break; | | ------------------ ------------------ 591| 5| default: ------------------ | Branch (591:7): [True: 5, False: 196] ------------------ 592| 5| *nextTokPtr = ptr; 593| 5| return XML_TOK_INVALID; ------------------ | | 57| 5|# define XML_TOK_INVALID 0 ------------------ 594| 201| } 595| 178| break; 596| 178|# endif 597| 178| case BT_S: ------------------ | Branch (597:5): [True: 106, False: 5.58k] ------------------ 598| 186| case BT_CR: ------------------ | Branch (598:5): [True: 80, False: 5.60k] ------------------ 599| 264| case BT_LF: ------------------ | Branch (599:5): [True: 78, False: 5.60k] ------------------ 600| 891| for (;;) { 601| 891| int t; 602| | 603| 891| ptr += MINBPC(enc); ------------------ | | 698| 891|#define MINBPC(enc) 2 ------------------ 604| 891| REQUIRE_CHAR(enc, ptr, end); ------------------ | | 140| 891|# define REQUIRE_CHAR(enc, ptr, end) REQUIRE_CHARS(enc, ptr, end, 1) | | ------------------ | | | | 134| 891| { \ | | | | 135| 891| if (! HAS_CHARS(enc, ptr, end, count)) { \ | | | | ------------------ | | | | | | 129| 891| ((end) - (ptr) >= ((count) * MINBPC(enc))) | | | | | | ------------------ | | | | | | | | 698| 891|#define MINBPC(enc) 2 | | | | | | ------------------ | | | | ------------------ | | | | | Branch (135:11): [True: 2, False: 889] | | | | ------------------ | | | | 136| 2| return XML_TOK_PARTIAL; \ | | | | ------------------ | | | | | | 56| 2|# define XML_TOK_PARTIAL -1 /* only part of a token */ | | | | ------------------ | | | | 137| 2| } \ | | | | 138| 891| } | | ------------------ ------------------ 605| 889| t = BYTE_TYPE(enc, ptr); ------------------ | | 700| 889|#define BYTE_TYPE(enc, p) LITTLE2_BYTE_TYPE(enc, p) | | ------------------ | | | | 683| 889| ((p)[1] == 0 ? SB_BYTE_TYPE(enc, p) : unicode_byte_type((p)[1], (p)[0])) | | | | ------------------ | | | | | | 231| 841| (((const struct normal_encoding *)(enc))->type[(unsigned char)*(p)]) | | | | ------------------ | | | | | Branch (683:4): [True: 841, False: 48] | | | | ------------------ | | ------------------ ------------------ 606| 889| if (t == BT_EQUALS) ------------------ | Branch (606:13): [True: 211, False: 678] ------------------ 607| 211| break; 608| 678| switch (t) { 609| 227| case BT_S: ------------------ | Branch (609:9): [True: 227, False: 451] ------------------ 610| 431| case BT_LF: ------------------ | Branch (610:9): [True: 204, False: 474] ------------------ 611| 627| case BT_CR: ------------------ | Branch (611:9): [True: 196, False: 482] ------------------ 612| 627| break; 613| 51| default: ------------------ | Branch (613:9): [True: 51, False: 627] ------------------ 614| 51| *nextTokPtr = ptr; 615| 51| return XML_TOK_INVALID; ------------------ | | 57| 51|# define XML_TOK_INVALID 0 ------------------ 616| 678| } 617| 678| } 618| 211| EXPAT_FALLTHROUGH; ------------------ | | 47| 211|# define EXPAT_FALLTHROUGH __attribute__((fallthrough)) ------------------ 619| 3.28k| case BT_EQUALS: { ------------------ | Branch (619:5): [True: 3.07k, False: 2.60k] ------------------ 620| 3.28k| int open; 621| 3.28k|# ifdef XML_NS 622| 3.28k| hadColon = 0; 623| 3.28k|# endif 624| 3.92k| for (;;) { 625| 3.92k| ptr += MINBPC(enc); ------------------ | | 698| 3.92k|#define MINBPC(enc) 2 ------------------ 626| 3.92k| REQUIRE_CHAR(enc, ptr, end); ------------------ | | 140| 3.92k|# define REQUIRE_CHAR(enc, ptr, end) REQUIRE_CHARS(enc, ptr, end, 1) | | ------------------ | | | | 134| 3.92k| { \ | | | | 135| 3.92k| if (! HAS_CHARS(enc, ptr, end, count)) { \ | | | | ------------------ | | | | | | 129| 3.92k| ((end) - (ptr) >= ((count) * MINBPC(enc))) | | | | | | ------------------ | | | | | | | | 698| 3.92k|#define MINBPC(enc) 2 | | | | | | ------------------ | | | | ------------------ | | | | | Branch (135:11): [True: 2, False: 3.92k] | | | | ------------------ | | | | 136| 2| return XML_TOK_PARTIAL; \ | | | | ------------------ | | | | | | 56| 2|# define XML_TOK_PARTIAL -1 /* only part of a token */ | | | | ------------------ | | | | 137| 2| } \ | | | | 138| 3.92k| } | | ------------------ ------------------ 627| 3.92k| open = BYTE_TYPE(enc, ptr); ------------------ | | 700| 3.92k|#define BYTE_TYPE(enc, p) LITTLE2_BYTE_TYPE(enc, p) | | ------------------ | | | | 683| 3.92k| ((p)[1] == 0 ? SB_BYTE_TYPE(enc, p) : unicode_byte_type((p)[1], (p)[0])) | | | | ------------------ | | | | | | 231| 3.89k| (((const struct normal_encoding *)(enc))->type[(unsigned char)*(p)]) | | | | ------------------ | | | | | Branch (683:4): [True: 3.89k, False: 34] | | | | ------------------ | | ------------------ ------------------ 628| 3.92k| if (open == BT_QUOT || open == BT_APOS) ------------------ | Branch (628:13): [True: 1.32k, False: 2.60k] | Branch (628:32): [True: 1.92k, False: 674] ------------------ 629| 3.25k| break; 630| 674| switch (open) { 631| 230| case BT_S: ------------------ | Branch (631:9): [True: 230, False: 444] ------------------ 632| 436| case BT_LF: ------------------ | Branch (632:9): [True: 206, False: 468] ------------------ 633| 638| case BT_CR: ------------------ | Branch (633:9): [True: 202, False: 472] ------------------ 634| 638| break; 635| 36| default: ------------------ | Branch (635:9): [True: 36, False: 638] ------------------ 636| 36| *nextTokPtr = ptr; 637| 36| return XML_TOK_INVALID; ------------------ | | 57| 36|# define XML_TOK_INVALID 0 ------------------ 638| 674| } 639| 674| } 640| 3.25k| ptr += MINBPC(enc); ------------------ | | 698| 3.25k|#define MINBPC(enc) 2 ------------------ 641| | /* in attribute value */ 642| 22.2k| for (;;) { 643| 22.2k| int t; 644| 22.2k| REQUIRE_CHAR(enc, ptr, end); ------------------ | | 140| 22.2k|# define REQUIRE_CHAR(enc, ptr, end) REQUIRE_CHARS(enc, ptr, end, 1) | | ------------------ | | | | 134| 22.2k| { \ | | | | 135| 22.2k| if (! HAS_CHARS(enc, ptr, end, count)) { \ | | | | ------------------ | | | | | | 129| 22.2k| ((end) - (ptr) >= ((count) * MINBPC(enc))) | | | | | | ------------------ | | | | | | | | 698| 22.2k|#define MINBPC(enc) 2 | | | | | | ------------------ | | | | ------------------ | | | | | Branch (135:11): [True: 45, False: 22.1k] | | | | ------------------ | | | | 136| 45| return XML_TOK_PARTIAL; \ | | | | ------------------ | | | | | | 56| 45|# define XML_TOK_PARTIAL -1 /* only part of a token */ | | | | ------------------ | | | | 137| 45| } \ | | | | 138| 22.2k| } | | ------------------ ------------------ 645| 22.1k| t = BYTE_TYPE(enc, ptr); ------------------ | | 700| 22.1k|#define BYTE_TYPE(enc, p) LITTLE2_BYTE_TYPE(enc, p) | | ------------------ | | | | 683| 22.1k| ((p)[1] == 0 ? SB_BYTE_TYPE(enc, p) : unicode_byte_type((p)[1], (p)[0])) | | | | ------------------ | | | | | | 231| 9.61k| (((const struct normal_encoding *)(enc))->type[(unsigned char)*(p)]) | | | | ------------------ | | | | | Branch (683:4): [True: 9.61k, False: 12.5k] | | | | ------------------ | | ------------------ ------------------ 646| 22.1k| if (t == open) ------------------ | Branch (646:13): [True: 3.16k, False: 19.0k] ------------------ 647| 3.16k| break; 648| 19.0k| switch (t) { 649| 2.96k| INVALID_CASES(ptr, nextTokPtr) ------------------ | | 60| 0| INVALID_LEAD_CASE(2, ptr, nextTokPtr) \ | | ------------------ | | | | 49| 0| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (49:3): [True: 0, False: 19.0k] | | | | ------------------ | | | | 50| 0| if (end - ptr < n) \ | | | | ------------------ | | | | | Branch (50:9): [True: 0, False: 0] | | | | ------------------ | | | | 51| 0| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 0|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 52| 0| if (IS_INVALID_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 707| 0|#define IS_INVALID_CHAR(enc, p, n) LITTLE2_IS_INVALID_CHAR(p, n) | | | | | | ------------------ | | | | | | | | 694| 0| ((n) == 4 && ((unsigned char)(p)[3] & 0xFC) != 0xDC) | | | | | | | | ------------------ | | | | | | | | | Branch (694:4): [Folded, False: 0] | | | | | | | | | Branch (694:16): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 53| 0| *(nextTokPtr) = (ptr); \ | | | | 54| 0| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 0|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 55| 0| } \ | | | | 56| 0| ptr += n; \ | | | | 57| 0| break; | | ------------------ | | 61| 0| INVALID_LEAD_CASE(3, ptr, nextTokPtr) \ | | ------------------ | | | | 49| 0| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (49:3): [True: 0, False: 19.0k] | | | | ------------------ | | | | 50| 0| if (end - ptr < n) \ | | | | ------------------ | | | | | Branch (50:9): [True: 0, False: 0] | | | | ------------------ | | | | 51| 0| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 0|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 52| 0| if (IS_INVALID_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 707| 0|#define IS_INVALID_CHAR(enc, p, n) LITTLE2_IS_INVALID_CHAR(p, n) | | | | | | ------------------ | | | | | | | | 694| 0| ((n) == 4 && ((unsigned char)(p)[3] & 0xFC) != 0xDC) | | | | | | | | ------------------ | | | | | | | | | Branch (694:4): [Folded, False: 0] | | | | | | | | | Branch (694:16): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 53| 0| *(nextTokPtr) = (ptr); \ | | | | 54| 0| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 0|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 55| 0| } \ | | | | 56| 0| ptr += n; \ | | | | 57| 0| break; | | ------------------ | | 62| 1.48k| INVALID_LEAD_CASE(4, ptr, nextTokPtr) \ | | ------------------ | | | | 49| 1.48k| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (49:3): [True: 1.48k, False: 17.5k] | | | | ------------------ | | | | 50| 1.48k| if (end - ptr < n) \ | | | | ------------------ | | | | | Branch (50:9): [True: 1, False: 1.47k] | | | | ------------------ | | | | 51| 1.45k| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 1|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 52| 1.47k| if (IS_INVALID_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 707| 1.47k|#define IS_INVALID_CHAR(enc, p, n) LITTLE2_IS_INVALID_CHAR(p, n) | | | | | | ------------------ | | | | | | | | 694| 1.47k| ((n) == 4 && ((unsigned char)(p)[3] & 0xFC) != 0xDC) | | | | | | | | ------------------ | | | | | | | | | Branch (694:4): [True: 1.47k, Folded] | | | | | | | | | Branch (694:16): [True: 28, False: 1.45k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 53| 28| *(nextTokPtr) = (ptr); \ | | | | 54| 28| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 28|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 55| 28| } \ | | | | 56| 1.47k| ptr += n; \ | | | | 57| 1.45k| break; | | ------------------ | | 63| 1.45k| case BT_NONXML: \ | | ------------------ | | | Branch (63:3): [True: 1, False: 19.0k] | | ------------------ | | 64| 1| case BT_MALFORM: \ | | ------------------ | | | Branch (64:3): [True: 0, False: 19.0k] | | ------------------ | | 65| 5| case BT_TRAIL: \ | | ------------------ | | | Branch (65:3): [True: 4, False: 19.0k] | | ------------------ | | 66| 5| *(nextTokPtr) = (ptr); \ | | 67| 5| return XML_TOK_INVALID; | | ------------------ | | | | 57| 5|# define XML_TOK_INVALID 0 | | ------------------ ------------------ 650| 568| case BT_AMP: { ------------------ | Branch (650:9): [True: 568, False: 18.4k] ------------------ 651| 568| int tok = PREFIX(scanRef)(enc, ptr + MINBPC(enc), end, &ptr); ------------------ | | 697| 568|#define PREFIX(ident) little2_##ident ------------------ int tok = PREFIX(scanRef)(enc, ptr + MINBPC(enc), end, &ptr); ------------------ | | 698| 568|#define MINBPC(enc) 2 ------------------ 652| 568| if (tok <= 0) { ------------------ | Branch (652:15): [True: 9, False: 559] ------------------ 653| 9| if (tok == XML_TOK_INVALID) ------------------ | | 57| 9|# define XML_TOK_INVALID 0 ------------------ | Branch (653:17): [True: 7, False: 2] ------------------ 654| 7| *nextTokPtr = ptr; 655| 9| return tok; 656| 9| } 657| 559| break; 658| 568| } 659| 559| case BT_LT: ------------------ | Branch (659:9): [True: 1, False: 19.0k] ------------------ 660| 1| *nextTokPtr = ptr; 661| 1| return XML_TOK_INVALID; ------------------ | | 57| 1|# define XML_TOK_INVALID 0 ------------------ 662| 16.9k| default: ------------------ | Branch (662:9): [True: 16.9k, False: 2.05k] ------------------ 663| 16.9k| ptr += MINBPC(enc); ------------------ | | 698| 16.9k|#define MINBPC(enc) 2 ------------------ 664| 16.9k| break; 665| 19.0k| } 666| 19.0k| } 667| 3.16k| ptr += MINBPC(enc); ------------------ | | 698| 3.16k|#define MINBPC(enc) 2 ------------------ 668| 3.16k| REQUIRE_CHAR(enc, ptr, end); ------------------ | | 140| 3.16k|# define REQUIRE_CHAR(enc, ptr, end) REQUIRE_CHARS(enc, ptr, end, 1) | | ------------------ | | | | 134| 3.16k| { \ | | | | 135| 3.16k| if (! HAS_CHARS(enc, ptr, end, count)) { \ | | | | ------------------ | | | | | | 129| 3.16k| ((end) - (ptr) >= ((count) * MINBPC(enc))) | | | | | | ------------------ | | | | | | | | 698| 3.16k|#define MINBPC(enc) 2 | | | | | | ------------------ | | | | ------------------ | | | | | Branch (135:11): [True: 8, False: 3.15k] | | | | ------------------ | | | | 136| 8| return XML_TOK_PARTIAL; \ | | | | ------------------ | | | | | | 56| 8|# define XML_TOK_PARTIAL -1 /* only part of a token */ | | | | ------------------ | | | | 137| 8| } \ | | | | 138| 3.16k| } | | ------------------ ------------------ 669| 3.15k| switch (BYTE_TYPE(enc, ptr)) { ------------------ | | 700| 3.15k|#define BYTE_TYPE(enc, p) LITTLE2_BYTE_TYPE(enc, p) | | ------------------ | | | | 683| 3.15k| ((p)[1] == 0 ? SB_BYTE_TYPE(enc, p) : unicode_byte_type((p)[1], (p)[0])) | | | | ------------------ | | | | | | 231| 3.12k| (((const struct normal_encoding *)(enc))->type[(unsigned char)*(p)]) | | | | ------------------ | | | | | Branch (683:4): [True: 3.12k, False: 27] | | | | ------------------ | | ------------------ ------------------ 670| 2.12k| case BT_S: ------------------ | Branch (670:7): [True: 2.12k, False: 1.02k] ------------------ 671| 2.21k| case BT_CR: ------------------ | Branch (671:7): [True: 85, False: 3.06k] ------------------ 672| 2.31k| case BT_LF: ------------------ | Branch (672:7): [True: 101, False: 3.05k] ------------------ 673| 2.31k| break; 674| 90| case BT_SOL: ------------------ | Branch (674:7): [True: 90, False: 3.06k] ------------------ 675| 90| goto sol; 676| 725| case BT_GT: ------------------ | Branch (676:7): [True: 725, False: 2.42k] ------------------ 677| 725| goto gt; 678| 27| default: ------------------ | Branch (678:7): [True: 27, False: 3.12k] ------------------ 679| 27| *nextTokPtr = ptr; 680| 27| return XML_TOK_INVALID; ------------------ | | 57| 27|# define XML_TOK_INVALID 0 ------------------ 681| 3.15k| } 682| | /* ptr points to closing quote */ 683| 2.87k| for (;;) { 684| 2.87k| ptr += MINBPC(enc); ------------------ | | 698| 2.87k|#define MINBPC(enc) 2 ------------------ 685| 2.87k| REQUIRE_CHAR(enc, ptr, end); ------------------ | | 140| 2.87k|# define REQUIRE_CHAR(enc, ptr, end) REQUIRE_CHARS(enc, ptr, end, 1) | | ------------------ | | | | 134| 2.87k| { \ | | | | 135| 2.87k| if (! HAS_CHARS(enc, ptr, end, count)) { \ | | | | ------------------ | | | | | | 129| 2.87k| ((end) - (ptr) >= ((count) * MINBPC(enc))) | | | | | | ------------------ | | | | | | | | 698| 2.87k|#define MINBPC(enc) 2 | | | | | | ------------------ | | | | ------------------ | | | | | Branch (135:11): [True: 4, False: 2.87k] | | | | ------------------ | | | | 136| 4| return XML_TOK_PARTIAL; \ | | | | ------------------ | | | | | | 56| 4|# define XML_TOK_PARTIAL -1 /* only part of a token */ | | | | ------------------ | | | | 137| 4| } \ | | | | 138| 2.87k| } | | ------------------ ------------------ 686| 2.87k| switch (BYTE_TYPE(enc, ptr)) { ------------------ | | 700| 2.87k|#define BYTE_TYPE(enc, p) LITTLE2_BYTE_TYPE(enc, p) | | ------------------ | | | | 683| 2.87k| ((p)[1] == 0 ? SB_BYTE_TYPE(enc, p) : unicode_byte_type((p)[1], (p)[0])) | | | | ------------------ | | | | | | 231| 879| (((const struct normal_encoding *)(enc))->type[(unsigned char)*(p)]) | | | | ------------------ | | | | | Branch (683:4): [True: 879, False: 1.99k] | | | | ------------------ | | ------------------ ------------------ 687| 5.96k| CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr) ------------------ | | 110| 2.08k| case BT_NONASCII: \ | | ------------------ | | | Branch (110:3): [True: 1.97k, False: 899] | | ------------------ | | 111| 2.08k| if (! IS_NMSTRT_CHAR_MINBPC(enc, ptr)) { \ | | ------------------ | | | | 706| 1.97k|#define IS_NMSTRT_CHAR_MINBPC(enc, p) LITTLE2_IS_NMSTRT_CHAR_MINBPC(p) | | | | ------------------ | | | | | | 689| 1.97k| UCS2_GET_NAMING(nmstrtPages, (unsigned char)p[1], (unsigned char)p[0]) | | | | | | ------------------ | | | | | | | | 87| 1.97k| (namingBitmap[(pages[hi] << 3) + ((lo) >> 5)] & (1u << ((lo) & 0x1F))) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (111:9): [True: 23, False: 1.94k] | | ------------------ | | 112| 23| *nextTokPtr = ptr; \ | | 113| 23| return XML_TOK_INVALID; \ | | ------------------ | | | | 57| 23|# define XML_TOK_INVALID 0 | | ------------------ | | 114| 23| } \ | | 115| 2.08k| EXPAT_FALLTHROUGH; \ | | ------------------ | | | | 47| 1.94k|# define EXPAT_FALLTHROUGH __attribute__((fallthrough)) | | ------------------ | | 116| 2.01k| case BT_NMSTRT: \ | | ------------------ | | | Branch (116:3): [True: 71, False: 2.79k] | | ------------------ | | 117| 2.08k| case BT_HEX: \ | | ------------------ | | | Branch (117:3): [True: 67, False: 2.80k] | | ------------------ | | 118| 2.08k| ptr += MINBPC(enc); \ | | ------------------ | | | | 698| 2.08k|#define MINBPC(enc) 2 | | ------------------ | | 119| 2.08k| break; \ | | 120| 2.08k| CHECK_NMSTRT_CASE(2, enc, ptr, end, nextTokPtr) \ | | ------------------ | | | | 99| 0| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (99:3): [True: 0, False: 2.87k] | | | | ------------------ | | | | 100| 0| if ((end) - (ptr) < (n)) \ | | | | ------------------ | | | | | Branch (100:9): [True: 0, False: 0] | | | | ------------------ | | | | 101| 0| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 0|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 102| 0| if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NMSTRT_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 707| 0|#define IS_INVALID_CHAR(enc, p, n) LITTLE2_IS_INVALID_CHAR(p, n) | | | | | | ------------------ | | | | | | | | 694| 0| ((n) == 4 && ((unsigned char)(p)[3] & 0xFC) != 0xDC) | | | | | | | | ------------------ | | | | | | | | | Branch (694:4): [Folded, False: 0] | | | | | | | | | Branch (694:16): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NMSTRT_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 705| 0|#define IS_NMSTRT_CHAR(enc, p, n) (0) | | | | ------------------ | | | | | Branch (102:41): [True: 0, Folded] | | | | ------------------ | | | | 103| 0| *nextTokPtr = ptr; \ | | | | 104| 0| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 0|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 105| 0| } \ | | | | 106| 0| ptr += n; \ | | | | 107| 0| break; | | ------------------ | | 121| 0| CHECK_NMSTRT_CASE(3, enc, ptr, end, nextTokPtr) \ | | ------------------ | | | | 99| 0| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (99:3): [True: 0, False: 2.87k] | | | | ------------------ | | | | 100| 0| if ((end) - (ptr) < (n)) \ | | | | ------------------ | | | | | Branch (100:9): [True: 0, False: 0] | | | | ------------------ | | | | 101| 0| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 0|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 102| 0| if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NMSTRT_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 707| 0|#define IS_INVALID_CHAR(enc, p, n) LITTLE2_IS_INVALID_CHAR(p, n) | | | | | | ------------------ | | | | | | | | 694| 0| ((n) == 4 && ((unsigned char)(p)[3] & 0xFC) != 0xDC) | | | | | | | | ------------------ | | | | | | | | | Branch (694:4): [Folded, False: 0] | | | | | | | | | Branch (694:16): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NMSTRT_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 705| 0|#define IS_NMSTRT_CHAR(enc, p, n) (0) | | | | ------------------ | | | | | Branch (102:41): [True: 0, Folded] | | | | ------------------ | | | | 103| 0| *nextTokPtr = ptr; \ | | | | 104| 0| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 0|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 105| 0| } \ | | | | 106| 0| ptr += n; \ | | | | 107| 0| break; | | ------------------ | | 122| 12| CHECK_NMSTRT_CASE(4, enc, ptr, end, nextTokPtr) | | ------------------ | | | | 99| 12| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (99:3): [True: 12, False: 2.85k] | | | | ------------------ | | | | 100| 12| if ((end) - (ptr) < (n)) \ | | | | ------------------ | | | | | Branch (100:9): [True: 1, False: 11] | | | | ------------------ | | | | 101| 1| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 1|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 102| 11| if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NMSTRT_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 707| 11|#define IS_INVALID_CHAR(enc, p, n) LITTLE2_IS_INVALID_CHAR(p, n) | | | | | | ------------------ | | | | | | | | 694| 22| ((n) == 4 && ((unsigned char)(p)[3] & 0xFC) != 0xDC) | | | | | | | | ------------------ | | | | | | | | | Branch (694:4): [True: 11, Folded] | | | | | | | | | Branch (694:16): [True: 11, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NMSTRT_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 705| 0|#define IS_NMSTRT_CHAR(enc, p, n) (0) | | | | ------------------ | | | | | Branch (102:41): [True: 0, Folded] | | | | ------------------ | | | | 103| 11| *nextTokPtr = ptr; \ | | | | 104| 11| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 11|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 105| 11| } \ | | | | 106| 11| ptr += n; \ | | | | 107| 0| break; | | ------------------ ------------------ 688| 269| case BT_S: ------------------ | Branch (688:9): [True: 269, False: 2.60k] ------------------ 689| 483| case BT_CR: ------------------ | Branch (689:9): [True: 214, False: 2.65k] ------------------ 690| 562| case BT_LF: ------------------ | Branch (690:9): [True: 79, False: 2.79k] ------------------ 691| 562| continue; 692| 112| case BT_GT: ------------------ | Branch (692:9): [True: 112, False: 2.75k] ------------------ 693| 837| gt: 694| 837| *nextTokPtr = ptr + MINBPC(enc); ------------------ | | 698| 837|#define MINBPC(enc) 2 ------------------ 695| 837| return XML_TOK_START_TAG_WITH_ATTS; ------------------ | | 62| 837|# define XML_TOK_START_TAG_WITH_ATTS 1 ------------------ 696| 67| case BT_SOL: ------------------ | Branch (696:9): [True: 67, False: 2.80k] ------------------ 697| 157| sol: 698| 157| ptr += MINBPC(enc); ------------------ | | 698| 157|#define MINBPC(enc) 2 ------------------ 699| 157| REQUIRE_CHAR(enc, ptr, end); ------------------ | | 140| 157|# define REQUIRE_CHAR(enc, ptr, end) REQUIRE_CHARS(enc, ptr, end, 1) | | ------------------ | | | | 134| 157| { \ | | | | 135| 157| if (! HAS_CHARS(enc, ptr, end, count)) { \ | | | | ------------------ | | | | | | 129| 157| ((end) - (ptr) >= ((count) * MINBPC(enc))) | | | | | | ------------------ | | | | | | | | 698| 157|#define MINBPC(enc) 2 | | | | | | ------------------ | | | | ------------------ | | | | | Branch (135:11): [True: 1, False: 156] | | | | ------------------ | | | | 136| 1| return XML_TOK_PARTIAL; \ | | | | ------------------ | | | | | | 56| 1|# define XML_TOK_PARTIAL -1 /* only part of a token */ | | | | ------------------ | | | | 137| 1| } \ | | | | 138| 157| } | | ------------------ ------------------ 700| 156| if (! CHAR_MATCHES(enc, ptr, ASCII_GT)) { ------------------ | | 702| 156|#define CHAR_MATCHES(enc, p, c) LITTLE2_CHAR_MATCHES(p, c) | | ------------------ | | | | 685| 156|#define LITTLE2_CHAR_MATCHES(p, c) ((p)[1] == 0 && (p)[0] == (c)) | | | | ------------------ | | | | | Branch (685:37): [True: 154, False: 2] | | | | | Branch (685:52): [True: 153, False: 1] | | | | ------------------ | | ------------------ ------------------ 701| 3| *nextTokPtr = ptr; 702| 3| return XML_TOK_INVALID; ------------------ | | 57| 3|# define XML_TOK_INVALID 0 ------------------ 703| 3| } 704| 153| *nextTokPtr = ptr + MINBPC(enc); ------------------ | | 698| 153|#define MINBPC(enc) 2 ------------------ 705| 153| return XML_TOK_EMPTY_ELEMENT_WITH_ATTS; ------------------ | | 64| 153|# define XML_TOK_EMPTY_ELEMENT_WITH_ATTS 3 /* empty element tag */ ------------------ 706| 8| default: ------------------ | Branch (706:9): [True: 8, False: 2.86k] ------------------ 707| 8| *nextTokPtr = ptr; 708| 8| return XML_TOK_INVALID; ------------------ | | 57| 8|# define XML_TOK_INVALID 0 ------------------ 709| 2.87k| } 710| 2.08k| break; 711| 2.87k| } 712| 2.08k| break; 713| 2.31k| } 714| 2.08k| default: ------------------ | Branch (714:5): [True: 11, False: 5.67k] ------------------ 715| 11| *nextTokPtr = ptr; 716| 11| return XML_TOK_INVALID; ------------------ | | 57| 11|# define XML_TOK_INVALID 0 ------------------ 717| 5.68k| } 718| 5.68k| } 719| 4| return XML_TOK_PARTIAL; ------------------ | | 56| 4|# define XML_TOK_PARTIAL -1 /* only part of a token */ ------------------ 720| 1.39k|} xmltok.c:little2_scanRef: 545| 2.55k| const char **nextTokPtr) { 546| 2.55k| REQUIRE_CHAR(enc, ptr, end); ------------------ | | 140| 2.55k|# define REQUIRE_CHAR(enc, ptr, end) REQUIRE_CHARS(enc, ptr, end, 1) | | ------------------ | | | | 134| 2.55k| { \ | | | | 135| 2.55k| if (! HAS_CHARS(enc, ptr, end, count)) { \ | | | | ------------------ | | | | | | 129| 2.55k| ((end) - (ptr) >= ((count) * MINBPC(enc))) | | | | | | ------------------ | | | | | | | | 698| 2.55k|#define MINBPC(enc) 2 | | | | | | ------------------ | | | | ------------------ | | | | | Branch (135:11): [True: 2, False: 2.55k] | | | | ------------------ | | | | 136| 2| return XML_TOK_PARTIAL; \ | | | | ------------------ | | | | | | 56| 2|# define XML_TOK_PARTIAL -1 /* only part of a token */ | | | | ------------------ | | | | 137| 2| } \ | | | | 138| 2.55k| } | | ------------------ ------------------ 547| 2.55k| switch (BYTE_TYPE(enc, ptr)) { ------------------ | | 700| 2.55k|#define BYTE_TYPE(enc, p) LITTLE2_BYTE_TYPE(enc, p) | | ------------------ | | | | 683| 2.55k| ((p)[1] == 0 ? SB_BYTE_TYPE(enc, p) : unicode_byte_type((p)[1], (p)[0])) | | | | ------------------ | | | | | | 231| 2.20k| (((const struct normal_encoding *)(enc))->type[(unsigned char)*(p)]) | | | | ------------------ | | | | | Branch (683:4): [True: 2.20k, False: 347] | | | | ------------------ | | ------------------ ------------------ 548| 1.45k| CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr) ------------------ | | 110| 1.10k| case BT_NONASCII: \ | | ------------------ | | | Branch (110:3): [True: 335, False: 2.22k] | | ------------------ | | 111| 1.10k| if (! IS_NMSTRT_CHAR_MINBPC(enc, ptr)) { \ | | ------------------ | | | | 706| 335|#define IS_NMSTRT_CHAR_MINBPC(enc, p) LITTLE2_IS_NMSTRT_CHAR_MINBPC(p) | | | | ------------------ | | | | | | 689| 335| UCS2_GET_NAMING(nmstrtPages, (unsigned char)p[1], (unsigned char)p[0]) | | | | | | ------------------ | | | | | | | | 87| 335| (namingBitmap[(pages[hi] << 3) + ((lo) >> 5)] & (1u << ((lo) & 0x1F))) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (111:9): [True: 18, False: 317] | | ------------------ | | 112| 18| *nextTokPtr = ptr; \ | | 113| 18| return XML_TOK_INVALID; \ | | ------------------ | | | | 57| 18|# define XML_TOK_INVALID 0 | | ------------------ | | 114| 18| } \ | | 115| 1.10k| EXPAT_FALLTHROUGH; \ | | ------------------ | | | | 47| 317|# define EXPAT_FALLTHROUGH __attribute__((fallthrough)) | | ------------------ | | 116| 789| case BT_NMSTRT: \ | | ------------------ | | | Branch (116:3): [True: 472, False: 2.08k] | | ------------------ | | 117| 1.10k| case BT_HEX: \ | | ------------------ | | | Branch (117:3): [True: 319, False: 2.23k] | | ------------------ | | 118| 1.10k| ptr += MINBPC(enc); \ | | ------------------ | | | | 698| 1.10k|#define MINBPC(enc) 2 | | ------------------ | | 119| 1.10k| break; \ | | 120| 1.10k| CHECK_NMSTRT_CASE(2, enc, ptr, end, nextTokPtr) \ | | ------------------ | | | | 99| 0| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (99:3): [True: 0, False: 2.55k] | | | | ------------------ | | | | 100| 0| if ((end) - (ptr) < (n)) \ | | | | ------------------ | | | | | Branch (100:9): [True: 0, False: 0] | | | | ------------------ | | | | 101| 0| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 0|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 102| 0| if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NMSTRT_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 707| 0|#define IS_INVALID_CHAR(enc, p, n) LITTLE2_IS_INVALID_CHAR(p, n) | | | | | | ------------------ | | | | | | | | 694| 0| ((n) == 4 && ((unsigned char)(p)[3] & 0xFC) != 0xDC) | | | | | | | | ------------------ | | | | | | | | | Branch (694:4): [Folded, False: 0] | | | | | | | | | Branch (694:16): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NMSTRT_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 705| 0|#define IS_NMSTRT_CHAR(enc, p, n) (0) | | | | ------------------ | | | | | Branch (102:41): [True: 0, Folded] | | | | ------------------ | | | | 103| 0| *nextTokPtr = ptr; \ | | | | 104| 0| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 0|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 105| 0| } \ | | | | 106| 0| ptr += n; \ | | | | 107| 0| break; | | ------------------ | | 121| 0| CHECK_NMSTRT_CASE(3, enc, ptr, end, nextTokPtr) \ | | ------------------ | | | | 99| 0| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (99:3): [True: 0, False: 2.55k] | | | | ------------------ | | | | 100| 0| if ((end) - (ptr) < (n)) \ | | | | ------------------ | | | | | Branch (100:9): [True: 0, False: 0] | | | | ------------------ | | | | 101| 0| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 0|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 102| 0| if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NMSTRT_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 707| 0|#define IS_INVALID_CHAR(enc, p, n) LITTLE2_IS_INVALID_CHAR(p, n) | | | | | | ------------------ | | | | | | | | 694| 0| ((n) == 4 && ((unsigned char)(p)[3] & 0xFC) != 0xDC) | | | | | | | | ------------------ | | | | | | | | | Branch (694:4): [Folded, False: 0] | | | | | | | | | Branch (694:16): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NMSTRT_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 705| 0|#define IS_NMSTRT_CHAR(enc, p, n) (0) | | | | ------------------ | | | | | Branch (102:41): [True: 0, Folded] | | | | ------------------ | | | | 103| 0| *nextTokPtr = ptr; \ | | | | 104| 0| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 0|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 105| 0| } \ | | | | 106| 0| ptr += n; \ | | | | 107| 0| break; | | ------------------ | | 122| 7| CHECK_NMSTRT_CASE(4, enc, ptr, end, nextTokPtr) | | ------------------ | | | | 99| 7| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (99:3): [True: 7, False: 2.54k] | | | | ------------------ | | | | 100| 7| if ((end) - (ptr) < (n)) \ | | | | ------------------ | | | | | Branch (100:9): [True: 2, False: 5] | | | | ------------------ | | | | 101| 2| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 2|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 102| 5| if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NMSTRT_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 707| 5|#define IS_INVALID_CHAR(enc, p, n) LITTLE2_IS_INVALID_CHAR(p, n) | | | | | | ------------------ | | | | | | | | 694| 10| ((n) == 4 && ((unsigned char)(p)[3] & 0xFC) != 0xDC) | | | | | | | | ------------------ | | | | | | | | | Branch (694:4): [True: 5, Folded] | | | | | | | | | Branch (694:16): [True: 5, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NMSTRT_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 705| 0|#define IS_NMSTRT_CHAR(enc, p, n) (0) | | | | ------------------ | | | | | Branch (102:41): [True: 0, Folded] | | | | ------------------ | | | | 103| 5| *nextTokPtr = ptr; \ | | | | 104| 5| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 5|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 105| 5| } \ | | | | 106| 5| ptr += n; \ | | | | 107| 0| break; | | ------------------ ------------------ 549| 1.41k| case BT_NUM: ------------------ | Branch (549:3): [True: 1.41k, False: 1.13k] ------------------ 550| 1.41k| return PREFIX(scanCharRef)(enc, ptr + MINBPC(enc), end, nextTokPtr); ------------------ | | 697| 1.41k|#define PREFIX(ident) little2_##ident ------------------ return PREFIX(scanCharRef)(enc, ptr + MINBPC(enc), end, nextTokPtr); ------------------ | | 698| 1.41k|#define MINBPC(enc) 2 ------------------ 551| 5| default: ------------------ | Branch (551:3): [True: 5, False: 2.55k] ------------------ 552| 5| *nextTokPtr = ptr; 553| 5| return XML_TOK_INVALID; ------------------ | | 57| 5|# define XML_TOK_INVALID 0 ------------------ 554| 2.55k| } 555| 3.75k| while (HAS_CHAR(enc, ptr, end)) { 556| 3.75k| switch (BYTE_TYPE(enc, ptr)) { ------------------ | | 700| 3.75k|#define BYTE_TYPE(enc, p) LITTLE2_BYTE_TYPE(enc, p) | | ------------------ | | | | 683| 3.75k| ((p)[1] == 0 ? SB_BYTE_TYPE(enc, p) : unicode_byte_type((p)[1], (p)[0])) | | | | ------------------ | | | | | | 231| 3.28k| (((const struct normal_encoding *)(enc))->type[(unsigned char)*(p)]) | | | | ------------------ | | | | | Branch (683:4): [True: 3.28k, False: 467] | | | | ------------------ | | ------------------ ------------------ 557| 9.47k| CHECK_NAME_CASES(enc, ptr, end, nextTokPtr) ------------------ | | 81| 2.64k| case BT_NONASCII: \ | | ------------------ | | | Branch (81:3): [True: 451, False: 3.30k] | | ------------------ | | 82| 2.64k| if (! IS_NAME_CHAR_MINBPC(enc, ptr)) { \ | | ------------------ | | | | 704| 451|#define IS_NAME_CHAR_MINBPC(enc, p) LITTLE2_IS_NAME_CHAR_MINBPC(p) | | | | ------------------ | | | | | | 687| 451| UCS2_GET_NAMING(namePages, (unsigned char)p[1], (unsigned char)p[0]) | | | | | | ------------------ | | | | | | | | 87| 451| (namingBitmap[(pages[hi] << 3) + ((lo) >> 5)] & (1u << ((lo) & 0x1F))) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (82:9): [True: 59, False: 392] | | ------------------ | | 83| 59| *nextTokPtr = ptr; \ | | 84| 59| return XML_TOK_INVALID; \ | | ------------------ | | | | 57| 59|# define XML_TOK_INVALID 0 | | ------------------ | | 85| 59| } \ | | 86| 2.64k| EXPAT_FALLTHROUGH; \ | | ------------------ | | | | 47| 392|# define EXPAT_FALLTHROUGH __attribute__((fallthrough)) | | ------------------ | | 87| 1.85k| case BT_NMSTRT: \ | | ------------------ | | | Branch (87:3): [True: 1.45k, False: 2.29k] | | ------------------ | | 88| 2.05k| case BT_HEX: \ | | ------------------ | | | Branch (88:3): [True: 200, False: 3.55k] | | ------------------ | | 89| 2.25k| case BT_DIGIT: \ | | ------------------ | | | Branch (89:3): [True: 202, False: 3.55k] | | ------------------ | | 90| 2.45k| case BT_NAME: \ | | ------------------ | | | Branch (90:3): [True: 198, False: 3.55k] | | ------------------ | | 91| 2.64k| case BT_MINUS: \ | | ------------------ | | | Branch (91:3): [True: 195, False: 3.55k] | | ------------------ | | 92| 2.64k| ptr += MINBPC(enc); \ | | ------------------ | | | | 698| 2.64k|#define MINBPC(enc) 2 | | ------------------ | | 93| 2.64k| break; \ | | 94| 2.64k| CHECK_NAME_CASE(2, enc, ptr, end, nextTokPtr) \ | | ------------------ | | | | 70| 0| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (70:3): [True: 0, False: 3.75k] | | | | ------------------ | | | | 71| 0| if (end - ptr < n) \ | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 0] | | | | ------------------ | | | | 72| 0| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 0|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 73| 0| if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NAME_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 707| 0|#define IS_INVALID_CHAR(enc, p, n) LITTLE2_IS_INVALID_CHAR(p, n) | | | | | | ------------------ | | | | | | | | 694| 0| ((n) == 4 && ((unsigned char)(p)[3] & 0xFC) != 0xDC) | | | | | | | | ------------------ | | | | | | | | | Branch (694:4): [Folded, False: 0] | | | | | | | | | Branch (694:16): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NAME_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 703| 0|#define IS_NAME_CHAR(enc, p, n) 0 | | | | ------------------ | | | | | Branch (73:41): [True: 0, Folded] | | | | ------------------ | | | | 74| 0| *nextTokPtr = ptr; \ | | | | 75| 0| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 0|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 76| 0| } \ | | | | 77| 0| ptr += n; \ | | | | 78| 0| break; | | ------------------ | | 95| 0| CHECK_NAME_CASE(3, enc, ptr, end, nextTokPtr) \ | | ------------------ | | | | 70| 0| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (70:3): [True: 0, False: 3.75k] | | | | ------------------ | | | | 71| 0| if (end - ptr < n) \ | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 0] | | | | ------------------ | | | | 72| 0| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 0|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 73| 0| if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NAME_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 707| 0|#define IS_INVALID_CHAR(enc, p, n) LITTLE2_IS_INVALID_CHAR(p, n) | | | | | | ------------------ | | | | | | | | 694| 0| ((n) == 4 && ((unsigned char)(p)[3] & 0xFC) != 0xDC) | | | | | | | | ------------------ | | | | | | | | | Branch (694:4): [Folded, False: 0] | | | | | | | | | Branch (694:16): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NAME_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 703| 0|#define IS_NAME_CHAR(enc, p, n) 0 | | | | ------------------ | | | | | Branch (73:41): [True: 0, Folded] | | | | ------------------ | | | | 74| 0| *nextTokPtr = ptr; \ | | | | 75| 0| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 0|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 76| 0| } \ | | | | 77| 0| ptr += n; \ | | | | 78| 0| break; | | ------------------ | | 96| 11| CHECK_NAME_CASE(4, enc, ptr, end, nextTokPtr) | | ------------------ | | | | 70| 11| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (70:3): [True: 11, False: 3.74k] | | | | ------------------ | | | | 71| 11| if (end - ptr < n) \ | | | | ------------------ | | | | | Branch (71:9): [True: 1, False: 10] | | | | ------------------ | | | | 72| 1| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 1|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 73| 10| if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NAME_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 707| 10|#define IS_INVALID_CHAR(enc, p, n) LITTLE2_IS_INVALID_CHAR(p, n) | | | | | | ------------------ | | | | | | | | 694| 20| ((n) == 4 && ((unsigned char)(p)[3] & 0xFC) != 0xDC) | | | | | | | | ------------------ | | | | | | | | | Branch (694:4): [True: 10, Folded] | | | | | | | | | Branch (694:16): [True: 10, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NAME_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 703| 0|#define IS_NAME_CHAR(enc, p, n) 0 | | | | ------------------ | | | | | Branch (73:41): [True: 0, Folded] | | | | ------------------ | | | | 74| 10| *nextTokPtr = ptr; \ | | | | 75| 10| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 10|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 76| 10| } \ | | | | 77| 10| ptr += n; \ | | | | 78| 0| break; | | ------------------ ------------------ 558| 1.03k| case BT_SEMI: ------------------ | Branch (558:5): [True: 1.03k, False: 2.72k] ------------------ 559| 1.03k| *nextTokPtr = ptr + MINBPC(enc); ------------------ | | 698| 1.03k|#define MINBPC(enc) 2 ------------------ 560| 1.03k| return XML_TOK_ENTITY_REF; ------------------ | | 70| 1.03k|# define XML_TOK_ENTITY_REF 9 ------------------ 561| 5| default: ------------------ | Branch (561:5): [True: 5, False: 3.74k] ------------------ 562| 5| *nextTokPtr = ptr; 563| 5| return XML_TOK_INVALID; ------------------ | | 57| 5|# define XML_TOK_INVALID 0 ------------------ 564| 3.75k| } 565| 3.75k| } 566| 2| return XML_TOK_PARTIAL; ------------------ | | 56| 2|# define XML_TOK_PARTIAL -1 /* only part of a token */ ------------------ 567| 1.10k|} xmltok.c:little2_scanCharRef: 514| 1.41k| const char **nextTokPtr) { 515| 1.41k| if (HAS_CHAR(enc, ptr, end)) { ------------------ | | 131| 1.41k|# define HAS_CHAR(enc, ptr, end) HAS_CHARS(enc, ptr, end, 1) | | ------------------ | | | | 129| 1.41k| ((end) - (ptr) >= ((count) * MINBPC(enc))) | | | | ------------------ | | | | | | 698| 1.41k|#define MINBPC(enc) 2 | | | | ------------------ | | | | | Branch (129:5): [True: 1.41k, False: 1] | | | | ------------------ | | ------------------ ------------------ 516| 1.41k| if (CHAR_MATCHES(enc, ptr, ASCII_x)) ------------------ | | 702| 1.41k|#define CHAR_MATCHES(enc, p, c) LITTLE2_CHAR_MATCHES(p, c) | | ------------------ | | | | 685| 1.41k|#define LITTLE2_CHAR_MATCHES(p, c) ((p)[1] == 0 && (p)[0] == (c)) | | | | ------------------ | | | | | Branch (685:37): [True: 1.40k, False: 10] | | | | | Branch (685:52): [True: 1.00k, False: 400] | | | | ------------------ | | ------------------ ------------------ 517| 1.00k| return PREFIX(scanHexCharRef)(enc, ptr + MINBPC(enc), end, nextTokPtr); ------------------ | | 697| 1.00k|#define PREFIX(ident) little2_##ident ------------------ return PREFIX(scanHexCharRef)(enc, ptr + MINBPC(enc), end, nextTokPtr); ------------------ | | 698| 1.00k|#define MINBPC(enc) 2 ------------------ 518| 410| switch (BYTE_TYPE(enc, ptr)) { ------------------ | | 700| 410|#define BYTE_TYPE(enc, p) LITTLE2_BYTE_TYPE(enc, p) | | ------------------ | | | | 683| 410| ((p)[1] == 0 ? SB_BYTE_TYPE(enc, p) : unicode_byte_type((p)[1], (p)[0])) | | | | ------------------ | | | | | | 231| 400| (((const struct normal_encoding *)(enc))->type[(unsigned char)*(p)]) | | | | ------------------ | | | | | Branch (683:4): [True: 400, False: 10] | | | | ------------------ | | ------------------ ------------------ 519| 398| case BT_DIGIT: ------------------ | Branch (519:5): [True: 398, False: 12] ------------------ 520| 398| break; 521| 12| default: ------------------ | Branch (521:5): [True: 12, False: 398] ------------------ 522| 12| *nextTokPtr = ptr; 523| 12| return XML_TOK_INVALID; ------------------ | | 57| 12|# define XML_TOK_INVALID 0 ------------------ 524| 410| } 525| 996| for (ptr += MINBPC(enc); HAS_CHAR(enc, ptr, end); ptr += MINBPC(enc)) { ------------------ | | 698| 398|#define MINBPC(enc) 2 ------------------ for (ptr += MINBPC(enc); HAS_CHAR(enc, ptr, end); ptr += MINBPC(enc)) { ------------------ | | 698| 599|#define MINBPC(enc) 2 ------------------ 526| 996| switch (BYTE_TYPE(enc, ptr)) { ------------------ | | 700| 996|#define BYTE_TYPE(enc, p) LITTLE2_BYTE_TYPE(enc, p) | | ------------------ | | | | 683| 996| ((p)[1] == 0 ? SB_BYTE_TYPE(enc, p) : unicode_byte_type((p)[1], (p)[0])) | | | | ------------------ | | | | | | 231| 981| (((const struct normal_encoding *)(enc))->type[(unsigned char)*(p)]) | | | | ------------------ | | | | | Branch (683:4): [True: 981, False: 15] | | | | ------------------ | | ------------------ ------------------ 527| 599| case BT_DIGIT: ------------------ | Branch (527:7): [True: 599, False: 397] ------------------ 528| 599| break; 529| 382| case BT_SEMI: ------------------ | Branch (529:7): [True: 382, False: 614] ------------------ 530| 382| *nextTokPtr = ptr + MINBPC(enc); ------------------ | | 698| 382|#define MINBPC(enc) 2 ------------------ 531| 382| return XML_TOK_CHAR_REF; ------------------ | | 71| 382|# define XML_TOK_CHAR_REF 10 /* numeric character reference */ ------------------ 532| 15| default: ------------------ | Branch (532:7): [True: 15, False: 981] ------------------ 533| 15| *nextTokPtr = ptr; 534| 15| return XML_TOK_INVALID; ------------------ | | 57| 15|# define XML_TOK_INVALID 0 ------------------ 535| 996| } 536| 996| } 537| 398| } 538| 2| return XML_TOK_PARTIAL; ------------------ | | 56| 2|# define XML_TOK_PARTIAL -1 /* only part of a token */ ------------------ 539| 1.41k|} xmltok.c:little2_scanHexCharRef: 483| 1.00k| const char **nextTokPtr) { 484| 1.00k| if (HAS_CHAR(enc, ptr, end)) { ------------------ | | 131| 1.00k|# define HAS_CHAR(enc, ptr, end) HAS_CHARS(enc, ptr, end, 1) | | ------------------ | | | | 129| 1.00k| ((end) - (ptr) >= ((count) * MINBPC(enc))) | | | | ------------------ | | | | | | 698| 1.00k|#define MINBPC(enc) 2 | | | | ------------------ | | | | | Branch (129:5): [True: 1.00k, False: 1] | | | | ------------------ | | ------------------ ------------------ 485| 1.00k| switch (BYTE_TYPE(enc, ptr)) { ------------------ | | 700| 1.00k|#define BYTE_TYPE(enc, p) LITTLE2_BYTE_TYPE(enc, p) | | ------------------ | | | | 683| 1.00k| ((p)[1] == 0 ? SB_BYTE_TYPE(enc, p) : unicode_byte_type((p)[1], (p)[0])) | | | | ------------------ | | | | | | 231| 1.00k| (((const struct normal_encoding *)(enc))->type[(unsigned char)*(p)]) | | | | ------------------ | | | | | Branch (683:4): [True: 1.00k, False: 5] | | | | ------------------ | | ------------------ ------------------ 486| 349| case BT_DIGIT: ------------------ | Branch (486:5): [True: 349, False: 656] ------------------ 487| 998| case BT_HEX: ------------------ | Branch (487:5): [True: 649, False: 356] ------------------ 488| 998| break; 489| 7| default: ------------------ | Branch (489:5): [True: 7, False: 998] ------------------ 490| 7| *nextTokPtr = ptr; 491| 7| return XML_TOK_INVALID; ------------------ | | 57| 7|# define XML_TOK_INVALID 0 ------------------ 492| 1.00k| } 493| 4.27k| for (ptr += MINBPC(enc); HAS_CHAR(enc, ptr, end); ptr += MINBPC(enc)) { ------------------ | | 698| 998|#define MINBPC(enc) 2 ------------------ for (ptr += MINBPC(enc); HAS_CHAR(enc, ptr, end); ptr += MINBPC(enc)) { ------------------ | | 698| 3.27k|#define MINBPC(enc) 2 ------------------ 494| 4.27k| switch (BYTE_TYPE(enc, ptr)) { ------------------ | | 700| 4.27k|#define BYTE_TYPE(enc, p) LITTLE2_BYTE_TYPE(enc, p) | | ------------------ | | | | 683| 4.27k| ((p)[1] == 0 ? SB_BYTE_TYPE(enc, p) : unicode_byte_type((p)[1], (p)[0])) | | | | ------------------ | | | | | | 231| 4.24k| (((const struct normal_encoding *)(enc))->type[(unsigned char)*(p)]) | | | | ------------------ | | | | | Branch (683:4): [True: 4.24k, False: 26] | | | | ------------------ | | ------------------ ------------------ 495| 1.56k| case BT_DIGIT: ------------------ | Branch (495:7): [True: 1.56k, False: 2.70k] ------------------ 496| 3.27k| case BT_HEX: ------------------ | Branch (496:7): [True: 1.71k, False: 2.55k] ------------------ 497| 3.27k| break; 498| 970| case BT_SEMI: ------------------ | Branch (498:7): [True: 970, False: 3.30k] ------------------ 499| 970| *nextTokPtr = ptr + MINBPC(enc); ------------------ | | 698| 970|#define MINBPC(enc) 2 ------------------ 500| 970| return XML_TOK_CHAR_REF; ------------------ | | 71| 970|# define XML_TOK_CHAR_REF 10 /* numeric character reference */ ------------------ 501| 26| default: ------------------ | Branch (501:7): [True: 26, False: 4.24k] ------------------ 502| 26| *nextTokPtr = ptr; 503| 26| return XML_TOK_INVALID; ------------------ | | 57| 26|# define XML_TOK_INVALID 0 ------------------ 504| 4.27k| } 505| 4.27k| } 506| 998| } 507| 3| return XML_TOK_PARTIAL; ------------------ | | 56| 3|# define XML_TOK_PARTIAL -1 /* only part of a token */ ------------------ 508| 1.00k|} xmltok.c:little2_cdataSectionTok: 356| 4.55k| const char **nextTokPtr) { 357| 4.55k| if (ptr >= end) ------------------ | Branch (357:7): [True: 109, False: 4.45k] ------------------ 358| 109| return XML_TOK_NONE; ------------------ | | 51| 109|# define XML_TOK_NONE -4 /* The string to be scanned is empty */ ------------------ 359| 4.45k| if (MINBPC(enc) > 1) { ------------------ | | 698| 4.45k|#define MINBPC(enc) 2 ------------------ | Branch (359:7): [True: 4.45k, Folded] ------------------ 360| 4.45k| size_t n = end - ptr; 361| 4.45k| if (n & (MINBPC(enc) - 1)) { ------------------ | | 698| 4.45k|#define MINBPC(enc) 2 ------------------ | Branch (361:9): [True: 1.47k, False: 2.97k] ------------------ 362| 1.47k| n &= ~(MINBPC(enc) - 1); ------------------ | | 698| 1.47k|#define MINBPC(enc) 2 ------------------ 363| 1.47k| if (n == 0) ------------------ | Branch (363:11): [True: 55, False: 1.41k] ------------------ 364| 55| return XML_TOK_PARTIAL; ------------------ | | 56| 55|# define XML_TOK_PARTIAL -1 /* only part of a token */ ------------------ 365| 1.41k| end = ptr + n; 366| 1.41k| } 367| 4.45k| } 368| 4.39k| switch (BYTE_TYPE(enc, ptr)) { ------------------ | | 700| 4.39k|#define BYTE_TYPE(enc, p) LITTLE2_BYTE_TYPE(enc, p) | | ------------------ | | | | 683| 4.39k| ((p)[1] == 0 ? SB_BYTE_TYPE(enc, p) : unicode_byte_type((p)[1], (p)[0])) | | | | ------------------ | | | | | | 231| 3.17k| (((const struct normal_encoding *)(enc))->type[(unsigned char)*(p)]) | | | | ------------------ | | | | | Branch (683:4): [True: 3.17k, False: 1.22k] | | | | ------------------ | | ------------------ ------------------ 369| 1.43k| case BT_RSQB: ------------------ | Branch (369:3): [True: 1.43k, False: 2.95k] ------------------ 370| 1.43k| ptr += MINBPC(enc); ------------------ | | 698| 1.43k|#define MINBPC(enc) 2 ------------------ 371| 1.43k| REQUIRE_CHAR(enc, ptr, end); ------------------ | | 140| 1.43k|# define REQUIRE_CHAR(enc, ptr, end) REQUIRE_CHARS(enc, ptr, end, 1) | | ------------------ | | | | 134| 1.43k| { \ | | | | 135| 1.43k| if (! HAS_CHARS(enc, ptr, end, count)) { \ | | | | ------------------ | | | | | | 129| 1.43k| ((end) - (ptr) >= ((count) * MINBPC(enc))) | | | | | | ------------------ | | | | | | | | 698| 1.43k|#define MINBPC(enc) 2 | | | | | | ------------------ | | | | ------------------ | | | | | Branch (135:11): [True: 2, False: 1.43k] | | | | ------------------ | | | | 136| 2| return XML_TOK_PARTIAL; \ | | | | ------------------ | | | | | | 56| 2|# define XML_TOK_PARTIAL -1 /* only part of a token */ | | | | ------------------ | | | | 137| 2| } \ | | | | 138| 1.43k| } | | ------------------ ------------------ 372| 1.43k| if (! CHAR_MATCHES(enc, ptr, ASCII_RSQB)) ------------------ | | 702| 1.43k|#define CHAR_MATCHES(enc, p, c) LITTLE2_CHAR_MATCHES(p, c) | | ------------------ | | | | 685| 1.43k|#define LITTLE2_CHAR_MATCHES(p, c) ((p)[1] == 0 && (p)[0] == (c)) | | | | ------------------ | | | | | Branch (685:37): [True: 999, False: 438] | | | | | Branch (685:52): [True: 780, False: 219] | | | | ------------------ | | ------------------ ------------------ 373| 657| break; 374| 780| ptr += MINBPC(enc); ------------------ | | 698| 780|#define MINBPC(enc) 2 ------------------ 375| 780| REQUIRE_CHAR(enc, ptr, end); ------------------ | | 140| 780|# define REQUIRE_CHAR(enc, ptr, end) REQUIRE_CHARS(enc, ptr, end, 1) | | ------------------ | | | | 134| 780| { \ | | | | 135| 780| if (! HAS_CHARS(enc, ptr, end, count)) { \ | | | | ------------------ | | | | | | 129| 780| ((end) - (ptr) >= ((count) * MINBPC(enc))) | | | | | | ------------------ | | | | | | | | 698| 780|#define MINBPC(enc) 2 | | | | | | ------------------ | | | | ------------------ | | | | | Branch (135:11): [True: 6, False: 774] | | | | ------------------ | | | | 136| 6| return XML_TOK_PARTIAL; \ | | | | ------------------ | | | | | | 56| 6|# define XML_TOK_PARTIAL -1 /* only part of a token */ | | | | ------------------ | | | | 137| 6| } \ | | | | 138| 780| } | | ------------------ ------------------ 376| 774| if (! CHAR_MATCHES(enc, ptr, ASCII_GT)) { ------------------ | | 702| 774|#define CHAR_MATCHES(enc, p, c) LITTLE2_CHAR_MATCHES(p, c) | | ------------------ | | | | 685| 774|#define LITTLE2_CHAR_MATCHES(p, c) ((p)[1] == 0 && (p)[0] == (c)) | | | | ------------------ | | | | | Branch (685:37): [True: 543, False: 231] | | | | | Branch (685:52): [True: 68, False: 475] | | | | ------------------ | | ------------------ ------------------ 377| 706| ptr -= MINBPC(enc); ------------------ | | 698| 706|#define MINBPC(enc) 2 ------------------ 378| 706| break; 379| 706| } 380| 68| *nextTokPtr = ptr + MINBPC(enc); ------------------ | | 698| 68|#define MINBPC(enc) 2 ------------------ 381| 68| return XML_TOK_CDATA_SECT_CLOSE; ------------------ | | 113| 68|# define XML_TOK_CDATA_SECT_CLOSE 40 ------------------ 382| 952| case BT_CR: ------------------ | Branch (382:3): [True: 952, False: 3.44k] ------------------ 383| 952| ptr += MINBPC(enc); ------------------ | | 698| 952|#define MINBPC(enc) 2 ------------------ 384| 952| REQUIRE_CHAR(enc, ptr, end); ------------------ | | 140| 952|# define REQUIRE_CHAR(enc, ptr, end) REQUIRE_CHARS(enc, ptr, end, 1) | | ------------------ | | | | 134| 952| { \ | | | | 135| 952| if (! HAS_CHARS(enc, ptr, end, count)) { \ | | | | ------------------ | | | | | | 129| 952| ((end) - (ptr) >= ((count) * MINBPC(enc))) | | | | | | ------------------ | | | | | | | | 698| 952|#define MINBPC(enc) 2 | | | | | | ------------------ | | | | ------------------ | | | | | Branch (135:11): [True: 6, False: 946] | | | | ------------------ | | | | 136| 6| return XML_TOK_PARTIAL; \ | | | | ------------------ | | | | | | 56| 6|# define XML_TOK_PARTIAL -1 /* only part of a token */ | | | | ------------------ | | | | 137| 6| } \ | | | | 138| 952| } | | ------------------ ------------------ 385| 946| if (BYTE_TYPE(enc, ptr) == BT_LF) ------------------ | | 700| 946|#define BYTE_TYPE(enc, p) LITTLE2_BYTE_TYPE(enc, p) | | ------------------ | | | | 683| 946| ((p)[1] == 0 ? SB_BYTE_TYPE(enc, p) : unicode_byte_type((p)[1], (p)[0])) | | | | ------------------ | | | | | | 231| 451| (((const struct normal_encoding *)(enc))->type[(unsigned char)*(p)]) | | | | ------------------ | | | | | Branch (683:4): [True: 451, False: 495] | | | | ------------------ | | ------------------ ------------------ | Branch (385:9): [True: 68, False: 878] ------------------ 386| 68| ptr += MINBPC(enc); ------------------ | | 698| 68|#define MINBPC(enc) 2 ------------------ 387| 946| *nextTokPtr = ptr; 388| 946| return XML_TOK_DATA_NEWLINE; ------------------ | | 68| 946|# define XML_TOK_DATA_NEWLINE 7 ------------------ 389| 725| case BT_LF: ------------------ | Branch (389:3): [True: 725, False: 3.67k] ------------------ 390| 725| *nextTokPtr = ptr + MINBPC(enc); ------------------ | | 698| 725|#define MINBPC(enc) 2 ------------------ 391| 725| return XML_TOK_DATA_NEWLINE; ------------------ | | 68| 725|# define XML_TOK_DATA_NEWLINE 7 ------------------ 392| 725| INVALID_CASES(ptr, nextTokPtr) ------------------ | | 60| 0| INVALID_LEAD_CASE(2, ptr, nextTokPtr) \ | | ------------------ | | | | 49| 0| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (49:3): [True: 0, False: 4.39k] | | | | ------------------ | | | | 50| 0| if (end - ptr < n) \ | | | | ------------------ | | | | | Branch (50:9): [True: 0, False: 0] | | | | ------------------ | | | | 51| 0| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 0|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 52| 0| if (IS_INVALID_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 707| 0|#define IS_INVALID_CHAR(enc, p, n) LITTLE2_IS_INVALID_CHAR(p, n) | | | | | | ------------------ | | | | | | | | 694| 0| ((n) == 4 && ((unsigned char)(p)[3] & 0xFC) != 0xDC) | | | | | | | | ------------------ | | | | | | | | | Branch (694:4): [Folded, False: 0] | | | | | | | | | Branch (694:16): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 53| 0| *(nextTokPtr) = (ptr); \ | | | | 54| 0| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 0|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 55| 0| } \ | | | | 56| 0| ptr += n; \ | | | | 57| 0| break; | | ------------------ | | 61| 0| INVALID_LEAD_CASE(3, ptr, nextTokPtr) \ | | ------------------ | | | | 49| 0| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (49:3): [True: 0, False: 4.39k] | | | | ------------------ | | | | 50| 0| if (end - ptr < n) \ | | | | ------------------ | | | | | Branch (50:9): [True: 0, False: 0] | | | | ------------------ | | | | 51| 0| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 0|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 52| 0| if (IS_INVALID_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 707| 0|#define IS_INVALID_CHAR(enc, p, n) LITTLE2_IS_INVALID_CHAR(p, n) | | | | | | ------------------ | | | | | | | | 694| 0| ((n) == 4 && ((unsigned char)(p)[3] & 0xFC) != 0xDC) | | | | | | | | ------------------ | | | | | | | | | Branch (694:4): [Folded, False: 0] | | | | | | | | | Branch (694:16): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 53| 0| *(nextTokPtr) = (ptr); \ | | | | 54| 0| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 0|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 55| 0| } \ | | | | 56| 0| ptr += n; \ | | | | 57| 0| break; | | ------------------ | | 62| 313| INVALID_LEAD_CASE(4, ptr, nextTokPtr) \ | | ------------------ | | | | 49| 313| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (49:3): [True: 313, False: 4.08k] | | | | ------------------ | | | | 50| 313| if (end - ptr < n) \ | | | | ------------------ | | | | | Branch (50:9): [True: 4, False: 309] | | | | ------------------ | | | | 51| 259| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 4|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 52| 309| if (IS_INVALID_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 707| 309|#define IS_INVALID_CHAR(enc, p, n) LITTLE2_IS_INVALID_CHAR(p, n) | | | | | | ------------------ | | | | | | | | 694| 309| ((n) == 4 && ((unsigned char)(p)[3] & 0xFC) != 0xDC) | | | | | | | | ------------------ | | | | | | | | | Branch (694:4): [True: 309, Folded] | | | | | | | | | Branch (694:16): [True: 50, False: 259] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 53| 50| *(nextTokPtr) = (ptr); \ | | | | 54| 50| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 50|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 55| 50| } \ | | | | 56| 309| ptr += n; \ | | | | 57| 259| break; | | ------------------ | | 63| 259| case BT_NONXML: \ | | ------------------ | | | Branch (63:3): [True: 5, False: 4.39k] | | ------------------ | | 64| 5| case BT_MALFORM: \ | | ------------------ | | | Branch (64:3): [True: 0, False: 4.39k] | | ------------------ | | 65| 13| case BT_TRAIL: \ | | ------------------ | | | Branch (65:3): [True: 8, False: 4.38k] | | ------------------ | | 66| 13| *(nextTokPtr) = (ptr); \ | | 67| 13| return XML_TOK_INVALID; | | ------------------ | | | | 57| 13|# define XML_TOK_INVALID 0 | | ------------------ ------------------ 393| 953| default: ------------------ | Branch (393:3): [True: 953, False: 3.44k] ------------------ 394| 953| ptr += MINBPC(enc); ------------------ | | 698| 953|#define MINBPC(enc) 2 ------------------ 395| 953| break; 396| 4.39k| } 397| 7.30k| while (HAS_CHAR(enc, ptr, end)) { 398| 7.30k| switch (BYTE_TYPE(enc, ptr)) { ------------------ | | 700| 7.30k|#define BYTE_TYPE(enc, p) LITTLE2_BYTE_TYPE(enc, p) | | ------------------ | | | | 683| 7.30k| ((p)[1] == 0 ? SB_BYTE_TYPE(enc, p) : unicode_byte_type((p)[1], (p)[0])) | | | | ------------------ | | | | | | 231| 3.51k| (((const struct normal_encoding *)(enc))->type[(unsigned char)*(p)]) | | | | ------------------ | | | | | Branch (683:4): [True: 3.51k, False: 3.79k] | | | | ------------------ | | ------------------ ------------------ 399| 0|# define LEAD_CASE(n) \ 400| 0| case BT_LEAD##n: \ 401| 0| if (end - ptr < n || IS_INVALID_CHAR(enc, ptr, n)) { \ 402| 0| *nextTokPtr = ptr; \ 403| 0| return XML_TOK_DATA_CHARS; \ 404| 0| } \ 405| 0| ptr += n; \ 406| 0| break; 407| 0| LEAD_CASE(2) ------------------ | | 400| 0| case BT_LEAD##n: \ | | ------------------ | | | Branch (400:3): [True: 0, False: 7.30k] | | ------------------ | | 401| 0| if (end - ptr < n || IS_INVALID_CHAR(enc, ptr, n)) { \ | | ------------------ | | | | 707| 0|#define IS_INVALID_CHAR(enc, p, n) LITTLE2_IS_INVALID_CHAR(p, n) | | | | ------------------ | | | | | | 694| 0| ((n) == 4 && ((unsigned char)(p)[3] & 0xFC) != 0xDC) | | | | | | ------------------ | | | | | | | Branch (694:4): [Folded, False: 0] | | | | | | | Branch (694:16): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (401:9): [True: 0, False: 0] | | ------------------ | | 402| 0| *nextTokPtr = ptr; \ | | 403| 0| return XML_TOK_DATA_CHARS; \ | | ------------------ | | | | 67| 0|# define XML_TOK_DATA_CHARS 6 | | ------------------ | | 404| 0| } \ | | 405| 0| ptr += n; \ | | 406| 0| break; ------------------ 408| 0| LEAD_CASE(3) ------------------ | | 400| 0| case BT_LEAD##n: \ | | ------------------ | | | Branch (400:3): [True: 0, False: 7.30k] | | ------------------ | | 401| 0| if (end - ptr < n || IS_INVALID_CHAR(enc, ptr, n)) { \ | | ------------------ | | | | 707| 0|#define IS_INVALID_CHAR(enc, p, n) LITTLE2_IS_INVALID_CHAR(p, n) | | | | ------------------ | | | | | | 694| 0| ((n) == 4 && ((unsigned char)(p)[3] & 0xFC) != 0xDC) | | | | | | ------------------ | | | | | | | Branch (694:4): [Folded, False: 0] | | | | | | | Branch (694:16): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (401:9): [True: 0, False: 0] | | ------------------ | | 402| 0| *nextTokPtr = ptr; \ | | 403| 0| return XML_TOK_DATA_CHARS; \ | | ------------------ | | | | 67| 0|# define XML_TOK_DATA_CHARS 6 | | ------------------ | | 404| 0| } \ | | 405| 0| ptr += n; \ | | 406| 0| break; ------------------ 409| 450| LEAD_CASE(4) ------------------ | | 400| 450| case BT_LEAD##n: \ | | ------------------ | | | Branch (400:3): [True: 450, False: 6.85k] | | ------------------ | | 401| 450| if (end - ptr < n || IS_INVALID_CHAR(enc, ptr, n)) { \ | | ------------------ | | | | 707| 446|#define IS_INVALID_CHAR(enc, p, n) LITTLE2_IS_INVALID_CHAR(p, n) | | | | ------------------ | | | | | | 694| 446| ((n) == 4 && ((unsigned char)(p)[3] & 0xFC) != 0xDC) | | | | | | ------------------ | | | | | | | Branch (694:4): [True: 446, Folded] | | | | | | | Branch (694:16): [True: 46, False: 400] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (401:9): [True: 4, False: 446] | | ------------------ | | 402| 50| *nextTokPtr = ptr; \ | | 403| 50| return XML_TOK_DATA_CHARS; \ | | ------------------ | | | | 67| 50|# define XML_TOK_DATA_CHARS 6 | | ------------------ | | 404| 50| } \ | | 405| 400| ptr += n; \ | | 406| 400| break; ------------------ 410| 0|# undef LEAD_CASE 411| 3| case BT_NONXML: ------------------ | Branch (411:5): [True: 3, False: 7.30k] ------------------ 412| 3| case BT_MALFORM: ------------------ | Branch (412:5): [True: 0, False: 7.30k] ------------------ 413| 7| case BT_TRAIL: ------------------ | Branch (413:5): [True: 4, False: 7.30k] ------------------ 414| 509| case BT_CR: ------------------ | Branch (414:5): [True: 502, False: 6.80k] ------------------ 415| 1.03k| case BT_LF: ------------------ | Branch (415:5): [True: 527, False: 6.78k] ------------------ 416| 2.36k| case BT_RSQB: ------------------ | Branch (416:5): [True: 1.33k, False: 5.97k] ------------------ 417| 2.36k| *nextTokPtr = ptr; 418| 2.36k| return XML_TOK_DATA_CHARS; ------------------ | | 67| 2.36k|# define XML_TOK_DATA_CHARS 6 ------------------ 419| 4.49k| default: ------------------ | Branch (419:5): [True: 4.49k, False: 2.81k] ------------------ 420| 4.49k| ptr += MINBPC(enc); ------------------ | | 698| 4.49k|#define MINBPC(enc) 2 ------------------ 421| 4.49k| break; 422| 7.30k| } 423| 7.30k| } 424| 157| *nextTokPtr = ptr; 425| 157| return XML_TOK_DATA_CHARS; ------------------ | | 67| 157|# define XML_TOK_DATA_CHARS 6 ------------------ 426| 2.57k|} xmltok.c:little2_attributeValueTok: 1262| 4.45k| const char **nextTokPtr) { 1263| 4.45k| const char *start; 1264| 4.45k| if (ptr >= end) ------------------ | Branch (1264:7): [True: 474, False: 3.98k] ------------------ 1265| 474| return XML_TOK_NONE; ------------------ | | 51| 474|# define XML_TOK_NONE -4 /* The string to be scanned is empty */ ------------------ 1266| 3.98k| else if (! HAS_CHAR(enc, ptr, end)) { ------------------ | | 131| 3.98k|# define HAS_CHAR(enc, ptr, end) HAS_CHARS(enc, ptr, end, 1) | | ------------------ | | | | 129| 3.98k| ((end) - (ptr) >= ((count) * MINBPC(enc))) | | | | ------------------ | | | | | | 698| 3.98k|#define MINBPC(enc) 2 | | | | ------------------ | | ------------------ ------------------ | Branch (1266:12): [True: 0, False: 3.98k] ------------------ 1267| | /* This line cannot be executed. The incoming data has already 1268| | * been tokenized once, so incomplete characters like this have 1269| | * already been eliminated from the input. Retaining the paranoia 1270| | * check is still valuable, however. 1271| | */ 1272| 0| return XML_TOK_PARTIAL; /* LCOV_EXCL_LINE */ ------------------ | | 56| 0|# define XML_TOK_PARTIAL -1 /* only part of a token */ ------------------ 1273| 0| } 1274| 3.98k| start = ptr; 1275| 8.37k| while (HAS_CHAR(enc, ptr, end)) { 1276| 8.37k| switch (BYTE_TYPE(enc, ptr)) { ------------------ | | 700| 8.37k|#define BYTE_TYPE(enc, p) LITTLE2_BYTE_TYPE(enc, p) | | ------------------ | | | | 683| 8.37k| ((p)[1] == 0 ? SB_BYTE_TYPE(enc, p) : unicode_byte_type((p)[1], (p)[0])) | | | | ------------------ | | | | | | 231| 4.19k| (((const struct normal_encoding *)(enc))->type[(unsigned char)*(p)]) | | | | ------------------ | | | | | Branch (683:4): [True: 4.19k, False: 4.18k] | | | | ------------------ | | ------------------ ------------------ 1277| 0|# define LEAD_CASE(n) \ 1278| 0| case BT_LEAD##n: \ 1279| 0| ptr += n; /* NOTE: The encoding has already been validated. */ \ 1280| 0| break; 1281| 0| LEAD_CASE(2) ------------------ | | 1278| 0| case BT_LEAD##n: \ | | ------------------ | | | Branch (1278:3): [True: 0, False: 8.37k] | | ------------------ | | 1279| 0| ptr += n; /* NOTE: The encoding has already been validated. */ \ | | 1280| 0| break; ------------------ 1282| 0| LEAD_CASE(3) ------------------ | | 1278| 0| case BT_LEAD##n: \ | | ------------------ | | | Branch (1278:3): [True: 0, False: 8.37k] | | ------------------ | | 1279| 0| ptr += n; /* NOTE: The encoding has already been validated. */ \ | | 1280| 0| break; ------------------ 1283| 393| LEAD_CASE(4) ------------------ | | 1278| 393| case BT_LEAD##n: \ | | ------------------ | | | Branch (1278:3): [True: 393, False: 7.98k] | | ------------------ | | 1279| 393| ptr += n; /* NOTE: The encoding has already been validated. */ \ | | 1280| 393| break; ------------------ 1284| 0|# undef LEAD_CASE 1285| 489| case BT_AMP: ------------------ | Branch (1285:5): [True: 489, False: 7.88k] ------------------ 1286| 489| if (ptr == start) ------------------ | Branch (1286:11): [True: 370, False: 119] ------------------ 1287| 370| return PREFIX(scanRef)(enc, ptr + MINBPC(enc), end, nextTokPtr); ------------------ | | 697| 370|#define PREFIX(ident) little2_##ident ------------------ return PREFIX(scanRef)(enc, ptr + MINBPC(enc), end, nextTokPtr); ------------------ | | 698| 370|#define MINBPC(enc) 2 ------------------ 1288| 119| *nextTokPtr = ptr; 1289| 119| return XML_TOK_DATA_CHARS; ------------------ | | 67| 119|# define XML_TOK_DATA_CHARS 6 ------------------ 1290| 0| case BT_LT: ------------------ | Branch (1290:5): [True: 0, False: 8.37k] ------------------ 1291| | /* this is for inside entity references */ 1292| 0| *nextTokPtr = ptr; 1293| 0| return XML_TOK_INVALID; ------------------ | | 57| 0|# define XML_TOK_INVALID 0 ------------------ 1294| 641| case BT_LF: ------------------ | Branch (1294:5): [True: 641, False: 7.73k] ------------------ 1295| 641| if (ptr == start) { ------------------ | Branch (1295:11): [True: 414, False: 227] ------------------ 1296| 414| *nextTokPtr = ptr + MINBPC(enc); ------------------ | | 698| 414|#define MINBPC(enc) 2 ------------------ 1297| 414| return XML_TOK_DATA_NEWLINE; ------------------ | | 68| 414|# define XML_TOK_DATA_NEWLINE 7 ------------------ 1298| 414| } 1299| 227| *nextTokPtr = ptr; 1300| 227| return XML_TOK_DATA_CHARS; ------------------ | | 67| 227|# define XML_TOK_DATA_CHARS 6 ------------------ 1301| 953| case BT_CR: ------------------ | Branch (1301:5): [True: 953, False: 7.42k] ------------------ 1302| 953| if (ptr == start) { ------------------ | Branch (1302:11): [True: 721, False: 232] ------------------ 1303| 721| ptr += MINBPC(enc); ------------------ | | 698| 721|#define MINBPC(enc) 2 ------------------ 1304| 721| if (! HAS_CHAR(enc, ptr, end)) ------------------ | | 131| 721|# define HAS_CHAR(enc, ptr, end) HAS_CHARS(enc, ptr, end, 1) | | ------------------ | | | | 129| 721| ((end) - (ptr) >= ((count) * MINBPC(enc))) | | | | ------------------ | | | | | | 698| 721|#define MINBPC(enc) 2 | | | | ------------------ | | ------------------ ------------------ | Branch (1304:13): [True: 73, False: 648] ------------------ 1305| 73| return XML_TOK_TRAILING_CR; ------------------ | | 53| 73| -3 /* A CR at the end of the scan; \ ------------------ 1306| 648| if (BYTE_TYPE(enc, ptr) == BT_LF) ------------------ | | 700| 648|#define BYTE_TYPE(enc, p) LITTLE2_BYTE_TYPE(enc, p) | | ------------------ | | | | 683| 648| ((p)[1] == 0 ? SB_BYTE_TYPE(enc, p) : unicode_byte_type((p)[1], (p)[0])) | | | | ------------------ | | | | | | 231| 418| (((const struct normal_encoding *)(enc))->type[(unsigned char)*(p)]) | | | | ------------------ | | | | | Branch (683:4): [True: 418, False: 230] | | | | ------------------ | | ------------------ ------------------ | Branch (1306:13): [True: 66, False: 582] ------------------ 1307| 66| ptr += MINBPC(enc); ------------------ | | 698| 66|#define MINBPC(enc) 2 ------------------ 1308| 648| *nextTokPtr = ptr; 1309| 648| return XML_TOK_DATA_NEWLINE; ------------------ | | 68| 648|# define XML_TOK_DATA_NEWLINE 7 ------------------ 1310| 721| } 1311| 232| *nextTokPtr = ptr; 1312| 232| return XML_TOK_DATA_CHARS; ------------------ | | 67| 232|# define XML_TOK_DATA_CHARS 6 ------------------ 1313| 1.69k| case BT_S: ------------------ | Branch (1313:5): [True: 1.69k, False: 6.68k] ------------------ 1314| 1.69k| if (ptr == start) { ------------------ | Branch (1314:11): [True: 1.05k, False: 633] ------------------ 1315| 1.05k| *nextTokPtr = ptr + MINBPC(enc); ------------------ | | 698| 1.05k|#define MINBPC(enc) 2 ------------------ 1316| 1.05k| return XML_TOK_ATTRIBUTE_VALUE_S; ------------------ | | 110| 1.05k|# define XML_TOK_ATTRIBUTE_VALUE_S 39 ------------------ 1317| 1.05k| } 1318| 633| *nextTokPtr = ptr; 1319| 633| return XML_TOK_DATA_CHARS; ------------------ | | 67| 633|# define XML_TOK_DATA_CHARS 6 ------------------ 1320| 4.20k| default: ------------------ | Branch (1320:5): [True: 4.20k, False: 4.16k] ------------------ 1321| 4.20k| ptr += MINBPC(enc); ------------------ | | 698| 4.20k|#define MINBPC(enc) 2 ------------------ 1322| 4.20k| break; 1323| 8.37k| } 1324| 8.37k| } 1325| 206| *nextTokPtr = ptr; 1326| 206| return XML_TOK_DATA_CHARS; ------------------ | | 67| 206|# define XML_TOK_DATA_CHARS 6 ------------------ 1327| 3.98k|} xmltok.c:little2_nameMatchesAscii: 1715| 40| const char *end1, const char *ptr2) { 1716| 40| UNUSED_P(enc); ------------------ | | 101| 40|# define UNUSED_P(p) (void)p ------------------ 1717| 54| for (; *ptr2; ptr1 += MINBPC(enc), ptr2++) { ------------------ | | 698| 14|#define MINBPC(enc) 2 ------------------ | Branch (1717:10): [True: 54, False: 0] ------------------ 1718| 54| if (end1 - ptr1 < MINBPC(enc)) { ------------------ | | 698| 54|#define MINBPC(enc) 2 ------------------ | Branch (1718:9): [True: 7, False: 47] ------------------ 1719| | /* This line cannot be executed. The incoming data has already 1720| | * been tokenized once, so incomplete characters like this have 1721| | * already been eliminated from the input. Retaining the 1722| | * paranoia check is still valuable, however. 1723| | */ 1724| 7| return 0; /* LCOV_EXCL_LINE */ 1725| 7| } 1726| 47| if (! CHAR_MATCHES(enc, ptr1, *ptr2)) ------------------ | | 702| 47|#define CHAR_MATCHES(enc, p, c) LITTLE2_CHAR_MATCHES(p, c) | | ------------------ | | | | 685| 47|#define LITTLE2_CHAR_MATCHES(p, c) ((p)[1] == 0 && (p)[0] == (c)) | | | | ------------------ | | | | | Branch (685:37): [True: 47, False: 0] | | | | | Branch (685:52): [True: 14, False: 33] | | | | ------------------ | | ------------------ ------------------ 1727| 33| return 0; 1728| 47| } 1729| 0| return ptr1 == end1; 1730| 40|} xmltok.c:little2_nameLength: 1733| 6.32k|PREFIX(nameLength)(const ENCODING *enc, const char *ptr) { 1734| 6.32k| const char *start = ptr; 1735| 18.8k| for (;;) { 1736| 18.8k| switch (BYTE_TYPE(enc, ptr)) { ------------------ | | 700| 18.8k|#define BYTE_TYPE(enc, p) LITTLE2_BYTE_TYPE(enc, p) | | ------------------ | | | | 683| 18.8k| ((p)[1] == 0 ? SB_BYTE_TYPE(enc, p) : unicode_byte_type((p)[1], (p)[0])) | | | | ------------------ | | | | | | 231| 8.98k| (((const struct normal_encoding *)(enc))->type[(unsigned char)*(p)]) | | | | ------------------ | | | | | Branch (683:4): [True: 8.98k, False: 9.82k] | | | | ------------------ | | ------------------ ------------------ 1737| 0|# define LEAD_CASE(n) \ 1738| 0| case BT_LEAD##n: \ 1739| 0| ptr += n; /* NOTE: The encoding has already been validated. */ \ 1740| 0| break; 1741| 0| LEAD_CASE(2) ------------------ | | 1738| 0| case BT_LEAD##n: \ | | ------------------ | | | Branch (1738:3): [True: 0, False: 18.8k] | | ------------------ | | 1739| 0| ptr += n; /* NOTE: The encoding has already been validated. */ \ | | 1740| 0| break; ------------------ 1742| 0| LEAD_CASE(3) ------------------ | | 1738| 0| case BT_LEAD##n: \ | | ------------------ | | | Branch (1738:3): [True: 0, False: 18.8k] | | ------------------ | | 1739| 0| ptr += n; /* NOTE: The encoding has already been validated. */ \ | | 1740| 0| break; ------------------ 1743| 0| LEAD_CASE(4) ------------------ | | 1738| 0| case BT_LEAD##n: \ | | ------------------ | | | Branch (1738:3): [True: 0, False: 18.8k] | | ------------------ | | 1739| 0| ptr += n; /* NOTE: The encoding has already been validated. */ \ | | 1740| 0| break; ------------------ 1744| 0|# undef LEAD_CASE 1745| 9.82k| case BT_NONASCII: ------------------ | Branch (1745:5): [True: 9.82k, False: 8.98k] ------------------ 1746| 11.0k| case BT_NMSTRT: ------------------ | Branch (1746:5): [True: 1.21k, False: 17.5k] ------------------ 1747| 11.0k|# ifdef XML_NS 1748| 11.2k| case BT_COLON: ------------------ | Branch (1748:5): [True: 196, False: 18.6k] ------------------ 1749| 11.2k|# endif 1750| 11.9k| case BT_HEX: ------------------ | Branch (1750:5): [True: 670, False: 18.1k] ------------------ 1751| 11.9k| case BT_DIGIT: ------------------ | Branch (1751:5): [True: 51, False: 18.7k] ------------------ 1752| 12.2k| case BT_NAME: ------------------ | Branch (1752:5): [True: 299, False: 18.5k] ------------------ 1753| 12.4k| case BT_MINUS: ------------------ | Branch (1753:5): [True: 221, False: 18.5k] ------------------ 1754| 12.4k| ptr += MINBPC(enc); ------------------ | | 698| 12.4k|#define MINBPC(enc) 2 ------------------ 1755| 12.4k| break; 1756| 6.32k| default: ------------------ | Branch (1756:5): [True: 6.32k, False: 12.4k] ------------------ 1757| 6.32k| return (int)(ptr - start); 1758| 18.8k| } 1759| 18.8k| } 1760| 6.32k|} xmltok.c:little2_getAtts: 1510| 4.46k| ATTRIBUTE *atts) { 1511| 4.46k| enum { other, inName, inValue } state = inName; 1512| 4.46k| int nAtts = 0; 1513| 4.46k| int open = 0; /* defined when state == inValue; 1514| | initialization just to shut up compilers */ 1515| | 1516| 58.7k| for (ptr += MINBPC(enc);; ptr += MINBPC(enc)) { ------------------ | | 698| 4.46k|#define MINBPC(enc) 2 ------------------ for (ptr += MINBPC(enc);; ptr += MINBPC(enc)) { ------------------ | | 698| 54.3k|#define MINBPC(enc) 2 ------------------ 1517| 58.7k| switch (BYTE_TYPE(enc, ptr)) { ------------------ | | 700| 58.7k|#define BYTE_TYPE(enc, p) LITTLE2_BYTE_TYPE(enc, p) | | ------------------ | | | | 683| 58.7k| ((p)[1] == 0 ? SB_BYTE_TYPE(enc, p) : unicode_byte_type((p)[1], (p)[0])) | | | | ------------------ | | | | | | 231| 33.8k| (((const struct normal_encoding *)(enc))->type[(unsigned char)*(p)]) | | | | ------------------ | | | | | Branch (683:4): [True: 33.8k, False: 24.8k] | | | | ------------------ | | ------------------ ------------------ 1518| 0|# define START_NAME \ 1519| 0| if (state == other) { \ 1520| 0| if (nAtts < attsMax) { \ 1521| 0| atts[nAtts].name = ptr; \ 1522| 0| atts[nAtts].normalized = 1; \ 1523| 0| } \ 1524| 0| state = inName; \ 1525| 0| } 1526| 0|# define LEAD_CASE(n) \ 1527| 0| case BT_LEAD##n: /* NOTE: The encoding has already been validated. */ \ 1528| 0| START_NAME ptr += (n - MINBPC(enc)); \ 1529| 0| break; 1530| 0| LEAD_CASE(2) ------------------ | | 1527| 0| case BT_LEAD##n: /* NOTE: The encoding has already been validated. */ \ | | ------------------ | | | Branch (1527:3): [True: 0, False: 58.7k] | | ------------------ | | 1528| 0| START_NAME ptr += (n - MINBPC(enc)); \ | | ------------------ | | | | 1519| 0| if (state == other) { \ | | | | ------------------ | | | | | Branch (1519:9): [True: 0, False: 0] | | | | ------------------ | | | | 1520| 0| if (nAtts < attsMax) { \ | | | | ------------------ | | | | | Branch (1520:11): [True: 0, False: 0] | | | | ------------------ | | | | 1521| 0| atts[nAtts].name = ptr; \ | | | | 1522| 0| atts[nAtts].normalized = 1; \ | | | | 1523| 0| } \ | | | | 1524| 0| state = inName; \ | | | | 1525| 0| } | | ------------------ | | START_NAME ptr += (n - MINBPC(enc)); \ | | ------------------ | | | | 698| 0|#define MINBPC(enc) 2 | | ------------------ | | 1529| 0| break; ------------------ 1531| 0| LEAD_CASE(3) ------------------ | | 1527| 0| case BT_LEAD##n: /* NOTE: The encoding has already been validated. */ \ | | ------------------ | | | Branch (1527:3): [True: 0, False: 58.7k] | | ------------------ | | 1528| 0| START_NAME ptr += (n - MINBPC(enc)); \ | | ------------------ | | | | 1519| 0| if (state == other) { \ | | | | ------------------ | | | | | Branch (1519:9): [True: 0, False: 0] | | | | ------------------ | | | | 1520| 0| if (nAtts < attsMax) { \ | | | | ------------------ | | | | | Branch (1520:11): [True: 0, False: 0] | | | | ------------------ | | | | 1521| 0| atts[nAtts].name = ptr; \ | | | | 1522| 0| atts[nAtts].normalized = 1; \ | | | | 1523| 0| } \ | | | | 1524| 0| state = inName; \ | | | | 1525| 0| } | | ------------------ | | START_NAME ptr += (n - MINBPC(enc)); \ | | ------------------ | | | | 698| 0|#define MINBPC(enc) 2 | | ------------------ | | 1529| 0| break; ------------------ 1532| 1.36k| LEAD_CASE(4) ------------------ | | 1527| 1.36k| case BT_LEAD##n: /* NOTE: The encoding has already been validated. */ \ | | ------------------ | | | Branch (1527:3): [True: 1.36k, False: 57.4k] | | ------------------ | | 1528| 1.36k| START_NAME ptr += (n - MINBPC(enc)); \ | | ------------------ | | | | 1519| 1.36k| if (state == other) { \ | | | | ------------------ | | | | | Branch (1519:9): [True: 0, False: 1.36k] | | | | ------------------ | | | | 1520| 0| if (nAtts < attsMax) { \ | | | | ------------------ | | | | | Branch (1520:11): [True: 0, False: 0] | | | | ------------------ | | | | 1521| 0| atts[nAtts].name = ptr; \ | | | | 1522| 0| atts[nAtts].normalized = 1; \ | | | | 1523| 0| } \ | | | | 1524| 0| state = inName; \ | | | | 1525| 0| } | | ------------------ | | START_NAME ptr += (n - MINBPC(enc)); \ | | ------------------ | | | | 698| 1.36k|#define MINBPC(enc) 2 | | ------------------ | | 1529| 1.36k| break; ------------------ 1533| 0|# undef LEAD_CASE 1534| 23.5k| case BT_NONASCII: ------------------ | Branch (1534:5): [True: 23.5k, False: 35.2k] ------------------ 1535| 25.3k| case BT_NMSTRT: ------------------ | Branch (1535:5): [True: 1.84k, False: 56.9k] ------------------ 1536| 26.2k| case BT_HEX: ------------------ | Branch (1536:5): [True: 840, False: 57.9k] ------------------ 1537| 26.2k| START_NAME ------------------ | | 1519| 26.2k| if (state == other) { \ | | ------------------ | | | Branch (1519:9): [True: 3.85k, False: 22.3k] | | ------------------ | | 1520| 3.85k| if (nAtts < attsMax) { \ | | ------------------ | | | Branch (1520:11): [True: 3.47k, False: 377] | | ------------------ | | 1521| 3.47k| atts[nAtts].name = ptr; \ | | 1522| 3.47k| atts[nAtts].normalized = 1; \ | | 1523| 3.47k| } \ | | 1524| 3.85k| state = inName; \ | | 1525| 3.85k| } ------------------ 1538| 26.2k| break; 1539| 0|# undef START_NAME 1540| 3.38k| case BT_QUOT: ------------------ | Branch (1540:5): [True: 3.38k, False: 55.3k] ------------------ 1541| 3.38k| if (state != inValue) { ------------------ | Branch (1541:11): [True: 1.57k, False: 1.81k] ------------------ 1542| 1.57k| if (nAtts < attsMax) ------------------ | Branch (1542:13): [True: 1.42k, False: 146] ------------------ 1543| 1.42k| atts[nAtts].valuePtr = ptr + MINBPC(enc); ------------------ | | 698| 1.42k|#define MINBPC(enc) 2 ------------------ 1544| 1.57k| state = inValue; 1545| 1.57k| open = BT_QUOT; 1546| 1.81k| } else if (open == BT_QUOT) { ------------------ | Branch (1546:18): [True: 1.57k, False: 240] ------------------ 1547| 1.57k| state = other; 1548| 1.57k| if (nAtts < attsMax) ------------------ | Branch (1548:13): [True: 1.42k, False: 146] ------------------ 1549| 1.42k| atts[nAtts].valueEnd = ptr; 1550| 1.57k| nAtts++; 1551| 1.57k| } 1552| 3.38k| break; 1553| 4.76k| case BT_APOS: ------------------ | Branch (1553:5): [True: 4.76k, False: 54.0k] ------------------ 1554| 4.76k| if (state != inValue) { ------------------ | Branch (1554:11): [True: 2.28k, False: 2.48k] ------------------ 1555| 2.28k| if (nAtts < attsMax) ------------------ | Branch (1555:13): [True: 2.05k, False: 231] ------------------ 1556| 2.05k| atts[nAtts].valuePtr = ptr + MINBPC(enc); ------------------ | | 698| 2.05k|#define MINBPC(enc) 2 ------------------ 1557| 2.28k| state = inValue; 1558| 2.28k| open = BT_APOS; 1559| 2.48k| } else if (open == BT_APOS) { ------------------ | Branch (1559:18): [True: 2.28k, False: 201] ------------------ 1560| 2.28k| state = other; 1561| 2.28k| if (nAtts < attsMax) ------------------ | Branch (1561:13): [True: 2.05k, False: 231] ------------------ 1562| 2.05k| atts[nAtts].valueEnd = ptr; 1563| 2.28k| nAtts++; 1564| 2.28k| } 1565| 4.76k| break; 1566| 590| case BT_AMP: ------------------ | Branch (1566:5): [True: 590, False: 58.1k] ------------------ 1567| 590| if (nAtts < attsMax) ------------------ | Branch (1567:11): [True: 517, False: 73] ------------------ 1568| 517| atts[nAtts].normalized = 0; 1569| 590| break; 1570| 7.97k| case BT_S: ------------------ | Branch (1570:5): [True: 7.97k, False: 50.8k] ------------------ 1571| 7.97k| if (state == inName) ------------------ | Branch (1571:11): [True: 1.22k, False: 6.75k] ------------------ 1572| 1.22k| state = other; 1573| 6.75k| else if (state == inValue && nAtts < attsMax && atts[nAtts].normalized ------------------ | Branch (1573:16): [True: 2.87k, False: 3.88k] | Branch (1573:36): [True: 2.62k, False: 245] | Branch (1573:55): [True: 1.95k, False: 677] ------------------ 1574| 1.95k| && (ptr == atts[nAtts].valuePtr ------------------ | Branch (1574:20): [True: 401, False: 1.54k] ------------------ 1575| 1.54k| || BYTE_TO_ASCII(enc, ptr) != ASCII_SPACE ------------------ | | 701| 1.54k|#define BYTE_TO_ASCII(enc, p) LITTLE2_BYTE_TO_ASCII(p) | | ------------------ | | | | 684| 1.54k|#define LITTLE2_BYTE_TO_ASCII(p) ((p)[1] == 0 ? (p)[0] : -1) | | | | ------------------ | | | | | Branch (684:35): [True: 1.54k, False: 0] | | | | ------------------ | | ------------------ ------------------ || BYTE_TO_ASCII(enc, ptr) != ASCII_SPACE ------------------ | | 104| 3.49k|#define ASCII_SPACE 0x20 ------------------ | Branch (1575:23): [True: 67, False: 1.48k] ------------------ 1576| 1.48k| || BYTE_TO_ASCII(enc, ptr + MINBPC(enc)) == ASCII_SPACE ------------------ | | 701| 1.48k|#define BYTE_TO_ASCII(enc, p) LITTLE2_BYTE_TO_ASCII(p) | | ------------------ | | | | 684| 1.48k|#define LITTLE2_BYTE_TO_ASCII(p) ((p)[1] == 0 ? (p)[0] : -1) | | | | ------------------ | | | | | Branch (684:35): [True: 373, False: 1.10k] | | | | ------------------ | | ------------------ ------------------ || BYTE_TO_ASCII(enc, ptr + MINBPC(enc)) == ASCII_SPACE ------------------ | | 104| 3.43k|#define ASCII_SPACE 0x20 ------------------ | Branch (1576:23): [True: 79, False: 1.40k] ------------------ 1577| 1.40k| || BYTE_TYPE(enc, ptr + MINBPC(enc)) == open)) ------------------ | | 700| 1.40k|#define BYTE_TYPE(enc, p) LITTLE2_BYTE_TYPE(enc, p) | | ------------------ | | | | 683| 1.40k| ((p)[1] == 0 ? SB_BYTE_TYPE(enc, p) : unicode_byte_type((p)[1], (p)[0])) | | | | ------------------ | | | | | | 231| 294| (((const struct normal_encoding *)(enc))->type[(unsigned char)*(p)]) | | | | ------------------ | | | | | Branch (683:4): [True: 294, False: 1.10k] | | | | ------------------ | | ------------------ ------------------ | Branch (1577:23): [True: 115, False: 1.28k] ------------------ 1578| 662| atts[nAtts].normalized = 0; 1579| 7.97k| break; 1580| 1.33k| case BT_CR: ------------------ | Branch (1580:5): [True: 1.33k, False: 57.4k] ------------------ 1581| 2.59k| case BT_LF: ------------------ | Branch (1581:5): [True: 1.25k, False: 57.5k] ------------------ 1582| | /* This case ensures that the first attribute name is counted 1583| | Apart from that we could just change state on the quote. */ 1584| 2.59k| if (state == inName) ------------------ | Branch (1584:11): [True: 273, False: 2.31k] ------------------ 1585| 273| state = other; 1586| 2.31k| else if (state == inValue && nAtts < attsMax) ------------------ | Branch (1586:16): [True: 1.59k, False: 725] | Branch (1586:36): [True: 1.39k, False: 194] ------------------ 1587| 1.39k| atts[nAtts].normalized = 0; 1588| 2.59k| break; 1589| 4.00k| case BT_GT: ------------------ | Branch (1589:5): [True: 4.00k, False: 54.7k] ------------------ 1590| 5.33k| case BT_SOL: ------------------ | Branch (1590:5): [True: 1.33k, False: 57.4k] ------------------ 1591| 5.33k| if (state != inValue) ------------------ | Branch (1591:11): [True: 4.46k, False: 873] ------------------ 1592| 4.46k| return nAtts; 1593| 873| break; 1594| 6.55k| default: ------------------ | Branch (1594:5): [True: 6.55k, False: 52.2k] ------------------ 1595| 6.55k| break; 1596| 58.7k| } 1597| 58.7k| } 1598| | /* not reached */ 1599| 4.46k|} xmltok.c:little2_charRefNumber: 1602| 1.18k|PREFIX(charRefNumber)(const ENCODING *enc, const char *ptr) { 1603| 1.18k| int result = 0; 1604| | /* skip &# */ 1605| 1.18k| UNUSED_P(enc); ------------------ | | 101| 1.18k|# define UNUSED_P(p) (void)p ------------------ 1606| 1.18k| ptr += 2 * MINBPC(enc); ------------------ | | 698| 1.18k|#define MINBPC(enc) 2 ------------------ 1607| 1.18k| if (CHAR_MATCHES(enc, ptr, ASCII_x)) { ------------------ | | 702| 1.18k|#define CHAR_MATCHES(enc, p, c) LITTLE2_CHAR_MATCHES(p, c) | | ------------------ | | | | 685| 1.18k|#define LITTLE2_CHAR_MATCHES(p, c) ((p)[1] == 0 && (p)[0] == (c)) | | | | ------------------ | | | | | Branch (685:37): [True: 1.18k, False: 0] | | | | | Branch (685:52): [True: 934, False: 254] | | | | ------------------ | | ------------------ ------------------ 1608| 4.87k| for (ptr += MINBPC(enc); ! CHAR_MATCHES(enc, ptr, ASCII_SEMI); ------------------ | | 698| 934|#define MINBPC(enc) 2 ------------------ for (ptr += MINBPC(enc); ! CHAR_MATCHES(enc, ptr, ASCII_SEMI); ------------------ | | 702| 4.87k|#define CHAR_MATCHES(enc, p, c) LITTLE2_CHAR_MATCHES(p, c) | | ------------------ | | | | 685| 4.87k|#define LITTLE2_CHAR_MATCHES(p, c) ((p)[1] == 0 && (p)[0] == (c)) | | | | ------------------ | | | | | Branch (685:37): [True: 4.87k, False: 0] | | | | | Branch (685:52): [True: 931, False: 3.94k] | | | | ------------------ | | ------------------ ------------------ 1609| 3.94k| ptr += MINBPC(enc)) { ------------------ | | 698| 3.94k|#define MINBPC(enc) 2 ------------------ 1610| 3.94k| int c = BYTE_TO_ASCII(enc, ptr); ------------------ | | 701| 3.94k|#define BYTE_TO_ASCII(enc, p) LITTLE2_BYTE_TO_ASCII(p) | | ------------------ | | | | 684| 3.94k|#define LITTLE2_BYTE_TO_ASCII(p) ((p)[1] == 0 ? (p)[0] : -1) | | | | ------------------ | | | | | Branch (684:35): [True: 3.94k, False: 0] | | | | ------------------ | | ------------------ ------------------ 1611| 3.94k| switch (c) { ------------------ | Branch (1611:15): [True: 3.94k, False: 0] ------------------ 1612| 546| case ASCII_0: ------------------ | | 92| 546|#define ASCII_0 0x30 ------------------ | Branch (1612:7): [True: 546, False: 3.39k] ------------------ 1613| 777| case ASCII_1: ------------------ | | 93| 777|#define ASCII_1 0x31 ------------------ | Branch (1613:7): [True: 231, False: 3.71k] ------------------ 1614| 868| case ASCII_2: ------------------ | | 94| 868|#define ASCII_2 0x32 ------------------ | Branch (1614:7): [True: 91, False: 3.85k] ------------------ 1615| 1.08k| case ASCII_3: ------------------ | | 95| 1.08k|#define ASCII_3 0x33 ------------------ | Branch (1615:7): [True: 212, False: 3.73k] ------------------ 1616| 1.16k| case ASCII_4: ------------------ | | 96| 1.16k|#define ASCII_4 0x34 ------------------ | Branch (1616:7): [True: 84, False: 3.86k] ------------------ 1617| 1.25k| case ASCII_5: ------------------ | | 97| 1.25k|#define ASCII_5 0x35 ------------------ | Branch (1617:7): [True: 90, False: 3.85k] ------------------ 1618| 1.33k| case ASCII_6: ------------------ | | 98| 1.33k|#define ASCII_6 0x36 ------------------ | Branch (1618:7): [True: 76, False: 3.86k] ------------------ 1619| 1.40k| case ASCII_7: ------------------ | | 99| 1.40k|#define ASCII_7 0x37 ------------------ | Branch (1619:7): [True: 76, False: 3.86k] ------------------ 1620| 1.61k| case ASCII_8: ------------------ | | 100| 1.61k|#define ASCII_8 0x38 ------------------ | Branch (1620:7): [True: 213, False: 3.73k] ------------------ 1621| 1.74k| case ASCII_9: ------------------ | | 101| 1.74k|#define ASCII_9 0x39 ------------------ | Branch (1621:7): [True: 122, False: 3.82k] ------------------ 1622| 1.74k| result <<= 4; 1623| 1.74k| result |= (c - ASCII_0); ------------------ | | 92| 1.74k|#define ASCII_0 0x30 ------------------ 1624| 1.74k| break; 1625| 78| case ASCII_A: ------------------ | | 38| 78|#define ASCII_A 0x41 ------------------ | Branch (1625:7): [True: 78, False: 3.86k] ------------------ 1626| 156| case ASCII_B: ------------------ | | 39| 156|#define ASCII_B 0x42 ------------------ | Branch (1626:7): [True: 78, False: 3.86k] ------------------ 1627| 357| case ASCII_C: ------------------ | | 40| 357|#define ASCII_C 0x43 ------------------ | Branch (1627:7): [True: 201, False: 3.74k] ------------------ 1628| 451| case ASCII_D: ------------------ | | 41| 451|#define ASCII_D 0x44 ------------------ | Branch (1628:7): [True: 94, False: 3.85k] ------------------ 1629| 548| case ASCII_E: ------------------ | | 42| 548|#define ASCII_E 0x45 ------------------ | Branch (1629:7): [True: 97, False: 3.84k] ------------------ 1630| 829| case ASCII_F: ------------------ | | 43| 829|#define ASCII_F 0x46 ------------------ | Branch (1630:7): [True: 281, False: 3.66k] ------------------ 1631| 829| result <<= 4; 1632| 829| result += 10 + (c - ASCII_A); ------------------ | | 38| 829|#define ASCII_A 0x41 ------------------ 1633| 829| break; 1634| 98| case ASCII_a: ------------------ | | 65| 98|#define ASCII_a 0x61 ------------------ | Branch (1634:7): [True: 98, False: 3.84k] ------------------ 1635| 173| case ASCII_b: ------------------ | | 66| 173|#define ASCII_b 0x62 ------------------ | Branch (1635:7): [True: 75, False: 3.86k] ------------------ 1636| 376| case ASCII_c: ------------------ | | 67| 376|#define ASCII_c 0x63 ------------------ | Branch (1636:7): [True: 203, False: 3.74k] ------------------ 1637| 682| case ASCII_d: ------------------ | | 68| 682|#define ASCII_d 0x64 ------------------ | Branch (1637:7): [True: 306, False: 3.63k] ------------------ 1638| 1.01k| case ASCII_e: ------------------ | | 69| 1.01k|#define ASCII_e 0x65 ------------------ | Branch (1638:7): [True: 335, False: 3.60k] ------------------ 1639| 1.37k| case ASCII_f: ------------------ | | 70| 1.37k|#define ASCII_f 0x66 ------------------ | Branch (1639:7): [True: 357, False: 3.58k] ------------------ 1640| 1.37k| result <<= 4; 1641| 1.37k| result += 10 + (c - ASCII_a); ------------------ | | 65| 1.37k|#define ASCII_a 0x61 ------------------ 1642| 1.37k| break; 1643| 3.94k| } 1644| 3.94k| if (result >= 0x110000) ------------------ | Branch (1644:11): [True: 3, False: 3.94k] ------------------ 1645| 3| return -1; 1646| 3.94k| } 1647| 934| } else { 1648| 963| for (; ! CHAR_MATCHES(enc, ptr, ASCII_SEMI); ptr += MINBPC(enc)) { ------------------ | | 702| 963|#define CHAR_MATCHES(enc, p, c) LITTLE2_CHAR_MATCHES(p, c) | | ------------------ | | | | 685| 963|#define LITTLE2_CHAR_MATCHES(p, c) ((p)[1] == 0 && (p)[0] == (c)) | | | | ------------------ | | | | | Branch (685:37): [True: 963, False: 0] | | | | | Branch (685:52): [True: 253, False: 710] | | | | ------------------ | | ------------------ ------------------ for (; ! CHAR_MATCHES(enc, ptr, ASCII_SEMI); ptr += MINBPC(enc)) { ------------------ | | 698| 709|#define MINBPC(enc) 2 ------------------ 1649| 710| int c = BYTE_TO_ASCII(enc, ptr); ------------------ | | 701| 710|#define BYTE_TO_ASCII(enc, p) LITTLE2_BYTE_TO_ASCII(p) | | ------------------ | | | | 684| 710|#define LITTLE2_BYTE_TO_ASCII(p) ((p)[1] == 0 ? (p)[0] : -1) | | | | ------------------ | | | | | Branch (684:35): [True: 710, False: 0] | | | | ------------------ | | ------------------ ------------------ 1650| 710| result *= 10; 1651| 710| result += (c - ASCII_0); ------------------ | | 92| 710|#define ASCII_0 0x30 ------------------ 1652| 710| if (result >= 0x110000) ------------------ | Branch (1652:11): [True: 1, False: 709] ------------------ 1653| 1| return -1; 1654| 710| } 1655| 254| } 1656| 1.18k| return checkCharRefNumber(result); 1657| 1.18k|} xmltok.c:little2_predefinedEntityName: 1661| 636| const char *end) { 1662| 636| UNUSED_P(enc); ------------------ | | 101| 636|# define UNUSED_P(p) (void)p ------------------ 1663| 636| switch ((end - ptr) / MINBPC(enc)) { ------------------ | | 698| 636|#define MINBPC(enc) 2 ------------------ | Branch (1663:11): [True: 607, False: 29] ------------------ 1664| 230| case 2: ------------------ | Branch (1664:3): [True: 230, False: 406] ------------------ 1665| 230| if (CHAR_MATCHES(enc, ptr + MINBPC(enc), ASCII_t)) { ------------------ | | 702| 230|#define CHAR_MATCHES(enc, p, c) LITTLE2_CHAR_MATCHES(p, c) | | ------------------ | | | | 685| 230|#define LITTLE2_CHAR_MATCHES(p, c) ((p)[1] == 0 && (p)[0] == (c)) | | | | ------------------ | | | | | Branch (685:37): [True: 227, False: 3] | | | | | Branch (685:52): [True: 225, False: 2] | | | | ------------------ | | ------------------ ------------------ 1666| 225| switch (BYTE_TO_ASCII(enc, ptr)) { ------------------ | | 701| 225|#define BYTE_TO_ASCII(enc, p) LITTLE2_BYTE_TO_ASCII(p) | | ------------------ | | | | 684| 225|#define LITTLE2_BYTE_TO_ASCII(p) ((p)[1] == 0 ? (p)[0] : -1) | | | | ------------------ | | | | | Branch (684:34): [True: 206, False: 19] | | | | | Branch (684:35): [True: 224, False: 1] | | | | ------------------ | | ------------------ ------------------ 1667| 173| case ASCII_l: ------------------ | | 76| 173|#define ASCII_l 0x6C ------------------ | Branch (1667:7): [True: 173, False: 52] ------------------ 1668| 173| return ASCII_LT; ------------------ | | 113| 173|#define ASCII_LT 0x3C ------------------ 1669| 33| case ASCII_g: ------------------ | | 71| 33|#define ASCII_g 0x67 ------------------ | Branch (1669:7): [True: 33, False: 192] ------------------ 1670| 33| return ASCII_GT; ------------------ | | 115| 33|#define ASCII_GT 0x3E ------------------ 1671| 225| } 1672| 225| } 1673| 24| break; 1674| 177| case 3: ------------------ | Branch (1674:3): [True: 177, False: 459] ------------------ 1675| 177| if (CHAR_MATCHES(enc, ptr, ASCII_a)) { ------------------ | | 702| 177|#define CHAR_MATCHES(enc, p, c) LITTLE2_CHAR_MATCHES(p, c) | | ------------------ | | | | 685| 177|#define LITTLE2_CHAR_MATCHES(p, c) ((p)[1] == 0 && (p)[0] == (c)) | | | | ------------------ | | | | | Branch (685:37): [True: 176, False: 1] | | | | | Branch (685:52): [True: 168, False: 8] | | | | ------------------ | | ------------------ ------------------ 1676| 168| ptr += MINBPC(enc); ------------------ | | 698| 168|#define MINBPC(enc) 2 ------------------ 1677| 168| if (CHAR_MATCHES(enc, ptr, ASCII_m)) { ------------------ | | 702| 168|#define CHAR_MATCHES(enc, p, c) LITTLE2_CHAR_MATCHES(p, c) | | ------------------ | | | | 685| 168|#define LITTLE2_CHAR_MATCHES(p, c) ((p)[1] == 0 && (p)[0] == (c)) | | | | ------------------ | | | | | Branch (685:37): [True: 165, False: 3] | | | | | Branch (685:52): [True: 160, False: 5] | | | | ------------------ | | ------------------ ------------------ 1678| 160| ptr += MINBPC(enc); ------------------ | | 698| 160|#define MINBPC(enc) 2 ------------------ 1679| 160| if (CHAR_MATCHES(enc, ptr, ASCII_p)) ------------------ | | 702| 160|#define CHAR_MATCHES(enc, p, c) LITTLE2_CHAR_MATCHES(p, c) | | ------------------ | | | | 685| 160|#define LITTLE2_CHAR_MATCHES(p, c) ((p)[1] == 0 && (p)[0] == (c)) | | | | ------------------ | | | | | Branch (685:37): [True: 157, False: 3] | | | | | Branch (685:52): [True: 155, False: 2] | | | | ------------------ | | ------------------ ------------------ 1680| 155| return ASCII_AMP; ------------------ | | 107| 155|#define ASCII_AMP 0x26 ------------------ 1681| 160| } 1682| 168| } 1683| 22| break; 1684| 200| case 4: ------------------ | Branch (1684:3): [True: 200, False: 436] ------------------ 1685| 200| switch (BYTE_TO_ASCII(enc, ptr)) { ------------------ | | 701| 200|#define BYTE_TO_ASCII(enc, p) LITTLE2_BYTE_TO_ASCII(p) | | ------------------ | | | | 684| 200|#define LITTLE2_BYTE_TO_ASCII(p) ((p)[1] == 0 ? (p)[0] : -1) | | | | ------------------ | | | | | Branch (684:34): [True: 193, False: 7] | | | | | Branch (684:35): [True: 194, False: 6] | | | | ------------------ | | ------------------ ------------------ 1686| 97| case ASCII_q: ------------------ | | 81| 97|#define ASCII_q 0x71 ------------------ | Branch (1686:5): [True: 97, False: 103] ------------------ 1687| 97| ptr += MINBPC(enc); ------------------ | | 698| 97|#define MINBPC(enc) 2 ------------------ 1688| 97| if (CHAR_MATCHES(enc, ptr, ASCII_u)) { ------------------ | | 702| 97|#define CHAR_MATCHES(enc, p, c) LITTLE2_CHAR_MATCHES(p, c) | | ------------------ | | | | 685| 97|#define LITTLE2_CHAR_MATCHES(p, c) ((p)[1] == 0 && (p)[0] == (c)) | | | | ------------------ | | | | | Branch (685:37): [True: 95, False: 2] | | | | | Branch (685:52): [True: 87, False: 8] | | | | ------------------ | | ------------------ ------------------ 1689| 87| ptr += MINBPC(enc); ------------------ | | 698| 87|#define MINBPC(enc) 2 ------------------ 1690| 87| if (CHAR_MATCHES(enc, ptr, ASCII_o)) { ------------------ | | 702| 87|#define CHAR_MATCHES(enc, p, c) LITTLE2_CHAR_MATCHES(p, c) | | ------------------ | | | | 685| 87|#define LITTLE2_CHAR_MATCHES(p, c) ((p)[1] == 0 && (p)[0] == (c)) | | | | ------------------ | | | | | Branch (685:37): [True: 86, False: 1] | | | | | Branch (685:52): [True: 84, False: 2] | | | | ------------------ | | ------------------ ------------------ 1691| 84| ptr += MINBPC(enc); ------------------ | | 698| 84|#define MINBPC(enc) 2 ------------------ 1692| 84| if (CHAR_MATCHES(enc, ptr, ASCII_t)) ------------------ | | 702| 84|#define CHAR_MATCHES(enc, p, c) LITTLE2_CHAR_MATCHES(p, c) | | ------------------ | | | | 685| 84|#define LITTLE2_CHAR_MATCHES(p, c) ((p)[1] == 0 && (p)[0] == (c)) | | | | ------------------ | | | | | Branch (685:37): [True: 77, False: 7] | | | | | Branch (685:52): [True: 69, False: 8] | | | | ------------------ | | ------------------ ------------------ 1693| 69| return ASCII_QUOT; ------------------ | | 106| 69|#define ASCII_QUOT 0x22 ------------------ 1694| 84| } 1695| 87| } 1696| 28| break; 1697| 96| case ASCII_a: ------------------ | | 65| 96|#define ASCII_a 0x61 ------------------ | Branch (1697:5): [True: 96, False: 104] ------------------ 1698| 96| ptr += MINBPC(enc); ------------------ | | 698| 96|#define MINBPC(enc) 2 ------------------ 1699| 96| if (CHAR_MATCHES(enc, ptr, ASCII_p)) { ------------------ | | 702| 96|#define CHAR_MATCHES(enc, p, c) LITTLE2_CHAR_MATCHES(p, c) | | ------------------ | | | | 685| 96|#define LITTLE2_CHAR_MATCHES(p, c) ((p)[1] == 0 && (p)[0] == (c)) | | | | ------------------ | | | | | Branch (685:37): [True: 92, False: 4] | | | | | Branch (685:52): [True: 85, False: 7] | | | | ------------------ | | ------------------ ------------------ 1700| 85| ptr += MINBPC(enc); ------------------ | | 698| 85|#define MINBPC(enc) 2 ------------------ 1701| 85| if (CHAR_MATCHES(enc, ptr, ASCII_o)) { ------------------ | | 702| 85|#define CHAR_MATCHES(enc, p, c) LITTLE2_CHAR_MATCHES(p, c) | | ------------------ | | | | 685| 85|#define LITTLE2_CHAR_MATCHES(p, c) ((p)[1] == 0 && (p)[0] == (c)) | | | | ------------------ | | | | | Branch (685:37): [True: 78, False: 7] | | | | | Branch (685:52): [True: 73, False: 5] | | | | ------------------ | | ------------------ ------------------ 1702| 73| ptr += MINBPC(enc); ------------------ | | 698| 73|#define MINBPC(enc) 2 ------------------ 1703| 73| if (CHAR_MATCHES(enc, ptr, ASCII_s)) ------------------ | | 702| 73|#define CHAR_MATCHES(enc, p, c) LITTLE2_CHAR_MATCHES(p, c) | | ------------------ | | | | 685| 73|#define LITTLE2_CHAR_MATCHES(p, c) ((p)[1] == 0 && (p)[0] == (c)) | | | | ------------------ | | | | | Branch (685:37): [True: 72, False: 1] | | | | | Branch (685:52): [True: 66, False: 6] | | | | ------------------ | | ------------------ ------------------ 1704| 66| return ASCII_APOS; ------------------ | | 108| 66|#define ASCII_APOS 0x27 ------------------ 1705| 73| } 1706| 85| } 1707| 30| break; 1708| 200| } 1709| 636| } 1710| 140| return 0; 1711| 636|} xmltok.c:big2_prologTok: 1018| 25| const char **nextTokPtr) { 1019| 25| int tok; 1020| 25| if (ptr >= end) ------------------ | Branch (1020:7): [True: 0, False: 25] ------------------ 1021| 0| return XML_TOK_NONE; ------------------ | | 51| 0|# define XML_TOK_NONE -4 /* The string to be scanned is empty */ ------------------ 1022| 25| if (MINBPC(enc) > 1) { ------------------ | | 799| 25|#define MINBPC(enc) 2 ------------------ | Branch (1022:7): [True: 25, Folded] ------------------ 1023| 25| size_t n = end - ptr; 1024| 25| if (n & (MINBPC(enc) - 1)) { ------------------ | | 799| 25|#define MINBPC(enc) 2 ------------------ | Branch (1024:9): [True: 16, False: 9] ------------------ 1025| 16| n &= ~(MINBPC(enc) - 1); ------------------ | | 799| 16|#define MINBPC(enc) 2 ------------------ 1026| 16| if (n == 0) ------------------ | Branch (1026:11): [True: 0, False: 16] ------------------ 1027| 0| return XML_TOK_PARTIAL; ------------------ | | 56| 0|# define XML_TOK_PARTIAL -1 /* only part of a token */ ------------------ 1028| 16| end = ptr + n; 1029| 16| } 1030| 25| } 1031| 25| switch (BYTE_TYPE(enc, ptr)) { ------------------ | | 801| 25|#define BYTE_TYPE(enc, p) BIG2_BYTE_TYPE(enc, p) | | ------------------ | | | | 784| 25| ((p)[0] == 0 ? SB_BYTE_TYPE(enc, p + 1) : unicode_byte_type((p)[0], (p)[1])) | | | | ------------------ | | | | | | 231| 0| (((const struct normal_encoding *)(enc))->type[(unsigned char)*(p)]) | | | | ------------------ | | | | | Branch (784:4): [True: 0, False: 25] | | | | ------------------ | | ------------------ ------------------ 1032| 0| case BT_QUOT: ------------------ | Branch (1032:3): [True: 0, False: 25] ------------------ 1033| 0| return PREFIX(scanLit)(BT_QUOT, enc, ptr + MINBPC(enc), end, nextTokPtr); ------------------ | | 798| 0|#define PREFIX(ident) big2_##ident ------------------ return PREFIX(scanLit)(BT_QUOT, enc, ptr + MINBPC(enc), end, nextTokPtr); ------------------ | | 799| 0|#define MINBPC(enc) 2 ------------------ 1034| 0| case BT_APOS: ------------------ | Branch (1034:3): [True: 0, False: 25] ------------------ 1035| 0| return PREFIX(scanLit)(BT_APOS, enc, ptr + MINBPC(enc), end, nextTokPtr); ------------------ | | 798| 0|#define PREFIX(ident) big2_##ident ------------------ return PREFIX(scanLit)(BT_APOS, enc, ptr + MINBPC(enc), end, nextTokPtr); ------------------ | | 799| 0|#define MINBPC(enc) 2 ------------------ 1036| 0| case BT_LT: { ------------------ | Branch (1036:3): [True: 0, False: 25] ------------------ 1037| 0| ptr += MINBPC(enc); ------------------ | | 799| 0|#define MINBPC(enc) 2 ------------------ 1038| 0| REQUIRE_CHAR(enc, ptr, end); ------------------ | | 140| 0|# define REQUIRE_CHAR(enc, ptr, end) REQUIRE_CHARS(enc, ptr, end, 1) | | ------------------ | | | | 134| 0| { \ | | | | 135| 0| if (! HAS_CHARS(enc, ptr, end, count)) { \ | | | | ------------------ | | | | | | 129| 0| ((end) - (ptr) >= ((count) * MINBPC(enc))) | | | | | | ------------------ | | | | | | | | 799| 0|#define MINBPC(enc) 2 | | | | | | ------------------ | | | | ------------------ | | | | | Branch (135:11): [True: 0, False: 0] | | | | ------------------ | | | | 136| 0| return XML_TOK_PARTIAL; \ | | | | ------------------ | | | | | | 56| 0|# define XML_TOK_PARTIAL -1 /* only part of a token */ | | | | ------------------ | | | | 137| 0| } \ | | | | 138| 0| } | | ------------------ ------------------ 1039| 0| switch (BYTE_TYPE(enc, ptr)) { ------------------ | | 801| 0|#define BYTE_TYPE(enc, p) BIG2_BYTE_TYPE(enc, p) | | ------------------ | | | | 784| 0| ((p)[0] == 0 ? SB_BYTE_TYPE(enc, p + 1) : unicode_byte_type((p)[0], (p)[1])) | | | | ------------------ | | | | | | 231| 0| (((const struct normal_encoding *)(enc))->type[(unsigned char)*(p)]) | | | | ------------------ | | | | | Branch (784:3): [True: 0, False: 0] | | | | | Branch (784:4): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 1040| 0| case BT_EXCL: ------------------ | Branch (1040:5): [True: 0, False: 0] ------------------ 1041| 0| return PREFIX(scanDecl)(enc, ptr + MINBPC(enc), end, nextTokPtr); ------------------ | | 798| 0|#define PREFIX(ident) big2_##ident ------------------ return PREFIX(scanDecl)(enc, ptr + MINBPC(enc), end, nextTokPtr); ------------------ | | 799| 0|#define MINBPC(enc) 2 ------------------ 1042| 0| case BT_QUEST: ------------------ | Branch (1042:5): [True: 0, False: 0] ------------------ 1043| 0| return PREFIX(scanPi)(enc, ptr + MINBPC(enc), end, nextTokPtr); ------------------ | | 798| 0|#define PREFIX(ident) big2_##ident ------------------ return PREFIX(scanPi)(enc, ptr + MINBPC(enc), end, nextTokPtr); ------------------ | | 799| 0|#define MINBPC(enc) 2 ------------------ 1044| 0| case BT_NMSTRT: ------------------ | Branch (1044:5): [True: 0, False: 0] ------------------ 1045| 0| case BT_HEX: ------------------ | Branch (1045:5): [True: 0, False: 0] ------------------ 1046| 0| case BT_NONASCII: ------------------ | Branch (1046:5): [True: 0, False: 0] ------------------ 1047| 0| case BT_LEAD2: ------------------ | Branch (1047:5): [True: 0, False: 0] ------------------ 1048| 0| case BT_LEAD3: ------------------ | Branch (1048:5): [True: 0, False: 0] ------------------ 1049| 0| case BT_LEAD4: ------------------ | Branch (1049:5): [True: 0, False: 0] ------------------ 1050| 0| *nextTokPtr = ptr - MINBPC(enc); ------------------ | | 799| 0|#define MINBPC(enc) 2 ------------------ 1051| 0| return XML_TOK_INSTANCE_START; ------------------ | | 96| 0|# define XML_TOK_INSTANCE_START 29 ------------------ 1052| 0| } 1053| 0| *nextTokPtr = ptr; 1054| 0| return XML_TOK_INVALID; ------------------ | | 57| 0|# define XML_TOK_INVALID 0 ------------------ 1055| 0| } 1056| 0| case BT_CR: ------------------ | Branch (1056:3): [True: 0, False: 25] ------------------ 1057| 0| if (ptr + MINBPC(enc) == end) { ------------------ | | 799| 0|#define MINBPC(enc) 2 ------------------ | Branch (1057:9): [True: 0, False: 0] ------------------ 1058| 0| *nextTokPtr = end; 1059| | /* indicate that this might be part of a CR/LF pair */ 1060| 0| return -XML_TOK_PROLOG_S; ------------------ | | 82| 0|# define XML_TOK_PROLOG_S 15 ------------------ 1061| 0| } 1062| 0| EXPAT_FALLTHROUGH; ------------------ | | 47| 0|# define EXPAT_FALLTHROUGH __attribute__((fallthrough)) ------------------ 1063| 0| case BT_S: ------------------ | Branch (1063:3): [True: 0, False: 25] ------------------ 1064| 0| case BT_LF: ------------------ | Branch (1064:3): [True: 0, False: 25] ------------------ 1065| 0| for (;;) { 1066| 0| ptr += MINBPC(enc); ------------------ | | 799| 0|#define MINBPC(enc) 2 ------------------ 1067| 0| if (! HAS_CHAR(enc, ptr, end)) ------------------ | | 131| 0|# define HAS_CHAR(enc, ptr, end) HAS_CHARS(enc, ptr, end, 1) | | ------------------ | | | | 129| 0| ((end) - (ptr) >= ((count) * MINBPC(enc))) | | | | ------------------ | | | | | | 799| 0|#define MINBPC(enc) 2 | | | | ------------------ | | ------------------ ------------------ | Branch (1067:11): [True: 0, False: 0] ------------------ 1068| 0| break; 1069| 0| switch (BYTE_TYPE(enc, ptr)) { ------------------ | | 801| 0|#define BYTE_TYPE(enc, p) BIG2_BYTE_TYPE(enc, p) | | ------------------ | | | | 784| 0| ((p)[0] == 0 ? SB_BYTE_TYPE(enc, p + 1) : unicode_byte_type((p)[0], (p)[1])) | | | | ------------------ | | | | | | 231| 0| (((const struct normal_encoding *)(enc))->type[(unsigned char)*(p)]) | | | | ------------------ | | | | | Branch (784:4): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 1070| 0| case BT_S: ------------------ | Branch (1070:7): [True: 0, False: 0] ------------------ 1071| 0| case BT_LF: ------------------ | Branch (1071:7): [True: 0, False: 0] ------------------ 1072| 0| break; 1073| 0| case BT_CR: ------------------ | Branch (1073:7): [True: 0, False: 0] ------------------ 1074| | /* don't split CR/LF pair */ 1075| 0| if (ptr + MINBPC(enc) != end) ------------------ | | 799| 0|#define MINBPC(enc) 2 ------------------ | Branch (1075:13): [True: 0, False: 0] ------------------ 1076| 0| break; 1077| 0| EXPAT_FALLTHROUGH; ------------------ | | 47| 0|# define EXPAT_FALLTHROUGH __attribute__((fallthrough)) ------------------ 1078| 0| default: ------------------ | Branch (1078:7): [True: 0, False: 0] ------------------ 1079| 0| *nextTokPtr = ptr; 1080| 0| return XML_TOK_PROLOG_S; ------------------ | | 82| 0|# define XML_TOK_PROLOG_S 15 ------------------ 1081| 0| } 1082| 0| } 1083| 0| *nextTokPtr = ptr; 1084| 0| return XML_TOK_PROLOG_S; ------------------ | | 82| 0|# define XML_TOK_PROLOG_S 15 ------------------ 1085| 0| case BT_PERCNT: ------------------ | Branch (1085:3): [True: 0, False: 25] ------------------ 1086| 0| return PREFIX(scanPercent)(enc, ptr + MINBPC(enc), end, nextTokPtr); ------------------ | | 798| 0|#define PREFIX(ident) big2_##ident ------------------ return PREFIX(scanPercent)(enc, ptr + MINBPC(enc), end, nextTokPtr); ------------------ | | 799| 0|#define MINBPC(enc) 2 ------------------ 1087| 0| case BT_COMMA: ------------------ | Branch (1087:3): [True: 0, False: 25] ------------------ 1088| 0| *nextTokPtr = ptr + MINBPC(enc); ------------------ | | 799| 0|#define MINBPC(enc) 2 ------------------ 1089| 0| return XML_TOK_COMMA; ------------------ | | 107| 0|# define XML_TOK_COMMA 38 ------------------ 1090| 0| case BT_LSQB: ------------------ | Branch (1090:3): [True: 0, False: 25] ------------------ 1091| 0| *nextTokPtr = ptr + MINBPC(enc); ------------------ | | 799| 0|#define MINBPC(enc) 2 ------------------ 1092| 0| return XML_TOK_OPEN_BRACKET; ------------------ | | 92| 0|# define XML_TOK_OPEN_BRACKET 25 ------------------ 1093| 0| case BT_RSQB: ------------------ | Branch (1093:3): [True: 0, False: 25] ------------------ 1094| 0| ptr += MINBPC(enc); ------------------ | | 799| 0|#define MINBPC(enc) 2 ------------------ 1095| 0| if (! HAS_CHAR(enc, ptr, end)) ------------------ | | 131| 0|# define HAS_CHAR(enc, ptr, end) HAS_CHARS(enc, ptr, end, 1) | | ------------------ | | | | 129| 0| ((end) - (ptr) >= ((count) * MINBPC(enc))) | | | | ------------------ | | | | | | 799| 0|#define MINBPC(enc) 2 | | | | ------------------ | | ------------------ ------------------ | Branch (1095:9): [True: 0, False: 0] ------------------ 1096| 0| return -XML_TOK_CLOSE_BRACKET; ------------------ | | 93| 0|# define XML_TOK_CLOSE_BRACKET 26 ------------------ 1097| 0| if (CHAR_MATCHES(enc, ptr, ASCII_RSQB)) { ------------------ | | 803| 0|#define CHAR_MATCHES(enc, p, c) BIG2_CHAR_MATCHES(p, c) | | ------------------ | | | | 786| 0|#define BIG2_CHAR_MATCHES(p, c) ((p)[0] == 0 && (p)[1] == (c)) | | | | ------------------ | | | | | Branch (786:34): [True: 0, False: 0] | | | | | Branch (786:49): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 1098| 0| REQUIRE_CHARS(enc, ptr, end, 2); ------------------ | | 134| 0| { \ | | 135| 0| if (! HAS_CHARS(enc, ptr, end, count)) { \ | | ------------------ | | | | 129| 0| ((end) - (ptr) >= ((count) * MINBPC(enc))) | | | | ------------------ | | | | | | 799| 0|#define MINBPC(enc) 2 | | | | ------------------ | | ------------------ | | | Branch (135:11): [True: 0, False: 0] | | ------------------ | | 136| 0| return XML_TOK_PARTIAL; \ | | ------------------ | | | | 56| 0|# define XML_TOK_PARTIAL -1 /* only part of a token */ | | ------------------ | | 137| 0| } \ | | 138| 0| } ------------------ 1099| 0| if (CHAR_MATCHES(enc, ptr + MINBPC(enc), ASCII_GT)) { ------------------ | | 803| 0|#define CHAR_MATCHES(enc, p, c) BIG2_CHAR_MATCHES(p, c) | | ------------------ | | | | 786| 0|#define BIG2_CHAR_MATCHES(p, c) ((p)[0] == 0 && (p)[1] == (c)) | | | | ------------------ | | | | | Branch (786:34): [True: 0, False: 0] | | | | | Branch (786:49): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 1100| 0| *nextTokPtr = ptr + 2 * MINBPC(enc); ------------------ | | 799| 0|#define MINBPC(enc) 2 ------------------ 1101| 0| return XML_TOK_COND_SECT_CLOSE; ------------------ | | 103| 0|# define XML_TOK_COND_SECT_CLOSE 34 /* ]]> */ ------------------ 1102| 0| } 1103| 0| } 1104| 0| *nextTokPtr = ptr; 1105| 0| return XML_TOK_CLOSE_BRACKET; ------------------ | | 93| 0|# define XML_TOK_CLOSE_BRACKET 26 ------------------ 1106| 0| case BT_LPAR: ------------------ | Branch (1106:3): [True: 0, False: 25] ------------------ 1107| 0| *nextTokPtr = ptr + MINBPC(enc); ------------------ | | 799| 0|#define MINBPC(enc) 2 ------------------ 1108| 0| return XML_TOK_OPEN_PAREN; ------------------ | | 90| 0|# define XML_TOK_OPEN_PAREN 23 ------------------ 1109| 0| case BT_RPAR: ------------------ | Branch (1109:3): [True: 0, False: 25] ------------------ 1110| 0| ptr += MINBPC(enc); ------------------ | | 799| 0|#define MINBPC(enc) 2 ------------------ 1111| 0| if (! HAS_CHAR(enc, ptr, end)) ------------------ | | 131| 0|# define HAS_CHAR(enc, ptr, end) HAS_CHARS(enc, ptr, end, 1) | | ------------------ | | | | 129| 0| ((end) - (ptr) >= ((count) * MINBPC(enc))) | | | | ------------------ | | | | | | 799| 0|#define MINBPC(enc) 2 | | | | ------------------ | | ------------------ ------------------ | Branch (1111:9): [True: 0, False: 0] ------------------ 1112| 0| return -XML_TOK_CLOSE_PAREN; ------------------ | | 91| 0|# define XML_TOK_CLOSE_PAREN 24 ------------------ 1113| 0| switch (BYTE_TYPE(enc, ptr)) { ------------------ | | 801| 0|#define BYTE_TYPE(enc, p) BIG2_BYTE_TYPE(enc, p) | | ------------------ | | | | 784| 0| ((p)[0] == 0 ? SB_BYTE_TYPE(enc, p + 1) : unicode_byte_type((p)[0], (p)[1])) | | | | ------------------ | | | | | | 231| 0| (((const struct normal_encoding *)(enc))->type[(unsigned char)*(p)]) | | | | ------------------ | | | | | Branch (784:3): [True: 0, False: 0] | | | | | Branch (784:4): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 1114| 0| case BT_AST: ------------------ | Branch (1114:5): [True: 0, False: 0] ------------------ 1115| 0| *nextTokPtr = ptr + MINBPC(enc); ------------------ | | 799| 0|#define MINBPC(enc) 2 ------------------ 1116| 0| return XML_TOK_CLOSE_PAREN_ASTERISK; ------------------ | | 105| 0|# define XML_TOK_CLOSE_PAREN_ASTERISK 36 /* )* */ ------------------ 1117| 0| case BT_QUEST: ------------------ | Branch (1117:5): [True: 0, False: 0] ------------------ 1118| 0| *nextTokPtr = ptr + MINBPC(enc); ------------------ | | 799| 0|#define MINBPC(enc) 2 ------------------ 1119| 0| return XML_TOK_CLOSE_PAREN_QUESTION; ------------------ | | 104| 0|# define XML_TOK_CLOSE_PAREN_QUESTION 35 /* )? */ ------------------ 1120| 0| case BT_PLUS: ------------------ | Branch (1120:5): [True: 0, False: 0] ------------------ 1121| 0| *nextTokPtr = ptr + MINBPC(enc); ------------------ | | 799| 0|#define MINBPC(enc) 2 ------------------ 1122| 0| return XML_TOK_CLOSE_PAREN_PLUS; ------------------ | | 106| 0|# define XML_TOK_CLOSE_PAREN_PLUS 37 /* )+ */ ------------------ 1123| 0| case BT_CR: ------------------ | Branch (1123:5): [True: 0, False: 0] ------------------ 1124| 0| case BT_LF: ------------------ | Branch (1124:5): [True: 0, False: 0] ------------------ 1125| 0| case BT_S: ------------------ | Branch (1125:5): [True: 0, False: 0] ------------------ 1126| 0| case BT_GT: ------------------ | Branch (1126:5): [True: 0, False: 0] ------------------ 1127| 0| case BT_COMMA: ------------------ | Branch (1127:5): [True: 0, False: 0] ------------------ 1128| 0| case BT_VERBAR: ------------------ | Branch (1128:5): [True: 0, False: 0] ------------------ 1129| 0| case BT_RPAR: ------------------ | Branch (1129:5): [True: 0, False: 0] ------------------ 1130| 0| *nextTokPtr = ptr; 1131| 0| return XML_TOK_CLOSE_PAREN; ------------------ | | 91| 0|# define XML_TOK_CLOSE_PAREN 24 ------------------ 1132| 0| } 1133| 0| *nextTokPtr = ptr; 1134| 0| return XML_TOK_INVALID; ------------------ | | 57| 0|# define XML_TOK_INVALID 0 ------------------ 1135| 0| case BT_VERBAR: ------------------ | Branch (1135:3): [True: 0, False: 25] ------------------ 1136| 0| *nextTokPtr = ptr + MINBPC(enc); ------------------ | | 799| 0|#define MINBPC(enc) 2 ------------------ 1137| 0| return XML_TOK_OR; ------------------ | | 88| 0|# define XML_TOK_OR 21 /* | */ ------------------ 1138| 0| case BT_GT: ------------------ | Branch (1138:3): [True: 0, False: 25] ------------------ 1139| 0| *nextTokPtr = ptr + MINBPC(enc); ------------------ | | 799| 0|#define MINBPC(enc) 2 ------------------ 1140| 0| return XML_TOK_DECL_CLOSE; ------------------ | | 84| 0|# define XML_TOK_DECL_CLOSE 17 /* > */ ------------------ 1141| 0| case BT_NUM: ------------------ | Branch (1141:3): [True: 0, False: 25] ------------------ 1142| 0| return PREFIX(scanPoundName)(enc, ptr + MINBPC(enc), end, nextTokPtr); ------------------ | | 798| 0|#define PREFIX(ident) big2_##ident ------------------ return PREFIX(scanPoundName)(enc, ptr + MINBPC(enc), end, nextTokPtr); ------------------ | | 799| 0|#define MINBPC(enc) 2 ------------------ 1143| 0|# define LEAD_CASE(n) \ 1144| 0| case BT_LEAD##n: \ 1145| 0| if (end - ptr < n) \ 1146| 0| return XML_TOK_PARTIAL_CHAR; \ 1147| 0| if (IS_INVALID_CHAR(enc, ptr, n)) { \ 1148| 0| *nextTokPtr = ptr; \ 1149| 0| return XML_TOK_INVALID; \ 1150| 0| } \ 1151| 0| if (IS_NMSTRT_CHAR(enc, ptr, n)) { \ 1152| 0| ptr += n; \ 1153| 0| tok = XML_TOK_NAME; \ 1154| 0| break; \ 1155| 0| } \ 1156| 0| if (IS_NAME_CHAR(enc, ptr, n)) { \ 1157| 0| ptr += n; \ 1158| 0| tok = XML_TOK_NMTOKEN; \ 1159| 0| break; \ 1160| 0| } \ 1161| 0| *nextTokPtr = ptr; \ 1162| 0| return XML_TOK_INVALID; 1163| 0| LEAD_CASE(2) ------------------ | | 1144| 0| case BT_LEAD##n: \ | | ------------------ | | | Branch (1144:3): [True: 0, False: 25] | | ------------------ | | 1145| 0| if (end - ptr < n) \ | | ------------------ | | | Branch (1145:9): [True: 0, False: 0] | | ------------------ | | 1146| 0| return XML_TOK_PARTIAL_CHAR; \ | | ------------------ | | | | 55| 0|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | ------------------ | | 1147| 0| if (IS_INVALID_CHAR(enc, ptr, n)) { \ | | ------------------ | | | | 808| 0|#define IS_INVALID_CHAR(enc, p, n) BIG2_IS_INVALID_CHAR(p, n) | | | | ------------------ | | | | | | 795| 0| ((n) == 4 && ((unsigned char)(p)[2] & 0xFC) != 0xDC) | | | | | | ------------------ | | | | | | | Branch (795:4): [Folded, False: 0] | | | | | | | Branch (795:16): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1148| 0| *nextTokPtr = ptr; \ | | 1149| 0| return XML_TOK_INVALID; \ | | ------------------ | | | | 57| 0|# define XML_TOK_INVALID 0 | | ------------------ | | 1150| 0| } \ | | 1151| 0| if (IS_NMSTRT_CHAR(enc, ptr, n)) { \ | | ------------------ | | | | 806| 0|#define IS_NMSTRT_CHAR(enc, p, n) (0) | | | | ------------------ | | | | | Branch (806:35): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 1152| 0| ptr += n; \ | | 1153| 0| tok = XML_TOK_NAME; \ | | ------------------ | | | | 85| 0|# define XML_TOK_NAME 18 | | ------------------ | | 1154| 0| break; \ | | 1155| 0| } \ | | 1156| 0| if (IS_NAME_CHAR(enc, ptr, n)) { \ | | ------------------ | | | | 804| 0|#define IS_NAME_CHAR(enc, p, n) 0 | | | | ------------------ | | | | | Branch (804:33): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 1157| 0| ptr += n; \ | | 1158| 0| tok = XML_TOK_NMTOKEN; \ | | ------------------ | | | | 86| 0|# define XML_TOK_NMTOKEN 19 | | ------------------ | | 1159| 0| break; \ | | 1160| 0| } \ | | 1161| 0| *nextTokPtr = ptr; \ | | 1162| 0| return XML_TOK_INVALID; | | ------------------ | | | | 57| 0|# define XML_TOK_INVALID 0 | | ------------------ ------------------ 1164| 0| LEAD_CASE(3) ------------------ | | 1144| 0| case BT_LEAD##n: \ | | ------------------ | | | Branch (1144:3): [True: 0, False: 25] | | ------------------ | | 1145| 0| if (end - ptr < n) \ | | ------------------ | | | Branch (1145:9): [True: 0, False: 0] | | ------------------ | | 1146| 0| return XML_TOK_PARTIAL_CHAR; \ | | ------------------ | | | | 55| 0|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | ------------------ | | 1147| 0| if (IS_INVALID_CHAR(enc, ptr, n)) { \ | | ------------------ | | | | 808| 0|#define IS_INVALID_CHAR(enc, p, n) BIG2_IS_INVALID_CHAR(p, n) | | | | ------------------ | | | | | | 795| 0| ((n) == 4 && ((unsigned char)(p)[2] & 0xFC) != 0xDC) | | | | | | ------------------ | | | | | | | Branch (795:4): [Folded, False: 0] | | | | | | | Branch (795:16): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1148| 0| *nextTokPtr = ptr; \ | | 1149| 0| return XML_TOK_INVALID; \ | | ------------------ | | | | 57| 0|# define XML_TOK_INVALID 0 | | ------------------ | | 1150| 0| } \ | | 1151| 0| if (IS_NMSTRT_CHAR(enc, ptr, n)) { \ | | ------------------ | | | | 806| 0|#define IS_NMSTRT_CHAR(enc, p, n) (0) | | | | ------------------ | | | | | Branch (806:35): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 1152| 0| ptr += n; \ | | 1153| 0| tok = XML_TOK_NAME; \ | | ------------------ | | | | 85| 0|# define XML_TOK_NAME 18 | | ------------------ | | 1154| 0| break; \ | | 1155| 0| } \ | | 1156| 0| if (IS_NAME_CHAR(enc, ptr, n)) { \ | | ------------------ | | | | 804| 0|#define IS_NAME_CHAR(enc, p, n) 0 | | | | ------------------ | | | | | Branch (804:33): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 1157| 0| ptr += n; \ | | 1158| 0| tok = XML_TOK_NMTOKEN; \ | | ------------------ | | | | 86| 0|# define XML_TOK_NMTOKEN 19 | | ------------------ | | 1159| 0| break; \ | | 1160| 0| } \ | | 1161| 0| *nextTokPtr = ptr; \ | | 1162| 0| return XML_TOK_INVALID; | | ------------------ | | | | 57| 0|# define XML_TOK_INVALID 0 | | ------------------ ------------------ 1165| 0| LEAD_CASE(4) ------------------ | | 1144| 0| case BT_LEAD##n: \ | | ------------------ | | | Branch (1144:3): [True: 0, False: 25] | | ------------------ | | 1145| 0| if (end - ptr < n) \ | | ------------------ | | | Branch (1145:9): [True: 0, False: 0] | | ------------------ | | 1146| 0| return XML_TOK_PARTIAL_CHAR; \ | | ------------------ | | | | 55| 0|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | ------------------ | | 1147| 0| if (IS_INVALID_CHAR(enc, ptr, n)) { \ | | ------------------ | | | | 808| 0|#define IS_INVALID_CHAR(enc, p, n) BIG2_IS_INVALID_CHAR(p, n) | | | | ------------------ | | | | | | 795| 0| ((n) == 4 && ((unsigned char)(p)[2] & 0xFC) != 0xDC) | | | | | | ------------------ | | | | | | | Branch (795:4): [True: 0, Folded] | | | | | | | Branch (795:16): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1148| 0| *nextTokPtr = ptr; \ | | 1149| 0| return XML_TOK_INVALID; \ | | ------------------ | | | | 57| 0|# define XML_TOK_INVALID 0 | | ------------------ | | 1150| 0| } \ | | 1151| 0| if (IS_NMSTRT_CHAR(enc, ptr, n)) { \ | | ------------------ | | | | 806| 0|#define IS_NMSTRT_CHAR(enc, p, n) (0) | | | | ------------------ | | | | | Branch (806:35): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 1152| 0| ptr += n; \ | | 1153| 0| tok = XML_TOK_NAME; \ | | ------------------ | | | | 85| 0|# define XML_TOK_NAME 18 | | ------------------ | | 1154| 0| break; \ | | 1155| 0| } \ | | 1156| 0| if (IS_NAME_CHAR(enc, ptr, n)) { \ | | ------------------ | | | | 804| 0|#define IS_NAME_CHAR(enc, p, n) 0 | | | | ------------------ | | | | | Branch (804:33): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 1157| 0| ptr += n; \ | | 1158| 0| tok = XML_TOK_NMTOKEN; \ | | ------------------ | | | | 86| 0|# define XML_TOK_NMTOKEN 19 | | ------------------ | | 1159| 0| break; \ | | 1160| 0| } \ | | 1161| 0| *nextTokPtr = ptr; \ | | 1162| 0| return XML_TOK_INVALID; | | ------------------ | | | | 57| 0|# define XML_TOK_INVALID 0 | | ------------------ ------------------ 1166| 0|# undef LEAD_CASE 1167| 0| case BT_NMSTRT: ------------------ | Branch (1167:3): [True: 0, False: 25] ------------------ 1168| 0| case BT_HEX: ------------------ | Branch (1168:3): [True: 0, False: 25] ------------------ 1169| 0| tok = XML_TOK_NAME; ------------------ | | 85| 0|# define XML_TOK_NAME 18 ------------------ 1170| 0| ptr += MINBPC(enc); ------------------ | | 799| 0|#define MINBPC(enc) 2 ------------------ 1171| 0| break; 1172| 0| case BT_DIGIT: ------------------ | Branch (1172:3): [True: 0, False: 25] ------------------ 1173| 0| case BT_NAME: ------------------ | Branch (1173:3): [True: 0, False: 25] ------------------ 1174| 0| case BT_MINUS: ------------------ | Branch (1174:3): [True: 0, False: 25] ------------------ 1175| 0|# ifdef XML_NS 1176| 0| case BT_COLON: ------------------ | Branch (1176:3): [True: 0, False: 25] ------------------ 1177| 0|# endif 1178| 0| tok = XML_TOK_NMTOKEN; ------------------ | | 86| 0|# define XML_TOK_NMTOKEN 19 ------------------ 1179| 0| ptr += MINBPC(enc); ------------------ | | 799| 0|#define MINBPC(enc) 2 ------------------ 1180| 0| break; 1181| 25| case BT_NONASCII: ------------------ | Branch (1181:3): [True: 25, False: 0] ------------------ 1182| 25| if (IS_NMSTRT_CHAR_MINBPC(enc, ptr)) { ------------------ | | 807| 25|#define IS_NMSTRT_CHAR_MINBPC(enc, p) BIG2_IS_NMSTRT_CHAR_MINBPC(p) | | ------------------ | | | | 790| 25| UCS2_GET_NAMING(nmstrtPages, (unsigned char)p[0], (unsigned char)p[1]) | | | | ------------------ | | | | | | 87| 25| (namingBitmap[(pages[hi] << 3) + ((lo) >> 5)] & (1u << ((lo) & 0x1F))) | | | | | | ------------------ | | | | | | | Branch (87:3): [True: 0, False: 25] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1183| 0| ptr += MINBPC(enc); ------------------ | | 799| 0|#define MINBPC(enc) 2 ------------------ 1184| 0| tok = XML_TOK_NAME; ------------------ | | 85| 0|# define XML_TOK_NAME 18 ------------------ 1185| 0| break; 1186| 0| } 1187| 25| if (IS_NAME_CHAR_MINBPC(enc, ptr)) { ------------------ | | 805| 25|#define IS_NAME_CHAR_MINBPC(enc, p) BIG2_IS_NAME_CHAR_MINBPC(p) | | ------------------ | | | | 788| 25| UCS2_GET_NAMING(namePages, (unsigned char)p[0], (unsigned char)p[1]) | | | | ------------------ | | | | | | 87| 25| (namingBitmap[(pages[hi] << 3) + ((lo) >> 5)] & (1u << ((lo) & 0x1F))) | | | | | | ------------------ | | | | | | | Branch (87:3): [True: 0, False: 25] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1188| 0| ptr += MINBPC(enc); ------------------ | | 799| 0|#define MINBPC(enc) 2 ------------------ 1189| 0| tok = XML_TOK_NMTOKEN; ------------------ | | 86| 0|# define XML_TOK_NMTOKEN 19 ------------------ 1190| 0| break; 1191| 0| } 1192| 25| EXPAT_FALLTHROUGH; ------------------ | | 47| 25|# define EXPAT_FALLTHROUGH __attribute__((fallthrough)) ------------------ 1193| 25| default: ------------------ | Branch (1193:3): [True: 0, False: 25] ------------------ 1194| 25| *nextTokPtr = ptr; 1195| 25| return XML_TOK_INVALID; ------------------ | | 57| 25|# define XML_TOK_INVALID 0 ------------------ 1196| 25| } 1197| 0| while (HAS_CHAR(enc, ptr, end)) { 1198| 0| switch (BYTE_TYPE(enc, ptr)) { ------------------ | | 801| 0|#define BYTE_TYPE(enc, p) BIG2_BYTE_TYPE(enc, p) | | ------------------ | | | | 784| 0| ((p)[0] == 0 ? SB_BYTE_TYPE(enc, p + 1) : unicode_byte_type((p)[0], (p)[1])) | | | | ------------------ | | | | | | 231| 0| (((const struct normal_encoding *)(enc))->type[(unsigned char)*(p)]) | | | | ------------------ | | | | | Branch (784:4): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 1199| 0| CHECK_NAME_CASES(enc, ptr, end, nextTokPtr) ------------------ | | 81| 0| case BT_NONASCII: \ | | ------------------ | | | Branch (81:3): [True: 0, False: 0] | | ------------------ | | 82| 0| if (! IS_NAME_CHAR_MINBPC(enc, ptr)) { \ | | ------------------ | | | | 805| 0|#define IS_NAME_CHAR_MINBPC(enc, p) BIG2_IS_NAME_CHAR_MINBPC(p) | | | | ------------------ | | | | | | 788| 0| UCS2_GET_NAMING(namePages, (unsigned char)p[0], (unsigned char)p[1]) | | | | | | ------------------ | | | | | | | | 87| 0| (namingBitmap[(pages[hi] << 3) + ((lo) >> 5)] & (1u << ((lo) & 0x1F))) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (82:9): [True: 0, False: 0] | | ------------------ | | 83| 0| *nextTokPtr = ptr; \ | | 84| 0| return XML_TOK_INVALID; \ | | ------------------ | | | | 57| 0|# define XML_TOK_INVALID 0 | | ------------------ | | 85| 0| } \ | | 86| 0| EXPAT_FALLTHROUGH; \ | | ------------------ | | | | 47| 0|# define EXPAT_FALLTHROUGH __attribute__((fallthrough)) | | ------------------ | | 87| 0| case BT_NMSTRT: \ | | ------------------ | | | Branch (87:3): [True: 0, False: 0] | | ------------------ | | 88| 0| case BT_HEX: \ | | ------------------ | | | Branch (88:3): [True: 0, False: 0] | | ------------------ | | 89| 0| case BT_DIGIT: \ | | ------------------ | | | Branch (89:3): [True: 0, False: 0] | | ------------------ | | 90| 0| case BT_NAME: \ | | ------------------ | | | Branch (90:3): [True: 0, False: 0] | | ------------------ | | 91| 0| case BT_MINUS: \ | | ------------------ | | | Branch (91:3): [True: 0, False: 0] | | ------------------ | | 92| 0| ptr += MINBPC(enc); \ | | ------------------ | | | | 799| 0|#define MINBPC(enc) 2 | | ------------------ | | 93| 0| break; \ | | 94| 0| CHECK_NAME_CASE(2, enc, ptr, end, nextTokPtr) \ | | ------------------ | | | | 70| 0| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (70:3): [True: 0, False: 0] | | | | ------------------ | | | | 71| 0| if (end - ptr < n) \ | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 0] | | | | ------------------ | | | | 72| 0| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 0|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 73| 0| if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NAME_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 808| 0|#define IS_INVALID_CHAR(enc, p, n) BIG2_IS_INVALID_CHAR(p, n) | | | | | | ------------------ | | | | | | | | 795| 0| ((n) == 4 && ((unsigned char)(p)[2] & 0xFC) != 0xDC) | | | | | | | | ------------------ | | | | | | | | | Branch (795:4): [Folded, False: 0] | | | | | | | | | Branch (795:16): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NAME_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 804| 0|#define IS_NAME_CHAR(enc, p, n) 0 | | | | ------------------ | | | | | Branch (73:41): [True: 0, Folded] | | | | ------------------ | | | | 74| 0| *nextTokPtr = ptr; \ | | | | 75| 0| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 0|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 76| 0| } \ | | | | 77| 0| ptr += n; \ | | | | 78| 0| break; | | ------------------ | | 95| 0| CHECK_NAME_CASE(3, enc, ptr, end, nextTokPtr) \ | | ------------------ | | | | 70| 0| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (70:3): [True: 0, False: 0] | | | | ------------------ | | | | 71| 0| if (end - ptr < n) \ | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 0] | | | | ------------------ | | | | 72| 0| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 0|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 73| 0| if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NAME_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 808| 0|#define IS_INVALID_CHAR(enc, p, n) BIG2_IS_INVALID_CHAR(p, n) | | | | | | ------------------ | | | | | | | | 795| 0| ((n) == 4 && ((unsigned char)(p)[2] & 0xFC) != 0xDC) | | | | | | | | ------------------ | | | | | | | | | Branch (795:4): [Folded, False: 0] | | | | | | | | | Branch (795:16): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NAME_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 804| 0|#define IS_NAME_CHAR(enc, p, n) 0 | | | | ------------------ | | | | | Branch (73:41): [True: 0, Folded] | | | | ------------------ | | | | 74| 0| *nextTokPtr = ptr; \ | | | | 75| 0| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 0|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 76| 0| } \ | | | | 77| 0| ptr += n; \ | | | | 78| 0| break; | | ------------------ | | 96| 0| CHECK_NAME_CASE(4, enc, ptr, end, nextTokPtr) | | ------------------ | | | | 70| 0| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (70:3): [True: 0, False: 0] | | | | ------------------ | | | | 71| 0| if (end - ptr < n) \ | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 0] | | | | ------------------ | | | | 72| 0| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 0|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 73| 0| if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NAME_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 808| 0|#define IS_INVALID_CHAR(enc, p, n) BIG2_IS_INVALID_CHAR(p, n) | | | | | | ------------------ | | | | | | | | 795| 0| ((n) == 4 && ((unsigned char)(p)[2] & 0xFC) != 0xDC) | | | | | | | | ------------------ | | | | | | | | | Branch (795:4): [True: 0, Folded] | | | | | | | | | Branch (795:16): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NAME_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 804| 0|#define IS_NAME_CHAR(enc, p, n) 0 | | | | ------------------ | | | | | Branch (73:41): [True: 0, Folded] | | | | ------------------ | | | | 74| 0| *nextTokPtr = ptr; \ | | | | 75| 0| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 0|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 76| 0| } \ | | | | 77| 0| ptr += n; \ | | | | 78| 0| break; | | ------------------ ------------------ 1200| 0| case BT_GT: ------------------ | Branch (1200:5): [True: 0, False: 0] ------------------ 1201| 0| case BT_RPAR: ------------------ | Branch (1201:5): [True: 0, False: 0] ------------------ 1202| 0| case BT_COMMA: ------------------ | Branch (1202:5): [True: 0, False: 0] ------------------ 1203| 0| case BT_VERBAR: ------------------ | Branch (1203:5): [True: 0, False: 0] ------------------ 1204| 0| case BT_LSQB: ------------------ | Branch (1204:5): [True: 0, False: 0] ------------------ 1205| 0| case BT_PERCNT: ------------------ | Branch (1205:5): [True: 0, False: 0] ------------------ 1206| 0| case BT_S: ------------------ | Branch (1206:5): [True: 0, False: 0] ------------------ 1207| 0| case BT_CR: ------------------ | Branch (1207:5): [True: 0, False: 0] ------------------ 1208| 0| case BT_LF: ------------------ | Branch (1208:5): [True: 0, False: 0] ------------------ 1209| 0| *nextTokPtr = ptr; 1210| 0| return tok; 1211| 0|# ifdef XML_NS 1212| 0| case BT_COLON: ------------------ | Branch (1212:5): [True: 0, False: 0] ------------------ 1213| 0| ptr += MINBPC(enc); ------------------ | | 799| 0|#define MINBPC(enc) 2 ------------------ 1214| 0| switch (tok) { ------------------ | Branch (1214:15): [True: 0, False: 0] ------------------ 1215| 0| case XML_TOK_NAME: ------------------ | | 85| 0|# define XML_TOK_NAME 18 ------------------ | Branch (1215:7): [True: 0, False: 0] ------------------ 1216| 0| REQUIRE_CHAR(enc, ptr, end); ------------------ | | 140| 0|# define REQUIRE_CHAR(enc, ptr, end) REQUIRE_CHARS(enc, ptr, end, 1) | | ------------------ | | | | 134| 0| { \ | | | | 135| 0| if (! HAS_CHARS(enc, ptr, end, count)) { \ | | | | ------------------ | | | | | | 129| 0| ((end) - (ptr) >= ((count) * MINBPC(enc))) | | | | | | ------------------ | | | | | | | | 799| 0|#define MINBPC(enc) 2 | | | | | | ------------------ | | | | ------------------ | | | | | Branch (135:11): [True: 0, False: 0] | | | | ------------------ | | | | 136| 0| return XML_TOK_PARTIAL; \ | | | | ------------------ | | | | | | 56| 0|# define XML_TOK_PARTIAL -1 /* only part of a token */ | | | | ------------------ | | | | 137| 0| } \ | | | | 138| 0| } | | ------------------ ------------------ 1217| 0| tok = XML_TOK_PREFIXED_NAME; ------------------ | | 118| 0|# define XML_TOK_PREFIXED_NAME 41 ------------------ 1218| 0| switch (BYTE_TYPE(enc, ptr)) { ------------------ | | 801| 0|#define BYTE_TYPE(enc, p) BIG2_BYTE_TYPE(enc, p) | | ------------------ | | | | 784| 0| ((p)[0] == 0 ? SB_BYTE_TYPE(enc, p + 1) : unicode_byte_type((p)[0], (p)[1])) | | | | ------------------ | | | | | | 231| 0| (((const struct normal_encoding *)(enc))->type[(unsigned char)*(p)]) | | | | ------------------ | | | | | Branch (784:4): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 1219| 0| CHECK_NAME_CASES(enc, ptr, end, nextTokPtr) ------------------ | | 81| 0| case BT_NONASCII: \ | | ------------------ | | | Branch (81:3): [True: 0, False: 0] | | ------------------ | | 82| 0| if (! IS_NAME_CHAR_MINBPC(enc, ptr)) { \ | | ------------------ | | | | 805| 0|#define IS_NAME_CHAR_MINBPC(enc, p) BIG2_IS_NAME_CHAR_MINBPC(p) | | | | ------------------ | | | | | | 788| 0| UCS2_GET_NAMING(namePages, (unsigned char)p[0], (unsigned char)p[1]) | | | | | | ------------------ | | | | | | | | 87| 0| (namingBitmap[(pages[hi] << 3) + ((lo) >> 5)] & (1u << ((lo) & 0x1F))) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (82:9): [True: 0, False: 0] | | ------------------ | | 83| 0| *nextTokPtr = ptr; \ | | 84| 0| return XML_TOK_INVALID; \ | | ------------------ | | | | 57| 0|# define XML_TOK_INVALID 0 | | ------------------ | | 85| 0| } \ | | 86| 0| EXPAT_FALLTHROUGH; \ | | ------------------ | | | | 47| 0|# define EXPAT_FALLTHROUGH __attribute__((fallthrough)) | | ------------------ | | 87| 0| case BT_NMSTRT: \ | | ------------------ | | | Branch (87:3): [True: 0, False: 0] | | ------------------ | | 88| 0| case BT_HEX: \ | | ------------------ | | | Branch (88:3): [True: 0, False: 0] | | ------------------ | | 89| 0| case BT_DIGIT: \ | | ------------------ | | | Branch (89:3): [True: 0, False: 0] | | ------------------ | | 90| 0| case BT_NAME: \ | | ------------------ | | | Branch (90:3): [True: 0, False: 0] | | ------------------ | | 91| 0| case BT_MINUS: \ | | ------------------ | | | Branch (91:3): [True: 0, False: 0] | | ------------------ | | 92| 0| ptr += MINBPC(enc); \ | | ------------------ | | | | 799| 0|#define MINBPC(enc) 2 | | ------------------ | | 93| 0| break; \ | | 94| 0| CHECK_NAME_CASE(2, enc, ptr, end, nextTokPtr) \ | | ------------------ | | | | 70| 0| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (70:3): [True: 0, False: 0] | | | | ------------------ | | | | 71| 0| if (end - ptr < n) \ | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 0] | | | | ------------------ | | | | 72| 0| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 0|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 73| 0| if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NAME_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 808| 0|#define IS_INVALID_CHAR(enc, p, n) BIG2_IS_INVALID_CHAR(p, n) | | | | | | ------------------ | | | | | | | | 795| 0| ((n) == 4 && ((unsigned char)(p)[2] & 0xFC) != 0xDC) | | | | | | | | ------------------ | | | | | | | | | Branch (795:4): [Folded, False: 0] | | | | | | | | | Branch (795:16): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NAME_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 804| 0|#define IS_NAME_CHAR(enc, p, n) 0 | | | | ------------------ | | | | | Branch (73:41): [True: 0, Folded] | | | | ------------------ | | | | 74| 0| *nextTokPtr = ptr; \ | | | | 75| 0| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 0|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 76| 0| } \ | | | | 77| 0| ptr += n; \ | | | | 78| 0| break; | | ------------------ | | 95| 0| CHECK_NAME_CASE(3, enc, ptr, end, nextTokPtr) \ | | ------------------ | | | | 70| 0| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (70:3): [True: 0, False: 0] | | | | ------------------ | | | | 71| 0| if (end - ptr < n) \ | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 0] | | | | ------------------ | | | | 72| 0| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 0|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 73| 0| if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NAME_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 808| 0|#define IS_INVALID_CHAR(enc, p, n) BIG2_IS_INVALID_CHAR(p, n) | | | | | | ------------------ | | | | | | | | 795| 0| ((n) == 4 && ((unsigned char)(p)[2] & 0xFC) != 0xDC) | | | | | | | | ------------------ | | | | | | | | | Branch (795:4): [Folded, False: 0] | | | | | | | | | Branch (795:16): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NAME_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 804| 0|#define IS_NAME_CHAR(enc, p, n) 0 | | | | ------------------ | | | | | Branch (73:41): [True: 0, Folded] | | | | ------------------ | | | | 74| 0| *nextTokPtr = ptr; \ | | | | 75| 0| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 0|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 76| 0| } \ | | | | 77| 0| ptr += n; \ | | | | 78| 0| break; | | ------------------ | | 96| 0| CHECK_NAME_CASE(4, enc, ptr, end, nextTokPtr) | | ------------------ | | | | 70| 0| case BT_LEAD##n: \ | | | | ------------------ | | | | | Branch (70:3): [True: 0, False: 0] | | | | ------------------ | | | | 71| 0| if (end - ptr < n) \ | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 0] | | | | ------------------ | | | | 72| 0| return XML_TOK_PARTIAL_CHAR; \ | | | | ------------------ | | | | | | 55| 0|# define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ | | | | ------------------ | | | | 73| 0| if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NAME_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 808| 0|#define IS_INVALID_CHAR(enc, p, n) BIG2_IS_INVALID_CHAR(p, n) | | | | | | ------------------ | | | | | | | | 795| 0| ((n) == 4 && ((unsigned char)(p)[2] & 0xFC) != 0xDC) | | | | | | | | ------------------ | | | | | | | | | Branch (795:4): [True: 0, Folded] | | | | | | | | | Branch (795:16): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NAME_CHAR(enc, ptr, n)) { \ | | | | ------------------ | | | | | | 804| 0|#define IS_NAME_CHAR(enc, p, n) 0 | | | | ------------------ | | | | | Branch (73:41): [True: 0, Folded] | | | | ------------------ | | | | 74| 0| *nextTokPtr = ptr; \ | | | | 75| 0| return XML_TOK_INVALID; \ | | | | ------------------ | | | | | | 57| 0|# define XML_TOK_INVALID 0 | | | | ------------------ | | | | 76| 0| } \ | | | | 77| 0| ptr += n; \ | | | | 78| 0| break; | | ------------------ ------------------ 1220| 0| default: ------------------ | Branch (1220:9): [True: 0, False: 0] ------------------ 1221| 0| tok = XML_TOK_NMTOKEN; ------------------ | | 86| 0|# define XML_TOK_NMTOKEN 19 ------------------ 1222| 0| break; 1223| 0| } 1224| 0| break; 1225| 0| case XML_TOK_PREFIXED_NAME: ------------------ | | 118| 0|# define XML_TOK_PREFIXED_NAME 41 ------------------ | Branch (1225:7): [True: 0, False: 0] ------------------ 1226| 0| tok = XML_TOK_NMTOKEN; ------------------ | | 86| 0|# define XML_TOK_NMTOKEN 19 ------------------ 1227| 0| break; 1228| 0| } 1229| 0| break; 1230| 0|# endif 1231| 0| case BT_PLUS: ------------------ | Branch (1231:5): [True: 0, False: 0] ------------------ 1232| 0| if (tok == XML_TOK_NMTOKEN) { ------------------ | | 86| 0|# define XML_TOK_NMTOKEN 19 ------------------ | Branch (1232:11): [True: 0, False: 0] ------------------ 1233| 0| *nextTokPtr = ptr; 1234| 0| return XML_TOK_INVALID; ------------------ | | 57| 0|# define XML_TOK_INVALID 0 ------------------ 1235| 0| } 1236| 0| *nextTokPtr = ptr + MINBPC(enc); ------------------ | | 799| 0|#define MINBPC(enc) 2 ------------------ 1237| 0| return XML_TOK_NAME_PLUS; ------------------ | | 101| 0|# define XML_TOK_NAME_PLUS 32 /* name+ */ ------------------ 1238| 0| case BT_AST: ------------------ | Branch (1238:5): [True: 0, False: 0] ------------------ 1239| 0| if (tok == XML_TOK_NMTOKEN) { ------------------ | | 86| 0|# define XML_TOK_NMTOKEN 19 ------------------ | Branch (1239:11): [True: 0, False: 0] ------------------ 1240| 0| *nextTokPtr = ptr; 1241| 0| return XML_TOK_INVALID; ------------------ | | 57| 0|# define XML_TOK_INVALID 0 ------------------ 1242| 0| } 1243| 0| *nextTokPtr = ptr + MINBPC(enc); ------------------ | | 799| 0|#define MINBPC(enc) 2 ------------------ 1244| 0| return XML_TOK_NAME_ASTERISK; ------------------ | | 100| 0|# define XML_TOK_NAME_ASTERISK 31 /* name* */ ------------------ 1245| 0| case BT_QUEST: ------------------ | Branch (1245:5): [True: 0, False: 0] ------------------ 1246| 0| if (tok == XML_TOK_NMTOKEN) { ------------------ | | 86| 0|# define XML_TOK_NMTOKEN 19 ------------------ | Branch (1246:11): [True: 0, False: 0] ------------------ 1247| 0| *nextTokPtr = ptr; 1248| 0| return XML_TOK_INVALID; ------------------ | | 57| 0|# define XML_TOK_INVALID 0 ------------------ 1249| 0| } 1250| 0| *nextTokPtr = ptr + MINBPC(enc); ------------------ | | 799| 0|#define MINBPC(enc) 2 ------------------ 1251| 0| return XML_TOK_NAME_QUESTION; ------------------ | | 99| 0|# define XML_TOK_NAME_QUESTION 30 /* name? */ ------------------ 1252| 0| default: ------------------ | Branch (1252:5): [True: 0, False: 0] ------------------ 1253| 0| *nextTokPtr = ptr; 1254| 0| return XML_TOK_INVALID; ------------------ | | 57| 0|# define XML_TOK_INVALID 0 ------------------ 1255| 0| } 1256| 0| } 1257| 0| return -tok; 1258| 0|} XmlGetUtf8InternalEncoding: 43| 7.30k|NS(XmlGetUtf8InternalEncoding)(void) { 44| 7.30k| return &ns(internal_utf8_encoding).enc; ------------------ | | 1568| 7.30k|#define ns(x) x ------------------ 45| 7.30k|} XmlInitEncoding: 83| 19.3k| const char *name) { 84| 19.3k| int i = getEncodingIndex(name); 85| 19.3k| if (i == UNKNOWN_ENC) ------------------ | Branch (85:7): [True: 1, False: 19.3k] ------------------ 86| 1| return 0; 87| 19.3k| SET_INIT_ENC_INDEX(p, i); ------------------ | | 1446| 19.3k|#define SET_INIT_ENC_INDEX(enc, i) ((enc)->initEnc.isUtf16 = (char)i) ------------------ 88| 19.3k| p->initEnc.scanners[XML_PROLOG_STATE] = NS(initScanProlog); ------------------ | | 130| 19.3k|# define XML_PROLOG_STATE 0 ------------------ p->initEnc.scanners[XML_PROLOG_STATE] = NS(initScanProlog); ------------------ | | 1567| 19.3k|#define NS(x) x ------------------ 89| 19.3k| p->initEnc.scanners[XML_CONTENT_STATE] = NS(initScanContent); ------------------ | | 131| 19.3k|# define XML_CONTENT_STATE 1 ------------------ p->initEnc.scanners[XML_CONTENT_STATE] = NS(initScanContent); ------------------ | | 1567| 19.3k|#define NS(x) x ------------------ 90| 19.3k| p->initEnc.updatePosition = initUpdatePosition; 91| 19.3k| p->encPtr = encPtr; 92| 19.3k| *encPtr = &(p->initEnc); 93| 19.3k| return 1; 94| 19.3k|} XmlParseXmlDecl: 119| 212| int *standalone) { 120| 212| return doParseXmlDecl(NS(findEncoding), isGeneralTextEntity, enc, ptr, end, ------------------ | | 1567| 212|#define NS(x) x ------------------ 121| 212| badPtr, versionPtr, versionEndPtr, encodingName, 122| 212| encoding, standalone); 123| 212|} XmlGetUtf8InternalEncodingNS: 43| 4.76k|NS(XmlGetUtf8InternalEncoding)(void) { 44| 4.76k| return &ns(internal_utf8_encoding).enc; ------------------ | | 1578| 4.76k|# define ns(x) x##_ns ------------------ 45| 4.76k|} XmlInitEncodingNS: 83| 4.76k| const char *name) { 84| 4.76k| int i = getEncodingIndex(name); 85| 4.76k| if (i == UNKNOWN_ENC) ------------------ | Branch (85:7): [True: 1, False: 4.76k] ------------------ 86| 1| return 0; 87| 4.76k| SET_INIT_ENC_INDEX(p, i); ------------------ | | 1446| 4.76k|#define SET_INIT_ENC_INDEX(enc, i) ((enc)->initEnc.isUtf16 = (char)i) ------------------ 88| 4.76k| p->initEnc.scanners[XML_PROLOG_STATE] = NS(initScanProlog); ------------------ | | 130| 4.76k|# define XML_PROLOG_STATE 0 ------------------ p->initEnc.scanners[XML_PROLOG_STATE] = NS(initScanProlog); ------------------ | | 1577| 4.76k|# define NS(x) x##NS ------------------ 89| 4.76k| p->initEnc.scanners[XML_CONTENT_STATE] = NS(initScanContent); ------------------ | | 131| 4.76k|# define XML_CONTENT_STATE 1 ------------------ p->initEnc.scanners[XML_CONTENT_STATE] = NS(initScanContent); ------------------ | | 1577| 4.76k|# define NS(x) x##NS ------------------ 90| 4.76k| p->initEnc.updatePosition = initUpdatePosition; 91| 4.76k| p->encPtr = encPtr; 92| 4.76k| *encPtr = &(p->initEnc); 93| 4.76k| return 1; 94| 4.76k|} XmlParseXmlDeclNS: 119| 269| int *standalone) { 120| 269| return doParseXmlDecl(NS(findEncoding), isGeneralTextEntity, enc, ptr, end, ------------------ | | 1577| 269|# define NS(x) x##NS ------------------ 121| 269| badPtr, versionPtr, versionEndPtr, encodingName, 122| 269| encoding, standalone); 123| 269|} xmltok.c:initScanProlog: 69| 7.30k| const char **nextTokPtr) { 70| 7.30k| return initScan(NS(encodings), (const INIT_ENCODING *)enc, XML_PROLOG_STATE, ------------------ | | 1567| 7.30k|#define NS(x) x ------------------ return initScan(NS(encodings), (const INIT_ENCODING *)enc, XML_PROLOG_STATE, ------------------ | | 130| 7.30k|# define XML_PROLOG_STATE 0 ------------------ 71| 7.30k| ptr, end, nextTokPtr); 72| 7.30k|} xmltok.c:findEncoding: 97| 31|NS(findEncoding)(const ENCODING *enc, const char *ptr, const char *end) { 98| 31|# define ENCODING_MAX 128 99| 31| char buf[ENCODING_MAX] = ""; 100| 31| char *p = buf; 101| 31| int i; 102| 31| XmlUtf8Convert(enc, &ptr, end, &p, p + ENCODING_MAX - 1); ------------------ | | 275| 31| (((enc)->utf8Convert)(enc, fromP, fromLim, toP, toLim)) ------------------ 103| 31| if (ptr != end) ------------------ | Branch (103:7): [True: 1, False: 30] ------------------ 104| 1| return NULL; 105| 30| *p = 0; 106| 30| if (streqci(buf, KW_UTF_16) && enc->minBytesPerChar == 2) ------------------ | Branch (106:7): [True: 1, False: 29] | Branch (106:34): [True: 0, False: 1] ------------------ 107| 0| return enc; 108| 30| i = getEncodingIndex(buf); 109| 30| if (i == UNKNOWN_ENC) ------------------ | Branch (109:7): [True: 26, False: 4] ------------------ 110| 26| return NULL; 111| 4| return NS(encodings)[i]; ------------------ | | 1567| 4|#define NS(x) x ------------------ 112| 30|} xmltok.c:initScanPrologNS: 69| 4.76k| const char **nextTokPtr) { 70| 4.76k| return initScan(NS(encodings), (const INIT_ENCODING *)enc, XML_PROLOG_STATE, ------------------ | | 1577| 4.76k|# define NS(x) x##NS ------------------ return initScan(NS(encodings), (const INIT_ENCODING *)enc, XML_PROLOG_STATE, ------------------ | | 130| 4.76k|# define XML_PROLOG_STATE 0 ------------------ 71| 4.76k| ptr, end, nextTokPtr); 72| 4.76k|} xmltok.c:findEncodingNS: 97| 37|NS(findEncoding)(const ENCODING *enc, const char *ptr, const char *end) { 98| 37|# define ENCODING_MAX 128 99| 37| char buf[ENCODING_MAX] = ""; 100| 37| char *p = buf; 101| 37| int i; 102| 37| XmlUtf8Convert(enc, &ptr, end, &p, p + ENCODING_MAX - 1); ------------------ | | 275| 37| (((enc)->utf8Convert)(enc, fromP, fromLim, toP, toLim)) ------------------ 103| 37| if (ptr != end) ------------------ | Branch (103:7): [True: 1, False: 36] ------------------ 104| 1| return NULL; 105| 36| *p = 0; 106| 36| if (streqci(buf, KW_UTF_16) && enc->minBytesPerChar == 2) ------------------ | Branch (106:7): [True: 1, False: 35] | Branch (106:34): [True: 0, False: 1] ------------------ 107| 0| return enc; 108| 36| i = getEncodingIndex(buf); 109| 36| if (i == UNKNOWN_ENC) ------------------ | Branch (109:7): [True: 33, False: 3] ------------------ 110| 33| return NULL; 111| 3| return NS(encodings)[i]; ------------------ | | 1577| 3|# define NS(x) x##NS ------------------ 112| 36|} _ZN16protobuf_mutator3xml8DocumentD2Ev: 609| 12.0k|Document::~Document() { 610| | // @@protoc_insertion_point(destructor:protobuf_mutator.xml.Document) 611| 12.0k| SharedDtor(*this); 612| 12.0k|} _ZNK16protobuf_mutator3xml8Document12GetClassDataEv: 670| 127k|const ::google::protobuf::internal::ClassData* Document::GetClassData() const { 671| 127k| ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_); 672| 127k| ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table); 673| 127k| return _class_data_.base(); 674| 127k|} _ZN16protobuf_mutator3xml8Document5ClearEv: 753| 2|PROTOBUF_NOINLINE void Document::Clear() { 754| |// @@protoc_insertion_point(message_clear_start:protobuf_mutator.xml.Document) 755| 2| ::google::protobuf::internal::TSanWrite(&_impl_); 756| 2| ::uint32_t cached_has_bits = 0; 757| | // Prevent compiler warnings about cached_has_bits being unused 758| 2| (void) cached_has_bits; 759| | 760| 2| _impl_.misk1_.Clear(); 761| 2| _impl_.misk2_.Clear(); 762| 2| cached_has_bits = _impl_._has_bits_[0]; 763| 2| if (cached_has_bits & 0x0000000fu) { ------------------ | Branch (763:7): [True: 0, False: 2] ------------------ 764| 0| if (cached_has_bits & 0x00000001u) { ------------------ | Branch (764:9): [True: 0, False: 0] ------------------ 765| 0| _impl_.version_.ClearNonDefaultToEmpty(); 766| 0| } 767| 0| if (cached_has_bits & 0x00000002u) { ------------------ | Branch (767:9): [True: 0, False: 0] ------------------ 768| 0| _impl_.encoding_.ClearNonDefaultToEmpty(); 769| 0| } 770| 0| if (cached_has_bits & 0x00000004u) { ------------------ | Branch (770:9): [True: 0, False: 0] ------------------ 771| 0| ABSL_DCHECK(_impl_.doctype_ != nullptr); ------------------ | | 47| 0| ABSL_LOG_INTERNAL_DCHECK_IMPL((condition), #condition) | | ------------------ | | | | 43| 0| ABSL_LOG_INTERNAL_CHECK_IMPL(true || (condition), "true") | | | | ------------------ | | | | | | 26| 0| ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS, \ | | | | | | ------------------ | | | | | | | | 172| 0| ABSL_LOG_INTERNAL_##type##_CONDITION(condition) | | | | | | | | ------------------ | | | | | | | | | | 65| 0| switch (0) \ | | | | | | | | | | 66| 0| case 0: \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (66:3): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 67| 0| default: \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (67:3): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 68| 0| !(condition) ? (void)0 : ::absl::log_internal::Voidify()&& | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (68:5): [True: 0, Folded] | | | | | | | | | | | Branch (68:7): [True: 0, Folded] | | | | | | | | | | | Branch (68:7): [True: 0, False: 0] | | | | | | | | | | | Branch (68:7): [Folded, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 27| 0| ABSL_PREDICT_FALSE(!(condition))) \ | | | | | | 28| 0| ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream() | | | | | | ------------------ | | | | | | | | 66| 0| ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 772| 0| _impl_.doctype_->Clear(); 773| 0| } 774| 0| if (cached_has_bits & 0x00000008u) { ------------------ | Branch (774:9): [True: 0, False: 0] ------------------ 775| 0| ABSL_DCHECK(_impl_.element_ != nullptr); ------------------ | | 47| 0| ABSL_LOG_INTERNAL_DCHECK_IMPL((condition), #condition) | | ------------------ | | | | 43| 0| ABSL_LOG_INTERNAL_CHECK_IMPL(true || (condition), "true") | | | | ------------------ | | | | | | 26| 0| ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS, \ | | | | | | ------------------ | | | | | | | | 172| 0| ABSL_LOG_INTERNAL_##type##_CONDITION(condition) | | | | | | | | ------------------ | | | | | | | | | | 65| 0| switch (0) \ | | | | | | | | | | 66| 0| case 0: \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (66:3): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 67| 0| default: \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (67:3): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 68| 0| !(condition) ? (void)0 : ::absl::log_internal::Voidify()&& | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (68:5): [True: 0, Folded] | | | | | | | | | | | Branch (68:7): [True: 0, Folded] | | | | | | | | | | | Branch (68:7): [True: 0, False: 0] | | | | | | | | | | | Branch (68:7): [Folded, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 27| 0| ABSL_PREDICT_FALSE(!(condition))) \ | | | | | | 28| 0| ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream() | | | | | | ------------------ | | | | | | | | 66| 0| ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 776| 0| _impl_.element_->Clear(); 777| 0| } 778| 0| } 779| 2| _impl_.standalone_ = false; 780| 2| _impl_._has_bits_.Clear(); 781| 2| _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); 782| 2|} _ZN16protobuf_mutator3xml11DoctypeDeclD2Ev: 1063| 6.63k|DoctypeDecl::~DoctypeDecl() { 1064| | // @@protoc_insertion_point(destructor:protobuf_mutator.xml.DoctypeDecl) 1065| 6.63k| SharedDtor(*this); 1066| 6.63k|} _ZNK16protobuf_mutator3xml11DoctypeDecl12GetClassDataEv: 1119| 72.4k|const ::google::protobuf::internal::ClassData* DoctypeDecl::GetClassData() const { 1120| 72.4k| ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_); 1121| 72.4k| ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table); 1122| 72.4k| return _class_data_.base(); 1123| 72.4k|} _ZN16protobuf_mutator3xml4MiskD2Ev: 1433| 423|Misk::~Misk() { 1434| | // @@protoc_insertion_point(destructor:protobuf_mutator.xml.Misk) 1435| 423| SharedDtor(*this); 1436| 423|} _ZN16protobuf_mutator3xml4Misk7clear__Ev: 1447| 406|void Misk::clear__() { 1448| |// @@protoc_insertion_point(one_of_clear_start:protobuf_mutator.xml.Misk) 1449| 406| ::google::protobuf::internal::TSanWrite(&_impl_); 1450| 406| switch (__case()) { ------------------ | Branch (1450:11): [True: 406, False: 0] ------------------ 1451| 94| case kPi: { ------------------ | Branch (1451:5): [True: 94, False: 312] ------------------ 1452| 94| if (GetArena() == nullptr) { ------------------ | Branch (1452:11): [True: 94, False: 0] ------------------ 1453| 94| delete _impl_.__.pi_; 1454| 94| } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { ------------------ | Branch (1454:18): [Folded, False: 0] ------------------ 1455| 0| ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.__.pi_); 1456| 0| } 1457| 94| break; 1458| 0| } 1459| 312| case kComment: { ------------------ | Branch (1459:5): [True: 312, False: 94] ------------------ 1460| 312| _impl_.__.comment_.Destroy(); 1461| 312| break; 1462| 0| } 1463| 0| case __NOT_SET: { ------------------ | Branch (1463:5): [True: 0, False: 406] ------------------ 1464| 0| break; 1465| 0| } 1466| 406| } 1467| 406| _impl_._oneof_case_[0] = __NOT_SET; 1468| 406|} _ZNK16protobuf_mutator3xml4Misk12GetClassDataEv: 1501| 4.18k|const ::google::protobuf::internal::ClassData* Misk::GetClassData() const { 1502| 4.18k| ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_); 1503| 4.18k| ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table); 1504| 4.18k| return _class_data_.base(); 1505| 4.18k|} _ZN16protobuf_mutator3xml7ElementD2Ev: 1748| 6.98k|Element::~Element() { 1749| | // @@protoc_insertion_point(destructor:protobuf_mutator.xml.Element) 1750| 6.98k| SharedDtor(*this); 1751| 6.98k|} _ZNK16protobuf_mutator3xml7Element12GetClassDataEv: 1802| 80.4k|const ::google::protobuf::internal::ClassData* Element::GetClassData() const { 1803| 80.4k| ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_); 1804| 80.4k| ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table); 1805| 80.4k| return _class_data_.base(); 1806| 80.4k|} _ZN16protobuf_mutator3xml3TagD2Ev: 2041| 6.96k|Tag::~Tag() { 2042| | // @@protoc_insertion_point(destructor:protobuf_mutator.xml.Tag) 2043| 6.96k| SharedDtor(*this); 2044| 6.96k|} _ZNK16protobuf_mutator3xml3Tag12GetClassDataEv: 2095| 70.7k|const ::google::protobuf::internal::ClassData* Tag::GetClassData() const { 2096| 70.7k| ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_); 2097| 70.7k| ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table); 2098| 70.7k| return _class_data_.base(); 2099| 70.7k|} _ZN16protobuf_mutator3xml9ReferenceD2Ev: 2331| 1|Reference::~Reference() { 2332| | // @@protoc_insertion_point(destructor:protobuf_mutator.xml.Reference) 2333| 1| SharedDtor(*this); 2334| 1|} _ZNK16protobuf_mutator3xml9Reference12GetClassDataEv: 2373| 11|const ::google::protobuf::internal::ClassData* Reference::GetClassData() const { 2374| 11| ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_); 2375| 11| ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table); 2376| 11| return _class_data_.base(); 2377| 11|} _ZN16protobuf_mutator3xml2PiD2Ev: 2603| 94|Pi::~Pi() { 2604| | // @@protoc_insertion_point(destructor:protobuf_mutator.xml.Pi) 2605| 94| SharedDtor(*this); 2606| 94|} _ZNK16protobuf_mutator3xml2Pi12GetClassDataEv: 2646| 974|const ::google::protobuf::internal::ClassData* Pi::GetClassData() const { 2647| 974| ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_); 2648| 974| ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table); 2649| 974| return _class_data_.base(); 2650| 974|} _ZN16protobuf_mutator3xml7ContentD2Ev: 2938| 3.55k|Content::~Content() { 2939| | // @@protoc_insertion_point(destructor:protobuf_mutator.xml.Content) 2940| 3.55k| SharedDtor(*this); 2941| 3.55k|} _ZN16protobuf_mutator3xml7Content7clear__Ev: 2952| 1.05k|void Content::clear__() { 2953| |// @@protoc_insertion_point(one_of_clear_start:protobuf_mutator.xml.Content) 2954| 1.05k| ::google::protobuf::internal::TSanWrite(&_impl_); 2955| 1.05k| switch (__case()) { ------------------ | Branch (2955:11): [True: 1.05k, False: 0] ------------------ 2956| 552| case kCharData: { ------------------ | Branch (2956:5): [True: 552, False: 506] ------------------ 2957| 552| _impl_.__.char_data_.Destroy(); 2958| 552| break; 2959| 0| } 2960| 329| case kElement: { ------------------ | Branch (2960:5): [True: 329, False: 729] ------------------ 2961| 329| if (GetArena() == nullptr) { ------------------ | Branch (2961:11): [True: 329, False: 0] ------------------ 2962| 329| delete _impl_.__.element_; 2963| 329| } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { ------------------ | Branch (2963:18): [Folded, False: 0] ------------------ 2964| 0| ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.__.element_); 2965| 0| } 2966| 329| break; 2967| 0| } 2968| 1| case kReference: { ------------------ | Branch (2968:5): [True: 1, False: 1.05k] ------------------ 2969| 1| if (GetArena() == nullptr) { ------------------ | Branch (2969:11): [True: 1, False: 0] ------------------ 2970| 1| delete _impl_.__.reference_; 2971| 1| } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { ------------------ | Branch (2971:18): [Folded, False: 0] ------------------ 2972| 0| ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.__.reference_); 2973| 0| } 2974| 1| break; 2975| 0| } 2976| 175| case kCdsect: { ------------------ | Branch (2976:5): [True: 175, False: 883] ------------------ 2977| 175| _impl_.__.cdsect_.Destroy(); 2978| 175| break; 2979| 0| } 2980| 1| case kMisk: { ------------------ | Branch (2980:5): [True: 1, False: 1.05k] ------------------ 2981| 1| if (GetArena() == nullptr) { ------------------ | Branch (2981:11): [True: 1, False: 0] ------------------ 2982| 1| delete _impl_.__.misk_; 2983| 1| } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { ------------------ | Branch (2983:18): [Folded, False: 0] ------------------ 2984| 0| ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.__.misk_); 2985| 0| } 2986| 1| break; 2987| 0| } 2988| 0| case __NOT_SET: { ------------------ | Branch (2988:5): [True: 0, False: 1.05k] ------------------ 2989| 0| break; 2990| 0| } 2991| 1.05k| } 2992| 1.05k| _impl_._oneof_case_[0] = __NOT_SET; 2993| 1.05k|} _ZNK16protobuf_mutator3xml7Content12GetClassDataEv: 3026| 28.0k|const ::google::protobuf::internal::ClassData* Content::GetClassData() const { 3027| 28.0k| ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_); 3028| 28.0k| ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table); 3029| 28.0k| return _class_data_.base(); 3030| 28.0k|} _ZN16protobuf_mutator3xml9AttributeD2Ev: 3344| 383|Attribute::~Attribute() { 3345| | // @@protoc_insertion_point(destructor:protobuf_mutator.xml.Attribute) 3346| 383| SharedDtor(*this); 3347| 383|} _ZNK16protobuf_mutator3xml9Attribute12GetClassDataEv: 3387| 4.25k|const ::google::protobuf::internal::ClassData* Attribute::GetClassData() const { 3388| 4.25k| ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_); 3389| 4.25k| ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table); 3390| 4.25k| return _class_data_.base(); 3391| 4.25k|} _ZN16protobuf_mutator3xml5InputC2EPN6google8protobuf5ArenaE: 3585| 12.0k| : ::google::protobuf::Message(arena) { 3586| 12.0k|#endif // PROTOBUF_CUSTOM_VTABLE 3587| 12.0k| SharedCtor(arena); 3588| | // @@protoc_insertion_point(arena_constructor:protobuf_mutator.xml.Input) 3589| 12.0k|} _ZN16protobuf_mutator3xml5InputD2Ev: 3631| 12.0k|Input::~Input() { 3632| | // @@protoc_insertion_point(destructor:protobuf_mutator.xml.Input) 3633| 12.0k| SharedDtor(*this); 3634| 12.0k|} _ZNK16protobuf_mutator3xml5Input12GetClassDataEv: 3673| 146k|const ::google::protobuf::internal::ClassData* Input::GetClassData() const { 3674| 146k| ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_); 3675| 146k| ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table); 3676| 146k| return _class_data_.base(); 3677| 146k|} _ZN16protobuf_mutator3xml5Input5ClearEv: 3718| 24.1k|PROTOBUF_NOINLINE void Input::Clear() { 3719| |// @@protoc_insertion_point(message_clear_start:protobuf_mutator.xml.Input) 3720| 24.1k| ::google::protobuf::internal::TSanWrite(&_impl_); 3721| 24.1k| ::uint32_t cached_has_bits = 0; 3722| | // Prevent compiler warnings about cached_has_bits being unused 3723| 24.1k| (void) cached_has_bits; 3724| | 3725| 24.1k| cached_has_bits = _impl_._has_bits_[0]; 3726| 24.1k| if (cached_has_bits & 0x00000001u) { ------------------ | Branch (3726:7): [True: 2, False: 24.1k] ------------------ 3727| 2| ABSL_DCHECK(_impl_.document_ != nullptr); ------------------ | | 47| 2| ABSL_LOG_INTERNAL_DCHECK_IMPL((condition), #condition) | | ------------------ | | | | 43| 2| ABSL_LOG_INTERNAL_CHECK_IMPL(true || (condition), "true") | | | | ------------------ | | | | | | 26| 4| ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS, \ | | | | | | ------------------ | | | | | | | | 172| 2| ABSL_LOG_INTERNAL_##type##_CONDITION(condition) | | | | | | | | ------------------ | | | | | | | | | | 65| 4| switch (0) \ | | | | | | | | | | 66| 4| case 0: \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (66:3): [True: 2, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 67| 2| default: \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (67:3): [True: 0, False: 2] | | | | | | | | | | ------------------ | | | | | | | | | | 68| 2| !(condition) ? (void)0 : ::absl::log_internal::Voidify()&& | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (68:5): [True: 2, Folded] | | | | | | | | | | | Branch (68:7): [True: 0, Folded] | | | | | | | | | | | Branch (68:7): [True: 0, False: 0] | | | | | | | | | | | Branch (68:7): [Folded, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 27| 4| ABSL_PREDICT_FALSE(!(condition))) \ | | | | | | 28| 4| ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream() | | | | | | ------------------ | | | | | | | | 66| 0| ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 3728| 2| _impl_.document_->Clear(); 3729| 2| } 3730| 24.1k| _impl_.options_ = 0u; 3731| 24.1k| _impl_._has_bits_.Clear(); 3732| 24.1k| _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); 3733| 24.1k|} _ZN16protobuf_mutator3xml8Document10SharedDtorERN6google8protobuf11MessageLiteE: 613| 12.0k|inline void Document::SharedDtor(MessageLite& self) { 614| 12.0k| Document& this_ = static_cast(self); 615| 12.0k| this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); 616| 12.0k| ABSL_DCHECK(this_.GetArena() == nullptr); ------------------ | | 47| 12.0k| ABSL_LOG_INTERNAL_DCHECK_IMPL((condition), #condition) | | ------------------ | | | | 43| 12.0k| ABSL_LOG_INTERNAL_CHECK_IMPL(true || (condition), "true") | | | | ------------------ | | | | | | 26| 24.1k| ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS, \ | | | | | | ------------------ | | | | | | | | 172| 12.0k| ABSL_LOG_INTERNAL_##type##_CONDITION(condition) | | | | | | | | ------------------ | | | | | | | | | | 65| 24.1k| switch (0) \ | | | | | | | | | | 66| 24.1k| case 0: \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (66:3): [True: 12.0k, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 67| 12.0k| default: \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (67:3): [True: 0, False: 12.0k] | | | | | | | | | | ------------------ | | | | | | | | | | 68| 12.0k| !(condition) ? (void)0 : ::absl::log_internal::Voidify()&& | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (68:5): [True: 12.0k, Folded] | | | | | | | | | | | Branch (68:7): [True: 0, Folded] | | | | | | | | | | | Branch (68:7): [True: 0, False: 0] | | | | | | | | | | | Branch (68:7): [Folded, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 27| 24.1k| ABSL_PREDICT_FALSE(!(condition))) \ | | | | | | 28| 24.1k| ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream() | | | | | | ------------------ | | | | | | | | 66| 0| ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 617| 12.0k| this_._impl_.version_.Destroy(); 618| 12.0k| this_._impl_.encoding_.Destroy(); 619| 12.0k| delete this_._impl_.doctype_; 620| 12.0k| delete this_._impl_.element_; 621| 12.0k| this_._impl_.~Impl_(); 622| 12.0k|} _ZN16protobuf_mutator3xml11DoctypeDecl10SharedDtorERN6google8protobuf11MessageLiteE: 1067| 6.63k|inline void DoctypeDecl::SharedDtor(MessageLite& self) { 1068| 6.63k| DoctypeDecl& this_ = static_cast(self); 1069| 6.63k| this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); 1070| 6.63k| ABSL_DCHECK(this_.GetArena() == nullptr); ------------------ | | 47| 6.63k| ABSL_LOG_INTERNAL_DCHECK_IMPL((condition), #condition) | | ------------------ | | | | 43| 6.63k| ABSL_LOG_INTERNAL_CHECK_IMPL(true || (condition), "true") | | | | ------------------ | | | | | | 26| 13.2k| ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS, \ | | | | | | ------------------ | | | | | | | | 172| 6.63k| ABSL_LOG_INTERNAL_##type##_CONDITION(condition) | | | | | | | | ------------------ | | | | | | | | | | 65| 13.2k| switch (0) \ | | | | | | | | | | 66| 13.2k| case 0: \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (66:3): [True: 6.63k, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 67| 6.63k| default: \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (67:3): [True: 0, False: 6.63k] | | | | | | | | | | ------------------ | | | | | | | | | | 68| 6.63k| !(condition) ? (void)0 : ::absl::log_internal::Voidify()&& | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (68:5): [True: 6.63k, Folded] | | | | | | | | | | | Branch (68:7): [True: 0, Folded] | | | | | | | | | | | Branch (68:7): [True: 0, False: 0] | | | | | | | | | | | Branch (68:7): [Folded, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 27| 13.2k| ABSL_PREDICT_FALSE(!(condition))) \ | | | | | | 28| 13.2k| ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream() | | | | | | ------------------ | | | | | | | | 66| 0| ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1071| 6.63k| this_._impl_.name_.Destroy(); 1072| 6.63k| this_._impl_.external_id_.Destroy(); 1073| 6.63k| this_._impl_.int_subset_.Destroy(); 1074| 6.63k| this_._impl_.~Impl_(); 1075| 6.63k|} _ZN16protobuf_mutator3xml4Misk10SharedDtorERN6google8protobuf11MessageLiteE: 1437| 423|inline void Misk::SharedDtor(MessageLite& self) { 1438| 423| Misk& this_ = static_cast(self); 1439| 423| this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); 1440| 423| ABSL_DCHECK(this_.GetArena() == nullptr); ------------------ | | 47| 423| ABSL_LOG_INTERNAL_DCHECK_IMPL((condition), #condition) | | ------------------ | | | | 43| 423| ABSL_LOG_INTERNAL_CHECK_IMPL(true || (condition), "true") | | | | ------------------ | | | | | | 26| 846| ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS, \ | | | | | | ------------------ | | | | | | | | 172| 423| ABSL_LOG_INTERNAL_##type##_CONDITION(condition) | | | | | | | | ------------------ | | | | | | | | | | 65| 846| switch (0) \ | | | | | | | | | | 66| 846| case 0: \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (66:3): [True: 423, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 67| 423| default: \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (67:3): [True: 0, False: 423] | | | | | | | | | | ------------------ | | | | | | | | | | 68| 423| !(condition) ? (void)0 : ::absl::log_internal::Voidify()&& | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (68:5): [True: 423, Folded] | | | | | | | | | | | Branch (68:7): [True: 0, Folded] | | | | | | | | | | | Branch (68:7): [True: 0, False: 0] | | | | | | | | | | | Branch (68:7): [Folded, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 27| 846| ABSL_PREDICT_FALSE(!(condition))) \ | | | | | | 28| 846| ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream() | | | | | | ------------------ | | | | | | | | 66| 0| ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1441| 423| if (this_.has__()) { ------------------ | Branch (1441:7): [True: 406, False: 17] ------------------ 1442| 406| this_.clear__(); 1443| 406| } 1444| 423| this_._impl_.~Impl_(); 1445| 423|} _ZN16protobuf_mutator3xml7Element10SharedDtorERN6google8protobuf11MessageLiteE: 1752| 6.98k|inline void Element::SharedDtor(MessageLite& self) { 1753| 6.98k| Element& this_ = static_cast(self); 1754| 6.98k| this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); 1755| 6.98k| ABSL_DCHECK(this_.GetArena() == nullptr); ------------------ | | 47| 6.98k| ABSL_LOG_INTERNAL_DCHECK_IMPL((condition), #condition) | | ------------------ | | | | 43| 6.98k| ABSL_LOG_INTERNAL_CHECK_IMPL(true || (condition), "true") | | | | ------------------ | | | | | | 26| 13.9k| ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS, \ | | | | | | ------------------ | | | | | | | | 172| 6.98k| ABSL_LOG_INTERNAL_##type##_CONDITION(condition) | | | | | | | | ------------------ | | | | | | | | | | 65| 13.9k| switch (0) \ | | | | | | | | | | 66| 13.9k| case 0: \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (66:3): [True: 6.98k, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 67| 6.98k| default: \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (67:3): [True: 0, False: 6.98k] | | | | | | | | | | ------------------ | | | | | | | | | | 68| 6.98k| !(condition) ? (void)0 : ::absl::log_internal::Voidify()&& | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (68:5): [True: 6.98k, Folded] | | | | | | | | | | | Branch (68:7): [True: 0, Folded] | | | | | | | | | | | Branch (68:7): [True: 0, False: 0] | | | | | | | | | | | Branch (68:7): [Folded, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 27| 13.9k| ABSL_PREDICT_FALSE(!(condition))) \ | | | | | | 28| 13.9k| ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream() | | | | | | ------------------ | | | | | | | | 66| 0| ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1756| 6.98k| delete this_._impl_.tag_; 1757| 6.98k| this_._impl_.~Impl_(); 1758| 6.98k|} _ZN16protobuf_mutator3xml3Tag10SharedDtorERN6google8protobuf11MessageLiteE: 2045| 6.96k|inline void Tag::SharedDtor(MessageLite& self) { 2046| 6.96k| Tag& this_ = static_cast(self); 2047| 6.96k| this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); 2048| 6.96k| ABSL_DCHECK(this_.GetArena() == nullptr); ------------------ | | 47| 6.96k| ABSL_LOG_INTERNAL_DCHECK_IMPL((condition), #condition) | | ------------------ | | | | 43| 6.96k| ABSL_LOG_INTERNAL_CHECK_IMPL(true || (condition), "true") | | | | ------------------ | | | | | | 26| 13.9k| ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS, \ | | | | | | ------------------ | | | | | | | | 172| 6.96k| ABSL_LOG_INTERNAL_##type##_CONDITION(condition) | | | | | | | | ------------------ | | | | | | | | | | 65| 13.9k| switch (0) \ | | | | | | | | | | 66| 13.9k| case 0: \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (66:3): [True: 6.96k, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 67| 6.96k| default: \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (67:3): [True: 0, False: 6.96k] | | | | | | | | | | ------------------ | | | | | | | | | | 68| 6.96k| !(condition) ? (void)0 : ::absl::log_internal::Voidify()&& | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (68:5): [True: 6.96k, Folded] | | | | | | | | | | | Branch (68:7): [True: 0, Folded] | | | | | | | | | | | Branch (68:7): [True: 0, False: 0] | | | | | | | | | | | Branch (68:7): [Folded, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 27| 13.9k| ABSL_PREDICT_FALSE(!(condition))) \ | | | | | | 28| 13.9k| ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream() | | | | | | ------------------ | | | | | | | | 66| 0| ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2049| 6.96k| this_._impl_.name_.Destroy(); 2050| 6.96k| this_._impl_.~Impl_(); 2051| 6.96k|} _ZN16protobuf_mutator3xml9Reference10SharedDtorERN6google8protobuf11MessageLiteE: 2335| 1|inline void Reference::SharedDtor(MessageLite& self) { 2336| 1| Reference& this_ = static_cast(self); 2337| 1| this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); 2338| 1| ABSL_DCHECK(this_.GetArena() == nullptr); ------------------ | | 47| 1| ABSL_LOG_INTERNAL_DCHECK_IMPL((condition), #condition) | | ------------------ | | | | 43| 1| ABSL_LOG_INTERNAL_CHECK_IMPL(true || (condition), "true") | | | | ------------------ | | | | | | 26| 2| ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS, \ | | | | | | ------------------ | | | | | | | | 172| 1| ABSL_LOG_INTERNAL_##type##_CONDITION(condition) | | | | | | | | ------------------ | | | | | | | | | | 65| 2| switch (0) \ | | | | | | | | | | 66| 2| case 0: \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (66:3): [True: 1, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 67| 1| default: \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (67:3): [True: 0, False: 1] | | | | | | | | | | ------------------ | | | | | | | | | | 68| 1| !(condition) ? (void)0 : ::absl::log_internal::Voidify()&& | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (68:5): [True: 1, Folded] | | | | | | | | | | | Branch (68:7): [True: 0, Folded] | | | | | | | | | | | Branch (68:7): [True: 0, False: 0] | | | | | | | | | | | Branch (68:7): [Folded, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 27| 2| ABSL_PREDICT_FALSE(!(condition))) \ | | | | | | 28| 2| ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream() | | | | | | ------------------ | | | | | | | | 66| 0| ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2339| 1| this_._impl_.name_.Destroy(); 2340| 1| this_._impl_.~Impl_(); 2341| 1|} _ZN16protobuf_mutator3xml2Pi10SharedDtorERN6google8protobuf11MessageLiteE: 2607| 94|inline void Pi::SharedDtor(MessageLite& self) { 2608| 94| Pi& this_ = static_cast(self); 2609| 94| this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); 2610| 94| ABSL_DCHECK(this_.GetArena() == nullptr); ------------------ | | 47| 94| ABSL_LOG_INTERNAL_DCHECK_IMPL((condition), #condition) | | ------------------ | | | | 43| 94| ABSL_LOG_INTERNAL_CHECK_IMPL(true || (condition), "true") | | | | ------------------ | | | | | | 26| 188| ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS, \ | | | | | | ------------------ | | | | | | | | 172| 94| ABSL_LOG_INTERNAL_##type##_CONDITION(condition) | | | | | | | | ------------------ | | | | | | | | | | 65| 188| switch (0) \ | | | | | | | | | | 66| 188| case 0: \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (66:3): [True: 94, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 67| 94| default: \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (67:3): [True: 0, False: 94] | | | | | | | | | | ------------------ | | | | | | | | | | 68| 94| !(condition) ? (void)0 : ::absl::log_internal::Voidify()&& | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (68:5): [True: 94, Folded] | | | | | | | | | | | Branch (68:7): [True: 0, Folded] | | | | | | | | | | | Branch (68:7): [True: 0, False: 0] | | | | | | | | | | | Branch (68:7): [Folded, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 27| 188| ABSL_PREDICT_FALSE(!(condition))) \ | | | | | | 28| 188| ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream() | | | | | | ------------------ | | | | | | | | 66| 0| ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2611| 94| this_._impl_.target_.Destroy(); 2612| 94| this_._impl_.data_.Destroy(); 2613| 94| this_._impl_.~Impl_(); 2614| 94|} _ZN16protobuf_mutator3xml7Content10SharedDtorERN6google8protobuf11MessageLiteE: 2942| 3.55k|inline void Content::SharedDtor(MessageLite& self) { 2943| 3.55k| Content& this_ = static_cast(self); 2944| 3.55k| this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); 2945| 3.55k| ABSL_DCHECK(this_.GetArena() == nullptr); ------------------ | | 47| 3.55k| ABSL_LOG_INTERNAL_DCHECK_IMPL((condition), #condition) | | ------------------ | | | | 43| 3.55k| ABSL_LOG_INTERNAL_CHECK_IMPL(true || (condition), "true") | | | | ------------------ | | | | | | 26| 7.11k| ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS, \ | | | | | | ------------------ | | | | | | | | 172| 3.55k| ABSL_LOG_INTERNAL_##type##_CONDITION(condition) | | | | | | | | ------------------ | | | | | | | | | | 65| 7.11k| switch (0) \ | | | | | | | | | | 66| 7.11k| case 0: \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (66:3): [True: 3.55k, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 67| 3.55k| default: \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (67:3): [True: 0, False: 3.55k] | | | | | | | | | | ------------------ | | | | | | | | | | 68| 3.55k| !(condition) ? (void)0 : ::absl::log_internal::Voidify()&& | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (68:5): [True: 3.55k, Folded] | | | | | | | | | | | Branch (68:7): [True: 0, Folded] | | | | | | | | | | | Branch (68:7): [True: 0, False: 0] | | | | | | | | | | | Branch (68:7): [Folded, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 27| 7.11k| ABSL_PREDICT_FALSE(!(condition))) \ | | | | | | 28| 7.11k| ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream() | | | | | | ------------------ | | | | | | | | 66| 0| ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2946| 3.55k| if (this_.has__()) { ------------------ | Branch (2946:7): [True: 1.05k, False: 2.49k] ------------------ 2947| 1.05k| this_.clear__(); 2948| 1.05k| } 2949| 3.55k| this_._impl_.~Impl_(); 2950| 3.55k|} _ZN16protobuf_mutator3xml9Attribute10SharedDtorERN6google8protobuf11MessageLiteE: 3348| 383|inline void Attribute::SharedDtor(MessageLite& self) { 3349| 383| Attribute& this_ = static_cast(self); 3350| 383| this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); 3351| 383| ABSL_DCHECK(this_.GetArena() == nullptr); ------------------ | | 47| 383| ABSL_LOG_INTERNAL_DCHECK_IMPL((condition), #condition) | | ------------------ | | | | 43| 383| ABSL_LOG_INTERNAL_CHECK_IMPL(true || (condition), "true") | | | | ------------------ | | | | | | 26| 766| ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS, \ | | | | | | ------------------ | | | | | | | | 172| 383| ABSL_LOG_INTERNAL_##type##_CONDITION(condition) | | | | | | | | ------------------ | | | | | | | | | | 65| 766| switch (0) \ | | | | | | | | | | 66| 766| case 0: \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (66:3): [True: 383, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 67| 383| default: \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (67:3): [True: 0, False: 383] | | | | | | | | | | ------------------ | | | | | | | | | | 68| 383| !(condition) ? (void)0 : ::absl::log_internal::Voidify()&& | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (68:5): [True: 383, Folded] | | | | | | | | | | | Branch (68:7): [True: 0, Folded] | | | | | | | | | | | Branch (68:7): [True: 0, False: 0] | | | | | | | | | | | Branch (68:7): [Folded, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 27| 766| ABSL_PREDICT_FALSE(!(condition))) \ | | | | | | 28| 766| ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream() | | | | | | ------------------ | | | | | | | | 66| 0| ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 3352| 383| this_._impl_.name_.Destroy(); 3353| 383| this_._impl_.value_.Destroy(); 3354| 383| this_._impl_.~Impl_(); 3355| 383|} _ZN16protobuf_mutator3xml5Input10SharedCtorEPN6google8protobuf5ArenaE: 3622| 12.0k|inline void Input::SharedCtor(::_pb::Arena* arena) { 3623| 12.0k| new (&_impl_) Impl_(internal_visibility(), arena); 3624| 12.0k| ::memset(reinterpret_cast(&_impl_) + 3625| 12.0k| offsetof(Impl_, document_), 3626| 12.0k| 0, 3627| 12.0k| offsetof(Impl_, options_) - 3628| | offsetof(Impl_, document_) + 3629| 12.0k| sizeof(Impl_::options_)); 3630| 12.0k|} _ZN16protobuf_mutator3xml5Input5Impl_C2EN6google8protobuf8internal18InternalVisibilityEPNS4_5ArenaE: 3620| 12.0k| : _cached_size_{0} {} _ZN16protobuf_mutator3xml5Input10SharedDtorERN6google8protobuf11MessageLiteE: 3635| 12.0k|inline void Input::SharedDtor(MessageLite& self) { 3636| 12.0k| Input& this_ = static_cast(self); 3637| 12.0k| this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); 3638| 12.0k| ABSL_DCHECK(this_.GetArena() == nullptr); ------------------ | | 47| 12.0k| ABSL_LOG_INTERNAL_DCHECK_IMPL((condition), #condition) | | ------------------ | | | | 43| 12.0k| ABSL_LOG_INTERNAL_CHECK_IMPL(true || (condition), "true") | | | | ------------------ | | | | | | 26| 24.1k| ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS, \ | | | | | | ------------------ | | | | | | | | 172| 12.0k| ABSL_LOG_INTERNAL_##type##_CONDITION(condition) | | | | | | | | ------------------ | | | | | | | | | | 65| 24.1k| switch (0) \ | | | | | | | | | | 66| 24.1k| case 0: \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (66:3): [True: 12.0k, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 67| 12.0k| default: \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (67:3): [True: 0, False: 12.0k] | | | | | | | | | | ------------------ | | | | | | | | | | 68| 12.0k| !(condition) ? (void)0 : ::absl::log_internal::Voidify()&& | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (68:5): [True: 12.0k, Folded] | | | | | | | | | | | Branch (68:7): [True: 0, Folded] | | | | | | | | | | | Branch (68:7): [True: 0, False: 0] | | | | | | | | | | | Branch (68:7): [Folded, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 27| 24.1k| ABSL_PREDICT_FALSE(!(condition))) \ | | | | | | 28| 24.1k| ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream() | | | | | | ------------------ | | | | | | | | 66| 0| ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 3639| 12.0k| delete this_._impl_.document_; 3640| 12.0k| this_._impl_.~Impl_(); 3641| 12.0k|} _ZN16protobuf_mutator3xml5InputC2Ev: 2273| 12.0k| inline Input() : Input(nullptr) {} _ZNK16protobuf_mutator3xml5Input8documentEv: 4483| 12.0k|inline const ::protobuf_mutator::xml::Document& Input::document() const ABSL_ATTRIBUTE_LIFETIME_BOUND { 4484| | // @@protoc_insertion_point(field_get:protobuf_mutator.xml.Input.document) 4485| 12.0k| return _internal_document(); 4486| 12.0k|} _ZNK16protobuf_mutator3xml5Input18_internal_documentEv: 4478| 12.0k|inline const ::protobuf_mutator::xml::Document& Input::_internal_document() const { 4479| 12.0k| ::google::protobuf::internal::TSanRead(&_impl_); 4480| 12.0k| const ::protobuf_mutator::xml::Document* p = _impl_.document_; 4481| 12.0k| return p != nullptr ? *p : reinterpret_cast(::protobuf_mutator::xml::_Document_default_instance_); ------------------ | Branch (4481:10): [True: 12.0k, False: 13] ------------------ 4482| 12.0k|} _ZNK16protobuf_mutator3xml5Input7optionsEv: 4573| 12.0k|inline ::uint32_t Input::options() const { 4574| | // @@protoc_insertion_point(field_get:protobuf_mutator.xml.Input.options) 4575| 12.0k| return _internal_options(); 4576| 12.0k|} _ZNK16protobuf_mutator3xml5Input17_internal_optionsEv: 4582| 12.0k|inline ::uint32_t Input::_internal_options() const { 4583| 12.0k| ::google::protobuf::internal::TSanRead(&_impl_); 4584| 12.0k| return _impl_.options_; 4585| 12.0k|} _ZNK16protobuf_mutator3xml8Document11has_versionEv: 2495| 12.6k|inline bool Document::has_version() const { 2496| 12.6k| bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; 2497| 12.6k| return value; 2498| 12.6k|} _ZNK16protobuf_mutator3xml8Document7versionEv: 2505| 1.14k| ABSL_ATTRIBUTE_LIFETIME_BOUND { 2506| | // @@protoc_insertion_point(field_get:protobuf_mutator.xml.Document.version) 2507| 1.14k| return _internal_version(); 2508| 1.14k|} _ZNK16protobuf_mutator3xml8Document17_internal_versionEv: 2522| 1.14k|inline const std::string& Document::_internal_version() const { 2523| 1.14k| ::google::protobuf::internal::TSanRead(&_impl_); 2524| 1.14k| return _impl_.version_.Get(); 2525| 1.14k|} _ZNK16protobuf_mutator3xml8Document12has_encodingEv: 2564| 12.0k|inline bool Document::has_encoding() const { 2565| 12.0k| bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; 2566| 12.0k| return value; 2567| 12.0k|} _ZNK16protobuf_mutator3xml8Document8encodingEv: 2574| 92| ABSL_ATTRIBUTE_LIFETIME_BOUND { 2575| | // @@protoc_insertion_point(field_get:protobuf_mutator.xml.Document.encoding) 2576| 92| return _internal_encoding(); 2577| 92|} _ZNK16protobuf_mutator3xml8Document18_internal_encodingEv: 2591| 92|inline const std::string& Document::_internal_encoding() const { 2592| 92| ::google::protobuf::internal::TSanRead(&_impl_); 2593| 92| return _impl_.encoding_.Get(); 2594| 92|} _ZNK16protobuf_mutator3xml8Document14has_standaloneEv: 2633| 12.0k|inline bool Document::has_standalone() const { 2634| 12.0k| bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0; 2635| 12.0k| return value; 2636| 12.0k|} _ZNK16protobuf_mutator3xml8Document10standaloneEv: 2642| 3|inline bool Document::standalone() const { 2643| | // @@protoc_insertion_point(field_get:protobuf_mutator.xml.Document.standalone) 2644| 3| return _internal_standalone(); 2645| 3|} _ZNK16protobuf_mutator3xml8Document20_internal_standaloneEv: 2651| 3|inline bool Document::_internal_standalone() const { 2652| 3| ::google::protobuf::internal::TSanRead(&_impl_); 2653| 3| return _impl_.standalone_; 2654| 3|} _ZNK16protobuf_mutator3xml8Document20_internal_misk1_sizeEv: 2661| 12.2k|inline int Document::_internal_misk1_size() const { 2662| 12.2k| return _internal_misk1().size(); 2663| 12.2k|} _ZNK16protobuf_mutator3xml8Document10misk1_sizeEv: 2664| 12.2k|inline int Document::misk1_size() const { 2665| 12.2k| return _internal_misk1_size(); 2666| 12.2k|} _ZNK16protobuf_mutator3xml8Document5misk1Ei: 2683| 180| ABSL_ATTRIBUTE_LIFETIME_BOUND { 2684| | // @@protoc_insertion_point(field_get:protobuf_mutator.xml.Document.misk1) 2685| 180| return _internal_misk1().Get(index); 2686| 180|} _ZNK16protobuf_mutator3xml8Document15_internal_misk1Ev: 2699| 12.4k|Document::_internal_misk1() const { 2700| 12.4k| ::google::protobuf::internal::TSanRead(&_impl_); 2701| 12.4k| return _impl_.misk1_; 2702| 12.4k|} _ZNK16protobuf_mutator3xml8Document11has_doctypeEv: 2710| 12.0k|inline bool Document::has_doctype() const { 2711| 12.0k| bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; 2712| 12.0k| PROTOBUF_ASSUME(!value || _impl_.doctype_ != nullptr); ------------------ | | 941| 18.7k|#define PROTOBUF_ASSUME(pred) __builtin_assume(pred) | | ------------------ | | | Branch (941:48): [True: 5.43k, False: 6.63k] | | | Branch (941:48): [True: 6.63k, False: 0] | | ------------------ ------------------ 2713| 12.0k| return value; 2714| 12.0k|} _ZNK16protobuf_mutator3xml8Document17_internal_doctypeEv: 2720| 6.63k|inline const ::protobuf_mutator::xml::DoctypeDecl& Document::_internal_doctype() const { 2721| 6.63k| ::google::protobuf::internal::TSanRead(&_impl_); 2722| 6.63k| const ::protobuf_mutator::xml::DoctypeDecl* p = _impl_.doctype_; 2723| 6.63k| return p != nullptr ? *p : reinterpret_cast(::protobuf_mutator::xml::_DoctypeDecl_default_instance_); ------------------ | Branch (2723:10): [True: 6.63k, False: 0] ------------------ 2724| 6.63k|} _ZNK16protobuf_mutator3xml8Document7doctypeEv: 2725| 6.63k|inline const ::protobuf_mutator::xml::DoctypeDecl& Document::doctype() const ABSL_ATTRIBUTE_LIFETIME_BOUND { 2726| | // @@protoc_insertion_point(field_get:protobuf_mutator.xml.Document.doctype) 2727| 6.63k| return _internal_doctype(); 2728| 6.63k|} _ZNK16protobuf_mutator3xml8Document17_internal_elementEv: 2816| 12.0k|inline const ::protobuf_mutator::xml::Element& Document::_internal_element() const { 2817| 12.0k| ::google::protobuf::internal::TSanRead(&_impl_); 2818| 12.0k| const ::protobuf_mutator::xml::Element* p = _impl_.element_; 2819| 12.0k| return p != nullptr ? *p : reinterpret_cast(::protobuf_mutator::xml::_Element_default_instance_); ------------------ | Branch (2819:10): [True: 6.65k, False: 5.41k] ------------------ 2820| 12.0k|} _ZNK16protobuf_mutator3xml8Document7elementEv: 2821| 12.0k|inline const ::protobuf_mutator::xml::Element& Document::element() const ABSL_ATTRIBUTE_LIFETIME_BOUND { 2822| | // @@protoc_insertion_point(field_get:protobuf_mutator.xml.Document.element) 2823| 12.0k| return _internal_element(); 2824| 12.0k|} _ZNK16protobuf_mutator3xml8Document20_internal_misk2_sizeEv: 2902| 12.3k|inline int Document::_internal_misk2_size() const { 2903| 12.3k| return _internal_misk2().size(); 2904| 12.3k|} _ZNK16protobuf_mutator3xml8Document10misk2_sizeEv: 2905| 12.3k|inline int Document::misk2_size() const { 2906| 12.3k| return _internal_misk2_size(); 2907| 12.3k|} _ZNK16protobuf_mutator3xml8Document5misk2Ei: 2924| 241| ABSL_ATTRIBUTE_LIFETIME_BOUND { 2925| | // @@protoc_insertion_point(field_get:protobuf_mutator.xml.Document.misk2) 2926| 241| return _internal_misk2().Get(index); 2927| 241|} _ZNK16protobuf_mutator3xml8Document15_internal_misk2Ev: 2940| 12.5k|Document::_internal_misk2() const { 2941| 12.5k| ::google::protobuf::internal::TSanRead(&_impl_); 2942| 12.5k| return _impl_.misk2_; 2943| 12.5k|} _ZNK16protobuf_mutator3xml11DoctypeDecl4nameEv: 2965| 6.63k| ABSL_ATTRIBUTE_LIFETIME_BOUND { 2966| | // @@protoc_insertion_point(field_get:protobuf_mutator.xml.DoctypeDecl.name) 2967| 6.63k| return _internal_name(); 2968| 6.63k|} _ZNK16protobuf_mutator3xml11DoctypeDecl14_internal_nameEv: 2982| 6.63k|inline const std::string& DoctypeDecl::_internal_name() const { 2983| 6.63k| ::google::protobuf::internal::TSanRead(&_impl_); 2984| 6.63k| return _impl_.name_.Get(); 2985| 6.63k|} _ZNK16protobuf_mutator3xml11DoctypeDecl15has_external_idEv: 3024| 6.63k|inline bool DoctypeDecl::has_external_id() const { 3025| 6.63k| bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; 3026| 6.63k| return value; 3027| 6.63k|} _ZNK16protobuf_mutator3xml11DoctypeDecl11external_idEv: 3034| 134| ABSL_ATTRIBUTE_LIFETIME_BOUND { 3035| | // @@protoc_insertion_point(field_get:protobuf_mutator.xml.DoctypeDecl.external_id) 3036| 134| return _internal_external_id(); 3037| 134|} _ZNK16protobuf_mutator3xml11DoctypeDecl21_internal_external_idEv: 3051| 134|inline const std::string& DoctypeDecl::_internal_external_id() const { 3052| 134| ::google::protobuf::internal::TSanRead(&_impl_); 3053| 134| return _impl_.external_id_.Get(); 3054| 134|} _ZNK16protobuf_mutator3xml11DoctypeDecl14has_int_subsetEv: 3093| 6.63k|inline bool DoctypeDecl::has_int_subset() const { 3094| 6.63k| bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; 3095| 6.63k| return value; 3096| 6.63k|} _ZNK16protobuf_mutator3xml11DoctypeDecl10int_subsetEv: 3103| 1.90k| ABSL_ATTRIBUTE_LIFETIME_BOUND { 3104| | // @@protoc_insertion_point(field_get:protobuf_mutator.xml.DoctypeDecl.int_subset) 3105| 1.90k| return _internal_int_subset(); 3106| 1.90k|} _ZNK16protobuf_mutator3xml11DoctypeDecl20_internal_int_subsetEv: 3120| 1.90k|inline const std::string& DoctypeDecl::_internal_int_subset() const { 3121| 1.90k| ::google::protobuf::internal::TSanRead(&_impl_); 3122| 1.90k| return _impl_.int_subset_.Get(); 3123| 1.90k|} _ZNK16protobuf_mutator3xml11DoctypeDecl19_internal_misk_sizeEv: 3162| 6.63k|inline int DoctypeDecl::_internal_misk_size() const { 3163| 6.63k| return _internal_misk().size(); 3164| 6.63k|} _ZNK16protobuf_mutator3xml11DoctypeDecl9misk_sizeEv: 3165| 6.63k|inline int DoctypeDecl::misk_size() const { 3166| 6.63k| return _internal_misk_size(); 3167| 6.63k|} _ZNK16protobuf_mutator3xml11DoctypeDecl4miskEi: 3184| 1| ABSL_ATTRIBUTE_LIFETIME_BOUND { 3185| | // @@protoc_insertion_point(field_get:protobuf_mutator.xml.DoctypeDecl.misk) 3186| 1| return _internal_misk().Get(index); 3187| 1|} _ZNK16protobuf_mutator3xml11DoctypeDecl14_internal_miskEv: 3200| 6.63k|DoctypeDecl::_internal_misk() const { 3201| 6.63k| ::google::protobuf::internal::TSanRead(&_impl_); 3202| 6.63k| return _impl_.misk_; 3203| 6.63k|} _ZNK16protobuf_mutator3xml4Misk6has_piEv: 3215| 423|inline bool Misk::has_pi() const { 3216| 423| return __case() == kPi; 3217| 423|} _ZNK16protobuf_mutator3xml4Misk12_internal_piEv: 3249| 188|inline const ::protobuf_mutator::xml::Pi& Misk::_internal_pi() const { 3250| 188| return __case() == kPi ? *_impl_.__.pi_ : reinterpret_cast<::protobuf_mutator::xml::Pi&>(::protobuf_mutator::xml::_Pi_default_instance_); ------------------ | Branch (3250:10): [True: 188, False: 0] ------------------ 3251| 188|} _ZNK16protobuf_mutator3xml4Misk2piEv: 3252| 188|inline const ::protobuf_mutator::xml::Pi& Misk::pi() const ABSL_ATTRIBUTE_LIFETIME_BOUND { 3253| | // @@protoc_insertion_point(field_get:protobuf_mutator.xml.Misk.pi) 3254| 188| return _internal_pi(); 3255| 188|} _ZNK16protobuf_mutator3xml4Misk11has_commentEv: 3294| 423|inline bool Misk::has_comment() const { 3295| 423| return __case() == kComment; 3296| 423|} _ZNK16protobuf_mutator3xml4Misk7commentEv: 3308| 312| ABSL_ATTRIBUTE_LIFETIME_BOUND { 3309| | // @@protoc_insertion_point(field_get:protobuf_mutator.xml.Misk.comment) 3310| 312| return _internal_comment(); 3311| 312|} _ZNK16protobuf_mutator3xml4Misk17_internal_commentEv: 3330| 312|inline const std::string& Misk::_internal_comment() const { 3331| 312| ::google::protobuf::internal::TSanRead(&_impl_); 3332| 312| if (__case() != kComment) { ------------------ | Branch (3332:7): [True: 0, False: 312] ------------------ 3333| 0| return ::google::protobuf::internal::GetEmptyStringAlreadyInited(); 3334| 0| } 3335| 312| return _impl_.__.comment_.Get(); 3336| 312|} _ZNK16protobuf_mutator3xml4Misk5has__Ev: 3378| 423|inline bool Misk::has__() const { 3379| 423| return __case() != __NOT_SET; 3380| 423|} _ZNK16protobuf_mutator3xml4Misk6__caseEv: 3384| 2.17k|inline Misk::Case Misk::__case() const { 3385| 2.17k| return Misk::Case(_impl_._oneof_case_[0]); 3386| 2.17k|} _ZNK16protobuf_mutator3xml7Element13_internal_tagEv: 3402| 25.9k|inline const ::protobuf_mutator::xml::Tag& Element::_internal_tag() const { 3403| 25.9k| ::google::protobuf::internal::TSanRead(&_impl_); 3404| 25.9k| const ::protobuf_mutator::xml::Tag* p = _impl_.tag_; 3405| 25.9k| return p != nullptr ? *p : reinterpret_cast(::protobuf_mutator::xml::_Tag_default_instance_); ------------------ | Branch (3405:10): [True: 15.0k, False: 10.8k] ------------------ 3406| 25.9k|} _ZNK16protobuf_mutator3xml7Element3tagEv: 3407| 25.9k|inline const ::protobuf_mutator::xml::Tag& Element::tag() const ABSL_ATTRIBUTE_LIFETIME_BOUND { 3408| | // @@protoc_insertion_point(field_get:protobuf_mutator.xml.Element.tag) 3409| 25.9k| return _internal_tag(); 3410| 25.9k|} _ZNK16protobuf_mutator3xml7Element22_internal_content_sizeEv: 3488| 19.2k|inline int Element::_internal_content_size() const { 3489| 19.2k| return _internal_content().size(); 3490| 19.2k|} _ZNK16protobuf_mutator3xml7Element12content_sizeEv: 3491| 19.2k|inline int Element::content_size() const { 3492| 19.2k| return _internal_content_size(); 3493| 19.2k|} _ZNK16protobuf_mutator3xml7Element7contentEi: 3510| 3.55k| ABSL_ATTRIBUTE_LIFETIME_BOUND { 3511| | // @@protoc_insertion_point(field_get:protobuf_mutator.xml.Element.content) 3512| 3.55k| return _internal_content().Get(index); 3513| 3.55k|} _ZNK16protobuf_mutator3xml7Element17_internal_contentEv: 3526| 22.7k|Element::_internal_content() const { 3527| 22.7k| ::google::protobuf::internal::TSanRead(&_impl_); 3528| 22.7k| return _impl_.content_; 3529| 22.7k|} _ZNK16protobuf_mutator3xml3Tag4nameEv: 3551| 12.3k| ABSL_ATTRIBUTE_LIFETIME_BOUND { 3552| | // @@protoc_insertion_point(field_get:protobuf_mutator.xml.Tag.name) 3553| 12.3k| return _internal_name(); 3554| 12.3k|} _ZNK16protobuf_mutator3xml3Tag14_internal_nameEv: 3568| 12.3k|inline const std::string& Tag::_internal_name() const { 3569| 12.3k| ::google::protobuf::internal::TSanRead(&_impl_); 3570| 12.3k| return _impl_.name_.Get(); 3571| 12.3k|} _ZNK16protobuf_mutator3xml3Tag24_internal_attribute_sizeEv: 3610| 12.7k|inline int Tag::_internal_attribute_size() const { 3611| 12.7k| return _internal_attribute().size(); 3612| 12.7k|} _ZNK16protobuf_mutator3xml3Tag14attribute_sizeEv: 3613| 12.7k|inline int Tag::attribute_size() const { 3614| 12.7k| return _internal_attribute_size(); 3615| 12.7k|} _ZNK16protobuf_mutator3xml3Tag9attributeEi: 3632| 766| ABSL_ATTRIBUTE_LIFETIME_BOUND { 3633| | // @@protoc_insertion_point(field_get:protobuf_mutator.xml.Tag.attribute) 3634| 766| return _internal_attribute().Get(index); 3635| 766|} _ZNK16protobuf_mutator3xml3Tag19_internal_attributeEv: 3648| 13.5k|Tag::_internal_attribute() const { 3649| 13.5k| ::google::protobuf::internal::TSanRead(&_impl_); 3650| 13.5k| return _impl_.attribute_; 3651| 13.5k|} _ZNK16protobuf_mutator3xml9Reference4nameEv: 3673| 1| ABSL_ATTRIBUTE_LIFETIME_BOUND { 3674| | // @@protoc_insertion_point(field_get:protobuf_mutator.xml.Reference.name) 3675| 1| return _internal_name(); 3676| 1|} _ZNK16protobuf_mutator3xml9Reference14_internal_nameEv: 3690| 1|inline const std::string& Reference::_internal_name() const { 3691| 1| ::google::protobuf::internal::TSanRead(&_impl_); 3692| 1| return _impl_.name_.Get(); 3693| 1|} _ZNK16protobuf_mutator3xml9Reference5entryEv: 3741| 1|inline bool Reference::entry() const { 3742| | // @@protoc_insertion_point(field_get:protobuf_mutator.xml.Reference.entry) 3743| 1| return _internal_entry(); 3744| 1|} _ZNK16protobuf_mutator3xml9Reference15_internal_entryEv: 3750| 1|inline bool Reference::_internal_entry() const { 3751| 1| ::google::protobuf::internal::TSanRead(&_impl_); 3752| 1| return _impl_.entry_; 3753| 1|} _ZNK16protobuf_mutator3xml2Pi6targetEv: 3774| 94| ABSL_ATTRIBUTE_LIFETIME_BOUND { 3775| | // @@protoc_insertion_point(field_get:protobuf_mutator.xml.Pi.target) 3776| 94| return _internal_target(); 3777| 94|} _ZNK16protobuf_mutator3xml2Pi16_internal_targetEv: 3791| 94|inline const std::string& Pi::_internal_target() const { 3792| 94| ::google::protobuf::internal::TSanRead(&_impl_); 3793| 94| return _impl_.target_.Get(); 3794| 94|} _ZNK16protobuf_mutator3xml2Pi4dataEv: 3843| 94| ABSL_ATTRIBUTE_LIFETIME_BOUND { 3844| | // @@protoc_insertion_point(field_get:protobuf_mutator.xml.Pi.data) 3845| 94| return _internal_data(); 3846| 94|} _ZNK16protobuf_mutator3xml2Pi14_internal_dataEv: 3860| 94|inline const std::string& Pi::_internal_data() const { 3861| 94| ::google::protobuf::internal::TSanRead(&_impl_); 3862| 94| return _impl_.data_.Get(); 3863| 94|} _ZNK16protobuf_mutator3xml7Content13has_char_dataEv: 3906| 3.55k|inline bool Content::has_char_data() const { 3907| 3.55k| return __case() == kCharData; 3908| 3.55k|} _ZNK16protobuf_mutator3xml7Content9char_dataEv: 3920| 552| ABSL_ATTRIBUTE_LIFETIME_BOUND { 3921| | // @@protoc_insertion_point(field_get:protobuf_mutator.xml.Content.char_data) 3922| 552| return _internal_char_data(); 3923| 552|} _ZNK16protobuf_mutator3xml7Content19_internal_char_dataEv: 3942| 552|inline const std::string& Content::_internal_char_data() const { 3943| 552| ::google::protobuf::internal::TSanRead(&_impl_); 3944| 552| if (__case() != kCharData) { ------------------ | Branch (3944:7): [True: 0, False: 552] ------------------ 3945| 0| return ::google::protobuf::internal::GetEmptyStringAlreadyInited(); 3946| 0| } 3947| 552| return _impl_.__.char_data_.Get(); 3948| 552|} _ZNK16protobuf_mutator3xml7Content11has_elementEv: 3991| 3.55k|inline bool Content::has_element() const { 3992| 3.55k| return __case() == kElement; 3993| 3.55k|} _ZNK16protobuf_mutator3xml7Content17_internal_elementEv: 4025| 329|inline const ::protobuf_mutator::xml::Element& Content::_internal_element() const { 4026| 329| return __case() == kElement ? *_impl_.__.element_ : reinterpret_cast<::protobuf_mutator::xml::Element&>(::protobuf_mutator::xml::_Element_default_instance_); ------------------ | Branch (4026:10): [True: 329, False: 0] ------------------ 4027| 329|} _ZNK16protobuf_mutator3xml7Content7elementEv: 4028| 329|inline const ::protobuf_mutator::xml::Element& Content::element() const ABSL_ATTRIBUTE_LIFETIME_BOUND { 4029| | // @@protoc_insertion_point(field_get:protobuf_mutator.xml.Content.element) 4030| 329| return _internal_element(); 4031| 329|} _ZNK16protobuf_mutator3xml7Content13has_referenceEv: 4070| 3.55k|inline bool Content::has_reference() const { 4071| 3.55k| return __case() == kReference; 4072| 3.55k|} _ZNK16protobuf_mutator3xml7Content19_internal_referenceEv: 4104| 2|inline const ::protobuf_mutator::xml::Reference& Content::_internal_reference() const { 4105| 2| return __case() == kReference ? *_impl_.__.reference_ : reinterpret_cast<::protobuf_mutator::xml::Reference&>(::protobuf_mutator::xml::_Reference_default_instance_); ------------------ | Branch (4105:10): [True: 2, False: 0] ------------------ 4106| 2|} _ZNK16protobuf_mutator3xml7Content9referenceEv: 4107| 2|inline const ::protobuf_mutator::xml::Reference& Content::reference() const ABSL_ATTRIBUTE_LIFETIME_BOUND { 4108| | // @@protoc_insertion_point(field_get:protobuf_mutator.xml.Content.reference) 4109| 2| return _internal_reference(); 4110| 2|} _ZNK16protobuf_mutator3xml7Content10has_cdsectEv: 4149| 3.55k|inline bool Content::has_cdsect() const { 4150| 3.55k| return __case() == kCdsect; 4151| 3.55k|} _ZNK16protobuf_mutator3xml7Content6cdsectEv: 4163| 175| ABSL_ATTRIBUTE_LIFETIME_BOUND { 4164| | // @@protoc_insertion_point(field_get:protobuf_mutator.xml.Content.cdsect) 4165| 175| return _internal_cdsect(); 4166| 175|} _ZNK16protobuf_mutator3xml7Content16_internal_cdsectEv: 4185| 175|inline const std::string& Content::_internal_cdsect() const { 4186| 175| ::google::protobuf::internal::TSanRead(&_impl_); 4187| 175| if (__case() != kCdsect) { ------------------ | Branch (4187:7): [True: 0, False: 175] ------------------ 4188| 0| return ::google::protobuf::internal::GetEmptyStringAlreadyInited(); 4189| 0| } 4190| 175| return _impl_.__.cdsect_.Get(); 4191| 175|} _ZNK16protobuf_mutator3xml7Content8has_miskEv: 4234| 3.55k|inline bool Content::has_misk() const { 4235| 3.55k| return __case() == kMisk; 4236| 3.55k|} _ZNK16protobuf_mutator3xml7Content14_internal_miskEv: 4268| 1|inline const ::protobuf_mutator::xml::Misk& Content::_internal_misk() const { 4269| 1| return __case() == kMisk ? *_impl_.__.misk_ : reinterpret_cast<::protobuf_mutator::xml::Misk&>(::protobuf_mutator::xml::_Misk_default_instance_); ------------------ | Branch (4269:10): [True: 1, False: 0] ------------------ 4270| 1|} _ZNK16protobuf_mutator3xml7Content4miskEv: 4271| 1|inline const ::protobuf_mutator::xml::Misk& Content::misk() const ABSL_ATTRIBUTE_LIFETIME_BOUND { 4272| | // @@protoc_insertion_point(field_get:protobuf_mutator.xml.Content.misk) 4273| 1| return _internal_misk(); 4274| 1|} _ZNK16protobuf_mutator3xml7Content5has__Ev: 4312| 3.55k|inline bool Content::has__() const { 4313| 3.55k| return __case() != __NOT_SET; 4314| 3.55k|} _ZNK16protobuf_mutator3xml7Content6__caseEv: 4318| 23.4k|inline Content::Case Content::__case() const { 4319| 23.4k| return Content::Case(_impl_._oneof_case_[0]); 4320| 23.4k|} _ZNK16protobuf_mutator3xml9Attribute4nameEv: 4336| 383| ABSL_ATTRIBUTE_LIFETIME_BOUND { 4337| | // @@protoc_insertion_point(field_get:protobuf_mutator.xml.Attribute.name) 4338| 383| return _internal_name(); 4339| 383|} _ZNK16protobuf_mutator3xml9Attribute14_internal_nameEv: 4353| 383|inline const std::string& Attribute::_internal_name() const { 4354| 383| ::google::protobuf::internal::TSanRead(&_impl_); 4355| 383| return _impl_.name_.Get(); 4356| 383|} _ZNK16protobuf_mutator3xml9Attribute5valueEv: 4405| 383| ABSL_ATTRIBUTE_LIFETIME_BOUND { 4406| | // @@protoc_insertion_point(field_get:protobuf_mutator.xml.Attribute.value) 4407| 383| return _internal_value(); 4408| 383|} _ZNK16protobuf_mutator3xml9Attribute15_internal_valueEv: 4422| 383|inline const std::string& Attribute::_internal_value() const { 4423| 383| ::google::protobuf::internal::TSanRead(&_impl_); 4424| 383| return _impl_.value_.Get(); 4425| 383|} _ZN4absl12lts_2024011620PrefetchToLocalCacheEPKv: 146| 1.28M| const void* addr) { 147| 1.28M| __builtin_prefetch(addr, 0, 3); 148| 1.28M|} _ZN4absl12lts_2024011611countl_zeroIjEENSt3__19enable_ifIXsr3std11is_unsignedIT_EE5valueEiE4typeES4_: 103| 888| countl_zero(T x) noexcept { 104| 888| return numeric_internal::CountLeadingZeroes(x); 105| 888|} _ZN4absl12lts_2024011616numeric_internal20CountLeadingZeroes32Ej: 133| 888|CountLeadingZeroes32(uint32_t x) { 134| 888|#if ABSL_NUMERIC_INTERNAL_HAVE_BUILTIN_OR_GCC(__builtin_clz) 135| | // Use __builtin_clz, which uses the following instructions: 136| | // x86: bsr, lzcnt 137| | // ARM64: clz 138| | // PPC: cntlzd 139| | 140| 888| static_assert(sizeof(unsigned int) == sizeof(x), 141| 888| "__builtin_clz does not take 32-bit arg"); 142| | // Handle 0 as a special case because __builtin_clz(0) is undefined. 143| 888| return x == 0 ? 32 : __builtin_clz(x); ------------------ | Branch (143:10): [True: 0, False: 888] ------------------ 144| |#elif defined(_MSC_VER) && !defined(__clang__) 145| | unsigned long result = 0; // NOLINT(runtime/int) 146| | if (_BitScanReverse(&result, x)) { 147| | return 31 - result; 148| | } 149| | return 32; 150| |#else 151| | int zeroes = 28; 152| | if (x >> 16) { 153| | zeroes -= 16; 154| | x >>= 16; 155| | } 156| | if (x >> 8) { 157| | zeroes -= 8; 158| | x >>= 8; 159| | } 160| | if (x >> 4) { 161| | zeroes -= 4; 162| | x >>= 4; 163| | } 164| | return "\4\3\2\2\1\1\1\1\0\0\0\0\0\0\0"[x] + zeroes; 165| |#endif 166| 888|} _ZN4absl12lts_2024011616numeric_internal18CountLeadingZeroesIjEEiT_: 234| 888|CountLeadingZeroes(T x) { 235| 888| static_assert(std::is_unsigned::value, "T must be unsigned"); 236| 888| static_assert(IsPowerOf2(std::numeric_limits::digits), 237| 888| "T must have a power-of-2 size"); 238| 888| static_assert(sizeof(T) <= sizeof(uint64_t), "T too large"); 239| 888| return sizeof(T) <= sizeof(uint16_t) ------------------ | Branch (239:10): [Folded, False: 888] ------------------ 240| 888| ? CountLeadingZeroes16(static_cast(x)) - 241| 0| (std::numeric_limits::digits - 242| 0| std::numeric_limits::digits) 243| 888| : (sizeof(T) <= sizeof(uint32_t) ------------------ | Branch (243:17): [True: 888, Folded] ------------------ 244| 888| ? CountLeadingZeroes32(static_cast(x)) - 245| 888| (std::numeric_limits::digits - 246| 888| std::numeric_limits::digits) 247| 888| : CountLeadingZeroes64(x)); 248| 888|} _ZN6google8protobuf3Any10descriptorEv: 113| 98.3k| static const ::google::protobuf::Descriptor* descriptor() { 114| 98.3k| return GetDescriptor(); 115| 98.3k| } _ZN6google8protobuf3Any13GetDescriptorEv: 116| 98.3k| static const ::google::protobuf::Descriptor* GetDescriptor() { 117| 98.3k| return default_instance().GetMetadata().descriptor; 118| 98.3k| } _ZN6google8protobuf3Any16default_instanceEv: 122| 98.3k| static const Any& default_instance() { 123| 98.3k| return *internal_default_instance(); 124| 98.3k| } _ZN6google8protobuf3Any25internal_default_instanceEv: 125| 98.3k| static inline const Any* internal_default_instance() { 126| 98.3k| return reinterpret_cast( 127| 98.3k| &_Any_default_instance_); 128| 98.3k| } _ZN6google8protobuf5Arena15AllocateAlignedEmm: 264| 436| void* AllocateAligned(size_t size, size_t align = 8) { 265| 436| if (align <= internal::ArenaAlignDefault::align) { ------------------ | Branch (265:9): [True: 436, False: 0] ------------------ 266| 436| return Allocate(internal::ArenaAlignDefault::Ceil(size)); 267| 436| } else { 268| | // We are wasting space by over allocating align - 8 bytes. Compared 269| | // to a dedicated function that takes current alignment in consideration. 270| | // Such a scheme would only waste (align - 8)/2 bytes on average, but 271| | // requires a dedicated function in the outline arena allocation 272| | // functions. Possibly re-evaluate tradeoffs later. 273| 0| auto align_as = internal::ArenaAlignAs(align); 274| 0| return align_as.Ceil(Allocate(align_as.Padded(size))); 275| 0| } 276| 436| } _ZN6google8protobuf8internal17ArenaAlignDefault4CeilEm: 79| 561| static inline PROTOBUF_ALWAYS_INLINE constexpr size_t Ceil(size_t n) { 80| 561| return (n + align - 1) & ~(align - 1); 81| 561| } _ZN6google8protobuf8internal15TaggedStringPtrC2EPNS1_21ExplicitlyConstructedINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEELm8EEE: 111| 1.08k| : ptr_(ptr) {} _ZNK6google8protobuf8internal15TaggedStringPtr9IsDefaultEv: 144| 17.9k| inline bool IsDefault() const { return (as_int() & kMask) == kDefault; } _ZNK6google8protobuf8internal15TaggedStringPtr3GetEv: 167| 25.7k| inline std::string* Get() const { 168| 25.7k| return reinterpret_cast(as_int() & ~kMask); 169| 25.7k| } _ZNK6google8protobuf8internal15TaggedStringPtr6as_intEv: 203| 98.7k| uintptr_t as_int() const { return reinterpret_cast(ptr_); } _ZN6google8protobuf8internal14ArenaStringPtrC2EPNS0_5ArenaE: 242| 50| : tagged_ptr_(&fixed_address_empty_string) { 243| 50| if (DebugHardenForceCopyDefaultString()) { ------------------ | Branch (243:9): [Folded, False: 50] ------------------ 244| 0| Set(absl::string_view(""), arena); 245| 0| } 246| 50| } _ZNK6google8protobuf8internal14ArenaStringPtr3GetEv: 335| 25.7k| PROTOBUF_NDEBUG_INLINE const std::string& Get() const { 336| | // Unconditionally mask away the tag. 337| 25.7k| return *tagged_ptr_.Get(); 338| 25.7k| } _ZN6google8protobuf8internal14ArenaStringPtr11InitDefaultEv: 451| 1.03k|inline void ArenaStringPtr::InitDefault() { 452| 1.03k| tagged_ptr_ = TaggedStringPtr(&fixed_address_empty_string); 453| 1.03k|} _ZNK6google8protobuf10Descriptor4fileEv: 2510| 63.7k| inline TYPE CLASS::FIELD() const { return FIELD##_; } _ZNK6google8protobuf10Descriptor11field_countEv: 2510| 469k| inline TYPE CLASS::FIELD() const { return FIELD##_; } _ZNK6google8protobuf10Descriptor5fieldEi: 2529| 366k| inline TYPE CLASS::FIELD(int index) const { \ 2530| 366k| ABSL_DCHECK_LE(0, index); \ ------------------ | | 78| 366k| ABSL_LOG_INTERNAL_DCHECK_LE_IMPL((val1), #val1, (val2), #val2) | | ------------------ | | | | 90| 366k| ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2) | | | | ------------------ | | | | | | 56| 366k| while (false && ((void)(x), (void)(y), 0)) \ | | | | | | ------------------ | | | | | | | Branch (56:10): [Folded, False: 366k] | | | | | | | Branch (56:19): [Folded, False: 0] | | | | | | ------------------ | | | | | | 57| 366k| ::absl::log_internal::NullStream().InternalStream() | | | | ------------------ | | ------------------ ------------------ 2531| 366k| ABSL_DCHECK_LT(index, FIELD##_count()); \ ------------------ | | 80| 366k| ABSL_LOG_INTERNAL_DCHECK_LT_IMPL((val1), #val1, (val2), #val2) | | ------------------ | | | | 92| 366k| ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2) | | | | ------------------ | | | | | | 56| 366k| while (false && ((void)(x), (void)(y), 0)) \ | | | | | | ------------------ | | | | | | | Branch (56:10): [Folded, False: 366k] | | | | | | | Branch (56:19): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 57| 366k| ::absl::log_internal::NullStream().InternalStream() | | | | ------------------ | | ------------------ ------------------ 2532| 366k| return FIELD##s_ + index; \ 2533| 366k| } _ZNK6google8protobuf10Descriptor7optionsEv: 2536| 285k| inline const TYPE& CLASS::options() const { return *options_; } _ZNK6google8protobuf15OneofDescriptor11field_countEv: 2510| 2.93k| inline TYPE CLASS::FIELD() const { return FIELD##_; } _ZNK6google8protobuf14EnumDescriptor11value_countEv: 2510| 540| inline TYPE CLASS::FIELD() const { return FIELD##_; } _ZNK6google8protobuf14EnumDescriptor5valueEi: 2529| 536| inline TYPE CLASS::FIELD(int index) const { \ 2530| 536| ABSL_DCHECK_LE(0, index); \ ------------------ | | 78| 536| ABSL_LOG_INTERNAL_DCHECK_LE_IMPL((val1), #val1, (val2), #val2) | | ------------------ | | | | 90| 536| ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2) | | | | ------------------ | | | | | | 56| 536| while (false && ((void)(x), (void)(y), 0)) \ | | | | | | ------------------ | | | | | | | Branch (56:10): [Folded, False: 536] | | | | | | | Branch (56:19): [Folded, False: 0] | | | | | | ------------------ | | | | | | 57| 536| ::absl::log_internal::NullStream().InternalStream() | | | | ------------------ | | ------------------ ------------------ 2531| 536| ABSL_DCHECK_LT(index, FIELD##_count()); \ ------------------ | | 80| 536| ABSL_LOG_INTERNAL_DCHECK_LT_IMPL((val1), #val1, (val2), #val2) | | ------------------ | | | | 92| 536| ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2) | | | | ------------------ | | | | | | 56| 536| while (false && ((void)(x), (void)(y), 0)) \ | | | | | | ------------------ | | | | | | | Branch (56:10): [Folded, False: 536] | | | | | | | Branch (56:19): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 57| 536| ::absl::log_internal::NullStream().InternalStream() | | | | ------------------ | | ------------------ ------------------ 2532| 536| return FIELD##s_ + index; \ 2533| 536| } _ZNK6google8protobuf19EnumValueDescriptor4typeEv: 2510| 821| inline TYPE CLASS::FIELD() const { return FIELD##_; } _ZNK6google8protobuf14FileDescriptor4poolEv: 2510| 1| inline TYPE CLASS::FIELD() const { return FIELD##_; } _ZNK6google8protobuf15FieldDescriptor16containing_oneofEv: 2711| 133k|inline const OneofDescriptor* FieldDescriptor::containing_oneof() const { 2712| 133k| if (is_oneof_) { ------------------ | Branch (2712:7): [True: 71.2k, False: 62.6k] ------------------ 2713| 71.2k| auto* res = scope_.containing_oneof; 2714| 71.2k| PROTOBUF_ASSUME(res != nullptr); ------------------ | | 941| 71.2k|#define PROTOBUF_ASSUME(pred) __builtin_assume(pred) ------------------ 2715| 71.2k| return res; 2716| 71.2k| } 2717| 62.6k| return nullptr; 2718| 133k|} _ZNK6google8protobuf15FieldDescriptor4typeEv: 2734| 1.09M|inline FieldDescriptor::Type FieldDescriptor::type() const { 2735| 1.09M| return static_cast(type_); 2736| 1.09M|} _ZNK6google8protobuf15FieldDescriptor11is_repeatedEv: 2742| 388k|inline bool FieldDescriptor::is_repeated() const { 2743| 388k| ABSL_DCHECK_EQ(is_repeated_, label() == LABEL_REPEATED); ------------------ | | 74| 388k| ABSL_LOG_INTERNAL_DCHECK_EQ_IMPL((val1), #val1, (val2), #val2) | | ------------------ | | | | 86| 388k| ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2) | | | | ------------------ | | | | | | 56| 388k| while (false && ((void)(x), (void)(y), 0)) \ | | | | | | ------------------ | | | | | | | Branch (56:10): [Folded, False: 388k] | | | | | | | Branch (56:19): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 57| 388k| ::absl::log_internal::NullStream().InternalStream() | | | | ------------------ | | ------------------ ------------------ 2744| 388k| return is_repeated_; 2745| 388k|} _ZNK6google8protobuf19EnumValueDescriptor5indexEv: 2813| 86|inline int EnumValueDescriptor::index() const { 2814| 86| return static_cast(this - type_->values_); 2815| 86|} _ZNK6google8protobuf15FieldDescriptor8cpp_typeEv: 2833| 746k|inline FieldDescriptor::CppType FieldDescriptor::cpp_type() const { 2834| 746k| return kTypeToCppTypeMap[type()]; 2835| 746k|} _ZNK6google8protobuf14MessageOptions9map_entryEv: 17247| 285k|inline bool MessageOptions::map_entry() const { 17248| | // @@protoc_insertion_point(field_get:google.protobuf.MessageOptions.map_entry) 17249| 285k| return _internal_map_entry(); 17250| 285k|} _ZNK6google8protobuf14MessageOptions19_internal_map_entryEv: 17256| 285k|inline bool MessageOptions::_internal_map_entry() const { 17257| 285k| ::google::protobuf::internal::TSanRead(&_impl_); 17258| 285k| return _impl_.map_entry_; 17259| 285k|} _ZNK6google8protobuf8internal21ExplicitlyConstructedINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEELm8EE3getEv: 49| 57| constexpr const T& get() const { return reinterpret_cast(union_); } _ZNK6google8protobuf8internal7HasBitsILi1EEixEi: 45| 69.8k| PROTOBUF_NDEBUG_INLINE const uint32_t& operator[](int index) const { 46| 69.8k| return has_bits_[index]; 47| 69.8k| } _ZN6google8protobuf8internal7HasBitsILi1EEixEi: 41| 25.7k| PROTOBUF_NDEBUG_INLINE uint32_t& operator[](int index) { 42| 25.7k| return has_bits_[index]; 43| 25.7k| } _ZN6google8protobuf8internal7HasBitsILi1EEC2Ev: 31| 12.3k| PROTOBUF_NDEBUG_INLINE constexpr HasBits() : has_bits_{} {} _ZN6google8protobuf8internal7HasBitsILi1EE5ClearEv: 37| 24.2k| PROTOBUF_NDEBUG_INLINE void Clear() { 38| 24.2k| memset(has_bits_, 0, sizeof(has_bits_)); 39| 24.2k| } _ZN6google8protobuf8internal18InternalVisibilityC2Ev: 38| 12.9k|inline constexpr InternalVisibility::InternalVisibility() = default; _ZN6google8protobuf2io19EpsCopyOutputStream11EnsureSpaceEPh: 662| 2.19k| PROTOBUF_NODISCARD uint8_t* EnsureSpace(uint8_t* ptr) { 663| 2.19k| if (PROTOBUF_PREDICT_FALSE(ptr >= end_)) { ------------------ | | 365| 2.19k|# define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(false || (x), false)) | | ------------------ | | | Branch (365:36): [True: 0, False: 2.19k] | | | Branch (365:54): [Folded, False: 2.19k] | | | Branch (365:63): [True: 0, False: 2.19k] | | ------------------ ------------------ 664| 0| return EnsureSpaceFallback(ptr); 665| 0| } 666| 2.19k| return ptr; 667| 2.19k| } _ZN6google8protobuf2io19EpsCopyOutputStream23WriteStringMaybeAliasedEjRKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEPh: 697| 29| uint8_t* ptr) { 698| 29| std::ptrdiff_t size = s.size(); 699| 29| if (PROTOBUF_PREDICT_FALSE( ------------------ | | 365| 57|# define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(false || (x), false)) | | ------------------ | | | Branch (365:36): [True: 1, False: 28] | | | Branch (365:54): [Folded, False: 29] | | | Branch (365:64): [True: 1, False: 28] | | | Branch (365:64): [True: 0, False: 28] | | ------------------ ------------------ 700| 29| size >= 128 || end_ - ptr + 16 - TagSize(num << 3) - 1 < size)) { 701| 1| return WriteStringMaybeAliasedOutline(num, s, ptr); 702| 1| } 703| 28| ptr = UnsafeVarint((num << 3) | 2, ptr); 704| 28| *ptr++ = static_cast(size); 705| 28| std::memcpy(ptr, s.data(), size); 706| 28| return ptr + size; 707| 29| } _ZN6google8protobuf2io19EpsCopyOutputStream7TagSizeEj: 843| 28| static constexpr int TagSize(uint32_t tag) { 844| 28| return (tag < (1 << 7)) ? 1 ------------------ | Branch (844:12): [True: 24, False: 4] ------------------ 845| 28| : (tag < (1 << 14)) ? 2 ------------------ | Branch (845:14): [True: 4, False: 0] ------------------ 846| 4| : (tag < (1 << 21)) ? 3 ------------------ | Branch (846:14): [True: 0, False: 0] ------------------ 847| 0| : (tag < (1 << 28)) ? 4 ------------------ | Branch (847:14): [True: 0, False: 0] ------------------ 848| 0| : 5; 849| 28| } _ZN6google8protobuf2io17CodedOutputStream20WriteVarint32ToArrayEjPh: 1641| 2.85k| uint8_t* target) { 1642| 2.85k| return EpsCopyOutputStream::UnsafeVarint(value, target); 1643| 2.85k|} _ZN6google8protobuf2io17CodedOutputStream15WriteTagToArrayEjPh: 1716| 2.19k| uint8_t* target) { 1717| 2.19k| return WriteVarint32ToArray(value, target); 1718| 2.19k|} _ZN6google8protobuf2io17CodedOutputStream12VarintSize32Ej: 1730| 888|inline size_t CodedOutputStream::VarintSize32(uint32_t value) { 1731| 888|#if PROTOBUF_CODED_STREAM_H_PREFER_BSR 1732| | // Explicit OR 0x1 to avoid calling absl::countl_zero(0), which 1733| | // requires a branch to check for on platforms without a clz instruction. 1734| 888| uint32_t log2value = (std::numeric_limits::digits - 1) - 1735| 888| absl::countl_zero(value | 0x1); 1736| 888| return static_cast((log2value * 9 + (64 + 9)) / 64); 1737| |#else 1738| | uint32_t clz = absl::countl_zero(value); 1739| | return static_cast( 1740| | ((std::numeric_limits::digits * 9 + 64) - (clz * 9)) / 64); 1741| |#endif 1742| 888|} _ZN6google8protobuf2io19EpsCopyOutputStream12UnsafeVarintIjEEPhT_S4_: 898| 2.88k| PROTOBUF_ALWAYS_INLINE static uint8_t* UnsafeVarint(T value, uint8_t* ptr) { 899| 2.88k| static_assert(std::is_unsigned::value, 900| 2.88k| "Varint serialization must be unsigned"); 901| 3.16k| while (PROTOBUF_PREDICT_FALSE(value >= 0x80)) { ------------------ | | 365| 3.16k|# define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(false || (x), false)) | | ------------------ | | | Branch (365:36): [True: 273, False: 2.88k] | | | Branch (365:54): [Folded, False: 3.16k] | | | Branch (365:63): [True: 273, False: 2.88k] | | ------------------ ------------------ 902| 273| *ptr = static_cast(value | 0x80); 903| 273| value >>= 7; 904| 273| ++ptr; 905| 273| } 906| 2.88k| *ptr++ = static_cast(value); 907| 2.88k| return ptr; 908| 2.88k| } _ZNK6google8protobuf7Message3NewEPNS0_5ArenaE: 264| 37.0k| Message* New(Arena* arena) const { 265| 37.0k| return static_cast(MessageLite::New(arena)); 266| 37.0k| } _ZNK6google8protobuf7Message13GetDescriptorEv: 363| 335k| const Descriptor* GetDescriptor() const { return GetMetadata().descriptor; } _ZNK6google8protobuf7Message13GetReflectionEv: 369| 161k| const Reflection* GetReflection() const { return GetMetadata().reflection; } _ZN6google8protobuf8internal10CachedSizeC2Ei: 173| 12.9k| constexpr CachedSize(Scalar desired) noexcept : atom_(desired) {} _ZNK6google8protobuf8internal10CachedSize3GetEv: 178| 612| Scalar Get() const noexcept { 179| 612| return __atomic_load_n(&atom_, __ATOMIC_RELAXED); 180| 612| } _ZNK6google8protobuf8internal13ClassDataFull4baseEv: 454| 635k| constexpr const ClassData* base() const { return this; } _ZNK6google8protobuf11MessageLite8GetArenaEv: 531| 57.1k| Arena* GetArena() const { return _internal_metadata_.arena(); } _ZN6google8protobuf11MessageLite19internal_visibilityEv: 816| 12.9k| static constexpr internal::InternalVisibility internal_visibility() { 817| 12.9k| return internal::InternalVisibility{}; 818| 12.9k| } _ZN6google8protobuf11MessageLiteC2EPNS0_5ArenaE: 879| 12.9k| explicit MessageLite(Arena* arena) : _internal_metadata_(arena) {} _ZN6google8protobuf8internal27GetEmptyStringAlreadyInitedEv: 314| 57|PROTOBUF_EXPORT constexpr const std::string& GetEmptyStringAlreadyInited() { 315| 57| return fixed_address_empty_string.get(); 316| 57|} _ZNK6google8protobuf8internal9ClassData4fullEv: 474| 595k|inline const ClassDataFull& ClassData::full() const { 475| 595k| ABSL_DCHECK(!is_lite); ------------------ | | 47| 595k| ABSL_LOG_INTERNAL_DCHECK_IMPL((condition), #condition) | | ------------------ | | | | 43| 595k| ABSL_LOG_INTERNAL_CHECK_IMPL(true || (condition), "true") | | | | ------------------ | | | | | | 26| 1.19M| ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS, \ | | | | | | ------------------ | | | | | | | | 172| 595k| ABSL_LOG_INTERNAL_##type##_CONDITION(condition) | | | | | | | | ------------------ | | | | | | | | | | 65| 1.19M| switch (0) \ | | | | | | | | | | 66| 1.19M| case 0: \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (66:3): [True: 595k, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 67| 595k| default: \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (67:3): [True: 0, False: 595k] | | | | | | | | | | ------------------ | | | | | | | | | | 68| 595k| !(condition) ? (void)0 : ::absl::log_internal::Voidify()&& | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (68:5): [True: 595k, Folded] | | | | | | | | | | | Branch (68:7): [True: 0, Folded] | | | | | | | | | | | Branch (68:7): [True: 0, False: 0] | | | | | | | | | | | Branch (68:7): [Folded, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 27| 1.19M| ABSL_PREDICT_FALSE(!(condition))) \ | | | | | | 28| 1.19M| ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream() | | | | | | ------------------ | | | | | | | | 66| 0| ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 476| 595k| return *static_cast(this); 477| 595k|} _ZN6google8protobuf11MessageLiteD2Ev: 511| 50.9k| PROTOBUF_VIRTUAL ~MessageLite() = default; _ZN6google8protobuf8internal16InternalMetadataC2EPNS0_5ArenaE: 46| 12.9k| explicit InternalMetadata(Arena* arena) { 47| 12.9k| ptr_ = reinterpret_cast(arena); 48| 12.9k| } _ZNK6google8protobuf8internal16InternalMetadata5arenaEv: 65| 57.1k| PROTOBUF_NDEBUG_INLINE Arena* arena() const { 66| 57.1k| if (PROTOBUF_PREDICT_FALSE(have_unknown_fields())) { ------------------ | | 365| 57.1k|# define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(false || (x), false)) | | ------------------ | | | Branch (365:36): [True: 0, False: 57.1k] | | | Branch (365:54): [Folded, False: 57.1k] | | | Branch (365:63): [True: 0, False: 57.1k] | | ------------------ ------------------ 67| 0| return PtrValue()->arena; 68| 57.1k| } else { 69| 57.1k| return PtrValue(); 70| 57.1k| } 71| 57.1k| } _ZNK6google8protobuf8internal16InternalMetadata19have_unknown_fieldsEv: 73| 135k| PROTOBUF_NDEBUG_INLINE bool have_unknown_fields() const { 74| 135k| return HasUnknownFieldsTag(); 75| 135k| } _ZN6google8protobuf8internal16InternalMetadata12InternalSwapEPS2_: 114| 230| InternalMetadata* PROTOBUF_RESTRICT other) { 115| 230| std::swap(ptr_, other->ptr_); 116| 230| } _ZNK6google8protobuf8internal16InternalMetadata19HasUnknownFieldsTagEv: 141| 135k| PROTOBUF_ALWAYS_INLINE bool HasUnknownFieldsTag() const { 142| 135k| return ptr_ & kUnknownFieldsTagMask; 143| 135k| } _ZNK6google8protobuf8internal16InternalMetadata8PtrValueINS0_5ArenaEEEPT_v: 146| 57.1k| U* PtrValue() const { 147| 57.1k| return reinterpret_cast(ptr_ & kPtrValueMask); 148| 57.1k| } _ZNK6google8protobuf8internal16InternalMetadata14unknown_fieldsINS0_15UnknownFieldSetEEERKT_PFS7_vE: 83| 19| const T& (*default_instance)()) const { 84| 19| if (PROTOBUF_PREDICT_FALSE(have_unknown_fields())) { ------------------ | | 365| 19|# define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(false || (x), false)) | | ------------------ | | | Branch (365:36): [True: 0, False: 19] | | | Branch (365:54): [Folded, False: 19] | | | Branch (365:63): [True: 0, False: 19] | | ------------------ ------------------ 85| 0| return PtrValue>()->unknown_fields; 86| 19| } else { 87| 19| return default_instance(); 88| 19| } 89| 19| } _ZN6google8protobuf8internal16InternalMetadata6DeleteINS0_15UnknownFieldSetEEEvv: 58| 50.9k| void Delete() { 59| | // Note that Delete<> should be called not more than once. 60| 50.9k| if (have_unknown_fields()) { ------------------ | Branch (60:9): [True: 0, False: 50.9k] ------------------ 61| 0| DeleteOutOfLineHelper(); 62| 0| } 63| 50.9k| } _ZN6google8protobuf8internal16InternalMetadata9MergeFromINS0_15UnknownFieldSetEEEvRKS2_: 119| 1.70k| PROTOBUF_NDEBUG_INLINE void MergeFrom(const InternalMetadata& other) { 120| 1.70k| if (other.have_unknown_fields()) { ------------------ | Branch (120:9): [True: 0, False: 1.70k] ------------------ 121| 0| DoMergeFrom(other.unknown_fields(nullptr)); 122| 0| } 123| 1.70k| } _ZN6google8protobuf8internal16InternalMetadata5ClearINS0_15UnknownFieldSetEEEvv: 126| 24.2k| PROTOBUF_NDEBUG_INLINE void Clear() { 127| 24.2k| if (have_unknown_fields()) { ------------------ | Branch (127:9): [True: 0, False: 24.2k] ------------------ 128| 0| DoClear(); 129| 0| } 130| 24.2k| } _ZN6google8protobuf8internal8TSanReadEPKv: 365| 726k|inline PROTOBUF_ALWAYS_INLINE void TSanRead(const void*) {} _ZN6google8protobuf8internal24Prefetch5LinesFrom7LinesEPKv: 314| 1.04k|inline PROTOBUF_ALWAYS_INLINE void Prefetch5LinesFrom7Lines(const void* ptr) { 315| 1.04k| PROTOBUF_PREFETCH_WITH_OFFSET(ptr, 448); ------------------ | | 670| 1.04k| asm("prefetcht0 " #offset "(%0)" : : "r"(base)); ------------------ 316| 1.04k| PROTOBUF_PREFETCH_WITH_OFFSET(ptr, 512); ------------------ | | 670| 1.04k| asm("prefetcht0 " #offset "(%0)" : : "r"(base)); ------------------ 317| 1.04k| PROTOBUF_PREFETCH_WITH_OFFSET(ptr, 576); ------------------ | | 670| 1.04k| asm("prefetcht0 " #offset "(%0)" : : "r"(base)); ------------------ 318| 1.04k| PROTOBUF_PREFETCH_WITH_OFFSET(ptr, 640); ------------------ | | 670| 1.04k| asm("prefetcht0 " #offset "(%0)" : : "r"(base)); ------------------ 319| 1.04k| PROTOBUF_PREFETCH_WITH_OFFSET(ptr, 704); ------------------ | | 670| 1.04k| asm("prefetcht0 " #offset "(%0)" : : "r"(base)); ------------------ 320| 1.04k|} _ZN6google8protobuf8internal9TSanWriteEPKv: 366| 25.6k|inline PROTOBUF_ALWAYS_INLINE void TSanWrite(const void*) {} _ZN6google8protobuf8internal20PrefetchToLocalCacheEPKv: 371| 1.27M|inline void PrefetchToLocalCache(const void* ptr) { 372| 1.27M| absl::PrefetchToLocalCache(ptr); 373| 1.27M|} _ZN6google8protobuf8internal20RepeatedPtrFieldBaseC2EPNS0_5ArenaE: 146| 87| : tagged_rep_or_elem_(nullptr), 147| 87| current_size_(0), 148| 87| capacity_proxy_(0), 149| 87| arena_(arena) {} _ZN6google8protobuf8internal20RepeatedPtrFieldBaseD2Ev: 154| 45.2k| ~RepeatedPtrFieldBase() { 155| |#ifndef NDEBUG 156| | // Try to trigger segfault / asan failure in non-opt builds if arena_ 157| | // lifetime has ended before the destructor. 158| | if (arena_) (void)arena_->SpaceAllocated(); 159| |#endif 160| 45.2k| } _ZNK6google8protobuf8internal20RepeatedPtrFieldBase4sizeEv: 163| 160k| int size() const { return current_size_; } _ZNK6google8protobuf8internal20RepeatedPtrFieldBase12NeedsDestroyEv: 239| 45.2k| inline bool NeedsDestroy() const { 240| | // Either there is an allocated element in SSO buffer or there is an 241| | // allocated Rep. 242| 45.2k| return tagged_rep_or_elem_ != nullptr; 243| 45.2k| } _ZNK6google8protobuf8internal20RepeatedPtrFieldBase8raw_dataEv: 347| 1.09k| void* const* raw_data() const { return elements(); } _ZN6google8protobuf8internal20RepeatedPtrFieldBase19ExchangeCurrentSizeEi: 602| 5.24k| inline int ExchangeCurrentSize(int new_size) { 603| 5.24k| return std::exchange(current_size_, new_size); 604| 5.24k| } _ZNK6google8protobuf8internal20RepeatedPtrFieldBase8elementsEv: 625| 1.09k| void* const* elements() const { 626| 1.09k| return using_sso() ? &tagged_rep_or_elem_ : +rep()->elements; ------------------ | Branch (626:12): [True: 916, False: 182] ------------------ 627| 1.09k| } _ZN6google8protobuf8internal20RepeatedPtrFieldBase8elementsEv: 628| 4.11k| void** elements() { 629| 4.11k| return using_sso() ? &tagged_rep_or_elem_ : +rep()->elements; ------------------ | Branch (629:12): [True: 3.78k, False: 328] ------------------ 630| 4.11k| } _ZN6google8protobuf8internal20RepeatedPtrFieldBase10element_atEi: 632| 21.0k| void*& element_at(int index) { 633| 21.0k| if (using_sso()) { ------------------ | Branch (633:9): [True: 15.9k, False: 5.15k] ------------------ 634| 15.9k| ABSL_DCHECK_EQ(index, 0); ------------------ | | 74| 15.9k| ABSL_LOG_INTERNAL_DCHECK_EQ_IMPL((val1), #val1, (val2), #val2) | | ------------------ | | | | 86| 15.9k| ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2) | | | | ------------------ | | | | | | 56| 15.9k| while (false && ((void)(x), (void)(y), 0)) \ | | | | | | ------------------ | | | | | | | Branch (56:10): [Folded, False: 15.9k] | | | | | | | Branch (56:19): [Folded, False: 0] | | | | | | ------------------ | | | | | | 57| 15.9k| ::absl::log_internal::NullStream().InternalStream() | | | | ------------------ | | ------------------ ------------------ 635| 15.9k| return tagged_rep_or_elem_; 636| 15.9k| } 637| 5.15k| return rep()->elements[index]; 638| 21.0k| } _ZNK6google8protobuf8internal20RepeatedPtrFieldBase10element_atEi: 639| 12.3k| const void* element_at(int index) const { 640| 12.3k| return const_cast(this)->element_at(index); 641| 12.3k| } _ZN6google8protobuf8internal20RepeatedPtrFieldBase3repEv: 647| 7.90k| Rep* rep() { 648| 7.90k| ABSL_DCHECK(!using_sso()); ------------------ | | 47| 7.90k| ABSL_LOG_INTERNAL_DCHECK_IMPL((condition), #condition) | | ------------------ | | | | 43| 7.90k| ABSL_LOG_INTERNAL_CHECK_IMPL(true || (condition), "true") | | | | ------------------ | | | | | | 26| 15.8k| ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS, \ | | | | | | ------------------ | | | | | | | | 172| 7.90k| ABSL_LOG_INTERNAL_##type##_CONDITION(condition) | | | | | | | | ------------------ | | | | | | | | | | 65| 15.8k| switch (0) \ | | | | | | | | | | 66| 15.8k| case 0: \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (66:3): [True: 7.90k, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 67| 7.90k| default: \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (67:3): [True: 0, False: 7.90k] | | | | | | | | | | ------------------ | | | | | | | | | | 68| 7.90k| !(condition) ? (void)0 : ::absl::log_internal::Voidify()&& | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (68:5): [True: 7.90k, Folded] | | | | | | | | | | | Branch (68:7): [True: 0, Folded] | | | | | | | | | | | Branch (68:7): [True: 0, False: 0] | | | | | | | | | | | Branch (68:7): [Folded, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 27| 15.8k| ABSL_PREDICT_FALSE(!(condition))) \ | | | | | | 28| 15.8k| ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream() | | | | | | ------------------ | | | | | | | | 66| 0| ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 649| 7.90k| return reinterpret_cast( 650| 7.90k| reinterpret_cast(tagged_rep_or_elem_) - 1); 651| 7.90k| } _ZNK6google8protobuf8internal20RepeatedPtrFieldBase3repEv: 652| 889| const Rep* rep() const { 653| 889| return const_cast(this)->rep(); 654| 889| } _ZNK6google8protobuf8internal20RepeatedPtrFieldBase9using_ssoEv: 656| 52.3k| bool using_sso() const { 657| 52.3k| return (reinterpret_cast(tagged_rep_or_elem_) & 1) == 0; 658| 52.3k| } _ZNK6google8protobuf16RepeatedPtrFieldIN16protobuf_mutator3xml4MiskEE4sizeEv: 1340| 31.1k|inline int RepeatedPtrField::size() const { 1341| 31.1k| return RepeatedPtrFieldBase::size(); 1342| 31.1k|} _ZN6google8protobuf16RepeatedPtrFieldIN16protobuf_mutator3xml4MiskEE5ClearEv: 1469| 4|inline void RepeatedPtrField::Clear() { 1470| 4| RepeatedPtrFieldBase::Clear(); 1471| 4|} _ZN6google8protobuf8internal20RepeatedPtrFieldBase5ClearINS1_18GenericTypeHandlerIN16protobuf_mutator3xml4MiskEEEEEvv: 265| 4| void Clear() { 266| 4| const int n = current_size_; 267| 4| ABSL_DCHECK_GE(n, 0); ------------------ | | 82| 4| ABSL_LOG_INTERNAL_DCHECK_GE_IMPL((val1), #val1, (val2), #val2) | | ------------------ | | | | 94| 4| ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2) | | | | ------------------ | | | | | | 56| 4| while (false && ((void)(x), (void)(y), 0)) \ | | | | | | ------------------ | | | | | | | Branch (56:10): [Folded, False: 4] | | | | | | | Branch (56:19): [Folded, False: 0] | | | | | | ------------------ | | | | | | 57| 4| ::absl::log_internal::NullStream().InternalStream() | | | | ------------------ | | ------------------ ------------------ 268| 4| if (n > 0) { ------------------ | Branch (268:9): [True: 0, False: 4] ------------------ 269| 0| using H = CommonHandler; 270| 0| ClearNonEmpty(); 271| 0| } 272| 4| } _ZN6google8protobuf8internal20RepeatedPtrFieldBase4castINS1_18GenericTypeHandlerINS0_11MessageLiteEEEEEPNT_4TypeEPv: 661| 4.80k| static inline Value* cast(void* element) { 662| 4.80k| return reinterpret_cast*>(element); 663| 4.80k| } _ZNK6google8protobuf16RepeatedPtrFieldIN16protobuf_mutator3xml4MiskEE3GetEi: 1346| 422| ABSL_ATTRIBUTE_LIFETIME_BOUND { 1347| 422| return RepeatedPtrFieldBase::Get(index); 1348| 422|} _ZNK6google8protobuf8internal20RepeatedPtrFieldBase3GetINS1_18GenericTypeHandlerIN16protobuf_mutator3xml4MiskEEEEERKNT_4TypeEi: 252| 422| const Value& Get(int index) const { 253| 422| ABSL_DCHECK_GE(index, 0); ------------------ | | 82| 422| ABSL_LOG_INTERNAL_DCHECK_GE_IMPL((val1), #val1, (val2), #val2) | | ------------------ | | | | 94| 422| ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2) | | | | ------------------ | | | | | | 56| 422| while (false && ((void)(x), (void)(y), 0)) \ | | | | | | ------------------ | | | | | | | Branch (56:10): [Folded, False: 422] | | | | | | | Branch (56:19): [Folded, False: 0] | | | | | | ------------------ | | | | | | 57| 422| ::absl::log_internal::NullStream().InternalStream() | | | | ------------------ | | ------------------ ------------------ 254| 422| ABSL_DCHECK_LT(index, current_size_); ------------------ | | 80| 422| ABSL_LOG_INTERNAL_DCHECK_LT_IMPL((val1), #val1, (val2), #val2) | | ------------------ | | | | 92| 422| ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2) | | | | ------------------ | | | | | | 56| 422| while (false && ((void)(x), (void)(y), 0)) \ | | | | | | ------------------ | | | | | | | Branch (56:10): [Folded, False: 422] | | | | | | | Branch (56:19): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 57| 422| ::absl::log_internal::NullStream().InternalStream() | | | | ------------------ | | ------------------ ------------------ 255| 422| return *cast(element_at(index)); 256| 422| } _ZN6google8protobuf8internal20RepeatedPtrFieldBase4castINS1_18GenericTypeHandlerIN16protobuf_mutator3xml4MiskEEEEEPKNT_4TypeEPKv: 665| 422| static inline const Value* cast(const void* element) { 666| 422| return reinterpret_cast*>(element); 667| 422| } _ZNK6google8protobuf16RepeatedPtrFieldIN16protobuf_mutator3xml7ContentEE4sizeEv: 1340| 19.2k|inline int RepeatedPtrField::size() const { 1341| 19.2k| return RepeatedPtrFieldBase::size(); 1342| 19.2k|} _ZNK6google8protobuf16RepeatedPtrFieldIN16protobuf_mutator3xml7ContentEE3GetEi: 1346| 3.55k| ABSL_ATTRIBUTE_LIFETIME_BOUND { 1347| 3.55k| return RepeatedPtrFieldBase::Get(index); 1348| 3.55k|} _ZNK6google8protobuf8internal20RepeatedPtrFieldBase3GetINS1_18GenericTypeHandlerIN16protobuf_mutator3xml7ContentEEEEERKNT_4TypeEi: 252| 3.55k| const Value& Get(int index) const { 253| 3.55k| ABSL_DCHECK_GE(index, 0); ------------------ | | 82| 3.55k| ABSL_LOG_INTERNAL_DCHECK_GE_IMPL((val1), #val1, (val2), #val2) | | ------------------ | | | | 94| 3.55k| ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2) | | | | ------------------ | | | | | | 56| 3.55k| while (false && ((void)(x), (void)(y), 0)) \ | | | | | | ------------------ | | | | | | | Branch (56:10): [Folded, False: 3.55k] | | | | | | | Branch (56:19): [Folded, False: 0] | | | | | | ------------------ | | | | | | 57| 3.55k| ::absl::log_internal::NullStream().InternalStream() | | | | ------------------ | | ------------------ ------------------ 254| 3.55k| ABSL_DCHECK_LT(index, current_size_); ------------------ | | 80| 3.55k| ABSL_LOG_INTERNAL_DCHECK_LT_IMPL((val1), #val1, (val2), #val2) | | ------------------ | | | | 92| 3.55k| ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2) | | | | ------------------ | | | | | | 56| 3.55k| while (false && ((void)(x), (void)(y), 0)) \ | | | | | | ------------------ | | | | | | | Branch (56:10): [Folded, False: 3.55k] | | | | | | | Branch (56:19): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 57| 3.55k| ::absl::log_internal::NullStream().InternalStream() | | | | ------------------ | | ------------------ ------------------ 255| 3.55k| return *cast(element_at(index)); 256| 3.55k| } _ZN6google8protobuf8internal20RepeatedPtrFieldBase4castINS1_18GenericTypeHandlerIN16protobuf_mutator3xml7ContentEEEEEPKNT_4TypeEPKv: 665| 3.55k| static inline const Value* cast(const void* element) { 666| 3.55k| return reinterpret_cast*>(element); 667| 3.55k| } _ZNK6google8protobuf16RepeatedPtrFieldIN16protobuf_mutator3xml9AttributeEE4sizeEv: 1340| 12.7k|inline int RepeatedPtrField::size() const { 1341| 12.7k| return RepeatedPtrFieldBase::size(); 1342| 12.7k|} _ZNK6google8protobuf16RepeatedPtrFieldIN16protobuf_mutator3xml9AttributeEE3GetEi: 1346| 766| ABSL_ATTRIBUTE_LIFETIME_BOUND { 1347| 766| return RepeatedPtrFieldBase::Get(index); 1348| 766|} _ZNK6google8protobuf8internal20RepeatedPtrFieldBase3GetINS1_18GenericTypeHandlerIN16protobuf_mutator3xml9AttributeEEEEERKNT_4TypeEi: 252| 766| const Value& Get(int index) const { 253| 766| ABSL_DCHECK_GE(index, 0); ------------------ | | 82| 766| ABSL_LOG_INTERNAL_DCHECK_GE_IMPL((val1), #val1, (val2), #val2) | | ------------------ | | | | 94| 766| ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2) | | | | ------------------ | | | | | | 56| 766| while (false && ((void)(x), (void)(y), 0)) \ | | | | | | ------------------ | | | | | | | Branch (56:10): [Folded, False: 766] | | | | | | | Branch (56:19): [Folded, False: 0] | | | | | | ------------------ | | | | | | 57| 766| ::absl::log_internal::NullStream().InternalStream() | | | | ------------------ | | ------------------ ------------------ 254| 766| ABSL_DCHECK_LT(index, current_size_); ------------------ | | 80| 766| ABSL_LOG_INTERNAL_DCHECK_LT_IMPL((val1), #val1, (val2), #val2) | | ------------------ | | | | 92| 766| ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2) | | | | ------------------ | | | | | | 56| 766| while (false && ((void)(x), (void)(y), 0)) \ | | | | | | ------------------ | | | | | | | Branch (56:10): [Folded, False: 766] | | | | | | | Branch (56:19): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 57| 766| ::absl::log_internal::NullStream().InternalStream() | | | | ------------------ | | ------------------ ------------------ 255| 766| return *cast(element_at(index)); 256| 766| } _ZN6google8protobuf8internal20RepeatedPtrFieldBase4castINS1_18GenericTypeHandlerIN16protobuf_mutator3xml9AttributeEEEEEPKNT_4TypeEPKv: 665| 766| static inline const Value* cast(const void* element) { 666| 766| return reinterpret_cast*>(element); 667| 766| } _ZN6google8protobuf16RepeatedPtrFieldIN16protobuf_mutator3xml4MiskEE19StaticValidityCheckEv: 938| 30.7k| static constexpr PROTOBUF_ALWAYS_INLINE void StaticValidityCheck() { 939| 30.7k| static_assert( 940| 30.7k| absl::disjunction< 941| 30.7k| internal::is_supported_string_type, 942| 30.7k| internal::is_supported_message_type>::value, 943| 30.7k| "We only support string and Message types in RepeatedPtrField."); 944| 30.7k| } _ZN6google8protobuf16RepeatedPtrFieldIN16protobuf_mutator3xml4MiskEED2Ev: 1285| 30.7k|RepeatedPtrField::~RepeatedPtrField() { 1286| 30.7k| StaticValidityCheck(); 1287| 30.7k| if (!NeedsDestroy()) return; ------------------ | Branch (1287:7): [True: 30.3k, False: 415] ------------------ 1288| 415|#ifdef __cpp_if_constexpr 1289| 415| if constexpr (std::is_base_of::value) { 1290| |#else 1291| | if (std::is_base_of::value) { 1292| |#endif 1293| 415| DestroyProtos(); 1294| | } else { 1295| | Destroy(); 1296| | } 1297| 415|} _ZN6google8protobuf16RepeatedPtrFieldIN16protobuf_mutator3xml7ContentEE19StaticValidityCheckEv: 938| 6.98k| static constexpr PROTOBUF_ALWAYS_INLINE void StaticValidityCheck() { 939| 6.98k| static_assert( 940| 6.98k| absl::disjunction< 941| 6.98k| internal::is_supported_string_type, 942| 6.98k| internal::is_supported_message_type>::value, 943| 6.98k| "We only support string and Message types in RepeatedPtrField."); 944| 6.98k| } _ZN6google8protobuf16RepeatedPtrFieldIN16protobuf_mutator3xml7ContentEED2Ev: 1285| 6.98k|RepeatedPtrField::~RepeatedPtrField() { 1286| 6.98k| StaticValidityCheck(); 1287| 6.98k| if (!NeedsDestroy()) return; ------------------ | Branch (1287:7): [True: 3.72k, False: 3.26k] ------------------ 1288| 3.26k|#ifdef __cpp_if_constexpr 1289| 3.26k| if constexpr (std::is_base_of::value) { 1290| |#else 1291| | if (std::is_base_of::value) { 1292| |#endif 1293| 3.26k| DestroyProtos(); 1294| | } else { 1295| | Destroy(); 1296| | } 1297| 3.26k|} _ZN6google8protobuf16RepeatedPtrFieldIN16protobuf_mutator3xml9AttributeEE19StaticValidityCheckEv: 938| 6.96k| static constexpr PROTOBUF_ALWAYS_INLINE void StaticValidityCheck() { 939| 6.96k| static_assert( 940| 6.96k| absl::disjunction< 941| 6.96k| internal::is_supported_string_type, 942| 6.96k| internal::is_supported_message_type>::value, 943| 6.96k| "We only support string and Message types in RepeatedPtrField."); 944| 6.96k| } _ZN6google8protobuf16RepeatedPtrFieldIN16protobuf_mutator3xml9AttributeEED2Ev: 1285| 6.96k|RepeatedPtrField::~RepeatedPtrField() { 1286| 6.96k| StaticValidityCheck(); 1287| 6.96k| if (!NeedsDestroy()) return; ------------------ | Branch (1287:7): [True: 6.65k, False: 306] ------------------ 1288| 306|#ifdef __cpp_if_constexpr 1289| 306| if constexpr (std::is_base_of::value) { 1290| |#else 1291| | if (std::is_base_of::value) { 1292| |#endif 1293| 306| DestroyProtos(); 1294| | } else { 1295| | Destroy(); 1296| | } 1297| 306|} _ZN6google8protobuf10TextFormat6Parser19AllowPartialMessageEb: 703| 12.0k| void AllowPartialMessage(bool allow) { allow_partial_ = allow; } _ZN6google8protobuf10TextFormat6Parser17AllowUnknownFieldEb: 734| 12.0k| void AllowUnknownField(bool allow) { allow_unknown_field_ = allow; } _ZN6google8protobuf10TextFormat6Parser17SetRecursionLimitEi: 741| 12.0k| void SetRecursionLimit(int limit) { recursion_limit_ = limit; } _ZN6google8protobuf15UnknownFieldSet16default_instanceEv: 320| 19|inline const UnknownFieldSet& UnknownFieldSet::default_instance() { 321| 19| PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT static const UnknownFieldSet ------------------ | | 481| 19|#define PROTOBUF_ATTRIBUTE_NO_DESTROY [[clang::no_destroy]] ------------------ 322| 19| instance; 323| 19| return instance; 324| 19|} _ZN6google8protobuf8internal10WireFormat26VerifyUTF8StringNamedFieldEPKciNS2_9OperationENSt3__117basic_string_viewIcNS6_11char_traitsIcEEEE: 357| 29| const absl::string_view field_name) { 358| |#ifdef GOOGLE_PROTOBUF_UTF8_VALIDATION_ENABLED 359| | WireFormatLite::VerifyUtf8String( 360| | data, size, static_cast(op), field_name); 361| |#else 362| | // Avoid the compiler warning about unused variables. 363| 29| (void)data; 364| 29| (void)size; 365| 29| (void)op; 366| 29| (void)field_name; 367| 29|#endif 368| 29|} _ZN6google8protobuf8internal14WireFormatLite7MakeTagEiNS2_8WireTypeE: 828| 2.19k| WireType type) { 829| 2.19k| return GOOGLE_PROTOBUF_WIRE_FORMAT_MAKE_TAG(field_number, type); ------------------ | | 191| 2.19k| static_cast((static_cast(FIELD_NUMBER) << 3) | (TYPE)) ------------------ 830| 2.19k|} _ZN6google8protobuf8internal14WireFormatLite15WriteTagToArrayEiNS2_8WireTypeEPh: 1415| 2.19k| uint8_t* target) { 1416| 2.19k| return io::CodedOutputStream::WriteTagToArray(MakeTag(field_number, type), 1417| 2.19k| target); 1418| 2.19k|} _ZN6google8protobuf8internal14WireFormatLite21WriteBoolNoTagToArrayEbPh: 1476| 428| uint8_t* target) { 1477| 428| return io::CodedOutputStream::WriteVarint32ToArray(value ? 1 : 0, target); ------------------ | Branch (1477:54): [True: 215, False: 213] ------------------ 1478| 428|} _ZN6google8protobuf8internal14WireFormatLite16WriteBoolToArrayEibPh: 1648| 428| uint8_t* target) { 1649| 428| target = WriteTagToArray(field_number, WIRETYPE_VARINT, target); 1650| 428| return WriteBoolNoTagToArray(value, target); 1651| 428|} _ZN6google8protobuf8internal14WireFormatLite10StringSizeERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE: 1825| 29|inline size_t WireFormatLite::StringSize(const std::string& value) { 1826| 29| return LengthDelimitedSize(value.size()); 1827| 29|} _ZN6google8protobuf8internal14WireFormatLite19LengthDelimitedSizeEm: 1873| 472|inline size_t WireFormatLite::LengthDelimitedSize(size_t length) { 1874| | // The static_cast here prevents an error in certain compiler configurations 1875| | // but is not technically correct--if length is too large to fit in a uint32_t 1876| | // then it will be silently truncated. We will need to fix this if we ever 1877| | // decide to start supporting serialized messages greater than 2 GiB in size. 1878| 472| return length + 1879| 472| io::CodedOutputStream::VarintSize32(static_cast(length)); 1880| 472|} _ZN6google8protobuf8internal22GetAnyFieldDescriptorsERKNS0_7MessageEPPKNS0_15FieldDescriptorES8_: 45| 63.5k| const FieldDescriptor** value_field) { 46| 63.5k| const Descriptor* descriptor = message.GetDescriptor(); 47| 63.5k| if (descriptor->full_name() != kAnyFullTypeName) { ------------------ | Branch (47:7): [True: 63.5k, False: 0] ------------------ 48| 63.5k| return false; 49| 63.5k| } 50| 0| *type_url_field = descriptor->FindFieldByNumber(1); 51| 0| *value_field = descriptor->FindFieldByNumber(2); 52| 0| return (*type_url_field != nullptr && ------------------ | Branch (52:11): [True: 0, False: 0] ------------------ 53| 0| (*type_url_field)->type() == FieldDescriptor::TYPE_STRING && ------------------ | Branch (53:11): [True: 0, False: 0] ------------------ 54| 0| *value_field != nullptr && ------------------ | Branch (54:11): [True: 0, False: 0] ------------------ 55| 0| (*value_field)->type() == FieldDescriptor::TYPE_BYTES); ------------------ | Branch (55:11): [True: 0, False: 0] ------------------ 56| 63.5k|} _ZNK6google8protobuf3Any12GetClassDataEv: 220| 98.3k|const ::google::protobuf::internal::ClassData* Any::GetClassData() const { 221| 98.3k| ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_); 222| 98.3k| ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table); 223| 98.3k| return _class_data_.base(); 224| 98.3k|} _ZNK6google8protobuf3Any11GetMetadataEv: 383| 98.3k|::google::protobuf::Metadata Any::GetMetadata() const { 384| 98.3k| return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); 385| 98.3k|} _ZN6google8protobuf8internal7cleanup9ChunkList7CleanupERKNS1_11SerialArenaE: 148| 5|void ChunkList::Cleanup(const SerialArena& arena) { 149| 5| Chunk* c = head_; 150| 5| if (c == nullptr) return; ------------------ | Branch (150:7): [True: 5, False: 0] ------------------ 151| 0| GetDeallocator deallocator(arena.parent_.AllocPolicy()); 152| | 153| | // Iterate backwards in order to destroy in the right order. 154| 0| CleanupNode* it = next_ - 1; 155| 0| while (true) { ------------------ | Branch (155:10): [True: 0, Folded] ------------------ 156| 0| CleanupNode* first = c->First(); 157| | // A prefetch distance of 8 here was chosen arbitrarily. 158| 0| constexpr int kPrefetchDistance = 8; 159| 0| CleanupNode* prefetch = it; 160| | // Prefetch the first kPrefetchDistance nodes. 161| 0| for (int i = 0; prefetch >= first && i < kPrefetchDistance; ------------------ | Branch (161:21): [True: 0, False: 0] | Branch (161:42): [True: 0, False: 0] ------------------ 162| 0| --prefetch, ++i) { 163| 0| prefetch->Prefetch(); 164| 0| } 165| | // For the middle nodes, run destructor and prefetch the node 166| | // kPrefetchDistance after the current one. 167| 0| for (; prefetch >= first; --it, --prefetch) { ------------------ | Branch (167:12): [True: 0, False: 0] ------------------ 168| 0| it->Destroy(); 169| 0| prefetch->Prefetch(); 170| 0| } 171| | // Note: we could consider prefetching `next` chunk earlier. 172| 0| absl::PrefetchToLocalCacheNta(c->next); 173| | // Destroy the rest without prefetching. 174| 0| for (; it >= first; --it) { ------------------ | Branch (174:12): [True: 0, False: 0] ------------------ 175| 0| it->Destroy(); 176| 0| } 177| 0| Chunk* next = c->next; 178| 0| deallocator({c, c->size}); 179| 0| if (next == nullptr) return; ------------------ | Branch (179:9): [True: 0, False: 0] ------------------ 180| 0| c = next; 181| 0| it = c->Last(); 182| 0| }; 183| 0|} _ZN6google8protobuf8internal11SerialArena23AllocateAlignedFallbackEm: 272| 21|void* SerialArena::AllocateAlignedFallback(size_t n) { 273| 21| AllocateNewBlock(n); 274| 21| void* ret = nullptr; 275| 21| bool res = MaybeAllocateAligned(n, &ret); 276| 21| ABSL_DCHECK(res); ------------------ | | 47| 21| ABSL_LOG_INTERNAL_DCHECK_IMPL((condition), #condition) | | ------------------ | | | | 43| 21| ABSL_LOG_INTERNAL_CHECK_IMPL(true || (condition), "true") | | | | ------------------ | | | | | | 26| 42| ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS, \ | | | | | | ------------------ | | | | | | | | 172| 21| ABSL_LOG_INTERNAL_##type##_CONDITION(condition) | | | | | | | | ------------------ | | | | | | | | | | 65| 42| switch (0) \ | | | | | | | | | | 66| 42| case 0: \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (66:3): [True: 21, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 67| 21| default: \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (67:3): [True: 0, False: 21] | | | | | | | | | | ------------------ | | | | | | | | | | 68| 21| !(condition) ? (void)0 : ::absl::log_internal::Voidify()&& | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (68:5): [True: 21, Folded] | | | | | | | | | | | Branch (68:7): [True: 0, Folded] | | | | | | | | | | | Branch (68:7): [True: 0, False: 0] | | | | | | | | | | | Branch (68:7): [Folded, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 27| 42| ABSL_PREDICT_FALSE(!(condition))) \ | | | | | | 28| 42| ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream() | | | | | | ------------------ | | | | | | | | 66| 0| ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 277| 21| return ret; 278| 21|} _ZN6google8protobuf8internal11SerialArena31AllocateFromStringBlockFallbackEv: 281| 16|void* SerialArena::AllocateFromStringBlockFallback() { 282| 16| ABSL_DCHECK_EQ(string_block_unused_.load(std::memory_order_relaxed), 0U); ------------------ | | 74| 16| ABSL_LOG_INTERNAL_DCHECK_EQ_IMPL((val1), #val1, (val2), #val2) | | ------------------ | | | | 86| 16| ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2) | | | | ------------------ | | | | | | 56| 16| while (false && ((void)(x), (void)(y), 0)) \ | | | | | | ------------------ | | | | | | | Branch (56:10): [Folded, False: 16] | | | | | | | Branch (56:19): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 57| 16| ::absl::log_internal::NullStream().InternalStream() | | | | ------------------ | | ------------------ ------------------ 283| 16| StringBlock* sb = string_block_.load(std::memory_order_relaxed); 284| 16| if (sb) { ------------------ | Branch (284:7): [True: 12, False: 4] ------------------ 285| 12| AddSpaceUsed(sb->effective_size()); 286| 12| } 287| | 288| 16| void* ptr; 289| 16| StringBlock* new_sb; 290| 16| size_t size = StringBlock::NextSize(sb); 291| 16| if (MaybeAllocateAligned(size, &ptr)) { ------------------ | Branch (291:7): [True: 11, False: 5] ------------------ 292| | // Correct space_used_ to avoid double counting 293| 11| AddSpaceUsed(-size); 294| 11| new_sb = StringBlock::Emplace(ptr, size, sb); 295| 11| } else { 296| 5| new_sb = StringBlock::New(sb); 297| 5| AddSpaceAllocated(new_sb->allocated_size()); 298| 5| } 299| 16| string_block_.store(new_sb, std::memory_order_release); 300| 16| size_t unused = new_sb->effective_size() - sizeof(std::string); 301| 16| string_block_unused_.store(unused, std::memory_order_relaxed); 302| 16| return new_sb->AtOffset(unused); 303| 16|} _ZN6google8protobuf8internal11SerialArena16FreeStringBlocksEPNS1_11StringBlockEm: 369| 4| size_t unused_bytes) { 370| 4| ABSL_DCHECK(string_block != nullptr); ------------------ | | 47| 4| ABSL_LOG_INTERNAL_DCHECK_IMPL((condition), #condition) | | ------------------ | | | | 43| 4| ABSL_LOG_INTERNAL_CHECK_IMPL(true || (condition), "true") | | | | ------------------ | | | | | | 26| 8| ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS, \ | | | | | | ------------------ | | | | | | | | 172| 4| ABSL_LOG_INTERNAL_##type##_CONDITION(condition) | | | | | | | | ------------------ | | | | | | | | | | 65| 8| switch (0) \ | | | | | | | | | | 66| 8| case 0: \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (66:3): [True: 4, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 67| 4| default: \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (67:3): [True: 0, False: 4] | | | | | | | | | | ------------------ | | | | | | | | | | 68| 4| !(condition) ? (void)0 : ::absl::log_internal::Voidify()&& | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (68:5): [True: 4, Folded] | | | | | | | | | | | Branch (68:7): [True: 0, Folded] | | | | | | | | | | | Branch (68:7): [True: 0, False: 0] | | | | | | | | | | | Branch (68:7): [Folded, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 27| 8| ABSL_PREDICT_FALSE(!(condition))) \ | | | | | | 28| 8| ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream() | | | | | | ------------------ | | | | | | | | 66| 0| ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 371| 4| StringBlock* next = string_block->next(); 372| 4| absl::PrefetchToLocalCacheNta(next); 373| 4| std::string* end = string_block->end(); 374| 116| for (std::string* s = string_block->AtOffset(unused_bytes); s != end; ++s) { ------------------ | Branch (374:63): [True: 112, False: 4] ------------------ 375| 112| s->~basic_string(); 376| 112| } 377| 4| size_t deallocated = StringBlock::Delete(string_block); 378| | 379| 16| while ((string_block = next) != nullptr) { ------------------ | Branch (379:10): [True: 12, False: 4] ------------------ 380| 12| next = string_block->next(); 381| 12| absl::PrefetchToLocalCacheNta(next); 382| 406| for (std::string& s : *string_block) { ------------------ | Branch (382:25): [True: 406, False: 12] ------------------ 383| 406| s.~basic_string(); 384| 406| } 385| 12| deallocated += StringBlock::Delete(string_block); 386| 12| } 387| 4| return deallocated; 388| 4|} _ZN6google8protobuf8internal15ThreadSafeArena22SentrySerialArenaChunkEv: 539| 5|ThreadSafeArena::SerialArenaChunk* ThreadSafeArena::SentrySerialArenaChunk() { 540| | // const_cast is okay because the sentry chunk is never mutated. Also, 541| | // reinterpret_cast is acceptable here as it should be identical to 542| | // SerialArenaChunk with zero payload. This is a necessary trick to 543| | // constexpr initialize kSentryArenaChunk. 544| 5| return reinterpret_cast( 545| 5| const_cast(&kSentryArenaChunk)); 546| 5|} _ZN6google8protobuf8internal15ThreadSafeArenaC2Ev: 567| 5|ThreadSafeArena::ThreadSafeArena() : first_arena_(*this) { Init(); } _ZN6google8protobuf8internal15ThreadSafeArena18GetNextLifeCycleIdEv: 638| 5|uint64_t ThreadSafeArena::GetNextLifeCycleId() { 639| 5| ThreadCache& tc = thread_cache(); 640| 5| uint64_t id = tc.next_lifecycle_id; 641| 5| constexpr uint64_t kInc = ThreadCache::kPerThreadIds; 642| 5| if (PROTOBUF_PREDICT_FALSE((id & (kInc - 1)) == 0)) { ------------------ | | 365| 5|# define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(false || (x), false)) | | ------------------ | | | Branch (365:36): [True: 1, False: 4] | | | Branch (365:54): [Folded, False: 5] | | | Branch (365:63): [True: 1, False: 4] | | ------------------ ------------------ 643| | // On platforms that don't support uint64_t atomics we can certainly not 644| | // afford to increment by large intervals and expect uniqueness due to 645| | // wrapping, hence we only add by 1. 646| 1| id = lifecycle_id_.fetch_add(1, std::memory_order_relaxed) * kInc; 647| 1| } 648| 5| tc.next_lifecycle_id = id + 1; 649| 5| return id; 650| 5|} _ZN6google8protobuf8internal15ThreadSafeArena4InitEv: 719| 5|void ThreadSafeArena::Init() { 720| 5| tag_and_id_ = GetNextLifeCycleId(); 721| 5| arena_stats_ = Sample(); 722| 5| head_.store(SentrySerialArenaChunk(), std::memory_order_relaxed); 723| 5| first_owner_ = &thread_cache(); 724| | 725| | // Record allocation for the first block that was either user-provided or 726| | // newly allocated. 727| 5| ThreadSafeArenaStats::RecordAllocateStats( 728| 5| arena_stats_.MutableStats(), 729| 5| /*used=*/0, 730| 5| /*allocated=*/first_arena_.SpaceAllocated(), 731| 5| /*wasted=*/0); 732| | 733| 5| CacheSerialArena(&first_arena_); 734| 5|} _ZN6google8protobuf8internal15ThreadSafeArenaD2Ev: 736| 5|ThreadSafeArena::~ThreadSafeArena() { 737| | // Have to do this in a first pass, because some of the destructors might 738| | // refer to memory in other blocks. 739| 5| CleanupList(); 740| | 741| 5| auto mem = Free(); 742| 5| if (alloc_policy_.is_user_owned_initial_block()) { ------------------ | Branch (742:7): [True: 0, False: 5] ------------------ 743| | // Unpoison the initial block, now that it's going back to the user. 744| 0| PROTOBUF_UNPOISON_MEMORY_REGION(mem.p, mem.n); 745| 5| } else if (mem.n > 0) { ------------------ | Branch (745:14): [True: 0, False: 5] ------------------ 746| 0| GetDeallocator(alloc_policy_.get())(mem); 747| 0| } 748| 5|} _ZN6google8protobuf8internal15ThreadSafeArena4FreeEv: 750| 5|SizedPtr ThreadSafeArena::Free() { 751| 5| auto deallocator = GetDeallocator(alloc_policy_.get()); 752| | 753| 5| WalkSerialArenaChunk([&](SerialArenaChunk* chunk) { 754| 5| absl::Span> span = chunk->arenas(); 755| | // Walks arenas backward to handle the first serial arena the last. Freeing 756| | // in reverse-order to the order in which objects were created may not be 757| | // necessary to Free and we should revisit this. (b/247560530) 758| 5| for (auto it = span.rbegin(); it != span.rend(); ++it) { 759| 5| SerialArena* serial = it->load(std::memory_order_relaxed); 760| 5| ABSL_DCHECK_NE(serial, nullptr); 761| | // Always frees the first block of "serial" as it cannot be user-provided. 762| 5| SizedPtr mem = serial->Free(deallocator); 763| 5| ABSL_DCHECK_NE(mem.p, nullptr); 764| 5| deallocator(mem); 765| 5| } 766| | 767| | // Delete the chunk as we're done with it. 768| 5| internal::SizedDelete(chunk, 769| 5| SerialArenaChunk::AllocSize(chunk->capacity())); 770| 5| }); 771| | 772| | // The first block of the first arena is special and let the caller handle it. 773| 5| return first_arena_.Free(deallocator); 774| 5|} _ZN6google8protobuf8internal15ThreadSafeArena14GetSerialArenaEv: 823| 515|SerialArena* ThreadSafeArena::GetSerialArena() { 824| 515| SerialArena* arena; 825| 515| if (PROTOBUF_PREDICT_FALSE(!GetSerialArenaFast(&arena))) { ------------------ | | 365| 515|# define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(false || (x), false)) | | ------------------ | | | Branch (365:36): [True: 0, False: 515] | | | Branch (365:54): [Folded, False: 515] | | | Branch (365:63): [True: 0, False: 515] | | ------------------ ------------------ 826| 0| arena = GetSerialArenaFallback(kMaxCleanupNodeSize); 827| 0| } 828| 515| return arena; 829| 515|} _ZN6google8protobuf8internal15ThreadSafeArena23AllocateFromStringBlockEv: 839| 515|void* ThreadSafeArena::AllocateFromStringBlock() { 840| 515| return GetSerialArena()->AllocateFromStringBlock(); 841| 515|} _ZN6google8protobuf8internal15ThreadSafeArena11CleanupListEv: 917| 5|void ThreadSafeArena::CleanupList() { 918| |#ifdef PROTOBUF_ASAN 919| | UnpoisonAllArenaBlocks(); 920| |#endif 921| | 922| 5| WalkSerialArenaChunk([](SerialArenaChunk* chunk) { 923| 5| absl::Span> span = chunk->arenas(); 924| | // Walks arenas backward to handle the first serial arena the last. 925| | // Destroying in reverse-order to the construction is often assumed by users 926| | // and required not to break inter-object dependencies. (b/247560530) 927| 5| for (auto it = span.rbegin(); it != span.rend(); ++it) { 928| 5| SerialArena* serial = it->load(std::memory_order_relaxed); 929| 5| ABSL_DCHECK_NE(serial, nullptr); 930| 5| serial->CleanupList(); 931| 5| } 932| 5| }); 933| | // First arena must be cleaned up last. (b/247560530) 934| 5| first_arena_.CleanupList(); 935| 5|} _ZN6google8protobuf5Arena8AllocateEm: 974| 436|void* Arena::Allocate(size_t n) { return impl_.AllocateAligned(n); } _ZN6google8protobuf5Arena16AllocateForArrayEm: 976| 125|void* Arena::AllocateForArray(size_t n) { 977| 125| return impl_.AllocateAligned(n); 978| 125|} arena.cc:_ZN6google8protobuf8internal12_GLOBAL__N_114AllocationSizeEmmm: 64| 21| size_t max_size) { 65| 21| if (last_size == 0) return start_size; ------------------ | Branch (65:7): [True: 4, False: 17] ------------------ 66| | // Double the current block size, up to a limit. 67| 17| return std::min(2 * last_size, max_size); 68| 21|} arena.cc:_ZN6google8protobuf8internal12_GLOBAL__N_114AllocateMemoryERKNS1_16AllocationPolicyEm: 70| 21|SizedPtr AllocateMemory(const AllocationPolicy& policy, size_t size) { 71| 21| if (policy.block_alloc == nullptr) { ------------------ | Branch (71:7): [True: 21, False: 0] ------------------ 72| 21| return AllocateAtLeast(size); 73| 21| } 74| 0| return {policy.block_alloc(size), size}; 75| 21|} arena.cc:_ZN6google8protobuf8internal12_GLOBAL__N_114GetDeallocatorC2EPKNS1_16AllocationPolicyE: 105| 5| : dealloc_(policy ? policy->block_dealloc : nullptr) {} ------------------ | Branch (105:18): [True: 0, False: 5] ------------------ arena.cc:_ZNK6google8protobuf8internal12_GLOBAL__N_114GetDeallocatorclENS1_8SizedPtrE: 107| 21| void operator()(SizedPtr mem) const { 108| 21| if (dealloc_) { ------------------ | Branch (108:9): [True: 0, False: 21] ------------------ 109| 0| dealloc_(mem.p, mem.n); 110| 21| } else { 111| 21| internal::SizedDelete(mem.p, mem.n); 112| 21| } 113| 21| } _ZN6google8protobuf8internal11SerialArena16AllocateNewBlockEm: 313| 21|void SerialArena::AllocateNewBlock(size_t n) { 314| 21| size_t used = 0; 315| 21| size_t wasted = 0; 316| 21| ArenaBlock* old_head = head(); 317| 21| if (!old_head->IsSentry()) { ------------------ | Branch (317:7): [True: 17, False: 4] ------------------ 318| | // Record how much used in this block. 319| 17| used = static_cast(ptr() - old_head->Pointer(kBlockHeaderSize)); 320| 17| wasted = old_head->size - used - kBlockHeaderSize; 321| 17| AddSpaceUsed(used); 322| 17| } 323| | 324| | // TODO: Evaluate if pushing unused space into the cached blocks is a 325| | // win. In preliminary testing showed increased memory savings as expected, 326| | // but with a CPU regression. The regression might have been an artifact of 327| | // the microbenchmark. 328| | 329| 21| auto mem = AllocateBlock(parent_.AllocPolicy(), old_head->size, n); 330| 21| AddSpaceAllocated(mem.n); 331| 21| ThreadSafeArenaStats::RecordAllocateStats(parent_.arena_stats_.MutableStats(), 332| 21| /*used=*/used, 333| 21| /*allocated=*/mem.n, wasted); 334| 21| auto* new_head = new (mem.p) ArenaBlock{old_head, mem.n}; 335| 21| set_range(new_head->Pointer(kBlockHeaderSize), new_head->Limit()); 336| | // Previous writes must take effect before writing new head. 337| 21| head_.store(new_head, std::memory_order_release); 338| | 339| 21| PROTOBUF_POISON_MEMORY_REGION(ptr(), limit_ - ptr()); 340| 21|} _ZN6google8protobuf8internal11SerialArenaC2ERNS1_15ThreadSafeArenaE: 218| 5| : head_{SentryArenaBlock()}, parent_{parent} {} arena.cc:_ZN6google8protobuf8internal12_GLOBAL__N_116SentryArenaBlockEv: 56| 5|ArenaBlock* SentryArenaBlock() { 57| 5| static const ArenaBlock kSentryArenaBlock; 58| | // const_cast<> is okay as kSentryArenaBlock will never be mutated. 59| 5| return const_cast(&kSentryArenaBlock); 60| 5|} arena.cc:_ZN6google8protobuf8internal12_GLOBAL__N_113AllocateBlockEPKNS1_16AllocationPolicyEmm: 78| 21| size_t min_bytes) { 79| 21| AllocationPolicy policy; // default policy 80| 21| if (policy_ptr) policy = *policy_ptr; ------------------ | Branch (80:7): [True: 0, False: 21] ------------------ 81| 21| size_t size = 82| 21| AllocationSize(last_size, policy.start_block_size, policy.max_block_size); 83| | // Verify that min_bytes + kBlockHeaderSize won't overflow. 84| 21| ABSL_CHECK_LE(min_bytes, std::numeric_limits::max() - ------------------ | | 54| 21| ABSL_LOG_INTERNAL_CHECK_LE_IMPL((val1), #val1, (val2), #val2) | | ------------------ | | | | 52| 21| ABSL_LOG_INTERNAL_CHECK_OP(Check_LE, <=, val1, val1_text, val2, val2_text) | | | | ------------------ | | | | | | 61| 21| while ( \ | | | | | | 62| 21| ::std::string* absl_log_internal_check_op_result ABSL_ATTRIBUTE_UNUSED = \ | | | | | | ------------------ | | | | | | | Branch (62:22): [True: 0, False: 21] | | | | | | ------------------ | | | | | | 63| 21| ::absl::log_internal::name##Impl( \ | | | | | | 64| 21| ::absl::log_internal::GetReferenceableValue(val1), \ | | | | | | 65| 21| ::absl::log_internal::GetReferenceableValue(val2), \ | | | | | | 66| 21| ABSL_LOG_INTERNAL_STRIP_STRING_LITERAL(val1_text \ | | | | | | 67| 21| " " #op " " val2_text))) \ | | | | | | 68| 21| ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS, true) \ | | | | | | ------------------ | | | | | | | | 172| 0| ABSL_LOG_INTERNAL_##type##_CONDITION(condition) | | | | | | | | ------------------ | | | | | | | | | | 65| 0| switch (0) \ | | | | | | | | | | 66| 0| case 0: \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (66:3): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 67| 0| default: \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (67:3): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 68| 0| !(condition) ? (void)0 : ::absl::log_internal::Voidify()&& | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (68:5): [Folded, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 69| 0| ABSL_LOG_INTERNAL_CHECK(*absl_log_internal_check_op_result).InternalStream() | | | | | | ------------------ | | | | | | | | 66| 0| ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 85| 21| SerialArena::kBlockHeaderSize); 86| 21| size = std::max(size, SerialArena::kBlockHeaderSize + min_bytes); 87| | 88| 21| return AllocateMemory(policy, size); 89| 21|} _ZNK6google8protobuf8internal15ThreadSafeArena16SerialArenaChunk8IsSentryEv: 439| 10| bool IsSentry() const { return capacity() == 0; } _ZNK6google8protobuf8internal15ThreadSafeArena16SerialArenaChunk8capacityEv: 449| 10| uint32_t capacity() const { return header().capacity; } _ZNK6google8protobuf8internal15ThreadSafeArena16SerialArenaChunk6headerEv: 518| 10| const SerialArenaChunkHeader& header() const { 519| 10| return *layout_type::Partial().Pointer(ptr()); 520| 10| } _ZNK6google8protobuf8internal15ThreadSafeArena16SerialArenaChunk3ptrEv: 512| 10| const char* ptr() const { return reinterpret_cast(this); } arena.cc:_ZN6google8protobuf8internal11SerialArena4FreeINS1_12_GLOBAL__N_114GetDeallocatorEEENS1_8SizedPtrET_: 258| 5|SizedPtr SerialArena::Free(Deallocator deallocator) { 259| 5| FreeStringBlocks(); 260| | 261| 5| ArenaBlock* b = head(); 262| 5| SizedPtr mem = {b, b->size}; 263| 26| while (b->next) { ------------------ | Branch (263:10): [True: 21, False: 5] ------------------ 264| 21| b = b->next; // We must first advance before deleting this block 265| 21| deallocator(mem); 266| 21| mem = {b, b->size}; 267| 21| } 268| 5| return mem; 269| 5|} arena.cc:_ZN6google8protobuf8internal15ThreadSafeArena20WalkSerialArenaChunkIZNS2_4FreeEvE3$_0EEvT_: 855| 5|void ThreadSafeArena::WalkSerialArenaChunk(Callback fn) { 856| | // By omitting an Acquire barrier we help the sanitizer that any user code 857| | // that doesn't properly synchronize Reset() or the destructor will throw a 858| | // TSAN warning. 859| 5| SerialArenaChunk* chunk = head_.load(std::memory_order_relaxed); 860| | 861| 5| while (!chunk->IsSentry()) { ------------------ | Branch (861:10): [True: 0, False: 5] ------------------ 862| | // Cache next chunk in case this chunk is destroyed. 863| 0| SerialArenaChunk* next_chunk = chunk->next_chunk(); 864| | // Prefetch the next chunk. 865| 0| absl::PrefetchToLocalCache(next_chunk); 866| 0| fn(chunk); 867| 0| chunk = next_chunk; 868| 0| } 869| 5|} arena.cc:_ZN6google8protobuf8internal15ThreadSafeArena20WalkSerialArenaChunkIZNS2_11CleanupListEvE3$_0EEvT_: 855| 5|void ThreadSafeArena::WalkSerialArenaChunk(Callback fn) { 856| | // By omitting an Acquire barrier we help the sanitizer that any user code 857| | // that doesn't properly synchronize Reset() or the destructor will throw a 858| | // TSAN warning. 859| 5| SerialArenaChunk* chunk = head_.load(std::memory_order_relaxed); 860| | 861| 5| while (!chunk->IsSentry()) { ------------------ | Branch (861:10): [True: 0, False: 5] ------------------ 862| | // Cache next chunk in case this chunk is destroyed. 863| 0| SerialArenaChunk* next_chunk = chunk->next_chunk(); 864| | // Prefetch the next chunk. 865| 0| absl::PrefetchToLocalCache(next_chunk); 866| 0| fn(chunk); 867| 0| chunk = next_chunk; 868| 0| } 869| 5|} _ZN6google8protobuf5ArenaC2Ev: 173| 5| inline Arena() : impl_() {} _ZN6google8protobuf5Arena17ReturnArrayMemoryEPvm: 527| 44| void ReturnArrayMemory(void* p, size_t size) { 528| 44| impl_.ReturnArrayMemory(p, size); 529| 44| } _ZN6google8protobuf5Arena23AllocateAlignedForArrayEmm: 634| 125| void* AllocateAlignedForArray(size_t n, size_t align) { 635| 125| if (align <= internal::ArenaAlignDefault::align) { ------------------ | Branch (635:9): [True: 125, False: 0] ------------------ 636| 125| return AllocateForArray(internal::ArenaAlignDefault::Ceil(n)); 637| 125| } else { 638| | // We are wasting space by over allocating align - 8 bytes. Compared 639| | // to a dedicated function that takes current alignment in consideration. 640| | // Such a scheme would only waste (align - 8)/2 bytes on average, but 641| | // requires a dedicated function in the outline arena allocation 642| | // functions. Possibly re-evaluate tradeoffs later. 643| 0| auto align_as = internal::ArenaAlignAs(align); 644| 0| return align_as.Ceil(AllocateForArray(align_as.Padded(n))); 645| 0| } 646| 125| } _ZN6google8protobuf8internal23CanMoveWithInternalSwapEPNS0_5ArenaES3_: 101| 230|inline bool CanMoveWithInternalSwap(Arena* lhs, Arena* rhs) { 102| 230| if (DebugHardenForceCopyInMove()) { ------------------ | Branch (102:7): [Folded, False: 230] ------------------ 103| | // We force copy in move when we are not using an arena. 104| | // If we did with an arena we would grow arena usage too much. 105| 0| return lhs != nullptr && lhs == rhs; ------------------ | Branch (105:12): [True: 0, False: 0] | Branch (105:30): [True: 0, False: 0] ------------------ 106| 230| } else { 107| 230| return lhs == rhs; 108| 230| } 109| 230|} _ZN6google8protobuf5Arena16AllocateInternalINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEELb0EEEPvv: 706| 515|inline void* Arena::AllocateInternal() { 707| 515| return impl_.AllocateFromStringBlock(); 708| 515|} _ZZN6google8protobuf5Arena6CreateINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEJEEEPT_PS1_DpOT0_ENKUlDpOT_E0_clIJEEEDaSI_: 244| 518| [arena](auto&&... args) { 245| 518| if (PROTOBUF_PREDICT_FALSE(arena == nullptr)) { ------------------ | | 365| 518|# define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(false || (x), false)) | | ------------------ | | | Branch (365:36): [True: 3, False: 515] | | | Branch (365:54): [Folded, False: 518] | | | Branch (365:63): [True: 3, False: 515] | | ------------------ ------------------ 246| 3| return new T(std::forward(args)...); 247| 3| } 248| 515| return new (arena->AllocateInternal()) 249| 515| T(std::forward(args)...); 250| 518| }, _ZN6google8protobuf5Arena6CreateINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEJEEEPT_PS1_DpOT0_: 216| 518| PROTOBUF_NDEBUG_INLINE static T* Create(Arena* arena, Args&&... args) { 217| 518| return absl::utility_internal::IfConstexprElse< 218| 518| is_arena_constructable::value>( 219| | // Arena-constructable 220| 518| [arena](auto&&... args) { 221| 518| using Type = std::remove_const_t; 222| 518|#ifdef __cpp_if_constexpr 223| | // DefaultConstruct/CopyConstruct are optimized for messages, which 224| | // are both arena constructible and destructor skippable and they 225| | // assume much. Don't use these functions unless the invariants 226| | // hold. 227| 518| if constexpr (is_destructor_skippable::value) { 228| 518| constexpr auto construct_type = GetConstructType(); 229| | // We delegate to DefaultConstruct/CopyConstruct where appropriate 230| | // because protobuf generated classes have external templates for 231| | // these functions for code size reasons. When `if constexpr` is not 232| | // available always use the fallback. 233| 518| if constexpr (construct_type == ConstructType::kDefault) { 234| 518| return static_cast(DefaultConstruct(arena)); 235| 518| } else if constexpr (construct_type == ConstructType::kCopy) { 236| 518| return static_cast(CopyConstruct(arena, &args...)); 237| 518| } 238| 518| } 239| 518|#endif 240| 518| return CreateArenaCompatible(arena, 241| 518| std::forward(args)...); 242| 518| }, 243| | // Non arena-constructable 244| 518| [arena](auto&&... args) { 245| 518| if (PROTOBUF_PREDICT_FALSE(arena == nullptr)) { 246| 518| return new T(std::forward(args)...); 247| 518| } 248| 518| return new (arena->AllocateInternal()) 249| 518| T(std::forward(args)...); 250| 518| }, 251| 518| std::forward(args)...); 252| 518| } _ZN6google8protobuf5Arena11CreateArrayIcEEPT_PS1_m: 286| 125| size_t num_elements) { 287| 125| static_assert(std::is_trivial::value, 288| 125| "CreateArray requires a trivially constructible type"); 289| 125| static_assert(std::is_trivially_destructible::value, 290| 125| "CreateArray requires a trivially destructible type"); 291| 125| ABSL_CHECK_LE(num_elements, std::numeric_limits::max() / sizeof(T)) ------------------ | | 54| 0| ABSL_LOG_INTERNAL_CHECK_LE_IMPL((val1), #val1, (val2), #val2) | | ------------------ | | | | 52| 125| ABSL_LOG_INTERNAL_CHECK_OP(Check_LE, <=, val1, val1_text, val2, val2_text) | | | | ------------------ | | | | | | 61| 125| while ( \ | | | | | | 62| 125| ::std::string* absl_log_internal_check_op_result ABSL_ATTRIBUTE_UNUSED = \ | | | | | | ------------------ | | | | | | | Branch (62:22): [True: 0, False: 125] | | | | | | ------------------ | | | | | | 63| 125| ::absl::log_internal::name##Impl( \ | | | | | | 64| 125| ::absl::log_internal::GetReferenceableValue(val1), \ | | | | | | 65| 125| ::absl::log_internal::GetReferenceableValue(val2), \ | | | | | | 66| 125| ABSL_LOG_INTERNAL_STRIP_STRING_LITERAL(val1_text \ | | | | | | 67| 125| " " #op " " val2_text))) \ | | | | | | 68| 125| ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS, true) \ | | | | | | ------------------ | | | | | | | | 172| 0| ABSL_LOG_INTERNAL_##type##_CONDITION(condition) | | | | | | | | ------------------ | | | | | | | | | | 65| 0| switch (0) \ | | | | | | | | | | 66| 0| case 0: \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (66:3): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 67| 0| default: \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (67:3): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 68| 0| !(condition) ? (void)0 : ::absl::log_internal::Voidify()&& | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (68:5): [Folded, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 69| 125| ABSL_LOG_INTERNAL_CHECK(*absl_log_internal_check_op_result).InternalStream() | | | | | | ------------------ | | | | | | | | 66| 125| ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 292| 0| << "Requested size is too large to fit into size_t."; 293| 125| if (PROTOBUF_PREDICT_FALSE(arena == nullptr)) { ------------------ | | 365| 125|# define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(false || (x), false)) | | ------------------ | | | Branch (365:36): [True: 0, False: 125] | | | Branch (365:54): [Folded, False: 125] | | | Branch (365:63): [True: 0, False: 125] | | ------------------ ------------------ 294| 0| return new T[num_elements]; 295| 125| } else { 296| | // We count on compiler to realize that if sizeof(T) is a multiple of 297| | // 8 AlignUpTo can be elided. 298| 125| return static_cast( 299| 125| arena->AllocateAlignedForArray(sizeof(T) * num_elements, alignof(T))); 300| 125| } 301| 125| } _ZN6google8protobuf5Arena16DefaultConstructINS0_19FileDescriptorProtoEEEPvPS1_: 684| 4|PROTOBUF_NOINLINE void* Arena::DefaultConstruct(Arena* arena) { 685| 4| static_assert(is_destructor_skippable::value, ""); 686| 4| void* mem = arena != nullptr ? arena->AllocateAligned(sizeof(T)) ------------------ | Branch (686:15): [True: 4, False: 0] ------------------ 687| 4| : ::operator new(sizeof(T)); 688| 4| return new (mem) T(arena); 689| 4|} _ZN6google8protobuf5ArenaD2Ev: 198| 5| inline ~Arena() = default; _ZN6google8protobuf5Arena6CreateINS0_19FileDescriptorProtoEJEEEPT_PS1_DpOT0_: 216| 4| PROTOBUF_NDEBUG_INLINE static T* Create(Arena* arena, Args&&... args) { 217| 4| return absl::utility_internal::IfConstexprElse< 218| 4| is_arena_constructable::value>( 219| | // Arena-constructable 220| 4| [arena](auto&&... args) { 221| 4| using Type = std::remove_const_t; 222| 4|#ifdef __cpp_if_constexpr 223| | // DefaultConstruct/CopyConstruct are optimized for messages, which 224| | // are both arena constructible and destructor skippable and they 225| | // assume much. Don't use these functions unless the invariants 226| | // hold. 227| 4| if constexpr (is_destructor_skippable::value) { 228| 4| constexpr auto construct_type = GetConstructType(); 229| | // We delegate to DefaultConstruct/CopyConstruct where appropriate 230| | // because protobuf generated classes have external templates for 231| | // these functions for code size reasons. When `if constexpr` is not 232| | // available always use the fallback. 233| 4| if constexpr (construct_type == ConstructType::kDefault) { 234| 4| return static_cast(DefaultConstruct(arena)); 235| 4| } else if constexpr (construct_type == ConstructType::kCopy) { 236| 4| return static_cast(CopyConstruct(arena, &args...)); 237| 4| } 238| 4| } 239| 4|#endif 240| 4| return CreateArenaCompatible(arena, 241| 4| std::forward(args)...); 242| 4| }, 243| | // Non arena-constructable 244| 4| [arena](auto&&... args) { 245| 4| if (PROTOBUF_PREDICT_FALSE(arena == nullptr)) { 246| 4| return new T(std::forward(args)...); 247| 4| } 248| 4| return new (arena->AllocateInternal()) 249| 4| T(std::forward(args)...); 250| 4| }, 251| 4| std::forward(args)...); 252| 4| } _ZZN6google8protobuf5Arena6CreateINS0_19FileDescriptorProtoEJEEEPT_PS1_DpOT0_ENKUlDpOT_E_clIJEEEDaSC_: 220| 4| [arena](auto&&... args) { 221| 4| using Type = std::remove_const_t; 222| 4|#ifdef __cpp_if_constexpr 223| | // DefaultConstruct/CopyConstruct are optimized for messages, which 224| | // are both arena constructible and destructor skippable and they 225| | // assume much. Don't use these functions unless the invariants 226| | // hold. 227| 4| if constexpr (is_destructor_skippable::value) { 228| 4| constexpr auto construct_type = GetConstructType(); 229| | // We delegate to DefaultConstruct/CopyConstruct where appropriate 230| | // because protobuf generated classes have external templates for 231| | // these functions for code size reasons. When `if constexpr` is not 232| | // available always use the fallback. 233| 4| if constexpr (construct_type == ConstructType::kDefault) { 234| 4| return static_cast(DefaultConstruct(arena)); 235| | } else if constexpr (construct_type == ConstructType::kCopy) { 236| | return static_cast(CopyConstruct(arena, &args...)); 237| | } 238| 4| } 239| 0|#endif 240| 0| return CreateArenaCompatible(arena, 241| 4| std::forward(args)...); 242| 4| }, _ZN6google8protobuf5Arena11CreateArrayINS0_8internal12ExtensionSet8KeyValueEEEPT_PS1_m: 286| 444| size_t num_elements) { 287| 444| static_assert(std::is_trivial::value, 288| 444| "CreateArray requires a trivially constructible type"); 289| 444| static_assert(std::is_trivially_destructible::value, 290| 444| "CreateArray requires a trivially destructible type"); 291| 444| ABSL_CHECK_LE(num_elements, std::numeric_limits::max() / sizeof(T)) ------------------ | | 54| 0| ABSL_LOG_INTERNAL_CHECK_LE_IMPL((val1), #val1, (val2), #val2) | | ------------------ | | | | 52| 444| ABSL_LOG_INTERNAL_CHECK_OP(Check_LE, <=, val1, val1_text, val2, val2_text) | | | | ------------------ | | | | | | 61| 444| while ( \ | | | | | | 62| 444| ::std::string* absl_log_internal_check_op_result ABSL_ATTRIBUTE_UNUSED = \ | | | | | | ------------------ | | | | | | | Branch (62:22): [True: 0, False: 444] | | | | | | ------------------ | | | | | | 63| 444| ::absl::log_internal::name##Impl( \ | | | | | | 64| 444| ::absl::log_internal::GetReferenceableValue(val1), \ | | | | | | 65| 444| ::absl::log_internal::GetReferenceableValue(val2), \ | | | | | | 66| 444| ABSL_LOG_INTERNAL_STRIP_STRING_LITERAL(val1_text \ | | | | | | 67| 444| " " #op " " val2_text))) \ | | | | | | 68| 444| ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS, true) \ | | | | | | ------------------ | | | | | | | | 172| 0| ABSL_LOG_INTERNAL_##type##_CONDITION(condition) | | | | | | | | ------------------ | | | | | | | | | | 65| 0| switch (0) \ | | | | | | | | | | 66| 0| case 0: \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (66:3): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 67| 0| default: \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (67:3): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 68| 0| !(condition) ? (void)0 : ::absl::log_internal::Voidify()&& | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (68:5): [Folded, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 69| 444| ABSL_LOG_INTERNAL_CHECK(*absl_log_internal_check_op_result).InternalStream() | | | | | | ------------------ | | | | | | | | 66| 444| ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 292| 0| << "Requested size is too large to fit into size_t."; 293| 444| if (PROTOBUF_PREDICT_FALSE(arena == nullptr)) { ------------------ | | 365| 444|# define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(false || (x), false)) | | ------------------ | | | Branch (365:36): [True: 444, False: 0] | | | Branch (365:54): [Folded, False: 444] | | | Branch (365:63): [True: 444, False: 0] | | ------------------ ------------------ 294| 444| return new T[num_elements]; 295| 444| } else { 296| | // We count on compiler to realize that if sizeof(T) is a multiple of 297| | // 8 AlignUpTo can be elided. 298| 0| return static_cast( 299| 0| arena->AllocateAlignedForArray(sizeof(T) * num_elements, alignof(T))); 300| 0| } 301| 444| } _ZN6google8protobuf8internal25TaggedAllocationPolicyPtrC2Ev: 43| 5| constexpr TaggedAllocationPolicyPtr() : policy_(0) {} _ZN6google8protobuf8internal25TaggedAllocationPolicyPtr3getEv: 53| 5| AllocationPolicy* get() { 54| 5| return reinterpret_cast(policy_ & kPtrMask); 55| 5| } _ZNK6google8protobuf8internal25TaggedAllocationPolicyPtr3getEv: 56| 21| const AllocationPolicy* get() const { 57| 21| return reinterpret_cast(policy_ & kPtrMask); 58| 21| } _ZNK6google8protobuf8internal25TaggedAllocationPolicyPtr27is_user_owned_initial_blockEv: 66| 5| bool is_user_owned_initial_block() const { 67| 5| return static_cast(get_mask()); 68| 5| } _ZNK6google8protobuf8internal25TaggedAllocationPolicyPtr8get_maskILm1EEEmv: 84| 5| uintptr_t get_mask() const { 85| 5| return policy_ & kMask; 86| 5| } _ZN6google8protobuf8internal14ArenaStringPtr3SetEONSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEPNS0_5ArenaE: 149| 17.9k|void ArenaStringPtr::Set(std::string&& value, Arena* arena) { 150| 17.9k| ScopedCheckPtrInvariants check(&tagged_ptr_); 151| 17.9k| if (IsDefault()) { ------------------ | Branch (151:7): [True: 17.9k, False: 0] ------------------ 152| 17.9k| NewString(arena, std::move(value)); 153| 17.9k| } else if (IsFixedSizeArena()) { ------------------ | Branch (153:14): [True: 0, False: 0] ------------------ 154| 0| std::string* current = tagged_ptr_.Get(); 155| 0| auto* s = new (current) std::string(std::move(value)); 156| 0| arena->OwnDestructor(s); 157| 0| tagged_ptr_.SetMutableArena(s); 158| 0| } else /* !IsFixedSizeArena() */ { 159| 0| *UnsafeMutablePointer() = std::move(value); 160| 0| } 161| 17.9k|} _ZN6google8protobuf8internal14ArenaStringPtr13MutableNoCopyEPNS0_5ArenaE: 182| 612|std::string* ArenaStringPtr::MutableNoCopy(Arena* arena) { 183| 612| ScopedCheckPtrInvariants check(&tagged_ptr_); 184| 612| if (tagged_ptr_.IsMutable()) { ------------------ | Branch (184:7): [True: 0, False: 612] ------------------ 185| 0| return tagged_ptr_.Get(); 186| 612| } else { 187| 612| ABSL_DCHECK(IsDefault()); ------------------ | | 47| 612| ABSL_LOG_INTERNAL_DCHECK_IMPL((condition), #condition) | | ------------------ | | | | 43| 612| ABSL_LOG_INTERNAL_CHECK_IMPL(true || (condition), "true") | | | | ------------------ | | | | | | 26| 1.22k| ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS, \ | | | | | | ------------------ | | | | | | | | 172| 612| ABSL_LOG_INTERNAL_##type##_CONDITION(condition) | | | | | | | | ------------------ | | | | | | | | | | 65| 1.22k| switch (0) \ | | | | | | | | | | 66| 1.22k| case 0: \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (66:3): [True: 612, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 67| 612| default: \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (67:3): [True: 0, False: 612] | | | | | | | | | | ------------------ | | | | | | | | | | 68| 612| !(condition) ? (void)0 : ::absl::log_internal::Voidify()&& | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (68:5): [True: 612, Folded] | | | | | | | | | | | Branch (68:7): [True: 0, Folded] | | | | | | | | | | | Branch (68:7): [True: 0, False: 0] | | | | | | | | | | | Branch (68:7): [Folded, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 27| 1.22k| ABSL_PREDICT_FALSE(!(condition))) \ | | | | | | 28| 1.22k| ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream() | | | | | | ------------------ | | | | | | | | 66| 0| ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 188| | // Allocate empty. The contents are not relevant. 189| 612| return NewString(arena); 190| 612| } 191| 612|} _ZN6google8protobuf8internal14ArenaStringPtr7DestroyEv: 237| 54.4k|void ArenaStringPtr::Destroy() { 238| 54.4k| delete tagged_ptr_.GetIfAllocated(); 239| 54.4k|} _ZN6google8protobuf8internal18EpsCopyInputStream15ReadArenaStringEPKcPNS1_14ArenaStringPtrEPNS0_5ArenaE: 268| 515| Arena* arena) { 269| 515| ScopedCheckPtrInvariants check(&s->tagged_ptr_); 270| 515| ABSL_DCHECK(arena != nullptr); ------------------ | | 47| 515| ABSL_LOG_INTERNAL_DCHECK_IMPL((condition), #condition) | | ------------------ | | | | 43| 515| ABSL_LOG_INTERNAL_CHECK_IMPL(true || (condition), "true") | | | | ------------------ | | | | | | 26| 1.03k| ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS, \ | | | | | | ------------------ | | | | | | | | 172| 515| ABSL_LOG_INTERNAL_##type##_CONDITION(condition) | | | | | | | | ------------------ | | | | | | | | | | 65| 1.03k| switch (0) \ | | | | | | | | | | 66| 1.03k| case 0: \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (66:3): [True: 515, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 67| 515| default: \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (67:3): [True: 0, False: 515] | | | | | | | | | | ------------------ | | | | | | | | | | 68| 515| !(condition) ? (void)0 : ::absl::log_internal::Voidify()&& | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (68:5): [True: 515, Folded] | | | | | | | | | | | Branch (68:7): [True: 0, Folded] | | | | | | | | | | | Branch (68:7): [True: 0, False: 0] | | | | | | | | | | | Branch (68:7): [Folded, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 27| 1.03k| ABSL_PREDICT_FALSE(!(condition))) \ | | | | | | 28| 1.03k| ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream() | | | | | | ------------------ | | | | | | | | 66| 0| ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 271| | 272| 515| int size = ReadSize(&ptr); 273| 515| if (!ptr) return nullptr; ------------------ | Branch (273:7): [True: 0, False: 515] ------------------ 274| | 275| 515| auto* str = s->NewString(arena); 276| 515| ptr = ReadString(ptr, size, str); 277| 515| GOOGLE_PROTOBUF_PARSER_ASSERT(ptr); ------------------ | | 1157| 515| GOOGLE_PROTOBUF_ASSERT_RETURN(predicate, nullptr) | | ------------------ | | | | 1150| 515| if (!(predicate)) { \ | | | | ------------------ | | | | | Branch (1150:7): [True: 0, False: 515] | | | | ------------------ | | | | 1151| 0| /* ::raise(SIGINT); */ \ | | | | 1152| 0| /* ABSL_LOG(ERROR) << "Parse failure"; */ \ | | | | 1153| 0| return ret; \ | | | | 1154| 0| } | | ------------------ ------------------ 278| 515| return ptr; 279| 515|} arenastring.cc:_ZN6google8protobuf8internal12_GLOBAL__N_124ScopedCheckPtrInvariantsC2EPKNS1_15TaggedStringPtrE: 70| 19.0k| explicit ScopedCheckPtrInvariants(const TaggedStringPtr*) {} _ZN6google8protobuf8internal15TaggedStringPtr12SetAllocatedEPNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE: 122| 18.5k| inline std::string* SetAllocated(std::string* p) { 123| 18.5k| return TagAs(kAllocated, p); 124| 18.5k| } _ZN6google8protobuf8internal15TaggedStringPtr15SetMutableArenaEPNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE: 136| 515| inline std::string* SetMutableArena(std::string* p) { 137| 515| return TagAs(kMutableArena, p); 138| 515| } _ZNK6google8protobuf8internal15TaggedStringPtr9IsMutableEv: 141| 612| inline bool IsMutable() const { return as_int() & kMutableBit; } _ZNK6google8protobuf8internal15TaggedStringPtr14GetIfAllocatedEv: 148| 54.4k| inline std::string* GetIfAllocated() const { 149| 54.4k| auto allocated = as_int() ^ kAllocated; 150| 54.4k| if (allocated & kMask) return nullptr; ------------------ | Branch (150:9): [True: 35.8k, False: 18.5k] ------------------ 151| | 152| 18.5k| auto ptr = reinterpret_cast(allocated); 153| 18.5k| PROTOBUF_ASSUME(ptr != nullptr); ------------------ | | 941| 18.5k|#define PROTOBUF_ASSUME(pred) __builtin_assume(pred) ------------------ 154| 18.5k| return ptr; 155| 54.4k| } _ZN6google8protobuf8internal15TaggedStringPtr14assert_alignedEPKv: 186| 19.0k| static inline void assert_aligned(const void* p) { 187| 19.0k| static_assert(kMask <= alignof(void*), "Pointer underaligned for bit mask"); 188| 19.0k| static_assert(kMask <= alignof(std::string), 189| 19.0k| "std::string underaligned for bit mask"); 190| 19.0k| ABSL_DCHECK_EQ(reinterpret_cast(p) & kMask, 0UL); ------------------ | | 74| 19.0k| ABSL_LOG_INTERNAL_DCHECK_EQ_IMPL((val1), #val1, (val2), #val2) | | ------------------ | | | | 86| 19.0k| ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2) | | | | ------------------ | | | | | | 56| 19.0k| while (false && ((void)(x), (void)(y), 0)) \ | | | | | | ------------------ | | | | | | | Branch (56:10): [Folded, False: 19.0k] | | | | | | | Branch (56:19): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 57| 19.0k| ::absl::log_internal::NullStream().InternalStream() | | | | ------------------ | | ------------------ ------------------ 191| 19.0k| } _ZN6google8protobuf8internal15TaggedStringPtr5TagAsENS2_4TypeEPNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEE: 196| 19.0k| inline std::string* TagAs(Type type, std::string* p) { 197| 19.0k| ABSL_DCHECK(p != nullptr); ------------------ | | 47| 19.0k| ABSL_LOG_INTERNAL_DCHECK_IMPL((condition), #condition) | | ------------------ | | | | 43| 19.0k| ABSL_LOG_INTERNAL_CHECK_IMPL(true || (condition), "true") | | | | ------------------ | | | | | | 26| 38.1k| ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS, \ | | | | | | ------------------ | | | | | | | | 172| 19.0k| ABSL_LOG_INTERNAL_##type##_CONDITION(condition) | | | | | | | | ------------------ | | | | | | | | | | 65| 38.1k| switch (0) \ | | | | | | | | | | 66| 38.1k| case 0: \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (66:3): [True: 19.0k, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 67| 19.0k| default: \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (67:3): [True: 0, False: 19.0k] | | | | | | | | | | ------------------ | | | | | | | | | | 68| 19.0k| !(condition) ? (void)0 : ::absl::log_internal::Voidify()&& | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (68:5): [True: 19.0k, Folded] | | | | | | | | | | | Branch (68:7): [True: 0, Folded] | | | | | | | | | | | Branch (68:7): [True: 0, False: 0] | | | | | | | | | | | Branch (68:7): [Folded, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 27| 38.1k| ABSL_PREDICT_FALSE(!(condition))) \ | | | | | | 28| 38.1k| ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream() | | | | | | ------------------ | | | | | | | | 66| 0| ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 198| 19.0k| assert_aligned(p); 199| 19.0k| ptr_ = reinterpret_cast(reinterpret_cast(p) | type); 200| 19.0k| return p; 201| 19.0k| } _ZNK6google8protobuf8internal14ArenaStringPtr9IsDefaultEv: 392| 17.9k| inline bool IsDefault() const { return tagged_ptr_.IsDefault(); } _ZN6google8protobuf8internal14ArenaStringPtr9NewStringIJNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEEPSA_PNS0_5ArenaEDpOT_: 396| 17.9k| inline std::string* NewString(Arena* arena, Args&&... args) { 397| 17.9k| if (arena == nullptr) { ------------------ | Branch (397:9): [True: 17.9k, False: 0] ------------------ 398| 17.9k| auto* s = new std::string(std::forward(args)...); 399| 17.9k| return tagged_ptr_.SetAllocated(s); 400| 17.9k| } else { 401| 0| auto* s = Arena::Create(arena, std::forward(args)...); 402| 0| return tagged_ptr_.SetMutableArena(s); 403| 0| } 404| 17.9k| } _ZN6google8protobuf8internal14ArenaStringPtr9NewStringIJEEEPNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEPNS0_5ArenaEDpOT_: 396| 1.12k| inline std::string* NewString(Arena* arena, Args&&... args) { 397| 1.12k| if (arena == nullptr) { ------------------ | Branch (397:9): [True: 612, False: 515] ------------------ 398| 612| auto* s = new std::string(std::forward(args)...); 399| 612| return tagged_ptr_.SetAllocated(s); 400| 612| } else { 401| 515| auto* s = Arena::Create(arena, std::forward(args)...); 402| 515| return tagged_ptr_.SetMutableArena(s); 403| 515| } 404| 1.12k| } _ZN6google8protobuf8internal20ThreadSafeArenaStats19RecordAllocateStatsEPS2_mmm: 169| 26| size_t /*allocated*/, size_t /*wasted*/) {} _ZN6google8protobuf8internal26ThreadSafeArenaStatsHandleC2EPNS1_20ThreadSafeArenaStatsE: 178| 5| explicit ThreadSafeArenaStatsHandle(ThreadSafeArenaStats*) {} _ZN6google8protobuf8internal26ThreadSafeArenaStatsHandle12MutableStatsEv: 182| 26| ThreadSafeArenaStats* MutableStats() { return nullptr; } _ZN6google8protobuf8internal6SampleEv: 198| 5|inline ThreadSafeArenaStatsHandle Sample() { 199| 5| return ThreadSafeArenaStatsHandle(nullptr); 200| 5|} _ZN2pb11CppFeaturesD2Ev: 187| 432|CppFeatures::~CppFeatures() { 188| | // @@protoc_insertion_point(destructor:pb.CppFeatures) 189| 432| SharedDtor(*this); 190| 432|} _ZNK2pb11CppFeatures12GetClassDataEv: 228| 1.99k|const ::google::protobuf::internal::ClassData* CppFeatures::GetClassData() const { 229| 1.99k| ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_); 230| 1.99k| ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table); 231| 1.99k| return _class_data_.base(); 232| 1.99k|} _ZNK2pb11CppFeatures18_InternalSerializeEPhPN6google8protobuf2io19EpsCopyOutputStreamE: 305| 210| ::google::protobuf::io::EpsCopyOutputStream* stream) const { 306| 210| const CppFeatures& this_ = *this; 307| 210|#endif // PROTOBUF_CUSTOM_VTABLE 308| | // @@protoc_insertion_point(serialize_to_array_start:pb.CppFeatures) 309| 210| ::uint32_t cached_has_bits = 0; 310| 210| (void)cached_has_bits; 311| | 312| 210| cached_has_bits = this_._impl_._has_bits_[0]; 313| | // optional bool legacy_closed_enum = 1 [retention = RETENTION_RUNTIME, targets = TARGET_TYPE_FIELD, targets = TARGET_TYPE_FILE, edition_defaults = { 314| 210| if (cached_has_bits & 0x00000002u) { ------------------ | Branch (314:15): [True: 210, False: 0] ------------------ 315| 210| target = stream->EnsureSpace(target); 316| 210| target = ::_pbi::WireFormatLite::WriteBoolToArray( 317| 210| 1, this_._internal_legacy_closed_enum(), target); 318| 210| } 319| | 320| | // optional .pb.CppFeatures.StringType string_type = 2 [retention = RETENTION_RUNTIME, targets = TARGET_TYPE_FIELD, targets = TARGET_TYPE_FILE, edition_defaults = { 321| 210| if (cached_has_bits & 0x00000001u) { ------------------ | Branch (321:15): [True: 210, False: 0] ------------------ 322| 210| target = stream->EnsureSpace(target); 323| 210| target = ::_pbi::WireFormatLite::WriteEnumToArray( 324| 210| 2, this_._internal_string_type(), target); 325| 210| } 326| | 327| | // optional bool enum_name_uses_string_view = 3 [retention = RETENTION_SOURCE, targets = TARGET_TYPE_ENUM, targets = TARGET_TYPE_FILE, edition_defaults = { 328| 210| if (cached_has_bits & 0x00000004u) { ------------------ | Branch (328:15): [True: 210, False: 0] ------------------ 329| 210| target = stream->EnsureSpace(target); 330| 210| target = ::_pbi::WireFormatLite::WriteBoolToArray( 331| 210| 3, this_._internal_enum_name_uses_string_view(), target); 332| 210| } 333| | 334| 210| if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { ------------------ | | 365| 210|# define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(false || (x), false)) | | ------------------ | | | Branch (365:36): [True: 0, False: 210] | | | Branch (365:54): [Folded, False: 210] | | | Branch (365:63): [True: 0, False: 210] | | ------------------ ------------------ 335| 0| target = 336| 0| ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( 337| 0| this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); 338| 0| } 339| | // @@protoc_insertion_point(serialize_to_array_end:pb.CppFeatures) 340| 210| return target; 341| 210| } _ZNK2pb11CppFeatures12ByteSizeLongEv: 347| 416| ::size_t CppFeatures::ByteSizeLong() const { 348| 416| const CppFeatures& this_ = *this; 349| 416|#endif // PROTOBUF_CUSTOM_VTABLE 350| | // @@protoc_insertion_point(message_byte_size_start:pb.CppFeatures) 351| 416| ::size_t total_size = 0; 352| | 353| 416| ::uint32_t cached_has_bits = 0; 354| | // Prevent compiler warnings about cached_has_bits being unused 355| 416| (void)cached_has_bits; 356| | 357| 416| ::_pbi::Prefetch5LinesFrom7Lines(&this_); 358| 416| cached_has_bits = this_._impl_._has_bits_[0]; 359| 416| if (cached_has_bits & 0x00000007u) { ------------------ | Branch (359:15): [True: 210, False: 206] ------------------ 360| | // optional .pb.CppFeatures.StringType string_type = 2 [retention = RETENTION_RUNTIME, targets = TARGET_TYPE_FIELD, targets = TARGET_TYPE_FILE, edition_defaults = { 361| 210| if (cached_has_bits & 0x00000001u) { ------------------ | Branch (361:17): [True: 210, False: 0] ------------------ 362| 210| total_size += 1 + 363| 210| ::_pbi::WireFormatLite::EnumSize(this_._internal_string_type()); 364| 210| } 365| | // optional bool legacy_closed_enum = 1 [retention = RETENTION_RUNTIME, targets = TARGET_TYPE_FIELD, targets = TARGET_TYPE_FILE, edition_defaults = { 366| 210| if (cached_has_bits & 0x00000002u) { ------------------ | Branch (366:17): [True: 210, False: 0] ------------------ 367| 210| total_size += 2; 368| 210| } 369| | // optional bool enum_name_uses_string_view = 3 [retention = RETENTION_SOURCE, targets = TARGET_TYPE_ENUM, targets = TARGET_TYPE_FILE, edition_defaults = { 370| 210| if (cached_has_bits & 0x00000004u) { ------------------ | Branch (370:17): [True: 210, False: 0] ------------------ 371| 210| total_size += 2; 372| 210| } 373| 210| } 374| 416| return this_.MaybeComputeUnknownFieldsSize(total_size, 375| 416| &this_._impl_._cached_size_); 376| 416| } _ZN2pb11CppFeatures9MergeImplERN6google8protobuf11MessageLiteERKS3_: 378| 662|void CppFeatures::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { 379| 662| auto* const _this = static_cast(&to_msg); 380| 662| auto& from = static_cast(from_msg); 381| | // @@protoc_insertion_point(class_specific_merge_from_start:pb.CppFeatures) 382| 662| ABSL_DCHECK_NE(&from, _this); ------------------ | | 76| 662| ABSL_LOG_INTERNAL_DCHECK_NE_IMPL((val1), #val1, (val2), #val2) | | ------------------ | | | | 88| 662| ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2) | | | | ------------------ | | | | | | 56| 662| while (false && ((void)(x), (void)(y), 0)) \ | | | | | | ------------------ | | | | | | | Branch (56:10): [Folded, False: 662] | | | | | | | Branch (56:19): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 57| 662| ::absl::log_internal::NullStream().InternalStream() | | | | ------------------ | | ------------------ ------------------ 383| 662| ::uint32_t cached_has_bits = 0; 384| 662| (void) cached_has_bits; 385| | 386| 662| cached_has_bits = from._impl_._has_bits_[0]; 387| 662| if (cached_has_bits & 0x00000007u) { ------------------ | Branch (387:7): [True: 440, False: 222] ------------------ 388| 440| if (cached_has_bits & 0x00000001u) { ------------------ | Branch (388:9): [True: 436, False: 4] ------------------ 389| 436| _this->_impl_.string_type_ = from._impl_.string_type_; 390| 436| } 391| 440| if (cached_has_bits & 0x00000002u) { ------------------ | Branch (391:9): [True: 436, False: 4] ------------------ 392| 436| _this->_impl_.legacy_closed_enum_ = from._impl_.legacy_closed_enum_; 393| 436| } 394| 440| if (cached_has_bits & 0x00000004u) { ------------------ | Branch (394:9): [True: 436, False: 4] ------------------ 395| 436| _this->_impl_.enum_name_uses_string_view_ = from._impl_.enum_name_uses_string_view_; 396| 436| } 397| 440| } 398| 662| _this->_impl_._has_bits_[0] |= cached_has_bits; 399| 662| _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); 400| 662|} _ZNK2pb11CppFeatures11GetMetadataEv: 422| 3|::google::protobuf::Metadata CppFeatures::GetMetadata() const { 423| 3| return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); 424| 3|} _ZN2pb11CppFeatures10SharedDtorERN6google8protobuf11MessageLiteE: 191| 432|inline void CppFeatures::SharedDtor(MessageLite& self) { 192| 432| CppFeatures& this_ = static_cast(self); 193| 432| this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); 194| 432| ABSL_DCHECK(this_.GetArena() == nullptr); ------------------ | | 47| 432| ABSL_LOG_INTERNAL_DCHECK_IMPL((condition), #condition) | | ------------------ | | | | 43| 432| ABSL_LOG_INTERNAL_CHECK_IMPL(true || (condition), "true") | | | | ------------------ | | | | | | 26| 864| ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS, \ | | | | | | ------------------ | | | | | | | | 172| 432| ABSL_LOG_INTERNAL_##type##_CONDITION(condition) | | | | | | | | ------------------ | | | | | | | | | | 65| 864| switch (0) \ | | | | | | | | | | 66| 864| case 0: \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (66:3): [True: 432, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 67| 432| default: \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (67:3): [True: 0, False: 432] | | | | | | | | | | ------------------ | | | | | | | | | | 68| 432| !(condition) ? (void)0 : ::absl::log_internal::Voidify()&& | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (68:5): [True: 432, Folded] | | | | | | | | | | | Branch (68:7): [True: 0, Folded] | | | | | | | | | | | Branch (68:7): [True: 0, False: 0] | | | | | | | | | | | Branch (68:7): [Folded, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 27| 864| ABSL_PREDICT_FALSE(!(condition))) \ | | | | | | 28| 864| ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream() | | | | | | ------------------ | | | | | | | | 66| 0| ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 195| 432| this_._impl_.~Impl_(); 196| 432|} _ZN2pb11CppFeatures10descriptorEv: 147| 3| static const ::google::protobuf::Descriptor* descriptor() { 148| 3| return GetDescriptor(); 149| 3| } _ZN2pb11CppFeatures13GetDescriptorEv: 150| 3| static const ::google::protobuf::Descriptor* GetDescriptor() { 151| 3| return default_instance().GetMetadata().descriptor; 152| 3| } _ZNK2pb11CppFeatures15has_string_typeEv: 392| 206|inline bool CppFeatures::has_string_type() const { 393| 206| bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; 394| 206| return value; 395| 206|} _ZNK2pb11CppFeatures28_internal_legacy_closed_enumEv: 382| 210|inline bool CppFeatures::_internal_legacy_closed_enum() const { 383| 210| ::google::protobuf::internal::TSanRead(&_impl_); 384| 210| return _impl_.legacy_closed_enum_; 385| 210|} _ZNK2pb11CppFeatures11string_typeEv: 401| 17.9k|inline ::pb::CppFeatures_StringType CppFeatures::string_type() const { 402| | // @@protoc_insertion_point(field_get:pb.CppFeatures.string_type) 403| 17.9k| return _internal_string_type(); 404| 17.9k|} _ZNK2pb11CppFeatures21_internal_string_typeEv: 410| 18.3k|inline ::pb::CppFeatures_StringType CppFeatures::_internal_string_type() const { 411| 18.3k| ::google::protobuf::internal::TSanRead(&_impl_); 412| 18.3k| return static_cast<::pb::CppFeatures_StringType>(_impl_.string_type_); 413| 18.3k|} _ZN2pb11CppFeatures16default_instanceEv: 156| 210| static const CppFeatures& default_instance() { 157| 210| return *internal_default_instance(); 158| 210| } _ZN2pb11CppFeatures25internal_default_instanceEv: 159| 210| static inline const CppFeatures* internal_default_instance() { 160| 210| return reinterpret_cast( 161| 210| &_CppFeatures_default_instance_); 162| 210| } _ZNK2pb11CppFeatures36_internal_enum_name_uses_string_viewEv: 439| 210|inline bool CppFeatures::_internal_enum_name_uses_string_view() const { 440| 210| ::google::protobuf::internal::TSanRead(&_impl_); 441| 210| return _impl_.enum_name_uses_string_view_; 442| 210|} _ZN6google8protobuf14DescriptorPool6TablesC2Ev: 1609| 2|DescriptorPool::Tables::Tables() { 1610| 2| well_known_types_.insert({ 1611| 2| {"google.protobuf.DoubleValue", Descriptor::WELLKNOWNTYPE_DOUBLEVALUE}, 1612| 2| {"google.protobuf.FloatValue", Descriptor::WELLKNOWNTYPE_FLOATVALUE}, 1613| 2| {"google.protobuf.Int64Value", Descriptor::WELLKNOWNTYPE_INT64VALUE}, 1614| 2| {"google.protobuf.UInt64Value", Descriptor::WELLKNOWNTYPE_UINT64VALUE}, 1615| 2| {"google.protobuf.Int32Value", Descriptor::WELLKNOWNTYPE_INT32VALUE}, 1616| 2| {"google.protobuf.UInt32Value", Descriptor::WELLKNOWNTYPE_UINT32VALUE}, 1617| 2| {"google.protobuf.StringValue", Descriptor::WELLKNOWNTYPE_STRINGVALUE}, 1618| 2| {"google.protobuf.BytesValue", Descriptor::WELLKNOWNTYPE_BYTESVALUE}, 1619| 2| {"google.protobuf.BoolValue", Descriptor::WELLKNOWNTYPE_BOOLVALUE}, 1620| 2| {"google.protobuf.Any", Descriptor::WELLKNOWNTYPE_ANY}, 1621| 2| {"google.protobuf.FieldMask", Descriptor::WELLKNOWNTYPE_FIELDMASK}, 1622| 2| {"google.protobuf.Duration", Descriptor::WELLKNOWNTYPE_DURATION}, 1623| 2| {"google.protobuf.Timestamp", Descriptor::WELLKNOWNTYPE_TIMESTAMP}, 1624| 2| {"google.protobuf.Value", Descriptor::WELLKNOWNTYPE_VALUE}, 1625| 2| {"google.protobuf.ListValue", Descriptor::WELLKNOWNTYPE_LISTVALUE}, 1626| 2| {"google.protobuf.Struct", Descriptor::WELLKNOWNTYPE_STRUCT}, 1627| 2| }); 1628| 2|} _ZN6google8protobuf20FileDescriptorTablesC2Ev: 1632| 4|FileDescriptorTables::FileDescriptorTables() = default; _ZN6google8protobuf14DescriptorPool6Tables13AddCheckpointEv: 1645| 4|void DescriptorPool::Tables::AddCheckpoint() { 1646| 4| checkpoints_.emplace_back(this); 1647| 4|} _ZN6google8protobuf14DescriptorPool6Tables19ClearLastCheckpointEv: 1649| 4|void DescriptorPool::Tables::ClearLastCheckpoint() { 1650| 4| ABSL_DCHECK(!checkpoints_.empty()); ------------------ | | 47| 4| ABSL_LOG_INTERNAL_DCHECK_IMPL((condition), #condition) | | ------------------ | | | | 43| 4| ABSL_LOG_INTERNAL_CHECK_IMPL(true || (condition), "true") | | | | ------------------ | | | | | | 26| 8| ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS, \ | | | | | | ------------------ | | | | | | | | 172| 4| ABSL_LOG_INTERNAL_##type##_CONDITION(condition) | | | | | | | | ------------------ | | | | | | | | | | 65| 8| switch (0) \ | | | | | | | | | | 66| 8| case 0: \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (66:3): [True: 4, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 67| 4| default: \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (67:3): [True: 0, False: 4] | | | | | | | | | | ------------------ | | | | | | | | | | 68| 4| !(condition) ? (void)0 : ::absl::log_internal::Voidify()&& | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (68:5): [True: 4, Folded] | | | | | | | | | | | Branch (68:7): [True: 0, Folded] | | | | | | | | | | | Branch (68:7): [True: 0, False: 0] | | | | | | | | | | | Branch (68:7): [Folded, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 27| 8| ABSL_PREDICT_FALSE(!(condition))) \ | | | | | | 28| 8| ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream() | | | | | | ------------------ | | | | | | | | 66| 0| ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1651| 4| checkpoints_.pop_back(); 1652| 4| if (checkpoints_.empty()) { ------------------ | Branch (1652:7): [True: 4, False: 0] ------------------ 1653| | // All checkpoints have been cleared: we can now commit all of the pending 1654| | // data. 1655| 4| symbols_after_checkpoint_.clear(); 1656| 4| files_after_checkpoint_.clear(); 1657| 4| extensions_after_checkpoint_.clear(); 1658| 4| } 1659| 4|} _ZN6google8protobuf14DescriptorPool6Tables9AddSymbolENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEENS0_6SymbolE: 1929| 362| Symbol symbol) { 1930| 362| ABSL_DCHECK_EQ(full_name, symbol.full_name()); ------------------ | | 74| 362| ABSL_LOG_INTERNAL_DCHECK_EQ_IMPL((val1), #val1, (val2), #val2) | | ------------------ | | | | 86| 362| ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2) | | | | ------------------ | | | | | | 56| 362| while (false && ((void)(x), (void)(y), 0)) \ | | | | | | ------------------ | | | | | | | Branch (56:10): [Folded, False: 362] | | | | | | | Branch (56:19): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 57| 362| ::absl::log_internal::NullStream().InternalStream() | | | | ------------------ | | ------------------ ------------------ 1931| 362| if (symbols_by_name_.insert(symbol).second) { ------------------ | Branch (1931:7): [True: 362, False: 0] ------------------ 1932| 362| symbols_after_checkpoint_.push_back(symbol); 1933| 362| return true; 1934| 362| } else { 1935| 0| return false; 1936| 0| } 1937| 362|} _ZN6google8protobuf20FileDescriptorTables19AddAliasUnderParentEPKvNSt3__117basic_string_viewIcNS4_11char_traitsIcEEEENS0_6SymbolE: 1941| 443| Symbol symbol) { 1942| 443| ABSL_DCHECK_EQ(name, symbol.parent_name_key().second); ------------------ | | 74| 443| ABSL_LOG_INTERNAL_DCHECK_EQ_IMPL((val1), #val1, (val2), #val2) | | ------------------ | | | | 86| 443| ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2) | | | | ------------------ | | | | | | 56| 443| while (false && ((void)(x), (void)(y), 0)) \ | | | | | | ------------------ | | | | | | | Branch (56:10): [Folded, False: 443] | | | | | | | Branch (56:10): [Folded, False: 443] | | | | | | | Branch (56:19): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 57| 443| ::absl::log_internal::NullStream().InternalStream() | | | | ------------------ | | ------------------ ------------------ 1943| 443| ABSL_DCHECK_EQ(parent, symbol.parent_name_key().first); ------------------ | | 74| 443| ABSL_LOG_INTERNAL_DCHECK_EQ_IMPL((val1), #val1, (val2), #val2) | | ------------------ | | | | 86| 443| ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2) | | | | ------------------ | | | | | | 56| 443| while (false && ((void)(x), (void)(y), 0)) \ | | | | | | ------------------ | | | | | | | Branch (56:10): [Folded, False: 443] | | | | | | | Branch (56:10): [Folded, False: 443] | | | | | | | Branch (56:19): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 57| 443| ::absl::log_internal::NullStream().InternalStream() | | | | ------------------ | | ------------------ ------------------ 1944| 443| return symbols_by_parent_.insert(symbol).second; 1945| 443|} _ZN6google8protobuf14DescriptorPool6Tables7AddFileEPKNS0_14FileDescriptorE: 1947| 4|bool DescriptorPool::Tables::AddFile(const FileDescriptor* file) { 1948| 4| if (files_by_name_.insert(file).second) { ------------------ | Branch (1948:7): [True: 4, False: 0] ------------------ 1949| 4| files_after_checkpoint_.push_back(file); 1950| 4| return true; 1951| 4| } else { 1952| 0| return false; 1953| 0| } 1954| 4|} _ZN6google8protobuf20FileDescriptorTables14FinalizeTablesEv: 1956| 4|void FileDescriptorTables::FinalizeTables() {} _ZN6google8protobuf20FileDescriptorTables16AddFieldByNumberEPNS0_15FieldDescriptorE: 1958| 206|bool FileDescriptorTables::AddFieldByNumber(FieldDescriptor* field) { 1959| | // Skip fields that are at the start of the sequence. 1960| 206| if (field->containing_type() != nullptr && field->number() >= 1 && ------------------ | Branch (1960:7): [True: 206, False: 0] | Branch (1960:46): [True: 206, False: 0] ------------------ 1961| 206| field->number() <= field->containing_type()->sequential_field_limit_) { ------------------ | Branch (1961:7): [True: 106, False: 100] ------------------ 1962| 106| if (field->is_extension()) { ------------------ | Branch (1962:9): [True: 0, False: 106] ------------------ 1963| | // Conflicts with the field that already exists in the sequential range. 1964| 0| return false; 1965| 0| } 1966| | // Only return true if the field at that index matches. Otherwise it 1967| | // conflicts with the existing field in the sequential range. 1968| 106| return field->containing_type()->field(field->number() - 1) == field; 1969| 106| } 1970| | 1971| 100| return fields_by_number_.insert(field).second; 1972| 206|} _ZN6google8protobuf20FileDescriptorTables20AddEnumValueByNumberEPNS0_19EnumValueDescriptorE: 1974| 86|bool FileDescriptorTables::AddEnumValueByNumber(EnumValueDescriptor* value) { 1975| | // Skip values that are at the start of the sequence. 1976| 86| const int base = value->type()->value(0)->number(); 1977| 86| if (base <= value->number() && ------------------ | Branch (1977:7): [True: 86, False: 0] ------------------ 1978| 86| value->number() <= ------------------ | Branch (1978:7): [True: 71, False: 15] ------------------ 1979| 86| static_cast(base) + value->type()->sequential_value_limit_) 1980| 71| return true; 1981| 15| return enum_values_by_number_.insert(value).second; 1982| 86|} _ZN6google8protobuf14DescriptorPool6Tables12AddExtensionEPKNS0_15FieldDescriptorE: 1984| 1|bool DescriptorPool::Tables::AddExtension(const FieldDescriptor* field) { 1985| 1| auto it_inserted = 1986| 1| extensions_.insert({{field->containing_type(), field->number()}, field}); 1987| 1| if (it_inserted.second) { ------------------ | Branch (1987:7): [True: 1, False: 0] ------------------ 1988| 1| extensions_after_checkpoint_.push_back(it_inserted.first->first); 1989| 1| return true; 1990| 1| } else { 1991| 0| return false; 1992| 0| } 1993| 1|} _ZN6google8protobuf14DescriptorPool6Tables16InternFeatureSetEONS0_10FeatureSetE: 1996| 210| FeatureSet&& features) { 1997| | // Use the serialized feature set as the cache key. If multiple equivalent 1998| | // feature sets serialize to different strings, that just bloats the cache a 1999| | // little. 2000| 210| auto& result = feature_set_cache_[features.SerializeAsString()]; 2001| 210| if (result == nullptr) { ------------------ | Branch (2001:7): [True: 4, False: 206] ------------------ 2002| 4| result = absl::make_unique(std::move(features)); 2003| 4| } 2004| 210| return result.get(); 2005| 210|} _ZN6google8protobuf14DescriptorPool6Tables13AllocateBytesEi: 2016| 2|void* DescriptorPool::Tables::AllocateBytes(int size) { 2017| 2| if (size == 0) return nullptr; ------------------ | Branch (2017:7): [True: 0, False: 2] ------------------ 2018| 2| void* p = ::operator new(size + RoundUpTo<8>(sizeof(int))); 2019| 2| int* sizep = static_cast(p); 2020| 2| misc_allocs_.emplace_back(sizep); 2021| 2| *sizep = size; 2022| 2| return static_cast(p) + RoundUpTo<8>(sizeof(int)); 2023| 2|} _ZN6google8protobuf14DescriptorPoolC2EPNS0_18DescriptorDatabaseEPNS1_14ErrorCollectorE: 2113| 2| : mutex_(new absl::Mutex), 2114| 2| fallback_database_(fallback_database), 2115| 2| default_error_collector_(error_collector), 2116| 2| underlay_(nullptr), 2117| 2| tables_(new Tables), 2118| 2| enforce_dependencies_(true), 2119| 2| lazily_build_dependencies_(false), 2120| 2| allow_unknown_(false), 2121| 2| enforce_weak_(false), 2122| 2| enforce_extension_declarations_(false), 2123| 2| disallow_enforce_utf8_(false), 2124| 2| deprecated_legacy_json_field_conflicts_(false) {} _ZN6google8protobuf14DescriptorPool31InternalDontEnforceDependenciesEv: 2147| 2|void DescriptorPool::InternalDontEnforceDependencies() { 2148| 2| enforce_dependencies_ = false; 2149| 2|} _ZN6google8protobuf14DescriptorPool23internal_generated_poolEv: 2204| 63|DescriptorPool* DescriptorPool::internal_generated_pool() { 2205| 63| static DescriptorPool* generated_pool = 2206| 63| internal::OnShutdownDelete(NewGeneratedPool()); 2207| 63| return generated_pool; 2208| 63|} _ZN6google8protobuf14DescriptorPool14generated_poolEv: 2210| 3|const DescriptorPool* DescriptorPool::generated_pool() { 2211| 3| const DescriptorPool* pool = internal_generated_pool(); 2212| | // Ensure that descriptor.proto and cpp_features.proto get registered in the 2213| | // generated pool. They're special cases because they're included in the full 2214| | // runtime. We have to avoid registering it pre-main, because we need to 2215| | // ensure that the linker --gc-sections step can strip out the full runtime if 2216| | // it is unused. 2217| 3| DescriptorProto::descriptor(); 2218| 3| pb::CppFeatures::descriptor(); 2219| 3| return pool; 2220| 3|} _ZN6google8protobuf14DescriptorPool24InternalAddGeneratedFileEPKvi: 2224| 6| const void* encoded_file_descriptor, int size) { 2225| | // So, this function is called in the process of initializing the 2226| | // descriptors for generated proto classes. Each generated .pb.cc file 2227| | // has an internal procedure called AddDescriptors() which is called at 2228| | // process startup, and that function calls this one in order to register 2229| | // the raw bytes of the FileDescriptorProto representing the file. 2230| | // 2231| | // We do not actually construct the descriptor objects right away. We just 2232| | // hang on to the bytes until they are actually needed. We actually construct 2233| | // the descriptor the first time one of the following things happens: 2234| | // * Someone calls a method like descriptor(), GetDescriptor(), or 2235| | // GetReflection() on the generated types, which requires returning the 2236| | // descriptor or an object based on it. 2237| | // * Someone looks up the descriptor in DescriptorPool::generated_pool(). 2238| | // 2239| | // Once one of these happens, the DescriptorPool actually parses the 2240| | // FileDescriptorProto and generates a FileDescriptor (and all its children) 2241| | // based on it. 2242| | // 2243| | // Note that FileDescriptorProto is itself a generated protocol message. 2244| | // Therefore, when we parse one, we have to be very careful to avoid using 2245| | // any descriptor-based operations, since this might cause infinite recursion 2246| | // or deadlock. 2247| 6| absl::MutexLockMaybe lock(internal_generated_pool()->mutex_); 2248| 6| ABSL_CHECK(GeneratedDatabase()->Add(encoded_file_descriptor, size)); ------------------ | | 41| 6| ABSL_LOG_INTERNAL_CHECK_IMPL((condition), #condition) | | ------------------ | | | | 26| 12| ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS, \ | | | | ------------------ | | | | | | 172| 6| ABSL_LOG_INTERNAL_##type##_CONDITION(condition) | | | | | | ------------------ | | | | | | | | 65| 12| switch (0) \ | | | | | | | | 66| 12| case 0: \ | | | | | | | | ------------------ | | | | | | | | | Branch (66:3): [True: 6, False: 0] | | | | | | | | ------------------ | | | | | | | | 67| 6| default: \ | | | | | | | | ------------------ | | | | | | | | | Branch (67:3): [True: 0, False: 6] | | | | | | | | ------------------ | | | | | | | | 68| 12| !(condition) ? (void)0 : ::absl::log_internal::Voidify()&& | | | | | | | | ------------------ | | | | | | | | | Branch (68:5): [True: 6, False: 0] | | | | | | | | | Branch (68:7): [Folded, False: 6] | | | | | | | | | Branch (68:7): [True: 0, False: 6] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 27| 12| ABSL_PREDICT_FALSE(!(condition))) \ | | | | 28| 12| ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream() | | | | ------------------ | | | | | | 66| 0| ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message) | | | | ------------------ | | ------------------ ------------------ 2249| 6|} _ZNK6google8protobuf14DescriptorPool14FindFileByNameENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEE: 2259| 5| absl::string_view name) const { 2260| 5| DeferredValidation deferred_validation(this); 2261| 5| const FileDescriptor* result = nullptr; 2262| 5| { 2263| 5| absl::MutexLockMaybe lock(mutex_); 2264| 5| if (fallback_database_ != nullptr) { ------------------ | Branch (2264:9): [True: 5, False: 0] ------------------ 2265| 5| tables_->known_bad_symbols_.clear(); 2266| 5| tables_->known_bad_files_.clear(); 2267| 5| } 2268| 5| result = tables_->FindFile(name); 2269| 5| if (result != nullptr) return result; ------------------ | Branch (2269:9): [True: 1, False: 4] ------------------ 2270| 4| if (underlay_ != nullptr) { ------------------ | Branch (2270:9): [True: 0, False: 4] ------------------ 2271| 0| result = underlay_->FindFileByName(name); 2272| 0| if (result != nullptr) return result; ------------------ | Branch (2272:11): [True: 0, False: 0] ------------------ 2273| 0| } 2274| 4| if (TryFindFileInFallbackDatabase(name, deferred_validation)) { ------------------ | Branch (2274:9): [True: 4, False: 0] ------------------ 2275| 4| result = tables_->FindFile(name); 2276| 4| } 2277| 4| } 2278| 4| if (!deferred_validation.Validate()) { ------------------ | Branch (2278:7): [True: 0, False: 4] ------------------ 2279| 0| return nullptr; 2280| 0| } 2281| 4| return result; 2282| 4|} _ZNK6google8protobuf10Descriptor15FindFieldByNameENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEE: 2521| 63.5k| absl::string_view name) const { 2522| 63.5k| const FieldDescriptor* field = 2523| 63.5k| file()->tables_->FindNestedSymbol(this, name).field_descriptor(); 2524| 63.5k| return field != nullptr && !field->is_extension() ? field : nullptr; ------------------ | Branch (2524:10): [True: 63.4k, False: 72] | Branch (2524:30): [True: 63.4k, False: 0] ------------------ 2525| 63.5k|} _ZNK6google8protobuf10Descriptor34FindExtensionRangeContainingNumberEi: 2665| 1|Descriptor::FindExtensionRangeContainingNumber(int number) const { 2666| | // Linear search should be fine because we don't expect a message to have 2667| | // more than a couple extension ranges. 2668| 1| for (int i = 0; i < extension_range_count(); i++) { ------------------ | Branch (2668:19): [True: 1, False: 0] ------------------ 2669| 1| if (number >= extension_range(i)->start_number() && ------------------ | Branch (2669:9): [True: 1, False: 0] ------------------ 2670| 1| number < extension_range(i)->end_number()) { ------------------ | Branch (2670:9): [True: 1, False: 0] ------------------ 2671| 1| return extension_range(i); 2672| 1| } 2673| 1| } 2674| 0| return nullptr; 2675| 1|} _ZNK6google8protobuf14DescriptorPool29TryFindFileInFallbackDatabaseENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEERNS1_18DeferredValidationE: 2703| 4| absl::string_view name, DeferredValidation& deferred_validation) const { 2704| 4| if (fallback_database_ == nullptr) return false; ------------------ | Branch (2704:7): [True: 0, False: 4] ------------------ 2705| | 2706| 4| if (tables_->known_bad_files_.contains(name)) return false; ------------------ | Branch (2706:7): [True: 0, False: 4] ------------------ 2707| | 2708| | // NOINLINE to reduce the stack cost of the operation in the caller. 2709| 4| const auto find_file = [](DescriptorDatabase& database, 2710| 4| absl::string_view filename, 2711| 4| FileDescriptorProto& output) PROTOBUF_NOINLINE { 2712| 4| return database.FindFileByName(std::string(filename), &output); 2713| 4| }; 2714| | 2715| 4| auto& file_proto = deferred_validation.CreateProto(); 2716| 4| if (!find_file(*fallback_database_, name, file_proto) || ------------------ | Branch (2716:7): [True: 0, False: 4] ------------------ 2717| 4| BuildFileFromDatabase(file_proto, deferred_validation) == nullptr) { ------------------ | Branch (2717:7): [True: 0, False: 4] ------------------ 2718| 0| tables_->known_bad_files_.emplace(name); 2719| 0| return false; 2720| 0| } 2721| 4| return true; 2722| 4|} _ZNK6google8protobuf15FieldDescriptor19is_map_message_typeEv: 2816| 102k|bool FieldDescriptor::is_map_message_type() const { 2817| 102k| return message_type()->options().map_entry(); 2818| 102k|} _ZNK6google8protobuf15FieldDescriptor11is_requiredEv: 3945| 182k|bool FieldDescriptor::is_required() const { 3946| 182k| return features().field_presence() == FeatureSet::LEGACY_REQUIRED; 3947| 182k|} _ZNK6google8protobuf15FieldDescriptor15cpp_string_typeEv: 3960| 17.9k|FieldDescriptor::CppStringType FieldDescriptor::cpp_string_type() const { 3961| 17.9k| ABSL_DCHECK(cpp_type() == FieldDescriptor::CPPTYPE_STRING); ------------------ | | 47| 17.9k| ABSL_LOG_INTERNAL_DCHECK_IMPL((condition), #condition) | | ------------------ | | | | 43| 17.9k| ABSL_LOG_INTERNAL_CHECK_IMPL(true || (condition), "true") | | | | ------------------ | | | | | | 26| 35.9k| ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS, \ | | | | | | ------------------ | | | | | | | | 172| 17.9k| ABSL_LOG_INTERNAL_##type##_CONDITION(condition) | | | | | | | | ------------------ | | | | | | | | | | 65| 35.9k| switch (0) \ | | | | | | | | | | 66| 35.9k| case 0: \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (66:3): [True: 17.9k, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 67| 17.9k| default: \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (67:3): [True: 0, False: 17.9k] | | | | | | | | | | ------------------ | | | | | | | | | | 68| 17.9k| !(condition) ? (void)0 : ::absl::log_internal::Voidify()&& | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (68:5): [True: 17.9k, Folded] | | | | | | | | | | | Branch (68:7): [True: 0, Folded] | | | | | | | | | | | Branch (68:7): [True: 0, False: 0] | | | | | | | | | | | Branch (68:7): [Folded, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 27| 35.9k| ABSL_PREDICT_FALSE(!(condition))) \ | | | | | | 28| 35.9k| ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream() | | | | | | ------------------ | | | | | | | | 66| 0| ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 3962| 17.9k| switch (features().GetExtension(pb::cpp).string_type()) { 3963| 0| case pb::CppFeatures::VIEW: ------------------ | Branch (3963:5): [True: 0, False: 17.9k] ------------------ 3964| 0| return CppStringType::kView; 3965| 0| case pb::CppFeatures::CORD: ------------------ | Branch (3965:5): [True: 0, False: 17.9k] ------------------ 3966| | // In open-source, protobuf CORD is only supported for singular bytes 3967| | // fields. 3968| 0| if (type() != FieldDescriptor::TYPE_BYTES || is_repeated() || ------------------ | Branch (3968:11): [True: 0, False: 0] | Branch (3968:52): [True: 0, False: 0] ------------------ 3969| 0| is_extension()) { ------------------ | Branch (3969:11): [True: 0, False: 0] ------------------ 3970| 0| return CppStringType::kString; 3971| 0| } 3972| 0| return CppStringType::kCord; 3973| 17.9k| case pb::CppFeatures::STRING: ------------------ | Branch (3973:5): [True: 17.9k, False: 0] ------------------ 3974| 17.9k| return CppStringType::kString; 3975| 0| default: ------------------ | Branch (3975:5): [True: 0, False: 17.9k] ------------------ 3976| | // If features haven't been resolved, this is a dynamic build not for C++ 3977| | // codegen. Just use string type. 3978| 0| ABSL_DCHECK(!features().GetExtension(pb::cpp).has_string_type()); ------------------ | | 47| 0| ABSL_LOG_INTERNAL_DCHECK_IMPL((condition), #condition) | | ------------------ | | | | 43| 0| ABSL_LOG_INTERNAL_CHECK_IMPL(true || (condition), "true") | | | | ------------------ | | | | | | 26| 0| ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS, \ | | | | | | ------------------ | | | | | | | | 172| 0| ABSL_LOG_INTERNAL_##type##_CONDITION(condition) | | | | | | | | ------------------ | | | | | | | | | | 65| 0| switch (0) \ | | | | | | | | | | 66| 0| case 0: \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (66:3): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 67| 0| default: \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (67:3): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 68| 0| !(condition) ? (void)0 : ::absl::log_internal::Voidify()&& | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (68:5): [True: 0, Folded] | | | | | | | | | | | Branch (68:7): [True: 0, Folded] | | | | | | | | | | | Branch (68:7): [True: 0, False: 0] | | | | | | | | | | | Branch (68:7): [Folded, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 27| 0| ABSL_PREDICT_FALSE(!(condition))) \ | | | | | | 28| 0| ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream() | | | | | | ------------------ | | | | | | | | 66| 0| ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 3979| 0| return CppStringType::kString; 3980| 17.9k| } 3981| 17.9k|} _ZNK6google8protobuf10Descriptor15GetLocationPathEPNSt3__16vectorIiNS2_9allocatorIiEEEE: 4058| 404|void Descriptor::GetLocationPath(std::vector* output) const { 4059| 404| if (containing_type()) { ------------------ | Branch (4059:7): [True: 47, False: 357] ------------------ 4060| 47| containing_type()->GetLocationPath(output); 4061| 47| output->push_back(DescriptorProto::kNestedTypeFieldNumber); 4062| 47| output->push_back(index()); 4063| 357| } else { 4064| 357| output->push_back(FileDescriptorProto::kMessageTypeFieldNumber); 4065| 357| output->push_back(index()); 4066| 357| } 4067| 404|} _ZNK6google8protobuf15FieldDescriptor15GetLocationPathEPNSt3__16vectorIiNS2_9allocatorIiEEEE: 4069| 206|void FieldDescriptor::GetLocationPath(std::vector* output) const { 4070| 206| if (is_extension()) { ------------------ | Branch (4070:7): [True: 1, False: 205] ------------------ 4071| 1| if (extension_scope() == nullptr) { ------------------ | Branch (4071:9): [True: 1, False: 0] ------------------ 4072| 1| output->push_back(FileDescriptorProto::kExtensionFieldNumber); 4073| 1| output->push_back(index()); 4074| 1| } else { 4075| 0| extension_scope()->GetLocationPath(output); 4076| 0| output->push_back(DescriptorProto::kExtensionFieldNumber); 4077| 0| output->push_back(index()); 4078| 0| } 4079| 205| } else { 4080| 205| containing_type()->GetLocationPath(output); 4081| 205| output->push_back(DescriptorProto::kFieldFieldNumber); 4082| 205| output->push_back(index()); 4083| 205| } 4084| 206|} _ZNK6google8protobuf15OneofDescriptor15GetLocationPathEPNSt3__16vectorIiNS2_9allocatorIiEEEE: 4086| 2|void OneofDescriptor::GetLocationPath(std::vector* output) const { 4087| 2| containing_type()->GetLocationPath(output); 4088| 2| output->push_back(DescriptorProto::kOneofDeclFieldNumber); 4089| 2| output->push_back(index()); 4090| 2|} _ZNK6google8protobuf10Descriptor14ExtensionRange15GetLocationPathEPNSt3__16vectorIiNS3_9allocatorIiEEEE: 4093| 14| std::vector* output) const { 4094| 14| containing_type()->GetLocationPath(output); 4095| 14| output->push_back(DescriptorProto::kExtensionRangeFieldNumber); 4096| 14| output->push_back(index()); 4097| 14|} _ZNK6google8protobuf14EnumDescriptor15GetLocationPathEPNSt3__16vectorIiNS2_9allocatorIiEEEE: 4099| 104|void EnumDescriptor::GetLocationPath(std::vector* output) const { 4100| 104| if (containing_type()) { ------------------ | Branch (4100:7): [True: 91, False: 13] ------------------ 4101| 91| containing_type()->GetLocationPath(output); 4102| 91| output->push_back(DescriptorProto::kEnumTypeFieldNumber); 4103| 91| output->push_back(index()); 4104| 91| } else { 4105| 13| output->push_back(FileDescriptorProto::kEnumTypeFieldNumber); 4106| 13| output->push_back(index()); 4107| 13| } 4108| 104|} _ZNK6google8protobuf19EnumValueDescriptor15GetLocationPathEPNSt3__16vectorIiNS2_9allocatorIiEEEE: 4110| 86|void EnumValueDescriptor::GetLocationPath(std::vector* output) const { 4111| 86| type()->GetLocationPath(output); 4112| 86| output->push_back(EnumDescriptorProto::kValueFieldNumber); 4113| 86| output->push_back(index()); 4114| 86|} _ZNK6google8protobuf14DescriptorPool21BuildFileFromDatabaseERKNS0_19FileDescriptorProtoERNS1_18DeferredValidationE: 4740| 4| DeferredValidation& deferred_validation) const { 4741| 4| mutex_->AssertHeld(); 4742| 4| build_started_ = true; 4743| 4| if (tables_->known_bad_files_.contains(proto.name())) { ------------------ | Branch (4743:7): [True: 0, False: 4] ------------------ 4744| 0| return nullptr; 4745| 0| } 4746| 4| const FileDescriptor* result; 4747| 4| const auto build_file = [&] { 4748| 4| result = DescriptorBuilder::New(this, tables_.get(), deferred_validation, 4749| 4| default_error_collector_) 4750| 4| ->BuildFile(proto); 4751| 4| }; 4752| 4| if (dispatcher_ != nullptr) { ------------------ | Branch (4752:7): [True: 0, False: 4] ------------------ 4753| 0| (*dispatcher_)(build_file); 4754| 4| } else { 4755| 4| build_file(); 4756| 4| } 4757| 4| if (result == nullptr) { ------------------ | Branch (4757:7): [True: 0, False: 4] ------------------ 4758| 0| tables_->known_bad_files_.insert(proto.name()); 4759| 0| } 4760| 4| return result; 4761| 4|} _ZN6google8protobuf17DescriptorBuilderC2EPKNS0_14DescriptorPoolEPNS2_6TablesERNS2_18DeferredValidationEPNS2_14ErrorCollectorE: 4797| 4| : pool_(pool), 4798| 4| tables_(tables), 4799| 4| deferred_validation_(deferred_validation), 4800| 4| error_collector_(error_collector), 4801| 4| had_errors_(false), 4802| 4| possible_undeclared_dependency_(nullptr), 4803| 4| undefine_resolved_name_("") { 4804| | // Ensure that any lazily loaded static initializers from the generated pool 4805| | // (e.g. from bootstrapped protos) are run before building any descriptors. We 4806| | // have to avoid registering these pre-main, because we need to ensure that 4807| | // the linker --gc-sections step can strip out the full runtime if it is 4808| | // unused. 4809| 4| PROTOBUF_UNUSED static std::true_type lazy_register = ------------------ | | 620| 4|#define PROTOBUF_UNUSED [[maybe_unused]] ------------------ 4810| 4| (internal::ExtensionSet::RegisterMessageExtension( 4811| 4| &FeatureSet::default_instance(), pb::cpp.number(), 4812| 4| FieldDescriptor::TYPE_MESSAGE, false, false, 4813| 4| &pb::CppFeatures::default_instance(), 4814| 4| nullptr, 4815| 4| internal::LazyAnnotation::kUndefined), 4816| 4| std::true_type{}); 4817| 4|} _ZN6google8protobuf17DescriptorBuilderD2Ev: 4819| 4|DescriptorBuilder::~DescriptorBuilder() = default; _ZN6google8protobuf17DescriptorBuilder32FindSymbolNotEnforcingDepsHelperEPKNS0_14DescriptorPoolENSt3__117basic_string_viewIcNS5_11char_traitsIcEEEEb: 4916| 98| const DescriptorPool* pool, const absl::string_view name, bool build_it) { 4917| | // If we are looking at an underlay, we must lock its mutex_, since we are 4918| | // accessing the underlay's tables_ directly. 4919| 98| absl::MutexLockMaybe lock((pool == pool_) ? nullptr : pool->mutex_); ------------------ | Branch (4919:29): [True: 98, False: 0] ------------------ 4920| | 4921| 98| Symbol result = pool->tables_->FindSymbol(name); 4922| 98| if (result.IsNull() && pool->underlay_ != nullptr) { ------------------ | Branch (4922:7): [True: 0, False: 98] | Branch (4922:26): [True: 0, False: 0] ------------------ 4923| | // Symbol not found; check the underlay. 4924| 0| result = FindSymbolNotEnforcingDepsHelper(pool->underlay_, name); 4925| 0| } 4926| | 4927| 98| if (result.IsNull()) { ------------------ | Branch (4927:7): [True: 0, False: 98] ------------------ 4928| | // With lazily_build_dependencies_, a symbol lookup at cross link time is 4929| | // not guaranteed to be successful. In most cases, build_it will be false, 4930| | // which intentionally prevents us from building an import until it's 4931| | // actually needed. In some cases, like registering an extension, we want 4932| | // to build the file containing the symbol, and build_it will be set. 4933| | // Also, build_it will be true when !lazily_build_dependencies_, to provide 4934| | // better error reporting of missing dependencies. 4935| 0| if (build_it && ------------------ | Branch (4935:9): [True: 0, False: 0] ------------------ 4936| 0| pool->TryFindSymbolInFallbackDatabase(name, deferred_validation_)) { ------------------ | Branch (4936:9): [True: 0, False: 0] ------------------ 4937| 0| result = pool->tables_->FindSymbol(name); 4938| 0| } 4939| 0| } 4940| | 4941| 98| return result; 4942| 98|} _ZN6google8protobuf17DescriptorBuilder26FindSymbolNotEnforcingDepsENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEb: 4945| 98| const absl::string_view name, bool build_it) { 4946| 98| Symbol result = FindSymbolNotEnforcingDepsHelper(pool_, name, build_it); 4947| | // Only find symbols which were defined in this file or one of its 4948| | // dependencies. 4949| 98| const FileDescriptor* file = result.GetFile(); 4950| 98| if ((file == file_ || dependencies_.contains(file)) && !result.IsPackage()) { ------------------ | Branch (4950:8): [True: 97, False: 1] | Branch (4950:25): [True: 0, False: 1] | Branch (4950:58): [True: 97, False: 0] ------------------ 4951| 97| unused_dependency_.erase(file); 4952| 97| } 4953| 98| return result; 4954| 98|} _ZN6google8protobuf17DescriptorBuilder10FindSymbolENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEb: 4957| 98| bool build_it) { 4958| 98| Symbol result = FindSymbolNotEnforcingDeps(name, build_it); 4959| | 4960| 98| if (result.IsNull()) return result; ------------------ | Branch (4960:7): [True: 0, False: 98] ------------------ 4961| | 4962| 98| if (!pool_->enforce_dependencies_) { ------------------ | Branch (4962:7): [True: 98, False: 0] ------------------ 4963| | // Hack for CompilerUpgrader, and also used for lazily_build_dependencies_ 4964| 98| return result; 4965| 98| } 4966| | 4967| | // Only find symbols which were defined in this file or one of its 4968| | // dependencies. 4969| 0| const FileDescriptor* file = result.GetFile(); 4970| 0| if (file == file_ || dependencies_.contains(file)) { ------------------ | Branch (4970:7): [True: 0, False: 0] | Branch (4970:24): [True: 0, False: 0] ------------------ 4971| 0| return result; 4972| 0| } 4973| | 4974| 0| if (result.IsPackage()) { ------------------ | Branch (4974:7): [True: 0, False: 0] ------------------ 4975| | // Arg, this is overcomplicated. The symbol is a package name. It could 4976| | // be that the package was defined in multiple files. result.GetFile() 4977| | // returns the first file we saw that used this package. We've determined 4978| | // that that file is not a direct dependency of the file we are currently 4979| | // building, but it could be that some other file which *is* a direct 4980| | // dependency also defines the same package. We can't really rule out this 4981| | // symbol unless none of the dependencies define it. 4982| 0| if (IsInPackage(file_, name)) return result; ------------------ | Branch (4982:9): [True: 0, False: 0] ------------------ 4983| 0| for (const auto* dep : dependencies_) { ------------------ | Branch (4983:26): [True: 0, False: 0] ------------------ 4984| | // Note: A dependency may be nullptr if it was not found or had errors. 4985| 0| if (dep != nullptr && IsInPackage(dep, name)) return result; ------------------ | Branch (4985:11): [True: 0, False: 0] | Branch (4985:29): [True: 0, False: 0] ------------------ 4986| 0| } 4987| 0| } 4988| | 4989| 0| possible_undeclared_dependency_ = file; 4990| 0| possible_undeclared_dependency_name_ = std::string(name); 4991| 0| return Symbol(); 4992| 0|} _ZN6google8protobuf17DescriptorBuilder25LookupSymbolNoPlaceholderENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEES6_NS1_11ResolveModeEb: 4996| 98| ResolveMode resolve_mode, bool build_it) { 4997| 98| possible_undeclared_dependency_ = nullptr; 4998| 98| undefine_resolved_name_.clear(); 4999| | 5000| 98| if (!name.empty() && name[0] == '.') { ------------------ | Branch (5000:7): [True: 98, False: 0] | Branch (5000:24): [True: 93, False: 5] ------------------ 5001| | // Fully-qualified name. 5002| 93| return FindSymbol(name.substr(1), build_it); 5003| 93| } 5004| | 5005| | // If name is something like "Foo.Bar.baz", and symbols named "Foo" are 5006| | // defined in multiple parent scopes, we only want to find "Bar.baz" in the 5007| | // innermost one. E.g., the following should produce an error: 5008| | // message Bar { message Baz {} } 5009| | // message Foo { 5010| | // message Bar { 5011| | // } 5012| | // optional Bar.Baz baz = 1; 5013| | // } 5014| | // So, we look for just "Foo" first, then look for "Bar.baz" within it if 5015| | // found. 5016| 5| std::string::size_type name_dot_pos = name.find_first_of('.'); 5017| 5| absl::string_view first_part_of_name; 5018| 5| if (name_dot_pos == std::string::npos) { ------------------ | Branch (5018:7): [True: 5, False: 0] ------------------ 5019| 5| first_part_of_name = name; 5020| 5| } else { 5021| 0| first_part_of_name = name.substr(0, name_dot_pos); 5022| 0| } 5023| | 5024| 5| std::string scope_to_try(relative_to); 5025| | 5026| 5| while (true) { ------------------ | Branch (5026:10): [True: 5, Folded] ------------------ 5027| | // Chop off the last component of the scope. 5028| 5| std::string::size_type dot_pos = scope_to_try.find_last_of('.'); 5029| 5| if (dot_pos == std::string::npos) { ------------------ | Branch (5029:9): [True: 0, False: 5] ------------------ 5030| 0| return FindSymbol(name, build_it); 5031| 5| } else { 5032| 5| scope_to_try.erase(dot_pos); 5033| 5| } 5034| | 5035| | // Append ".first_part_of_name" and try to find. 5036| 5| std::string::size_type old_size = scope_to_try.size(); 5037| 5| absl::StrAppend(&scope_to_try, ".", first_part_of_name); 5038| 5| Symbol result = FindSymbol(scope_to_try, build_it); 5039| 5| if (!result.IsNull()) { ------------------ | Branch (5039:9): [True: 5, False: 0] ------------------ 5040| 5| if (first_part_of_name.size() < name.size()) { ------------------ | Branch (5040:11): [True: 0, False: 5] ------------------ 5041| | // name is a compound symbol, of which we only found the first part. 5042| | // Now try to look up the rest of it. 5043| 0| if (result.IsAggregate()) { ------------------ | Branch (5043:13): [True: 0, False: 0] ------------------ 5044| 0| absl::StrAppend(&scope_to_try, 5045| 0| name.substr(first_part_of_name.size())); 5046| 0| result = FindSymbol(scope_to_try, build_it); 5047| 0| if (result.IsNull()) { ------------------ | Branch (5047:15): [True: 0, False: 0] ------------------ 5048| 0| undefine_resolved_name_ = scope_to_try; 5049| 0| } 5050| 0| return result; 5051| 0| } else { 5052| | // We found a symbol but it's not an aggregate. Continue the loop. 5053| 0| } 5054| 5| } else { 5055| 5| if (resolve_mode == LOOKUP_TYPES && !result.IsType()) { ------------------ | Branch (5055:13): [True: 0, False: 5] | Branch (5055:45): [True: 0, False: 0] ------------------ 5056| | // We found a symbol but it's not a type. Continue the loop. 5057| 5| } else { 5058| 5| return result; 5059| 5| } 5060| 5| } 5061| 5| } 5062| | 5063| | // Not found. Remove the name so we can try again. 5064| 0| scope_to_try.erase(old_size); 5065| 0| } 5066| 5|} _ZN6google8protobuf17DescriptorBuilder12LookupSymbolENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEES6_NS0_14DescriptorPool15PlaceholderTypeENS1_11ResolveModeEb: 5071| 93| bool build_it) { 5072| 93| Symbol result = 5073| 93| LookupSymbolNoPlaceholder(name, relative_to, resolve_mode, build_it); 5074| 93| if (result.IsNull() && pool_->allow_unknown_) { ------------------ | Branch (5074:7): [True: 0, False: 93] | Branch (5074:26): [True: 0, False: 0] ------------------ 5075| | // Not found, but AllowUnknownDependencies() is enabled. Return a 5076| | // placeholder instead. 5077| 0| result = pool_->NewPlaceholderWithMutexHeld(name, placeholder_type); 5078| 0| } 5079| 93| return result; 5080| 93|} _ZN6google8protobuf17DescriptorBuilder9AddSymbolENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEPKvS6_RKNS0_7MessageENS0_6SymbolE: 5269| 357| const Message& proto, Symbol symbol) { 5270| | // If the caller passed nullptr for the parent, the symbol is at file scope. 5271| | // Use its file as the parent instead. 5272| 357| if (parent == nullptr) parent = file_; ------------------ | Branch (5272:7): [True: 49, False: 308] ------------------ 5273| | 5274| 357| if (absl::StrContains(full_name, '\0')) { ------------------ | Branch (5274:7): [True: 0, False: 357] ------------------ 5275| 0| AddError(full_name, proto, DescriptorPool::ErrorCollector::NAME, [&] { 5276| 0| return absl::StrCat("\"", full_name, "\" contains null character."); 5277| 0| }); 5278| 0| return false; 5279| 0| } 5280| 357| if (tables_->AddSymbol(full_name, symbol)) { ------------------ | Branch (5280:7): [True: 357, False: 0] ------------------ 5281| 357| if (!file_tables_->AddAliasUnderParent(parent, name, symbol)) { ------------------ | Branch (5281:9): [True: 0, False: 357] ------------------ 5282| | // This is only possible if there was already an error adding something of 5283| | // the same name. 5284| 0| if (!had_errors_) { ------------------ | Branch (5284:11): [True: 0, False: 0] ------------------ 5285| 0| ABSL_DLOG(FATAL) << "\"" << full_name ------------------ | | 40| 0|#define ABSL_DLOG(severity) ABSL_LOG_INTERNAL_DLOG_IMPL(_##severity) | | ------------------ | | | | 41| 0| ABSL_LOG_INTERNAL_CONDITION##severity(STATELESS, false) \ | | | | ------------------ | | | | | | 172| 0| ABSL_LOG_INTERNAL_##type##_CONDITION(condition) | | | | | | ------------------ | | | | | | | | 65| 0| switch (0) \ | | | | | | | | 66| 0| case 0: \ | | | | | | | | ------------------ | | | | | | | | | Branch (66:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 67| 0| default: \ | | | | | | | | ------------------ | | | | | | | | | Branch (67:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 68| 0| !(condition) ? (void)0 : ::absl::log_internal::Voidify()&& | | | | | | | | ------------------ | | | | | | | | | Branch (68:5): [True: 0, Folded] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 42| 0| ABSL_LOGGING_INTERNAL_LOG##severity.InternalStream() | | | | ------------------ | | | | | | 55| 0| ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__) | | | | ------------------ | | ------------------ ------------------ 5286| 0| << "\" not previously defined in " 5287| 0| "symbols_by_name_, but was defined in " 5288| 0| "symbols_by_parent_; this shouldn't be possible."; 5289| 0| } 5290| 0| return false; 5291| 0| } 5292| 357| return true; 5293| 357| } else { 5294| 0| const FileDescriptor* other_file = tables_->FindSymbol(full_name).GetFile(); 5295| 0| if (other_file == file_) { ------------------ | Branch (5295:9): [True: 0, False: 0] ------------------ 5296| 0| std::string::size_type dot_pos = full_name.find_last_of('.'); 5297| 0| if (dot_pos == std::string::npos) { ------------------ | Branch (5297:11): [True: 0, False: 0] ------------------ 5298| 0| AddError(full_name, proto, DescriptorPool::ErrorCollector::NAME, [&] { 5299| 0| return absl::StrCat("\"", full_name, "\" is already defined."); 5300| 0| }); 5301| 0| } else { 5302| 0| AddError(full_name, proto, DescriptorPool::ErrorCollector::NAME, [&] { 5303| 0| return absl::StrCat("\"", full_name.substr(dot_pos + 1), 5304| 0| "\" is already defined in \"", 5305| 0| full_name.substr(0, dot_pos), "\"."); 5306| 0| }); 5307| 0| } 5308| 0| } else { 5309| | // Symbol seems to have been defined in a different file. 5310| 0| AddError(full_name, proto, DescriptorPool::ErrorCollector::NAME, [&] { 5311| 0| return absl::StrCat( 5312| 0| "\"", full_name, "\" is already defined in file \"", 5313| 0| (other_file == nullptr ? "null" : other_file->name()), "\"."); 5314| 0| }); 5315| 0| } 5316| 0| return false; 5317| 0| } 5318| 357|} _ZN6google8protobuf17DescriptorBuilder10AddPackageENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEERKNS0_7MessageEPNS0_14FileDescriptorEb: 5322| 6| bool toplevel) { 5323| 6| if (absl::StrContains(name, '\0')) { ------------------ | Branch (5323:7): [True: 0, False: 6] ------------------ 5324| 0| AddError(name, proto, DescriptorPool::ErrorCollector::NAME, [&] { 5325| 0| return absl::StrCat("\"", name, "\" contains null character."); 5326| 0| }); 5327| 0| return; 5328| 0| } 5329| | 5330| 6| Symbol existing_symbol = tables_->FindSymbol(name); 5331| | // It's OK to redefine a package. 5332| 6| if (existing_symbol.IsNull()) { ------------------ | Branch (5332:7): [True: 5, False: 1] ------------------ 5333| 5| if (toplevel) { ------------------ | Branch (5333:9): [True: 3, False: 2] ------------------ 5334| | // It is the toplevel package name, so insert the descriptor directly. 5335| 3| tables_->AddSymbol(file->package(), Symbol(file)); 5336| 3| } else { 5337| 2| auto* package = tables_->Allocate(); 5338| | // If the name is the package name, then it is already in the arena. 5339| | // If not, copy it there. It came from the call to AddPackage below. 5340| 2| package->name_size = static_cast(name.size()); 5341| 2| package->file = file; 5342| 2| tables_->AddSymbol(name, Symbol(package)); 5343| 2| } 5344| | // Also add parent package, if any. 5345| 5| std::string::size_type dot_pos = name.find_last_of('.'); 5346| 5| if (dot_pos == std::string::npos) { ------------------ | Branch (5346:9): [True: 3, False: 2] ------------------ 5347| | // No parents. 5348| 3| ValidateSymbolName(name, name, proto); 5349| 3| } else { 5350| | // Has parent. 5351| 2| AddPackage(name.substr(0, dot_pos), proto, file, false); 5352| 2| ValidateSymbolName(name.substr(dot_pos + 1), name, proto); 5353| 2| } 5354| 5| } else if (!existing_symbol.IsPackage()) { ------------------ | Branch (5354:14): [True: 0, False: 1] ------------------ 5355| | // Symbol seems to have been defined in a different file. 5356| 0| const FileDescriptor* other_file = existing_symbol.GetFile(); 5357| 0| AddError(name, proto, DescriptorPool::ErrorCollector::NAME, [&] { 5358| 0| return absl::StrCat("\"", name, 5359| 0| "\" is already defined (as something other than " 5360| 0| "a package) in file \"", 5361| 0| (other_file == nullptr ? "null" : other_file->name()), 5362| 0| "\"."); 5363| 0| }); 5364| 0| } 5365| 6|} _ZN6google8protobuf17DescriptorBuilder18ValidateSymbolNameENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEES6_RKNS0_7MessageE: 5369| 362| const Message& proto) { 5370| 362| if (name.empty()) { ------------------ | Branch (5370:7): [True: 0, False: 362] ------------------ 5371| 0| AddError(full_name, proto, DescriptorPool::ErrorCollector::NAME, 5372| 0| "Missing name."); 5373| 362| } else { 5374| 4.16k| for (char character : name) { ------------------ | Branch (5374:25): [True: 4.16k, False: 362] ------------------ 5375| | // I don't trust isalnum() due to locales. :( 5376| 4.16k| if ((character < 'a' || 'z' < character) && ------------------ | Branch (5376:12): [True: 1.37k, False: 2.78k] | Branch (5376:31): [True: 0, False: 2.78k] ------------------ 5377| 1.37k| (character < 'A' || 'Z' < character) && ------------------ | Branch (5377:12): [True: 54, False: 1.32k] | Branch (5377:31): [True: 228, False: 1.09k] ------------------ 5378| 282| (character < '0' || '9' < character) && (character != '_')) { ------------------ | Branch (5378:12): [True: 0, False: 282] | Branch (5378:31): [True: 228, False: 54] | Branch (5378:51): [True: 0, False: 228] ------------------ 5379| 0| AddError(full_name, proto, DescriptorPool::ErrorCollector::NAME, [&] { 5380| 0| return absl::StrCat("\"", name, "\" is not a valid identifier."); 5381| 0| }); 5382| 0| return; 5383| 0| } 5384| 4.16k| } 5385| 362| } 5386| 362|} _ZN6google8protobuf17DescriptorBuilder15AllocateOptionsERKNS0_19FileDescriptorProtoEPNS0_14FileDescriptorERNS0_8internal13FlatAllocatorE: 5411| 4| internal::FlatAllocator& alloc) { 5412| 4| std::vector options_path; 5413| 4| options_path.push_back(FileDescriptorProto::kOptionsFieldNumber); 5414| | // We add the dummy token so that LookupSymbol does the right thing. 5415| 4| auto options = AllocateOptionsImpl( 5416| 4| absl::StrCat(descriptor->package(), ".dummy"), descriptor->name(), proto, 5417| 4| options_path, "google.protobuf.FileOptions", alloc); 5418| 4| descriptor->options_ = options; 5419| 4| descriptor->proto_features_ = &FeatureSet::default_instance(); 5420| 4| descriptor->merged_features_ = &FeatureSet::default_instance(); 5421| 4|} _ZN6google8protobuf17DescriptorBuilder15ResolveFeaturesERKNS0_19FileDescriptorProtoEPNS0_14FileDescriptorEPNS0_11FileOptionsERNS0_8internal13FlatAllocatorE: 5593| 4| internal::FlatAllocator& alloc) { 5594| | // File descriptors always need their own merged feature set, even without 5595| | // any explicit features. 5596| 4| ResolveFeaturesImpl(descriptor->edition(), proto, descriptor, options, alloc, 5597| 4| DescriptorPool::ErrorCollector::EDITIONS, 5598| 4| /*force_merge=*/true); 5599| 4|} _ZN6google8protobuf17DescriptorBuilder24PostProcessFieldFeaturesERNS0_15FieldDescriptorERKNS0_20FieldDescriptorProtoE: 5602| 206| FieldDescriptor& field, const FieldDescriptorProto& proto) { 5603| | // TODO This can be replace by a runtime check in `is_required` 5604| | // once the `label` getter is hidden. 5605| 206| if (field.features().field_presence() == FeatureSet::LEGACY_REQUIRED && ------------------ | Branch (5605:7): [True: 2, False: 204] ------------------ 5606| 2| field.label_ == FieldDescriptor::LABEL_OPTIONAL) { ------------------ | Branch (5606:7): [True: 0, False: 2] ------------------ 5607| 0| field.label_ = FieldDescriptor::LABEL_REQUIRED; 5608| 0| } 5609| | // TODO This can be replace by a runtime check of `is_delimited` 5610| | // once the `TYPE_GROUP` value is removed. 5611| 206| if (field.type_ == FieldDescriptor::TYPE_MESSAGE && ------------------ | Branch (5611:7): [True: 67, False: 139] ------------------ 5612| 67| !field.containing_type()->options().map_entry() && ------------------ | Branch (5612:7): [True: 67, False: 0] ------------------ 5613| 67| field.features().message_encoding() == FeatureSet::DELIMITED) { ------------------ | Branch (5613:7): [True: 0, False: 67] ------------------ 5614| 0| Symbol type = 5615| 0| LookupSymbol(proto.type_name(), field.full_name(), 5616| 0| DescriptorPool::PLACEHOLDER_MESSAGE, LOOKUP_TYPES, false); 5617| 0| if (type.descriptor() == nullptr || ------------------ | Branch (5617:9): [True: 0, False: 0] ------------------ 5618| 0| !type.descriptor()->options().map_entry()) { ------------------ | Branch (5618:9): [True: 0, False: 0] ------------------ 5619| 0| field.type_ = FieldDescriptor::TYPE_GROUP; 5620| 0| } 5621| 0| } 5622| 206|} _ZN6google8protobuf17DescriptorBuilder9BuildFileERKNS0_19FileDescriptorProtoE: 5816| 4| const FileDescriptorProto& proto) { 5817| | // Ensure the generated pool has been lazily initialized. This is most 5818| | // important for protos that use C++-specific features, since that extension 5819| | // is only registered lazily and we always parse options into the generated 5820| | // pool. 5821| 4| if (pool_ != DescriptorPool::internal_generated_pool()) { ------------------ | Branch (5821:7): [True: 0, False: 4] ------------------ 5822| 0| DescriptorPool::generated_pool(); 5823| 0| } 5824| | 5825| 4| filename_ = proto.name(); 5826| | 5827| | // Check if the file already exists and is identical to the one being built. 5828| | // Note: This only works if the input is canonical -- that is, it 5829| | // fully-qualifies all type names, has no UninterpretedOptions, etc. 5830| | // This is fine, because this idempotency "feature" really only exists to 5831| | // accommodate one hack in the proto1->proto2 migration layer. 5832| 4| const FileDescriptor* existing_file = tables_->FindFile(filename_); 5833| 4| if (existing_file != nullptr) { ------------------ | Branch (5833:7): [True: 0, False: 4] ------------------ 5834| | // File already in pool. Compare the existing one to the input. 5835| 0| if (ExistingFileMatchesProto(existing_file->edition(), existing_file, ------------------ | Branch (5835:9): [True: 0, False: 0] ------------------ 5836| 0| proto)) { 5837| | // They're identical. Return the existing descriptor. 5838| 0| return existing_file; 5839| 0| } 5840| | 5841| | // Not a match. The error will be detected and handled later. 5842| 0| } 5843| | 5844| | // Check to see if this file is already on the pending files list. 5845| | // TODO: Allow recursive imports? It may not work with some 5846| | // (most?) programming languages. E.g., in C++, a forward declaration 5847| | // of a type is not sufficient to allow it to be used even in a 5848| | // generated header file due to inlining. This could perhaps be 5849| | // worked around using tricks involving inserting #include statements 5850| | // mid-file, but that's pretty ugly, and I'm pretty sure there are 5851| | // some languages out there that do not allow recursive dependencies 5852| | // at all. 5853| 4| for (size_t i = 0; i < tables_->pending_files_.size(); i++) { ------------------ | Branch (5853:22): [True: 0, False: 4] ------------------ 5854| 0| if (tables_->pending_files_[i] == proto.name()) { ------------------ | Branch (5854:9): [True: 0, False: 0] ------------------ 5855| 0| AddRecursiveImportError(proto, i); 5856| 0| return nullptr; 5857| 0| } 5858| 0| } 5859| | 5860| 4| static const int kMaximumPackageLength = 511; 5861| 4| if (proto.package().size() > kMaximumPackageLength) { ------------------ | Branch (5861:7): [True: 0, False: 4] ------------------ 5862| 0| AddError(proto.package(), proto, DescriptorPool::ErrorCollector::NAME, 5863| 0| "Package name is too long"); 5864| 0| return nullptr; 5865| 0| } 5866| | 5867| | // If we have a fallback_database_, and we aren't doing lazy import building, 5868| | // attempt to load all dependencies now, before checkpointing tables_. This 5869| | // avoids confusion with recursive checkpoints. 5870| 4| if (!pool_->lazily_build_dependencies_) { ------------------ | Branch (5870:7): [True: 0, False: 4] ------------------ 5871| 0| if (pool_->fallback_database_ != nullptr) { ------------------ | Branch (5871:9): [True: 0, False: 0] ------------------ 5872| 0| tables_->pending_files_.push_back(proto.name()); 5873| 0| for (int i = 0; i < proto.dependency_size(); i++) { ------------------ | Branch (5873:23): [True: 0, False: 0] ------------------ 5874| 0| if (tables_->FindFile(proto.dependency(i)) == nullptr && ------------------ | Branch (5874:13): [True: 0, False: 0] ------------------ 5875| 0| (pool_->underlay_ == nullptr || ------------------ | Branch (5875:14): [True: 0, False: 0] ------------------ 5876| 0| pool_->underlay_->FindFileByName(proto.dependency(i)) == ------------------ | Branch (5876:14): [True: 0, False: 0] ------------------ 5877| 0| nullptr)) { 5878| | // We don't care what this returns since we'll find out below anyway. 5879| 0| pool_->TryFindFileInFallbackDatabase(proto.dependency(i), 5880| 0| deferred_validation_); 5881| 0| } 5882| 0| } 5883| 0| tables_->pending_files_.pop_back(); 5884| 0| } 5885| 0| } 5886| | 5887| | // Checkpoint the tables so that we can roll back if something goes wrong. 5888| 4| tables_->AddCheckpoint(); 5889| | 5890| 4| auto alloc = absl::make_unique(); 5891| 4| PlanAllocationSize(proto, *alloc); 5892| 4| alloc->FinalizePlanning(tables_); 5893| 4| FileDescriptor* result = BuildFileImpl(proto, *alloc); 5894| | 5895| 4| file_tables_->FinalizeTables(); 5896| 4| if (result) { ------------------ | Branch (5896:7): [True: 4, False: 0] ------------------ 5897| 4| tables_->ClearLastCheckpoint(); 5898| 4| result->finished_building_ = true; 5899| 4| alloc->ExpectConsumed(); 5900| 4| } else { 5901| 0| tables_->RollbackToLastCheckpoint(deferred_validation_); 5902| 0| } 5903| | 5904| 4| return result; 5905| 4|} _ZN6google8protobuf17DescriptorBuilder13BuildFileImplERKNS0_19FileDescriptorProtoERNS0_8internal13FlatAllocatorE: 5908| 4| const FileDescriptorProto& proto, internal::FlatAllocator& alloc) { 5909| 4| FileDescriptor* result = alloc.AllocateArray(1); 5910| 4| file_ = result; 5911| | 5912| 4| if (proto.has_edition()) { ------------------ | Branch (5912:7): [True: 0, False: 4] ------------------ 5913| 0| file_->edition_ = proto.edition(); 5914| 4| } else if (proto.syntax().empty() || proto.syntax() == "proto2") { ------------------ | Branch (5914:14): [True: 3, False: 1] | Branch (5914:40): [True: 0, False: 1] ------------------ 5915| 3| file_->edition_ = Edition::EDITION_PROTO2; 5916| 3| } else if (proto.syntax() == "proto3") { ------------------ | Branch (5916:14): [True: 1, False: 0] ------------------ 5917| 1| file_->edition_ = Edition::EDITION_PROTO3; 5918| 1| } else { 5919| 0| file_->edition_ = Edition::EDITION_UNKNOWN; 5920| 0| AddError(proto.name(), proto, DescriptorPool::ErrorCollector::OTHER, [&] { 5921| 0| return absl::StrCat("Unrecognized syntax: ", proto.syntax()); 5922| 0| }); 5923| 0| } 5924| | 5925| 4| const FeatureSetDefaults& defaults = 5926| 4| pool_->feature_set_defaults_spec_ == nullptr ------------------ | Branch (5926:7): [True: 4, False: 0] ------------------ 5927| 4| ? GetCppFeatureSetDefaults() 5928| 4| : *pool_->feature_set_defaults_spec_; 5929| | 5930| 4| absl::StatusOr feature_resolver = 5931| 4| FeatureResolver::Create(file_->edition_, defaults); 5932| 4| if (!feature_resolver.ok()) { ------------------ | Branch (5932:7): [True: 0, False: 4] ------------------ 5933| 0| AddError(proto.name(), proto, DescriptorPool::ErrorCollector::EDITIONS, 5934| 0| [&] { return std::string(feature_resolver.status().message()); }); 5935| 4| } else { 5936| 4| feature_resolver_.emplace(std::move(feature_resolver).value()); 5937| 4| } 5938| | 5939| 4| result->is_placeholder_ = false; 5940| 4| result->finished_building_ = false; 5941| 4| SourceCodeInfo* info = nullptr; 5942| 4| if (proto.has_source_code_info()) { ------------------ | Branch (5942:7): [True: 0, False: 4] ------------------ 5943| 0| info = alloc.AllocateArray(1); 5944| 0| *info = proto.source_code_info(); 5945| 0| result->source_code_info_ = info; 5946| 4| } else { 5947| 4| result->source_code_info_ = &SourceCodeInfo::default_instance(); 5948| 4| } 5949| | 5950| 4| file_tables_ = alloc.AllocateArray(1); 5951| 4| file_->tables_ = file_tables_; 5952| | 5953| 4| if (!proto.has_name()) { ------------------ | Branch (5953:7): [True: 0, False: 4] ------------------ 5954| 0| AddError("", proto, DescriptorPool::ErrorCollector::OTHER, 5955| 0| "Missing field: FileDescriptorProto.name."); 5956| 0| } 5957| | 5958| 4| result->name_ = alloc.AllocateStrings(proto.name()); 5959| 4| if (proto.has_package()) { ------------------ | Branch (5959:7): [True: 4, False: 0] ------------------ 5960| 4| result->package_ = alloc.AllocateStrings(proto.package()); 5961| 4| } else { 5962| | // We cannot rely on proto.package() returning a valid string if 5963| | // proto.has_package() is false, because we might be running at static 5964| | // initialization time, in which case default values have not yet been 5965| | // initialized. 5966| 0| result->package_ = alloc.AllocateStrings(""); 5967| 0| } 5968| 4| result->pool_ = pool_; 5969| | 5970| 4| if (absl::StrContains(result->name(), '\0')) { ------------------ | Branch (5970:7): [True: 0, False: 4] ------------------ 5971| 0| AddError(result->name(), proto, DescriptorPool::ErrorCollector::NAME, [&] { 5972| 0| return absl::StrCat("\"", result->name(), "\" contains null character."); 5973| 0| }); 5974| 0| return nullptr; 5975| 0| } 5976| | 5977| | // Add to tables. 5978| 4| if (!tables_->AddFile(result)) { ------------------ | Branch (5978:7): [True: 0, False: 4] ------------------ 5979| 0| AddError(proto.name(), proto, DescriptorPool::ErrorCollector::OTHER, 5980| 0| "A file with this name is already in the pool."); 5981| | // Bail out early so that if this is actually the exact same file, we 5982| | // don't end up reporting that every single symbol is already defined. 5983| 0| return nullptr; 5984| 0| } 5985| 4| if (!result->package().empty()) { ------------------ | Branch (5985:7): [True: 4, False: 0] ------------------ 5986| 4| if (std::count(result->package().begin(), result->package().end(), '.') > ------------------ | Branch (5986:9): [True: 0, False: 4] ------------------ 5987| 4| kPackageLimit) { 5988| 0| AddError(result->package(), proto, DescriptorPool::ErrorCollector::NAME, 5989| 0| "Exceeds Maximum Package Depth"); 5990| 0| return nullptr; 5991| 0| } 5992| 4| AddPackage(result->package(), proto, result, true); 5993| 4| } 5994| | 5995| | // Make sure all dependencies are loaded. 5996| 4| absl::flat_hash_set seen_dependencies; 5997| 4| result->dependency_count_ = proto.dependency_size(); 5998| 4| result->dependencies_ = 5999| 4| alloc.AllocateArray(proto.dependency_size()); 6000| 4| result->dependencies_once_ = nullptr; 6001| 4| unused_dependency_.clear(); 6002| 4| absl::flat_hash_set weak_deps; 6003| 4| for (int i = 0; i < proto.weak_dependency_size(); ++i) { ------------------ | Branch (6003:19): [True: 0, False: 4] ------------------ 6004| 0| weak_deps.insert(proto.weak_dependency(i)); 6005| 0| } 6006| | 6007| 4| bool need_lazy_deps = false; 6008| 5| for (int i = 0; i < proto.dependency_size(); i++) { ------------------ | Branch (6008:19): [True: 1, False: 4] ------------------ 6009| 1| if (!seen_dependencies.insert(proto.dependency(i)).second) { ------------------ | Branch (6009:9): [True: 0, False: 1] ------------------ 6010| 0| AddTwiceListedError(proto, i); 6011| 0| } 6012| | 6013| 1| const FileDescriptor* dependency = tables_->FindFile(proto.dependency(i)); 6014| 1| if (dependency == nullptr && pool_->underlay_ != nullptr) { ------------------ | Branch (6014:9): [True: 0, False: 1] | Branch (6014:34): [True: 0, False: 0] ------------------ 6015| 0| dependency = pool_->underlay_->FindFileByName(proto.dependency(i)); 6016| 0| } 6017| | 6018| 1| if (dependency == result) { ------------------ | Branch (6018:9): [True: 0, False: 1] ------------------ 6019| | // Recursive import. dependency/result is not fully initialized, and it's 6020| | // dangerous to try to do anything with it. The recursive import error 6021| | // will be detected and reported in DescriptorBuilder::BuildFile(). 6022| 0| return nullptr; 6023| 0| } 6024| | 6025| 1| if (dependency == nullptr) { ------------------ | Branch (6025:9): [True: 0, False: 1] ------------------ 6026| 0| if (!pool_->lazily_build_dependencies_) { ------------------ | Branch (6026:11): [True: 0, False: 0] ------------------ 6027| 0| if (pool_->allow_unknown_ || ------------------ | Branch (6027:13): [True: 0, False: 0] ------------------ 6028| 0| (!pool_->enforce_weak_ && weak_deps.contains(i))) { ------------------ | Branch (6028:14): [True: 0, False: 0] | Branch (6028:39): [True: 0, False: 0] ------------------ 6029| 0| internal::FlatAllocator lazy_dep_alloc; 6030| 0| lazy_dep_alloc.PlanArray(1); 6031| 0| lazy_dep_alloc.PlanArray(1); 6032| 0| lazy_dep_alloc.FinalizePlanning(tables_); 6033| 0| dependency = pool_->NewPlaceholderFileWithMutexHeld( 6034| 0| proto.dependency(i), lazy_dep_alloc); 6035| 0| } else { 6036| 0| AddImportError(proto, i); 6037| 0| } 6038| 0| } 6039| 1| } else { 6040| | // Add to unused_dependency_ to track unused imported files. 6041| | // Note: do not track unused imported files for public import. 6042| 1| if (pool_->enforce_dependencies_ && ------------------ | Branch (6042:11): [True: 0, False: 1] | Branch (6042:11): [True: 0, False: 1] ------------------ 6043| 0| (pool_->direct_input_files_.find(proto.name()) != ------------------ | Branch (6043:11): [True: 0, False: 0] ------------------ 6044| 0| pool_->direct_input_files_.end()) && 6045| 0| (dependency->public_dependency_count() == 0)) { ------------------ | Branch (6045:11): [True: 0, False: 0] ------------------ 6046| 0| unused_dependency_.insert(dependency); 6047| 0| } 6048| 1| } 6049| | 6050| 1| result->dependencies_[i] = dependency; 6051| 1| if (pool_->lazily_build_dependencies_ && !dependency) { ------------------ | Branch (6051:9): [True: 1, False: 0] | Branch (6051:46): [True: 0, False: 1] ------------------ 6052| 0| need_lazy_deps = true; 6053| 0| } 6054| 1| } 6055| 4| if (need_lazy_deps) { ------------------ | Branch (6055:7): [True: 0, False: 4] ------------------ 6056| 0| int total_char_size = 0; 6057| 0| for (int i = 0; i < proto.dependency_size(); i++) { ------------------ | Branch (6057:21): [True: 0, False: 0] ------------------ 6058| 0| if (result->dependencies_[i] == nullptr) { ------------------ | Branch (6058:11): [True: 0, False: 0] ------------------ 6059| 0| total_char_size += static_cast(proto.dependency(i).size()); 6060| 0| } 6061| 0| ++total_char_size; // For NUL char 6062| 0| } 6063| | 6064| 0| void* data = tables_->AllocateBytes( 6065| 0| static_cast(sizeof(absl::once_flag)) + total_char_size); 6066| 0| result->dependencies_once_ = ::new (data) absl::once_flag{}; 6067| 0| char* name_data = reinterpret_cast(result->dependencies_once_ + 1); 6068| | 6069| 0| for (int i = 0; i < proto.dependency_size(); i++) { ------------------ | Branch (6069:21): [True: 0, False: 0] ------------------ 6070| 0| if (result->dependencies_[i] == nullptr) { ------------------ | Branch (6070:11): [True: 0, False: 0] ------------------ 6071| 0| memcpy(name_data, proto.dependency(i).data(), 6072| 0| proto.dependency(i).size()); 6073| 0| name_data += proto.dependency(i).size(); 6074| 0| } 6075| 0| *name_data++ = '\0'; 6076| 0| } 6077| 0| } 6078| | 6079| | // Check public dependencies. 6080| 4| int public_dependency_count = 0; 6081| 4| result->public_dependencies_ = 6082| 4| alloc.AllocateArray(proto.public_dependency_size()); 6083| 4| for (int i = 0; i < proto.public_dependency_size(); i++) { ------------------ | Branch (6083:19): [True: 0, False: 4] ------------------ 6084| | // Only put valid public dependency indexes. 6085| 0| int index = proto.public_dependency(i); 6086| 0| if (index >= 0 && index < proto.dependency_size()) { ------------------ | Branch (6086:9): [True: 0, False: 0] | Branch (6086:23): [True: 0, False: 0] ------------------ 6087| 0| result->public_dependencies_[public_dependency_count++] = index; 6088| | // Do not track unused imported files for public import. 6089| | // Calling dependency(i) builds that file when doing lazy imports, 6090| | // need to avoid doing this. Unused dependency detection isn't done 6091| | // when building lazily, anyways. 6092| 0| if (!pool_->lazily_build_dependencies_) { ------------------ | Branch (6092:11): [True: 0, False: 0] ------------------ 6093| 0| unused_dependency_.erase(result->dependency(index)); 6094| 0| } 6095| 0| } else { 6096| 0| AddError(proto.name(), proto, DescriptorPool::ErrorCollector::OTHER, 6097| 0| "Invalid public dependency index."); 6098| 0| } 6099| 0| } 6100| 4| result->public_dependency_count_ = public_dependency_count; 6101| | 6102| | // Build dependency set 6103| 4| dependencies_.clear(); 6104| | // We don't/can't do proper dependency error checking when 6105| | // lazily_build_dependencies_, and calling dependency(i) will force 6106| | // a dependency to be built, which we don't want. 6107| 4| if (!pool_->lazily_build_dependencies_) { ------------------ | Branch (6107:7): [True: 0, False: 4] ------------------ 6108| 0| for (int i = 0; i < result->dependency_count(); i++) { ------------------ | Branch (6108:21): [True: 0, False: 0] ------------------ 6109| 0| RecordPublicDependencies(result->dependency(i)); 6110| 0| } 6111| 0| } 6112| | 6113| | // Check weak dependencies. 6114| 4| int weak_dependency_count = 0; 6115| 4| result->weak_dependencies_ = 6116| 4| alloc.AllocateArray(proto.weak_dependency_size()); 6117| 4| for (int i = 0; i < proto.weak_dependency_size(); i++) { ------------------ | Branch (6117:19): [True: 0, False: 4] ------------------ 6118| 0| int index = proto.weak_dependency(i); 6119| 0| if (index >= 0 && index < proto.dependency_size()) { ------------------ | Branch (6119:9): [True: 0, False: 0] | Branch (6119:23): [True: 0, False: 0] ------------------ 6120| 0| result->weak_dependencies_[weak_dependency_count++] = index; 6121| 0| } else { 6122| 0| AddError(proto.name(), proto, DescriptorPool::ErrorCollector::OTHER, 6123| 0| "Invalid weak dependency index."); 6124| 0| } 6125| 0| } 6126| 4| result->weak_dependency_count_ = weak_dependency_count; 6127| | 6128| | // Convert children. 6129| 4| BUILD_ARRAY(proto, result, message_type, BuildMessage, nullptr); ------------------ | | 5627| 4| OUTPUT->NAME##_count_ = INPUT.NAME##_size(); \ | | 5628| 4| OUTPUT->NAME##s_ = alloc.AllocateArray< \ | | 5629| 4| typename std::remove_pointerNAME##s_)>::type>( \ | | 5630| 4| INPUT.NAME##_size()); \ | | 5631| 39| for (int i = 0; i < INPUT.NAME##_size(); i++) { \ | | ------------------ | | | Branch (5631:19): [True: 35, False: 4] | | ------------------ | | 5632| 35| METHOD(INPUT.NAME(i), PARENT, OUTPUT->NAME##s_ + i, alloc); \ | | 5633| 35| } ------------------ 6130| 4| BUILD_ARRAY(proto, result, enum_type, BuildEnum, nullptr); ------------------ | | 5627| 4| OUTPUT->NAME##_count_ = INPUT.NAME##_size(); \ | | 5628| 4| OUTPUT->NAME##s_ = alloc.AllocateArray< \ | | 5629| 4| typename std::remove_pointerNAME##s_)>::type>( \ | | 5630| 4| INPUT.NAME##_size()); \ | | 5631| 5| for (int i = 0; i < INPUT.NAME##_size(); i++) { \ | | ------------------ | | | Branch (5631:19): [True: 1, False: 4] | | ------------------ | | 5632| 1| METHOD(INPUT.NAME(i), PARENT, OUTPUT->NAME##s_ + i, alloc); \ | | 5633| 1| } ------------------ 6131| 4| BUILD_ARRAY(proto, result, service, BuildService, nullptr); ------------------ | | 5627| 4| OUTPUT->NAME##_count_ = INPUT.NAME##_size(); \ | | 5628| 4| OUTPUT->NAME##s_ = alloc.AllocateArray< \ | | 5629| 4| typename std::remove_pointerNAME##s_)>::type>( \ | | 5630| 4| INPUT.NAME##_size()); \ | | 5631| 4| for (int i = 0; i < INPUT.NAME##_size(); i++) { \ | | ------------------ | | | Branch (5631:19): [True: 0, False: 4] | | ------------------ | | 5632| 0| METHOD(INPUT.NAME(i), PARENT, OUTPUT->NAME##s_ + i, alloc); \ | | 5633| 0| } ------------------ 6132| 4| BUILD_ARRAY(proto, result, extension, BuildExtension, nullptr); ------------------ | | 5627| 4| OUTPUT->NAME##_count_ = INPUT.NAME##_size(); \ | | 5628| 4| OUTPUT->NAME##s_ = alloc.AllocateArray< \ | | 5629| 4| typename std::remove_pointerNAME##s_)>::type>( \ | | 5630| 4| INPUT.NAME##_size()); \ | | 5631| 5| for (int i = 0; i < INPUT.NAME##_size(); i++) { \ | | ------------------ | | | Branch (5631:19): [True: 1, False: 4] | | ------------------ | | 5632| 1| METHOD(INPUT.NAME(i), PARENT, OUTPUT->NAME##s_ + i, alloc); \ | | 5633| 1| } ------------------ 6133| | 6134| | // Copy options. 6135| 4| AllocateOptions(proto, result, alloc); 6136| | 6137| | // Note that the following steps must occur in exactly the specified order. 6138| | 6139| | // Cross-link. 6140| 4| CrossLinkFile(result, proto); 6141| | 6142| 4| if (!message_hints_.empty()) { ------------------ | Branch (6142:7): [True: 0, False: 4] ------------------ 6143| 0| SuggestFieldNumbers(result, proto); 6144| 0| } 6145| | 6146| | // Interpret only the non-extension options first, including features and 6147| | // their extensions. This has to be done in two passes, since option 6148| | // extensions defined in this file may have features attached to them. 6149| 4| if (!had_errors_) { ------------------ | Branch (6149:7): [True: 4, False: 0] ------------------ 6150| 4| OptionInterpreter option_interpreter(this); 6151| 4| for (std::vector::iterator iter = 6152| 4| options_to_interpret_.begin(); 6153| 4| iter != options_to_interpret_.end(); ++iter) { ------------------ | Branch (6153:10): [True: 0, False: 4] ------------------ 6154| 0| option_interpreter.InterpretNonExtensionOptions(&(*iter)); 6155| 0| } 6156| | 6157| | // TODO: move this check back to generator.cc once we no longer 6158| | // need to set both ctype and string_type internally. 6159| 4| internal::VisitDescriptors( 6160| 4| *result, proto, 6161| 4| [&](const FieldDescriptor& field, const FieldDescriptorProto& proto) { 6162| 4| if (field.options_->has_ctype() && field.options_->features() 6163| 4| .GetExtension(pb::cpp) 6164| 4| .has_string_type()) { 6165| 4| AddError(field.full_name(), proto, 6166| 4| DescriptorPool::ErrorCollector::TYPE, [&] { 6167| 4| return absl::StrFormat( 6168| 4| "Field %s specifies both string_type and ctype " 6169| 4| "which is not supported.", 6170| 4| field.full_name()); 6171| 4| }); 6172| 4| } 6173| 4| }); 6174| | 6175| | // Handle feature resolution. This must occur after option interpretation, 6176| | // but before validation. 6177| 4| { 6178| 4| auto cleanup = DisableTracking(); 6179| 4| internal::VisitDescriptors( 6180| 4| *result, proto, [&](const auto& descriptor, const auto& proto) { 6181| 4| using OptionsT = 6182| 4| typename std::remove_const::type>::type; 6184| 4| using DescriptorT = 6185| 4| typename std::remove_const::type>::type; 6187| | 6188| 4| ResolveFeatures( 6189| 4| proto, const_cast(&descriptor), 6190| 4| const_cast< // NOLINT(google3-runtime-proto-const-cast) 6191| 4| OptionsT*>(descriptor.options_), 6192| 4| alloc); 6193| 4| }); 6194| 4| } 6195| | 6196| 4| internal::VisitDescriptors(*result, [&](const FieldDescriptor& field) { 6197| 4| if (result->edition() >= Edition::EDITION_2024 && 6198| 4| field.options().has_ctype()) { 6199| | // "ctype" is no longer supported in edition 2024 and beyond. 6200| 4| AddError( 6201| 4| field.full_name(), proto, DescriptorPool::ErrorCollector::NAME, 6202| 4| "ctype option is not allowed under edition 2024 and beyond. Use " 6203| 4| "the feature string_type = VIEW|CORD|STRING|... instead."); 6204| 4| } 6205| 4| EnforceCTypeStringTypeConsistency( 6206| 4| field.file()->edition(), field.cpp_type(), 6207| 4| field.merged_features_->GetExtension(pb::cpp), 6208| 4| const_cast< // NOLINT(google3-runtime-proto-const-cast) 6209| 4| FieldOptions&>(*field.options_)); 6210| 4| }); 6211| | 6212| | // Post-process cleanup for field features. 6213| 4| internal::VisitDescriptors( 6214| 4| *result, proto, 6215| 4| [&](const FieldDescriptor& field, const FieldDescriptorProto& proto) { 6216| 4| PostProcessFieldFeatures(const_cast(field), proto); 6217| 4| }); 6218| | 6219| | // Interpret any remaining uninterpreted options gathered into 6220| | // options_to_interpret_ during descriptor building. Cross-linking has made 6221| | // extension options known, so all interpretations should now succeed. 6222| 4| for (std::vector::iterator iter = 6223| 4| options_to_interpret_.begin(); 6224| 4| iter != options_to_interpret_.end(); ++iter) { ------------------ | Branch (6224:10): [True: 0, False: 4] ------------------ 6225| 0| option_interpreter.InterpretOptionExtensions(&(*iter)); 6226| 0| } 6227| 4| options_to_interpret_.clear(); 6228| 4| if (info != nullptr) { ------------------ | Branch (6228:9): [True: 0, False: 4] ------------------ 6229| 0| option_interpreter.UpdateSourceCodeInfo(info); 6230| 0| } 6231| 4| } 6232| | 6233| | // Validate options. See comments at InternalSetLazilyBuildDependencies about 6234| | // error checking and lazy import building. 6235| 4| if (!had_errors_ && !pool_->lazily_build_dependencies_) { ------------------ | Branch (6235:7): [True: 4, False: 0] | Branch (6235:23): [True: 0, False: 4] ------------------ 6236| 0| internal::VisitDescriptors( 6237| 0| *result, proto, [&](const auto& descriptor, const auto& desc_proto) { 6238| 0| ValidateOptions(&descriptor, desc_proto); 6239| 0| }); 6240| 0| } 6241| | 6242| | // Additional naming conflict check for map entry types. Only need to check 6243| | // this if there are already errors. 6244| 4| if (had_errors_) { ------------------ | Branch (6244:7): [True: 0, False: 4] ------------------ 6245| 0| for (int i = 0; i < proto.message_type_size(); ++i) { ------------------ | Branch (6245:21): [True: 0, False: 0] ------------------ 6246| 0| DetectMapConflicts(result->message_type(i), proto.message_type(i)); 6247| 0| } 6248| 0| } 6249| | 6250| | 6251| | // Again, see comments at InternalSetLazilyBuildDependencies about error 6252| | // checking. Also, don't log unused dependencies if there were previous 6253| | // errors, since the results might be inaccurate. 6254| 4| if (!had_errors_ && !unused_dependency_.empty() && ------------------ | Branch (6254:7): [True: 4, False: 0] | Branch (6254:23): [True: 0, False: 4] ------------------ 6255| 0| !pool_->lazily_build_dependencies_) { ------------------ | Branch (6255:7): [True: 0, False: 0] ------------------ 6256| 0| LogUnusedDependency(proto, result); 6257| 0| } 6258| | 6259| | // Store feature information for deferred validation outside of the database 6260| | // mutex. 6261| 4| if (!had_errors_ && !pool_->lazily_build_dependencies_) { ------------------ | Branch (6261:7): [True: 4, False: 0] | Branch (6261:23): [True: 0, False: 4] ------------------ 6262| 0| internal::VisitDescriptors( 6263| 0| *result, proto, [&](const auto& descriptor, const auto& desc_proto) { 6264| 0| if (descriptor.proto_features_ != &FeatureSet::default_instance()) { 6265| 0| deferred_validation_.ValidateFeatureLifetimes( 6266| 0| GetFile(descriptor), {descriptor.proto_features_, &desc_proto, 6267| 0| GetFullName(descriptor), proto.name()}); 6268| 0| } 6269| 0| }); 6270| 0| } 6271| | 6272| 4| if (had_errors_) { ------------------ | Branch (6272:7): [True: 0, False: 4] ------------------ 6273| 0| return nullptr; 6274| 4| } else { 6275| 4| return result; 6276| 4| } 6277| 4|} _ZN6google8protobuf17DescriptorBuilder19AllocateNameStringsENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEES6_RNS0_8internal13FlatAllocatorE: 6282| 65| internal::FlatAllocator& alloc) { 6283| 65| if (scope.empty()) { ------------------ | Branch (6283:7): [True: 0, False: 65] ------------------ 6284| 0| return alloc.AllocateStrings(proto_name, proto_name); 6285| 65| } else { 6286| 65| return alloc.AllocateStrings(proto_name, 6287| 65| absl::StrCat(scope, ".", proto_name)); 6288| 65| } 6289| 65|} _ZN6google8protobuf17DescriptorBuilder12BuildMessageERKNS0_15DescriptorProtoEPKNS0_10DescriptorEPS5_RNS0_8internal13FlatAllocatorE: 6316| 45| internal::FlatAllocator& alloc) { 6317| 45| const absl::string_view scope = 6318| 45| (parent == nullptr) ? file_->package() : parent->full_name(); ------------------ | Branch (6318:7): [True: 35, False: 10] ------------------ 6319| 45| result->all_names_ = AllocateNameStrings(scope, proto.name(), alloc); 6320| 45| ValidateSymbolName(proto.name(), result->full_name(), proto); 6321| | 6322| 45| result->file_ = file_; 6323| 45| result->containing_type_ = parent; 6324| 45| result->is_placeholder_ = false; 6325| 45| result->is_unqualified_placeholder_ = false; 6326| 45| result->well_known_type_ = Descriptor::WELLKNOWNTYPE_UNSPECIFIED; 6327| 45| result->options_ = nullptr; // Set to default_instance later if necessary. 6328| | 6329| 45| auto it = pool_->tables_->well_known_types_.find(result->full_name()); 6330| 45| if (it != pool_->tables_->well_known_types_.end()) { ------------------ | Branch (6330:7): [True: 1, False: 44] ------------------ 6331| 1| result->well_known_type_ = it->second; 6332| 1| } 6333| | 6334| | // Calculate the continuous sequence of fields. 6335| | // These can be fast-path'd during lookup and don't need to be added to the 6336| | // tables. 6337| | // We use uint16_t to save space for sequential_field_limit_, so stop before 6338| | // overflowing it. Worst case, we are not taking full advantage on huge 6339| | // messages, but it is unlikely. 6340| 45| result->sequential_field_limit_ = 0; 6341| 151| for (int i = 0; i < std::numeric_limits::max() && ------------------ | Branch (6341:19): [True: 151, False: 0] ------------------ 6342| 151| i < proto.field_size() && proto.field(i).number() == i + 1; ------------------ | Branch (6342:19): [True: 124, False: 27] | Branch (6342:45): [True: 106, False: 18] ------------------ 6343| 106| ++i) { 6344| 106| result->sequential_field_limit_ = i + 1; 6345| 106| } 6346| | 6347| | // Build oneofs first so that fields and extension ranges can refer to them. 6348| 45| BUILD_ARRAY(proto, result, oneof_decl, BuildOneof, result); ------------------ | | 5627| 45| OUTPUT->NAME##_count_ = INPUT.NAME##_size(); \ | | 5628| 45| OUTPUT->NAME##s_ = alloc.AllocateArray< \ | | 5629| 45| typename std::remove_pointerNAME##s_)>::type>( \ | | 5630| 45| INPUT.NAME##_size()); \ | | 5631| 47| for (int i = 0; i < INPUT.NAME##_size(); i++) { \ | | ------------------ | | | Branch (5631:19): [True: 2, False: 45] | | ------------------ | | 5632| 2| METHOD(INPUT.NAME(i), PARENT, OUTPUT->NAME##s_ + i, alloc); \ | | 5633| 2| } ------------------ 6349| 45| BUILD_ARRAY(proto, result, field, BuildField, result); ------------------ | | 5627| 45| OUTPUT->NAME##_count_ = INPUT.NAME##_size(); \ | | 5628| 45| OUTPUT->NAME##s_ = alloc.AllocateArray< \ | | 5629| 45| typename std::remove_pointerNAME##s_)>::type>( \ | | 5630| 45| INPUT.NAME##_size()); \ | | 5631| 250| for (int i = 0; i < INPUT.NAME##_size(); i++) { \ | | ------------------ | | | Branch (5631:19): [True: 205, False: 45] | | ------------------ | | 5632| 205| METHOD(INPUT.NAME(i), PARENT, OUTPUT->NAME##s_ + i, alloc); \ | | 5633| 205| } ------------------ 6350| 45| BUILD_ARRAY(proto, result, enum_type, BuildEnum, result); ------------------ | | 5627| 45| OUTPUT->NAME##_count_ = INPUT.NAME##_size(); \ | | 5628| 45| OUTPUT->NAME##s_ = alloc.AllocateArray< \ | | 5629| 45| typename std::remove_pointerNAME##s_)>::type>( \ | | 5630| 45| INPUT.NAME##_size()); \ | | 5631| 62| for (int i = 0; i < INPUT.NAME##_size(); i++) { \ | | ------------------ | | | Branch (5631:19): [True: 17, False: 45] | | ------------------ | | 5632| 17| METHOD(INPUT.NAME(i), PARENT, OUTPUT->NAME##s_ + i, alloc); \ | | 5633| 17| } ------------------ 6351| 45| BUILD_ARRAY(proto, result, extension_range, BuildExtensionRange, result); ------------------ | | 5627| 45| OUTPUT->NAME##_count_ = INPUT.NAME##_size(); \ | | 5628| 45| OUTPUT->NAME##s_ = alloc.AllocateArray< \ | | 5629| 45| typename std::remove_pointerNAME##s_)>::type>( \ | | 5630| 45| INPUT.NAME##_size()); \ | | 5631| 59| for (int i = 0; i < INPUT.NAME##_size(); i++) { \ | | ------------------ | | | Branch (5631:19): [True: 14, False: 45] | | ------------------ | | 5632| 14| METHOD(INPUT.NAME(i), PARENT, OUTPUT->NAME##s_ + i, alloc); \ | | 5633| 14| } ------------------ 6352| 45| BUILD_ARRAY(proto, result, extension, BuildExtension, result); ------------------ | | 5627| 45| OUTPUT->NAME##_count_ = INPUT.NAME##_size(); \ | | 5628| 45| OUTPUT->NAME##s_ = alloc.AllocateArray< \ | | 5629| 45| typename std::remove_pointerNAME##s_)>::type>( \ | | 5630| 45| INPUT.NAME##_size()); \ | | 5631| 45| for (int i = 0; i < INPUT.NAME##_size(); i++) { \ | | ------------------ | | | Branch (5631:19): [True: 0, False: 45] | | ------------------ | | 5632| 0| METHOD(INPUT.NAME(i), PARENT, OUTPUT->NAME##s_ + i, alloc); \ | | 5633| 0| } ------------------ 6353| 45| BUILD_ARRAY(proto, result, reserved_range, BuildReservedRange, result); ------------------ | | 5627| 45| OUTPUT->NAME##_count_ = INPUT.NAME##_size(); \ | | 5628| 45| OUTPUT->NAME##s_ = alloc.AllocateArray< \ | | 5629| 45| typename std::remove_pointerNAME##s_)>::type>( \ | | 5630| 45| INPUT.NAME##_size()); \ | | 5631| 59| for (int i = 0; i < INPUT.NAME##_size(); i++) { \ | | ------------------ | | | Branch (5631:19): [True: 14, False: 45] | | ------------------ | | 5632| 14| METHOD(INPUT.NAME(i), PARENT, OUTPUT->NAME##s_ + i, alloc); \ | | 5633| 14| } ------------------ 6354| | 6355| | // Copy options. 6356| 45| AllocateOptions(proto, result, DescriptorProto::kOptionsFieldNumber, 6357| 45| "google.protobuf.MessageOptions", alloc); 6358| | 6359| | // Before building submessages, check recursion limit. 6360| 45| --recursion_depth_; 6361| 45| IncrementWhenDestroyed revert{recursion_depth_}; 6362| 45| if (recursion_depth_ <= 0) { ------------------ | Branch (6362:7): [True: 0, False: 45] ------------------ 6363| 0| AddError(result->full_name(), proto, DescriptorPool::ErrorCollector::OTHER, 6364| 0| "Reached maximum recursion limit for nested messages."); 6365| 0| result->nested_types_ = nullptr; 6366| 0| result->nested_type_count_ = 0; 6367| 0| return; 6368| 0| } 6369| 45| BUILD_ARRAY(proto, result, nested_type, BuildMessage, result); ------------------ | | 5627| 45| OUTPUT->NAME##_count_ = INPUT.NAME##_size(); \ | | 5628| 45| OUTPUT->NAME##s_ = alloc.AllocateArray< \ | | 5629| 45| typename std::remove_pointerNAME##s_)>::type>( \ | | 5630| 45| INPUT.NAME##_size()); \ | | 5631| 55| for (int i = 0; i < INPUT.NAME##_size(); i++) { \ | | ------------------ | | | Branch (5631:19): [True: 10, False: 45] | | ------------------ | | 5632| 10| METHOD(INPUT.NAME(i), PARENT, OUTPUT->NAME##s_ + i, alloc); \ | | 5633| 10| } ------------------ 6370| | 6371| | // Copy reserved names. 6372| 45| int reserved_name_count = proto.reserved_name_size(); 6373| 45| result->reserved_name_count_ = reserved_name_count; 6374| 45| result->reserved_names_ = 6375| 45| alloc.AllocateArray(reserved_name_count); 6376| 47| for (int i = 0; i < reserved_name_count; ++i) { ------------------ | Branch (6376:19): [True: 2, False: 45] ------------------ 6377| 2| result->reserved_names_[i] = alloc.AllocateStrings(proto.reserved_name(i)); 6378| 2| } 6379| | 6380| 45| AddSymbol(result->full_name(), parent, result->name(), proto, Symbol(result)); 6381| | 6382| 59| for (int i = 0; i < proto.reserved_range_size(); i++) { ------------------ | Branch (6382:19): [True: 14, False: 45] ------------------ 6383| 14| const DescriptorProto_ReservedRange& range1 = proto.reserved_range(i); 6384| 27| for (int j = i + 1; j < proto.reserved_range_size(); j++) { ------------------ | Branch (6384:25): [True: 13, False: 14] ------------------ 6385| 13| const DescriptorProto_ReservedRange& range2 = proto.reserved_range(j); 6386| 13| if (range1.end() > range2.start() && range2.end() > range1.start()) { ------------------ | Branch (6386:11): [True: 1, False: 12] | Branch (6386:44): [True: 0, False: 1] ------------------ 6387| 0| AddError(result->full_name(), proto.reserved_range(i), 6388| 0| DescriptorPool::ErrorCollector::NUMBER, [&] { 6389| 0| return absl::Substitute( 6390| 0| "Reserved range $0 to $1 overlaps with " 6391| 0| "already-defined range $2 to $3.", 6392| 0| range2.start(), range2.end() - 1, range1.start(), 6393| 0| range1.end() - 1); 6394| 0| }); 6395| 0| } 6396| 13| } 6397| 14| } 6398| | 6399| 45| absl::flat_hash_set reserved_name_set; 6400| 45| for (const std::string& name : proto.reserved_name()) { ------------------ | Branch (6400:32): [True: 2, False: 45] ------------------ 6401| 2| if (!reserved_name_set.insert(name).second) { ------------------ | Branch (6401:9): [True: 0, False: 2] ------------------ 6402| 0| AddError(name, proto, DescriptorPool::ErrorCollector::NAME, [&] { 6403| 0| return absl::Substitute("Field name \"$0\" is reserved multiple times.", 6404| 0| name); 6405| 0| }); 6406| 0| } 6407| 2| } 6408| | // Check that fields aren't using reserved names or numbers and that they 6409| | // aren't using extension numbers. 6410| 250| for (int i = 0; i < result->field_count(); i++) { ------------------ | Branch (6410:19): [True: 205, False: 45] ------------------ 6411| 205| const FieldDescriptor* field = result->field(i); 6412| 290| for (int j = 0; j < result->extension_range_count(); j++) { ------------------ | Branch (6412:21): [True: 85, False: 205] ------------------ 6413| 85| const Descriptor::ExtensionRange* range = result->extension_range(j); 6414| 85| if (range->start_number() <= field->number() && ------------------ | Branch (6414:11): [True: 0, False: 85] ------------------ 6415| 0| field->number() < range->end_number()) { ------------------ | Branch (6415:11): [True: 0, False: 0] ------------------ 6416| 0| message_hints_[result].RequestHintOnFieldNumbers( 6417| 0| proto.extension_range(j), DescriptorPool::ErrorCollector::NUMBER); 6418| 0| AddError(field->full_name(), proto.extension_range(j), 6419| 0| DescriptorPool::ErrorCollector::NUMBER, [&] { 6420| 0| return absl::Substitute( 6421| 0| "Extension range $0 to $1 includes field \"$2\" ($3).", 6422| 0| range->start_number(), range->end_number() - 1, 6423| 0| field->name(), field->number()); 6424| 0| }); 6425| 0| } 6426| 85| } 6427| 332| for (int j = 0; j < result->reserved_range_count(); j++) { ------------------ | Branch (6427:21): [True: 127, False: 205] ------------------ 6428| 127| const Descriptor::ReservedRange* range = result->reserved_range(j); 6429| 127| if (range->start <= field->number() && field->number() < range->end) { ------------------ | Branch (6429:11): [True: 56, False: 71] | Branch (6429:46): [True: 0, False: 56] ------------------ 6430| 0| message_hints_[result].RequestHintOnFieldNumbers( 6431| 0| proto.reserved_range(j), DescriptorPool::ErrorCollector::NUMBER); 6432| 0| AddError(field->full_name(), proto.reserved_range(j), 6433| 0| DescriptorPool::ErrorCollector::NUMBER, [&] { 6434| 0| return absl::Substitute( 6435| 0| "Field \"$0\" uses reserved number $1.", field->name(), 6436| 0| field->number()); 6437| 0| }); 6438| 0| } 6439| 127| } 6440| 205| if (reserved_name_set.contains(field->name())) { ------------------ | Branch (6440:9): [True: 0, False: 205] ------------------ 6441| 0| AddError(field->full_name(), proto.field(i), 6442| 0| DescriptorPool::ErrorCollector::NAME, [&] { 6443| 0| return absl::Substitute("Field name \"$0\" is reserved.", 6444| 0| field->name()); 6445| 0| }); 6446| 0| } 6447| 205| } 6448| | 6449| | // Check that extension ranges don't overlap and don't include 6450| | // reserved field numbers or names. 6451| 59| for (int i = 0; i < result->extension_range_count(); i++) { ------------------ | Branch (6451:19): [True: 14, False: 45] ------------------ 6452| 14| const Descriptor::ExtensionRange* range1 = result->extension_range(i); 6453| 27| for (int j = 0; j < result->reserved_range_count(); j++) { ------------------ | Branch (6453:21): [True: 13, False: 14] ------------------ 6454| 13| const Descriptor::ReservedRange* range2 = result->reserved_range(j); 6455| 13| if (range1->end_number() > range2->start && ------------------ | Branch (6455:11): [True: 13, False: 0] ------------------ 6456| 13| range2->end > range1->start_number()) { ------------------ | Branch (6456:11): [True: 0, False: 13] ------------------ 6457| 0| AddError(result->full_name(), proto.extension_range(i), 6458| 0| DescriptorPool::ErrorCollector::NUMBER, [&] { 6459| 0| return absl::Substitute( 6460| 0| "Extension range $0 to $1 overlaps with " 6461| 0| "reserved range $2 to $3.", 6462| 0| range1->start_number(), range1->end_number() - 1, 6463| 0| range2->start, range2->end - 1); 6464| 0| }); 6465| 0| } 6466| 13| } 6467| 17| for (int j = i + 1; j < result->extension_range_count(); j++) { ------------------ | Branch (6467:25): [True: 3, False: 14] ------------------ 6468| 3| const Descriptor::ExtensionRange* range2 = result->extension_range(j); 6469| 3| if (range1->end_number() > range2->start_number() && ------------------ | Branch (6469:11): [True: 0, False: 3] ------------------ 6470| 0| range2->end_number() > range1->start_number()) { ------------------ | Branch (6470:11): [True: 0, False: 0] ------------------ 6471| 0| AddError(result->full_name(), proto.extension_range(i), 6472| 0| DescriptorPool::ErrorCollector::NUMBER, [&] { 6473| 0| return absl::Substitute( 6474| 0| "Extension range $0 to $1 overlaps with " 6475| 0| "already-defined range $2 to $3.", 6476| 0| range2->start_number(), range2->end_number() - 1, 6477| 0| range1->start_number(), range1->end_number() - 1); 6478| 0| }); 6479| 0| } 6480| 3| } 6481| 14| } 6482| 45|} _ZN6google8protobuf17DescriptorBuilder21BuildFieldOrExtensionERKNS0_20FieldDescriptorProtoEPNS0_10DescriptorEPNS0_15FieldDescriptorEbRNS0_8internal13FlatAllocatorE: 6585| 206| internal::FlatAllocator& alloc) { 6586| 206| const absl::string_view scope = 6587| 206| (parent == nullptr) ? file_->package() : parent->full_name(); ------------------ | Branch (6587:7): [True: 1, False: 205] ------------------ 6588| | 6589| | // We allocate all names in a single array, and dedup them. 6590| | // We remember the indices for the potentially deduped values. 6591| 206| auto all_names = alloc.AllocateFieldNames( 6592| 206| proto.name(), scope, 6593| 206| proto.has_json_name() ? &proto.json_name() : nullptr); ------------------ | Branch (6593:7): [True: 0, False: 206] ------------------ 6594| 206| result->all_names_ = all_names.array; 6595| 206| result->lowercase_name_index_ = all_names.lowercase_index; 6596| 206| result->camelcase_name_index_ = all_names.camelcase_index; 6597| 206| result->json_name_index_ = all_names.json_index; 6598| | 6599| 206| ValidateSymbolName(proto.name(), result->full_name(), proto); 6600| | 6601| 206| result->file_ = file_; 6602| 206| result->number_ = proto.number(); 6603| 206| result->is_extension_ = is_extension; 6604| 206| result->is_oneof_ = false; 6605| 206| result->in_real_oneof_ = false; 6606| 206| result->proto3_optional_ = proto.proto3_optional(); 6607| | 6608| 206| if (proto.proto3_optional() && file_->edition() != Edition::EDITION_PROTO3) { ------------------ | Branch (6608:7): [True: 0, False: 206] | Branch (6608:34): [True: 0, False: 0] ------------------ 6609| 0| AddError(result->full_name(), proto, DescriptorPool::ErrorCollector::TYPE, 6610| 0| [&] { 6611| 0| return absl::StrCat( 6612| 0| "The [proto3_optional=true] option may only be set on proto3" 6613| 0| "fields, not ", 6614| 0| result->full_name()); 6615| 0| }); 6616| 0| } 6617| | 6618| 206| result->has_json_name_ = proto.has_json_name(); 6619| | 6620| 206| result->type_ = proto.type(); 6621| 206| result->label_ = proto.label(); 6622| 206| result->is_repeated_ = result->label_ == FieldDescriptor::LABEL_REPEATED; 6623| | 6624| 206| if (result->label() == FieldDescriptor::LABEL_REQUIRED) { ------------------ | Branch (6624:7): [True: 2, False: 204] ------------------ 6625| | // An extension cannot have a required field (b/13365836). 6626| 2| if (result->is_extension_) { ------------------ | Branch (6626:9): [True: 0, False: 2] ------------------ 6627| 0| AddError(result->full_name(), proto, 6628| | // Error location `TYPE`: we would really like to indicate 6629| | // `LABEL`, but the `ErrorLocation` enum has no entry for this, 6630| | // and we don't necessarily know about all implementations of the 6631| | // `ErrorCollector` interface to extend them to handle the new 6632| | // error location type properly. 6633| 0| DescriptorPool::ErrorCollector::TYPE, [&] { 6634| 0| return absl::StrCat("The extension ", result->full_name(), 6635| 0| " cannot be required."); 6636| 0| }); 6637| 0| } 6638| 2| } 6639| | 6640| | // Some of these may be filled in when cross-linking. 6641| 206| result->containing_type_ = nullptr; 6642| 206| result->type_once_ = nullptr; 6643| 206| result->default_value_enum_ = nullptr; 6644| | 6645| 206| result->has_default_value_ = proto.has_default_value(); 6646| 206| if (proto.has_default_value() && result->is_repeated()) { ------------------ | Branch (6646:7): [True: 27, False: 179] | Branch (6646:36): [True: 0, False: 27] ------------------ 6647| 0| AddError(result->full_name(), proto, 6648| 0| DescriptorPool::ErrorCollector::DEFAULT_VALUE, 6649| 0| "Repeated fields can't have default values."); 6650| 0| } 6651| | 6652| 206| if (proto.has_type()) { ------------------ | Branch (6652:7): [True: 206, False: 0] ------------------ 6653| 206| if (proto.has_default_value()) { ------------------ | Branch (6653:9): [True: 27, False: 179] ------------------ 6654| 27| char* end_pos = nullptr; 6655| 27| switch (result->cpp_type()) { ------------------ | Branch (6655:15): [True: 27, False: 0] ------------------ 6656| 0| case FieldDescriptor::CPPTYPE_INT32: ------------------ | Branch (6656:9): [True: 0, False: 27] ------------------ 6657| 0| result->default_value_int32_t_ = 6658| 0| std::strtol(proto.default_value().c_str(), &end_pos, 0); 6659| 0| break; 6660| 0| case FieldDescriptor::CPPTYPE_INT64: ------------------ | Branch (6660:9): [True: 0, False: 27] ------------------ 6661| 0| static_assert(sizeof(int64_t) == sizeof(long long), // NOLINT 6662| 0| "sizeof int64_t is not sizeof long long"); 6663| 0| result->default_value_int64_t_ = 6664| 0| std::strtoll(proto.default_value().c_str(), &end_pos, 0); 6665| 0| break; 6666| 0| case FieldDescriptor::CPPTYPE_UINT32: ------------------ | Branch (6666:9): [True: 0, False: 27] ------------------ 6667| 0| result->default_value_uint32_t_ = 6668| 0| std::strtoul(proto.default_value().c_str(), &end_pos, 0); 6669| 0| break; 6670| 0| case FieldDescriptor::CPPTYPE_UINT64: ------------------ | Branch (6670:9): [True: 0, False: 27] ------------------ 6671| 0| static_assert( 6672| 0| sizeof(uint64_t) == sizeof(unsigned long long), // NOLINT 6673| 0| "sizeof uint64_t is not sizeof unsigned long long"); 6674| 0| result->default_value_uint64_t_ = 6675| 0| std::strtoull(proto.default_value().c_str(), &end_pos, 0); 6676| 0| break; 6677| 0| case FieldDescriptor::CPPTYPE_FLOAT: ------------------ | Branch (6677:9): [True: 0, False: 27] ------------------ 6678| 0| if (proto.default_value() == "inf") { ------------------ | Branch (6678:15): [True: 0, False: 0] ------------------ 6679| 0| result->default_value_float_ = 6680| 0| std::numeric_limits::infinity(); 6681| 0| } else if (proto.default_value() == "-inf") { ------------------ | Branch (6681:22): [True: 0, False: 0] ------------------ 6682| 0| result->default_value_float_ = 6683| 0| -std::numeric_limits::infinity(); 6684| 0| } else if (proto.default_value() == "nan") { ------------------ | Branch (6684:22): [True: 0, False: 0] ------------------ 6685| 0| result->default_value_float_ = 6686| 0| std::numeric_limits::quiet_NaN(); 6687| 0| } else { 6688| 0| result->default_value_float_ = io::SafeDoubleToFloat( 6689| 0| io::NoLocaleStrtod(proto.default_value().c_str(), &end_pos)); 6690| 0| } 6691| 0| break; 6692| 0| case FieldDescriptor::CPPTYPE_DOUBLE: ------------------ | Branch (6692:9): [True: 0, False: 27] ------------------ 6693| 0| if (proto.default_value() == "inf") { ------------------ | Branch (6693:15): [True: 0, False: 0] ------------------ 6694| 0| result->default_value_double_ = 6695| 0| std::numeric_limits::infinity(); 6696| 0| } else if (proto.default_value() == "-inf") { ------------------ | Branch (6696:22): [True: 0, False: 0] ------------------ 6697| 0| result->default_value_double_ = 6698| 0| -std::numeric_limits::infinity(); 6699| 0| } else if (proto.default_value() == "nan") { ------------------ | Branch (6699:22): [True: 0, False: 0] ------------------ 6700| 0| result->default_value_double_ = 6701| 0| std::numeric_limits::quiet_NaN(); 6702| 0| } else { 6703| 0| result->default_value_double_ = 6704| 0| io::NoLocaleStrtod(proto.default_value().c_str(), &end_pos); 6705| 0| } 6706| 0| break; 6707| 22| case FieldDescriptor::CPPTYPE_BOOL: ------------------ | Branch (6707:9): [True: 22, False: 5] ------------------ 6708| 22| if (proto.default_value() == "true") { ------------------ | Branch (6708:15): [True: 1, False: 21] ------------------ 6709| 1| result->default_value_bool_ = true; 6710| 21| } else if (proto.default_value() == "false") { ------------------ | Branch (6710:22): [True: 21, False: 0] ------------------ 6711| 21| result->default_value_bool_ = false; 6712| 21| } else { 6713| 0| AddError(result->full_name(), proto, 6714| 0| DescriptorPool::ErrorCollector::DEFAULT_VALUE, 6715| 0| "Boolean default must be true or false."); 6716| 0| } 6717| 22| break; 6718| 5| case FieldDescriptor::CPPTYPE_ENUM: ------------------ | Branch (6718:9): [True: 5, False: 22] ------------------ 6719| | // This will be filled in when cross-linking. 6720| 5| result->default_value_enum_ = nullptr; 6721| 5| break; 6722| 0| case FieldDescriptor::CPPTYPE_STRING: ------------------ | Branch (6722:9): [True: 0, False: 27] ------------------ 6723| 0| if (result->type() == FieldDescriptor::TYPE_BYTES) { ------------------ | Branch (6723:15): [True: 0, False: 0] ------------------ 6724| 0| std::string value; 6725| 0| if (absl::CUnescape(proto.default_value(), &value)) { ------------------ | Branch (6725:17): [True: 0, False: 0] ------------------ 6726| 0| result->default_value_string_ = alloc.AllocateStrings(value); 6727| 0| } else { 6728| 0| AddError(result->full_name(), proto, 6729| 0| DescriptorPool::ErrorCollector::DEFAULT_VALUE, 6730| 0| "Invalid escaping in default value."); 6731| 0| } 6732| 0| } else { 6733| 0| result->default_value_string_ = 6734| 0| alloc.AllocateStrings(proto.default_value()); 6735| 0| } 6736| 0| break; 6737| 0| case FieldDescriptor::CPPTYPE_MESSAGE: ------------------ | Branch (6737:9): [True: 0, False: 27] ------------------ 6738| 0| AddError(result->full_name(), proto, 6739| 0| DescriptorPool::ErrorCollector::DEFAULT_VALUE, 6740| 0| "Messages can't have default values."); 6741| 0| result->has_default_value_ = false; 6742| 0| result->default_generated_instance_ = nullptr; 6743| 0| break; 6744| 27| } 6745| | 6746| 27| if (end_pos != nullptr) { ------------------ | Branch (6746:11): [True: 0, False: 27] ------------------ 6747| | // end_pos is only set non-null by the parsers for numeric types, 6748| | // above. This checks that the default was non-empty and had no extra 6749| | // junk after the end of the number. 6750| 0| if (proto.default_value().empty() || *end_pos != '\0') { ------------------ | Branch (6750:13): [True: 0, False: 0] | Branch (6750:46): [True: 0, False: 0] ------------------ 6751| 0| AddError(result->full_name(), proto, 6752| 0| DescriptorPool::ErrorCollector::DEFAULT_VALUE, [&] { 6753| 0| return absl::StrCat("Couldn't parse default value \"", 6754| 0| proto.default_value(), "\"."); 6755| 0| }); 6756| 0| } 6757| 0| } 6758| 179| } else { 6759| | // No explicit default value 6760| 179| switch (result->cpp_type()) { ------------------ | Branch (6760:15): [True: 179, False: 0] ------------------ 6761| 17| case FieldDescriptor::CPPTYPE_INT32: ------------------ | Branch (6761:9): [True: 17, False: 162] ------------------ 6762| 17| result->default_value_int32_t_ = 0; 6763| 17| break; 6764| 1| case FieldDescriptor::CPPTYPE_INT64: ------------------ | Branch (6764:9): [True: 1, False: 178] ------------------ 6765| 1| result->default_value_int64_t_ = 0; 6766| 1| break; 6767| 1| case FieldDescriptor::CPPTYPE_UINT32: ------------------ | Branch (6767:9): [True: 1, False: 178] ------------------ 6768| 1| result->default_value_uint32_t_ = 0; 6769| 1| break; 6770| 1| case FieldDescriptor::CPPTYPE_UINT64: ------------------ | Branch (6770:9): [True: 1, False: 178] ------------------ 6771| 1| result->default_value_uint64_t_ = 0; 6772| 1| break; 6773| 0| case FieldDescriptor::CPPTYPE_FLOAT: ------------------ | Branch (6773:9): [True: 0, False: 179] ------------------ 6774| 0| result->default_value_float_ = 0.0f; 6775| 0| break; 6776| 1| case FieldDescriptor::CPPTYPE_DOUBLE: ------------------ | Branch (6776:9): [True: 1, False: 178] ------------------ 6777| 1| result->default_value_double_ = 0.0; 6778| 1| break; 6779| 14| case FieldDescriptor::CPPTYPE_BOOL: ------------------ | Branch (6779:9): [True: 14, False: 165] ------------------ 6780| 14| result->default_value_bool_ = false; 6781| 14| break; 6782| 20| case FieldDescriptor::CPPTYPE_ENUM: ------------------ | Branch (6782:9): [True: 20, False: 159] ------------------ 6783| | // This will be filled in when cross-linking. 6784| 20| result->default_value_enum_ = nullptr; 6785| 20| break; 6786| 57| case FieldDescriptor::CPPTYPE_STRING: ------------------ | Branch (6786:9): [True: 57, False: 122] ------------------ 6787| 57| result->default_value_string_ = &internal::GetEmptyString(); 6788| 57| break; 6789| 67| case FieldDescriptor::CPPTYPE_MESSAGE: ------------------ | Branch (6789:9): [True: 67, False: 112] ------------------ 6790| 67| result->default_generated_instance_ = nullptr; 6791| 67| break; 6792| 179| } 6793| 179| } 6794| 206| } 6795| | 6796| 206| if (result->number() <= 0) { ------------------ | Branch (6796:7): [True: 0, False: 206] ------------------ 6797| 0| message_hints_[parent].RequestHintOnFieldNumbers( 6798| 0| proto, DescriptorPool::ErrorCollector::NUMBER); 6799| 0| AddError(result->full_name(), proto, DescriptorPool::ErrorCollector::NUMBER, 6800| 0| "Field numbers must be positive integers."); 6801| 206| } else if (!is_extension && result->number() > FieldDescriptor::kMaxNumber) { ------------------ | Branch (6801:14): [True: 205, False: 1] | Branch (6801:31): [True: 0, False: 205] ------------------ 6802| | // Only validate that the number is within the valid field range if it is 6803| | // not an extension. Since extension numbers are validated with the 6804| | // extendee's valid set of extension numbers, and those are in turn 6805| | // validated against the max allowed number, the check is unnecessary for 6806| | // extension fields. 6807| | // This avoids cross-linking issues that arise when attempting to check if 6808| | // the extendee is a message_set_wire_format message, which has a higher max 6809| | // on extension numbers. 6810| 0| message_hints_[parent].RequestHintOnFieldNumbers( 6811| 0| proto, DescriptorPool::ErrorCollector::NUMBER); 6812| 0| AddError(result->full_name(), proto, DescriptorPool::ErrorCollector::NUMBER, 6813| 0| [&] { 6814| 0| return absl::Substitute( 6815| 0| "Field numbers cannot be greater than $0.", 6816| 0| FieldDescriptor::kMaxNumber); 6817| 0| }); 6818| 0| } 6819| | 6820| 206| if (is_extension) { ------------------ | Branch (6820:7): [True: 1, False: 205] ------------------ 6821| 1| if (!proto.has_extendee()) { ------------------ | Branch (6821:9): [True: 0, False: 1] ------------------ 6822| 0| AddError(result->full_name(), proto, 6823| 0| DescriptorPool::ErrorCollector::EXTENDEE, 6824| 0| "FieldDescriptorProto.extendee not set for extension field."); 6825| 0| } 6826| | 6827| 1| result->scope_.extension_scope = parent; 6828| | 6829| 1| if (proto.has_oneof_index()) { ------------------ | Branch (6829:9): [True: 0, False: 1] ------------------ 6830| 0| AddError(result->full_name(), proto, DescriptorPool::ErrorCollector::TYPE, 6831| 0| "FieldDescriptorProto.oneof_index should not be set for " 6832| 0| "extensions."); 6833| 0| } 6834| 205| } else { 6835| 205| if (proto.has_extendee()) { ------------------ | Branch (6835:9): [True: 0, False: 205] ------------------ 6836| 0| AddError(result->full_name(), proto, 6837| 0| DescriptorPool::ErrorCollector::EXTENDEE, 6838| 0| "FieldDescriptorProto.extendee set for non-extension field."); 6839| 0| } 6840| | 6841| 205| result->containing_type_ = parent; 6842| | 6843| 205| if (proto.has_oneof_index()) { ------------------ | Branch (6843:9): [True: 7, False: 198] ------------------ 6844| 7| if (proto.oneof_index() < 0 || ------------------ | Branch (6844:11): [True: 0, False: 7] ------------------ 6845| 7| proto.oneof_index() >= parent->oneof_decl_count()) { ------------------ | Branch (6845:11): [True: 0, False: 7] ------------------ 6846| 0| AddError(result->full_name(), proto, 6847| 0| DescriptorPool::ErrorCollector::TYPE, [&] { 6848| 0| return absl::Substitute( 6849| 0| "FieldDescriptorProto.oneof_index $0 is " 6850| 0| "out of range for type \"$1\".", 6851| 0| proto.oneof_index(), parent->name()); 6852| 0| }); 6853| 7| } else { 6854| 7| result->is_oneof_ = true; 6855| 7| result->scope_.containing_oneof = 6856| 7| parent->oneof_decl(proto.oneof_index()); 6857| 7| result->in_real_oneof_ = !result->proto3_optional_; 6858| 7| } 6859| 7| } 6860| 205| } 6861| | 6862| | // Copy options. 6863| 206| AllocateOptions(proto, result, FieldDescriptorProto::kOptionsFieldNumber, 6864| 206| "google.protobuf.FieldOptions", alloc); 6865| | 6866| 206| AddSymbol(result->full_name(), parent, result->name(), proto, Symbol(result)); 6867| 206|} _ZN6google8protobuf17DescriptorBuilder19BuildExtensionRangeERKNS0_30DescriptorProto_ExtensionRangeEPKNS0_10DescriptorEPNS5_14ExtensionRangeERNS0_8internal13FlatAllocatorE: 6871| 14| Descriptor::ExtensionRange* result, internal::FlatAllocator& alloc) { 6872| 14| result->start_ = proto.start(); 6873| 14| result->end_ = proto.end(); 6874| 14| result->containing_type_ = parent; 6875| | 6876| 14| if (result->start_number() <= 0) { ------------------ | Branch (6876:7): [True: 0, False: 14] ------------------ 6877| 0| message_hints_[parent].RequestHintOnFieldNumbers( 6878| 0| proto, DescriptorPool::ErrorCollector::NUMBER, result->start_number(), 6879| 0| result->end_number()); 6880| 0| AddError(parent->full_name(), proto, DescriptorPool::ErrorCollector::NUMBER, 6881| 0| "Extension numbers must be positive integers."); 6882| 0| } 6883| | 6884| | // Checking of the upper bound of the extension range is deferred until after 6885| | // options interpreting. This allows messages with message_set_wire_format to 6886| | // have extensions beyond FieldDescriptor::kMaxNumber, since the extension 6887| | // numbers are actually used as int32s in the message_set_wire_format. 6888| | 6889| 14| if (result->start_number() >= result->end_number()) { ------------------ | Branch (6889:7): [True: 0, False: 14] ------------------ 6890| 0| AddError(parent->full_name(), proto, DescriptorPool::ErrorCollector::NUMBER, 6891| 0| "Extension range end number must be greater than start number."); 6892| 0| } 6893| | 6894| | // Copy options 6895| 14| AllocateOptions(proto, result, 6896| 14| DescriptorProto_ExtensionRange::kOptionsFieldNumber, 6897| 14| "google.protobuf.ExtensionRangeOptions", alloc); 6898| 14|} _ZN6google8protobuf17DescriptorBuilder18BuildReservedRangeERKNS0_29DescriptorProto_ReservedRangeEPKNS0_10DescriptorEPNS5_13ReservedRangeERNS0_8internal13FlatAllocatorE: 6902| 14| Descriptor::ReservedRange* result, internal::FlatAllocator&) { 6903| 14| result->start = proto.start(); 6904| 14| result->end = proto.end(); 6905| 14| if (result->start <= 0) { ------------------ | Branch (6905:7): [True: 0, False: 14] ------------------ 6906| 0| message_hints_[parent].RequestHintOnFieldNumbers( 6907| 0| proto, DescriptorPool::ErrorCollector::NUMBER, result->start, 6908| 0| result->end); 6909| 0| AddError(parent->full_name(), proto, DescriptorPool::ErrorCollector::NUMBER, 6910| 0| "Reserved numbers must be positive integers."); 6911| 0| } 6912| 14| if (result->start >= result->end) { ------------------ | Branch (6912:7): [True: 0, False: 14] ------------------ 6913| 0| AddError(parent->full_name(), proto, DescriptorPool::ErrorCollector::NUMBER, 6914| 0| "Reserved range end number must be greater than start number."); 6915| 0| } 6916| 14|} _ZN6google8protobuf17DescriptorBuilder18BuildReservedRangeERKNS0_37EnumDescriptorProto_EnumReservedRangeEPKNS0_14EnumDescriptorEPNS5_13ReservedRangeERNS0_8internal13FlatAllocatorE: 6921| 1| internal::FlatAllocator&) { 6922| 1| result->start = proto.start(); 6923| 1| result->end = proto.end(); 6924| | 6925| 1| if (result->start > result->end) { ------------------ | Branch (6925:7): [True: 0, False: 1] ------------------ 6926| 0| AddError(parent->full_name(), proto, DescriptorPool::ErrorCollector::NUMBER, 6927| 0| "Reserved range end number must be greater than start number."); 6928| 0| } 6929| 1|} _ZN6google8protobuf17DescriptorBuilder10BuildOneofERKNS0_20OneofDescriptorProtoEPNS0_10DescriptorEPNS0_15OneofDescriptorERNS0_8internal13FlatAllocatorE: 6933| 2| internal::FlatAllocator& alloc) { 6934| 2| result->all_names_ = 6935| 2| AllocateNameStrings(parent->full_name(), proto.name(), alloc); 6936| 2| ValidateSymbolName(proto.name(), result->full_name(), proto); 6937| | 6938| 2| result->containing_type_ = parent; 6939| | 6940| | // We need to fill these in later. 6941| 2| result->field_count_ = 0; 6942| 2| result->fields_ = nullptr; 6943| | 6944| | // Copy options. 6945| 2| AllocateOptions(proto, result, OneofDescriptorProto::kOptionsFieldNumber, 6946| 2| "google.protobuf.OneofOptions", alloc); 6947| | 6948| 2| AddSymbol(result->full_name(), parent, result->name(), proto, Symbol(result)); 6949| 2|} _ZN6google8protobuf17DescriptorBuilder9BuildEnumERKNS0_19EnumDescriptorProtoEPKNS0_10DescriptorEPNS0_14EnumDescriptorERNS0_8internal13FlatAllocatorE: 7021| 18| internal::FlatAllocator& alloc) { 7022| 18| const absl::string_view scope = 7023| 18| (parent == nullptr) ? file_->package() : parent->full_name(); ------------------ | Branch (7023:7): [True: 1, False: 17] ------------------ 7024| | 7025| 18| result->all_names_ = AllocateNameStrings(scope, proto.name(), alloc); 7026| 18| ValidateSymbolName(proto.name(), result->full_name(), proto); 7027| 18| result->file_ = file_; 7028| 18| result->containing_type_ = parent; 7029| 18| result->is_placeholder_ = false; 7030| 18| result->is_unqualified_placeholder_ = false; 7031| | 7032| 18| if (proto.value_size() == 0) { ------------------ | Branch (7032:7): [True: 0, False: 18] ------------------ 7033| | // We cannot allow enums with no values because this would mean there 7034| | // would be no valid default value for fields of this type. 7035| 0| AddError(result->full_name(), proto, DescriptorPool::ErrorCollector::NAME, 7036| 0| "Enums must contain at least one value."); 7037| 0| } 7038| | 7039| | // Calculate the continuous sequence of the labels. 7040| | // These can be fast-path'd during lookup and don't need to be added to the 7041| | // tables. 7042| | // We use uint16_t to save space for sequential_value_limit_, so stop before 7043| | // overflowing it. Worst case, we are not taking full advantage on huge 7044| | // enums, but it is unlikely. 7045| 18| for (int i = 0; 7046| 89| i < std::numeric_limits::max() && i < proto.value_size() && ------------------ | Branch (7046:8): [True: 89, False: 0] | Branch (7046:52): [True: 74, False: 15] ------------------ 7047| | // We do the math in int64_t to avoid overflows. 7048| 74| proto.value(i).number() == ------------------ | Branch (7048:8): [True: 71, False: 3] ------------------ 7049| 74| static_cast(i) + proto.value(0).number(); 7050| 71| ++i) { 7051| 71| result->sequential_value_limit_ = i; 7052| 71| } 7053| | 7054| 18| BUILD_ARRAY(proto, result, value, BuildEnumValue, result); ------------------ | | 5627| 18| OUTPUT->NAME##_count_ = INPUT.NAME##_size(); \ | | 5628| 18| OUTPUT->NAME##s_ = alloc.AllocateArray< \ | | 5629| 18| typename std::remove_pointerNAME##s_)>::type>( \ | | 5630| 18| INPUT.NAME##_size()); \ | | 5631| 104| for (int i = 0; i < INPUT.NAME##_size(); i++) { \ | | ------------------ | | | Branch (5631:19): [True: 86, False: 18] | | ------------------ | | 5632| 86| METHOD(INPUT.NAME(i), PARENT, OUTPUT->NAME##s_ + i, alloc); \ | | 5633| 86| } ------------------ 7055| 18| BUILD_ARRAY(proto, result, reserved_range, BuildReservedRange, result); ------------------ | | 5627| 18| OUTPUT->NAME##_count_ = INPUT.NAME##_size(); \ | | 5628| 18| OUTPUT->NAME##s_ = alloc.AllocateArray< \ | | 5629| 18| typename std::remove_pointerNAME##s_)>::type>( \ | | 5630| 18| INPUT.NAME##_size()); \ | | 5631| 19| for (int i = 0; i < INPUT.NAME##_size(); i++) { \ | | ------------------ | | | Branch (5631:19): [True: 1, False: 18] | | ------------------ | | 5632| 1| METHOD(INPUT.NAME(i), PARENT, OUTPUT->NAME##s_ + i, alloc); \ | | 5633| 1| } ------------------ 7056| | 7057| | // Copy reserved names. 7058| 18| int reserved_name_count = proto.reserved_name_size(); 7059| 18| result->reserved_name_count_ = reserved_name_count; 7060| 18| result->reserved_names_ = 7061| 18| alloc.AllocateArray(reserved_name_count); 7062| 18| for (int i = 0; i < reserved_name_count; ++i) { ------------------ | Branch (7062:19): [True: 0, False: 18] ------------------ 7063| 0| result->reserved_names_[i] = alloc.AllocateStrings(proto.reserved_name(i)); 7064| 0| } 7065| | 7066| | // Copy options. 7067| 18| AllocateOptions(proto, result, EnumDescriptorProto::kOptionsFieldNumber, 7068| 18| "google.protobuf.EnumOptions", alloc); 7069| | 7070| 18| AddSymbol(result->full_name(), parent, result->name(), proto, Symbol(result)); 7071| | 7072| 19| for (int i = 0; i < proto.reserved_range_size(); i++) { ------------------ | Branch (7072:19): [True: 1, False: 18] ------------------ 7073| 1| const EnumDescriptorProto_EnumReservedRange& range1 = 7074| 1| proto.reserved_range(i); 7075| 1| for (int j = i + 1; j < proto.reserved_range_size(); j++) { ------------------ | Branch (7075:25): [True: 0, False: 1] ------------------ 7076| 0| const EnumDescriptorProto_EnumReservedRange& range2 = 7077| 0| proto.reserved_range(j); 7078| 0| if (range1.end() >= range2.start() && range2.end() >= range1.start()) { ------------------ | Branch (7078:11): [True: 0, False: 0] | Branch (7078:45): [True: 0, False: 0] ------------------ 7079| 0| AddError(result->full_name(), proto.reserved_range(i), 7080| 0| DescriptorPool::ErrorCollector::NUMBER, [&] { 7081| 0| return absl::Substitute( 7082| 0| "Reserved range $0 to $1 overlaps with " 7083| 0| "already-defined range $2 to $3.", 7084| 0| range2.start(), range2.end(), range1.start(), 7085| 0| range1.end()); 7086| 0| }); 7087| 0| } 7088| 0| } 7089| 1| } 7090| | 7091| 18| absl::flat_hash_set reserved_name_set; 7092| 18| for (const std::string& name : proto.reserved_name()) { ------------------ | Branch (7092:32): [True: 0, False: 18] ------------------ 7093| 0| if (!reserved_name_set.insert(name).second) { ------------------ | Branch (7093:9): [True: 0, False: 0] ------------------ 7094| 0| AddError(name, proto, DescriptorPool::ErrorCollector::NAME, [&] { 7095| 0| return absl::Substitute("Enum value \"$0\" is reserved multiple times.", 7096| 0| name); 7097| 0| }); 7098| 0| } 7099| 0| } 7100| | 7101| 104| for (int i = 0; i < result->value_count(); i++) { ------------------ | Branch (7101:19): [True: 86, False: 18] ------------------ 7102| 86| const EnumValueDescriptor* value = result->value(i); 7103| 89| for (int j = 0; j < result->reserved_range_count(); j++) { ------------------ | Branch (7103:21): [True: 3, False: 86] ------------------ 7104| 3| const EnumDescriptor::ReservedRange* range = result->reserved_range(j); 7105| 3| if (range->start <= value->number() && value->number() <= range->end) { ------------------ | Branch (7105:11): [True: 2, False: 1] | Branch (7105:46): [True: 0, False: 2] ------------------ 7106| 0| AddError(value->full_name(), proto.reserved_range(j), 7107| 0| DescriptorPool::ErrorCollector::NUMBER, [&] { 7108| 0| return absl::Substitute( 7109| 0| "Enum value \"$0\" uses reserved number $1.", 7110| 0| value->name(), value->number()); 7111| 0| }); 7112| 0| } 7113| 3| } 7114| 86| if (reserved_name_set.contains(value->name())) { ------------------ | Branch (7114:9): [True: 0, False: 86] ------------------ 7115| 0| AddError(value->full_name(), proto.value(i), 7116| 0| DescriptorPool::ErrorCollector::NAME, [&] { 7117| 0| return absl::Substitute("Enum value \"$0\" is reserved.", 7118| 0| value->name()); 7119| 0| }); 7120| 0| } 7121| 86| } 7122| 18|} _ZN6google8protobuf17DescriptorBuilder14BuildEnumValueERKNS0_24EnumValueDescriptorProtoEPKNS0_14EnumDescriptorEPNS0_19EnumValueDescriptorERNS0_8internal13FlatAllocatorE: 7127| 86| internal::FlatAllocator& alloc) { 7128| | // Note: full_name for enum values is a sibling to the parent's name, not a 7129| | // child of it. 7130| 86| std::string full_name; 7131| 86| size_t scope_len = parent->full_name().size() - parent->name().size(); 7132| 86| full_name.reserve(scope_len + proto.name().size()); 7133| 86| full_name.append(parent->full_name().data(), scope_len); 7134| 86| full_name.append(proto.name()); 7135| | 7136| 86| result->all_names_ = 7137| 86| alloc.AllocateStrings(proto.name(), std::move(full_name)); 7138| 86| result->number_ = proto.number(); 7139| 86| result->type_ = parent; 7140| | 7141| 86| ValidateSymbolName(proto.name(), result->full_name(), proto); 7142| | 7143| | // Copy options. 7144| 86| AllocateOptions(proto, result, EnumValueDescriptorProto::kOptionsFieldNumber, 7145| 86| "google.protobuf.EnumValueOptions", alloc); 7146| | 7147| | // Again, enum values are weird because we makes them appear as siblings 7148| | // of the enum type instead of children of it. So, we use 7149| | // parent->containing_type() as the value's parent. 7150| 86| bool added_to_outer_scope = 7151| 86| AddSymbol(result->full_name(), parent->containing_type(), result->name(), 7152| 86| proto, Symbol::EnumValue(result, 0)); 7153| | 7154| | // However, we also want to be able to search for values within a single 7155| | // enum type, so we add it as a child of the enum type itself, too. 7156| | // Note: This could fail, but if it does, the error has already been 7157| | // reported by the above AddSymbol() call, so we ignore the return code. 7158| 86| bool added_to_inner_scope = file_tables_->AddAliasUnderParent( 7159| 86| parent, result->name(), Symbol::EnumValue(result, 1)); 7160| | 7161| 86| if (added_to_inner_scope && !added_to_outer_scope) { ------------------ | Branch (7161:7): [True: 86, False: 0] | Branch (7161:31): [True: 0, False: 86] ------------------ 7162| | // This value did not conflict with any values defined in the same enum, 7163| | // but it did conflict with some other symbol defined in the enum type's 7164| | // scope. Let's print an additional error to explain this. 7165| 0| std::string outer_scope; 7166| 0| if (parent->containing_type() == nullptr) { ------------------ | Branch (7166:9): [True: 0, False: 0] ------------------ 7167| 0| outer_scope = file_->package(); 7168| 0| } else { 7169| 0| outer_scope = parent->containing_type()->full_name(); 7170| 0| } 7171| | 7172| 0| if (outer_scope.empty()) { ------------------ | Branch (7172:9): [True: 0, False: 0] ------------------ 7173| 0| outer_scope = "the global scope"; 7174| 0| } else { 7175| 0| outer_scope = absl::StrCat("\"", outer_scope, "\""); 7176| 0| } 7177| | 7178| 0| AddError( 7179| 0| result->full_name(), proto, DescriptorPool::ErrorCollector::NAME, [&] { 7180| 0| return absl::StrCat( 7181| 0| "Note that enum values use C++ scoping rules, meaning that " 7182| 0| "enum values are siblings of their type, not children of it. " 7183| 0| "Therefore, \"", 7184| 0| result->name(), "\" must be unique within ", outer_scope, 7185| 0| ", not just within \"", parent->name(), "\"."); 7186| 0| }); 7187| 0| } 7188| | 7189| | // An enum is allowed to define two numbers that refer to the same value. 7190| | // FindValueByNumber() should return the first such value, so we simply 7191| | // ignore AddEnumValueByNumber()'s return code. 7192| 86| file_tables_->AddEnumValueByNumber(result); 7193| 86|} _ZN6google8protobuf17DescriptorBuilder13CrossLinkFileEPNS0_14FileDescriptorERKNS0_19FileDescriptorProtoE: 7243| 4| const FileDescriptorProto& proto) { 7244| 39| for (int i = 0; i < file->message_type_count(); i++) { ------------------ | Branch (7244:19): [True: 35, False: 4] ------------------ 7245| 35| CrossLinkMessage(&file->message_types_[i], proto.message_type(i)); 7246| 35| } 7247| | 7248| 5| for (int i = 0; i < file->extension_count(); i++) { ------------------ | Branch (7248:19): [True: 1, False: 4] ------------------ 7249| 1| CrossLinkField(&file->extensions_[i], proto.extension(i)); 7250| 1| } 7251| | 7252| 4| for (int i = 0; i < file->service_count(); i++) { ------------------ | Branch (7252:19): [True: 0, False: 4] ------------------ 7253| 0| CrossLinkService(&file->services_[i], proto.service(i)); 7254| 0| } 7255| 4|} _ZN6google8protobuf17DescriptorBuilder16CrossLinkMessageEPNS0_10DescriptorERKNS0_15DescriptorProtoE: 7258| 45| const DescriptorProto& proto) { 7259| 55| for (int i = 0; i < message->nested_type_count(); i++) { ------------------ | Branch (7259:19): [True: 10, False: 45] ------------------ 7260| 10| CrossLinkMessage(&message->nested_types_[i], proto.nested_type(i)); 7261| 10| } 7262| | 7263| 250| for (int i = 0; i < message->field_count(); i++) { ------------------ | Branch (7263:19): [True: 205, False: 45] ------------------ 7264| 205| CrossLinkField(&message->fields_[i], proto.field(i)); 7265| 205| } 7266| | 7267| 45| for (int i = 0; i < message->extension_count(); i++) { ------------------ | Branch (7267:19): [True: 0, False: 45] ------------------ 7268| 0| CrossLinkField(&message->extensions_[i], proto.extension(i)); 7269| 0| } 7270| | 7271| | // Set up field array for each oneof. 7272| | 7273| | // First count the number of fields per oneof. 7274| 250| for (int i = 0; i < message->field_count(); i++) { ------------------ | Branch (7274:19): [True: 205, False: 45] ------------------ 7275| 205| const OneofDescriptor* oneof_decl = message->field(i)->containing_oneof(); 7276| 205| if (oneof_decl != nullptr) { ------------------ | Branch (7276:9): [True: 7, False: 198] ------------------ 7277| | // Make sure fields belonging to the same oneof are defined consecutively. 7278| | // This enables optimizations in codegens and reflection libraries to 7279| | // skip fields in the oneof group, as only one of the field can be set. 7280| | // Note that field_count() returns how many fields in this oneof we have 7281| | // seen so far. field_count() > 0 guarantees that i > 0, so field(i-1) is 7282| | // safe. 7283| 7| if (oneof_decl->field_count() > 0 && ------------------ | Branch (7283:11): [True: 5, False: 2] ------------------ 7284| 5| message->field(i - 1)->containing_oneof() != oneof_decl) { ------------------ | Branch (7284:11): [True: 0, False: 5] ------------------ 7285| 0| AddError( 7286| 0| absl::StrCat(message->full_name(), ".", 7287| 0| message->field(i - 1)->name()), 7288| 0| proto.field(i - 1), DescriptorPool::ErrorCollector::TYPE, [&] { 7289| 0| return absl::Substitute( 7290| 0| "Fields in the same oneof must be defined consecutively. " 7291| 0| "\"$0\" cannot be defined before the completion of the " 7292| 0| "\"$1\" oneof definition.", 7293| 0| message->field(i - 1)->name(), oneof_decl->name()); 7294| 0| }); 7295| 0| } 7296| | // Must go through oneof_decls_ array to get a non-const version of the 7297| | // OneofDescriptor. 7298| 7| auto& out_oneof_decl = message->oneof_decls_[oneof_decl->index()]; 7299| 7| if (out_oneof_decl.field_count_ == 0) { ------------------ | Branch (7299:11): [True: 2, False: 5] ------------------ 7300| 2| out_oneof_decl.fields_ = message->field(i); 7301| 2| } 7302| | 7303| 7| if (!had_errors_) { ------------------ | Branch (7303:11): [True: 7, False: 0] ------------------ 7304| | // Verify that they are contiguous. 7305| | // This is assumed by OneofDescriptor::field(i). 7306| | // But only if there are no errors. 7307| 7| ABSL_CHECK_EQ(out_oneof_decl.fields_ + out_oneof_decl.field_count_, ------------------ | | 50| 7| ABSL_LOG_INTERNAL_CHECK_EQ_IMPL((val1), #val1, (val2), #val2) | | ------------------ | | | | 48| 7| ABSL_LOG_INTERNAL_CHECK_OP(Check_EQ, ==, val1, val1_text, val2, val2_text) | | | | ------------------ | | | | | | 61| 7| while ( \ | | | | | | 62| 7| ::std::string* absl_log_internal_check_op_result ABSL_ATTRIBUTE_UNUSED = \ | | | | | | ------------------ | | | | | | | Branch (62:22): [True: 0, False: 7] | | | | | | ------------------ | | | | | | 63| 7| ::absl::log_internal::name##Impl( \ | | | | | | 64| 7| ::absl::log_internal::GetReferenceableValue(val1), \ | | | | | | 65| 7| ::absl::log_internal::GetReferenceableValue(val2), \ | | | | | | 66| 7| ABSL_LOG_INTERNAL_STRIP_STRING_LITERAL(val1_text \ | | | | | | 67| 7| " " #op " " val2_text))) \ | | | | | | 68| 7| ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS, true) \ | | | | | | ------------------ | | | | | | | | 172| 0| ABSL_LOG_INTERNAL_##type##_CONDITION(condition) | | | | | | | | ------------------ | | | | | | | | | | 65| 0| switch (0) \ | | | | | | | | | | 66| 0| case 0: \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (66:3): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 67| 0| default: \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (67:3): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 68| 0| !(condition) ? (void)0 : ::absl::log_internal::Voidify()&& | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (68:5): [Folded, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 69| 0| ABSL_LOG_INTERNAL_CHECK(*absl_log_internal_check_op_result).InternalStream() | | | | | | ------------------ | | | | | | | | 66| 0| ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 7308| 7| message->field(i)); 7309| 7| } 7310| 7| ++out_oneof_decl.field_count_; 7311| 7| } 7312| 205| } 7313| | 7314| | // Then verify the sizes. 7315| 47| for (int i = 0; i < message->oneof_decl_count(); i++) { ------------------ | Branch (7315:19): [True: 2, False: 45] ------------------ 7316| 2| OneofDescriptor* oneof_decl = &message->oneof_decls_[i]; 7317| | 7318| 2| if (oneof_decl->field_count() == 0) { ------------------ | Branch (7318:9): [True: 0, False: 2] ------------------ 7319| 0| AddError(absl::StrCat(message->full_name(), ".", oneof_decl->name()), 7320| 0| proto.oneof_decl(i), DescriptorPool::ErrorCollector::NAME, 7321| 0| "Oneof must have at least one field."); 7322| 0| } 7323| 2| } 7324| | 7325| 250| for (int i = 0; i < message->field_count(); i++) { ------------------ | Branch (7325:19): [True: 205, False: 45] ------------------ 7326| 205| const FieldDescriptor* field = message->field(i); 7327| 205| if (field->proto3_optional_) { ------------------ | Branch (7327:9): [True: 0, False: 205] ------------------ 7328| 0| if (!field->containing_oneof() || ------------------ | Branch (7328:11): [True: 0, False: 0] ------------------ 7329| 0| !field->containing_oneof()->is_synthetic()) { ------------------ | Branch (7329:11): [True: 0, False: 0] ------------------ 7330| 0| AddError(message->full_name(), proto.field(i), 7331| 0| DescriptorPool::ErrorCollector::OTHER, 7332| 0| "Fields with proto3_optional set must be " 7333| 0| "a member of a one-field oneof"); 7334| 0| } 7335| 0| } 7336| 205| } 7337| | 7338| | // Synthetic oneofs must be last. 7339| 45| int first_synthetic = -1; 7340| 47| for (int i = 0; i < message->oneof_decl_count(); i++) { ------------------ | Branch (7340:19): [True: 2, False: 45] ------------------ 7341| 2| if (message->oneof_decl(i)->is_synthetic()) { ------------------ | Branch (7341:9): [True: 0, False: 2] ------------------ 7342| 0| if (first_synthetic == -1) { ------------------ | Branch (7342:11): [True: 0, False: 0] ------------------ 7343| 0| first_synthetic = i; 7344| 0| } 7345| 2| } else { 7346| 2| if (first_synthetic != -1) { ------------------ | Branch (7346:11): [True: 0, False: 2] ------------------ 7347| 0| AddError(message->full_name(), proto.oneof_decl(i), 7348| 0| DescriptorPool::ErrorCollector::OTHER, 7349| 0| "Synthetic oneofs must be after all other oneofs"); 7350| 0| } 7351| 2| } 7352| 2| } 7353| | 7354| 45| if (first_synthetic == -1) { ------------------ | Branch (7354:7): [True: 45, False: 0] ------------------ 7355| 45| message->real_oneof_decl_count_ = message->oneof_decl_count_; 7356| 45| } else { 7357| 0| message->real_oneof_decl_count_ = first_synthetic; 7358| 0| } 7359| 45|} _ZN6google8protobuf17DescriptorBuilder14CrossLinkFieldEPNS0_15FieldDescriptorERKNS0_20FieldDescriptorProtoE: 7425| 206| const FieldDescriptorProto& proto) { 7426| 206| if (proto.has_extendee()) { ------------------ | Branch (7426:7): [True: 1, False: 205] ------------------ 7427| 1| Symbol extendee = 7428| 1| LookupSymbol(proto.extendee(), field->full_name(), 7429| 1| DescriptorPool::PLACEHOLDER_EXTENDABLE_MESSAGE); 7430| 1| if (extendee.IsNull()) { ------------------ | Branch (7430:9): [True: 0, False: 1] ------------------ 7431| 0| AddNotDefinedError(field->full_name(), proto, 7432| 0| DescriptorPool::ErrorCollector::EXTENDEE, 7433| 0| proto.extendee()); 7434| 0| return; 7435| 1| } else if (extendee.type() != Symbol::MESSAGE) { ------------------ | Branch (7435:16): [True: 0, False: 1] ------------------ 7436| 0| AddError(field->full_name(), proto, 7437| 0| DescriptorPool::ErrorCollector::EXTENDEE, [&] { 7438| 0| return absl::StrCat("\"", proto.extendee(), 7439| 0| "\" is not a message type."); 7440| 0| }); 7441| 0| return; 7442| 0| } 7443| 1| field->containing_type_ = extendee.descriptor(); 7444| | 7445| 1| const Descriptor::ExtensionRange* extension_range = 7446| 1| field->containing_type()->FindExtensionRangeContainingNumber( 7447| 1| field->number()); 7448| | 7449| 1| if (extension_range == nullptr) { ------------------ | Branch (7449:9): [True: 0, False: 1] ------------------ 7450| 0| AddError(field->full_name(), proto, 7451| 0| DescriptorPool::ErrorCollector::NUMBER, [&] { 7452| 0| return absl::Substitute( 7453| 0| "\"$0\" does not declare $1 as an " 7454| 0| "extension number.", 7455| 0| field->containing_type()->full_name(), field->number()); 7456| 0| }); 7457| 0| } 7458| 1| } 7459| | 7460| 206| if (field->containing_oneof() != nullptr) { ------------------ | Branch (7460:7): [True: 7, False: 199] ------------------ 7461| 7| if (field->label() != FieldDescriptor::LABEL_OPTIONAL) { ------------------ | Branch (7461:9): [True: 0, False: 7] ------------------ 7462| | // Note that this error will never happen when parsing .proto files. 7463| | // It can only happen if you manually construct a FileDescriptorProto 7464| | // that is incorrect. 7465| 0| AddError(field->full_name(), proto, DescriptorPool::ErrorCollector::NAME, 7466| 0| "Fields of oneofs must themselves have label LABEL_OPTIONAL."); 7467| 0| } 7468| 7| } 7469| | 7470| 206| if (proto.has_type_name()) { ------------------ | Branch (7470:7): [True: 92, False: 114] ------------------ 7471| | // Assume we are expecting a message type unless the proto contains some 7472| | // evidence that it expects an enum type. This only makes a difference if 7473| | // we end up creating a placeholder. 7474| 92| bool expecting_enum = (proto.type() == FieldDescriptorProto::TYPE_ENUM) || ------------------ | Branch (7474:27): [True: 25, False: 67] ------------------ 7475| 67| proto.has_default_value(); ------------------ | Branch (7475:27): [True: 0, False: 67] ------------------ 7476| | 7477| | // In case of weak fields we force building the dependency. We need to know 7478| | // if the type exist or not. If it doesn't exist we substitute Empty which 7479| | // should only be done if the type can't be found in the generated pool. 7480| | // TODO Ideally we should query the database directly to check 7481| | // if weak fields exist or not so that we don't need to force building 7482| | // weak dependencies. However the name lookup rules for symbols are 7483| | // somewhat complicated, so I defer it too another CL. 7484| 92| bool is_weak = !pool_->enforce_weak_ && proto.options().weak(); ------------------ | Branch (7484:20): [True: 92, False: 0] | Branch (7484:45): [True: 0, False: 92] ------------------ 7485| 92| bool is_lazy = pool_->lazily_build_dependencies_ && !is_weak; ------------------ | Branch (7485:20): [True: 92, False: 0] | Branch (7485:57): [True: 92, False: 0] ------------------ 7486| | 7487| 92| Symbol type = 7488| 92| LookupSymbol(proto.type_name(), field->full_name(), 7489| 92| expecting_enum ? DescriptorPool::PLACEHOLDER_ENUM ------------------ | Branch (7489:22): [True: 25, False: 67] ------------------ 7490| 92| : DescriptorPool::PLACEHOLDER_MESSAGE, 7491| 92| LOOKUP_TYPES, !is_lazy); 7492| | 7493| 92| if (type.IsNull()) { ------------------ | Branch (7493:9): [True: 0, False: 92] ------------------ 7494| 0| if (is_lazy) { ------------------ | Branch (7494:11): [True: 0, False: 0] ------------------ 7495| 0| ABSL_CHECK(field->type_ == FieldDescriptor::TYPE_MESSAGE || ------------------ | | 41| 0| ABSL_LOG_INTERNAL_CHECK_IMPL((condition), #condition) | | ------------------ | | | | 26| 0| ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS, \ | | | | ------------------ | | | | | | 172| 0| ABSL_LOG_INTERNAL_##type##_CONDITION(condition) | | | | | | ------------------ | | | | | | | | 65| 0| switch (0) \ | | | | | | | | 66| 0| case 0: \ | | | | | | | | ------------------ | | | | | | | | | Branch (66:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 67| 0| default: \ | | | | | | | | ------------------ | | | | | | | | | Branch (67:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 68| 0| !(condition) ? (void)0 : ::absl::log_internal::Voidify()&& | | | | | | | | ------------------ | | | | | | | | | Branch (68:5): [True: 0, False: 0] | | | | | | | | | Branch (68:7): [True: 0, False: 0] | | | | | | | | | Branch (68:7): [True: 0, False: 0] | | | | | | | | | Branch (68:7): [True: 0, False: 0] | | | | | | | | | Branch (68:7): [Folded, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 27| 0| ABSL_PREDICT_FALSE(!(condition))) \ | | | | 28| 0| ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream() | | | | ------------------ | | | | | | 66| 0| ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message) | | | | ------------------ | | ------------------ ------------------ 7496| 0| field->type_ == FieldDescriptor::TYPE_GROUP || 7497| 0| field->type_ == FieldDescriptor::TYPE_ENUM) 7498| 0| << proto; 7499| | // Save the symbol names for later for lookup, and allocate the once 7500| | // object needed for the accessors. 7501| 0| const std::string& name = proto.type_name(); 7502| | 7503| 0| int name_sizes = static_cast(name.size() + 1 + 7504| 0| proto.default_value().size() + 1); 7505| | 7506| 0| field->type_once_ = ::new (tables_->AllocateBytes( 7507| 0| static_cast(sizeof(absl::once_flag)) + name_sizes)) 7508| 0| absl::once_flag{}; 7509| 0| char* names = reinterpret_cast(field->type_once_ + 1); 7510| | 7511| 0| memcpy(names, name.c_str(), name.size() + 1); 7512| 0| memcpy(names + name.size() + 1, proto.default_value().c_str(), 7513| 0| proto.default_value().size() + 1); 7514| | 7515| | // AddFieldByNumber and AddExtension are done later in this function, 7516| | // and can/must be done if the field type was not found. The related 7517| | // error checking is not necessary when in lazily_build_dependencies_ 7518| | // mode, and can't be done without building the type's descriptor, 7519| | // which we don't want to do. 7520| 0| file_tables_->AddFieldByNumber(field); 7521| 0| if (field->is_extension()) { ------------------ | Branch (7521:13): [True: 0, False: 0] ------------------ 7522| 0| tables_->AddExtension(field); 7523| 0| } 7524| 0| return; 7525| 0| } else { 7526| | // If the type is a weak type, we change the type to a google.protobuf.Empty 7527| | // field. 7528| 0| if (is_weak) { ------------------ | Branch (7528:13): [True: 0, False: 0] ------------------ 7529| 0| type = FindSymbol(kNonLinkedWeakMessageReplacementName); 7530| 0| } 7531| 0| if (type.IsNull()) { ------------------ | Branch (7531:13): [True: 0, False: 0] ------------------ 7532| 0| AddNotDefinedError(field->full_name(), proto, 7533| 0| DescriptorPool::ErrorCollector::TYPE, 7534| 0| proto.type_name()); 7535| 0| return; 7536| 0| } 7537| 0| } 7538| 0| } 7539| | 7540| 92| if (!proto.has_type()) { ------------------ | Branch (7540:9): [True: 0, False: 92] ------------------ 7541| | // Choose field type based on symbol. 7542| 0| if (type.type() == Symbol::MESSAGE) { ------------------ | Branch (7542:11): [True: 0, False: 0] ------------------ 7543| 0| field->type_ = FieldDescriptor::TYPE_MESSAGE; 7544| 0| } else if (type.type() == Symbol::ENUM) { ------------------ | Branch (7544:18): [True: 0, False: 0] ------------------ 7545| 0| field->type_ = FieldDescriptor::TYPE_ENUM; 7546| 0| } else { 7547| 0| AddError(field->full_name(), proto, 7548| 0| DescriptorPool::ErrorCollector::TYPE, [&] { 7549| 0| return absl::StrCat("\"", proto.type_name(), 7550| 0| "\" is not a type."); 7551| 0| }); 7552| 0| return; 7553| 0| } 7554| 0| } 7555| | 7556| 92| if (field->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE) { ------------------ | Branch (7556:9): [True: 67, False: 25] ------------------ 7557| 67| field->type_descriptor_.message_type = type.descriptor(); 7558| 67| if (field->type_descriptor_.message_type == nullptr) { ------------------ | Branch (7558:11): [True: 0, False: 67] ------------------ 7559| 0| AddError(field->full_name(), proto, 7560| 0| DescriptorPool::ErrorCollector::TYPE, [&] { 7561| 0| return absl::StrCat("\"", proto.type_name(), 7562| 0| "\" is not a message type."); 7563| 0| }); 7564| 0| return; 7565| 0| } 7566| | 7567| 67| if (field->has_default_value()) { ------------------ | Branch (7567:11): [True: 0, False: 67] ------------------ 7568| 0| AddError(field->full_name(), proto, 7569| 0| DescriptorPool::ErrorCollector::DEFAULT_VALUE, 7570| 0| "Messages can't have default values."); 7571| 0| } 7572| 67| } else if (field->cpp_type() == FieldDescriptor::CPPTYPE_ENUM) { ------------------ | Branch (7572:16): [True: 25, False: 0] ------------------ 7573| 25| field->type_descriptor_.enum_type = type.enum_descriptor(); 7574| 25| if (field->type_descriptor_.enum_type == nullptr) { ------------------ | Branch (7574:11): [True: 0, False: 25] ------------------ 7575| 0| AddError(field->full_name(), proto, 7576| 0| DescriptorPool::ErrorCollector::TYPE, [&] { 7577| 0| return absl::StrCat("\"", proto.type_name(), 7578| 0| "\" is not an enum type."); 7579| 0| }); 7580| 0| return; 7581| 0| } 7582| | 7583| 25| if (field->enum_type()->is_placeholder_) { ------------------ | Branch (7583:11): [True: 0, False: 25] ------------------ 7584| | // We can't look up default values for placeholder types. We'll have 7585| | // to just drop them. 7586| 0| field->has_default_value_ = false; 7587| 0| } 7588| | 7589| 25| if (field->has_default_value()) { ------------------ | Branch (7589:11): [True: 5, False: 20] ------------------ 7590| | // Ensure that the default value is an identifier. Parser cannot always 7591| | // verify this because it does not have complete type information. 7592| | // N.B. that this check yields better error messages but is not 7593| | // necessary for correctness (an enum symbol must be a valid identifier 7594| | // anyway), only for better errors. 7595| 5| if (!io::Tokenizer::IsIdentifier(proto.default_value())) { ------------------ | Branch (7595:13): [True: 0, False: 5] ------------------ 7596| 0| AddError(field->full_name(), proto, 7597| 0| DescriptorPool::ErrorCollector::DEFAULT_VALUE, 7598| 0| "Default value for an enum field must be an identifier."); 7599| 5| } else { 7600| | // We can't just use field->enum_type()->FindValueByName() here 7601| | // because that locks the pool's mutex, which we have already locked 7602| | // at this point. 7603| 5| const EnumValueDescriptor* default_value = 7604| 5| LookupSymbolNoPlaceholder(proto.default_value(), 7605| 5| field->enum_type()->full_name()) 7606| 5| .enum_value_descriptor(); 7607| | 7608| 5| if (default_value != nullptr && ------------------ | Branch (7608:15): [True: 5, False: 0] ------------------ 7609| 5| default_value->type() == field->enum_type()) { ------------------ | Branch (7609:15): [True: 5, False: 0] ------------------ 7610| 5| field->default_value_enum_ = default_value; 7611| 5| } else { 7612| 0| AddError(field->full_name(), proto, 7613| 0| DescriptorPool::ErrorCollector::DEFAULT_VALUE, [&] { 7614| 0| return absl::StrCat("Enum type \"", 7615| 0| field->enum_type()->full_name(), 7616| 0| "\" has no value named \"", 7617| 0| proto.default_value(), "\"."); 7618| 0| }); 7619| 0| } 7620| 5| } 7621| 20| } else if (field->enum_type()->value_count() > 0) { ------------------ | Branch (7621:18): [True: 20, False: 0] ------------------ 7622| | // All enums must have at least one value, or we would have reported 7623| | // an error elsewhere. We use the first defined value as the default 7624| | // if a default is not explicitly defined. 7625| 20| field->default_value_enum_ = field->enum_type()->value(0); 7626| 20| } 7627| 25| } else { 7628| 0| AddError(field->full_name(), proto, DescriptorPool::ErrorCollector::TYPE, 7629| 0| "Field with primitive type has type_name."); 7630| 0| } 7631| 114| } else { 7632| 114| if (field->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE || ------------------ | Branch (7632:9): [True: 0, False: 114] ------------------ 7633| 114| field->cpp_type() == FieldDescriptor::CPPTYPE_ENUM) { ------------------ | Branch (7633:9): [True: 0, False: 114] ------------------ 7634| 0| AddError(field->full_name(), proto, DescriptorPool::ErrorCollector::TYPE, 7635| 0| "Field with message or enum type missing type_name."); 7636| 0| } 7637| 114| } 7638| | 7639| | // Add the field to the fields-by-number table. 7640| | // Note: We have to do this *after* cross-linking because extensions do not 7641| | // know their containing type until now. If we're in 7642| | // lazily_build_dependencies_ mode, we're guaranteed there's no errors, so no 7643| | // risk to calling containing_type() or other accessors that will build 7644| | // dependencies. 7645| 206| if (!file_tables_->AddFieldByNumber(field)) { ------------------ | Branch (7645:7): [True: 0, False: 206] ------------------ 7646| 0| const FieldDescriptor* conflicting_field = file_tables_->FindFieldByNumber( 7647| 0| field->containing_type(), field->number()); 7648| 0| const absl::string_view containing_type_name = 7649| 0| field->containing_type() == nullptr ------------------ | Branch (7649:9): [True: 0, False: 0] ------------------ 7650| 0| ? absl::string_view("unknown") 7651| 0| : field->containing_type()->full_name(); 7652| 0| if (field->is_extension()) { ------------------ | Branch (7652:9): [True: 0, False: 0] ------------------ 7653| 0| AddError(field->full_name(), proto, 7654| 0| DescriptorPool::ErrorCollector::NUMBER, [&] { 7655| 0| return absl::Substitute( 7656| 0| "Extension number $0 has already been used " 7657| 0| "in \"$1\" by extension \"$2\".", 7658| 0| field->number(), containing_type_name, 7659| 0| conflicting_field->full_name()); 7660| 0| }); 7661| 0| } else { 7662| 0| AddError(field->full_name(), proto, 7663| 0| DescriptorPool::ErrorCollector::NUMBER, [&] { 7664| 0| return absl::Substitute( 7665| 0| "Field number $0 has already been used in " 7666| 0| "\"$1\" by field \"$2\".", 7667| 0| field->number(), containing_type_name, 7668| 0| conflicting_field->name()); 7669| 0| }); 7670| 0| } 7671| 206| } else { 7672| 206| if (field->is_extension()) { ------------------ | Branch (7672:9): [True: 1, False: 205] ------------------ 7673| 1| if (!tables_->AddExtension(field)) { ------------------ | Branch (7673:11): [True: 0, False: 1] ------------------ 7674| 0| auto make_error = [&] { 7675| 0| const FieldDescriptor* conflicting_field = 7676| 0| tables_->FindExtension(field->containing_type(), field->number()); 7677| 0| const absl::string_view containing_type_name = 7678| 0| field->containing_type() == nullptr 7679| 0| ? absl::string_view("unknown") 7680| 0| : field->containing_type()->full_name(); 7681| 0| return absl::Substitute( 7682| 0| "Extension number $0 has already been used in \"$1\" by " 7683| 0| "extension " 7684| 0| "\"$2\" defined in $3.", 7685| 0| field->number(), containing_type_name, 7686| 0| conflicting_field->full_name(), 7687| 0| conflicting_field->file()->name()); 7688| 0| }; 7689| | // Conflicting extension numbers should be an error. However, before 7690| | // turning this into an error we need to fix all existing broken 7691| | // protos first. 7692| | // TODO: Change this to an error. 7693| 0| AddWarning(field->full_name(), proto, 7694| 0| DescriptorPool::ErrorCollector::NUMBER, make_error); 7695| 0| } 7696| 1| } 7697| 206| } 7698| 206|} _ZN6google8protobuf17DescriptorBuilder17OptionInterpreterC2EPS1_: 8612| 4| : builder_(builder) { 8613| 4| ABSL_CHECK(builder_); ------------------ | | 41| 4| ABSL_LOG_INTERNAL_CHECK_IMPL((condition), #condition) | | ------------------ | | | | 26| 8| ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS, \ | | | | ------------------ | | | | | | 172| 4| ABSL_LOG_INTERNAL_##type##_CONDITION(condition) | | | | | | ------------------ | | | | | | | | 65| 8| switch (0) \ | | | | | | | | 66| 8| case 0: \ | | | | | | | | ------------------ | | | | | | | | | Branch (66:3): [True: 4, False: 0] | | | | | | | | ------------------ | | | | | | | | 67| 4| default: \ | | | | | | | | ------------------ | | | | | | | | | Branch (67:3): [True: 0, False: 4] | | | | | | | | ------------------ | | | | | | | | 68| 8| !(condition) ? (void)0 : ::absl::log_internal::Voidify()&& | | | | | | | | ------------------ | | | | | | | | | Branch (68:5): [True: 4, False: 0] | | | | | | | | | Branch (68:7): [Folded, False: 4] | | | | | | | | | Branch (68:7): [True: 0, False: 4] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 27| 8| ABSL_PREDICT_FALSE(!(condition))) \ | | | | 28| 8| ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream() | | | | ------------------ | | | | | | 66| 0| ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message) | | | | ------------------ | | ------------------ ------------------ 8614| 4|} _ZN6google8protobuf17DescriptorBuilder17OptionInterpreterD2Ev: 8616| 4|DescriptorBuilder::OptionInterpreter::~OptionInterpreter() = default; _ZNK6google8protobuf15FieldDescriptor12message_typeEv: 9676| 106k|const Descriptor* FieldDescriptor::message_type() const { 9677| 106k| if (type_ == TYPE_MESSAGE || type_ == TYPE_GROUP) { ------------------ | Branch (9677:7): [True: 106k, False: 0] | Branch (9677:32): [True: 0, False: 0] ------------------ 9678| 106k| if (type_once_) { ------------------ | Branch (9678:9): [True: 0, False: 106k] ------------------ 9679| 0| absl::call_once(*type_once_, FieldDescriptor::TypeOnceInit, this); 9680| 0| } 9681| 106k| return type_descriptor_.message_type; 9682| 106k| } 9683| 0| return nullptr; 9684| 106k|} _ZNK6google8protobuf15FieldDescriptor9enum_typeEv: 9686| 75|const EnumDescriptor* FieldDescriptor::enum_type() const { 9687| 75| if (type_ == TYPE_ENUM) { ------------------ | Branch (9687:7): [True: 75, False: 0] ------------------ 9688| 75| if (type_once_) { ------------------ | Branch (9688:9): [True: 0, False: 75] ------------------ 9689| 0| absl::call_once(*type_once_, FieldDescriptor::TypeOnceInit, this); 9690| 0| } 9691| 75| return type_descriptor_.enum_type; 9692| 75| } 9693| 0| return nullptr; 9694| 75|} _ZN6google8protobuf8internal17ParseNoReflectionENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEERNS0_11MessageLiteE: 9780| 24|bool ParseNoReflection(absl::string_view from, google::protobuf::MessageLite& to) { 9781| 24| auto cleanup = DisableTracking(); 9782| | 9783| 24| to.Clear(); 9784| 24| const char* ptr; 9785| 24| internal::ParseContext ctx(io::CodedInputStream::GetDefaultRecursionLimit(), 9786| 24| false, &ptr, from); 9787| 24| ptr = to._InternalParse(ptr, &ctx); 9788| 24| if (ptr == nullptr || !ctx.EndedAtLimit()) return false; ------------------ | Branch (9788:7): [True: 0, False: 24] | Branch (9788:25): [True: 0, False: 24] ------------------ 9789| 24| return to.IsInitializedWithErrors(); 9790| 24|} _ZN6google8protobuf8internal3cpp23IsLazilyInitializedFileENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEE: 9846| 4|bool IsLazilyInitializedFile(absl::string_view filename) { 9847| 4| if (filename == "third_party/protobuf/cpp_features.proto" || ------------------ | Branch (9847:7): [True: 0, False: 4] ------------------ 9848| 4| filename == "google/protobuf/cpp_features.proto") { ------------------ | Branch (9848:7): [True: 1, False: 3] ------------------ 9849| 1| return true; 9850| 1| } 9851| 3| return filename == "net/proto2/proto/descriptor.proto" || ------------------ | Branch (9851:10): [True: 0, False: 3] ------------------ 9852| 3| filename == "google/protobuf/descriptor.proto"; ------------------ | Branch (9852:10): [True: 1, False: 2] ------------------ 9853| 4|} _ZNK6google8protobuf14FileDescriptor7editionEv: 9860| 787|Edition FileDescriptor::edition() const { return edition_; } _ZNK6google8protobuf14DescriptorPool6Tables10FindSymbolENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEE: 1693| 104|inline Symbol DescriptorPool::Tables::FindSymbol(absl::string_view key) const { 1694| 104| auto it = symbols_by_name_.find(FullNameQuery{key}); 1695| 104| return it == symbols_by_name_.end() ? Symbol() : *it; ------------------ | Branch (1695:10): [True: 5, False: 99] ------------------ 1696| 104|} descriptor.cc:_ZNK6google8protobuf12_GLOBAL__N_118SymbolByFullNameEqclINS0_6SymbolENS1_13FullNameQueryEEEbRKT_RKT0_: 958| 102| bool operator()(const T& a, const U& b) const { 959| 102| return a.full_name() == b.full_name(); 960| 102| } _ZNK6google8protobuf6Symbol9full_nameEv: 707| 964| absl::string_view full_name() const { 708| 964| switch (type()) { 709| 165| case MESSAGE: ------------------ | Branch (709:7): [True: 165, False: 799] ------------------ 710| 165| return descriptor()->full_name(); 711| 542| case FIELD: ------------------ | Branch (711:7): [True: 542, False: 422] ------------------ 712| 542| return field_descriptor()->full_name(); 713| 2| case ONEOF: ------------------ | Branch (713:7): [True: 2, False: 962] ------------------ 714| 2| return oneof_descriptor()->full_name(); 715| 58| case ENUM: ------------------ | Branch (715:7): [True: 58, False: 906] ------------------ 716| 58| return enum_descriptor()->full_name(); 717| 181| case ENUM_VALUE: ------------------ | Branch (717:7): [True: 181, False: 783] ------------------ 718| 181| return enum_value_descriptor()->full_name(); 719| 0| case SERVICE: ------------------ | Branch (719:7): [True: 0, False: 964] ------------------ 720| 0| return service_descriptor()->full_name(); 721| 0| case METHOD: ------------------ | Branch (721:7): [True: 0, False: 964] ------------------ 722| 0| return method_descriptor()->full_name(); 723| 9| case FULL_PACKAGE: ------------------ | Branch (723:7): [True: 9, False: 955] ------------------ 724| 9| return file_descriptor()->package(); 725| 7| case SUB_PACKAGE: ------------------ | Branch (725:7): [True: 7, False: 957] ------------------ 726| 7| return absl::string_view(sub_package_file_descriptor()->file->package()) 727| 7| .substr(0, sub_package_file_descriptor()->name_size); 728| 0| default: ------------------ | Branch (728:7): [True: 0, False: 964] ------------------ 729| 0| ABSL_CHECK(false); ------------------ | | 41| 0| ABSL_LOG_INTERNAL_CHECK_IMPL((condition), #condition) | | ------------------ | | | | 26| 0| ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS, \ | | | | ------------------ | | | | | | 172| 0| ABSL_LOG_INTERNAL_##type##_CONDITION(condition) | | | | | | ------------------ | | | | | | | | 65| 0| switch (0) \ | | | | | | | | 66| 0| case 0: \ | | | | | | | | ------------------ | | | | | | | | | Branch (66:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 67| 0| default: \ | | | | | | | | ------------------ | | | | | | | | | Branch (67:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 68| 0| !(condition) ? (void)0 : ::absl::log_internal::Voidify()&& | | | | | | | | ------------------ | | | | | | | | | Branch (68:5): [Folded, False: 0] | | | | | | | | | Branch (68:7): [Folded, False: 0] | | | | | | | | | Branch (68:7): [True: 0, Folded] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 27| 0| ABSL_PREDICT_FALSE(!(condition))) \ | | | | 28| 0| ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream() | | | | ------------------ | | | | | | 66| 0| ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message) | | | | ------------------ | | ------------------ ------------------ 730| 964| } 731| 0| return ""; 732| 964| } _ZNK6google8protobuf6Symbol15file_descriptorEv: 622| 9| const TYPE* FIELD() const { \ 623| 9| return type() == TYPE_CONSTANT ? static_cast(ptr_) : nullptr; \ ------------------ | Branch (623:12): [True: 9, False: 0] ------------------ 624| 9| } _ZNK6google8protobuf6Symbol27sub_package_file_descriptorEv: 622| 14| const TYPE* FIELD() const { \ 623| 14| return type() == TYPE_CONSTANT ? static_cast(ptr_) : nullptr; \ ------------------ | Branch (623:12): [True: 14, False: 0] ------------------ 624| 14| } descriptor.cc:_ZNK6google8protobuf12_GLOBAL__N_113FullNameQuery9full_nameEv: 944| 206| absl::string_view full_name() const { return query; } descriptor.cc:_ZNK6google8protobuf12_GLOBAL__N_120SymbolByFullNameHashclINS1_13FullNameQueryEEEmRKT_: 950| 104| size_t operator()(const T& s) const { 951| 104| return absl::HashOf(s.full_name()); 952| 104| } _ZNK6google8protobuf6Symbol6IsNullEv: 673| 491| bool IsNull() const { return type() == NULL_SYMBOL; } _ZN6google8protobuf14DescriptorPool18DeferredValidationC2EPKS1_: 1337| 5| : pool_(pool), error_collector_(pool->default_error_collector_) {} _ZN6google8protobuf6SymbolC2Ev: 607| 249| Symbol() { 608| 249| static constexpr internal::SymbolBase null_symbol{}; 609| 249| static_assert(null_symbol.symbol_type_ == NULL_SYMBOL, ""); 610| | // Initialize with a sentinel to make sure `ptr_` is never null. 611| 249| ptr_ = &null_symbol; 612| 249| } _ZN6google8protobuf14DescriptorPool18DeferredValidation8ValidateEv: 1373| 4| bool Validate() { 1374| 4| if (lifetimes_info_map_.empty()) return true; ------------------ | Branch (1374:9): [True: 4, False: 0] ------------------ 1375| | 1376| 0| static absl::string_view feature_set_name = "google.protobuf.FeatureSet"; 1377| 0| const Descriptor* feature_set = 1378| 0| pool_->FindMessageTypeByName(feature_set_name); 1379| | 1380| 0| bool has_errors = false; 1381| 0| for (const auto& it : lifetimes_info_map_) { ------------------ | Branch (1381:25): [True: 0, False: 0] ------------------ 1382| 0| const FileDescriptor* file = it.first; 1383| | 1384| 0| for (const auto& info : it.second) { ------------------ | Branch (1384:29): [True: 0, False: 0] ------------------ 1385| 0| auto results = FeatureResolver::ValidateFeatureLifetimes( 1386| 0| file->edition(), *info.proto_features, feature_set); 1387| 0| for (const auto& error : results.errors) { ------------------ | Branch (1387:32): [True: 0, False: 0] ------------------ 1388| 0| has_errors = true; 1389| 0| if (error_collector_ == nullptr) { ------------------ | Branch (1389:15): [True: 0, False: 0] ------------------ 1390| 0| ABSL_LOG(ERROR) ------------------ | | 38| 0|#define ABSL_LOG(severity) ABSL_LOG_INTERNAL_LOG_IMPL(_##severity) | | ------------------ | | | | 25| 0| ABSL_LOG_INTERNAL_CONDITION##severity(STATELESS, true) \ | | | | ------------------ | | | | | | 170| 0| ABSL_LOG_INTERNAL_##type##_CONDITION(condition) | | | | | | ------------------ | | | | | | | | 65| 0| switch (0) \ | | | | | | | | 66| 0| case 0: \ | | | | | | | | ------------------ | | | | | | | | | Branch (66:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 67| 0| default: \ | | | | | | | | ------------------ | | | | | | | | | Branch (67:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 68| 0| !(condition) ? (void)0 : ::absl::log_internal::Voidify()&& | | | | | | | | ------------------ | | | | | | | | | Branch (68:5): [Folded, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 26| 0| ABSL_LOGGING_INTERNAL_LOG##severity.InternalStream() | | | | ------------------ | | | | | | 52| 0| ::absl::log_internal::LogMessage( \ | | | | | | 53| 0| __FILE__, __LINE__, ::absl::log_internal::LogMessage::ErrorTag{}) | | | | ------------------ | | ------------------ ------------------ 1391| 0| << info.filename << " " << info.full_name << ": " << error; 1392| 0| } else { 1393| 0| error_collector_->RecordError( 1394| 0| info.filename, info.full_name, info.proto, 1395| 0| DescriptorPool::ErrorCollector::NAME, error); 1396| 0| } 1397| 0| } 1398| 0| if (pool_->direct_input_files_.find(file->name()) != ------------------ | Branch (1398:13): [True: 0, False: 0] ------------------ 1399| 0| pool_->direct_input_files_.end()) { 1400| 0| for (const auto& warning : results.warnings) { ------------------ | Branch (1400:36): [True: 0, False: 0] ------------------ 1401| 0| if (error_collector_ == nullptr) { ------------------ | Branch (1401:17): [True: 0, False: 0] ------------------ 1402| 0| ABSL_LOG(WARNING) ------------------ | | 38| 0|#define ABSL_LOG(severity) ABSL_LOG_INTERNAL_LOG_IMPL(_##severity) | | ------------------ | | | | 25| 0| ABSL_LOG_INTERNAL_CONDITION##severity(STATELESS, true) \ | | | | ------------------ | | | | | | 168| 0| ABSL_LOG_INTERNAL_##type##_CONDITION(condition) | | | | | | ------------------ | | | | | | | | 65| 0| switch (0) \ | | | | | | | | 66| 0| case 0: \ | | | | | | | | ------------------ | | | | | | | | | Branch (66:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 67| 0| default: \ | | | | | | | | ------------------ | | | | | | | | | Branch (67:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 68| 0| !(condition) ? (void)0 : ::absl::log_internal::Voidify()&& | | | | | | | | ------------------ | | | | | | | | | Branch (68:5): [Folded, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 26| 0| ABSL_LOGGING_INTERNAL_LOG##severity.InternalStream() | | | | ------------------ | | | | | | 49| 0| ::absl::log_internal::LogMessage( \ | | | | | | 50| 0| __FILE__, __LINE__, ::absl::log_internal::LogMessage::WarningTag{}) | | | | ------------------ | | ------------------ ------------------ 1403| 0| << info.filename << " " << info.full_name << ": " << warning; 1404| 0| } else { 1405| 0| error_collector_->RecordWarning( 1406| 0| info.filename, info.full_name, info.proto, 1407| 0| DescriptorPool::ErrorCollector::NAME, warning); 1408| 0| } 1409| 0| } 1410| 0| } 1411| 0| } 1412| 0| } 1413| 0| lifetimes_info_map_.clear(); 1414| 0| return !has_errors; 1415| 0| } _ZN6google8protobuf14DescriptorPool18DeferredValidationD2Ev: 1344| 5| ~DeferredValidation() { 1345| 10| ABSL_CHECK(lifetimes_info_map_.empty()) ------------------ | | 41| 5| ABSL_LOG_INTERNAL_CHECK_IMPL((condition), #condition) | | ------------------ | | | | 26| 0| ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS, \ | | | | ------------------ | | | | | | 172| 5| ABSL_LOG_INTERNAL_##type##_CONDITION(condition) | | | | | | ------------------ | | | | | | | | 65| 10| switch (0) \ | | | | | | | | 66| 10| case 0: \ | | | | | | | | ------------------ | | | | | | | | | Branch (66:3): [True: 5, False: 0] | | | | | | | | ------------------ | | | | | | | | 67| 5| default: \ | | | | | | | | ------------------ | | | | | | | | | Branch (67:3): [True: 0, False: 5] | | | | | | | | ------------------ | | | | | | | | 68| 10| !(condition) ? (void)0 : ::absl::log_internal::Voidify()&& | | | | | | | | ------------------ | | | | | | | | | Branch (68:5): [True: 5, False: 0] | | | | | | | | | Branch (68:7): [Folded, False: 5] | | | | | | | | | Branch (68:7): [True: 0, False: 5] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 27| 0| ABSL_PREDICT_FALSE(!(condition))) \ | | | | 28| 5| ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream() | | | | ------------------ | | | | | | 66| 5| ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message) | | | | ------------------ | | ------------------ ------------------ 1346| 10| << "DeferredValidation destroyed with unvalidated features"; 1347| 5| } _ZNK6google8protobuf6Symbol16field_descriptorEv: 622| 128k| const TYPE* FIELD() const { \ 623| 128k| return type() == TYPE_CONSTANT ? static_cast(ptr_) : nullptr; \ ------------------ | Branch (623:12): [True: 128k, False: 72] ------------------ 624| 128k| } descriptor.cc:_ZN6google8protobuf12_GLOBAL__N_19RoundUpToILi8EEEmm: 162| 960|constexpr size_t RoundUpTo(size_t n) { 163| 960| static_assert((R & (R - 1)) == 0, "Must be power of two"); 164| 960| return (n + (R - 1)) & ~(R - 1); 165| 960|} _ZNK6google8protobuf14DescriptorPool6Tables8FindFileENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEE: 1745| 14| absl::string_view key) const { 1746| 14| auto it = files_by_name_.find(key); 1747| 14| if (it == files_by_name_.end()) return nullptr; ------------------ | Branch (1747:7): [True: 8, False: 6] ------------------ 1748| 6| return *it; 1749| 14|} descriptor.cc:_ZNK6google8protobuf12_GLOBAL__N_119DescriptorsByNameEqINS0_14FileDescriptorEEclEPKS3_NSt3__117basic_string_viewIcNS7_11char_traitsIcEEEE: 1011| 6| bool operator()(const DescriptorT* lhs, absl::string_view rhs) const { 1012| 6| return lhs->name() == rhs; 1013| 6| } descriptor.cc:_ZNK6google8protobuf12_GLOBAL__N_121DescriptorsByNameHashINS0_14FileDescriptorEEclENSt3__117basic_string_viewIcNS5_11char_traitsIcEEEE: 994| 14| size_t operator()(absl::string_view name) const { return absl::HashOf(name); } descriptor.cc:_ZN6google8protobuf12_GLOBAL__N_117GeneratedDatabaseEv: 2186| 8|EncodedDescriptorDatabase* GeneratedDatabase() { 2187| 8| static auto generated_database = 2188| 8| internal::OnShutdownDelete(new EncodedDescriptorDatabase()); 2189| 8| return generated_database; 2190| 8|} descriptor.cc:_ZN6google8protobuf12_GLOBAL__N_116NewGeneratedPoolEv: 2192| 2|DescriptorPool* NewGeneratedPool() { 2193| 2| auto generated_pool = new DescriptorPool(GeneratedDatabase()); 2194| 2| generated_pool->InternalSetLazilyBuildDependencies(); 2195| 2| return generated_pool; 2196| 2|} _ZNK6google8protobuf6Symbol7GetFileEv: 682| 189| const FileDescriptor* GetFile() const { 683| 189| switch (type()) { 684| 143| case MESSAGE: ------------------ | Branch (684:7): [True: 143, False: 46] ------------------ 685| 143| return descriptor()->file(); 686| 2| case FIELD: ------------------ | Branch (686:7): [True: 2, False: 187] ------------------ 687| 2| return field_descriptor()->file(); 688| 0| case ONEOF: ------------------ | Branch (688:7): [True: 0, False: 189] ------------------ 689| 0| return oneof_descriptor()->containing_type()->file(); 690| 26| case ENUM: ------------------ | Branch (690:7): [True: 26, False: 163] ------------------ 691| 26| return enum_descriptor()->file(); 692| 18| case ENUM_VALUE: ------------------ | Branch (692:7): [True: 18, False: 171] ------------------ 693| 18| return enum_value_descriptor()->type()->file(); 694| 0| case SERVICE: ------------------ | Branch (694:7): [True: 0, False: 189] ------------------ 695| 0| return service_descriptor()->file(); 696| 0| case METHOD: ------------------ | Branch (696:7): [True: 0, False: 189] ------------------ 697| 0| return method_descriptor()->service()->file(); 698| 0| case FULL_PACKAGE: ------------------ | Branch (698:7): [True: 0, False: 189] ------------------ 699| 0| return file_descriptor(); 700| 0| case SUB_PACKAGE: ------------------ | Branch (700:7): [True: 0, False: 189] ------------------ 701| 0| return sub_package_file_descriptor()->file; 702| 0| default: ------------------ | Branch (702:7): [True: 0, False: 189] ------------------ 703| 0| return nullptr; 704| 189| } 705| 189| } _ZNK6google8protobuf6Symbol10descriptorEv: 622| 568| const TYPE* FIELD() const { \ 623| 568| return type() == TYPE_CONSTANT ? static_cast(ptr_) : nullptr; \ ------------------ | Branch (623:12): [True: 568, False: 0] ------------------ 624| 568| } _ZNK6google8protobuf6Symbol16oneof_descriptorEv: 622| 10| const TYPE* FIELD() const { \ 623| 10| return type() == TYPE_CONSTANT ? static_cast(ptr_) : nullptr; \ ------------------ | Branch (623:12): [True: 10, False: 0] ------------------ 624| 10| } _ZNK6google8protobuf6Symbol15enum_descriptorEv: 622| 173| const TYPE* FIELD() const { \ 623| 173| return type() == TYPE_CONSTANT ? static_cast(ptr_) : nullptr; \ ------------------ | Branch (623:12): [True: 173, False: 0] ------------------ 624| 173| } _ZNK6google8protobuf6Symbol21enum_value_descriptorEv: 660| 882| const EnumValueDescriptor* enum_value_descriptor() const { 661| 882| return type() == ENUM_VALUE ------------------ | Branch (661:12): [True: 550, False: 332] ------------------ 662| 882| ? static_cast( 663| 550| static_cast*>(ptr_)) 664| 882| : type() == ENUM_VALUE_OTHER_PARENT ------------------ | Branch (664:14): [True: 332, False: 0] ------------------ 665| 332| ? static_cast( 666| 332| static_cast*>(ptr_)) 667| 332| : nullptr; 668| 882| } descriptor.cc:_ZN6google8protobuf12_GLOBAL__N_120ObjectToParentNumberEPKNS0_15FieldDescriptorE: 1031| 206|std::pair ObjectToParentNumber(const FieldDescriptor* field) { 1032| 206| return {field->containing_type(), field->number()}; 1033| 206|} _ZNK6google8protobuf20FileDescriptorTables16FindNestedSymbolEPKvNSt3__117basic_string_viewIcNS4_11char_traitsIcEEEE: 1699| 63.5k| const void* parent, absl::string_view name) const { 1700| 63.5k| auto it = symbols_by_parent_.find(ParentNameQuery{{parent, name}}); 1701| 63.5k| return it == symbols_by_parent_.end() ? Symbol() : *it; ------------------ | Branch (1701:10): [True: 72, False: 63.4k] ------------------ 1702| 63.5k|} descriptor.cc:_ZNK6google8protobuf12_GLOBAL__N_116SymbolByParentEqclINS0_6SymbolENS1_15ParentNameQueryEEEbRKT_RKT0_: 983| 63.4k| bool operator()(const T& a, const U& b) const { 984| 63.4k| return a.parent_name_key() == b.parent_name_key(); 985| 63.4k| } _ZNK6google8protobuf6Symbol15parent_name_keyEv: 734| 64.4k| std::pair parent_name_key() const { 735| 64.4k| const auto or_file = [&](const void* p) { return p ? p : GetFile(); }; 736| 64.4k| switch (type()) { 737| 96| case MESSAGE: ------------------ | Branch (737:7): [True: 96, False: 64.3k] ------------------ 738| 96| return {or_file(descriptor()->containing_type()), descriptor()->name()}; 739| 64.0k| case FIELD: { ------------------ | Branch (739:7): [True: 64.0k, False: 471] ------------------ 740| 64.0k| auto* field = field_descriptor(); 741| 64.0k| return {or_file(field->is_extension() ? field->extension_scope() ------------------ | Branch (741:25): [True: 2, False: 64.0k] ------------------ 742| 64.0k| : field->containing_type()), 743| 64.0k| field->name()}; 744| 0| } 745| 4| case ONEOF: ------------------ | Branch (745:7): [True: 4, False: 64.4k] ------------------ 746| 4| return {oneof_descriptor()->containing_type(), 747| 4| oneof_descriptor()->name()}; 748| 32| case ENUM: ------------------ | Branch (748:7): [True: 32, False: 64.4k] ------------------ 749| 32| return {or_file(enum_descriptor()->containing_type()), 750| 32| enum_descriptor()->name()}; 751| 173| case ENUM_VALUE: ------------------ | Branch (751:7): [True: 173, False: 64.3k] ------------------ 752| 173| return {or_file(enum_value_descriptor()->type()->containing_type()), 753| 173| enum_value_descriptor()->name()}; 754| 166| case ENUM_VALUE_OTHER_PARENT: ------------------ | Branch (754:7): [True: 166, False: 64.3k] ------------------ 755| 166| return {enum_value_descriptor()->type(), 756| 166| enum_value_descriptor()->name()}; 757| 0| case SERVICE: ------------------ | Branch (757:7): [True: 0, False: 64.4k] ------------------ 758| 0| return {GetFile(), service_descriptor()->name()}; 759| 0| case METHOD: ------------------ | Branch (759:7): [True: 0, False: 64.4k] ------------------ 760| 0| return {method_descriptor()->service(), method_descriptor()->name()}; 761| 0| default: ------------------ | Branch (761:7): [True: 0, False: 64.4k] ------------------ 762| 0| ABSL_CHECK(false); ------------------ | | 41| 0| ABSL_LOG_INTERNAL_CHECK_IMPL((condition), #condition) | | ------------------ | | | | 26| 0| ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS, \ | | | | ------------------ | | | | | | 172| 0| ABSL_LOG_INTERNAL_##type##_CONDITION(condition) | | | | | | ------------------ | | | | | | | | 65| 0| switch (0) \ | | | | | | | | 66| 0| case 0: \ | | | | | | | | ------------------ | | | | | | | | | Branch (66:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 67| 0| default: \ | | | | | | | | ------------------ | | | | | | | | | Branch (67:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 68| 0| !(condition) ? (void)0 : ::absl::log_internal::Voidify()&& | | | | | | | | ------------------ | | | | | | | | | Branch (68:5): [Folded, False: 0] | | | | | | | | | Branch (68:7): [Folded, False: 0] | | | | | | | | | Branch (68:7): [True: 0, Folded] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 27| 0| ABSL_PREDICT_FALSE(!(condition))) \ | | | | 28| 0| ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream() | | | | ------------------ | | | | | | 66| 0| ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message) | | | | ------------------ | | ------------------ ------------------ 763| 64.4k| } 764| 0| return {}; 765| 64.4k| } _ZZNK6google8protobuf6Symbol15parent_name_keyEvENKUlPKvE_clES3_: 735| 64.3k| const auto or_file = [&](const void* p) { return p ? p : GetFile(); }; ------------------ | Branch (735:54): [True: 64.2k, False: 91] ------------------ descriptor.cc:_ZNK6google8protobuf12_GLOBAL__N_115ParentNameQuery15parent_name_keyEv: 967| 127k| std::pair parent_name_key() const { 968| 127k| return query; 969| 127k| } descriptor.cc:_ZNK6google8protobuf12_GLOBAL__N_118SymbolByParentHashclINS1_15ParentNameQueryEEEmRKT_: 975| 63.5k| size_t operator()(const T& s) const { 976| 63.5k| return absl::HashOf(s.parent_name_key()); 977| 63.5k| } descriptor.cc:_ZN6google8protobuf12_GLOBAL__N_120ObjectToParentNumberEPKNS0_19EnumValueDescriptorE: 1035| 29| const EnumValueDescriptor* enum_value) { 1036| 29| return {enum_value->type(), enum_value->number()}; 1037| 29|} descriptor.cc:_ZN6google8protobuf12_GLOBAL__N_117FlatAllocatorImplIJcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE13AllocateArrayIS9_EEPT_i: 400| 367| U* AllocateArray(int array_size) { 401| 367| constexpr bool trivial = std::is_trivially_destructible::value; 402| 367| using TypeToUse = typename std::conditional::type; 403| | 404| | // We can only allocate after FinalizePlanning has been called. 405| 367| ABSL_CHECK(has_allocated()); ------------------ | | 41| 367| ABSL_LOG_INTERNAL_CHECK_IMPL((condition), #condition) | | ------------------ | | | | 26| 734| ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS, \ | | | | ------------------ | | | | | | 172| 367| ABSL_LOG_INTERNAL_##type##_CONDITION(condition) | | | | | | ------------------ | | | | | | | | 65| 734| switch (0) \ | | | | | | | | 66| 734| case 0: \ | | | | | | | | ------------------ | | | | | | | | | Branch (66:3): [True: 367, False: 0] | | | | | | | | ------------------ | | | | | | | | 67| 367| default: \ | | | | | | | | ------------------ | | | | | | | | | Branch (67:3): [True: 0, False: 367] | | | | | | | | ------------------ | | | | | | | | 68| 734| !(condition) ? (void)0 : ::absl::log_internal::Voidify()&& | | | | | | | | ------------------ | | | | | | | | | Branch (68:5): [True: 367, False: 0] | | | | | | | | | Branch (68:7): [Folded, False: 367] | | | | | | | | | Branch (68:7): [True: 0, False: 367] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 27| 734| ABSL_PREDICT_FALSE(!(condition))) \ | | | | 28| 734| ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream() | | | | ------------------ | | | | | | 66| 0| ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message) | | | | ------------------ | | ------------------ ------------------ 406| | 407| 367| TypeToUse*& data = pointers_.template Get(); 408| 367| int& used = used_.template Get(); 409| 367| U* res = reinterpret_cast(data + used); 410| 367| used += trivial ? RoundUpTo<8>(array_size * sizeof(U)) : array_size; ------------------ | Branch (410:13): [Folded, False: 367] ------------------ 411| 367| ABSL_CHECK_LE(used, total_.template Get()); ------------------ | | 54| 367| ABSL_LOG_INTERNAL_CHECK_LE_IMPL((val1), #val1, (val2), #val2) | | ------------------ | | | | 52| 367| ABSL_LOG_INTERNAL_CHECK_OP(Check_LE, <=, val1, val1_text, val2, val2_text) | | | | ------------------ | | | | | | 61| 367| while ( \ | | | | | | 62| 367| ::std::string* absl_log_internal_check_op_result ABSL_ATTRIBUTE_UNUSED = \ | | | | | | ------------------ | | | | | | | Branch (62:22): [True: 0, False: 367] | | | | | | ------------------ | | | | | | 63| 367| ::absl::log_internal::name##Impl( \ | | | | | | 64| 367| ::absl::log_internal::GetReferenceableValue(val1), \ | | | | | | 65| 367| ::absl::log_internal::GetReferenceableValue(val2), \ | | | | | | 66| 367| ABSL_LOG_INTERNAL_STRIP_STRING_LITERAL(val1_text \ | | | | | | 67| 367| " " #op " " val2_text))) \ | | | | | | 68| 367| ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS, true) \ | | | | | | ------------------ | | | | | | | | 172| 0| ABSL_LOG_INTERNAL_##type##_CONDITION(condition) | | | | | | | | ------------------ | | | | | | | | | | 65| 0| switch (0) \ | | | | | | | | | | 66| 0| case 0: \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (66:3): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 67| 0| default: \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (67:3): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 68| 0| !(condition) ? (void)0 : ::absl::log_internal::Voidify()&& | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (68:5): [Folded, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 69| 0| ABSL_LOG_INTERNAL_CHECK(*absl_log_internal_check_op_result).InternalStream() | | | | | | ------------------ | | | | | | | | 66| 0| ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 412| 367| return res; 413| 367| } descriptor.cc:_ZNK6google8protobuf12_GLOBAL__N_117FlatAllocatorImplIJcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE13has_allocatedEv: 541| 2.16k| bool has_allocated() const { 542| 2.16k| return pointers_.template Get() != nullptr; 543| 2.16k| } descriptor.cc:_ZNK6google8protobuf12_GLOBAL__N_17TypeMapINS1_8PointerTEJcNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE3GetIcEERKPT_v: 243| 2.16k| const ValueT& Get() const { 244| 2.16k| return static_cast&>(payload_).value; 245| 2.16k| } descriptor.cc:_ZN6google8protobuf12_GLOBAL__N_17TypeMapINS1_8PointerTEJcNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE3GetISA_EERPT_v: 238| 371| ValueT& Get() { 239| 371| return static_cast&>(payload_).value; 240| 371| } descriptor.cc:_ZN6google8protobuf12_GLOBAL__N_17TypeMapINS1_4IntTEJcNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE3GetISA_EERiv: 238| 1.18k| ValueT& Get() { 239| 1.18k| return static_cast&>(payload_).value; 240| 1.18k| } descriptor.cc:_ZN6google8protobuf12_GLOBAL__N_14FoldESt16initializer_listINS1_15ExpressionEaterEE: 159| 387|void Fold(std::initializer_list) {} descriptor.cc:_ZN6google8protobuf12_GLOBAL__N_115ExpressionEaterC2IRNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEOT_: 157| 820| ExpressionEater(T&&) {} // NOLINT _ZN6google8protobuf14DescriptorPool18DeferredValidation11CreateProtoEv: 1368| 4| FileDescriptorProto& CreateProto() { 1369| 4| owned_protos_.push_back(Arena::Create(&arena_)); 1370| 4| return *owned_protos_.back(); 1371| 4| } descriptor.cc:_ZZNK6google8protobuf14DescriptorPool29TryFindFileInFallbackDatabaseENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEERNS1_18DeferredValidationEENK3$_0clERNS0_18DescriptorDatabaseES6_RNS0_19FileDescriptorProtoE: 2711| 4| FileDescriptorProto& output) PROTOBUF_NOINLINE { 2712| 4| return database.FindFileByName(std::string(filename), &output); 2713| 4| }; _ZNK6google8protobuf6Symbol9IsPackageEv: 678| 98| bool IsPackage() const { 679| 98| return type() == FULL_PACKAGE || type() == SUB_PACKAGE; ------------------ | Branch (679:12): [True: 1, False: 97] | Branch (679:38): [True: 0, False: 97] ------------------ 680| 98| } descriptor.cc:_ZN6google8protobuf12_GLOBAL__N_115IsLegacyEditionENS0_7EditionE: 1198| 581|bool IsLegacyEdition(Edition edition) { 1199| 581| return edition < Edition::EDITION_2023; 1200| 581|} _ZN6google8protobuf17DescriptorBuilder3NewEPKNS0_14DescriptorPoolEPNS2_6TablesERNS2_18DeferredValidationEPNS2_14ErrorCollectorE: 4159| 4| DescriptorPool::ErrorCollector* error_collector) { 4160| 4| return std::unique_ptr(new DescriptorBuilder( 4161| 4| pool, tables, deferred_validation, error_collector)); 4162| 4| } descriptor.cc:_ZZNK6google8protobuf14DescriptorPool21BuildFileFromDatabaseERKNS0_19FileDescriptorProtoERNS1_18DeferredValidationEENK3$_0clEv: 4747| 4| const auto build_file = [&] { 4748| 4| result = DescriptorBuilder::New(this, tables_.get(), deferred_validation, 4749| 4| default_error_collector_) 4750| 4| ->BuildFile(proto); 4751| 4| }; _ZN6google8protobuf6SymbolC2EPNS0_14EnumDescriptorE: 619| 18| explicit Symbol(TYPE* value) : ptr_(value) { \ 620| 18| value->symbol_type_ = TYPE_CONSTANT; \ 621| 18| } \ _ZN6google8protobuf6SymbolC2EPNS0_10DescriptorE: 619| 45| explicit Symbol(TYPE* value) : ptr_(value) { \ 620| 45| value->symbol_type_ = TYPE_CONSTANT; \ 621| 45| } \ _ZN6google8protobuf6SymbolC2EPNS0_14FileDescriptorE: 619| 3| explicit Symbol(TYPE* value) : ptr_(value) { \ 620| 3| value->symbol_type_ = TYPE_CONSTANT; \ 621| 3| } \ _ZN6google8protobuf6SymbolC2EPNS1_10SubpackageE: 619| 2| explicit Symbol(TYPE* value) : ptr_(value) { \ 620| 2| value->symbol_type_ = TYPE_CONSTANT; \ 621| 2| } \ descriptor.cc:_ZN6google8protobufL18PlanAllocationSizeERKNS0_19FileDescriptorProtoERNS0_8internal13FlatAllocatorE: 5798| 4| internal::FlatAllocator& alloc) { 5799| 4| alloc.PlanArray(1); 5800| 4| alloc.PlanArray(1); 5801| 4| alloc.PlanArray(2); // name + package 5802| 4| if (proto.has_options()) alloc.PlanArray(1); ------------------ | Branch (5802:7): [True: 2, False: 2] ------------------ 5803| 4| if (proto.has_source_code_info()) alloc.PlanArray(1); ------------------ | Branch (5803:7): [True: 0, False: 4] ------------------ 5804| | 5805| 4| PlanAllocationSize(proto.service(), alloc); 5806| 4| PlanAllocationSize(proto.message_type(), alloc); 5807| 4| PlanAllocationSize(proto.enum_type(), alloc); 5808| 4| PlanAllocationSize(proto.extension(), alloc); 5809| | 5810| 4| alloc.PlanArray(proto.weak_dependency_size()); 5811| 4| alloc.PlanArray(proto.public_dependency_size()); 5812| 4| alloc.PlanArray(proto.dependency_size()); 5813| 4|} descriptor.cc:_ZN6google8protobuf12_GLOBAL__N_117FlatAllocatorImplIJcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE9PlanArrayISB_EEvi: 382| 4| void PlanArray(int array_size) { 383| | // We can't call PlanArray after FinalizePlanning has been called. 384| 4| ABSL_CHECK(!has_allocated()); ------------------ | | 41| 4| ABSL_LOG_INTERNAL_CHECK_IMPL((condition), #condition) | | ------------------ | | | | 26| 8| ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS, \ | | | | ------------------ | | | | | | 172| 4| ABSL_LOG_INTERNAL_##type##_CONDITION(condition) | | | | | | ------------------ | | | | | | | | 65| 8| switch (0) \ | | | | | | | | 66| 8| case 0: \ | | | | | | | | ------------------ | | | | | | | | | Branch (66:3): [True: 4, False: 0] | | | | | | | | ------------------ | | | | | | | | 67| 4| default: \ | | | | | | | | ------------------ | | | | | | | | | Branch (67:3): [True: 0, False: 4] | | | | | | | | ------------------ | | | | | | | | 68| 8| !(condition) ? (void)0 : ::absl::log_internal::Voidify()&& | | | | | | | | ------------------ | | | | | | | | | Branch (68:5): [True: 4, False: 0] | | | | | | | | | Branch (68:7): [Folded, False: 4] | | | | | | | | | Branch (68:7): [True: 0, False: 4] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 27| 8| ABSL_PREDICT_FALSE(!(condition))) \ | | | | 28| 8| ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream() | | | | ------------------ | | | | | | 66| 0| ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message) | | | | ------------------ | | ------------------ ------------------ 385| 4| if (std::is_trivially_destructible::value) { ------------------ | Branch (385:9): [Folded, False: 4] ------------------ 386| | // Trivial types are aligned to 8 bytes. 387| 0| static_assert(alignof(U) <= 8, ""); 388| 0| total_.template Get() += RoundUpTo<8>(array_size * sizeof(U)); 389| 4| } else { 390| | // Since we can't use `if constexpr`, just make the expression compile 391| | // when this path is not taken. 392| 4| using TypeToUse = 393| 4| typename std::conditional::value, 394| 4| char, U>::type; 395| 4| total_.template Get() += array_size; 396| 4| } 397| 4| } descriptor.cc:_ZN6google8protobuf12_GLOBAL__N_17TypeMapINS1_4IntTEJcNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE3GetISC_EERiv: 238| 20| ValueT& Get() { 239| 20| return static_cast&>(payload_).value; 240| 20| } descriptor.cc:_ZN6google8protobuf12_GLOBAL__N_117FlatAllocatorImplIJcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE9PlanArrayISL_EEvi: 382| 2| void PlanArray(int array_size) { 383| | // We can't call PlanArray after FinalizePlanning has been called. 384| 2| ABSL_CHECK(!has_allocated()); ------------------ | | 41| 2| ABSL_LOG_INTERNAL_CHECK_IMPL((condition), #condition) | | ------------------ | | | | 26| 4| ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS, \ | | | | ------------------ | | | | | | 172| 2| ABSL_LOG_INTERNAL_##type##_CONDITION(condition) | | | | | | ------------------ | | | | | | | | 65| 4| switch (0) \ | | | | | | | | 66| 4| case 0: \ | | | | | | | | ------------------ | | | | | | | | | Branch (66:3): [True: 2, False: 0] | | | | | | | | ------------------ | | | | | | | | 67| 2| default: \ | | | | | | | | ------------------ | | | | | | | | | Branch (67:3): [True: 0, False: 2] | | | | | | | | ------------------ | | | | | | | | 68| 4| !(condition) ? (void)0 : ::absl::log_internal::Voidify()&& | | | | | | | | ------------------ | | | | | | | | | Branch (68:5): [True: 2, False: 0] | | | | | | | | | Branch (68:7): [Folded, False: 2] | | | | | | | | | Branch (68:7): [True: 0, False: 2] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 27| 4| ABSL_PREDICT_FALSE(!(condition))) \ | | | | 28| 4| ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream() | | | | ------------------ | | | | | | 66| 0| ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message) | | | | ------------------ | | ------------------ ------------------ 385| 2| if (std::is_trivially_destructible::value) { ------------------ | Branch (385:9): [Folded, False: 2] ------------------ 386| | // Trivial types are aligned to 8 bytes. 387| 0| static_assert(alignof(U) <= 8, ""); 388| 0| total_.template Get() += RoundUpTo<8>(array_size * sizeof(U)); 389| 2| } else { 390| | // Since we can't use `if constexpr`, just make the expression compile 391| | // when this path is not taken. 392| 2| using TypeToUse = 393| 2| typename std::conditional::value, 394| 2| char, U>::type; 395| 2| total_.template Get() += array_size; 396| 2| } 397| 2| } descriptor.cc:_ZN6google8protobuf12_GLOBAL__N_17TypeMapINS1_4IntTEJcNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE3GetISM_EERiv: 238| 18| ValueT& Get() { 239| 18| return static_cast&>(payload_).value; 240| 18| } descriptor.cc:_ZN6google8protobuf12_GLOBAL__N_17TypeMapINS1_4IntTEJcNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE3GetISB_EERiv: 238| 8| ValueT& Get() { 239| 8| return static_cast&>(payload_).value; 240| 8| } descriptor.cc:_ZN6google8protobufL18PlanAllocationSizeERKNS0_16RepeatedPtrFieldINS0_22ServiceDescriptorProtoEEERNS0_8internal13FlatAllocatorE: 5788| 4| internal::FlatAllocator& alloc) { 5789| 4| alloc.PlanArray(services.size()); 5790| 4| alloc.PlanArray(2 * services.size()); // name + full_name 5791| 4| for (const auto& service : services) { ------------------ | Branch (5791:28): [True: 0, False: 4] ------------------ 5792| 0| if (service.has_options()) alloc.PlanArray(1); ------------------ | Branch (5792:9): [True: 0, False: 0] ------------------ 5793| 0| PlanAllocationSize(service.method(), alloc); 5794| 0| } 5795| 4|} descriptor.cc:_ZN6google8protobuf12_GLOBAL__N_117FlatAllocatorImplIJcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE9PlanArrayINS0_17ServiceDescriptorEEEvi: 382| 4| void PlanArray(int array_size) { 383| | // We can't call PlanArray after FinalizePlanning has been called. 384| 4| ABSL_CHECK(!has_allocated()); ------------------ | | 41| 4| ABSL_LOG_INTERNAL_CHECK_IMPL((condition), #condition) | | ------------------ | | | | 26| 8| ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS, \ | | | | ------------------ | | | | | | 172| 4| ABSL_LOG_INTERNAL_##type##_CONDITION(condition) | | | | | | ------------------ | | | | | | | | 65| 8| switch (0) \ | | | | | | | | 66| 8| case 0: \ | | | | | | | | ------------------ | | | | | | | | | Branch (66:3): [True: 4, False: 0] | | | | | | | | ------------------ | | | | | | | | 67| 4| default: \ | | | | | | | | ------------------ | | | | | | | | | Branch (67:3): [True: 0, False: 4] | | | | | | | | ------------------ | | | | | | | | 68| 8| !(condition) ? (void)0 : ::absl::log_internal::Voidify()&& | | | | | | | | ------------------ | | | | | | | | | Branch (68:5): [True: 4, False: 0] | | | | | | | | | Branch (68:7): [Folded, False: 4] | | | | | | | | | Branch (68:7): [True: 0, False: 4] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 27| 8| ABSL_PREDICT_FALSE(!(condition))) \ | | | | 28| 8| ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream() | | | | ------------------ | | | | | | 66| 0| ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message) | | | | ------------------ | | ------------------ ------------------ 385| 4| if (std::is_trivially_destructible::value) { ------------------ | Branch (385:9): [True: 4, Folded] ------------------ 386| | // Trivial types are aligned to 8 bytes. 387| 4| static_assert(alignof(U) <= 8, ""); 388| 4| total_.template Get() += RoundUpTo<8>(array_size * sizeof(U)); 389| 4| } else { 390| | // Since we can't use `if constexpr`, just make the expression compile 391| | // when this path is not taken. 392| 0| using TypeToUse = 393| 0| typename std::conditional::value, 394| 0| char, U>::type; 395| 0| total_.template Get() += array_size; 396| 0| } 397| 4| } descriptor.cc:_ZN6google8protobuf12_GLOBAL__N_17TypeMapINS1_4IntTEJcNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE3GetIcEERiv: 238| 1.34k| ValueT& Get() { 239| 1.34k| return static_cast&>(payload_).value; 240| 1.34k| } descriptor.cc:_ZN6google8protobuf12_GLOBAL__N_17TypeMapINS1_4IntTEJcNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE3GetISK_EERiv: 238| 8| ValueT& Get() { 239| 8| return static_cast&>(payload_).value; 240| 8| } descriptor.cc:_ZN6google8protobuf12_GLOBAL__N_17TypeMapINS1_4IntTEJcNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE3GetISL_EERiv: 238| 8| ValueT& Get() { 239| 8| return static_cast&>(payload_).value; 240| 8| } descriptor.cc:_ZN6google8protobufL18PlanAllocationSizeERKNS0_16RepeatedPtrFieldINS0_15DescriptorProtoEEERNS0_8internal13FlatAllocatorE: 5758| 49| internal::FlatAllocator& alloc) { 5759| 49| alloc.PlanArray(messages.size()); 5760| 49| alloc.PlanArray(2 * messages.size()); // name + full_name 5761| | 5762| 49| for (const auto& message : messages) { ------------------ | Branch (5762:28): [True: 45, False: 49] ------------------ 5763| 45| if (message.has_options()) alloc.PlanArray(1); ------------------ | Branch (5763:9): [True: 0, False: 45] ------------------ 5764| 45| PlanAllocationSize(message.nested_type(), alloc); 5765| 45| PlanAllocationSize(message.field(), alloc); 5766| 45| PlanAllocationSize(message.extension(), alloc); 5767| 45| PlanAllocationSize(message.extension_range(), alloc); 5768| 45| alloc.PlanArray(message.reserved_range_size()); 5769| 45| alloc.PlanArray(message.reserved_name_size()); 5770| 45| alloc.PlanArray(message.reserved_name_size()); 5771| 45| PlanAllocationSize(message.enum_type(), alloc); 5772| 45| PlanAllocationSize(message.oneof_decl(), alloc); 5773| 45| } 5774| 49|} descriptor.cc:_ZN6google8protobuf12_GLOBAL__N_17TypeMapINS1_4IntTEJcNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE3GetISE_EERiv: 238| 8| ValueT& Get() { 239| 8| return static_cast&>(payload_).value; 240| 8| } descriptor.cc:_ZN6google8protobufL18PlanAllocationSizeERKNS0_16RepeatedPtrFieldINS0_30DescriptorProto_ExtensionRangeEEERNS0_8internal13FlatAllocatorE: 5749| 45| internal::FlatAllocator& alloc) { 5750| 45| alloc.PlanArray(ranges.size()); 5751| 45| for (const auto& r : ranges) { ------------------ | Branch (5751:22): [True: 14, False: 45] ------------------ 5752| 14| if (r.has_options()) alloc.PlanArray(1); ------------------ | Branch (5752:9): [True: 0, False: 14] ------------------ 5753| 14| } 5754| 45|} descriptor.cc:_ZN6google8protobuf12_GLOBAL__N_17TypeMapINS1_4IntTEJcNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE3GetISI_EERiv: 238| 8| ValueT& Get() { 239| 8| return static_cast&>(payload_).value; 240| 8| } descriptor.cc:_ZN6google8protobuf12_GLOBAL__N_117FlatAllocatorImplIJcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE9PlanArrayINS0_10Descriptor13ReservedRangeEEEvi: 382| 45| void PlanArray(int array_size) { 383| | // We can't call PlanArray after FinalizePlanning has been called. 384| 45| ABSL_CHECK(!has_allocated()); ------------------ | | 41| 45| ABSL_LOG_INTERNAL_CHECK_IMPL((condition), #condition) | | ------------------ | | | | 26| 90| ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS, \ | | | | ------------------ | | | | | | 172| 45| ABSL_LOG_INTERNAL_##type##_CONDITION(condition) | | | | | | ------------------ | | | | | | | | 65| 90| switch (0) \ | | | | | | | | 66| 90| case 0: \ | | | | | | | | ------------------ | | | | | | | | | Branch (66:3): [True: 45, False: 0] | | | | | | | | ------------------ | | | | | | | | 67| 45| default: \ | | | | | | | | ------------------ | | | | | | | | | Branch (67:3): [True: 0, False: 45] | | | | | | | | ------------------ | | | | | | | | 68| 90| !(condition) ? (void)0 : ::absl::log_internal::Voidify()&& | | | | | | | | ------------------ | | | | | | | | | Branch (68:5): [True: 45, False: 0] | | | | | | | | | Branch (68:7): [Folded, False: 45] | | | | | | | | | Branch (68:7): [True: 0, False: 45] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 27| 90| ABSL_PREDICT_FALSE(!(condition))) \ | | | | 28| 90| ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream() | | | | ------------------ | | | | | | 66| 0| ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message) | | | | ------------------ | | ------------------ ------------------ 385| 45| if (std::is_trivially_destructible::value) { ------------------ | Branch (385:9): [True: 45, Folded] ------------------ 386| | // Trivial types are aligned to 8 bytes. 387| 45| static_assert(alignof(U) <= 8, ""); 388| 45| total_.template Get() += RoundUpTo<8>(array_size * sizeof(U)); 389| 45| } else { 390| | // Since we can't use `if constexpr`, just make the expression compile 391| | // when this path is not taken. 392| 0| using TypeToUse = 393| 0| typename std::conditional::value, 394| 0| char, U>::type; 395| 0| total_.template Get() += array_size; 396| 0| } 397| 45| } descriptor.cc:_ZN6google8protobuf12_GLOBAL__N_117FlatAllocatorImplIJcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE9PlanArrayIPKS9_EEvi: 382| 63| void PlanArray(int array_size) { 383| | // We can't call PlanArray after FinalizePlanning has been called. 384| 63| ABSL_CHECK(!has_allocated()); ------------------ | | 41| 63| ABSL_LOG_INTERNAL_CHECK_IMPL((condition), #condition) | | ------------------ | | | | 26| 126| ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS, \ | | | | ------------------ | | | | | | 172| 63| ABSL_LOG_INTERNAL_##type##_CONDITION(condition) | | | | | | ------------------ | | | | | | | | 65| 126| switch (0) \ | | | | | | | | 66| 126| case 0: \ | | | | | | | | ------------------ | | | | | | | | | Branch (66:3): [True: 63, False: 0] | | | | | | | | ------------------ | | | | | | | | 67| 63| default: \ | | | | | | | | ------------------ | | | | | | | | | Branch (67:3): [True: 0, False: 63] | | | | | | | | ------------------ | | | | | | | | 68| 126| !(condition) ? (void)0 : ::absl::log_internal::Voidify()&& | | | | | | | | ------------------ | | | | | | | | | Branch (68:5): [True: 63, False: 0] | | | | | | | | | Branch (68:7): [Folded, False: 63] | | | | | | | | | Branch (68:7): [True: 0, False: 63] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 27| 126| ABSL_PREDICT_FALSE(!(condition))) \ | | | | 28| 126| ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream() | | | | ------------------ | | | | | | 66| 0| ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message) | | | | ------------------ | | ------------------ ------------------ 385| 63| if (std::is_trivially_destructible::value) { ------------------ | Branch (385:9): [True: 63, Folded] ------------------ 386| | // Trivial types are aligned to 8 bytes. 387| 63| static_assert(alignof(U) <= 8, ""); 388| 63| total_.template Get() += RoundUpTo<8>(array_size * sizeof(U)); 389| 63| } else { 390| | // Since we can't use `if constexpr`, just make the expression compile 391| | // when this path is not taken. 392| 0| using TypeToUse = 393| 0| typename std::conditional::value, 394| 0| char, U>::type; 395| 0| total_.template Get() += array_size; 396| 0| } 397| 63| } descriptor.cc:_ZN6google8protobufL18PlanAllocationSizeERKNS0_16RepeatedPtrFieldINS0_20OneofDescriptorProtoEEERNS0_8internal13FlatAllocatorE: 5722| 45| internal::FlatAllocator& alloc) { 5723| 45| alloc.PlanArray(oneofs.size()); 5724| 45| alloc.PlanArray(2 * oneofs.size()); // name + full_name 5725| 45| for (const auto& oneof : oneofs) { ------------------ | Branch (5725:26): [True: 2, False: 45] ------------------ 5726| 2| if (oneof.has_options()) alloc.PlanArray(1); ------------------ | Branch (5726:9): [True: 0, False: 2] ------------------ 5727| 2| } 5728| 45|} descriptor.cc:_ZN6google8protobuf12_GLOBAL__N_117FlatAllocatorImplIJcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE9PlanArrayINS0_15OneofDescriptorEEEvi: 382| 45| void PlanArray(int array_size) { 383| | // We can't call PlanArray after FinalizePlanning has been called. 384| 45| ABSL_CHECK(!has_allocated()); ------------------ | | 41| 45| ABSL_LOG_INTERNAL_CHECK_IMPL((condition), #condition) | | ------------------ | | | | 26| 90| ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS, \ | | | | ------------------ | | | | | | 172| 45| ABSL_LOG_INTERNAL_##type##_CONDITION(condition) | | | | | | ------------------ | | | | | | | | 65| 90| switch (0) \ | | | | | | | | 66| 90| case 0: \ | | | | | | | | ------------------ | | | | | | | | | Branch (66:3): [True: 45, False: 0] | | | | | | | | ------------------ | | | | | | | | 67| 45| default: \ | | | | | | | | ------------------ | | | | | | | | | Branch (67:3): [True: 0, False: 45] | | | | | | | | ------------------ | | | | | | | | 68| 90| !(condition) ? (void)0 : ::absl::log_internal::Voidify()&& | | | | | | | | ------------------ | | | | | | | | | Branch (68:5): [True: 45, False: 0] | | | | | | | | | Branch (68:7): [Folded, False: 45] | | | | | | | | | Branch (68:7): [True: 0, False: 45] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 27| 90| ABSL_PREDICT_FALSE(!(condition))) \ | | | | 28| 90| ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream() | | | | ------------------ | | | | | | 66| 0| ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message) | | | | ------------------ | | ------------------ ------------------ 385| 45| if (std::is_trivially_destructible::value) { ------------------ | Branch (385:9): [True: 45, Folded] ------------------ 386| | // Trivial types are aligned to 8 bytes. 387| 45| static_assert(alignof(U) <= 8, ""); 388| 45| total_.template Get() += RoundUpTo<8>(array_size * sizeof(U)); 389| 45| } else { 390| | // Since we can't use `if constexpr`, just make the expression compile 391| | // when this path is not taken. 392| 0| using TypeToUse = 393| 0| typename std::conditional::value, 394| 0| char, U>::type; 395| 0| total_.template Get() += array_size; 396| 0| } 397| 45| } descriptor.cc:_ZN6google8protobuf12_GLOBAL__N_17TypeMapINS1_4IntTEJcNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE3GetISJ_EERiv: 238| 8| ValueT& Get() { 239| 8| return static_cast&>(payload_).value; 240| 8| } descriptor.cc:_ZN6google8protobufL18PlanAllocationSizeERKNS0_16RepeatedPtrFieldINS0_19EnumDescriptorProtoEEERNS0_8internal13FlatAllocatorE: 5708| 49| internal::FlatAllocator& alloc) { 5709| 49| alloc.PlanArray(enums.size()); 5710| 49| alloc.PlanArray(2 * enums.size()); // name + full_name 5711| 49| for (const auto& e : enums) { ------------------ | Branch (5711:22): [True: 18, False: 49] ------------------ 5712| 18| if (e.has_options()) alloc.PlanArray(1); ------------------ | Branch (5712:9): [True: 0, False: 18] ------------------ 5713| 18| PlanAllocationSize(e.value(), alloc); 5714| 18| alloc.PlanArray(e.reserved_range_size()); 5715| 18| alloc.PlanArray(e.reserved_name_size()); 5716| 18| alloc.PlanArray(e.reserved_name_size()); 5717| 18| } 5718| 49|} descriptor.cc:_ZN6google8protobuf12_GLOBAL__N_17TypeMapINS1_4IntTEJcNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE3GetISG_EERiv: 238| 8| ValueT& Get() { 239| 8| return static_cast&>(payload_).value; 240| 8| } descriptor.cc:_ZN6google8protobufL18PlanAllocationSizeERKNS0_16RepeatedPtrFieldINS0_24EnumValueDescriptorProtoEEERNS0_8internal13FlatAllocatorE: 5698| 18| internal::FlatAllocator& alloc) { 5699| 18| alloc.PlanArray(values.size()); 5700| 18| alloc.PlanArray(2 * values.size()); // name + full_name 5701| 86| for (const auto& v : values) { ------------------ | Branch (5701:22): [True: 86, False: 18] ------------------ 5702| 86| if (v.has_options()) alloc.PlanArray(1); ------------------ | Branch (5702:9): [True: 0, False: 86] ------------------ 5703| 86| } 5704| 18|} descriptor.cc:_ZN6google8protobuf12_GLOBAL__N_17TypeMapINS1_4IntTEJcNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE3GetISH_EERiv: 238| 8| ValueT& Get() { 239| 8| return static_cast&>(payload_).value; 240| 8| } descriptor.cc:_ZN6google8protobuf12_GLOBAL__N_117FlatAllocatorImplIJcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE9PlanArrayINS0_14EnumDescriptor13ReservedRangeEEEvi: 382| 18| void PlanArray(int array_size) { 383| | // We can't call PlanArray after FinalizePlanning has been called. 384| 18| ABSL_CHECK(!has_allocated()); ------------------ | | 41| 18| ABSL_LOG_INTERNAL_CHECK_IMPL((condition), #condition) | | ------------------ | | | | 26| 36| ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS, \ | | | | ------------------ | | | | | | 172| 18| ABSL_LOG_INTERNAL_##type##_CONDITION(condition) | | | | | | ------------------ | | | | | | | | 65| 36| switch (0) \ | | | | | | | | 66| 36| case 0: \ | | | | | | | | ------------------ | | | | | | | | | Branch (66:3): [True: 18, False: 0] | | | | | | | | ------------------ | | | | | | | | 67| 18| default: \ | | | | | | | | ------------------ | | | | | | | | | Branch (67:3): [True: 0, False: 18] | | | | | | | | ------------------ | | | | | | | | 68| 36| !(condition) ? (void)0 : ::absl::log_internal::Voidify()&& | | | | | | | | ------------------ | | | | | | | | | Branch (68:5): [True: 18, False: 0] | | | | | | | | | Branch (68:7): [Folded, False: 18] | | | | | | | | | Branch (68:7): [True: 0, False: 18] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 27| 36| ABSL_PREDICT_FALSE(!(condition))) \ | | | | 28| 36| ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream() | | | | ------------------ | | | | | | 66| 0| ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message) | | | | ------------------ | | ------------------ ------------------ 385| 18| if (std::is_trivially_destructible::value) { ------------------ | Branch (385:9): [True: 18, Folded] ------------------ 386| | // Trivial types are aligned to 8 bytes. 387| 18| static_assert(alignof(U) <= 8, ""); 388| 18| total_.template Get() += RoundUpTo<8>(array_size * sizeof(U)); 389| 18| } else { 390| | // Since we can't use `if constexpr`, just make the expression compile 391| | // when this path is not taken. 392| 0| using TypeToUse = 393| 0| typename std::conditional::value, 394| 0| char, U>::type; 395| 0| total_.template Get() += array_size; 396| 0| } 397| 18| } descriptor.cc:_ZN6google8protobufL18PlanAllocationSizeERKNS0_16RepeatedPtrFieldINS0_20FieldDescriptorProtoEEERNS0_8internal13FlatAllocatorE: 5732| 94| internal::FlatAllocator& alloc) { 5733| 94| alloc.PlanArray(fields.size()); 5734| 206| for (const auto& field : fields) { ------------------ | Branch (5734:26): [True: 206, False: 94] ------------------ 5735| 206| if (field.has_options()) alloc.PlanArray(1); ------------------ | Branch (5735:9): [True: 17, False: 189] ------------------ 5736| 206| alloc.PlanFieldNames(field.name(), 5737| 206| field.has_json_name() ? &field.json_name() : nullptr); ------------------ | Branch (5737:26): [True: 0, False: 206] ------------------ 5738| 206| if (field.has_default_value() && field.has_type() && ------------------ | Branch (5738:9): [True: 27, False: 179] | Branch (5738:38): [True: 27, False: 0] ------------------ 5739| 27| (field.type() == FieldDescriptorProto::TYPE_STRING || ------------------ | Branch (5739:10): [True: 0, False: 27] ------------------ 5740| 27| field.type() == FieldDescriptorProto::TYPE_BYTES)) { ------------------ | Branch (5740:10): [True: 0, False: 27] ------------------ 5741| | // For the default string value. 5742| 0| alloc.PlanArray(1); 5743| 0| } 5744| 206| } 5745| 94|} descriptor.cc:_ZN6google8protobuf12_GLOBAL__N_117FlatAllocatorImplIJcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE9PlanArrayINS0_15FieldDescriptorEEEvi: 382| 94| void PlanArray(int array_size) { 383| | // We can't call PlanArray after FinalizePlanning has been called. 384| 94| ABSL_CHECK(!has_allocated()); ------------------ | | 41| 94| ABSL_LOG_INTERNAL_CHECK_IMPL((condition), #condition) | | ------------------ | | | | 26| 188| ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS, \ | | | | ------------------ | | | | | | 172| 94| ABSL_LOG_INTERNAL_##type##_CONDITION(condition) | | | | | | ------------------ | | | | | | | | 65| 188| switch (0) \ | | | | | | | | 66| 188| case 0: \ | | | | | | | | ------------------ | | | | | | | | | Branch (66:3): [True: 94, False: 0] | | | | | | | | ------------------ | | | | | | | | 67| 94| default: \ | | | | | | | | ------------------ | | | | | | | | | Branch (67:3): [True: 0, False: 94] | | | | | | | | ------------------ | | | | | | | | 68| 188| !(condition) ? (void)0 : ::absl::log_internal::Voidify()&& | | | | | | | | ------------------ | | | | | | | | | Branch (68:5): [True: 94, False: 0] | | | | | | | | | Branch (68:7): [Folded, False: 94] | | | | | | | | | Branch (68:7): [True: 0, False: 94] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 27| 188| ABSL_PREDICT_FALSE(!(condition))) \ | | | | 28| 188| ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream() | | | | ------------------ | | | | | | 66| 0| ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message) | | | | ------------------ | | ------------------ ------------------ 385| 94| if (std::is_trivially_destructible::value) { ------------------ | Branch (385:9): [True: 94, Folded] ------------------ 386| | // Trivial types are aligned to 8 bytes. 387| 94| static_assert(alignof(U) <= 8, ""); 388| 94| total_.template Get() += RoundUpTo<8>(array_size * sizeof(U)); 389| 94| } else { 390| | // Since we can't use `if constexpr`, just make the expression compile 391| | // when this path is not taken. 392| 0| using TypeToUse = 393| 0| typename std::conditional::value, 394| 0| char, U>::type; 395| 0| total_.template Get() += array_size; 396| 0| } 397| 94| } descriptor.cc:_ZN6google8protobuf12_GLOBAL__N_117FlatAllocatorImplIJcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE9PlanArrayISE_EEvi: 382| 17| void PlanArray(int array_size) { 383| | // We can't call PlanArray after FinalizePlanning has been called. 384| 17| ABSL_CHECK(!has_allocated()); ------------------ | | 41| 17| ABSL_LOG_INTERNAL_CHECK_IMPL((condition), #condition) | | ------------------ | | | | 26| 34| ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS, \ | | | | ------------------ | | | | | | 172| 17| ABSL_LOG_INTERNAL_##type##_CONDITION(condition) | | | | | | ------------------ | | | | | | | | 65| 34| switch (0) \ | | | | | | | | 66| 34| case 0: \ | | | | | | | | ------------------ | | | | | | | | | Branch (66:3): [True: 17, False: 0] | | | | | | | | ------------------ | | | | | | | | 67| 17| default: \ | | | | | | | | ------------------ | | | | | | | | | Branch (67:3): [True: 0, False: 17] | | | | | | | | ------------------ | | | | | | | | 68| 34| !(condition) ? (void)0 : ::absl::log_internal::Voidify()&& | | | | | | | | ------------------ | | | | | | | | | Branch (68:5): [True: 17, False: 0] | | | | | | | | | Branch (68:7): [Folded, False: 17] | | | | | | | | | Branch (68:7): [True: 0, False: 17] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 27| 34| ABSL_PREDICT_FALSE(!(condition))) \ | | | | 28| 34| ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream() | | | | ------------------ | | | | | | 66| 0| ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message) | | | | ------------------ | | ------------------ ------------------ 385| 17| if (std::is_trivially_destructible::value) { ------------------ | Branch (385:9): [Folded, False: 17] ------------------ 386| | // Trivial types are aligned to 8 bytes. 387| 0| static_assert(alignof(U) <= 8, ""); 388| 0| total_.template Get() += RoundUpTo<8>(array_size * sizeof(U)); 389| 17| } else { 390| | // Since we can't use `if constexpr`, just make the expression compile 391| | // when this path is not taken. 392| 17| using TypeToUse = 393| 17| typename std::conditional::value, 394| 17| char, U>::type; 395| 17| total_.template Get() += array_size; 396| 17| } 397| 17| } descriptor.cc:_ZN6google8protobuf12_GLOBAL__N_17TypeMapINS1_4IntTEJcNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE3GetISF_EERiv: 238| 59| ValueT& Get() { 239| 59| return static_cast&>(payload_).value; 240| 59| } descriptor.cc:_ZN6google8protobuf12_GLOBAL__N_117FlatAllocatorImplIJcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE14PlanFieldNamesERKS9_PSN_: 429| 206| const std::string* opt_json_name) { 430| 206| ABSL_CHECK(!has_allocated()); ------------------ | | 41| 206| ABSL_LOG_INTERNAL_CHECK_IMPL((condition), #condition) | | ------------------ | | | | 26| 412| ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS, \ | | | | ------------------ | | | | | | 172| 206| ABSL_LOG_INTERNAL_##type##_CONDITION(condition) | | | | | | ------------------ | | | | | | | | 65| 412| switch (0) \ | | | | | | | | 66| 412| case 0: \ | | | | | | | | ------------------ | | | | | | | | | Branch (66:3): [True: 206, False: 0] | | | | | | | | ------------------ | | | | | | | | 67| 206| default: \ | | | | | | | | ------------------ | | | | | | | | | Branch (67:3): [True: 0, False: 206] | | | | | | | | ------------------ | | | | | | | | 68| 412| !(condition) ? (void)0 : ::absl::log_internal::Voidify()&& | | | | | | | | ------------------ | | | | | | | | | Branch (68:5): [True: 206, False: 0] | | | | | | | | | Branch (68:7): [Folded, False: 206] | | | | | | | | | Branch (68:7): [True: 0, False: 206] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 27| 412| ABSL_PREDICT_FALSE(!(condition))) \ | | | | 28| 412| ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream() | | | | ------------------ | | | | | | 66| 0| ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message) | | | | ------------------ | | ------------------ ------------------ 431| | 432| | // Fast path for snake_case names, which follow the style guide. 433| 206| if (opt_json_name == nullptr) { ------------------ | Branch (433:9): [True: 206, False: 0] ------------------ 434| 206| switch (GetFieldNameCase(name)) { 435| 110| case FieldNameCase::kAllLower: ------------------ | Branch (435:9): [True: 110, False: 96] ------------------ 436| | // Case 1: they are all the same. 437| 110| return PlanArray(2); 438| 96| case FieldNameCase::kSnakeCase: ------------------ | Branch (438:9): [True: 96, False: 110] ------------------ 439| | // Case 2: name==lower, camel==json 440| 96| return PlanArray(3); 441| 0| default: ------------------ | Branch (441:9): [True: 0, False: 206] ------------------ 442| 0| break; 443| 206| } 444| 206| } 445| | 446| 0| std::string lowercase_name = name; 447| 0| absl::AsciiStrToLower(&lowercase_name); 448| | 449| 0| std::string camelcase_name = ToCamelCase(name, /* lower_first = */ true); 450| 0| std::string json_name = 451| 0| opt_json_name != nullptr ? *opt_json_name : ToJsonName(name); ------------------ | Branch (451:9): [True: 0, False: 0] ------------------ 452| | 453| 0| absl::string_view all_names[] = {name, lowercase_name, camelcase_name, 454| 0| json_name}; 455| 0| std::sort(all_names, all_names + 4); 456| 0| int unique = 457| 0| static_cast(std::unique(all_names, all_names + 4) - all_names); 458| | 459| 0| PlanArray(unique + 1); 460| 0| } descriptor.cc:_ZN6google8protobuf12_GLOBAL__N_117FlatAllocatorImplIJcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE16GetFieldNameCaseENS3_17basic_string_viewIcS6_EE: 550| 412| FieldNameCase GetFieldNameCase(const absl::string_view name) { 551| 412| if (!name.empty() && !IsLower(name[0])) return FieldNameCase::kOther; ------------------ | Branch (551:9): [True: 412, False: 0] | Branch (551:26): [True: 0, False: 412] ------------------ 552| 412| FieldNameCase best = FieldNameCase::kAllLower; 553| 4.44k| for (char c : name) { ------------------ | Branch (553:17): [True: 4.44k, False: 412] ------------------ 554| 4.44k| if (IsLowerOrDigit(c)) { ------------------ | Branch (554:11): [True: 4.18k, False: 258] ------------------ 555| | // nothing to do 556| 4.18k| } else if (c == '_') { ------------------ | Branch (556:18): [True: 258, False: 0] ------------------ 557| 258| best = FieldNameCase::kSnakeCase; 558| 258| } else { 559| 0| return FieldNameCase::kOther; 560| 0| } 561| 4.44k| } 562| 412| return best; 563| 412| } descriptor.cc:_ZN6google8protobuf12_GLOBAL__N_117FlatAllocatorImplIJcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE7IsLowerEc: 545| 4.85k| static bool IsLower(char c) { return 'a' <= c && c <= 'z'; } ------------------ | Branch (545:40): [True: 4.58k, False: 268] | Branch (545:52): [True: 4.58k, False: 0] ------------------ descriptor.cc:_ZN6google8protobuf12_GLOBAL__N_117FlatAllocatorImplIJcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE14IsLowerOrDigitEc: 547| 4.44k| static bool IsLowerOrDigit(char c) { return IsLower(c) || IsDigit(c); } ------------------ | Branch (547:47): [True: 4.17k, False: 268] | Branch (547:61): [True: 10, False: 258] ------------------ descriptor.cc:_ZN6google8protobuf12_GLOBAL__N_117FlatAllocatorImplIJcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE7IsDigitEc: 546| 268| static bool IsDigit(char c) { return '0' <= c && c <= '9'; } ------------------ | Branch (546:40): [True: 268, False: 0] | Branch (546:52): [True: 10, False: 258] ------------------ descriptor.cc:_ZN6google8protobuf12_GLOBAL__N_117FlatAllocatorImplIJcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE9PlanArrayIiEEvi: 382| 8| void PlanArray(int array_size) { 383| | // We can't call PlanArray after FinalizePlanning has been called. 384| 8| ABSL_CHECK(!has_allocated()); ------------------ | | 41| 8| ABSL_LOG_INTERNAL_CHECK_IMPL((condition), #condition) | | ------------------ | | | | 26| 16| ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS, \ | | | | ------------------ | | | | | | 172| 8| ABSL_LOG_INTERNAL_##type##_CONDITION(condition) | | | | | | ------------------ | | | | | | | | 65| 16| switch (0) \ | | | | | | | | 66| 16| case 0: \ | | | | | | | | ------------------ | | | | | | | | | Branch (66:3): [True: 8, False: 0] | | | | | | | | ------------------ | | | | | | | | 67| 8| default: \ | | | | | | | | ------------------ | | | | | | | | | Branch (67:3): [True: 0, False: 8] | | | | | | | | ------------------ | | | | | | | | 68| 16| !(condition) ? (void)0 : ::absl::log_internal::Voidify()&& | | | | | | | | ------------------ | | | | | | | | | Branch (68:5): [True: 8, False: 0] | | | | | | | | | Branch (68:7): [Folded, False: 8] | | | | | | | | | Branch (68:7): [True: 0, False: 8] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 27| 16| ABSL_PREDICT_FALSE(!(condition))) \ | | | | 28| 16| ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream() | | | | ------------------ | | | | | | 66| 0| ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message) | | | | ------------------ | | ------------------ ------------------ 385| 8| if (std::is_trivially_destructible::value) { ------------------ | Branch (385:9): [True: 8, Folded] ------------------ 386| | // Trivial types are aligned to 8 bytes. 387| 8| static_assert(alignof(U) <= 8, ""); 388| 8| total_.template Get() += RoundUpTo<8>(array_size * sizeof(U)); 389| 8| } else { 390| | // Since we can't use `if constexpr`, just make the expression compile 391| | // when this path is not taken. 392| 0| using TypeToUse = 393| 0| typename std::conditional::value, 394| 0| char, U>::type; 395| 0| total_.template Get() += array_size; 396| 0| } 397| 8| } descriptor.cc:_ZN6google8protobuf12_GLOBAL__N_117FlatAllocatorImplIJcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE9PlanArrayIPKNS0_14FileDescriptorEEEvi: 382| 4| void PlanArray(int array_size) { 383| | // We can't call PlanArray after FinalizePlanning has been called. 384| 4| ABSL_CHECK(!has_allocated()); ------------------ | | 41| 4| ABSL_LOG_INTERNAL_CHECK_IMPL((condition), #condition) | | ------------------ | | | | 26| 8| ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS, \ | | | | ------------------ | | | | | | 172| 4| ABSL_LOG_INTERNAL_##type##_CONDITION(condition) | | | | | | ------------------ | | | | | | | | 65| 8| switch (0) \ | | | | | | | | 66| 8| case 0: \ | | | | | | | | ------------------ | | | | | | | | | Branch (66:3): [True: 4, False: 0] | | | | | | | | ------------------ | | | | | | | | 67| 4| default: \ | | | | | | | | ------------------ | | | | | | | | | Branch (67:3): [True: 0, False: 4] | | | | | | | | ------------------ | | | | | | | | 68| 8| !(condition) ? (void)0 : ::absl::log_internal::Voidify()&& | | | | | | | | ------------------ | | | | | | | | | Branch (68:5): [True: 4, False: 0] | | | | | | | | | Branch (68:7): [Folded, False: 4] | | | | | | | | | Branch (68:7): [True: 0, False: 4] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 27| 8| ABSL_PREDICT_FALSE(!(condition))) \ | | | | 28| 8| ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream() | | | | ------------------ | | | | | | 66| 0| ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message) | | | | ------------------ | | ------------------ ------------------ 385| 4| if (std::is_trivially_destructible::value) { ------------------ | Branch (385:9): [True: 4, Folded] ------------------ 386| | // Trivial types are aligned to 8 bytes. 387| 4| static_assert(alignof(U) <= 8, ""); 388| 4| total_.template Get() += RoundUpTo<8>(array_size * sizeof(U)); 389| 4| } else { 390| | // Since we can't use `if constexpr`, just make the expression compile 391| | // when this path is not taken. 392| 0| using TypeToUse = 393| 0| typename std::conditional::value, 394| 0| char, U>::type; 395| 0| total_.template Get() += array_size; 396| 0| } 397| 4| } descriptor.cc:_ZN6google8protobuf12_GLOBAL__N_124GetCppFeatureSetDefaultsEv: 1105| 4|const FeatureSetDefaults& GetCppFeatureSetDefaults() { 1106| 4| static const FeatureSetDefaults* default_spec = 1107| 4| internal::OnShutdownDelete([] { 1108| 4| auto* defaults = new FeatureSetDefaults(); 1109| 4| internal::ParseNoReflection( 1110| 4| absl::string_view{ 1111| 4| PROTOBUF_INTERNAL_CPP_EDITION_DEFAULTS, 1112| 4| sizeof(PROTOBUF_INTERNAL_CPP_EDITION_DEFAULTS) - 1}, 1113| 4| *defaults); 1114| 4| return defaults; 1115| 4| }()); 1116| 4| return *default_spec; 1117| 4|} descriptor.cc:_ZZN6google8protobuf12_GLOBAL__N_124GetCppFeatureSetDefaultsEvENK3$_0clEv: 1107| 1| internal::OnShutdownDelete([] { 1108| 1| auto* defaults = new FeatureSetDefaults(); 1109| 1| internal::ParseNoReflection( 1110| 1| absl::string_view{ 1111| 1| PROTOBUF_INTERNAL_CPP_EDITION_DEFAULTS, ------------------ | | 8| 1|#define PROTOBUF_INTERNAL_CPP_EDITION_DEFAULTS "\n\037\030\204\007\"\003\302>\000*\025\010\001\020\002\030\002 \003(\0010\002\302>\006\010\001\020\003\030\000\n\037\030\347\007\"\003\302>\000*\025\010\002\020\001\030\001 \002(\0010\001\302>\006\010\000\020\003\030\000\n\037\030\350\007\"\023\010\001\020\001\030\001 \002(\0010\001\302>\004\010\000\020\003*\005\302>\002\030\000\n\037\030\351\007\"\025\010\001\020\001\030\001 \002(\0010\001\302>\006\010\000\020\001\030\001*\003\302>\000 \346\007(\351\007" ------------------ 1112| 1| sizeof(PROTOBUF_INTERNAL_CPP_EDITION_DEFAULTS) - 1}, ------------------ | | 8| 1|#define PROTOBUF_INTERNAL_CPP_EDITION_DEFAULTS "\n\037\030\204\007\"\003\302>\000*\025\010\001\020\002\030\002 \003(\0010\002\302>\006\010\001\020\003\030\000\n\037\030\347\007\"\003\302>\000*\025\010\002\020\001\030\001 \002(\0010\001\302>\006\010\000\020\003\030\000\n\037\030\350\007\"\023\010\001\020\001\030\001 \002(\0010\001\302>\004\010\000\020\003*\005\302>\002\030\000\n\037\030\351\007\"\025\010\001\020\001\030\001 \002(\0010\001\302>\006\010\000\020\001\030\001*\003\302>\000 \346\007(\351\007" ------------------ 1113| 1| *defaults); 1114| 1| return defaults; 1115| 1| }()); _ZN6google8protobuf17DescriptorBuilder14BuildExtensionERKNS0_20FieldDescriptorProtoEPNS0_10DescriptorEPNS0_15FieldDescriptorERNS0_8internal13FlatAllocatorE: 4423| 1| FieldDescriptor* result, internal::FlatAllocator& alloc) { 4424| 1| BuildFieldOrExtension(proto, parent, result, true, alloc); 4425| 1| } descriptor.cc:_ZN6google8protobuf12_GLOBAL__N_115DisableTrackingEv: 583| 28|auto DisableTracking() { 584| 28| bool old_value = is_tracking_enabled(); 585| 28| is_tracking_enabled() = false; 586| 28| return absl::MakeCleanup([=] { is_tracking_enabled() = old_value; }); 587| 28|} _ZN6google8protobuf17DescriptorBuilder10BuildFieldERKNS0_20FieldDescriptorProtoEPNS0_10DescriptorEPNS0_15FieldDescriptorERNS0_8internal13FlatAllocatorE: 4419| 205| FieldDescriptor* result, internal::FlatAllocator& alloc) { 4420| 205| BuildFieldOrExtension(proto, parent, result, false, alloc); 4421| 205| } descriptor.cc:_ZN6google8protobuf12_GLOBAL__N_122IncrementWhenDestroyedD2Ev: 6295| 45| ~IncrementWhenDestroyed() { ++to_increment; } _ZN6google8protobuf6SymbolC2EPNS0_15FieldDescriptorE: 619| 206| explicit Symbol(TYPE* value) : ptr_(value) { \ 620| 206| value->symbol_type_ = TYPE_CONSTANT; \ 621| 206| } \ _ZN6google8protobuf6SymbolC2EPNS0_15OneofDescriptorE: 619| 2| explicit Symbol(TYPE* value) : ptr_(value) { \ 620| 2| value->symbol_type_ = TYPE_CONSTANT; \ 621| 2| } \ _ZN6google8protobuf6Symbol9EnumValueEPNS0_19EnumValueDescriptorEi: 646| 172| static Symbol EnumValue(EnumValueDescriptor* value, int n) { 647| 172| Symbol s; 648| 172| internal::SymbolBase* ptr; 649| 172| if (n == 0) { ------------------ | Branch (649:9): [True: 86, False: 86] ------------------ 650| 86| ptr = static_cast*>(value); 651| 86| ptr->symbol_type_ = ENUM_VALUE; 652| 86| } else { 653| 86| ptr = static_cast*>(value); 654| 86| ptr->symbol_type_ = ENUM_VALUE_OTHER_PARENT; 655| 86| } 656| 172| s.ptr_ = ptr; 657| 172| return s; 658| 172| } _ZNK6google8protobuf6Symbol4typeEv: 672| 196k| Type type() const { return static_cast(ptr_->symbol_type_); } descriptor.cc:_ZN6google8protobuf12_GLOBAL__N_111ToCamelCaseENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEb: 97| 96|std::string ToCamelCase(const absl::string_view input, bool lower_first) { 98| 96| bool capitalize_next = !lower_first; 99| 96| std::string result; 100| 96| result.reserve(input.size()); 101| | 102| 1.52k| for (char character : input) { ------------------ | Branch (102:23): [True: 1.52k, False: 96] ------------------ 103| 1.52k| if (character == '_') { ------------------ | Branch (103:9): [True: 129, False: 1.39k] ------------------ 104| 129| capitalize_next = true; 105| 1.39k| } else if (capitalize_next) { ------------------ | Branch (105:16): [True: 129, False: 1.26k] ------------------ 106| 129| result.push_back(absl::ascii_toupper(character)); 107| 129| capitalize_next = false; 108| 1.26k| } else { 109| 1.26k| result.push_back(character); 110| 1.26k| } 111| 1.52k| } 112| | 113| | // Lower-case the first letter. 114| 96| if (lower_first && !result.empty()) { ------------------ | Branch (114:7): [True: 96, False: 0] | Branch (114:22): [True: 96, False: 0] ------------------ 115| 96| result[0] = absl::ascii_tolower(result[0]); 116| 96| } 117| | 118| 96| return result; 119| 96|} descriptor.cc:_ZN6google8protobuf12_GLOBAL__N_119is_tracking_enabledEv: 578| 84|bool& is_tracking_enabled() { 579| 84| static PROTOBUF_THREAD_LOCAL bool value = true; 580| 84| return value; 581| 84|} descriptor.cc:_ZZN6google8protobuf12_GLOBAL__N_115DisableTrackingEvENK3$_0clEv: 586| 28| return absl::MakeCleanup([=] { is_tracking_enabled() = old_value; }); descriptor.cc:_ZN6google8protobuf12_GLOBAL__N_115ExpressionEaterC2IbEEOT_: 157| 112| ExpressionEater(T&&) {} // NOLINT descriptor.cc:_ZNK6google8protobuf12_GLOBAL__N_114FlatAllocationIJcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE5BeginIS9_EEPT_v: 324| 4| U* Begin() const { 325| 4| int begin = BeginOffset(), end = EndOffset(); 326| 4| if (begin == end) return nullptr; ------------------ | Branch (326:9): [True: 0, False: 4] ------------------ 327| 4| return reinterpret_cast(data() + begin); 328| 4| } descriptor.cc:_ZNK6google8protobuf12_GLOBAL__N_114FlatAllocationIJcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE11BeginOffsetIS9_EEiv: 302| 8| int BeginOffset() const { 303| 8| constexpr int type_index = FindTypeIndex(); 304| | // Avoid a negative value here to keep it compiling when type_index == 0 305| 8| constexpr int prev_type_index = type_index == 0 ? 0 : type_index - 1; ------------------ | Branch (305:37): [Folded, False: 8] ------------------ 306| 8| using PrevType = 307| 8| typename std::tuple_element>::type; 308| | // Ensure the types are properly aligned. 309| 8| static_assert(EffectiveAlignof() >= EffectiveAlignof(), ""); 310| 8| return type_index == 0 ? RoundUpTo(sizeof(FlatAllocation)) ------------------ | Branch (310:12): [Folded, False: 8] ------------------ 311| 8| : ends_.template Get(); 312| 8| } descriptor.cc:_ZNK6google8protobuf12_GLOBAL__N_17TypeMapINS1_4IntTEJcNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE3GetIcEERKiv: 243| 24| const ValueT& Get() const { 244| 24| return static_cast&>(payload_).value; 245| 24| } descriptor.cc:_ZNK6google8protobuf12_GLOBAL__N_114FlatAllocationIJcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE9EndOffsetIS9_EEiv: 315| 8| int EndOffset() const { 316| 8| return ends_.template Get(); 317| 8| } descriptor.cc:_ZNK6google8protobuf12_GLOBAL__N_17TypeMapINS1_4IntTEJcNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE3GetISA_EERKiv: 243| 28| const ValueT& Get() const { 244| 28| return static_cast&>(payload_).value; 245| 28| } descriptor.cc:_ZNK6google8protobuf12_GLOBAL__N_114FlatAllocationIJcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE4dataEv: 357| 120| char* data() const { 358| 120| return const_cast(reinterpret_cast(this)); 359| 120| } descriptor.cc:_ZNK6google8protobuf12_GLOBAL__N_114FlatAllocationIJcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE5BeginISA_EEPT_v: 324| 4| U* Begin() const { 325| 4| int begin = BeginOffset(), end = EndOffset(); 326| 4| if (begin == end) return nullptr; ------------------ | Branch (326:9): [True: 4, False: 0] ------------------ 327| 0| return reinterpret_cast(data() + begin); 328| 4| } descriptor.cc:_ZNK6google8protobuf12_GLOBAL__N_114FlatAllocationIJcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE11BeginOffsetISA_EEiv: 302| 8| int BeginOffset() const { 303| 8| constexpr int type_index = FindTypeIndex(); 304| | // Avoid a negative value here to keep it compiling when type_index == 0 305| 8| constexpr int prev_type_index = type_index == 0 ? 0 : type_index - 1; ------------------ | Branch (305:37): [Folded, False: 8] ------------------ 306| 8| using PrevType = 307| 8| typename std::tuple_element>::type; 308| | // Ensure the types are properly aligned. 309| 8| static_assert(EffectiveAlignof() >= EffectiveAlignof(), ""); 310| 8| return type_index == 0 ? RoundUpTo(sizeof(FlatAllocation)) ------------------ | Branch (310:12): [Folded, False: 8] ------------------ 311| 8| : ends_.template Get(); 312| 8| } descriptor.cc:_ZNK6google8protobuf12_GLOBAL__N_114FlatAllocationIJcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE9EndOffsetISA_EEiv: 315| 8| int EndOffset() const { 316| 8| return ends_.template Get(); 317| 8| } descriptor.cc:_ZNK6google8protobuf12_GLOBAL__N_17TypeMapINS1_4IntTEJcNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE3GetISB_EERKiv: 243| 28| const ValueT& Get() const { 244| 28| return static_cast&>(payload_).value; 245| 28| } descriptor.cc:_ZNK6google8protobuf12_GLOBAL__N_114FlatAllocationIJcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE5BeginISB_EEPT_v: 324| 4| U* Begin() const { 325| 4| int begin = BeginOffset(), end = EndOffset(); 326| 4| if (begin == end) return nullptr; ------------------ | Branch (326:9): [True: 0, False: 4] ------------------ 327| 4| return reinterpret_cast(data() + begin); 328| 4| } descriptor.cc:_ZNK6google8protobuf12_GLOBAL__N_114FlatAllocationIJcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE11BeginOffsetISB_EEiv: 302| 8| int BeginOffset() const { 303| 8| constexpr int type_index = FindTypeIndex(); 304| | // Avoid a negative value here to keep it compiling when type_index == 0 305| 8| constexpr int prev_type_index = type_index == 0 ? 0 : type_index - 1; ------------------ | Branch (305:37): [Folded, False: 8] ------------------ 306| 8| using PrevType = 307| 8| typename std::tuple_element>::type; 308| | // Ensure the types are properly aligned. 309| 8| static_assert(EffectiveAlignof() >= EffectiveAlignof(), ""); 310| 8| return type_index == 0 ? RoundUpTo(sizeof(FlatAllocation)) ------------------ | Branch (310:12): [Folded, False: 8] ------------------ 311| 8| : ends_.template Get(); 312| 8| } descriptor.cc:_ZNK6google8protobuf12_GLOBAL__N_114FlatAllocationIJcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE9EndOffsetISB_EEiv: 315| 8| int EndOffset() const { 316| 8| return ends_.template Get(); 317| 8| } descriptor.cc:_ZNK6google8protobuf12_GLOBAL__N_17TypeMapINS1_4IntTEJcNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE3GetISC_EERKiv: 243| 28| const ValueT& Get() const { 244| 28| return static_cast&>(payload_).value; 245| 28| } descriptor.cc:_ZNK6google8protobuf12_GLOBAL__N_114FlatAllocationIJcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE5BeginISC_EEPT_v: 324| 4| U* Begin() const { 325| 4| int begin = BeginOffset(), end = EndOffset(); 326| 4| if (begin == end) return nullptr; ------------------ | Branch (326:9): [True: 4, False: 0] ------------------ 327| 0| return reinterpret_cast(data() + begin); 328| 4| } descriptor.cc:_ZNK6google8protobuf12_GLOBAL__N_114FlatAllocationIJcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE11BeginOffsetISC_EEiv: 302| 8| int BeginOffset() const { 303| 8| constexpr int type_index = FindTypeIndex(); 304| | // Avoid a negative value here to keep it compiling when type_index == 0 305| 8| constexpr int prev_type_index = type_index == 0 ? 0 : type_index - 1; ------------------ | Branch (305:37): [Folded, False: 8] ------------------ 306| 8| using PrevType = 307| 8| typename std::tuple_element>::type; 308| | // Ensure the types are properly aligned. 309| 8| static_assert(EffectiveAlignof() >= EffectiveAlignof(), ""); 310| 8| return type_index == 0 ? RoundUpTo(sizeof(FlatAllocation)) ------------------ | Branch (310:12): [Folded, False: 8] ------------------ 311| 8| : ends_.template Get(); 312| 8| } descriptor.cc:_ZNK6google8protobuf12_GLOBAL__N_114FlatAllocationIJcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE9EndOffsetISC_EEiv: 315| 8| int EndOffset() const { 316| 8| return ends_.template Get(); 317| 8| } descriptor.cc:_ZNK6google8protobuf12_GLOBAL__N_17TypeMapINS1_4IntTEJcNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE3GetISD_EERKiv: 243| 28| const ValueT& Get() const { 244| 28| return static_cast&>(payload_).value; 245| 28| } descriptor.cc:_ZNK6google8protobuf12_GLOBAL__N_114FlatAllocationIJcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE5BeginISD_EEPT_v: 324| 4| U* Begin() const { 325| 4| int begin = BeginOffset(), end = EndOffset(); 326| 4| if (begin == end) return nullptr; ------------------ | Branch (326:9): [True: 4, False: 0] ------------------ 327| 0| return reinterpret_cast(data() + begin); 328| 4| } descriptor.cc:_ZNK6google8protobuf12_GLOBAL__N_114FlatAllocationIJcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE11BeginOffsetISD_EEiv: 302| 8| int BeginOffset() const { 303| 8| constexpr int type_index = FindTypeIndex(); 304| | // Avoid a negative value here to keep it compiling when type_index == 0 305| 8| constexpr int prev_type_index = type_index == 0 ? 0 : type_index - 1; ------------------ | Branch (305:37): [Folded, False: 8] ------------------ 306| 8| using PrevType = 307| 8| typename std::tuple_element>::type; 308| | // Ensure the types are properly aligned. 309| 8| static_assert(EffectiveAlignof() >= EffectiveAlignof(), ""); 310| 8| return type_index == 0 ? RoundUpTo(sizeof(FlatAllocation)) ------------------ | Branch (310:12): [Folded, False: 8] ------------------ 311| 8| : ends_.template Get(); 312| 8| } descriptor.cc:_ZNK6google8protobuf12_GLOBAL__N_114FlatAllocationIJcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE9EndOffsetISD_EEiv: 315| 8| int EndOffset() const { 316| 8| return ends_.template Get(); 317| 8| } descriptor.cc:_ZNK6google8protobuf12_GLOBAL__N_17TypeMapINS1_4IntTEJcNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE3GetISE_EERKiv: 243| 28| const ValueT& Get() const { 244| 28| return static_cast&>(payload_).value; 245| 28| } descriptor.cc:_ZNK6google8protobuf12_GLOBAL__N_114FlatAllocationIJcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE5BeginISE_EEPT_v: 324| 4| U* Begin() const { 325| 4| int begin = BeginOffset(), end = EndOffset(); 326| 4| if (begin == end) return nullptr; ------------------ | Branch (326:9): [True: 2, False: 2] ------------------ 327| 2| return reinterpret_cast(data() + begin); 328| 4| } descriptor.cc:_ZNK6google8protobuf12_GLOBAL__N_114FlatAllocationIJcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE11BeginOffsetISE_EEiv: 302| 8| int BeginOffset() const { 303| 8| constexpr int type_index = FindTypeIndex(); 304| | // Avoid a negative value here to keep it compiling when type_index == 0 305| 8| constexpr int prev_type_index = type_index == 0 ? 0 : type_index - 1; ------------------ | Branch (305:37): [Folded, False: 8] ------------------ 306| 8| using PrevType = 307| 8| typename std::tuple_element>::type; 308| | // Ensure the types are properly aligned. 309| 8| static_assert(EffectiveAlignof() >= EffectiveAlignof(), ""); 310| 8| return type_index == 0 ? RoundUpTo(sizeof(FlatAllocation)) ------------------ | Branch (310:12): [Folded, False: 8] ------------------ 311| 8| : ends_.template Get(); 312| 8| } descriptor.cc:_ZNK6google8protobuf12_GLOBAL__N_114FlatAllocationIJcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE9EndOffsetISE_EEiv: 315| 8| int EndOffset() const { 316| 8| return ends_.template Get(); 317| 8| } descriptor.cc:_ZNK6google8protobuf12_GLOBAL__N_17TypeMapINS1_4IntTEJcNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE3GetISF_EERKiv: 243| 28| const ValueT& Get() const { 244| 28| return static_cast&>(payload_).value; 245| 28| } descriptor.cc:_ZNK6google8protobuf12_GLOBAL__N_114FlatAllocationIJcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE5BeginISF_EEPT_v: 324| 4| U* Begin() const { 325| 4| int begin = BeginOffset(), end = EndOffset(); 326| 4| if (begin == end) return nullptr; ------------------ | Branch (326:9): [True: 4, False: 0] ------------------ 327| 0| return reinterpret_cast(data() + begin); 328| 4| } descriptor.cc:_ZNK6google8protobuf12_GLOBAL__N_114FlatAllocationIJcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE11BeginOffsetISF_EEiv: 302| 8| int BeginOffset() const { 303| 8| constexpr int type_index = FindTypeIndex(); 304| | // Avoid a negative value here to keep it compiling when type_index == 0 305| 8| constexpr int prev_type_index = type_index == 0 ? 0 : type_index - 1; ------------------ | Branch (305:37): [Folded, False: 8] ------------------ 306| 8| using PrevType = 307| 8| typename std::tuple_element>::type; 308| | // Ensure the types are properly aligned. 309| 8| static_assert(EffectiveAlignof() >= EffectiveAlignof(), ""); 310| 8| return type_index == 0 ? RoundUpTo(sizeof(FlatAllocation)) ------------------ | Branch (310:12): [Folded, False: 8] ------------------ 311| 8| : ends_.template Get(); 312| 8| } descriptor.cc:_ZNK6google8protobuf12_GLOBAL__N_114FlatAllocationIJcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE9EndOffsetISF_EEiv: 315| 8| int EndOffset() const { 316| 8| return ends_.template Get(); 317| 8| } descriptor.cc:_ZNK6google8protobuf12_GLOBAL__N_17TypeMapINS1_4IntTEJcNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE3GetISG_EERKiv: 243| 28| const ValueT& Get() const { 244| 28| return static_cast&>(payload_).value; 245| 28| } descriptor.cc:_ZNK6google8protobuf12_GLOBAL__N_114FlatAllocationIJcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE5BeginISG_EEPT_v: 324| 4| U* Begin() const { 325| 4| int begin = BeginOffset(), end = EndOffset(); 326| 4| if (begin == end) return nullptr; ------------------ | Branch (326:9): [True: 4, False: 0] ------------------ 327| 0| return reinterpret_cast(data() + begin); 328| 4| } descriptor.cc:_ZNK6google8protobuf12_GLOBAL__N_114FlatAllocationIJcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE11BeginOffsetISG_EEiv: 302| 8| int BeginOffset() const { 303| 8| constexpr int type_index = FindTypeIndex(); 304| | // Avoid a negative value here to keep it compiling when type_index == 0 305| 8| constexpr int prev_type_index = type_index == 0 ? 0 : type_index - 1; ------------------ | Branch (305:37): [Folded, False: 8] ------------------ 306| 8| using PrevType = 307| 8| typename std::tuple_element>::type; 308| | // Ensure the types are properly aligned. 309| 8| static_assert(EffectiveAlignof() >= EffectiveAlignof(), ""); 310| 8| return type_index == 0 ? RoundUpTo(sizeof(FlatAllocation)) ------------------ | Branch (310:12): [Folded, False: 8] ------------------ 311| 8| : ends_.template Get(); 312| 8| } descriptor.cc:_ZNK6google8protobuf12_GLOBAL__N_114FlatAllocationIJcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE9EndOffsetISG_EEiv: 315| 8| int EndOffset() const { 316| 8| return ends_.template Get(); 317| 8| } descriptor.cc:_ZNK6google8protobuf12_GLOBAL__N_17TypeMapINS1_4IntTEJcNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE3GetISH_EERKiv: 243| 28| const ValueT& Get() const { 244| 28| return static_cast&>(payload_).value; 245| 28| } descriptor.cc:_ZNK6google8protobuf12_GLOBAL__N_114FlatAllocationIJcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE5BeginISH_EEPT_v: 324| 4| U* Begin() const { 325| 4| int begin = BeginOffset(), end = EndOffset(); 326| 4| if (begin == end) return nullptr; ------------------ | Branch (326:9): [True: 4, False: 0] ------------------ 327| 0| return reinterpret_cast(data() + begin); 328| 4| } descriptor.cc:_ZNK6google8protobuf12_GLOBAL__N_114FlatAllocationIJcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE11BeginOffsetISH_EEiv: 302| 8| int BeginOffset() const { 303| 8| constexpr int type_index = FindTypeIndex(); 304| | // Avoid a negative value here to keep it compiling when type_index == 0 305| 8| constexpr int prev_type_index = type_index == 0 ? 0 : type_index - 1; ------------------ | Branch (305:37): [Folded, False: 8] ------------------ 306| 8| using PrevType = 307| 8| typename std::tuple_element>::type; 308| | // Ensure the types are properly aligned. 309| 8| static_assert(EffectiveAlignof() >= EffectiveAlignof(), ""); 310| 8| return type_index == 0 ? RoundUpTo(sizeof(FlatAllocation)) ------------------ | Branch (310:12): [Folded, False: 8] ------------------ 311| 8| : ends_.template Get(); 312| 8| } descriptor.cc:_ZNK6google8protobuf12_GLOBAL__N_114FlatAllocationIJcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE9EndOffsetISH_EEiv: 315| 8| int EndOffset() const { 316| 8| return ends_.template Get(); 317| 8| } descriptor.cc:_ZNK6google8protobuf12_GLOBAL__N_17TypeMapINS1_4IntTEJcNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE3GetISI_EERKiv: 243| 28| const ValueT& Get() const { 244| 28| return static_cast&>(payload_).value; 245| 28| } descriptor.cc:_ZNK6google8protobuf12_GLOBAL__N_114FlatAllocationIJcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE5BeginISI_EEPT_v: 324| 4| U* Begin() const { 325| 4| int begin = BeginOffset(), end = EndOffset(); 326| 4| if (begin == end) return nullptr; ------------------ | Branch (326:9): [True: 4, False: 0] ------------------ 327| 0| return reinterpret_cast(data() + begin); 328| 4| } descriptor.cc:_ZNK6google8protobuf12_GLOBAL__N_114FlatAllocationIJcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE11BeginOffsetISI_EEiv: 302| 8| int BeginOffset() const { 303| 8| constexpr int type_index = FindTypeIndex(); 304| | // Avoid a negative value here to keep it compiling when type_index == 0 305| 8| constexpr int prev_type_index = type_index == 0 ? 0 : type_index - 1; ------------------ | Branch (305:37): [Folded, False: 8] ------------------ 306| 8| using PrevType = 307| 8| typename std::tuple_element>::type; 308| | // Ensure the types are properly aligned. 309| 8| static_assert(EffectiveAlignof() >= EffectiveAlignof(), ""); 310| 8| return type_index == 0 ? RoundUpTo(sizeof(FlatAllocation)) ------------------ | Branch (310:12): [Folded, False: 8] ------------------ 311| 8| : ends_.template Get(); 312| 8| } descriptor.cc:_ZNK6google8protobuf12_GLOBAL__N_114FlatAllocationIJcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE9EndOffsetISI_EEiv: 315| 8| int EndOffset() const { 316| 8| return ends_.template Get(); 317| 8| } descriptor.cc:_ZNK6google8protobuf12_GLOBAL__N_17TypeMapINS1_4IntTEJcNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE3GetISJ_EERKiv: 243| 28| const ValueT& Get() const { 244| 28| return static_cast&>(payload_).value; 245| 28| } descriptor.cc:_ZNK6google8protobuf12_GLOBAL__N_114FlatAllocationIJcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE5BeginISJ_EEPT_v: 324| 4| U* Begin() const { 325| 4| int begin = BeginOffset(), end = EndOffset(); 326| 4| if (begin == end) return nullptr; ------------------ | Branch (326:9): [True: 4, False: 0] ------------------ 327| 0| return reinterpret_cast(data() + begin); 328| 4| } descriptor.cc:_ZNK6google8protobuf12_GLOBAL__N_114FlatAllocationIJcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE11BeginOffsetISJ_EEiv: 302| 8| int BeginOffset() const { 303| 8| constexpr int type_index = FindTypeIndex(); 304| | // Avoid a negative value here to keep it compiling when type_index == 0 305| 8| constexpr int prev_type_index = type_index == 0 ? 0 : type_index - 1; ------------------ | Branch (305:37): [Folded, False: 8] ------------------ 306| 8| using PrevType = 307| 8| typename std::tuple_element>::type; 308| | // Ensure the types are properly aligned. 309| 8| static_assert(EffectiveAlignof() >= EffectiveAlignof(), ""); 310| 8| return type_index == 0 ? RoundUpTo(sizeof(FlatAllocation)) ------------------ | Branch (310:12): [Folded, False: 8] ------------------ 311| 8| : ends_.template Get(); 312| 8| } descriptor.cc:_ZNK6google8protobuf12_GLOBAL__N_114FlatAllocationIJcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE9EndOffsetISJ_EEiv: 315| 8| int EndOffset() const { 316| 8| return ends_.template Get(); 317| 8| } descriptor.cc:_ZNK6google8protobuf12_GLOBAL__N_17TypeMapINS1_4IntTEJcNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE3GetISK_EERKiv: 243| 28| const ValueT& Get() const { 244| 28| return static_cast&>(payload_).value; 245| 28| } descriptor.cc:_ZNK6google8protobuf12_GLOBAL__N_114FlatAllocationIJcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE5BeginISK_EEPT_v: 324| 4| U* Begin() const { 325| 4| int begin = BeginOffset(), end = EndOffset(); 326| 4| if (begin == end) return nullptr; ------------------ | Branch (326:9): [True: 4, False: 0] ------------------ 327| 0| return reinterpret_cast(data() + begin); 328| 4| } descriptor.cc:_ZNK6google8protobuf12_GLOBAL__N_114FlatAllocationIJcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE11BeginOffsetISK_EEiv: 302| 8| int BeginOffset() const { 303| 8| constexpr int type_index = FindTypeIndex(); 304| | // Avoid a negative value here to keep it compiling when type_index == 0 305| 8| constexpr int prev_type_index = type_index == 0 ? 0 : type_index - 1; ------------------ | Branch (305:37): [Folded, False: 8] ------------------ 306| 8| using PrevType = 307| 8| typename std::tuple_element>::type; 308| | // Ensure the types are properly aligned. 309| 8| static_assert(EffectiveAlignof() >= EffectiveAlignof(), ""); 310| 8| return type_index == 0 ? RoundUpTo(sizeof(FlatAllocation)) ------------------ | Branch (310:12): [Folded, False: 8] ------------------ 311| 8| : ends_.template Get(); 312| 8| } descriptor.cc:_ZNK6google8protobuf12_GLOBAL__N_114FlatAllocationIJcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE9EndOffsetISK_EEiv: 315| 8| int EndOffset() const { 316| 8| return ends_.template Get(); 317| 8| } descriptor.cc:_ZNK6google8protobuf12_GLOBAL__N_17TypeMapINS1_4IntTEJcNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE3GetISL_EERKiv: 243| 28| const ValueT& Get() const { 244| 28| return static_cast&>(payload_).value; 245| 28| } descriptor.cc:_ZNK6google8protobuf12_GLOBAL__N_114FlatAllocationIJcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE5BeginISL_EEPT_v: 324| 4| U* Begin() const { 325| 4| int begin = BeginOffset(), end = EndOffset(); 326| 4| if (begin == end) return nullptr; ------------------ | Branch (326:9): [True: 2, False: 2] ------------------ 327| 2| return reinterpret_cast(data() + begin); 328| 4| } descriptor.cc:_ZNK6google8protobuf12_GLOBAL__N_114FlatAllocationIJcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE11BeginOffsetISL_EEiv: 302| 8| int BeginOffset() const { 303| 8| constexpr int type_index = FindTypeIndex(); 304| | // Avoid a negative value here to keep it compiling when type_index == 0 305| 8| constexpr int prev_type_index = type_index == 0 ? 0 : type_index - 1; ------------------ | Branch (305:37): [Folded, False: 8] ------------------ 306| 8| using PrevType = 307| 8| typename std::tuple_element>::type; 308| | // Ensure the types are properly aligned. 309| 8| static_assert(EffectiveAlignof() >= EffectiveAlignof(), ""); 310| 8| return type_index == 0 ? RoundUpTo(sizeof(FlatAllocation)) ------------------ | Branch (310:12): [Folded, False: 8] ------------------ 311| 8| : ends_.template Get(); 312| 8| } descriptor.cc:_ZNK6google8protobuf12_GLOBAL__N_114FlatAllocationIJcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE9EndOffsetISL_EEiv: 315| 8| int EndOffset() const { 316| 8| return ends_.template Get(); 317| 8| } descriptor.cc:_ZNK6google8protobuf12_GLOBAL__N_17TypeMapINS1_4IntTEJcNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE3GetISM_EERKiv: 243| 20| const ValueT& Get() const { 244| 20| return static_cast&>(payload_).value; 245| 20| } _ZN6google8protobuf14DescriptorPool6Tables10CheckPointC2EPKS2_: 1588| 4| static_cast(tables->flat_allocs_.size())), 1589| | misc_allocations_before_checkpoint( 1590| 4| static_cast(tables->misc_allocs_.size())), 1591| | pending_symbols_before_checkpoint( 1592| 4| tables->symbols_after_checkpoint_.size()), 1593| | pending_files_before_checkpoint( 1594| 4| tables->files_after_checkpoint_.size()), 1595| | pending_extensions_before_checkpoint( 1596| 4| tables->extensions_after_checkpoint_.size()) {} descriptor.cc:_ZNK6google8protobuf12_GLOBAL__N_118SymbolByFullNameEqclINS0_6SymbolES4_EEbRKT_RKT0_: 958| 33| bool operator()(const T& a, const U& b) const { 959| 33| return a.full_name() == b.full_name(); 960| 33| } descriptor.cc:_ZNK6google8protobuf12_GLOBAL__N_120SymbolByFullNameHashclINS0_6SymbolEEEmRKT_: 950| 796| size_t operator()(const T& s) const { 951| 796| return absl::HashOf(s.full_name()); 952| 796| } descriptor.cc:_ZNK6google8protobuf12_GLOBAL__N_121DescriptorsByNameHashINS0_14FileDescriptorEEclEPKS3_: 996| 4| size_t operator()(const DescriptorT* file) const { 997| 4| return absl::HashOf(file->name()); 998| 4| } descriptor.cc:_ZN6google8protobuf12_GLOBAL__N_117FlatAllocatorImplIJcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE9PlanArrayINS0_19EnumValueDescriptorEEEvi: 382| 18| void PlanArray(int array_size) { 383| | // We can't call PlanArray after FinalizePlanning has been called. 384| 18| ABSL_CHECK(!has_allocated()); ------------------ | | 41| 18| ABSL_LOG_INTERNAL_CHECK_IMPL((condition), #condition) | | ------------------ | | | | 26| 36| ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS, \ | | | | ------------------ | | | | | | 172| 18| ABSL_LOG_INTERNAL_##type##_CONDITION(condition) | | | | | | ------------------ | | | | | | | | 65| 36| switch (0) \ | | | | | | | | 66| 36| case 0: \ | | | | | | | | ------------------ | | | | | | | | | Branch (66:3): [True: 18, False: 0] | | | | | | | | ------------------ | | | | | | | | 67| 18| default: \ | | | | | | | | ------------------ | | | | | | | | | Branch (67:3): [True: 0, False: 18] | | | | | | | | ------------------ | | | | | | | | 68| 36| !(condition) ? (void)0 : ::absl::log_internal::Voidify()&& | | | | | | | | ------------------ | | | | | | | | | Branch (68:5): [True: 18, False: 0] | | | | | | | | | Branch (68:7): [Folded, False: 18] | | | | | | | | | Branch (68:7): [True: 0, False: 18] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 27| 36| ABSL_PREDICT_FALSE(!(condition))) \ | | | | 28| 36| ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream() | | | | ------------------ | | | | | | 66| 0| ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message) | | | | ------------------ | | ------------------ ------------------ 385| 18| if (std::is_trivially_destructible::value) { ------------------ | Branch (385:9): [True: 18, Folded] ------------------ 386| | // Trivial types are aligned to 8 bytes. 387| 18| static_assert(alignof(U) <= 8, ""); 388| 18| total_.template Get() += RoundUpTo<8>(array_size * sizeof(U)); 389| 18| } else { 390| | // Since we can't use `if constexpr`, just make the expression compile 391| | // when this path is not taken. 392| 0| using TypeToUse = 393| 0| typename std::conditional::value, 394| 0| char, U>::type; 395| 0| total_.template Get() += array_size; 396| 0| } 397| 18| } descriptor.cc:_ZN6google8protobuf12_GLOBAL__N_117FlatAllocatorImplIJcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE9PlanArrayIS9_EEvi: 382| 438| void PlanArray(int array_size) { 383| | // We can't call PlanArray after FinalizePlanning has been called. 384| 438| ABSL_CHECK(!has_allocated()); ------------------ | | 41| 438| ABSL_LOG_INTERNAL_CHECK_IMPL((condition), #condition) | | ------------------ | | | | 26| 876| ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS, \ | | | | ------------------ | | | | | | 172| 438| ABSL_LOG_INTERNAL_##type##_CONDITION(condition) | | | | | | ------------------ | | | | | | | | 65| 876| switch (0) \ | | | | | | | | 66| 876| case 0: \ | | | | | | | | ------------------ | | | | | | | | | Branch (66:3): [True: 438, False: 0] | | | | | | | | ------------------ | | | | | | | | 67| 438| default: \ | | | | | | | | ------------------ | | | | | | | | | Branch (67:3): [True: 0, False: 438] | | | | | | | | ------------------ | | | | | | | | 68| 876| !(condition) ? (void)0 : ::absl::log_internal::Voidify()&& | | | | | | | | ------------------ | | | | | | | | | Branch (68:5): [True: 438, False: 0] | | | | | | | | | Branch (68:7): [Folded, False: 438] | | | | | | | | | Branch (68:7): [True: 0, False: 438] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 27| 876| ABSL_PREDICT_FALSE(!(condition))) \ | | | | 28| 876| ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream() | | | | ------------------ | | | | | | 66| 0| ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message) | | | | ------------------ | | ------------------ ------------------ 385| 438| if (std::is_trivially_destructible::value) { ------------------ | Branch (385:9): [Folded, False: 438] ------------------ 386| | // Trivial types are aligned to 8 bytes. 387| 0| static_assert(alignof(U) <= 8, ""); 388| 0| total_.template Get() += RoundUpTo<8>(array_size * sizeof(U)); 389| 438| } else { 390| | // Since we can't use `if constexpr`, just make the expression compile 391| | // when this path is not taken. 392| 438| using TypeToUse = 393| 438| typename std::conditional::value, 394| 438| char, U>::type; 395| 438| total_.template Get() += array_size; 396| 438| } 397| 438| } descriptor.cc:_ZN6google8protobuf12_GLOBAL__N_117FlatAllocatorImplIJcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE16FinalizePlanningIPNS0_14DescriptorPool6TablesEEEvRT_: 526| 4| void FinalizePlanning(Alloc& alloc) { 527| 4| ABSL_CHECK(!has_allocated()); ------------------ | | 41| 4| ABSL_LOG_INTERNAL_CHECK_IMPL((condition), #condition) | | ------------------ | | | | 26| 8| ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS, \ | | | | ------------------ | | | | | | 172| 4| ABSL_LOG_INTERNAL_##type##_CONDITION(condition) | | | | | | ------------------ | | | | | | | | 65| 8| switch (0) \ | | | | | | | | 66| 8| case 0: \ | | | | | | | | ------------------ | | | | | | | | | Branch (66:3): [True: 4, False: 0] | | | | | | | | ------------------ | | | | | | | | 67| 4| default: \ | | | | | | | | ------------------ | | | | | | | | | Branch (67:3): [True: 0, False: 4] | | | | | | | | ------------------ | | | | | | | | 68| 8| !(condition) ? (void)0 : ::absl::log_internal::Voidify()&& | | | | | | | | ------------------ | | | | | | | | | Branch (68:5): [True: 4, False: 0] | | | | | | | | | Branch (68:7): [Folded, False: 4] | | | | | | | | | Branch (68:7): [True: 0, False: 4] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 27| 8| ABSL_PREDICT_FALSE(!(condition))) \ | | | | 28| 8| ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream() | | | | ------------------ | | | | | | 66| 0| ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message) | | | | ------------------ | | ------------------ ------------------ 528| | 529| 4| pointers_ = alloc->CreateFlatAlloc(total_)->Pointers(); 530| | 531| 4| ABSL_CHECK(has_allocated()); ------------------ | | 41| 4| ABSL_LOG_INTERNAL_CHECK_IMPL((condition), #condition) | | ------------------ | | | | 26| 8| ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS, \ | | | | ------------------ | | | | | | 172| 4| ABSL_LOG_INTERNAL_##type##_CONDITION(condition) | | | | | | ------------------ | | | | | | | | 65| 8| switch (0) \ | | | | | | | | 66| 8| case 0: \ | | | | | | | | ------------------ | | | | | | | | | Branch (66:3): [True: 4, False: 0] | | | | | | | | ------------------ | | | | | | | | 67| 4| default: \ | | | | | | | | ------------------ | | | | | | | | | Branch (67:3): [True: 0, False: 4] | | | | | | | | ------------------ | | | | | | | | 68| 8| !(condition) ? (void)0 : ::absl::log_internal::Voidify()&& | | | | | | | | ------------------ | | | | | | | | | Branch (68:5): [True: 4, False: 0] | | | | | | | | | Branch (68:7): [Folded, False: 4] | | | | | | | | | Branch (68:7): [True: 0, False: 4] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 27| 8| ABSL_PREDICT_FALSE(!(condition))) \ | | | | 28| 8| ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream() | | | | ------------------ | | | | | | 66| 0| ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message) | | | | ------------------ | | ------------------ ------------------ 532| 4| } descriptor.cc:_ZN6google8protobuf14DescriptorPool6Tables15CreateFlatAllocIJcNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEEEPNS0_12_GLOBAL__N_114FlatAllocationIJcSA_SB_SC_SD_SE_SF_SG_SH_SI_SJ_SK_SL_SM_EEERKNSN_7TypeMapINSN_4IntTEJDpT_EEE: 2027| 4| const TypeMap& sizes) { 2028| 4| auto ends = CalculateEnds(sizes); 2029| 4| using FlatAlloc = internal::FlatAllocator::Allocation; 2030| | 2031| 4| int last_end = ends.template Get< 2032| 4| typename std::tuple_element>::type>(); 2033| 4| size_t total_size = 2034| 4| last_end + RoundUpTo(sizeof(FlatAlloc)); 2035| 4| char* data = static_cast(::operator new(total_size)); 2036| 4| auto* res = ::new (data) FlatAlloc(ends); 2037| 4| flat_allocs_.emplace_back(res); 2038| | 2039| 4| return res; 2040| 4|} descriptor.cc:_ZN6google8protobuf12_GLOBAL__N_113CalculateEndsIJcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEEENS1_7TypeMapINS1_4IntTEJDpT_EEERKSQ_: 365| 4|TypeMap CalculateEnds(const TypeMap& sizes) { 366| 4| int total = 0; 367| 4| TypeMap out; 368| 4| Fold({(out.template Get() = total += 369| 4| sizeof(T) * sizes.template Get())...}); 370| 4| return out; 371| 4|} descriptor.cc:_ZN6google8protobuf12_GLOBAL__N_115ExpressionEaterC2IRiEEOT_: 157| 112| ExpressionEater(T&&) {} // NOLINT descriptor.cc:_ZN6google8protobuf12_GLOBAL__N_17TypeMapINS1_4IntTEJcNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE3GetISD_EERiv: 238| 8| ValueT& Get() { 239| 8| return static_cast&>(payload_).value; 240| 8| } descriptor.cc:_ZN6google8protobuf12_GLOBAL__N_114FlatAllocationIJcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEEC2ERKNS1_7TypeMapINS1_4IntTEJcS9_SA_SB_SC_SD_SE_SF_SG_SH_SI_SJ_SK_SL_EEE: 269| 4| explicit FlatAllocation(const TypeMap& ends) : ends_(ends) { 270| | // The arrays start just after FlatAllocation, so adjust the ends. 271| 4| Fold({(ends_.template Get() += 272| 4| RoundUpTo(sizeof(FlatAllocation)))...}); 273| 4| Fold({Init()...}); 274| 4| } descriptor.cc:_ZN6google8protobuf12_GLOBAL__N_114FlatAllocationIJcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE4InitIcEEbv: 338| 4| bool Init() { 339| | // Skip for the `char` block. No need to zero initialize it. 340| 4| if (std::is_same::value) return true; ------------------ | Branch (340:9): [True: 4, Folded] ------------------ 341| 0| for (char *p = data() + BeginOffset(), *end = data() + EndOffset(); 342| 0| p != end; p += sizeof(U)) { ------------------ | Branch (342:10): [True: 0, False: 0] ------------------ 343| 0| ::new (p) U{}; 344| 0| } 345| 0| return true; 346| 4| } descriptor.cc:_ZN6google8protobuf12_GLOBAL__N_114FlatAllocationIJcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE4InitIS9_EEbv: 338| 4| bool Init() { 339| | // Skip for the `char` block. No need to zero initialize it. 340| 4| if (std::is_same::value) return true; ------------------ | Branch (340:9): [Folded, False: 4] ------------------ 341| 4| for (char *p = data() + BeginOffset(), *end = data() + EndOffset(); 342| 824| p != end; p += sizeof(U)) { ------------------ | Branch (342:10): [True: 820, False: 4] ------------------ 343| 820| ::new (p) U{}; 344| 820| } 345| 4| return true; 346| 4| } descriptor.cc:_ZN6google8protobuf12_GLOBAL__N_114FlatAllocationIJcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE4InitISA_EEbv: 338| 4| bool Init() { 339| | // Skip for the `char` block. No need to zero initialize it. 340| 4| if (std::is_same::value) return true; ------------------ | Branch (340:9): [Folded, False: 4] ------------------ 341| 4| for (char *p = data() + BeginOffset(), *end = data() + EndOffset(); 342| 4| p != end; p += sizeof(U)) { ------------------ | Branch (342:10): [True: 0, False: 4] ------------------ 343| 0| ::new (p) U{}; 344| 0| } 345| 4| return true; 346| 4| } descriptor.cc:_ZN6google8protobuf12_GLOBAL__N_114FlatAllocationIJcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE4InitISB_EEbv: 338| 4| bool Init() { 339| | // Skip for the `char` block. No need to zero initialize it. 340| 4| if (std::is_same::value) return true; ------------------ | Branch (340:9): [Folded, False: 4] ------------------ 341| 4| for (char *p = data() + BeginOffset(), *end = data() + EndOffset(); 342| 8| p != end; p += sizeof(U)) { ------------------ | Branch (342:10): [True: 4, False: 4] ------------------ 343| 4| ::new (p) U{}; 344| 4| } 345| 4| return true; 346| 4| } descriptor.cc:_ZN6google8protobuf12_GLOBAL__N_114FlatAllocationIJcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE4InitISC_EEbv: 338| 4| bool Init() { 339| | // Skip for the `char` block. No need to zero initialize it. 340| 4| if (std::is_same::value) return true; ------------------ | Branch (340:9): [Folded, False: 4] ------------------ 341| 4| for (char *p = data() + BeginOffset(), *end = data() + EndOffset(); 342| 4| p != end; p += sizeof(U)) { ------------------ | Branch (342:10): [True: 0, False: 4] ------------------ 343| 0| ::new (p) U{}; 344| 0| } 345| 4| return true; 346| 4| } descriptor.cc:_ZN6google8protobuf12_GLOBAL__N_114FlatAllocationIJcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE4InitISD_EEbv: 338| 4| bool Init() { 339| | // Skip for the `char` block. No need to zero initialize it. 340| 4| if (std::is_same::value) return true; ------------------ | Branch (340:9): [Folded, False: 4] ------------------ 341| 4| for (char *p = data() + BeginOffset(), *end = data() + EndOffset(); 342| 4| p != end; p += sizeof(U)) { ------------------ | Branch (342:10): [True: 0, False: 4] ------------------ 343| 0| ::new (p) U{}; 344| 0| } 345| 4| return true; 346| 4| } descriptor.cc:_ZN6google8protobuf12_GLOBAL__N_114FlatAllocationIJcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE4InitISE_EEbv: 338| 4| bool Init() { 339| | // Skip for the `char` block. No need to zero initialize it. 340| 4| if (std::is_same::value) return true; ------------------ | Branch (340:9): [Folded, False: 4] ------------------ 341| 4| for (char *p = data() + BeginOffset(), *end = data() + EndOffset(); 342| 21| p != end; p += sizeof(U)) { ------------------ | Branch (342:10): [True: 17, False: 4] ------------------ 343| 17| ::new (p) U{}; 344| 17| } 345| 4| return true; 346| 4| } descriptor.cc:_ZN6google8protobuf12_GLOBAL__N_114FlatAllocationIJcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE4InitISF_EEbv: 338| 4| bool Init() { 339| | // Skip for the `char` block. No need to zero initialize it. 340| 4| if (std::is_same::value) return true; ------------------ | Branch (340:9): [Folded, False: 4] ------------------ 341| 4| for (char *p = data() + BeginOffset(), *end = data() + EndOffset(); 342| 4| p != end; p += sizeof(U)) { ------------------ | Branch (342:10): [True: 0, False: 4] ------------------ 343| 0| ::new (p) U{}; 344| 0| } 345| 4| return true; 346| 4| } descriptor.cc:_ZN6google8protobuf12_GLOBAL__N_114FlatAllocationIJcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE4InitISG_EEbv: 338| 4| bool Init() { 339| | // Skip for the `char` block. No need to zero initialize it. 340| 4| if (std::is_same::value) return true; ------------------ | Branch (340:9): [Folded, False: 4] ------------------ 341| 4| for (char *p = data() + BeginOffset(), *end = data() + EndOffset(); 342| 4| p != end; p += sizeof(U)) { ------------------ | Branch (342:10): [True: 0, False: 4] ------------------ 343| 0| ::new (p) U{}; 344| 0| } 345| 4| return true; 346| 4| } descriptor.cc:_ZN6google8protobuf12_GLOBAL__N_114FlatAllocationIJcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE4InitISH_EEbv: 338| 4| bool Init() { 339| | // Skip for the `char` block. No need to zero initialize it. 340| 4| if (std::is_same::value) return true; ------------------ | Branch (340:9): [Folded, False: 4] ------------------ 341| 4| for (char *p = data() + BeginOffset(), *end = data() + EndOffset(); 342| 4| p != end; p += sizeof(U)) { ------------------ | Branch (342:10): [True: 0, False: 4] ------------------ 343| 0| ::new (p) U{}; 344| 0| } 345| 4| return true; 346| 4| } descriptor.cc:_ZN6google8protobuf12_GLOBAL__N_114FlatAllocationIJcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE4InitISI_EEbv: 338| 4| bool Init() { 339| | // Skip for the `char` block. No need to zero initialize it. 340| 4| if (std::is_same::value) return true; ------------------ | Branch (340:9): [Folded, False: 4] ------------------ 341| 4| for (char *p = data() + BeginOffset(), *end = data() + EndOffset(); 342| 4| p != end; p += sizeof(U)) { ------------------ | Branch (342:10): [True: 0, False: 4] ------------------ 343| 0| ::new (p) U{}; 344| 0| } 345| 4| return true; 346| 4| } descriptor.cc:_ZN6google8protobuf12_GLOBAL__N_114FlatAllocationIJcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE4InitISJ_EEbv: 338| 4| bool Init() { 339| | // Skip for the `char` block. No need to zero initialize it. 340| 4| if (std::is_same::value) return true; ------------------ | Branch (340:9): [Folded, False: 4] ------------------ 341| 4| for (char *p = data() + BeginOffset(), *end = data() + EndOffset(); 342| 4| p != end; p += sizeof(U)) { ------------------ | Branch (342:10): [True: 0, False: 4] ------------------ 343| 0| ::new (p) U{}; 344| 0| } 345| 4| return true; 346| 4| } descriptor.cc:_ZN6google8protobuf12_GLOBAL__N_114FlatAllocationIJcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE4InitISK_EEbv: 338| 4| bool Init() { 339| | // Skip for the `char` block. No need to zero initialize it. 340| 4| if (std::is_same::value) return true; ------------------ | Branch (340:9): [Folded, False: 4] ------------------ 341| 4| for (char *p = data() + BeginOffset(), *end = data() + EndOffset(); 342| 4| p != end; p += sizeof(U)) { ------------------ | Branch (342:10): [True: 0, False: 4] ------------------ 343| 0| ::new (p) U{}; 344| 0| } 345| 4| return true; 346| 4| } descriptor.cc:_ZN6google8protobuf12_GLOBAL__N_114FlatAllocationIJcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE4InitISL_EEbv: 338| 4| bool Init() { 339| | // Skip for the `char` block. No need to zero initialize it. 340| 4| if (std::is_same::value) return true; ------------------ | Branch (340:9): [Folded, False: 4] ------------------ 341| 4| for (char *p = data() + BeginOffset(), *end = data() + EndOffset(); 342| 6| p != end; p += sizeof(U)) { ------------------ | Branch (342:10): [True: 2, False: 4] ------------------ 343| 2| ::new (p) U{}; 344| 2| } 345| 4| return true; 346| 4| } descriptor.cc:_ZNK6google8protobuf12_GLOBAL__N_114FlatAllocationIJcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE8PointersEv: 285| 4| TypeMap Pointers() const { 286| 4| TypeMap out; 287| 4| Fold({(out.template Get() = Begin())...}); 288| 4| return out; 289| 4| } descriptor.cc:_ZNK6google8protobuf12_GLOBAL__N_114FlatAllocationIJcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE5BeginIcEEPT_v: 324| 4| U* Begin() const { 325| 4| int begin = BeginOffset(), end = EndOffset(); 326| 4| if (begin == end) return nullptr; ------------------ | Branch (326:9): [True: 0, False: 4] ------------------ 327| 4| return reinterpret_cast(data() + begin); 328| 4| } descriptor.cc:_ZNK6google8protobuf12_GLOBAL__N_114FlatAllocationIJcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE11BeginOffsetIcEEiv: 302| 4| int BeginOffset() const { 303| 4| constexpr int type_index = FindTypeIndex(); 304| | // Avoid a negative value here to keep it compiling when type_index == 0 305| 4| constexpr int prev_type_index = type_index == 0 ? 0 : type_index - 1; ------------------ | Branch (305:37): [True: 0, Folded] ------------------ 306| 4| using PrevType = 307| 4| typename std::tuple_element>::type; 308| | // Ensure the types are properly aligned. 309| 4| static_assert(EffectiveAlignof() >= EffectiveAlignof(), ""); 310| 4| return type_index == 0 ? RoundUpTo(sizeof(FlatAllocation)) ------------------ | Branch (310:12): [True: 4, Folded] ------------------ 311| 4| : ends_.template Get(); 312| 4| } descriptor.cc:_ZNK6google8protobuf12_GLOBAL__N_114FlatAllocationIJcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE9EndOffsetIcEEiv: 315| 4| int EndOffset() const { 316| 4| return ends_.template Get(); 317| 4| } descriptor.cc:_ZN6google8protobuf12_GLOBAL__N_17TypeMapINS1_8PointerTEJcNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE3GetIcEERPT_v: 238| 450| ValueT& Get() { 239| 450| return static_cast&>(payload_).value; 240| 450| } descriptor.cc:_ZN6google8protobuf12_GLOBAL__N_115ExpressionEaterC2IRPcEEOT_: 157| 4| ExpressionEater(T&&) {} // NOLINT descriptor.cc:_ZN6google8protobuf12_GLOBAL__N_115ExpressionEaterC2IRPNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEOT_: 157| 4| ExpressionEater(T&&) {} // NOLINT descriptor.cc:_ZN6google8protobuf12_GLOBAL__N_17TypeMapINS1_8PointerTEJcNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE3GetISB_EERPT_v: 238| 4| ValueT& Get() { 239| 4| return static_cast&>(payload_).value; 240| 4| } descriptor.cc:_ZN6google8protobuf12_GLOBAL__N_115ExpressionEaterC2IRPNS0_14SourceCodeInfoEEEOT_: 157| 4| ExpressionEater(T&&) {} // NOLINT descriptor.cc:_ZN6google8protobuf12_GLOBAL__N_17TypeMapINS1_8PointerTEJcNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE3GetISC_EERPT_v: 238| 8| ValueT& Get() { 239| 8| return static_cast&>(payload_).value; 240| 8| } descriptor.cc:_ZN6google8protobuf12_GLOBAL__N_115ExpressionEaterC2IRPNS0_20FileDescriptorTablesEEEOT_: 157| 4| ExpressionEater(T&&) {} // NOLINT descriptor.cc:_ZN6google8protobuf12_GLOBAL__N_17TypeMapINS1_8PointerTEJcNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE3GetISD_EERPT_v: 238| 4| ValueT& Get() { 239| 4| return static_cast&>(payload_).value; 240| 4| } descriptor.cc:_ZN6google8protobuf12_GLOBAL__N_115ExpressionEaterC2IRPNS0_10FeatureSetEEEOT_: 157| 4| ExpressionEater(T&&) {} // NOLINT descriptor.cc:_ZN6google8protobuf12_GLOBAL__N_17TypeMapINS1_8PointerTEJcNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE3GetISE_EERPT_v: 238| 4| ValueT& Get() { 239| 4| return static_cast&>(payload_).value; 240| 4| } descriptor.cc:_ZN6google8protobuf12_GLOBAL__N_115ExpressionEaterC2IRPNS0_14MessageOptionsEEEOT_: 157| 4| ExpressionEater(T&&) {} // NOLINT descriptor.cc:_ZN6google8protobuf12_GLOBAL__N_17TypeMapINS1_8PointerTEJcNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE3GetISF_EERPT_v: 238| 21| ValueT& Get() { 239| 21| return static_cast&>(payload_).value; 240| 21| } descriptor.cc:_ZN6google8protobuf12_GLOBAL__N_115ExpressionEaterC2IRPNS0_12FieldOptionsEEEOT_: 157| 4| ExpressionEater(T&&) {} // NOLINT descriptor.cc:_ZN6google8protobuf12_GLOBAL__N_17TypeMapINS1_8PointerTEJcNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE3GetISG_EERPT_v: 238| 4| ValueT& Get() { 239| 4| return static_cast&>(payload_).value; 240| 4| } descriptor.cc:_ZN6google8protobuf12_GLOBAL__N_115ExpressionEaterC2IRPNS0_11EnumOptionsEEEOT_: 157| 4| ExpressionEater(T&&) {} // NOLINT descriptor.cc:_ZN6google8protobuf12_GLOBAL__N_17TypeMapINS1_8PointerTEJcNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE3GetISH_EERPT_v: 238| 4| ValueT& Get() { 239| 4| return static_cast&>(payload_).value; 240| 4| } descriptor.cc:_ZN6google8protobuf12_GLOBAL__N_115ExpressionEaterC2IRPNS0_16EnumValueOptionsEEEOT_: 157| 4| ExpressionEater(T&&) {} // NOLINT descriptor.cc:_ZN6google8protobuf12_GLOBAL__N_17TypeMapINS1_8PointerTEJcNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE3GetISI_EERPT_v: 238| 4| ValueT& Get() { 239| 4| return static_cast&>(payload_).value; 240| 4| } descriptor.cc:_ZN6google8protobuf12_GLOBAL__N_115ExpressionEaterC2IRPNS0_21ExtensionRangeOptionsEEEOT_: 157| 4| ExpressionEater(T&&) {} // NOLINT descriptor.cc:_ZN6google8protobuf12_GLOBAL__N_17TypeMapINS1_8PointerTEJcNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE3GetISJ_EERPT_v: 238| 4| ValueT& Get() { 239| 4| return static_cast&>(payload_).value; 240| 4| } descriptor.cc:_ZN6google8protobuf12_GLOBAL__N_115ExpressionEaterC2IRPNS0_12OneofOptionsEEEOT_: 157| 4| ExpressionEater(T&&) {} // NOLINT descriptor.cc:_ZN6google8protobuf12_GLOBAL__N_17TypeMapINS1_8PointerTEJcNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE3GetISK_EERPT_v: 238| 4| ValueT& Get() { 239| 4| return static_cast&>(payload_).value; 240| 4| } descriptor.cc:_ZN6google8protobuf12_GLOBAL__N_115ExpressionEaterC2IRPNS0_14ServiceOptionsEEEOT_: 157| 4| ExpressionEater(T&&) {} // NOLINT descriptor.cc:_ZN6google8protobuf12_GLOBAL__N_17TypeMapINS1_8PointerTEJcNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE3GetISL_EERPT_v: 238| 4| ValueT& Get() { 239| 4| return static_cast&>(payload_).value; 240| 4| } descriptor.cc:_ZN6google8protobuf12_GLOBAL__N_115ExpressionEaterC2IRPNS0_13MethodOptionsEEEOT_: 157| 4| ExpressionEater(T&&) {} // NOLINT descriptor.cc:_ZN6google8protobuf12_GLOBAL__N_17TypeMapINS1_8PointerTEJcNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE3GetISM_EERPT_v: 238| 6| ValueT& Get() { 239| 6| return static_cast&>(payload_).value; 240| 6| } descriptor.cc:_ZN6google8protobuf12_GLOBAL__N_115ExpressionEaterC2IRPNS0_11FileOptionsEEEOT_: 157| 4| ExpressionEater(T&&) {} // NOLINT descriptor.cc:_ZN6google8protobuf12_GLOBAL__N_117FlatAllocatorImplIJcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE13AllocateArrayINS0_19EnumValueDescriptorEEEPT_i: 400| 18| U* AllocateArray(int array_size) { 401| 18| constexpr bool trivial = std::is_trivially_destructible::value; 402| 18| using TypeToUse = typename std::conditional::type; 403| | 404| | // We can only allocate after FinalizePlanning has been called. 405| 18| ABSL_CHECK(has_allocated()); ------------------ | | 41| 18| ABSL_LOG_INTERNAL_CHECK_IMPL((condition), #condition) | | ------------------ | | | | 26| 36| ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS, \ | | | | ------------------ | | | | | | 172| 18| ABSL_LOG_INTERNAL_##type##_CONDITION(condition) | | | | | | ------------------ | | | | | | | | 65| 36| switch (0) \ | | | | | | | | 66| 36| case 0: \ | | | | | | | | ------------------ | | | | | | | | | Branch (66:3): [True: 18, False: 0] | | | | | | | | ------------------ | | | | | | | | 67| 18| default: \ | | | | | | | | ------------------ | | | | | | | | | Branch (67:3): [True: 0, False: 18] | | | | | | | | ------------------ | | | | | | | | 68| 36| !(condition) ? (void)0 : ::absl::log_internal::Voidify()&& | | | | | | | | ------------------ | | | | | | | | | Branch (68:5): [True: 18, False: 0] | | | | | | | | | Branch (68:7): [Folded, False: 18] | | | | | | | | | Branch (68:7): [True: 0, False: 18] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 27| 36| ABSL_PREDICT_FALSE(!(condition))) \ | | | | 28| 36| ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream() | | | | ------------------ | | | | | | 66| 0| ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message) | | | | ------------------ | | ------------------ ------------------ 406| | 407| 18| TypeToUse*& data = pointers_.template Get(); 408| 18| int& used = used_.template Get(); 409| 18| U* res = reinterpret_cast(data + used); 410| 18| used += trivial ? RoundUpTo<8>(array_size * sizeof(U)) : array_size; ------------------ | Branch (410:13): [True: 18, Folded] ------------------ 411| 18| ABSL_CHECK_LE(used, total_.template Get()); ------------------ | | 54| 18| ABSL_LOG_INTERNAL_CHECK_LE_IMPL((val1), #val1, (val2), #val2) | | ------------------ | | | | 52| 18| ABSL_LOG_INTERNAL_CHECK_OP(Check_LE, <=, val1, val1_text, val2, val2_text) | | | | ------------------ | | | | | | 61| 18| while ( \ | | | | | | 62| 18| ::std::string* absl_log_internal_check_op_result ABSL_ATTRIBUTE_UNUSED = \ | | | | | | ------------------ | | | | | | | Branch (62:22): [True: 0, False: 18] | | | | | | ------------------ | | | | | | 63| 18| ::absl::log_internal::name##Impl( \ | | | | | | 64| 18| ::absl::log_internal::GetReferenceableValue(val1), \ | | | | | | 65| 18| ::absl::log_internal::GetReferenceableValue(val2), \ | | | | | | 66| 18| ABSL_LOG_INTERNAL_STRIP_STRING_LITERAL(val1_text \ | | | | | | 67| 18| " " #op " " val2_text))) \ | | | | | | 68| 18| ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS, true) \ | | | | | | ------------------ | | | | | | | | 172| 0| ABSL_LOG_INTERNAL_##type##_CONDITION(condition) | | | | | | | | ------------------ | | | | | | | | | | 65| 0| switch (0) \ | | | | | | | | | | 66| 0| case 0: \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (66:3): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 67| 0| default: \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (67:3): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 68| 0| !(condition) ? (void)0 : ::absl::log_internal::Voidify()&& | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (68:5): [Folded, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 69| 0| ABSL_LOG_INTERNAL_CHECK(*absl_log_internal_check_op_result).InternalStream() | | | | | | ------------------ | | | | | | | | 66| 0| ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 412| 18| return res; 413| 18| } descriptor.cc:_ZNK6google8protobuf12_GLOBAL__N_116ParentNumberHashclIPNS0_19EnumValueDescriptorEEEmRKT_: 1045| 15| size_t operator()(const T& t) const { 1046| 15| return absl::HashOf(ObjectToParentNumber(t)); 1047| 15| } descriptor.cc:_ZNK6google8protobuf12_GLOBAL__N_116ParentNumberHashclIPKNS0_19EnumValueDescriptorEEEmRKT_: 1045| 14| size_t operator()(const T& t) const { 1046| 14| return absl::HashOf(ObjectToParentNumber(t)); 1047| 14| } descriptor.cc:_ZNK6google8protobuf12_GLOBAL__N_118SymbolByParentHashclINS0_6SymbolEEEmRKT_: 975| 919| size_t operator()(const T& s) const { 976| 919| return absl::HashOf(s.parent_name_key()); 977| 919| } descriptor.cc:_ZNK6google8protobuf12_GLOBAL__N_116SymbolByParentEqclINS0_6SymbolES4_EEbRKT_RKT0_: 983| 43| bool operator()(const T& a, const U& b) const { 984| 43| return a.parent_name_key() == b.parent_name_key(); 985| 43| } descriptor.cc:_ZNK6google8protobuf12_GLOBAL__N_116ParentNumberHashclIPNS0_15FieldDescriptorEEEmRKT_: 1045| 100| size_t operator()(const T& t) const { 1046| 100| return absl::HashOf(ObjectToParentNumber(t)); 1047| 100| } descriptor.cc:_ZNK6google8protobuf12_GLOBAL__N_114ParentNumberEqclIPKNS0_15FieldDescriptorEPS4_EEbRKT_RKT0_: 1053| 4| bool operator()(const T& a, const U& b) const { 1054| 4| return ObjectToParentNumber(a) == ObjectToParentNumber(b); 1055| 4| } descriptor.cc:_ZNK6google8protobuf12_GLOBAL__N_116ParentNumberHashclIPKNS0_15FieldDescriptorEEEmRKT_: 1045| 98| size_t operator()(const T& t) const { 1046| 98| return absl::HashOf(ObjectToParentNumber(t)); 1047| 98| } descriptor.cc:_ZN6google8protobuf12_GLOBAL__N_117FlatAllocatorImplIJcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE9PlanArrayINS0_14FileDescriptorEEEvi: 382| 4| void PlanArray(int array_size) { 383| | // We can't call PlanArray after FinalizePlanning has been called. 384| 4| ABSL_CHECK(!has_allocated()); ------------------ | | 41| 4| ABSL_LOG_INTERNAL_CHECK_IMPL((condition), #condition) | | ------------------ | | | | 26| 8| ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS, \ | | | | ------------------ | | | | | | 172| 4| ABSL_LOG_INTERNAL_##type##_CONDITION(condition) | | | | | | ------------------ | | | | | | | | 65| 8| switch (0) \ | | | | | | | | 66| 8| case 0: \ | | | | | | | | ------------------ | | | | | | | | | Branch (66:3): [True: 4, False: 0] | | | | | | | | ------------------ | | | | | | | | 67| 4| default: \ | | | | | | | | ------------------ | | | | | | | | | Branch (67:3): [True: 0, False: 4] | | | | | | | | ------------------ | | | | | | | | 68| 8| !(condition) ? (void)0 : ::absl::log_internal::Voidify()&& | | | | | | | | ------------------ | | | | | | | | | Branch (68:5): [True: 4, False: 0] | | | | | | | | | Branch (68:7): [Folded, False: 4] | | | | | | | | | Branch (68:7): [True: 0, False: 4] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 27| 8| ABSL_PREDICT_FALSE(!(condition))) \ | | | | 28| 8| ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream() | | | | ------------------ | | | | | | 66| 0| ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message) | | | | ------------------ | | ------------------ ------------------ 385| 4| if (std::is_trivially_destructible::value) { ------------------ | Branch (385:9): [True: 4, Folded] ------------------ 386| | // Trivial types are aligned to 8 bytes. 387| 4| static_assert(alignof(U) <= 8, ""); 388| 4| total_.template Get() += RoundUpTo<8>(array_size * sizeof(U)); 389| 4| } else { 390| | // Since we can't use `if constexpr`, just make the expression compile 391| | // when this path is not taken. 392| 0| using TypeToUse = 393| 0| typename std::conditional::value, 394| 0| char, U>::type; 395| 0| total_.template Get() += array_size; 396| 0| } 397| 4| } descriptor.cc:_ZN6google8protobuf12_GLOBAL__N_117FlatAllocatorImplIJcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE9PlanArrayINS0_14EnumDescriptorEEEvi: 382| 49| void PlanArray(int array_size) { 383| | // We can't call PlanArray after FinalizePlanning has been called. 384| 49| ABSL_CHECK(!has_allocated()); ------------------ | | 41| 49| ABSL_LOG_INTERNAL_CHECK_IMPL((condition), #condition) | | ------------------ | | | | 26| 98| ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS, \ | | | | ------------------ | | | | | | 172| 49| ABSL_LOG_INTERNAL_##type##_CONDITION(condition) | | | | | | ------------------ | | | | | | | | 65| 98| switch (0) \ | | | | | | | | 66| 98| case 0: \ | | | | | | | | ------------------ | | | | | | | | | Branch (66:3): [True: 49, False: 0] | | | | | | | | ------------------ | | | | | | | | 67| 49| default: \ | | | | | | | | ------------------ | | | | | | | | | Branch (67:3): [True: 0, False: 49] | | | | | | | | ------------------ | | | | | | | | 68| 98| !(condition) ? (void)0 : ::absl::log_internal::Voidify()&& | | | | | | | | ------------------ | | | | | | | | | Branch (68:5): [True: 49, False: 0] | | | | | | | | | Branch (68:7): [Folded, False: 49] | | | | | | | | | Branch (68:7): [True: 0, False: 49] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 27| 98| ABSL_PREDICT_FALSE(!(condition))) \ | | | | 28| 98| ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream() | | | | ------------------ | | | | | | 66| 0| ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message) | | | | ------------------ | | ------------------ ------------------ 385| 49| if (std::is_trivially_destructible::value) { ------------------ | Branch (385:9): [True: 49, Folded] ------------------ 386| | // Trivial types are aligned to 8 bytes. 387| 49| static_assert(alignof(U) <= 8, ""); 388| 49| total_.template Get() += RoundUpTo<8>(array_size * sizeof(U)); 389| 49| } else { 390| | // Since we can't use `if constexpr`, just make the expression compile 391| | // when this path is not taken. 392| 0| using TypeToUse = 393| 0| typename std::conditional::value, 394| 0| char, U>::type; 395| 0| total_.template Get() += array_size; 396| 0| } 397| 49| } descriptor.cc:_ZN6google8protobuf12_GLOBAL__N_117FlatAllocatorImplIJcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE9PlanArrayINS0_10DescriptorEEEvi: 382| 49| void PlanArray(int array_size) { 383| | // We can't call PlanArray after FinalizePlanning has been called. 384| 49| ABSL_CHECK(!has_allocated()); ------------------ | | 41| 49| ABSL_LOG_INTERNAL_CHECK_IMPL((condition), #condition) | | ------------------ | | | | 26| 98| ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS, \ | | | | ------------------ | | | | | | 172| 49| ABSL_LOG_INTERNAL_##type##_CONDITION(condition) | | | | | | ------------------ | | | | | | | | 65| 98| switch (0) \ | | | | | | | | 66| 98| case 0: \ | | | | | | | | ------------------ | | | | | | | | | Branch (66:3): [True: 49, False: 0] | | | | | | | | ------------------ | | | | | | | | 67| 49| default: \ | | | | | | | | ------------------ | | | | | | | | | Branch (67:3): [True: 0, False: 49] | | | | | | | | ------------------ | | | | | | | | 68| 98| !(condition) ? (void)0 : ::absl::log_internal::Voidify()&& | | | | | | | | ------------------ | | | | | | | | | Branch (68:5): [True: 49, False: 0] | | | | | | | | | Branch (68:7): [Folded, False: 49] | | | | | | | | | Branch (68:7): [True: 0, False: 49] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 27| 98| ABSL_PREDICT_FALSE(!(condition))) \ | | | | 28| 98| ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream() | | | | ------------------ | | | | | | 66| 0| ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message) | | | | ------------------ | | ------------------ ------------------ 385| 49| if (std::is_trivially_destructible::value) { ------------------ | Branch (385:9): [True: 49, Folded] ------------------ 386| | // Trivial types are aligned to 8 bytes. 387| 49| static_assert(alignof(U) <= 8, ""); 388| 49| total_.template Get() += RoundUpTo<8>(array_size * sizeof(U)); 389| 49| } else { 390| | // Since we can't use `if constexpr`, just make the expression compile 391| | // when this path is not taken. 392| 0| using TypeToUse = 393| 0| typename std::conditional::value, 394| 0| char, U>::type; 395| 0| total_.template Get() += array_size; 396| 0| } 397| 49| } descriptor.cc:_ZN6google8protobuf12_GLOBAL__N_117FlatAllocatorImplIJcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE9PlanArrayINS0_10Descriptor14ExtensionRangeEEEvi: 382| 45| void PlanArray(int array_size) { 383| | // We can't call PlanArray after FinalizePlanning has been called. 384| 45| ABSL_CHECK(!has_allocated()); ------------------ | | 41| 45| ABSL_LOG_INTERNAL_CHECK_IMPL((condition), #condition) | | ------------------ | | | | 26| 90| ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS, \ | | | | ------------------ | | | | | | 172| 45| ABSL_LOG_INTERNAL_##type##_CONDITION(condition) | | | | | | ------------------ | | | | | | | | 65| 90| switch (0) \ | | | | | | | | 66| 90| case 0: \ | | | | | | | | ------------------ | | | | | | | | | Branch (66:3): [True: 45, False: 0] | | | | | | | | ------------------ | | | | | | | | 67| 45| default: \ | | | | | | | | ------------------ | | | | | | | | | Branch (67:3): [True: 0, False: 45] | | | | | | | | ------------------ | | | | | | | | 68| 90| !(condition) ? (void)0 : ::absl::log_internal::Voidify()&& | | | | | | | | ------------------ | | | | | | | | | Branch (68:5): [True: 45, False: 0] | | | | | | | | | Branch (68:7): [Folded, False: 45] | | | | | | | | | Branch (68:7): [True: 0, False: 45] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 27| 90| ABSL_PREDICT_FALSE(!(condition))) \ | | | | 28| 90| ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream() | | | | ------------------ | | | | | | 66| 0| ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message) | | | | ------------------ | | ------------------ ------------------ 385| 45| if (std::is_trivially_destructible::value) { ------------------ | Branch (385:9): [True: 45, Folded] ------------------ 386| | // Trivial types are aligned to 8 bytes. 387| 45| static_assert(alignof(U) <= 8, ""); 388| 45| total_.template Get() += RoundUpTo<8>(array_size * sizeof(U)); 389| 45| } else { 390| | // Since we can't use `if constexpr`, just make the expression compile 391| | // when this path is not taken. 392| 0| using TypeToUse = 393| 0| typename std::conditional::value, 394| 0| char, U>::type; 395| 0| total_.template Get() += array_size; 396| 0| } 397| 45| } descriptor.cc:_ZN6google8protobuf12_GLOBAL__N_117FlatAllocatorImplIJcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE13AllocateArrayINS0_14EnumDescriptorEEEPT_i: 400| 49| U* AllocateArray(int array_size) { 401| 49| constexpr bool trivial = std::is_trivially_destructible::value; 402| 49| using TypeToUse = typename std::conditional::type; 403| | 404| | // We can only allocate after FinalizePlanning has been called. 405| 49| ABSL_CHECK(has_allocated()); ------------------ | | 41| 49| ABSL_LOG_INTERNAL_CHECK_IMPL((condition), #condition) | | ------------------ | | | | 26| 98| ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS, \ | | | | ------------------ | | | | | | 172| 49| ABSL_LOG_INTERNAL_##type##_CONDITION(condition) | | | | | | ------------------ | | | | | | | | 65| 98| switch (0) \ | | | | | | | | 66| 98| case 0: \ | | | | | | | | ------------------ | | | | | | | | | Branch (66:3): [True: 49, False: 0] | | | | | | | | ------------------ | | | | | | | | 67| 49| default: \ | | | | | | | | ------------------ | | | | | | | | | Branch (67:3): [True: 0, False: 49] | | | | | | | | ------------------ | | | | | | | | 68| 98| !(condition) ? (void)0 : ::absl::log_internal::Voidify()&& | | | | | | | | ------------------ | | | | | | | | | Branch (68:5): [True: 49, False: 0] | | | | | | | | | Branch (68:7): [Folded, False: 49] | | | | | | | | | Branch (68:7): [True: 0, False: 49] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 27| 98| ABSL_PREDICT_FALSE(!(condition))) \ | | | | 28| 98| ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream() | | | | ------------------ | | | | | | 66| 0| ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message) | | | | ------------------ | | ------------------ ------------------ 406| | 407| 49| TypeToUse*& data = pointers_.template Get(); 408| 49| int& used = used_.template Get(); 409| 49| U* res = reinterpret_cast(data + used); 410| 49| used += trivial ? RoundUpTo<8>(array_size * sizeof(U)) : array_size; ------------------ | Branch (410:13): [True: 49, Folded] ------------------ 411| 49| ABSL_CHECK_LE(used, total_.template Get()); ------------------ | | 54| 49| ABSL_LOG_INTERNAL_CHECK_LE_IMPL((val1), #val1, (val2), #val2) | | ------------------ | | | | 52| 49| ABSL_LOG_INTERNAL_CHECK_OP(Check_LE, <=, val1, val1_text, val2, val2_text) | | | | ------------------ | | | | | | 61| 49| while ( \ | | | | | | 62| 49| ::std::string* absl_log_internal_check_op_result ABSL_ATTRIBUTE_UNUSED = \ | | | | | | ------------------ | | | | | | | Branch (62:22): [True: 0, False: 49] | | | | | | ------------------ | | | | | | 63| 49| ::absl::log_internal::name##Impl( \ | | | | | | 64| 49| ::absl::log_internal::GetReferenceableValue(val1), \ | | | | | | 65| 49| ::absl::log_internal::GetReferenceableValue(val2), \ | | | | | | 66| 49| ABSL_LOG_INTERNAL_STRIP_STRING_LITERAL(val1_text \ | | | | | | 67| 49| " " #op " " val2_text))) \ | | | | | | 68| 49| ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS, true) \ | | | | | | ------------------ | | | | | | | | 172| 0| ABSL_LOG_INTERNAL_##type##_CONDITION(condition) | | | | | | | | ------------------ | | | | | | | | | | 65| 0| switch (0) \ | | | | | | | | | | 66| 0| case 0: \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (66:3): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 67| 0| default: \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (67:3): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 68| 0| !(condition) ? (void)0 : ::absl::log_internal::Voidify()&& | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (68:5): [Folded, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 69| 0| ABSL_LOG_INTERNAL_CHECK(*absl_log_internal_check_op_result).InternalStream() | | | | | | ------------------ | | | | | | | | 66| 0| ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 412| 49| return res; 413| 49| } descriptor.cc:_ZN6google8protobuf12_GLOBAL__N_117FlatAllocatorImplIJcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE13AllocateArrayINS0_10DescriptorEEEPT_i: 400| 49| U* AllocateArray(int array_size) { 401| 49| constexpr bool trivial = std::is_trivially_destructible::value; 402| 49| using TypeToUse = typename std::conditional::type; 403| | 404| | // We can only allocate after FinalizePlanning has been called. 405| 49| ABSL_CHECK(has_allocated()); ------------------ | | 41| 49| ABSL_LOG_INTERNAL_CHECK_IMPL((condition), #condition) | | ------------------ | | | | 26| 98| ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS, \ | | | | ------------------ | | | | | | 172| 49| ABSL_LOG_INTERNAL_##type##_CONDITION(condition) | | | | | | ------------------ | | | | | | | | 65| 98| switch (0) \ | | | | | | | | 66| 98| case 0: \ | | | | | | | | ------------------ | | | | | | | | | Branch (66:3): [True: 49, False: 0] | | | | | | | | ------------------ | | | | | | | | 67| 49| default: \ | | | | | | | | ------------------ | | | | | | | | | Branch (67:3): [True: 0, False: 49] | | | | | | | | ------------------ | | | | | | | | 68| 98| !(condition) ? (void)0 : ::absl::log_internal::Voidify()&& | | | | | | | | ------------------ | | | | | | | | | Branch (68:5): [True: 49, False: 0] | | | | | | | | | Branch (68:7): [Folded, False: 49] | | | | | | | | | Branch (68:7): [True: 0, False: 49] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 27| 98| ABSL_PREDICT_FALSE(!(condition))) \ | | | | 28| 98| ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream() | | | | ------------------ | | | | | | 66| 0| ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message) | | | | ------------------ | | ------------------ ------------------ 406| | 407| 49| TypeToUse*& data = pointers_.template Get(); 408| 49| int& used = used_.template Get(); 409| 49| U* res = reinterpret_cast(data + used); 410| 49| used += trivial ? RoundUpTo<8>(array_size * sizeof(U)) : array_size; ------------------ | Branch (410:13): [True: 49, Folded] ------------------ 411| 49| ABSL_CHECK_LE(used, total_.template Get()); ------------------ | | 54| 49| ABSL_LOG_INTERNAL_CHECK_LE_IMPL((val1), #val1, (val2), #val2) | | ------------------ | | | | 52| 49| ABSL_LOG_INTERNAL_CHECK_OP(Check_LE, <=, val1, val1_text, val2, val2_text) | | | | ------------------ | | | | | | 61| 49| while ( \ | | | | | | 62| 49| ::std::string* absl_log_internal_check_op_result ABSL_ATTRIBUTE_UNUSED = \ | | | | | | ------------------ | | | | | | | Branch (62:22): [True: 0, False: 49] | | | | | | ------------------ | | | | | | 63| 49| ::absl::log_internal::name##Impl( \ | | | | | | 64| 49| ::absl::log_internal::GetReferenceableValue(val1), \ | | | | | | 65| 49| ::absl::log_internal::GetReferenceableValue(val2), \ | | | | | | 66| 49| ABSL_LOG_INTERNAL_STRIP_STRING_LITERAL(val1_text \ | | | | | | 67| 49| " " #op " " val2_text))) \ | | | | | | 68| 49| ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS, true) \ | | | | | | ------------------ | | | | | | | | 172| 0| ABSL_LOG_INTERNAL_##type##_CONDITION(condition) | | | | | | | | ------------------ | | | | | | | | | | 65| 0| switch (0) \ | | | | | | | | | | 66| 0| case 0: \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (66:3): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 67| 0| default: \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (67:3): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 68| 0| !(condition) ? (void)0 : ::absl::log_internal::Voidify()&& | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (68:5): [Folded, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 69| 0| ABSL_LOG_INTERNAL_CHECK(*absl_log_internal_check_op_result).InternalStream() | | | | | | ------------------ | | | | | | | | 66| 0| ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 412| 49| return res; 413| 49| } descriptor.cc:_ZN6google8protobuf12_GLOBAL__N_117FlatAllocatorImplIJcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE13AllocateArrayINS0_10Descriptor14ExtensionRangeEEEPT_i: 400| 45| U* AllocateArray(int array_size) { 401| 45| constexpr bool trivial = std::is_trivially_destructible::value; 402| 45| using TypeToUse = typename std::conditional::type; 403| | 404| | // We can only allocate after FinalizePlanning has been called. 405| 45| ABSL_CHECK(has_allocated()); ------------------ | | 41| 45| ABSL_LOG_INTERNAL_CHECK_IMPL((condition), #condition) | | ------------------ | | | | 26| 90| ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS, \ | | | | ------------------ | | | | | | 172| 45| ABSL_LOG_INTERNAL_##type##_CONDITION(condition) | | | | | | ------------------ | | | | | | | | 65| 90| switch (0) \ | | | | | | | | 66| 90| case 0: \ | | | | | | | | ------------------ | | | | | | | | | Branch (66:3): [True: 45, False: 0] | | | | | | | | ------------------ | | | | | | | | 67| 45| default: \ | | | | | | | | ------------------ | | | | | | | | | Branch (67:3): [True: 0, False: 45] | | | | | | | | ------------------ | | | | | | | | 68| 90| !(condition) ? (void)0 : ::absl::log_internal::Voidify()&& | | | | | | | | ------------------ | | | | | | | | | Branch (68:5): [True: 45, False: 0] | | | | | | | | | Branch (68:7): [Folded, False: 45] | | | | | | | | | Branch (68:7): [True: 0, False: 45] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 27| 90| ABSL_PREDICT_FALSE(!(condition))) \ | | | | 28| 90| ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream() | | | | ------------------ | | | | | | 66| 0| ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message) | | | | ------------------ | | ------------------ ------------------ 406| | 407| 45| TypeToUse*& data = pointers_.template Get(); 408| 45| int& used = used_.template Get(); 409| 45| U* res = reinterpret_cast(data + used); 410| 45| used += trivial ? RoundUpTo<8>(array_size * sizeof(U)) : array_size; ------------------ | Branch (410:13): [True: 45, Folded] ------------------ 411| 45| ABSL_CHECK_LE(used, total_.template Get()); ------------------ | | 54| 45| ABSL_LOG_INTERNAL_CHECK_LE_IMPL((val1), #val1, (val2), #val2) | | ------------------ | | | | 52| 45| ABSL_LOG_INTERNAL_CHECK_OP(Check_LE, <=, val1, val1_text, val2, val2_text) | | | | ------------------ | | | | | | 61| 45| while ( \ | | | | | | 62| 45| ::std::string* absl_log_internal_check_op_result ABSL_ATTRIBUTE_UNUSED = \ | | | | | | ------------------ | | | | | | | Branch (62:22): [True: 0, False: 45] | | | | | | ------------------ | | | | | | 63| 45| ::absl::log_internal::name##Impl( \ | | | | | | 64| 45| ::absl::log_internal::GetReferenceableValue(val1), \ | | | | | | 65| 45| ::absl::log_internal::GetReferenceableValue(val2), \ | | | | | | 66| 45| ABSL_LOG_INTERNAL_STRIP_STRING_LITERAL(val1_text \ | | | | | | 67| 45| " " #op " " val2_text))) \ | | | | | | 68| 45| ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS, true) \ | | | | | | ------------------ | | | | | | | | 172| 0| ABSL_LOG_INTERNAL_##type##_CONDITION(condition) | | | | | | | | ------------------ | | | | | | | | | | 65| 0| switch (0) \ | | | | | | | | | | 66| 0| case 0: \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (66:3): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 67| 0| default: \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (67:3): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 68| 0| !(condition) ? (void)0 : ::absl::log_internal::Voidify()&& | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (68:5): [Folded, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 69| 0| ABSL_LOG_INTERNAL_CHECK(*absl_log_internal_check_op_result).InternalStream() | | | | | | ------------------ | | | | | | | | 66| 0| ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 412| 45| return res; 413| 45| } descriptor.cc:_ZN6google8protobuf12_GLOBAL__N_117FlatAllocatorImplIJcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE13AllocateArrayINS0_14FileDescriptorEEEPT_i: 400| 4| U* AllocateArray(int array_size) { 401| 4| constexpr bool trivial = std::is_trivially_destructible::value; 402| 4| using TypeToUse = typename std::conditional::type; 403| | 404| | // We can only allocate after FinalizePlanning has been called. 405| 4| ABSL_CHECK(has_allocated()); ------------------ | | 41| 4| ABSL_LOG_INTERNAL_CHECK_IMPL((condition), #condition) | | ------------------ | | | | 26| 8| ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS, \ | | | | ------------------ | | | | | | 172| 4| ABSL_LOG_INTERNAL_##type##_CONDITION(condition) | | | | | | ------------------ | | | | | | | | 65| 8| switch (0) \ | | | | | | | | 66| 8| case 0: \ | | | | | | | | ------------------ | | | | | | | | | Branch (66:3): [True: 4, False: 0] | | | | | | | | ------------------ | | | | | | | | 67| 4| default: \ | | | | | | | | ------------------ | | | | | | | | | Branch (67:3): [True: 0, False: 4] | | | | | | | | ------------------ | | | | | | | | 68| 8| !(condition) ? (void)0 : ::absl::log_internal::Voidify()&& | | | | | | | | ------------------ | | | | | | | | | Branch (68:5): [True: 4, False: 0] | | | | | | | | | Branch (68:7): [Folded, False: 4] | | | | | | | | | Branch (68:7): [True: 0, False: 4] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 27| 8| ABSL_PREDICT_FALSE(!(condition))) \ | | | | 28| 8| ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream() | | | | ------------------ | | | | | | 66| 0| ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message) | | | | ------------------ | | ------------------ ------------------ 406| | 407| 4| TypeToUse*& data = pointers_.template Get(); 408| 4| int& used = used_.template Get(); 409| 4| U* res = reinterpret_cast(data + used); 410| 4| used += trivial ? RoundUpTo<8>(array_size * sizeof(U)) : array_size; ------------------ | Branch (410:13): [True: 4, Folded] ------------------ 411| 4| ABSL_CHECK_LE(used, total_.template Get()); ------------------ | | 54| 4| ABSL_LOG_INTERNAL_CHECK_LE_IMPL((val1), #val1, (val2), #val2) | | ------------------ | | | | 52| 4| ABSL_LOG_INTERNAL_CHECK_OP(Check_LE, <=, val1, val1_text, val2, val2_text) | | | | ------------------ | | | | | | 61| 4| while ( \ | | | | | | 62| 4| ::std::string* absl_log_internal_check_op_result ABSL_ATTRIBUTE_UNUSED = \ | | | | | | ------------------ | | | | | | | Branch (62:22): [True: 0, False: 4] | | | | | | ------------------ | | | | | | 63| 4| ::absl::log_internal::name##Impl( \ | | | | | | 64| 4| ::absl::log_internal::GetReferenceableValue(val1), \ | | | | | | 65| 4| ::absl::log_internal::GetReferenceableValue(val2), \ | | | | | | 66| 4| ABSL_LOG_INTERNAL_STRIP_STRING_LITERAL(val1_text \ | | | | | | 67| 4| " " #op " " val2_text))) \ | | | | | | 68| 4| ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS, true) \ | | | | | | ------------------ | | | | | | | | 172| 0| ABSL_LOG_INTERNAL_##type##_CONDITION(condition) | | | | | | | | ------------------ | | | | | | | | | | 65| 0| switch (0) \ | | | | | | | | | | 66| 0| case 0: \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (66:3): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 67| 0| default: \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (67:3): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 68| 0| !(condition) ? (void)0 : ::absl::log_internal::Voidify()&& | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (68:5): [Folded, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 69| 0| ABSL_LOG_INTERNAL_CHECK(*absl_log_internal_check_op_result).InternalStream() | | | | | | ------------------ | | | | | | | | 66| 0| ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 412| 4| return res; 413| 4| } _ZN6google8protobuf14DescriptorPool6Tables8AllocateINS0_6Symbol10SubpackageEEEPT_v: 2010| 2|Type* DescriptorPool::Tables::Allocate() { 2011| 2| static_assert(std::is_trivially_destructible::value, ""); 2012| 2| static_assert(alignof(Type) <= 8, ""); 2013| 2| return ::new (AllocateBytes(sizeof(Type))) Type{}; 2014| 2|} _ZN6google8protobuf17DescriptorBuilder19AllocateOptionsImplINS0_14FileDescriptorEEEPKNT_11OptionsTypeENSt3__117basic_string_viewIcNS8_11char_traitsIcEEEESC_RKNS4_5ProtoEN4absl12lts_202401164SpanIKiEESC_RNS0_8internal13FlatAllocatorE: 5428| 4| internal::FlatAllocator& alloc) { 5429| 4| if (!proto.has_options()) { ------------------ | Branch (5429:7): [True: 2, False: 2] ------------------ 5430| 2| return &DescriptorT::OptionsType::default_instance(); 5431| 2| } 5432| 2| const typename DescriptorT::OptionsType& orig_options = proto.options(); 5433| | 5434| 2| auto* options = alloc.AllocateArray(1); 5435| | 5436| 2| if (!orig_options.IsInitialized()) { ------------------ | Branch (5436:7): [True: 0, False: 2] ------------------ 5437| 0| AddError(absl::StrCat(name_scope, ".", element_name), orig_options, 5438| 0| DescriptorPool::ErrorCollector::OPTION_NAME, 5439| 0| "Uninterpreted option is missing name or value."); 5440| 0| return &DescriptorT::OptionsType::default_instance(); 5441| 0| } 5442| | 5443| 2| const bool parse_success = 5444| 2| internal::ParseNoReflection(orig_options.SerializeAsString(), *options); 5445| 2| ABSL_DCHECK(parse_success); ------------------ | | 47| 2| ABSL_LOG_INTERNAL_DCHECK_IMPL((condition), #condition) | | ------------------ | | | | 43| 2| ABSL_LOG_INTERNAL_CHECK_IMPL(true || (condition), "true") | | | | ------------------ | | | | | | 26| 4| ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS, \ | | | | | | ------------------ | | | | | | | | 172| 2| ABSL_LOG_INTERNAL_##type##_CONDITION(condition) | | | | | | | | ------------------ | | | | | | | | | | 65| 4| switch (0) \ | | | | | | | | | | 66| 4| case 0: \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (66:3): [True: 2, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 67| 2| default: \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (67:3): [True: 0, False: 2] | | | | | | | | | | ------------------ | | | | | | | | | | 68| 2| !(condition) ? (void)0 : ::absl::log_internal::Voidify()&& | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (68:5): [True: 2, Folded] | | | | | | | | | | | Branch (68:7): [True: 0, Folded] | | | | | | | | | | | Branch (68:7): [True: 0, False: 0] | | | | | | | | | | | Branch (68:7): [Folded, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 27| 4| ABSL_PREDICT_FALSE(!(condition))) \ | | | | | | 28| 4| ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream() | | | | | | ------------------ | | | | | | | | 66| 0| ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 5446| | 5447| | // Don't add to options_to_interpret_ unless there were uninterpreted 5448| | // options. This not only avoids unnecessary work, but prevents a 5449| | // bootstrapping problem when building descriptors for descriptor.proto. 5450| | // descriptor.proto does not contain any uninterpreted options, but 5451| | // attempting to interpret options anyway will cause 5452| | // OptionsType::GetDescriptor() to be called which may then deadlock since 5453| | // we're still trying to build it. 5454| 2| if (options->uninterpreted_option_size() > 0) { ------------------ | Branch (5454:7): [True: 0, False: 2] ------------------ 5455| 0| options_to_interpret_.push_back(OptionsToInterpret( 5456| 0| name_scope, element_name, options_path, &orig_options, options)); 5457| 0| } 5458| | 5459| | // If the custom option is in unknown fields, no need to interpret it. 5460| | // Remove the dependency file from unused_dependency. 5461| 2| const UnknownFieldSet& unknown_fields = orig_options.unknown_fields(); 5462| 2| if (!unknown_fields.empty()) { ------------------ | Branch (5462:7): [True: 0, False: 2] ------------------ 5463| | // Can not use options->GetDescriptor() which may case deadlock. 5464| 0| Symbol msg_symbol = tables_->FindSymbol(option_name); 5465| 0| if (msg_symbol.type() == Symbol::MESSAGE) { ------------------ | Branch (5465:9): [True: 0, False: 0] ------------------ 5466| 0| for (int i = 0; i < unknown_fields.field_count(); ++i) { ------------------ | Branch (5466:23): [True: 0, False: 0] ------------------ 5467| 0| assert_mutex_held(pool_); 5468| 0| const FieldDescriptor* field = 5469| 0| pool_->InternalFindExtensionByNumberNoLock( 5470| 0| msg_symbol.descriptor(), unknown_fields.field(i).number()); 5471| 0| if (field) { ------------------ | Branch (5471:13): [True: 0, False: 0] ------------------ 5472| 0| unused_dependency_.erase(field->file()); 5473| 0| } 5474| 0| } 5475| 0| } 5476| 0| } 5477| 2| return options; 5478| 2|} descriptor.cc:_ZN6google8protobuf12_GLOBAL__N_117FlatAllocatorImplIJcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE13AllocateArrayISL_EEPT_i: 400| 2| U* AllocateArray(int array_size) { 401| 2| constexpr bool trivial = std::is_trivially_destructible::value; 402| 2| using TypeToUse = typename std::conditional::type; 403| | 404| | // We can only allocate after FinalizePlanning has been called. 405| 2| ABSL_CHECK(has_allocated()); ------------------ | | 41| 2| ABSL_LOG_INTERNAL_CHECK_IMPL((condition), #condition) | | ------------------ | | | | 26| 4| ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS, \ | | | | ------------------ | | | | | | 172| 2| ABSL_LOG_INTERNAL_##type##_CONDITION(condition) | | | | | | ------------------ | | | | | | | | 65| 4| switch (0) \ | | | | | | | | 66| 4| case 0: \ | | | | | | | | ------------------ | | | | | | | | | Branch (66:3): [True: 2, False: 0] | | | | | | | | ------------------ | | | | | | | | 67| 2| default: \ | | | | | | | | ------------------ | | | | | | | | | Branch (67:3): [True: 0, False: 2] | | | | | | | | ------------------ | | | | | | | | 68| 4| !(condition) ? (void)0 : ::absl::log_internal::Voidify()&& | | | | | | | | ------------------ | | | | | | | | | Branch (68:5): [True: 2, False: 0] | | | | | | | | | Branch (68:7): [Folded, False: 2] | | | | | | | | | Branch (68:7): [True: 0, False: 2] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 27| 4| ABSL_PREDICT_FALSE(!(condition))) \ | | | | 28| 4| ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream() | | | | ------------------ | | | | | | 66| 0| ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message) | | | | ------------------ | | ------------------ ------------------ 406| | 407| 2| TypeToUse*& data = pointers_.template Get(); 408| 2| int& used = used_.template Get(); 409| 2| U* res = reinterpret_cast(data + used); 410| 2| used += trivial ? RoundUpTo<8>(array_size * sizeof(U)) : array_size; ------------------ | Branch (410:13): [Folded, False: 2] ------------------ 411| 2| ABSL_CHECK_LE(used, total_.template Get()); ------------------ | | 54| 2| ABSL_LOG_INTERNAL_CHECK_LE_IMPL((val1), #val1, (val2), #val2) | | ------------------ | | | | 52| 2| ABSL_LOG_INTERNAL_CHECK_OP(Check_LE, <=, val1, val1_text, val2, val2_text) | | | | ------------------ | | | | | | 61| 2| while ( \ | | | | | | 62| 2| ::std::string* absl_log_internal_check_op_result ABSL_ATTRIBUTE_UNUSED = \ | | | | | | ------------------ | | | | | | | Branch (62:22): [True: 0, False: 2] | | | | | | ------------------ | | | | | | 63| 2| ::absl::log_internal::name##Impl( \ | | | | | | 64| 2| ::absl::log_internal::GetReferenceableValue(val1), \ | | | | | | 65| 2| ::absl::log_internal::GetReferenceableValue(val2), \ | | | | | | 66| 2| ABSL_LOG_INTERNAL_STRIP_STRING_LITERAL(val1_text \ | | | | | | 67| 2| " " #op " " val2_text))) \ | | | | | | 68| 2| ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS, true) \ | | | | | | ------------------ | | | | | | | | 172| 0| ABSL_LOG_INTERNAL_##type##_CONDITION(condition) | | | | | | | | ------------------ | | | | | | | | | | 65| 0| switch (0) \ | | | | | | | | | | 66| 0| case 0: \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (66:3): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 67| 0| default: \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (67:3): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 68| 0| !(condition) ? (void)0 : ::absl::log_internal::Voidify()&& | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (68:5): [Folded, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 69| 0| ABSL_LOG_INTERNAL_CHECK(*absl_log_internal_check_op_result).InternalStream() | | | | | | ------------------ | | | | | | | | 66| 0| ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 412| 2| return res; 413| 2| } _ZN6google8protobuf17DescriptorBuilder19ResolveFeaturesImplINS0_14FileDescriptorEEEvNS0_7EditionERKNT_5ProtoEPS5_PNS5_11OptionsTypeERNS0_8internal13FlatAllocatorENS0_14DescriptorPool14ErrorCollector13ErrorLocationEb: 5537| 4| bool force_merge) { 5538| 4| const FeatureSet& parent_features = GetParentFeatures(descriptor); 5539| 4| descriptor->proto_features_ = &FeatureSet::default_instance(); 5540| 4| descriptor->merged_features_ = &FeatureSet::default_instance(); 5541| | 5542| 4| ABSL_CHECK(feature_resolver_.has_value()); ------------------ | | 41| 4| ABSL_LOG_INTERNAL_CHECK_IMPL((condition), #condition) | | ------------------ | | | | 26| 8| ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS, \ | | | | ------------------ | | | | | | 172| 4| ABSL_LOG_INTERNAL_##type##_CONDITION(condition) | | | | | | ------------------ | | | | | | | | 65| 8| switch (0) \ | | | | | | | | 66| 8| case 0: \ | | | | | | | | ------------------ | | | | | | | | | Branch (66:3): [True: 4, False: 0] | | | | | | | | ------------------ | | | | | | | | 67| 4| default: \ | | | | | | | | ------------------ | | | | | | | | | Branch (67:3): [True: 0, False: 4] | | | | | | | | ------------------ | | | | | | | | 68| 8| !(condition) ? (void)0 : ::absl::log_internal::Voidify()&& | | | | | | | | ------------------ | | | | | | | | | Branch (68:5): [True: 4, False: 0] | | | | | | | | | Branch (68:7): [Folded, False: 4] | | | | | | | | | Branch (68:7): [True: 0, False: 4] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 27| 8| ABSL_PREDICT_FALSE(!(condition))) \ | | | | 28| 8| ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream() | | | | ------------------ | | | | | | 66| 0| ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message) | | | | ------------------ | | ------------------ ------------------ 5543| | 5544| 4| if (options->has_features()) { ------------------ | Branch (5544:7): [True: 0, False: 4] ------------------ 5545| | // Remove the features from the child's options proto to avoid leaking 5546| | // internal details. 5547| 0| descriptor->proto_features_ = 5548| 0| tables_->InternFeatureSet(std::move(*options->mutable_features())); 5549| 0| options->clear_features(); 5550| 0| } 5551| | 5552| 4| FeatureSet base_features = *descriptor->proto_features_; 5553| | 5554| | // Handle feature inference from proto2/proto3. 5555| 4| if (IsLegacyEdition(edition)) { ------------------ | Branch (5555:7): [True: 4, False: 0] ------------------ 5556| 4| if (descriptor->proto_features_ != &FeatureSet::default_instance()) { ------------------ | Branch (5556:9): [True: 0, False: 4] ------------------ 5557| 0| AddError(descriptor->name(), proto, error_location, 5558| 0| "Features are only valid under editions."); 5559| 0| } 5560| 4| } 5561| 4| InferLegacyProtoFeatures(proto, *options, edition, base_features); 5562| | 5563| 4| if (base_features.ByteSizeLong() == 0 && !force_merge) { ------------------ | Branch (5563:7): [True: 4, False: 0] | Branch (5563:44): [True: 0, False: 4] ------------------ 5564| | // Nothing to merge, and we aren't forcing it. 5565| 0| descriptor->merged_features_ = &parent_features; 5566| 0| return; 5567| 0| } 5568| | 5569| | // Calculate the merged features for this target. 5570| 4| absl::StatusOr merged = 5571| 4| feature_resolver_->MergeFeatures(parent_features, base_features); 5572| 4| if (!merged.ok()) { ------------------ | Branch (5572:7): [True: 0, False: 4] ------------------ 5573| 0| AddError(descriptor->name(), proto, error_location, 5574| 0| [&] { return std::string(merged.status().message()); }); 5575| 0| return; 5576| 0| } 5577| | 5578| 4| descriptor->merged_features_ = tables_->InternFeatureSet(*std::move(merged)); 5579| 4|} descriptor.cc:_ZN6google8protobuf12_GLOBAL__N_117GetParentFeaturesEPKNS0_14FileDescriptorE: 1142| 4|const FeatureSet& GetParentFeatures(const FileDescriptor* file) { 1143| 4| return FeatureSet::default_instance(); 1144| 4|} descriptor.cc:_ZN6google8protobufL24InferLegacyProtoFeaturesINS0_19FileDescriptorProtoENS0_11FileOptionsEEEvRKT_RKT0_NS0_7EditionERNS0_10FeatureSetE: 5483| 4| FeatureSet& features) {} descriptor.cc:_ZNK6google8protobuf12_GLOBAL__N_117FlatAllocatorImplIJcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE14ExpectConsumedEv: 534| 4| void ExpectConsumed() const { 535| | // We verify that we consumed all the memory requested if there was no 536| | // error in processing. 537| 4| Fold({ExpectConsumed()...}); 538| 4| } descriptor.cc:_ZNK6google8protobuf12_GLOBAL__N_117FlatAllocatorImplIJcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE14ExpectConsumedIcEEbv: 566| 4| bool ExpectConsumed() const { 567| 4| ABSL_CHECK_EQ(total_.template Get(), used_.template Get()); ------------------ | | 50| 4| ABSL_LOG_INTERNAL_CHECK_EQ_IMPL((val1), #val1, (val2), #val2) | | ------------------ | | | | 48| 4| ABSL_LOG_INTERNAL_CHECK_OP(Check_EQ, ==, val1, val1_text, val2, val2_text) | | | | ------------------ | | | | | | 61| 4| while ( \ | | | | | | 62| 4| ::std::string* absl_log_internal_check_op_result ABSL_ATTRIBUTE_UNUSED = \ | | | | | | ------------------ | | | | | | | Branch (62:22): [True: 0, False: 4] | | | | | | ------------------ | | | | | | 63| 4| ::absl::log_internal::name##Impl( \ | | | | | | 64| 4| ::absl::log_internal::GetReferenceableValue(val1), \ | | | | | | 65| 4| ::absl::log_internal::GetReferenceableValue(val2), \ | | | | | | 66| 4| ABSL_LOG_INTERNAL_STRIP_STRING_LITERAL(val1_text \ | | | | | | 67| 4| " " #op " " val2_text))) \ | | | | | | 68| 4| ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS, true) \ | | | | | | ------------------ | | | | | | | | 172| 0| ABSL_LOG_INTERNAL_##type##_CONDITION(condition) | | | | | | | | ------------------ | | | | | | | | | | 65| 0| switch (0) \ | | | | | | | | | | 66| 0| case 0: \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (66:3): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 67| 0| default: \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (67:3): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 68| 0| !(condition) ? (void)0 : ::absl::log_internal::Voidify()&& | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (68:5): [Folded, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 69| 0| ABSL_LOG_INTERNAL_CHECK(*absl_log_internal_check_op_result).InternalStream() | | | | | | ------------------ | | | | | | | | 66| 0| ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 568| 4| return true; 569| 4| } descriptor.cc:_ZNK6google8protobuf12_GLOBAL__N_117FlatAllocatorImplIJcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE14ExpectConsumedIS9_EEbv: 566| 4| bool ExpectConsumed() const { 567| 4| ABSL_CHECK_EQ(total_.template Get(), used_.template Get()); ------------------ | | 50| 4| ABSL_LOG_INTERNAL_CHECK_EQ_IMPL((val1), #val1, (val2), #val2) | | ------------------ | | | | 48| 4| ABSL_LOG_INTERNAL_CHECK_OP(Check_EQ, ==, val1, val1_text, val2, val2_text) | | | | ------------------ | | | | | | 61| 4| while ( \ | | | | | | 62| 4| ::std::string* absl_log_internal_check_op_result ABSL_ATTRIBUTE_UNUSED = \ | | | | | | ------------------ | | | | | | | Branch (62:22): [True: 0, False: 4] | | | | | | ------------------ | | | | | | 63| 4| ::absl::log_internal::name##Impl( \ | | | | | | 64| 4| ::absl::log_internal::GetReferenceableValue(val1), \ | | | | | | 65| 4| ::absl::log_internal::GetReferenceableValue(val2), \ | | | | | | 66| 4| ABSL_LOG_INTERNAL_STRIP_STRING_LITERAL(val1_text \ | | | | | | 67| 4| " " #op " " val2_text))) \ | | | | | | 68| 4| ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS, true) \ | | | | | | ------------------ | | | | | | | | 172| 0| ABSL_LOG_INTERNAL_##type##_CONDITION(condition) | | | | | | | | ------------------ | | | | | | | | | | 65| 0| switch (0) \ | | | | | | | | | | 66| 0| case 0: \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (66:3): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 67| 0| default: \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (67:3): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 68| 0| !(condition) ? (void)0 : ::absl::log_internal::Voidify()&& | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (68:5): [Folded, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 69| 0| ABSL_LOG_INTERNAL_CHECK(*absl_log_internal_check_op_result).InternalStream() | | | | | | ------------------ | | | | | | | | 66| 0| ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 568| 4| return true; 569| 4| } descriptor.cc:_ZNK6google8protobuf12_GLOBAL__N_117FlatAllocatorImplIJcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE14ExpectConsumedISA_EEbv: 566| 4| bool ExpectConsumed() const { 567| 4| ABSL_CHECK_EQ(total_.template Get(), used_.template Get()); ------------------ | | 50| 4| ABSL_LOG_INTERNAL_CHECK_EQ_IMPL((val1), #val1, (val2), #val2) | | ------------------ | | | | 48| 4| ABSL_LOG_INTERNAL_CHECK_OP(Check_EQ, ==, val1, val1_text, val2, val2_text) | | | | ------------------ | | | | | | 61| 4| while ( \ | | | | | | 62| 4| ::std::string* absl_log_internal_check_op_result ABSL_ATTRIBUTE_UNUSED = \ | | | | | | ------------------ | | | | | | | Branch (62:22): [True: 0, False: 4] | | | | | | ------------------ | | | | | | 63| 4| ::absl::log_internal::name##Impl( \ | | | | | | 64| 4| ::absl::log_internal::GetReferenceableValue(val1), \ | | | | | | 65| 4| ::absl::log_internal::GetReferenceableValue(val2), \ | | | | | | 66| 4| ABSL_LOG_INTERNAL_STRIP_STRING_LITERAL(val1_text \ | | | | | | 67| 4| " " #op " " val2_text))) \ | | | | | | 68| 4| ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS, true) \ | | | | | | ------------------ | | | | | | | | 172| 0| ABSL_LOG_INTERNAL_##type##_CONDITION(condition) | | | | | | | | ------------------ | | | | | | | | | | 65| 0| switch (0) \ | | | | | | | | | | 66| 0| case 0: \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (66:3): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 67| 0| default: \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (67:3): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 68| 0| !(condition) ? (void)0 : ::absl::log_internal::Voidify()&& | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (68:5): [Folded, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 69| 0| ABSL_LOG_INTERNAL_CHECK(*absl_log_internal_check_op_result).InternalStream() | | | | | | ------------------ | | | | | | | | 66| 0| ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 568| 4| return true; 569| 4| } descriptor.cc:_ZNK6google8protobuf12_GLOBAL__N_117FlatAllocatorImplIJcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE14ExpectConsumedISB_EEbv: 566| 4| bool ExpectConsumed() const { 567| 4| ABSL_CHECK_EQ(total_.template Get(), used_.template Get()); ------------------ | | 50| 4| ABSL_LOG_INTERNAL_CHECK_EQ_IMPL((val1), #val1, (val2), #val2) | | ------------------ | | | | 48| 4| ABSL_LOG_INTERNAL_CHECK_OP(Check_EQ, ==, val1, val1_text, val2, val2_text) | | | | ------------------ | | | | | | 61| 4| while ( \ | | | | | | 62| 4| ::std::string* absl_log_internal_check_op_result ABSL_ATTRIBUTE_UNUSED = \ | | | | | | ------------------ | | | | | | | Branch (62:22): [True: 0, False: 4] | | | | | | ------------------ | | | | | | 63| 4| ::absl::log_internal::name##Impl( \ | | | | | | 64| 4| ::absl::log_internal::GetReferenceableValue(val1), \ | | | | | | 65| 4| ::absl::log_internal::GetReferenceableValue(val2), \ | | | | | | 66| 4| ABSL_LOG_INTERNAL_STRIP_STRING_LITERAL(val1_text \ | | | | | | 67| 4| " " #op " " val2_text))) \ | | | | | | 68| 4| ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS, true) \ | | | | | | ------------------ | | | | | | | | 172| 0| ABSL_LOG_INTERNAL_##type##_CONDITION(condition) | | | | | | | | ------------------ | | | | | | | | | | 65| 0| switch (0) \ | | | | | | | | | | 66| 0| case 0: \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (66:3): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 67| 0| default: \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (67:3): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 68| 0| !(condition) ? (void)0 : ::absl::log_internal::Voidify()&& | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (68:5): [Folded, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 69| 0| ABSL_LOG_INTERNAL_CHECK(*absl_log_internal_check_op_result).InternalStream() | | | | | | ------------------ | | | | | | | | 66| 0| ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 568| 4| return true; 569| 4| } descriptor.cc:_ZNK6google8protobuf12_GLOBAL__N_117FlatAllocatorImplIJcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE14ExpectConsumedISC_EEbv: 566| 4| bool ExpectConsumed() const { 567| 4| ABSL_CHECK_EQ(total_.template Get(), used_.template Get()); ------------------ | | 50| 4| ABSL_LOG_INTERNAL_CHECK_EQ_IMPL((val1), #val1, (val2), #val2) | | ------------------ | | | | 48| 4| ABSL_LOG_INTERNAL_CHECK_OP(Check_EQ, ==, val1, val1_text, val2, val2_text) | | | | ------------------ | | | | | | 61| 4| while ( \ | | | | | | 62| 4| ::std::string* absl_log_internal_check_op_result ABSL_ATTRIBUTE_UNUSED = \ | | | | | | ------------------ | | | | | | | Branch (62:22): [True: 0, False: 4] | | | | | | ------------------ | | | | | | 63| 4| ::absl::log_internal::name##Impl( \ | | | | | | 64| 4| ::absl::log_internal::GetReferenceableValue(val1), \ | | | | | | 65| 4| ::absl::log_internal::GetReferenceableValue(val2), \ | | | | | | 66| 4| ABSL_LOG_INTERNAL_STRIP_STRING_LITERAL(val1_text \ | | | | | | 67| 4| " " #op " " val2_text))) \ | | | | | | 68| 4| ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS, true) \ | | | | | | ------------------ | | | | | | | | 172| 0| ABSL_LOG_INTERNAL_##type##_CONDITION(condition) | | | | | | | | ------------------ | | | | | | | | | | 65| 0| switch (0) \ | | | | | | | | | | 66| 0| case 0: \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (66:3): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 67| 0| default: \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (67:3): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 68| 0| !(condition) ? (void)0 : ::absl::log_internal::Voidify()&& | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (68:5): [Folded, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 69| 0| ABSL_LOG_INTERNAL_CHECK(*absl_log_internal_check_op_result).InternalStream() | | | | | | ------------------ | | | | | | | | 66| 0| ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 568| 4| return true; 569| 4| } descriptor.cc:_ZNK6google8protobuf12_GLOBAL__N_117FlatAllocatorImplIJcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE14ExpectConsumedISD_EEbv: 566| 4| bool ExpectConsumed() const { 567| 4| ABSL_CHECK_EQ(total_.template Get(), used_.template Get()); ------------------ | | 50| 4| ABSL_LOG_INTERNAL_CHECK_EQ_IMPL((val1), #val1, (val2), #val2) | | ------------------ | | | | 48| 4| ABSL_LOG_INTERNAL_CHECK_OP(Check_EQ, ==, val1, val1_text, val2, val2_text) | | | | ------------------ | | | | | | 61| 4| while ( \ | | | | | | 62| 4| ::std::string* absl_log_internal_check_op_result ABSL_ATTRIBUTE_UNUSED = \ | | | | | | ------------------ | | | | | | | Branch (62:22): [True: 0, False: 4] | | | | | | ------------------ | | | | | | 63| 4| ::absl::log_internal::name##Impl( \ | | | | | | 64| 4| ::absl::log_internal::GetReferenceableValue(val1), \ | | | | | | 65| 4| ::absl::log_internal::GetReferenceableValue(val2), \ | | | | | | 66| 4| ABSL_LOG_INTERNAL_STRIP_STRING_LITERAL(val1_text \ | | | | | | 67| 4| " " #op " " val2_text))) \ | | | | | | 68| 4| ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS, true) \ | | | | | | ------------------ | | | | | | | | 172| 0| ABSL_LOG_INTERNAL_##type##_CONDITION(condition) | | | | | | | | ------------------ | | | | | | | | | | 65| 0| switch (0) \ | | | | | | | | | | 66| 0| case 0: \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (66:3): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 67| 0| default: \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (67:3): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 68| 0| !(condition) ? (void)0 : ::absl::log_internal::Voidify()&& | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (68:5): [Folded, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 69| 0| ABSL_LOG_INTERNAL_CHECK(*absl_log_internal_check_op_result).InternalStream() | | | | | | ------------------ | | | | | | | | 66| 0| ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 568| 4| return true; 569| 4| } descriptor.cc:_ZNK6google8protobuf12_GLOBAL__N_117FlatAllocatorImplIJcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE14ExpectConsumedISE_EEbv: 566| 4| bool ExpectConsumed() const { 567| 4| ABSL_CHECK_EQ(total_.template Get(), used_.template Get()); ------------------ | | 50| 4| ABSL_LOG_INTERNAL_CHECK_EQ_IMPL((val1), #val1, (val2), #val2) | | ------------------ | | | | 48| 4| ABSL_LOG_INTERNAL_CHECK_OP(Check_EQ, ==, val1, val1_text, val2, val2_text) | | | | ------------------ | | | | | | 61| 4| while ( \ | | | | | | 62| 4| ::std::string* absl_log_internal_check_op_result ABSL_ATTRIBUTE_UNUSED = \ | | | | | | ------------------ | | | | | | | Branch (62:22): [True: 0, False: 4] | | | | | | ------------------ | | | | | | 63| 4| ::absl::log_internal::name##Impl( \ | | | | | | 64| 4| ::absl::log_internal::GetReferenceableValue(val1), \ | | | | | | 65| 4| ::absl::log_internal::GetReferenceableValue(val2), \ | | | | | | 66| 4| ABSL_LOG_INTERNAL_STRIP_STRING_LITERAL(val1_text \ | | | | | | 67| 4| " " #op " " val2_text))) \ | | | | | | 68| 4| ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS, true) \ | | | | | | ------------------ | | | | | | | | 172| 0| ABSL_LOG_INTERNAL_##type##_CONDITION(condition) | | | | | | | | ------------------ | | | | | | | | | | 65| 0| switch (0) \ | | | | | | | | | | 66| 0| case 0: \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (66:3): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 67| 0| default: \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (67:3): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 68| 0| !(condition) ? (void)0 : ::absl::log_internal::Voidify()&& | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (68:5): [Folded, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 69| 0| ABSL_LOG_INTERNAL_CHECK(*absl_log_internal_check_op_result).InternalStream() | | | | | | ------------------ | | | | | | | | 66| 0| ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 568| 4| return true; 569| 4| } descriptor.cc:_ZNK6google8protobuf12_GLOBAL__N_117FlatAllocatorImplIJcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE14ExpectConsumedISF_EEbv: 566| 4| bool ExpectConsumed() const { 567| 4| ABSL_CHECK_EQ(total_.template Get(), used_.template Get()); ------------------ | | 50| 4| ABSL_LOG_INTERNAL_CHECK_EQ_IMPL((val1), #val1, (val2), #val2) | | ------------------ | | | | 48| 4| ABSL_LOG_INTERNAL_CHECK_OP(Check_EQ, ==, val1, val1_text, val2, val2_text) | | | | ------------------ | | | | | | 61| 4| while ( \ | | | | | | 62| 4| ::std::string* absl_log_internal_check_op_result ABSL_ATTRIBUTE_UNUSED = \ | | | | | | ------------------ | | | | | | | Branch (62:22): [True: 0, False: 4] | | | | | | ------------------ | | | | | | 63| 4| ::absl::log_internal::name##Impl( \ | | | | | | 64| 4| ::absl::log_internal::GetReferenceableValue(val1), \ | | | | | | 65| 4| ::absl::log_internal::GetReferenceableValue(val2), \ | | | | | | 66| 4| ABSL_LOG_INTERNAL_STRIP_STRING_LITERAL(val1_text \ | | | | | | 67| 4| " " #op " " val2_text))) \ | | | | | | 68| 4| ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS, true) \ | | | | | | ------------------ | | | | | | | | 172| 0| ABSL_LOG_INTERNAL_##type##_CONDITION(condition) | | | | | | | | ------------------ | | | | | | | | | | 65| 0| switch (0) \ | | | | | | | | | | 66| 0| case 0: \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (66:3): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 67| 0| default: \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (67:3): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 68| 0| !(condition) ? (void)0 : ::absl::log_internal::Voidify()&& | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (68:5): [Folded, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 69| 0| ABSL_LOG_INTERNAL_CHECK(*absl_log_internal_check_op_result).InternalStream() | | | | | | ------------------ | | | | | | | | 66| 0| ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 568| 4| return true; 569| 4| } descriptor.cc:_ZNK6google8protobuf12_GLOBAL__N_117FlatAllocatorImplIJcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE14ExpectConsumedISG_EEbv: 566| 4| bool ExpectConsumed() const { 567| 4| ABSL_CHECK_EQ(total_.template Get(), used_.template Get()); ------------------ | | 50| 4| ABSL_LOG_INTERNAL_CHECK_EQ_IMPL((val1), #val1, (val2), #val2) | | ------------------ | | | | 48| 4| ABSL_LOG_INTERNAL_CHECK_OP(Check_EQ, ==, val1, val1_text, val2, val2_text) | | | | ------------------ | | | | | | 61| 4| while ( \ | | | | | | 62| 4| ::std::string* absl_log_internal_check_op_result ABSL_ATTRIBUTE_UNUSED = \ | | | | | | ------------------ | | | | | | | Branch (62:22): [True: 0, False: 4] | | | | | | ------------------ | | | | | | 63| 4| ::absl::log_internal::name##Impl( \ | | | | | | 64| 4| ::absl::log_internal::GetReferenceableValue(val1), \ | | | | | | 65| 4| ::absl::log_internal::GetReferenceableValue(val2), \ | | | | | | 66| 4| ABSL_LOG_INTERNAL_STRIP_STRING_LITERAL(val1_text \ | | | | | | 67| 4| " " #op " " val2_text))) \ | | | | | | 68| 4| ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS, true) \ | | | | | | ------------------ | | | | | | | | 172| 0| ABSL_LOG_INTERNAL_##type##_CONDITION(condition) | | | | | | | | ------------------ | | | | | | | | | | 65| 0| switch (0) \ | | | | | | | | | | 66| 0| case 0: \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (66:3): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 67| 0| default: \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (67:3): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 68| 0| !(condition) ? (void)0 : ::absl::log_internal::Voidify()&& | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (68:5): [Folded, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 69| 0| ABSL_LOG_INTERNAL_CHECK(*absl_log_internal_check_op_result).InternalStream() | | | | | | ------------------ | | | | | | | | 66| 0| ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 568| 4| return true; 569| 4| } descriptor.cc:_ZNK6google8protobuf12_GLOBAL__N_117FlatAllocatorImplIJcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE14ExpectConsumedISH_EEbv: 566| 4| bool ExpectConsumed() const { 567| 4| ABSL_CHECK_EQ(total_.template Get(), used_.template Get()); ------------------ | | 50| 4| ABSL_LOG_INTERNAL_CHECK_EQ_IMPL((val1), #val1, (val2), #val2) | | ------------------ | | | | 48| 4| ABSL_LOG_INTERNAL_CHECK_OP(Check_EQ, ==, val1, val1_text, val2, val2_text) | | | | ------------------ | | | | | | 61| 4| while ( \ | | | | | | 62| 4| ::std::string* absl_log_internal_check_op_result ABSL_ATTRIBUTE_UNUSED = \ | | | | | | ------------------ | | | | | | | Branch (62:22): [True: 0, False: 4] | | | | | | ------------------ | | | | | | 63| 4| ::absl::log_internal::name##Impl( \ | | | | | | 64| 4| ::absl::log_internal::GetReferenceableValue(val1), \ | | | | | | 65| 4| ::absl::log_internal::GetReferenceableValue(val2), \ | | | | | | 66| 4| ABSL_LOG_INTERNAL_STRIP_STRING_LITERAL(val1_text \ | | | | | | 67| 4| " " #op " " val2_text))) \ | | | | | | 68| 4| ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS, true) \ | | | | | | ------------------ | | | | | | | | 172| 0| ABSL_LOG_INTERNAL_##type##_CONDITION(condition) | | | | | | | | ------------------ | | | | | | | | | | 65| 0| switch (0) \ | | | | | | | | | | 66| 0| case 0: \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (66:3): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 67| 0| default: \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (67:3): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 68| 0| !(condition) ? (void)0 : ::absl::log_internal::Voidify()&& | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (68:5): [Folded, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 69| 0| ABSL_LOG_INTERNAL_CHECK(*absl_log_internal_check_op_result).InternalStream() | | | | | | ------------------ | | | | | | | | 66| 0| ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 568| 4| return true; 569| 4| } descriptor.cc:_ZNK6google8protobuf12_GLOBAL__N_117FlatAllocatorImplIJcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE14ExpectConsumedISI_EEbv: 566| 4| bool ExpectConsumed() const { 567| 4| ABSL_CHECK_EQ(total_.template Get(), used_.template Get()); ------------------ | | 50| 4| ABSL_LOG_INTERNAL_CHECK_EQ_IMPL((val1), #val1, (val2), #val2) | | ------------------ | | | | 48| 4| ABSL_LOG_INTERNAL_CHECK_OP(Check_EQ, ==, val1, val1_text, val2, val2_text) | | | | ------------------ | | | | | | 61| 4| while ( \ | | | | | | 62| 4| ::std::string* absl_log_internal_check_op_result ABSL_ATTRIBUTE_UNUSED = \ | | | | | | ------------------ | | | | | | | Branch (62:22): [True: 0, False: 4] | | | | | | ------------------ | | | | | | 63| 4| ::absl::log_internal::name##Impl( \ | | | | | | 64| 4| ::absl::log_internal::GetReferenceableValue(val1), \ | | | | | | 65| 4| ::absl::log_internal::GetReferenceableValue(val2), \ | | | | | | 66| 4| ABSL_LOG_INTERNAL_STRIP_STRING_LITERAL(val1_text \ | | | | | | 67| 4| " " #op " " val2_text))) \ | | | | | | 68| 4| ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS, true) \ | | | | | | ------------------ | | | | | | | | 172| 0| ABSL_LOG_INTERNAL_##type##_CONDITION(condition) | | | | | | | | ------------------ | | | | | | | | | | 65| 0| switch (0) \ | | | | | | | | | | 66| 0| case 0: \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (66:3): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 67| 0| default: \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (67:3): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 68| 0| !(condition) ? (void)0 : ::absl::log_internal::Voidify()&& | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (68:5): [Folded, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 69| 0| ABSL_LOG_INTERNAL_CHECK(*absl_log_internal_check_op_result).InternalStream() | | | | | | ------------------ | | | | | | | | 66| 0| ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 568| 4| return true; 569| 4| } descriptor.cc:_ZNK6google8protobuf12_GLOBAL__N_117FlatAllocatorImplIJcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE14ExpectConsumedISJ_EEbv: 566| 4| bool ExpectConsumed() const { 567| 4| ABSL_CHECK_EQ(total_.template Get(), used_.template Get()); ------------------ | | 50| 4| ABSL_LOG_INTERNAL_CHECK_EQ_IMPL((val1), #val1, (val2), #val2) | | ------------------ | | | | 48| 4| ABSL_LOG_INTERNAL_CHECK_OP(Check_EQ, ==, val1, val1_text, val2, val2_text) | | | | ------------------ | | | | | | 61| 4| while ( \ | | | | | | 62| 4| ::std::string* absl_log_internal_check_op_result ABSL_ATTRIBUTE_UNUSED = \ | | | | | | ------------------ | | | | | | | Branch (62:22): [True: 0, False: 4] | | | | | | ------------------ | | | | | | 63| 4| ::absl::log_internal::name##Impl( \ | | | | | | 64| 4| ::absl::log_internal::GetReferenceableValue(val1), \ | | | | | | 65| 4| ::absl::log_internal::GetReferenceableValue(val2), \ | | | | | | 66| 4| ABSL_LOG_INTERNAL_STRIP_STRING_LITERAL(val1_text \ | | | | | | 67| 4| " " #op " " val2_text))) \ | | | | | | 68| 4| ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS, true) \ | | | | | | ------------------ | | | | | | | | 172| 0| ABSL_LOG_INTERNAL_##type##_CONDITION(condition) | | | | | | | | ------------------ | | | | | | | | | | 65| 0| switch (0) \ | | | | | | | | | | 66| 0| case 0: \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (66:3): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 67| 0| default: \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (67:3): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 68| 0| !(condition) ? (void)0 : ::absl::log_internal::Voidify()&& | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (68:5): [Folded, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 69| 0| ABSL_LOG_INTERNAL_CHECK(*absl_log_internal_check_op_result).InternalStream() | | | | | | ------------------ | | | | | | | | 66| 0| ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 568| 4| return true; 569| 4| } descriptor.cc:_ZNK6google8protobuf12_GLOBAL__N_117FlatAllocatorImplIJcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE14ExpectConsumedISK_EEbv: 566| 4| bool ExpectConsumed() const { 567| 4| ABSL_CHECK_EQ(total_.template Get(), used_.template Get()); ------------------ | | 50| 4| ABSL_LOG_INTERNAL_CHECK_EQ_IMPL((val1), #val1, (val2), #val2) | | ------------------ | | | | 48| 4| ABSL_LOG_INTERNAL_CHECK_OP(Check_EQ, ==, val1, val1_text, val2, val2_text) | | | | ------------------ | | | | | | 61| 4| while ( \ | | | | | | 62| 4| ::std::string* absl_log_internal_check_op_result ABSL_ATTRIBUTE_UNUSED = \ | | | | | | ------------------ | | | | | | | Branch (62:22): [True: 0, False: 4] | | | | | | ------------------ | | | | | | 63| 4| ::absl::log_internal::name##Impl( \ | | | | | | 64| 4| ::absl::log_internal::GetReferenceableValue(val1), \ | | | | | | 65| 4| ::absl::log_internal::GetReferenceableValue(val2), \ | | | | | | 66| 4| ABSL_LOG_INTERNAL_STRIP_STRING_LITERAL(val1_text \ | | | | | | 67| 4| " " #op " " val2_text))) \ | | | | | | 68| 4| ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS, true) \ | | | | | | ------------------ | | | | | | | | 172| 0| ABSL_LOG_INTERNAL_##type##_CONDITION(condition) | | | | | | | | ------------------ | | | | | | | | | | 65| 0| switch (0) \ | | | | | | | | | | 66| 0| case 0: \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (66:3): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 67| 0| default: \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (67:3): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 68| 0| !(condition) ? (void)0 : ::absl::log_internal::Voidify()&& | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (68:5): [Folded, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 69| 0| ABSL_LOG_INTERNAL_CHECK(*absl_log_internal_check_op_result).InternalStream() | | | | | | ------------------ | | | | | | | | 66| 0| ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 568| 4| return true; 569| 4| } descriptor.cc:_ZNK6google8protobuf12_GLOBAL__N_117FlatAllocatorImplIJcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE14ExpectConsumedISL_EEbv: 566| 4| bool ExpectConsumed() const { 567| 4| ABSL_CHECK_EQ(total_.template Get(), used_.template Get()); ------------------ | | 50| 4| ABSL_LOG_INTERNAL_CHECK_EQ_IMPL((val1), #val1, (val2), #val2) | | ------------------ | | | | 48| 4| ABSL_LOG_INTERNAL_CHECK_OP(Check_EQ, ==, val1, val1_text, val2, val2_text) | | | | ------------------ | | | | | | 61| 4| while ( \ | | | | | | 62| 4| ::std::string* absl_log_internal_check_op_result ABSL_ATTRIBUTE_UNUSED = \ | | | | | | ------------------ | | | | | | | Branch (62:22): [True: 0, False: 4] | | | | | | ------------------ | | | | | | 63| 4| ::absl::log_internal::name##Impl( \ | | | | | | 64| 4| ::absl::log_internal::GetReferenceableValue(val1), \ | | | | | | 65| 4| ::absl::log_internal::GetReferenceableValue(val2), \ | | | | | | 66| 4| ABSL_LOG_INTERNAL_STRIP_STRING_LITERAL(val1_text \ | | | | | | 67| 4| " " #op " " val2_text))) \ | | | | | | 68| 4| ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS, true) \ | | | | | | ------------------ | | | | | | | | 172| 0| ABSL_LOG_INTERNAL_##type##_CONDITION(condition) | | | | | | | | ------------------ | | | | | | | | | | 65| 0| switch (0) \ | | | | | | | | | | 66| 0| case 0: \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (66:3): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 67| 0| default: \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (67:3): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 68| 0| !(condition) ? (void)0 : ::absl::log_internal::Voidify()&& | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (68:5): [Folded, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 69| 0| ABSL_LOG_INTERNAL_CHECK(*absl_log_internal_check_op_result).InternalStream() | | | | | | ------------------ | | | | | | | | 66| 0| ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 568| 4| return true; 569| 4| } descriptor.cc:_ZN6google8protobuf12_GLOBAL__N_117FlatAllocatorImplIJcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE13AllocateArrayISB_EEPT_i: 400| 4| U* AllocateArray(int array_size) { 401| 4| constexpr bool trivial = std::is_trivially_destructible::value; 402| 4| using TypeToUse = typename std::conditional::type; 403| | 404| | // We can only allocate after FinalizePlanning has been called. 405| 4| ABSL_CHECK(has_allocated()); ------------------ | | 41| 4| ABSL_LOG_INTERNAL_CHECK_IMPL((condition), #condition) | | ------------------ | | | | 26| 8| ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS, \ | | | | ------------------ | | | | | | 172| 4| ABSL_LOG_INTERNAL_##type##_CONDITION(condition) | | | | | | ------------------ | | | | | | | | 65| 8| switch (0) \ | | | | | | | | 66| 8| case 0: \ | | | | | | | | ------------------ | | | | | | | | | Branch (66:3): [True: 4, False: 0] | | | | | | | | ------------------ | | | | | | | | 67| 4| default: \ | | | | | | | | ------------------ | | | | | | | | | Branch (67:3): [True: 0, False: 4] | | | | | | | | ------------------ | | | | | | | | 68| 8| !(condition) ? (void)0 : ::absl::log_internal::Voidify()&& | | | | | | | | ------------------ | | | | | | | | | Branch (68:5): [True: 4, False: 0] | | | | | | | | | Branch (68:7): [Folded, False: 4] | | | | | | | | | Branch (68:7): [True: 0, False: 4] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 27| 8| ABSL_PREDICT_FALSE(!(condition))) \ | | | | 28| 8| ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream() | | | | ------------------ | | | | | | 66| 0| ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message) | | | | ------------------ | | ------------------ ------------------ 406| | 407| 4| TypeToUse*& data = pointers_.template Get(); 408| 4| int& used = used_.template Get(); 409| 4| U* res = reinterpret_cast(data + used); 410| 4| used += trivial ? RoundUpTo<8>(array_size * sizeof(U)) : array_size; ------------------ | Branch (410:13): [Folded, False: 4] ------------------ 411| 4| ABSL_CHECK_LE(used, total_.template Get()); ------------------ | | 54| 4| ABSL_LOG_INTERNAL_CHECK_LE_IMPL((val1), #val1, (val2), #val2) | | ------------------ | | | | 52| 4| ABSL_LOG_INTERNAL_CHECK_OP(Check_LE, <=, val1, val1_text, val2, val2_text) | | | | ------------------ | | | | | | 61| 4| while ( \ | | | | | | 62| 4| ::std::string* absl_log_internal_check_op_result ABSL_ATTRIBUTE_UNUSED = \ | | | | | | ------------------ | | | | | | | Branch (62:22): [True: 0, False: 4] | | | | | | ------------------ | | | | | | 63| 4| ::absl::log_internal::name##Impl( \ | | | | | | 64| 4| ::absl::log_internal::GetReferenceableValue(val1), \ | | | | | | 65| 4| ::absl::log_internal::GetReferenceableValue(val2), \ | | | | | | 66| 4| ABSL_LOG_INTERNAL_STRIP_STRING_LITERAL(val1_text \ | | | | | | 67| 4| " " #op " " val2_text))) \ | | | | | | 68| 4| ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS, true) \ | | | | | | ------------------ | | | | | | | | 172| 0| ABSL_LOG_INTERNAL_##type##_CONDITION(condition) | | | | | | | | ------------------ | | | | | | | | | | 65| 0| switch (0) \ | | | | | | | | | | 66| 0| case 0: \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (66:3): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 67| 0| default: \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (67:3): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 68| 0| !(condition) ? (void)0 : ::absl::log_internal::Voidify()&& | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (68:5): [Folded, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 69| 0| ABSL_LOG_INTERNAL_CHECK(*absl_log_internal_check_op_result).InternalStream() | | | | | | ------------------ | | | | | | | | 66| 0| ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 412| 4| return res; 413| 4| } descriptor.cc:_ZN6google8protobuf12_GLOBAL__N_117FlatAllocatorImplIJcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE15AllocateStringsIJRKS9_EEEPSO_DpOT_: 416| 10| const std::string* AllocateStrings(In&&... in) { 417| 10| std::string* strings = AllocateArray(sizeof...(in)); 418| 10| std::string* res = strings; 419| 10| Fold({(*strings++ = std::string(std::forward(in)))...}); 420| 10| return res; 421| 10| } descriptor.cc:_ZN6google8protobuf12_GLOBAL__N_117FlatAllocatorImplIJcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE13AllocateArrayIPKNS0_14FileDescriptorEEEPT_i: 400| 4| U* AllocateArray(int array_size) { 401| 4| constexpr bool trivial = std::is_trivially_destructible::value; 402| 4| using TypeToUse = typename std::conditional::type; 403| | 404| | // We can only allocate after FinalizePlanning has been called. 405| 4| ABSL_CHECK(has_allocated()); ------------------ | | 41| 4| ABSL_LOG_INTERNAL_CHECK_IMPL((condition), #condition) | | ------------------ | | | | 26| 8| ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS, \ | | | | ------------------ | | | | | | 172| 4| ABSL_LOG_INTERNAL_##type##_CONDITION(condition) | | | | | | ------------------ | | | | | | | | 65| 8| switch (0) \ | | | | | | | | 66| 8| case 0: \ | | | | | | | | ------------------ | | | | | | | | | Branch (66:3): [True: 4, False: 0] | | | | | | | | ------------------ | | | | | | | | 67| 4| default: \ | | | | | | | | ------------------ | | | | | | | | | Branch (67:3): [True: 0, False: 4] | | | | | | | | ------------------ | | | | | | | | 68| 8| !(condition) ? (void)0 : ::absl::log_internal::Voidify()&& | | | | | | | | ------------------ | | | | | | | | | Branch (68:5): [True: 4, False: 0] | | | | | | | | | Branch (68:7): [Folded, False: 4] | | | | | | | | | Branch (68:7): [True: 0, False: 4] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 27| 8| ABSL_PREDICT_FALSE(!(condition))) \ | | | | 28| 8| ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream() | | | | ------------------ | | | | | | 66| 0| ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message) | | | | ------------------ | | ------------------ ------------------ 406| | 407| 4| TypeToUse*& data = pointers_.template Get(); 408| 4| int& used = used_.template Get(); 409| 4| U* res = reinterpret_cast(data + used); 410| 4| used += trivial ? RoundUpTo<8>(array_size * sizeof(U)) : array_size; ------------------ | Branch (410:13): [True: 4, Folded] ------------------ 411| 4| ABSL_CHECK_LE(used, total_.template Get()); ------------------ | | 54| 4| ABSL_LOG_INTERNAL_CHECK_LE_IMPL((val1), #val1, (val2), #val2) | | ------------------ | | | | 52| 4| ABSL_LOG_INTERNAL_CHECK_OP(Check_LE, <=, val1, val1_text, val2, val2_text) | | | | ------------------ | | | | | | 61| 4| while ( \ | | | | | | 62| 4| ::std::string* absl_log_internal_check_op_result ABSL_ATTRIBUTE_UNUSED = \ | | | | | | ------------------ | | | | | | | Branch (62:22): [True: 0, False: 4] | | | | | | ------------------ | | | | | | 63| 4| ::absl::log_internal::name##Impl( \ | | | | | | 64| 4| ::absl::log_internal::GetReferenceableValue(val1), \ | | | | | | 65| 4| ::absl::log_internal::GetReferenceableValue(val2), \ | | | | | | 66| 4| ABSL_LOG_INTERNAL_STRIP_STRING_LITERAL(val1_text \ | | | | | | 67| 4| " " #op " " val2_text))) \ | | | | | | 68| 4| ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS, true) \ | | | | | | ------------------ | | | | | | | | 172| 0| ABSL_LOG_INTERNAL_##type##_CONDITION(condition) | | | | | | | | ------------------ | | | | | | | | | | 65| 0| switch (0) \ | | | | | | | | | | 66| 0| case 0: \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (66:3): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 67| 0| default: \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (67:3): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 68| 0| !(condition) ? (void)0 : ::absl::log_internal::Voidify()&& | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (68:5): [Folded, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 69| 0| ABSL_LOG_INTERNAL_CHECK(*absl_log_internal_check_op_result).InternalStream() | | | | | | ------------------ | | | | | | | | 66| 0| ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 412| 4| return res; 413| 4| } descriptor.cc:_ZN6google8protobuf12_GLOBAL__N_117FlatAllocatorImplIJcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE13AllocateArrayIiEEPT_i: 400| 8| U* AllocateArray(int array_size) { 401| 8| constexpr bool trivial = std::is_trivially_destructible::value; 402| 8| using TypeToUse = typename std::conditional::type; 403| | 404| | // We can only allocate after FinalizePlanning has been called. 405| 8| ABSL_CHECK(has_allocated()); ------------------ | | 41| 8| ABSL_LOG_INTERNAL_CHECK_IMPL((condition), #condition) | | ------------------ | | | | 26| 16| ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS, \ | | | | ------------------ | | | | | | 172| 8| ABSL_LOG_INTERNAL_##type##_CONDITION(condition) | | | | | | ------------------ | | | | | | | | 65| 16| switch (0) \ | | | | | | | | 66| 16| case 0: \ | | | | | | | | ------------------ | | | | | | | | | Branch (66:3): [True: 8, False: 0] | | | | | | | | ------------------ | | | | | | | | 67| 8| default: \ | | | | | | | | ------------------ | | | | | | | | | Branch (67:3): [True: 0, False: 8] | | | | | | | | ------------------ | | | | | | | | 68| 16| !(condition) ? (void)0 : ::absl::log_internal::Voidify()&& | | | | | | | | ------------------ | | | | | | | | | Branch (68:5): [True: 8, False: 0] | | | | | | | | | Branch (68:7): [Folded, False: 8] | | | | | | | | | Branch (68:7): [True: 0, False: 8] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 27| 16| ABSL_PREDICT_FALSE(!(condition))) \ | | | | 28| 16| ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream() | | | | ------------------ | | | | | | 66| 0| ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message) | | | | ------------------ | | ------------------ ------------------ 406| | 407| 8| TypeToUse*& data = pointers_.template Get(); 408| 8| int& used = used_.template Get(); 409| 8| U* res = reinterpret_cast(data + used); 410| 8| used += trivial ? RoundUpTo<8>(array_size * sizeof(U)) : array_size; ------------------ | Branch (410:13): [True: 8, Folded] ------------------ 411| 8| ABSL_CHECK_LE(used, total_.template Get()); ------------------ | | 54| 8| ABSL_LOG_INTERNAL_CHECK_LE_IMPL((val1), #val1, (val2), #val2) | | ------------------ | | | | 52| 8| ABSL_LOG_INTERNAL_CHECK_OP(Check_LE, <=, val1, val1_text, val2, val2_text) | | | | ------------------ | | | | | | 61| 8| while ( \ | | | | | | 62| 8| ::std::string* absl_log_internal_check_op_result ABSL_ATTRIBUTE_UNUSED = \ | | | | | | ------------------ | | | | | | | Branch (62:22): [True: 0, False: 8] | | | | | | ------------------ | | | | | | 63| 8| ::absl::log_internal::name##Impl( \ | | | | | | 64| 8| ::absl::log_internal::GetReferenceableValue(val1), \ | | | | | | 65| 8| ::absl::log_internal::GetReferenceableValue(val2), \ | | | | | | 66| 8| ABSL_LOG_INTERNAL_STRIP_STRING_LITERAL(val1_text \ | | | | | | 67| 8| " " #op " " val2_text))) \ | | | | | | 68| 8| ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS, true) \ | | | | | | ------------------ | | | | | | | | 172| 0| ABSL_LOG_INTERNAL_##type##_CONDITION(condition) | | | | | | | | ------------------ | | | | | | | | | | 65| 0| switch (0) \ | | | | | | | | | | 66| 0| case 0: \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (66:3): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 67| 0| default: \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (67:3): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 68| 0| !(condition) ? (void)0 : ::absl::log_internal::Voidify()&& | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (68:5): [Folded, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 69| 0| ABSL_LOG_INTERNAL_CHECK(*absl_log_internal_check_op_result).InternalStream() | | | | | | ------------------ | | | | | | | | 66| 0| ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 412| 8| return res; 413| 8| } descriptor.cc:_ZN6google8protobuf12_GLOBAL__N_117FlatAllocatorImplIJcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE13AllocateArrayINS0_17ServiceDescriptorEEEPT_i: 400| 4| U* AllocateArray(int array_size) { 401| 4| constexpr bool trivial = std::is_trivially_destructible::value; 402| 4| using TypeToUse = typename std::conditional::type; 403| | 404| | // We can only allocate after FinalizePlanning has been called. 405| 4| ABSL_CHECK(has_allocated()); ------------------ | | 41| 4| ABSL_LOG_INTERNAL_CHECK_IMPL((condition), #condition) | | ------------------ | | | | 26| 8| ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS, \ | | | | ------------------ | | | | | | 172| 4| ABSL_LOG_INTERNAL_##type##_CONDITION(condition) | | | | | | ------------------ | | | | | | | | 65| 8| switch (0) \ | | | | | | | | 66| 8| case 0: \ | | | | | | | | ------------------ | | | | | | | | | Branch (66:3): [True: 4, False: 0] | | | | | | | | ------------------ | | | | | | | | 67| 4| default: \ | | | | | | | | ------------------ | | | | | | | | | Branch (67:3): [True: 0, False: 4] | | | | | | | | ------------------ | | | | | | | | 68| 8| !(condition) ? (void)0 : ::absl::log_internal::Voidify()&& | | | | | | | | ------------------ | | | | | | | | | Branch (68:5): [True: 4, False: 0] | | | | | | | | | Branch (68:7): [Folded, False: 4] | | | | | | | | | Branch (68:7): [True: 0, False: 4] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 27| 8| ABSL_PREDICT_FALSE(!(condition))) \ | | | | 28| 8| ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream() | | | | ------------------ | | | | | | 66| 0| ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message) | | | | ------------------ | | ------------------ ------------------ 406| | 407| 4| TypeToUse*& data = pointers_.template Get(); 408| 4| int& used = used_.template Get(); 409| 4| U* res = reinterpret_cast(data + used); 410| 4| used += trivial ? RoundUpTo<8>(array_size * sizeof(U)) : array_size; ------------------ | Branch (410:13): [True: 4, Folded] ------------------ 411| 4| ABSL_CHECK_LE(used, total_.template Get()); ------------------ | | 54| 4| ABSL_LOG_INTERNAL_CHECK_LE_IMPL((val1), #val1, (val2), #val2) | | ------------------ | | | | 52| 4| ABSL_LOG_INTERNAL_CHECK_OP(Check_LE, <=, val1, val1_text, val2, val2_text) | | | | ------------------ | | | | | | 61| 4| while ( \ | | | | | | 62| 4| ::std::string* absl_log_internal_check_op_result ABSL_ATTRIBUTE_UNUSED = \ | | | | | | ------------------ | | | | | | | Branch (62:22): [True: 0, False: 4] | | | | | | ------------------ | | | | | | 63| 4| ::absl::log_internal::name##Impl( \ | | | | | | 64| 4| ::absl::log_internal::GetReferenceableValue(val1), \ | | | | | | 65| 4| ::absl::log_internal::GetReferenceableValue(val2), \ | | | | | | 66| 4| ABSL_LOG_INTERNAL_STRIP_STRING_LITERAL(val1_text \ | | | | | | 67| 4| " " #op " " val2_text))) \ | | | | | | 68| 4| ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS, true) \ | | | | | | ------------------ | | | | | | | | 172| 0| ABSL_LOG_INTERNAL_##type##_CONDITION(condition) | | | | | | | | ------------------ | | | | | | | | | | 65| 0| switch (0) \ | | | | | | | | | | 66| 0| case 0: \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (66:3): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 67| 0| default: \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (67:3): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 68| 0| !(condition) ? (void)0 : ::absl::log_internal::Voidify()&& | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (68:5): [Folded, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 69| 0| ABSL_LOG_INTERNAL_CHECK(*absl_log_internal_check_op_result).InternalStream() | | | | | | ------------------ | | | | | | | | 66| 0| ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 412| 4| return res; 413| 4| } descriptor.cc:_ZN6google8protobuf12_GLOBAL__N_117FlatAllocatorImplIJcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE13AllocateArrayINS0_15FieldDescriptorEEEPT_i: 400| 94| U* AllocateArray(int array_size) { 401| 94| constexpr bool trivial = std::is_trivially_destructible::value; 402| 94| using TypeToUse = typename std::conditional::type; 403| | 404| | // We can only allocate after FinalizePlanning has been called. 405| 94| ABSL_CHECK(has_allocated()); ------------------ | | 41| 94| ABSL_LOG_INTERNAL_CHECK_IMPL((condition), #condition) | | ------------------ | | | | 26| 188| ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS, \ | | | | ------------------ | | | | | | 172| 94| ABSL_LOG_INTERNAL_##type##_CONDITION(condition) | | | | | | ------------------ | | | | | | | | 65| 188| switch (0) \ | | | | | | | | 66| 188| case 0: \ | | | | | | | | ------------------ | | | | | | | | | Branch (66:3): [True: 94, False: 0] | | | | | | | | ------------------ | | | | | | | | 67| 94| default: \ | | | | | | | | ------------------ | | | | | | | | | Branch (67:3): [True: 0, False: 94] | | | | | | | | ------------------ | | | | | | | | 68| 188| !(condition) ? (void)0 : ::absl::log_internal::Voidify()&& | | | | | | | | ------------------ | | | | | | | | | Branch (68:5): [True: 94, False: 0] | | | | | | | | | Branch (68:7): [Folded, False: 94] | | | | | | | | | Branch (68:7): [True: 0, False: 94] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 27| 188| ABSL_PREDICT_FALSE(!(condition))) \ | | | | 28| 188| ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream() | | | | ------------------ | | | | | | 66| 0| ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message) | | | | ------------------ | | ------------------ ------------------ 406| | 407| 94| TypeToUse*& data = pointers_.template Get(); 408| 94| int& used = used_.template Get(); 409| 94| U* res = reinterpret_cast(data + used); 410| 94| used += trivial ? RoundUpTo<8>(array_size * sizeof(U)) : array_size; ------------------ | Branch (410:13): [True: 94, Folded] ------------------ 411| 94| ABSL_CHECK_LE(used, total_.template Get()); ------------------ | | 54| 94| ABSL_LOG_INTERNAL_CHECK_LE_IMPL((val1), #val1, (val2), #val2) | | ------------------ | | | | 52| 94| ABSL_LOG_INTERNAL_CHECK_OP(Check_LE, <=, val1, val1_text, val2, val2_text) | | | | ------------------ | | | | | | 61| 94| while ( \ | | | | | | 62| 94| ::std::string* absl_log_internal_check_op_result ABSL_ATTRIBUTE_UNUSED = \ | | | | | | ------------------ | | | | | | | Branch (62:22): [True: 0, False: 94] | | | | | | ------------------ | | | | | | 63| 94| ::absl::log_internal::name##Impl( \ | | | | | | 64| 94| ::absl::log_internal::GetReferenceableValue(val1), \ | | | | | | 65| 94| ::absl::log_internal::GetReferenceableValue(val2), \ | | | | | | 66| 94| ABSL_LOG_INTERNAL_STRIP_STRING_LITERAL(val1_text \ | | | | | | 67| 94| " " #op " " val2_text))) \ | | | | | | 68| 94| ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS, true) \ | | | | | | ------------------ | | | | | | | | 172| 0| ABSL_LOG_INTERNAL_##type##_CONDITION(condition) | | | | | | | | ------------------ | | | | | | | | | | 65| 0| switch (0) \ | | | | | | | | | | 66| 0| case 0: \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (66:3): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 67| 0| default: \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (67:3): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 68| 0| !(condition) ? (void)0 : ::absl::log_internal::Voidify()&& | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (68:5): [Folded, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 69| 0| ABSL_LOG_INTERNAL_CHECK(*absl_log_internal_check_op_result).InternalStream() | | | | | | ------------------ | | | | | | | | 66| 0| ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 412| 94| return res; 413| 94| } descriptor.cc:_ZZN6google8protobuf17DescriptorBuilder13BuildFileImplERKNS0_19FileDescriptorProtoERNS0_8internal13FlatAllocatorEENK3$_3clERKNS0_15FieldDescriptorERKNS0_20FieldDescriptorProtoE: 6161| 206| [&](const FieldDescriptor& field, const FieldDescriptorProto& proto) { 6162| 206| if (field.options_->has_ctype() && field.options_->features() ------------------ | Branch (6162:15): [True: 0, False: 206] | Branch (6162:46): [True: 0, False: 0] ------------------ 6163| 0| .GetExtension(pb::cpp) 6164| 0| .has_string_type()) { 6165| 0| AddError(field.full_name(), proto, 6166| 0| DescriptorPool::ErrorCollector::TYPE, [&] { 6167| 0| return absl::StrFormat( 6168| 0| "Field %s specifies both string_type and ctype " 6169| 0| "which is not supported.", 6170| 0| field.full_name()); 6171| 0| }); 6172| 0| } 6173| 206| }); descriptor.cc:_ZZN6google8protobuf17DescriptorBuilder13BuildFileImplERKNS0_19FileDescriptorProtoERNS0_8internal13FlatAllocatorEENK3$_4clINS0_14FileDescriptorES2_EEDaRKT_RKT0_: 6180| 4| *result, proto, [&](const auto& descriptor, const auto& proto) { 6181| 4| using OptionsT = 6182| 4| typename std::remove_const::type>::type; 6184| 4| using DescriptorT = 6185| 4| typename std::remove_const::type>::type; 6187| | 6188| 4| ResolveFeatures( 6189| 4| proto, const_cast(&descriptor), 6190| 4| const_cast< // NOLINT(google3-runtime-proto-const-cast) 6191| 4| OptionsT*>(descriptor.options_), 6192| 4| alloc); 6193| 4| }); descriptor.cc:_ZZN6google8protobuf17DescriptorBuilder13BuildFileImplERKNS0_19FileDescriptorProtoERNS0_8internal13FlatAllocatorEENK3$_4clINS0_10DescriptorENS0_15DescriptorProtoEEEDaRKT_RKT0_: 6180| 45| *result, proto, [&](const auto& descriptor, const auto& proto) { 6181| 45| using OptionsT = 6182| 45| typename std::remove_const::type>::type; 6184| 45| using DescriptorT = 6185| 45| typename std::remove_const::type>::type; 6187| | 6188| 45| ResolveFeatures( 6189| 45| proto, const_cast(&descriptor), 6190| 45| const_cast< // NOLINT(google3-runtime-proto-const-cast) 6191| 45| OptionsT*>(descriptor.options_), 6192| 45| alloc); 6193| 45| }); _ZN6google8protobuf17DescriptorBuilder15ResolveFeaturesINS0_10DescriptorEEEvRKNT_5ProtoEPS4_PNS4_11OptionsTypeERNS0_8internal13FlatAllocatorE: 5585| 45| internal::FlatAllocator& alloc) { 5586| 45| ResolveFeaturesImpl(descriptor->file()->edition(), proto, descriptor, options, 5587| 45| alloc, DescriptorPool::ErrorCollector::NAME); 5588| 45|} _ZN6google8protobuf17DescriptorBuilder19ResolveFeaturesImplINS0_10DescriptorEEEvNS0_7EditionERKNT_5ProtoEPS5_PNS5_11OptionsTypeERNS0_8internal13FlatAllocatorENS0_14DescriptorPool14ErrorCollector13ErrorLocationEb: 5537| 45| bool force_merge) { 5538| 45| const FeatureSet& parent_features = GetParentFeatures(descriptor); 5539| 45| descriptor->proto_features_ = &FeatureSet::default_instance(); 5540| 45| descriptor->merged_features_ = &FeatureSet::default_instance(); 5541| | 5542| 45| ABSL_CHECK(feature_resolver_.has_value()); ------------------ | | 41| 45| ABSL_LOG_INTERNAL_CHECK_IMPL((condition), #condition) | | ------------------ | | | | 26| 90| ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS, \ | | | | ------------------ | | | | | | 172| 45| ABSL_LOG_INTERNAL_##type##_CONDITION(condition) | | | | | | ------------------ | | | | | | | | 65| 90| switch (0) \ | | | | | | | | 66| 90| case 0: \ | | | | | | | | ------------------ | | | | | | | | | Branch (66:3): [True: 45, False: 0] | | | | | | | | ------------------ | | | | | | | | 67| 45| default: \ | | | | | | | | ------------------ | | | | | | | | | Branch (67:3): [True: 0, False: 45] | | | | | | | | ------------------ | | | | | | | | 68| 90| !(condition) ? (void)0 : ::absl::log_internal::Voidify()&& | | | | | | | | ------------------ | | | | | | | | | Branch (68:5): [True: 45, False: 0] | | | | | | | | | Branch (68:7): [Folded, False: 45] | | | | | | | | | Branch (68:7): [True: 0, False: 45] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 27| 90| ABSL_PREDICT_FALSE(!(condition))) \ | | | | 28| 90| ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream() | | | | ------------------ | | | | | | 66| 0| ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message) | | | | ------------------ | | ------------------ ------------------ 5543| | 5544| 45| if (options->has_features()) { ------------------ | Branch (5544:7): [True: 0, False: 45] ------------------ 5545| | // Remove the features from the child's options proto to avoid leaking 5546| | // internal details. 5547| 0| descriptor->proto_features_ = 5548| 0| tables_->InternFeatureSet(std::move(*options->mutable_features())); 5549| 0| options->clear_features(); 5550| 0| } 5551| | 5552| 45| FeatureSet base_features = *descriptor->proto_features_; 5553| | 5554| | // Handle feature inference from proto2/proto3. 5555| 45| if (IsLegacyEdition(edition)) { ------------------ | Branch (5555:7): [True: 45, False: 0] ------------------ 5556| 45| if (descriptor->proto_features_ != &FeatureSet::default_instance()) { ------------------ | Branch (5556:9): [True: 0, False: 45] ------------------ 5557| 0| AddError(descriptor->name(), proto, error_location, 5558| 0| "Features are only valid under editions."); 5559| 0| } 5560| 45| } 5561| 45| InferLegacyProtoFeatures(proto, *options, edition, base_features); 5562| | 5563| 45| if (base_features.ByteSizeLong() == 0 && !force_merge) { ------------------ | Branch (5563:7): [True: 45, False: 0] | Branch (5563:44): [True: 45, False: 0] ------------------ 5564| | // Nothing to merge, and we aren't forcing it. 5565| 45| descriptor->merged_features_ = &parent_features; 5566| 45| return; 5567| 45| } 5568| | 5569| | // Calculate the merged features for this target. 5570| 0| absl::StatusOr merged = 5571| 0| feature_resolver_->MergeFeatures(parent_features, base_features); 5572| 0| if (!merged.ok()) { ------------------ | Branch (5572:7): [True: 0, False: 0] ------------------ 5573| 0| AddError(descriptor->name(), proto, error_location, 5574| 0| [&] { return std::string(merged.status().message()); }); 5575| 0| return; 5576| 0| } 5577| | 5578| 0| descriptor->merged_features_ = tables_->InternFeatureSet(*std::move(merged)); 5579| 0|} descriptor.cc:_ZN6google8protobuf12_GLOBAL__N_117GetParentFeaturesEPKNS0_10DescriptorE: 1146| 45|const FeatureSet& GetParentFeatures(const Descriptor* message) { 1147| 45| if (message->containing_type() == nullptr) { ------------------ | Branch (1147:7): [True: 35, False: 10] ------------------ 1148| 35| return internal::InternalFeatureHelper::GetFeatures(*message->file()); 1149| 35| } 1150| 10| return internal::InternalFeatureHelper::GetFeatures( 1151| 10| *message->containing_type()); 1152| 45|} descriptor.cc:_ZN6google8protobufL24InferLegacyProtoFeaturesINS0_15DescriptorProtoENS0_14MessageOptionsEEEvRKT_RKT0_NS0_7EditionERNS0_10FeatureSetE: 5483| 45| FeatureSet& features) {} descriptor.cc:_ZZN6google8protobuf17DescriptorBuilder13BuildFileImplERKNS0_19FileDescriptorProtoERNS0_8internal13FlatAllocatorEENK3$_4clINS0_15OneofDescriptorENS0_20OneofDescriptorProtoEEEDaRKT_RKT0_: 6180| 2| *result, proto, [&](const auto& descriptor, const auto& proto) { 6181| 2| using OptionsT = 6182| 2| typename std::remove_const::type>::type; 6184| 2| using DescriptorT = 6185| 2| typename std::remove_const::type>::type; 6187| | 6188| 2| ResolveFeatures( 6189| 2| proto, const_cast(&descriptor), 6190| 2| const_cast< // NOLINT(google3-runtime-proto-const-cast) 6191| 2| OptionsT*>(descriptor.options_), 6192| 2| alloc); 6193| 2| }); _ZN6google8protobuf17DescriptorBuilder15ResolveFeaturesINS0_15OneofDescriptorEEEvRKNT_5ProtoEPS4_PNS4_11OptionsTypeERNS0_8internal13FlatAllocatorE: 5585| 2| internal::FlatAllocator& alloc) { 5586| 2| ResolveFeaturesImpl(descriptor->file()->edition(), proto, descriptor, options, 5587| 2| alloc, DescriptorPool::ErrorCollector::NAME); 5588| 2|} _ZN6google8protobuf17DescriptorBuilder19ResolveFeaturesImplINS0_15OneofDescriptorEEEvNS0_7EditionERKNT_5ProtoEPS5_PNS5_11OptionsTypeERNS0_8internal13FlatAllocatorENS0_14DescriptorPool14ErrorCollector13ErrorLocationEb: 5537| 2| bool force_merge) { 5538| 2| const FeatureSet& parent_features = GetParentFeatures(descriptor); 5539| 2| descriptor->proto_features_ = &FeatureSet::default_instance(); 5540| 2| descriptor->merged_features_ = &FeatureSet::default_instance(); 5541| | 5542| 2| ABSL_CHECK(feature_resolver_.has_value()); ------------------ | | 41| 2| ABSL_LOG_INTERNAL_CHECK_IMPL((condition), #condition) | | ------------------ | | | | 26| 4| ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS, \ | | | | ------------------ | | | | | | 172| 2| ABSL_LOG_INTERNAL_##type##_CONDITION(condition) | | | | | | ------------------ | | | | | | | | 65| 4| switch (0) \ | | | | | | | | 66| 4| case 0: \ | | | | | | | | ------------------ | | | | | | | | | Branch (66:3): [True: 2, False: 0] | | | | | | | | ------------------ | | | | | | | | 67| 2| default: \ | | | | | | | | ------------------ | | | | | | | | | Branch (67:3): [True: 0, False: 2] | | | | | | | | ------------------ | | | | | | | | 68| 4| !(condition) ? (void)0 : ::absl::log_internal::Voidify()&& | | | | | | | | ------------------ | | | | | | | | | Branch (68:5): [True: 2, False: 0] | | | | | | | | | Branch (68:7): [Folded, False: 2] | | | | | | | | | Branch (68:7): [True: 0, False: 2] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 27| 4| ABSL_PREDICT_FALSE(!(condition))) \ | | | | 28| 4| ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream() | | | | ------------------ | | | | | | 66| 0| ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message) | | | | ------------------ | | ------------------ ------------------ 5543| | 5544| 2| if (options->has_features()) { ------------------ | Branch (5544:7): [True: 0, False: 2] ------------------ 5545| | // Remove the features from the child's options proto to avoid leaking 5546| | // internal details. 5547| 0| descriptor->proto_features_ = 5548| 0| tables_->InternFeatureSet(std::move(*options->mutable_features())); 5549| 0| options->clear_features(); 5550| 0| } 5551| | 5552| 2| FeatureSet base_features = *descriptor->proto_features_; 5553| | 5554| | // Handle feature inference from proto2/proto3. 5555| 2| if (IsLegacyEdition(edition)) { ------------------ | Branch (5555:7): [True: 2, False: 0] ------------------ 5556| 2| if (descriptor->proto_features_ != &FeatureSet::default_instance()) { ------------------ | Branch (5556:9): [True: 0, False: 2] ------------------ 5557| 0| AddError(descriptor->name(), proto, error_location, 5558| 0| "Features are only valid under editions."); 5559| 0| } 5560| 2| } 5561| 2| InferLegacyProtoFeatures(proto, *options, edition, base_features); 5562| | 5563| 2| if (base_features.ByteSizeLong() == 0 && !force_merge) { ------------------ | Branch (5563:7): [True: 2, False: 0] | Branch (5563:44): [True: 2, False: 0] ------------------ 5564| | // Nothing to merge, and we aren't forcing it. 5565| 2| descriptor->merged_features_ = &parent_features; 5566| 2| return; 5567| 2| } 5568| | 5569| | // Calculate the merged features for this target. 5570| 0| absl::StatusOr merged = 5571| 0| feature_resolver_->MergeFeatures(parent_features, base_features); 5572| 0| if (!merged.ok()) { ------------------ | Branch (5572:7): [True: 0, False: 0] ------------------ 5573| 0| AddError(descriptor->name(), proto, error_location, 5574| 0| [&] { return std::string(merged.status().message()); }); 5575| 0| return; 5576| 0| } 5577| | 5578| 0| descriptor->merged_features_ = tables_->InternFeatureSet(*std::move(merged)); 5579| 0|} descriptor.cc:_ZN6google8protobuf12_GLOBAL__N_117GetParentFeaturesEPKNS0_15OneofDescriptorE: 1154| 2|const FeatureSet& GetParentFeatures(const OneofDescriptor* oneof) { 1155| 2| return internal::InternalFeatureHelper::GetFeatures( 1156| 2| *oneof->containing_type()); 1157| 2|} descriptor.cc:_ZN6google8protobufL24InferLegacyProtoFeaturesINS0_20OneofDescriptorProtoENS0_12OneofOptionsEEEvRKT_RKT0_NS0_7EditionERNS0_10FeatureSetE: 5483| 2| FeatureSet& features) {} descriptor.cc:_ZZN6google8protobuf17DescriptorBuilder13BuildFileImplERKNS0_19FileDescriptorProtoERNS0_8internal13FlatAllocatorEENK3$_4clINS0_10Descriptor14ExtensionRangeENS0_30DescriptorProto_ExtensionRangeEEEDaRKT_RKT0_: 6180| 14| *result, proto, [&](const auto& descriptor, const auto& proto) { 6181| 14| using OptionsT = 6182| 14| typename std::remove_const::type>::type; 6184| 14| using DescriptorT = 6185| 14| typename std::remove_const::type>::type; 6187| | 6188| 14| ResolveFeatures( 6189| 14| proto, const_cast(&descriptor), 6190| 14| const_cast< // NOLINT(google3-runtime-proto-const-cast) 6191| 14| OptionsT*>(descriptor.options_), 6192| 14| alloc); 6193| 14| }); _ZN6google8protobuf17DescriptorBuilder15ResolveFeaturesINS0_10Descriptor14ExtensionRangeEEEvRKNT_5ProtoEPS5_PNS5_11OptionsTypeERNS0_8internal13FlatAllocatorE: 5585| 14| internal::FlatAllocator& alloc) { 5586| 14| ResolveFeaturesImpl(descriptor->file()->edition(), proto, descriptor, options, 5587| 14| alloc, DescriptorPool::ErrorCollector::NAME); 5588| 14|} _ZN6google8protobuf17DescriptorBuilder19ResolveFeaturesImplINS0_10Descriptor14ExtensionRangeEEEvNS0_7EditionERKNT_5ProtoEPS6_PNS6_11OptionsTypeERNS0_8internal13FlatAllocatorENS0_14DescriptorPool14ErrorCollector13ErrorLocationEb: 5537| 14| bool force_merge) { 5538| 14| const FeatureSet& parent_features = GetParentFeatures(descriptor); 5539| 14| descriptor->proto_features_ = &FeatureSet::default_instance(); 5540| 14| descriptor->merged_features_ = &FeatureSet::default_instance(); 5541| | 5542| 14| ABSL_CHECK(feature_resolver_.has_value()); ------------------ | | 41| 14| ABSL_LOG_INTERNAL_CHECK_IMPL((condition), #condition) | | ------------------ | | | | 26| 28| ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS, \ | | | | ------------------ | | | | | | 172| 14| ABSL_LOG_INTERNAL_##type##_CONDITION(condition) | | | | | | ------------------ | | | | | | | | 65| 28| switch (0) \ | | | | | | | | 66| 28| case 0: \ | | | | | | | | ------------------ | | | | | | | | | Branch (66:3): [True: 14, False: 0] | | | | | | | | ------------------ | | | | | | | | 67| 14| default: \ | | | | | | | | ------------------ | | | | | | | | | Branch (67:3): [True: 0, False: 14] | | | | | | | | ------------------ | | | | | | | | 68| 28| !(condition) ? (void)0 : ::absl::log_internal::Voidify()&& | | | | | | | | ------------------ | | | | | | | | | Branch (68:5): [True: 14, False: 0] | | | | | | | | | Branch (68:7): [Folded, False: 14] | | | | | | | | | Branch (68:7): [True: 0, False: 14] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 27| 28| ABSL_PREDICT_FALSE(!(condition))) \ | | | | 28| 28| ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream() | | | | ------------------ | | | | | | 66| 0| ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message) | | | | ------------------ | | ------------------ ------------------ 5543| | 5544| 14| if (options->has_features()) { ------------------ | Branch (5544:7): [True: 0, False: 14] ------------------ 5545| | // Remove the features from the child's options proto to avoid leaking 5546| | // internal details. 5547| 0| descriptor->proto_features_ = 5548| 0| tables_->InternFeatureSet(std::move(*options->mutable_features())); 5549| 0| options->clear_features(); 5550| 0| } 5551| | 5552| 14| FeatureSet base_features = *descriptor->proto_features_; 5553| | 5554| | // Handle feature inference from proto2/proto3. 5555| 14| if (IsLegacyEdition(edition)) { ------------------ | Branch (5555:7): [True: 14, False: 0] ------------------ 5556| 14| if (descriptor->proto_features_ != &FeatureSet::default_instance()) { ------------------ | Branch (5556:9): [True: 0, False: 14] ------------------ 5557| 0| AddError(descriptor->name(), proto, error_location, 5558| 0| "Features are only valid under editions."); 5559| 0| } 5560| 14| } 5561| 14| InferLegacyProtoFeatures(proto, *options, edition, base_features); 5562| | 5563| 14| if (base_features.ByteSizeLong() == 0 && !force_merge) { ------------------ | Branch (5563:7): [True: 14, False: 0] | Branch (5563:44): [True: 14, False: 0] ------------------ 5564| | // Nothing to merge, and we aren't forcing it. 5565| 14| descriptor->merged_features_ = &parent_features; 5566| 14| return; 5567| 14| } 5568| | 5569| | // Calculate the merged features for this target. 5570| 0| absl::StatusOr merged = 5571| 0| feature_resolver_->MergeFeatures(parent_features, base_features); 5572| 0| if (!merged.ok()) { ------------------ | Branch (5572:7): [True: 0, False: 0] ------------------ 5573| 0| AddError(descriptor->name(), proto, error_location, 5574| 0| [&] { return std::string(merged.status().message()); }); 5575| 0| return; 5576| 0| } 5577| | 5578| 0| descriptor->merged_features_ = tables_->InternFeatureSet(*std::move(merged)); 5579| 0|} descriptor.cc:_ZN6google8protobuf12_GLOBAL__N_117GetParentFeaturesEPKNS0_10Descriptor14ExtensionRangeE: 1159| 14|const FeatureSet& GetParentFeatures(const Descriptor::ExtensionRange* range) { 1160| 14| return internal::InternalFeatureHelper::GetFeatures( 1161| 14| *range->containing_type()); 1162| 14|} descriptor.cc:_ZN6google8protobufL24InferLegacyProtoFeaturesINS0_30DescriptorProto_ExtensionRangeENS0_21ExtensionRangeOptionsEEEvRKT_RKT0_NS0_7EditionERNS0_10FeatureSetE: 5483| 14| FeatureSet& features) {} descriptor.cc:_ZZN6google8protobuf17DescriptorBuilder13BuildFileImplERKNS0_19FileDescriptorProtoERNS0_8internal13FlatAllocatorEENK3$_4clINS0_14EnumDescriptorENS0_19EnumDescriptorProtoEEEDaRKT_RKT0_: 6180| 18| *result, proto, [&](const auto& descriptor, const auto& proto) { 6181| 18| using OptionsT = 6182| 18| typename std::remove_const::type>::type; 6184| 18| using DescriptorT = 6185| 18| typename std::remove_const::type>::type; 6187| | 6188| 18| ResolveFeatures( 6189| 18| proto, const_cast(&descriptor), 6190| 18| const_cast< // NOLINT(google3-runtime-proto-const-cast) 6191| 18| OptionsT*>(descriptor.options_), 6192| 18| alloc); 6193| 18| }); _ZN6google8protobuf17DescriptorBuilder15ResolveFeaturesINS0_14EnumDescriptorEEEvRKNT_5ProtoEPS4_PNS4_11OptionsTypeERNS0_8internal13FlatAllocatorE: 5585| 18| internal::FlatAllocator& alloc) { 5586| 18| ResolveFeaturesImpl(descriptor->file()->edition(), proto, descriptor, options, 5587| 18| alloc, DescriptorPool::ErrorCollector::NAME); 5588| 18|} _ZN6google8protobuf17DescriptorBuilder19ResolveFeaturesImplINS0_14EnumDescriptorEEEvNS0_7EditionERKNT_5ProtoEPS5_PNS5_11OptionsTypeERNS0_8internal13FlatAllocatorENS0_14DescriptorPool14ErrorCollector13ErrorLocationEb: 5537| 18| bool force_merge) { 5538| 18| const FeatureSet& parent_features = GetParentFeatures(descriptor); 5539| 18| descriptor->proto_features_ = &FeatureSet::default_instance(); 5540| 18| descriptor->merged_features_ = &FeatureSet::default_instance(); 5541| | 5542| 18| ABSL_CHECK(feature_resolver_.has_value()); ------------------ | | 41| 18| ABSL_LOG_INTERNAL_CHECK_IMPL((condition), #condition) | | ------------------ | | | | 26| 36| ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS, \ | | | | ------------------ | | | | | | 172| 18| ABSL_LOG_INTERNAL_##type##_CONDITION(condition) | | | | | | ------------------ | | | | | | | | 65| 36| switch (0) \ | | | | | | | | 66| 36| case 0: \ | | | | | | | | ------------------ | | | | | | | | | Branch (66:3): [True: 18, False: 0] | | | | | | | | ------------------ | | | | | | | | 67| 18| default: \ | | | | | | | | ------------------ | | | | | | | | | Branch (67:3): [True: 0, False: 18] | | | | | | | | ------------------ | | | | | | | | 68| 36| !(condition) ? (void)0 : ::absl::log_internal::Voidify()&& | | | | | | | | ------------------ | | | | | | | | | Branch (68:5): [True: 18, False: 0] | | | | | | | | | Branch (68:7): [Folded, False: 18] | | | | | | | | | Branch (68:7): [True: 0, False: 18] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 27| 36| ABSL_PREDICT_FALSE(!(condition))) \ | | | | 28| 36| ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream() | | | | ------------------ | | | | | | 66| 0| ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message) | | | | ------------------ | | ------------------ ------------------ 5543| | 5544| 18| if (options->has_features()) { ------------------ | Branch (5544:7): [True: 0, False: 18] ------------------ 5545| | // Remove the features from the child's options proto to avoid leaking 5546| | // internal details. 5547| 0| descriptor->proto_features_ = 5548| 0| tables_->InternFeatureSet(std::move(*options->mutable_features())); 5549| 0| options->clear_features(); 5550| 0| } 5551| | 5552| 18| FeatureSet base_features = *descriptor->proto_features_; 5553| | 5554| | // Handle feature inference from proto2/proto3. 5555| 18| if (IsLegacyEdition(edition)) { ------------------ | Branch (5555:7): [True: 18, False: 0] ------------------ 5556| 18| if (descriptor->proto_features_ != &FeatureSet::default_instance()) { ------------------ | Branch (5556:9): [True: 0, False: 18] ------------------ 5557| 0| AddError(descriptor->name(), proto, error_location, 5558| 0| "Features are only valid under editions."); 5559| 0| } 5560| 18| } 5561| 18| InferLegacyProtoFeatures(proto, *options, edition, base_features); 5562| | 5563| 18| if (base_features.ByteSizeLong() == 0 && !force_merge) { ------------------ | Branch (5563:7): [True: 18, False: 0] | Branch (5563:44): [True: 18, False: 0] ------------------ 5564| | // Nothing to merge, and we aren't forcing it. 5565| 18| descriptor->merged_features_ = &parent_features; 5566| 18| return; 5567| 18| } 5568| | 5569| | // Calculate the merged features for this target. 5570| 0| absl::StatusOr merged = 5571| 0| feature_resolver_->MergeFeatures(parent_features, base_features); 5572| 0| if (!merged.ok()) { ------------------ | Branch (5572:7): [True: 0, False: 0] ------------------ 5573| 0| AddError(descriptor->name(), proto, error_location, 5574| 0| [&] { return std::string(merged.status().message()); }); 5575| 0| return; 5576| 0| } 5577| | 5578| 0| descriptor->merged_features_ = tables_->InternFeatureSet(*std::move(merged)); 5579| 0|} descriptor.cc:_ZN6google8protobuf12_GLOBAL__N_117GetParentFeaturesEPKNS0_14EnumDescriptorE: 1179| 18|const FeatureSet& GetParentFeatures(const EnumDescriptor* enm) { 1180| 18| if (enm->containing_type() == nullptr) { ------------------ | Branch (1180:7): [True: 1, False: 17] ------------------ 1181| 1| return internal::InternalFeatureHelper::GetFeatures(*enm->file()); 1182| 1| } 1183| 17| return internal::InternalFeatureHelper::GetFeatures(*enm->containing_type()); 1184| 18|} descriptor.cc:_ZN6google8protobufL24InferLegacyProtoFeaturesINS0_19EnumDescriptorProtoENS0_11EnumOptionsEEEvRKT_RKT0_NS0_7EditionERNS0_10FeatureSetE: 5483| 18| FeatureSet& features) {} descriptor.cc:_ZZN6google8protobuf17DescriptorBuilder13BuildFileImplERKNS0_19FileDescriptorProtoERNS0_8internal13FlatAllocatorEENK3$_4clINS0_19EnumValueDescriptorENS0_24EnumValueDescriptorProtoEEEDaRKT_RKT0_: 6180| 86| *result, proto, [&](const auto& descriptor, const auto& proto) { 6181| 86| using OptionsT = 6182| 86| typename std::remove_const::type>::type; 6184| 86| using DescriptorT = 6185| 86| typename std::remove_const::type>::type; 6187| | 6188| 86| ResolveFeatures( 6189| 86| proto, const_cast(&descriptor), 6190| 86| const_cast< // NOLINT(google3-runtime-proto-const-cast) 6191| 86| OptionsT*>(descriptor.options_), 6192| 86| alloc); 6193| 86| }); _ZN6google8protobuf17DescriptorBuilder15ResolveFeaturesINS0_19EnumValueDescriptorEEEvRKNT_5ProtoEPS4_PNS4_11OptionsTypeERNS0_8internal13FlatAllocatorE: 5585| 86| internal::FlatAllocator& alloc) { 5586| 86| ResolveFeaturesImpl(descriptor->file()->edition(), proto, descriptor, options, 5587| 86| alloc, DescriptorPool::ErrorCollector::NAME); 5588| 86|} _ZN6google8protobuf17DescriptorBuilder19ResolveFeaturesImplINS0_19EnumValueDescriptorEEEvNS0_7EditionERKNT_5ProtoEPS5_PNS5_11OptionsTypeERNS0_8internal13FlatAllocatorENS0_14DescriptorPool14ErrorCollector13ErrorLocationEb: 5537| 86| bool force_merge) { 5538| 86| const FeatureSet& parent_features = GetParentFeatures(descriptor); 5539| 86| descriptor->proto_features_ = &FeatureSet::default_instance(); 5540| 86| descriptor->merged_features_ = &FeatureSet::default_instance(); 5541| | 5542| 86| ABSL_CHECK(feature_resolver_.has_value()); ------------------ | | 41| 86| ABSL_LOG_INTERNAL_CHECK_IMPL((condition), #condition) | | ------------------ | | | | 26| 172| ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS, \ | | | | ------------------ | | | | | | 172| 86| ABSL_LOG_INTERNAL_##type##_CONDITION(condition) | | | | | | ------------------ | | | | | | | | 65| 172| switch (0) \ | | | | | | | | 66| 172| case 0: \ | | | | | | | | ------------------ | | | | | | | | | Branch (66:3): [True: 86, False: 0] | | | | | | | | ------------------ | | | | | | | | 67| 86| default: \ | | | | | | | | ------------------ | | | | | | | | | Branch (67:3): [True: 0, False: 86] | | | | | | | | ------------------ | | | | | | | | 68| 172| !(condition) ? (void)0 : ::absl::log_internal::Voidify()&& | | | | | | | | ------------------ | | | | | | | | | Branch (68:5): [True: 86, False: 0] | | | | | | | | | Branch (68:7): [Folded, False: 86] | | | | | | | | | Branch (68:7): [True: 0, False: 86] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 27| 172| ABSL_PREDICT_FALSE(!(condition))) \ | | | | 28| 172| ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream() | | | | ------------------ | | | | | | 66| 0| ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message) | | | | ------------------ | | ------------------ ------------------ 5543| | 5544| 86| if (options->has_features()) { ------------------ | Branch (5544:7): [True: 0, False: 86] ------------------ 5545| | // Remove the features from the child's options proto to avoid leaking 5546| | // internal details. 5547| 0| descriptor->proto_features_ = 5548| 0| tables_->InternFeatureSet(std::move(*options->mutable_features())); 5549| 0| options->clear_features(); 5550| 0| } 5551| | 5552| 86| FeatureSet base_features = *descriptor->proto_features_; 5553| | 5554| | // Handle feature inference from proto2/proto3. 5555| 86| if (IsLegacyEdition(edition)) { ------------------ | Branch (5555:7): [True: 86, False: 0] ------------------ 5556| 86| if (descriptor->proto_features_ != &FeatureSet::default_instance()) { ------------------ | Branch (5556:9): [True: 0, False: 86] ------------------ 5557| 0| AddError(descriptor->name(), proto, error_location, 5558| 0| "Features are only valid under editions."); 5559| 0| } 5560| 86| } 5561| 86| InferLegacyProtoFeatures(proto, *options, edition, base_features); 5562| | 5563| 86| if (base_features.ByteSizeLong() == 0 && !force_merge) { ------------------ | Branch (5563:7): [True: 86, False: 0] | Branch (5563:44): [True: 86, False: 0] ------------------ 5564| | // Nothing to merge, and we aren't forcing it. 5565| 86| descriptor->merged_features_ = &parent_features; 5566| 86| return; 5567| 86| } 5568| | 5569| | // Calculate the merged features for this target. 5570| 0| absl::StatusOr merged = 5571| 0| feature_resolver_->MergeFeatures(parent_features, base_features); 5572| 0| if (!merged.ok()) { ------------------ | Branch (5572:7): [True: 0, False: 0] ------------------ 5573| 0| AddError(descriptor->name(), proto, error_location, 5574| 0| [&] { return std::string(merged.status().message()); }); 5575| 0| return; 5576| 0| } 5577| | 5578| 0| descriptor->merged_features_ = tables_->InternFeatureSet(*std::move(merged)); 5579| 0|} descriptor.cc:_ZN6google8protobuf12_GLOBAL__N_117GetParentFeaturesEPKNS0_19EnumValueDescriptorE: 1186| 86|const FeatureSet& GetParentFeatures(const EnumValueDescriptor* value) { 1187| 86| return internal::InternalFeatureHelper::GetFeatures(*value->type()); 1188| 86|} descriptor.cc:_ZN6google8protobufL24InferLegacyProtoFeaturesINS0_24EnumValueDescriptorProtoENS0_16EnumValueOptionsEEEvRKT_RKT0_NS0_7EditionERNS0_10FeatureSetE: 5483| 86| FeatureSet& features) {} descriptor.cc:_ZZN6google8protobuf17DescriptorBuilder13BuildFileImplERKNS0_19FileDescriptorProtoERNS0_8internal13FlatAllocatorEENK3$_4clINS0_15FieldDescriptorENS0_20FieldDescriptorProtoEEEDaRKT_RKT0_: 6180| 206| *result, proto, [&](const auto& descriptor, const auto& proto) { 6181| 206| using OptionsT = 6182| 206| typename std::remove_const::type>::type; 6184| 206| using DescriptorT = 6185| 206| typename std::remove_const::type>::type; 6187| | 6188| 206| ResolveFeatures( 6189| 206| proto, const_cast(&descriptor), 6190| 206| const_cast< // NOLINT(google3-runtime-proto-const-cast) 6191| 206| OptionsT*>(descriptor.options_), 6192| 206| alloc); 6193| 206| }); _ZN6google8protobuf17DescriptorBuilder15ResolveFeaturesINS0_15FieldDescriptorEEEvRKNT_5ProtoEPS4_PNS4_11OptionsTypeERNS0_8internal13FlatAllocatorE: 5585| 206| internal::FlatAllocator& alloc) { 5586| 206| ResolveFeaturesImpl(descriptor->file()->edition(), proto, descriptor, options, 5587| 206| alloc, DescriptorPool::ErrorCollector::NAME); 5588| 206|} _ZN6google8protobuf17DescriptorBuilder19ResolveFeaturesImplINS0_15FieldDescriptorEEEvNS0_7EditionERKNT_5ProtoEPS5_PNS5_11OptionsTypeERNS0_8internal13FlatAllocatorENS0_14DescriptorPool14ErrorCollector13ErrorLocationEb: 5537| 206| bool force_merge) { 5538| 206| const FeatureSet& parent_features = GetParentFeatures(descriptor); 5539| 206| descriptor->proto_features_ = &FeatureSet::default_instance(); 5540| 206| descriptor->merged_features_ = &FeatureSet::default_instance(); 5541| | 5542| 206| ABSL_CHECK(feature_resolver_.has_value()); ------------------ | | 41| 206| ABSL_LOG_INTERNAL_CHECK_IMPL((condition), #condition) | | ------------------ | | | | 26| 412| ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS, \ | | | | ------------------ | | | | | | 172| 206| ABSL_LOG_INTERNAL_##type##_CONDITION(condition) | | | | | | ------------------ | | | | | | | | 65| 412| switch (0) \ | | | | | | | | 66| 412| case 0: \ | | | | | | | | ------------------ | | | | | | | | | Branch (66:3): [True: 206, False: 0] | | | | | | | | ------------------ | | | | | | | | 67| 206| default: \ | | | | | | | | ------------------ | | | | | | | | | Branch (67:3): [True: 0, False: 206] | | | | | | | | ------------------ | | | | | | | | 68| 412| !(condition) ? (void)0 : ::absl::log_internal::Voidify()&& | | | | | | | | ------------------ | | | | | | | | | Branch (68:5): [True: 206, False: 0] | | | | | | | | | Branch (68:7): [Folded, False: 206] | | | | | | | | | Branch (68:7): [True: 0, False: 206] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 27| 412| ABSL_PREDICT_FALSE(!(condition))) \ | | | | 28| 412| ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream() | | | | ------------------ | | | | | | 66| 0| ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message) | | | | ------------------ | | ------------------ ------------------ 5543| | 5544| 206| if (options->has_features()) { ------------------ | Branch (5544:7): [True: 0, False: 206] ------------------ 5545| | // Remove the features from the child's options proto to avoid leaking 5546| | // internal details. 5547| 0| descriptor->proto_features_ = 5548| 0| tables_->InternFeatureSet(std::move(*options->mutable_features())); 5549| 0| options->clear_features(); 5550| 0| } 5551| | 5552| 206| FeatureSet base_features = *descriptor->proto_features_; 5553| | 5554| | // Handle feature inference from proto2/proto3. 5555| 206| if (IsLegacyEdition(edition)) { ------------------ | Branch (5555:7): [True: 206, False: 0] ------------------ 5556| 206| if (descriptor->proto_features_ != &FeatureSet::default_instance()) { ------------------ | Branch (5556:9): [True: 0, False: 206] ------------------ 5557| 0| AddError(descriptor->name(), proto, error_location, 5558| 0| "Features are only valid under editions."); 5559| 0| } 5560| 206| } 5561| 206| InferLegacyProtoFeatures(proto, *options, edition, base_features); 5562| | 5563| 206| if (base_features.ByteSizeLong() == 0 && !force_merge) { ------------------ | Branch (5563:7): [True: 0, False: 206] | Branch (5563:44): [True: 0, False: 0] ------------------ 5564| | // Nothing to merge, and we aren't forcing it. 5565| 0| descriptor->merged_features_ = &parent_features; 5566| 0| return; 5567| 0| } 5568| | 5569| | // Calculate the merged features for this target. 5570| 206| absl::StatusOr merged = 5571| 206| feature_resolver_->MergeFeatures(parent_features, base_features); 5572| 206| if (!merged.ok()) { ------------------ | Branch (5572:7): [True: 0, False: 206] ------------------ 5573| 0| AddError(descriptor->name(), proto, error_location, 5574| 0| [&] { return std::string(merged.status().message()); }); 5575| 0| return; 5576| 0| } 5577| | 5578| 206| descriptor->merged_features_ = tables_->InternFeatureSet(*std::move(merged)); 5579| 206|} descriptor.cc:_ZN6google8protobuf12_GLOBAL__N_117GetParentFeaturesEPKNS0_15FieldDescriptorE: 1164| 206|const FeatureSet& GetParentFeatures(const FieldDescriptor* field) { 1165| 206| if (field->containing_oneof() != nullptr) { ------------------ | Branch (1165:7): [True: 7, False: 199] ------------------ 1166| 7| return internal::InternalFeatureHelper::GetFeatures( 1167| 7| *field->containing_oneof()); 1168| 199| } else if (field->is_extension()) { ------------------ | Branch (1168:14): [True: 1, False: 198] ------------------ 1169| 1| if (field->extension_scope() == nullptr) { ------------------ | Branch (1169:9): [True: 1, False: 0] ------------------ 1170| 1| return internal::InternalFeatureHelper::GetFeatures(*field->file()); 1171| 1| } 1172| 0| return internal::InternalFeatureHelper::GetFeatures( 1173| 0| *field->extension_scope()); 1174| 1| } 1175| 198| return internal::InternalFeatureHelper::GetFeatures( 1176| 198| *field->containing_type()); 1177| 206|} descriptor.cc:_ZN6google8protobufL24InferLegacyProtoFeaturesERKNS0_20FieldDescriptorProtoERKNS0_12FieldOptionsENS0_7EditionERNS0_10FeatureSetE: 5487| 206| Edition edition, FeatureSet& features) { 5488| 206| if (!features.MutableExtension(pb::cpp)->has_string_type()) { ------------------ | Branch (5488:7): [True: 206, False: 0] ------------------ 5489| 206| if (options.ctype() == FieldOptions::CORD) { ------------------ | Branch (5489:9): [True: 0, False: 206] ------------------ 5490| 0| features.MutableExtension(pb::cpp)->set_string_type( 5491| 0| pb::CppFeatures::CORD); 5492| 0| } 5493| 206| } 5494| | 5495| | // Everything below is specifically for proto2/proto. 5496| 206| if (!IsLegacyEdition(edition)) return; ------------------ | Branch (5496:7): [True: 0, False: 206] ------------------ 5497| | 5498| 206| if (proto.label() == FieldDescriptorProto::LABEL_REQUIRED) { ------------------ | Branch (5498:7): [True: 2, False: 204] ------------------ 5499| 2| features.set_field_presence(FeatureSet::LEGACY_REQUIRED); 5500| 2| } 5501| 206| if (proto.type() == FieldDescriptorProto::TYPE_GROUP) { ------------------ | Branch (5501:7): [True: 0, False: 206] ------------------ 5502| 0| features.set_message_encoding(FeatureSet::DELIMITED); 5503| 0| } 5504| 206| if (options.packed()) { ------------------ | Branch (5504:7): [True: 3, False: 203] ------------------ 5505| 3| features.set_repeated_field_encoding(FeatureSet::PACKED); 5506| 3| } 5507| 206| if (edition == Edition::EDITION_PROTO3) { ------------------ | Branch (5507:7): [True: 2, False: 204] ------------------ 5508| 2| if (options.has_packed() && !options.packed()) { ------------------ | Branch (5508:9): [True: 0, False: 2] | Branch (5508:33): [True: 0, False: 0] ------------------ 5509| 0| features.set_repeated_field_encoding(FeatureSet::EXPANDED); 5510| 0| } 5511| 2| } 5512| 206|} descriptor.cc:_ZZN6google8protobuf17DescriptorBuilder13BuildFileImplERKNS0_19FileDescriptorProtoERNS0_8internal13FlatAllocatorEENK3$_5clERKNS0_15FieldDescriptorE: 6196| 206| internal::VisitDescriptors(*result, [&](const FieldDescriptor& field) { 6197| 206| if (result->edition() >= Edition::EDITION_2024 && ------------------ | Branch (6197:11): [True: 0, False: 206] ------------------ 6198| 0| field.options().has_ctype()) { ------------------ | Branch (6198:11): [True: 0, False: 0] ------------------ 6199| | // "ctype" is no longer supported in edition 2024 and beyond. 6200| 0| AddError( 6201| 0| field.full_name(), proto, DescriptorPool::ErrorCollector::NAME, 6202| 0| "ctype option is not allowed under edition 2024 and beyond. Use " 6203| 0| "the feature string_type = VIEW|CORD|STRING|... instead."); 6204| 0| } 6205| 206| EnforceCTypeStringTypeConsistency( 6206| 206| field.file()->edition(), field.cpp_type(), 6207| 206| field.merged_features_->GetExtension(pb::cpp), 6208| 206| const_cast< // NOLINT(google3-runtime-proto-const-cast) 6209| 206| FieldOptions&>(*field.options_)); 6210| 206| }); descriptor.cc:_ZN6google8protobufL33EnforceCTypeStringTypeConsistencyENS0_7EditionENS0_8internal19FieldDescriptorLite7CppTypeERKN2pb11CppFeaturesERNS0_12FieldOptionsE: 5518| 206| const pb::CppFeatures& cpp_features, FieldOptions& options) { 5519| 206| if (&options == &FieldOptions::default_instance()) return; ------------------ | Branch (5519:7): [True: 189, False: 17] ------------------ 5520| 17| if (type == FieldDescriptor::CPPTYPE_STRING) { ------------------ | Branch (5520:7): [True: 0, False: 17] ------------------ 5521| 0| switch (cpp_features.string_type()) { 5522| 0| case pb::CppFeatures::CORD: ------------------ | Branch (5522:7): [True: 0, False: 0] ------------------ 5523| 0| options.set_ctype(FieldOptions::CORD); 5524| 0| break; 5525| 0| default: ------------------ | Branch (5525:7): [True: 0, False: 0] ------------------ 5526| 0| break; 5527| 0| } 5528| 0| } 5529| 17|} descriptor.cc:_ZZN6google8protobuf17DescriptorBuilder13BuildFileImplERKNS0_19FileDescriptorProtoERNS0_8internal13FlatAllocatorEENK3$_6clERKNS0_15FieldDescriptorERKNS0_20FieldDescriptorProtoE: 6215| 206| [&](const FieldDescriptor& field, const FieldDescriptorProto& proto) { 6216| 206| PostProcessFieldFeatures(const_cast(field), proto); 6217| 206| }); descriptor.cc:_ZN6google8protobuf12_GLOBAL__N_117FlatAllocatorImplIJcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE15AllocateStringsIJRKNS3_17basic_string_viewIcS6_EES9_EEEPKS9_DpOT_: 416| 175| const std::string* AllocateStrings(In&&... in) { 417| 175| std::string* strings = AllocateArray(sizeof...(in)); 418| 175| std::string* res = strings; 419| 175| Fold({(*strings++ = std::string(std::forward(in)))...}); 420| 175| return res; 421| 175| } descriptor.cc:_ZN6google8protobuf12_GLOBAL__N_117FlatAllocatorImplIJcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE13AllocateArrayINS0_15OneofDescriptorEEEPT_i: 400| 45| U* AllocateArray(int array_size) { 401| 45| constexpr bool trivial = std::is_trivially_destructible::value; 402| 45| using TypeToUse = typename std::conditional::type; 403| | 404| | // We can only allocate after FinalizePlanning has been called. 405| 45| ABSL_CHECK(has_allocated()); ------------------ | | 41| 45| ABSL_LOG_INTERNAL_CHECK_IMPL((condition), #condition) | | ------------------ | | | | 26| 90| ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS, \ | | | | ------------------ | | | | | | 172| 45| ABSL_LOG_INTERNAL_##type##_CONDITION(condition) | | | | | | ------------------ | | | | | | | | 65| 90| switch (0) \ | | | | | | | | 66| 90| case 0: \ | | | | | | | | ------------------ | | | | | | | | | Branch (66:3): [True: 45, False: 0] | | | | | | | | ------------------ | | | | | | | | 67| 45| default: \ | | | | | | | | ------------------ | | | | | | | | | Branch (67:3): [True: 0, False: 45] | | | | | | | | ------------------ | | | | | | | | 68| 90| !(condition) ? (void)0 : ::absl::log_internal::Voidify()&& | | | | | | | | ------------------ | | | | | | | | | Branch (68:5): [True: 45, False: 0] | | | | | | | | | Branch (68:7): [Folded, False: 45] | | | | | | | | | Branch (68:7): [True: 0, False: 45] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 27| 90| ABSL_PREDICT_FALSE(!(condition))) \ | | | | 28| 90| ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream() | | | | ------------------ | | | | | | 66| 0| ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message) | | | | ------------------ | | ------------------ ------------------ 406| | 407| 45| TypeToUse*& data = pointers_.template Get(); 408| 45| int& used = used_.template Get(); 409| 45| U* res = reinterpret_cast(data + used); 410| 45| used += trivial ? RoundUpTo<8>(array_size * sizeof(U)) : array_size; ------------------ | Branch (410:13): [True: 45, Folded] ------------------ 411| 45| ABSL_CHECK_LE(used, total_.template Get()); ------------------ | | 54| 45| ABSL_LOG_INTERNAL_CHECK_LE_IMPL((val1), #val1, (val2), #val2) | | ------------------ | | | | 52| 45| ABSL_LOG_INTERNAL_CHECK_OP(Check_LE, <=, val1, val1_text, val2, val2_text) | | | | ------------------ | | | | | | 61| 45| while ( \ | | | | | | 62| 45| ::std::string* absl_log_internal_check_op_result ABSL_ATTRIBUTE_UNUSED = \ | | | | | | ------------------ | | | | | | | Branch (62:22): [True: 0, False: 45] | | | | | | ------------------ | | | | | | 63| 45| ::absl::log_internal::name##Impl( \ | | | | | | 64| 45| ::absl::log_internal::GetReferenceableValue(val1), \ | | | | | | 65| 45| ::absl::log_internal::GetReferenceableValue(val2), \ | | | | | | 66| 45| ABSL_LOG_INTERNAL_STRIP_STRING_LITERAL(val1_text \ | | | | | | 67| 45| " " #op " " val2_text))) \ | | | | | | 68| 45| ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS, true) \ | | | | | | ------------------ | | | | | | | | 172| 0| ABSL_LOG_INTERNAL_##type##_CONDITION(condition) | | | | | | | | ------------------ | | | | | | | | | | 65| 0| switch (0) \ | | | | | | | | | | 66| 0| case 0: \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (66:3): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 67| 0| default: \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (67:3): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 68| 0| !(condition) ? (void)0 : ::absl::log_internal::Voidify()&& | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (68:5): [Folded, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 69| 0| ABSL_LOG_INTERNAL_CHECK(*absl_log_internal_check_op_result).InternalStream() | | | | | | ------------------ | | | | | | | | 66| 0| ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 412| 45| return res; 413| 45| } descriptor.cc:_ZN6google8protobuf12_GLOBAL__N_117FlatAllocatorImplIJcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE13AllocateArrayINS0_10Descriptor13ReservedRangeEEEPT_i: 400| 45| U* AllocateArray(int array_size) { 401| 45| constexpr bool trivial = std::is_trivially_destructible::value; 402| 45| using TypeToUse = typename std::conditional::type; 403| | 404| | // We can only allocate after FinalizePlanning has been called. 405| 45| ABSL_CHECK(has_allocated()); ------------------ | | 41| 45| ABSL_LOG_INTERNAL_CHECK_IMPL((condition), #condition) | | ------------------ | | | | 26| 90| ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS, \ | | | | ------------------ | | | | | | 172| 45| ABSL_LOG_INTERNAL_##type##_CONDITION(condition) | | | | | | ------------------ | | | | | | | | 65| 90| switch (0) \ | | | | | | | | 66| 90| case 0: \ | | | | | | | | ------------------ | | | | | | | | | Branch (66:3): [True: 45, False: 0] | | | | | | | | ------------------ | | | | | | | | 67| 45| default: \ | | | | | | | | ------------------ | | | | | | | | | Branch (67:3): [True: 0, False: 45] | | | | | | | | ------------------ | | | | | | | | 68| 90| !(condition) ? (void)0 : ::absl::log_internal::Voidify()&& | | | | | | | | ------------------ | | | | | | | | | Branch (68:5): [True: 45, False: 0] | | | | | | | | | Branch (68:7): [Folded, False: 45] | | | | | | | | | Branch (68:7): [True: 0, False: 45] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 27| 90| ABSL_PREDICT_FALSE(!(condition))) \ | | | | 28| 90| ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream() | | | | ------------------ | | | | | | 66| 0| ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message) | | | | ------------------ | | ------------------ ------------------ 406| | 407| 45| TypeToUse*& data = pointers_.template Get(); 408| 45| int& used = used_.template Get(); 409| 45| U* res = reinterpret_cast(data + used); 410| 45| used += trivial ? RoundUpTo<8>(array_size * sizeof(U)) : array_size; ------------------ | Branch (410:13): [True: 45, Folded] ------------------ 411| 45| ABSL_CHECK_LE(used, total_.template Get()); ------------------ | | 54| 45| ABSL_LOG_INTERNAL_CHECK_LE_IMPL((val1), #val1, (val2), #val2) | | ------------------ | | | | 52| 45| ABSL_LOG_INTERNAL_CHECK_OP(Check_LE, <=, val1, val1_text, val2, val2_text) | | | | ------------------ | | | | | | 61| 45| while ( \ | | | | | | 62| 45| ::std::string* absl_log_internal_check_op_result ABSL_ATTRIBUTE_UNUSED = \ | | | | | | ------------------ | | | | | | | Branch (62:22): [True: 0, False: 45] | | | | | | ------------------ | | | | | | 63| 45| ::absl::log_internal::name##Impl( \ | | | | | | 64| 45| ::absl::log_internal::GetReferenceableValue(val1), \ | | | | | | 65| 45| ::absl::log_internal::GetReferenceableValue(val2), \ | | | | | | 66| 45| ABSL_LOG_INTERNAL_STRIP_STRING_LITERAL(val1_text \ | | | | | | 67| 45| " " #op " " val2_text))) \ | | | | | | 68| 45| ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS, true) \ | | | | | | ------------------ | | | | | | | | 172| 0| ABSL_LOG_INTERNAL_##type##_CONDITION(condition) | | | | | | | | ------------------ | | | | | | | | | | 65| 0| switch (0) \ | | | | | | | | | | 66| 0| case 0: \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (66:3): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 67| 0| default: \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (67:3): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 68| 0| !(condition) ? (void)0 : ::absl::log_internal::Voidify()&& | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (68:5): [Folded, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 69| 0| ABSL_LOG_INTERNAL_CHECK(*absl_log_internal_check_op_result).InternalStream() | | | | | | ------------------ | | | | | | | | 66| 0| ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 412| 45| return res; 413| 45| } _ZN6google8protobuf17DescriptorBuilder15AllocateOptionsINS0_10DescriptorEEEvRKNT_5ProtoEPS4_iNSt3__117basic_string_viewIcNS9_11char_traitsIcEEEERNS0_8internal13FlatAllocatorE: 5396| 45| internal::FlatAllocator& alloc) { 5397| 45| std::vector options_path; 5398| 45| descriptor->GetLocationPath(&options_path); 5399| 45| options_path.push_back(options_field_tag); 5400| 45| auto options = AllocateOptionsImpl( 5401| 45| descriptor->full_name(), descriptor->full_name(), proto, options_path, 5402| 45| option_name, alloc); 5403| 45| descriptor->options_ = options; 5404| 45| descriptor->proto_features_ = &FeatureSet::default_instance(); 5405| 45| descriptor->merged_features_ = &FeatureSet::default_instance(); 5406| 45|} _ZN6google8protobuf17DescriptorBuilder19AllocateOptionsImplINS0_10DescriptorEEEPKNT_11OptionsTypeENSt3__117basic_string_viewIcNS8_11char_traitsIcEEEESC_RKNS4_5ProtoEN4absl12lts_202401164SpanIKiEESC_RNS0_8internal13FlatAllocatorE: 5428| 45| internal::FlatAllocator& alloc) { 5429| 45| if (!proto.has_options()) { ------------------ | Branch (5429:7): [True: 45, False: 0] ------------------ 5430| 45| return &DescriptorT::OptionsType::default_instance(); 5431| 45| } 5432| 0| const typename DescriptorT::OptionsType& orig_options = proto.options(); 5433| | 5434| 0| auto* options = alloc.AllocateArray(1); 5435| | 5436| 0| if (!orig_options.IsInitialized()) { ------------------ | Branch (5436:7): [True: 0, False: 0] ------------------ 5437| 0| AddError(absl::StrCat(name_scope, ".", element_name), orig_options, 5438| 0| DescriptorPool::ErrorCollector::OPTION_NAME, 5439| 0| "Uninterpreted option is missing name or value."); 5440| 0| return &DescriptorT::OptionsType::default_instance(); 5441| 0| } 5442| | 5443| 0| const bool parse_success = 5444| 0| internal::ParseNoReflection(orig_options.SerializeAsString(), *options); 5445| 0| ABSL_DCHECK(parse_success); ------------------ | | 47| 0| ABSL_LOG_INTERNAL_DCHECK_IMPL((condition), #condition) | | ------------------ | | | | 43| 0| ABSL_LOG_INTERNAL_CHECK_IMPL(true || (condition), "true") | | | | ------------------ | | | | | | 26| 0| ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS, \ | | | | | | ------------------ | | | | | | | | 172| 0| ABSL_LOG_INTERNAL_##type##_CONDITION(condition) | | | | | | | | ------------------ | | | | | | | | | | 65| 0| switch (0) \ | | | | | | | | | | 66| 0| case 0: \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (66:3): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 67| 0| default: \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (67:3): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 68| 0| !(condition) ? (void)0 : ::absl::log_internal::Voidify()&& | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (68:5): [True: 0, Folded] | | | | | | | | | | | Branch (68:7): [True: 0, Folded] | | | | | | | | | | | Branch (68:7): [True: 0, False: 0] | | | | | | | | | | | Branch (68:7): [Folded, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 27| 0| ABSL_PREDICT_FALSE(!(condition))) \ | | | | | | 28| 0| ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream() | | | | | | ------------------ | | | | | | | | 66| 0| ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 5446| | 5447| | // Don't add to options_to_interpret_ unless there were uninterpreted 5448| | // options. This not only avoids unnecessary work, but prevents a 5449| | // bootstrapping problem when building descriptors for descriptor.proto. 5450| | // descriptor.proto does not contain any uninterpreted options, but 5451| | // attempting to interpret options anyway will cause 5452| | // OptionsType::GetDescriptor() to be called which may then deadlock since 5453| | // we're still trying to build it. 5454| 0| if (options->uninterpreted_option_size() > 0) { ------------------ | Branch (5454:7): [True: 0, False: 0] ------------------ 5455| 0| options_to_interpret_.push_back(OptionsToInterpret( 5456| 0| name_scope, element_name, options_path, &orig_options, options)); 5457| 0| } 5458| | 5459| | // If the custom option is in unknown fields, no need to interpret it. 5460| | // Remove the dependency file from unused_dependency. 5461| 0| const UnknownFieldSet& unknown_fields = orig_options.unknown_fields(); 5462| 0| if (!unknown_fields.empty()) { ------------------ | Branch (5462:7): [True: 0, False: 0] ------------------ 5463| | // Can not use options->GetDescriptor() which may case deadlock. 5464| 0| Symbol msg_symbol = tables_->FindSymbol(option_name); 5465| 0| if (msg_symbol.type() == Symbol::MESSAGE) { ------------------ | Branch (5465:9): [True: 0, False: 0] ------------------ 5466| 0| for (int i = 0; i < unknown_fields.field_count(); ++i) { ------------------ | Branch (5466:23): [True: 0, False: 0] ------------------ 5467| 0| assert_mutex_held(pool_); 5468| 0| const FieldDescriptor* field = 5469| 0| pool_->InternalFindExtensionByNumberNoLock( 5470| 0| msg_symbol.descriptor(), unknown_fields.field(i).number()); 5471| 0| if (field) { ------------------ | Branch (5471:13): [True: 0, False: 0] ------------------ 5472| 0| unused_dependency_.erase(field->file()); 5473| 0| } 5474| 0| } 5475| 0| } 5476| 0| } 5477| 0| return options; 5478| 0|} descriptor.cc:_ZN6google8protobuf12_GLOBAL__N_117FlatAllocatorImplIJcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE13AllocateArrayIPKS9_EEPT_i: 400| 63| U* AllocateArray(int array_size) { 401| 63| constexpr bool trivial = std::is_trivially_destructible::value; 402| 63| using TypeToUse = typename std::conditional::type; 403| | 404| | // We can only allocate after FinalizePlanning has been called. 405| 63| ABSL_CHECK(has_allocated()); ------------------ | | 41| 63| ABSL_LOG_INTERNAL_CHECK_IMPL((condition), #condition) | | ------------------ | | | | 26| 126| ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS, \ | | | | ------------------ | | | | | | 172| 63| ABSL_LOG_INTERNAL_##type##_CONDITION(condition) | | | | | | ------------------ | | | | | | | | 65| 126| switch (0) \ | | | | | | | | 66| 126| case 0: \ | | | | | | | | ------------------ | | | | | | | | | Branch (66:3): [True: 63, False: 0] | | | | | | | | ------------------ | | | | | | | | 67| 63| default: \ | | | | | | | | ------------------ | | | | | | | | | Branch (67:3): [True: 0, False: 63] | | | | | | | | ------------------ | | | | | | | | 68| 126| !(condition) ? (void)0 : ::absl::log_internal::Voidify()&& | | | | | | | | ------------------ | | | | | | | | | Branch (68:5): [True: 63, False: 0] | | | | | | | | | Branch (68:7): [Folded, False: 63] | | | | | | | | | Branch (68:7): [True: 0, False: 63] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 27| 126| ABSL_PREDICT_FALSE(!(condition))) \ | | | | 28| 126| ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream() | | | | ------------------ | | | | | | 66| 0| ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message) | | | | ------------------ | | ------------------ ------------------ 406| | 407| 63| TypeToUse*& data = pointers_.template Get(); 408| 63| int& used = used_.template Get(); 409| 63| U* res = reinterpret_cast(data + used); 410| 63| used += trivial ? RoundUpTo<8>(array_size * sizeof(U)) : array_size; ------------------ | Branch (410:13): [True: 63, Folded] ------------------ 411| 63| ABSL_CHECK_LE(used, total_.template Get()); ------------------ | | 54| 63| ABSL_LOG_INTERNAL_CHECK_LE_IMPL((val1), #val1, (val2), #val2) | | ------------------ | | | | 52| 63| ABSL_LOG_INTERNAL_CHECK_OP(Check_LE, <=, val1, val1_text, val2, val2_text) | | | | ------------------ | | | | | | 61| 63| while ( \ | | | | | | 62| 63| ::std::string* absl_log_internal_check_op_result ABSL_ATTRIBUTE_UNUSED = \ | | | | | | ------------------ | | | | | | | Branch (62:22): [True: 0, False: 63] | | | | | | ------------------ | | | | | | 63| 63| ::absl::log_internal::name##Impl( \ | | | | | | 64| 63| ::absl::log_internal::GetReferenceableValue(val1), \ | | | | | | 65| 63| ::absl::log_internal::GetReferenceableValue(val2), \ | | | | | | 66| 63| ABSL_LOG_INTERNAL_STRIP_STRING_LITERAL(val1_text \ | | | | | | 67| 63| " " #op " " val2_text))) \ | | | | | | 68| 63| ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS, true) \ | | | | | | ------------------ | | | | | | | | 172| 0| ABSL_LOG_INTERNAL_##type##_CONDITION(condition) | | | | | | | | ------------------ | | | | | | | | | | 65| 0| switch (0) \ | | | | | | | | | | 66| 0| case 0: \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (66:3): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 67| 0| default: \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (67:3): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 68| 0| !(condition) ? (void)0 : ::absl::log_internal::Voidify()&& | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (68:5): [Folded, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 69| 0| ABSL_LOG_INTERNAL_CHECK(*absl_log_internal_check_op_result).InternalStream() | | | | | | ------------------ | | | | | | | | 66| 0| ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 412| 63| return res; 413| 63| } descriptor.cc:_ZN6google8protobuf12_GLOBAL__N_117FlatAllocatorImplIJcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE18AllocateFieldNamesENS3_17basic_string_viewIcS6_EESO_PKS9_: 470| 206| const std::string* opt_json_name) { 471| 206| ABSL_CHECK(has_allocated()); ------------------ | | 41| 206| ABSL_LOG_INTERNAL_CHECK_IMPL((condition), #condition) | | ------------------ | | | | 26| 412| ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS, \ | | | | ------------------ | | | | | | 172| 206| ABSL_LOG_INTERNAL_##type##_CONDITION(condition) | | | | | | ------------------ | | | | | | | | 65| 412| switch (0) \ | | | | | | | | 66| 412| case 0: \ | | | | | | | | ------------------ | | | | | | | | | Branch (66:3): [True: 206, False: 0] | | | | | | | | ------------------ | | | | | | | | 67| 206| default: \ | | | | | | | | ------------------ | | | | | | | | | Branch (67:3): [True: 0, False: 206] | | | | | | | | ------------------ | | | | | | | | 68| 412| !(condition) ? (void)0 : ::absl::log_internal::Voidify()&& | | | | | | | | ------------------ | | | | | | | | | Branch (68:5): [True: 206, False: 0] | | | | | | | | | Branch (68:7): [Folded, False: 206] | | | | | | | | | Branch (68:7): [True: 0, False: 206] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 27| 412| ABSL_PREDICT_FALSE(!(condition))) \ | | | | 28| 412| ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream() | | | | ------------------ | | | | | | 66| 0| ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message) | | | | ------------------ | | ------------------ ------------------ 472| | 473| 206| std::string full_name = 474| 206| scope.empty() ? std::string(name) : absl::StrCat(scope, ".", name); ------------------ | Branch (474:9): [True: 0, False: 206] ------------------ 475| | 476| | // Fast path for snake_case names, which follow the style guide. 477| 206| if (opt_json_name == nullptr) { ------------------ | Branch (477:9): [True: 206, False: 0] ------------------ 478| 206| switch (GetFieldNameCase(name)) { 479| 110| case FieldNameCase::kAllLower: ------------------ | Branch (479:9): [True: 110, False: 96] ------------------ 480| | // Case 1: they are all the same. 481| 110| return {AllocateStrings(name, std::move(full_name)), 0, 0, 0}; 482| 96| case FieldNameCase::kSnakeCase: ------------------ | Branch (482:9): [True: 96, False: 110] ------------------ 483| | // Case 2: name==lower, camel==json 484| 96| return {AllocateStrings(name, std::move(full_name), 485| 96| ToCamelCase(name, /* lower_first = */ true)), 486| 96| 0, 2, 2}; 487| 0| default: ------------------ | Branch (487:9): [True: 0, False: 206] ------------------ 488| 0| break; 489| 206| } 490| 206| } 491| | 492| 0| std::vector names; 493| 0| names.emplace_back(name); 494| 0| names.push_back(std::move(full_name)); 495| | 496| 0| const auto push_name = [&](std::string new_name) { 497| 0| for (size_t i = 0; i < names.size(); ++i) { 498| | // Do not compare the full_name. It is unlikely to match, except in 499| | // custom json_name. We are not taking this into account in 500| | // PlanFieldNames so better to not try it. 501| 0| if (i == 1) continue; 502| 0| if (names[i] == new_name) return i; 503| 0| } 504| 0| names.push_back(std::move(new_name)); 505| 0| return names.size() - 1; 506| 0| }; 507| | 508| 0| FieldNamesResult result{nullptr, 0, 0, 0}; 509| | 510| 0| std::string lowercase_name = std::string(name); 511| 0| absl::AsciiStrToLower(&lowercase_name); 512| 0| result.lowercase_index = push_name(std::move(lowercase_name)); 513| 0| result.camelcase_index = 514| 0| push_name(ToCamelCase(name, /* lower_first = */ true)); 515| 0| result.json_index = 516| 0| push_name(opt_json_name != nullptr ? *opt_json_name : ToJsonName(name)); ------------------ | Branch (516:19): [True: 0, False: 0] ------------------ 517| | 518| 0| std::string* all_names = AllocateArray(names.size()); 519| 0| result.array = all_names; 520| 0| std::move(names.begin(), names.end(), all_names); 521| | 522| 0| return result; 523| 206| } descriptor.cc:_ZN6google8protobuf12_GLOBAL__N_117FlatAllocatorImplIJcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE15AllocateStringsIJRKNS3_17basic_string_viewIcS6_EES9_S9_EEEPKS9_DpOT_: 416| 96| const std::string* AllocateStrings(In&&... in) { 417| 96| std::string* strings = AllocateArray(sizeof...(in)); 418| 96| std::string* res = strings; 419| 96| Fold({(*strings++ = std::string(std::forward(in)))...}); 420| 96| return res; 421| 96| } _ZN6google8protobuf17DescriptorBuilder15AllocateOptionsINS0_15FieldDescriptorEEEvRKNT_5ProtoEPS4_iNSt3__117basic_string_viewIcNS9_11char_traitsIcEEEERNS0_8internal13FlatAllocatorE: 5396| 206| internal::FlatAllocator& alloc) { 5397| 206| std::vector options_path; 5398| 206| descriptor->GetLocationPath(&options_path); 5399| 206| options_path.push_back(options_field_tag); 5400| 206| auto options = AllocateOptionsImpl( 5401| 206| descriptor->full_name(), descriptor->full_name(), proto, options_path, 5402| 206| option_name, alloc); 5403| 206| descriptor->options_ = options; 5404| 206| descriptor->proto_features_ = &FeatureSet::default_instance(); 5405| 206| descriptor->merged_features_ = &FeatureSet::default_instance(); 5406| 206|} _ZN6google8protobuf17DescriptorBuilder19AllocateOptionsImplINS0_15FieldDescriptorEEEPKNT_11OptionsTypeENSt3__117basic_string_viewIcNS8_11char_traitsIcEEEESC_RKNS4_5ProtoEN4absl12lts_202401164SpanIKiEESC_RNS0_8internal13FlatAllocatorE: 5428| 206| internal::FlatAllocator& alloc) { 5429| 206| if (!proto.has_options()) { ------------------ | Branch (5429:7): [True: 189, False: 17] ------------------ 5430| 189| return &DescriptorT::OptionsType::default_instance(); 5431| 189| } 5432| 17| const typename DescriptorT::OptionsType& orig_options = proto.options(); 5433| | 5434| 17| auto* options = alloc.AllocateArray(1); 5435| | 5436| 17| if (!orig_options.IsInitialized()) { ------------------ | Branch (5436:7): [True: 0, False: 17] ------------------ 5437| 0| AddError(absl::StrCat(name_scope, ".", element_name), orig_options, 5438| 0| DescriptorPool::ErrorCollector::OPTION_NAME, 5439| 0| "Uninterpreted option is missing name or value."); 5440| 0| return &DescriptorT::OptionsType::default_instance(); 5441| 0| } 5442| | 5443| 17| const bool parse_success = 5444| 17| internal::ParseNoReflection(orig_options.SerializeAsString(), *options); 5445| 17| ABSL_DCHECK(parse_success); ------------------ | | 47| 17| ABSL_LOG_INTERNAL_DCHECK_IMPL((condition), #condition) | | ------------------ | | | | 43| 17| ABSL_LOG_INTERNAL_CHECK_IMPL(true || (condition), "true") | | | | ------------------ | | | | | | 26| 34| ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS, \ | | | | | | ------------------ | | | | | | | | 172| 17| ABSL_LOG_INTERNAL_##type##_CONDITION(condition) | | | | | | | | ------------------ | | | | | | | | | | 65| 34| switch (0) \ | | | | | | | | | | 66| 34| case 0: \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (66:3): [True: 17, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 67| 17| default: \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (67:3): [True: 0, False: 17] | | | | | | | | | | ------------------ | | | | | | | | | | 68| 17| !(condition) ? (void)0 : ::absl::log_internal::Voidify()&& | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (68:5): [True: 17, Folded] | | | | | | | | | | | Branch (68:7): [True: 0, Folded] | | | | | | | | | | | Branch (68:7): [True: 0, False: 0] | | | | | | | | | | | Branch (68:7): [Folded, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 27| 34| ABSL_PREDICT_FALSE(!(condition))) \ | | | | | | 28| 34| ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream() | | | | | | ------------------ | | | | | | | | 66| 0| ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 5446| | 5447| | // Don't add to options_to_interpret_ unless there were uninterpreted 5448| | // options. This not only avoids unnecessary work, but prevents a 5449| | // bootstrapping problem when building descriptors for descriptor.proto. 5450| | // descriptor.proto does not contain any uninterpreted options, but 5451| | // attempting to interpret options anyway will cause 5452| | // OptionsType::GetDescriptor() to be called which may then deadlock since 5453| | // we're still trying to build it. 5454| 17| if (options->uninterpreted_option_size() > 0) { ------------------ | Branch (5454:7): [True: 0, False: 17] ------------------ 5455| 0| options_to_interpret_.push_back(OptionsToInterpret( 5456| 0| name_scope, element_name, options_path, &orig_options, options)); 5457| 0| } 5458| | 5459| | // If the custom option is in unknown fields, no need to interpret it. 5460| | // Remove the dependency file from unused_dependency. 5461| 17| const UnknownFieldSet& unknown_fields = orig_options.unknown_fields(); 5462| 17| if (!unknown_fields.empty()) { ------------------ | Branch (5462:7): [True: 0, False: 17] ------------------ 5463| | // Can not use options->GetDescriptor() which may case deadlock. 5464| 0| Symbol msg_symbol = tables_->FindSymbol(option_name); 5465| 0| if (msg_symbol.type() == Symbol::MESSAGE) { ------------------ | Branch (5465:9): [True: 0, False: 0] ------------------ 5466| 0| for (int i = 0; i < unknown_fields.field_count(); ++i) { ------------------ | Branch (5466:23): [True: 0, False: 0] ------------------ 5467| 0| assert_mutex_held(pool_); 5468| 0| const FieldDescriptor* field = 5469| 0| pool_->InternalFindExtensionByNumberNoLock( 5470| 0| msg_symbol.descriptor(), unknown_fields.field(i).number()); 5471| 0| if (field) { ------------------ | Branch (5471:13): [True: 0, False: 0] ------------------ 5472| 0| unused_dependency_.erase(field->file()); 5473| 0| } 5474| 0| } 5475| 0| } 5476| 0| } 5477| 17| return options; 5478| 17|} descriptor.cc:_ZN6google8protobuf12_GLOBAL__N_117FlatAllocatorImplIJcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE13AllocateArrayISE_EEPT_i: 400| 17| U* AllocateArray(int array_size) { 401| 17| constexpr bool trivial = std::is_trivially_destructible::value; 402| 17| using TypeToUse = typename std::conditional::type; 403| | 404| | // We can only allocate after FinalizePlanning has been called. 405| 17| ABSL_CHECK(has_allocated()); ------------------ | | 41| 17| ABSL_LOG_INTERNAL_CHECK_IMPL((condition), #condition) | | ------------------ | | | | 26| 34| ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS, \ | | | | ------------------ | | | | | | 172| 17| ABSL_LOG_INTERNAL_##type##_CONDITION(condition) | | | | | | ------------------ | | | | | | | | 65| 34| switch (0) \ | | | | | | | | 66| 34| case 0: \ | | | | | | | | ------------------ | | | | | | | | | Branch (66:3): [True: 17, False: 0] | | | | | | | | ------------------ | | | | | | | | 67| 17| default: \ | | | | | | | | ------------------ | | | | | | | | | Branch (67:3): [True: 0, False: 17] | | | | | | | | ------------------ | | | | | | | | 68| 34| !(condition) ? (void)0 : ::absl::log_internal::Voidify()&& | | | | | | | | ------------------ | | | | | | | | | Branch (68:5): [True: 17, False: 0] | | | | | | | | | Branch (68:7): [Folded, False: 17] | | | | | | | | | Branch (68:7): [True: 0, False: 17] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 27| 34| ABSL_PREDICT_FALSE(!(condition))) \ | | | | 28| 34| ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream() | | | | ------------------ | | | | | | 66| 0| ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message) | | | | ------------------ | | ------------------ ------------------ 406| | 407| 17| TypeToUse*& data = pointers_.template Get(); 408| 17| int& used = used_.template Get(); 409| 17| U* res = reinterpret_cast(data + used); 410| 17| used += trivial ? RoundUpTo<8>(array_size * sizeof(U)) : array_size; ------------------ | Branch (410:13): [Folded, False: 17] ------------------ 411| 17| ABSL_CHECK_LE(used, total_.template Get()); ------------------ | | 54| 17| ABSL_LOG_INTERNAL_CHECK_LE_IMPL((val1), #val1, (val2), #val2) | | ------------------ | | | | 52| 17| ABSL_LOG_INTERNAL_CHECK_OP(Check_LE, <=, val1, val1_text, val2, val2_text) | | | | ------------------ | | | | | | 61| 17| while ( \ | | | | | | 62| 17| ::std::string* absl_log_internal_check_op_result ABSL_ATTRIBUTE_UNUSED = \ | | | | | | ------------------ | | | | | | | Branch (62:22): [True: 0, False: 17] | | | | | | ------------------ | | | | | | 63| 17| ::absl::log_internal::name##Impl( \ | | | | | | 64| 17| ::absl::log_internal::GetReferenceableValue(val1), \ | | | | | | 65| 17| ::absl::log_internal::GetReferenceableValue(val2), \ | | | | | | 66| 17| ABSL_LOG_INTERNAL_STRIP_STRING_LITERAL(val1_text \ | | | | | | 67| 17| " " #op " " val2_text))) \ | | | | | | 68| 17| ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS, true) \ | | | | | | ------------------ | | | | | | | | 172| 0| ABSL_LOG_INTERNAL_##type##_CONDITION(condition) | | | | | | | | ------------------ | | | | | | | | | | 65| 0| switch (0) \ | | | | | | | | | | 66| 0| case 0: \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (66:3): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 67| 0| default: \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (67:3): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 68| 0| !(condition) ? (void)0 : ::absl::log_internal::Voidify()&& | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (68:5): [Folded, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 69| 0| ABSL_LOG_INTERNAL_CHECK(*absl_log_internal_check_op_result).InternalStream() | | | | | | ------------------ | | | | | | | | 66| 0| ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 412| 17| return res; 413| 17| } _ZN6google8protobuf17DescriptorBuilder15AllocateOptionsINS0_10Descriptor14ExtensionRangeEEEvRKNT_5ProtoEPS5_iNSt3__117basic_string_viewIcNSA_11char_traitsIcEEEERNS0_8internal13FlatAllocatorE: 5396| 14| internal::FlatAllocator& alloc) { 5397| 14| std::vector options_path; 5398| 14| descriptor->GetLocationPath(&options_path); 5399| 14| options_path.push_back(options_field_tag); 5400| 14| auto options = AllocateOptionsImpl( 5401| 14| descriptor->full_name(), descriptor->full_name(), proto, options_path, 5402| 14| option_name, alloc); 5403| 14| descriptor->options_ = options; 5404| 14| descriptor->proto_features_ = &FeatureSet::default_instance(); 5405| 14| descriptor->merged_features_ = &FeatureSet::default_instance(); 5406| 14|} _ZN6google8protobuf17DescriptorBuilder19AllocateOptionsImplINS0_10Descriptor14ExtensionRangeEEEPKNT_11OptionsTypeENSt3__117basic_string_viewIcNS9_11char_traitsIcEEEESD_RKNS5_5ProtoEN4absl12lts_202401164SpanIKiEESD_RNS0_8internal13FlatAllocatorE: 5428| 14| internal::FlatAllocator& alloc) { 5429| 14| if (!proto.has_options()) { ------------------ | Branch (5429:7): [True: 14, False: 0] ------------------ 5430| 14| return &DescriptorT::OptionsType::default_instance(); 5431| 14| } 5432| 0| const typename DescriptorT::OptionsType& orig_options = proto.options(); 5433| | 5434| 0| auto* options = alloc.AllocateArray(1); 5435| | 5436| 0| if (!orig_options.IsInitialized()) { ------------------ | Branch (5436:7): [True: 0, False: 0] ------------------ 5437| 0| AddError(absl::StrCat(name_scope, ".", element_name), orig_options, 5438| 0| DescriptorPool::ErrorCollector::OPTION_NAME, 5439| 0| "Uninterpreted option is missing name or value."); 5440| 0| return &DescriptorT::OptionsType::default_instance(); 5441| 0| } 5442| | 5443| 0| const bool parse_success = 5444| 0| internal::ParseNoReflection(orig_options.SerializeAsString(), *options); 5445| 0| ABSL_DCHECK(parse_success); ------------------ | | 47| 0| ABSL_LOG_INTERNAL_DCHECK_IMPL((condition), #condition) | | ------------------ | | | | 43| 0| ABSL_LOG_INTERNAL_CHECK_IMPL(true || (condition), "true") | | | | ------------------ | | | | | | 26| 0| ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS, \ | | | | | | ------------------ | | | | | | | | 172| 0| ABSL_LOG_INTERNAL_##type##_CONDITION(condition) | | | | | | | | ------------------ | | | | | | | | | | 65| 0| switch (0) \ | | | | | | | | | | 66| 0| case 0: \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (66:3): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 67| 0| default: \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (67:3): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 68| 0| !(condition) ? (void)0 : ::absl::log_internal::Voidify()&& | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (68:5): [True: 0, Folded] | | | | | | | | | | | Branch (68:7): [True: 0, Folded] | | | | | | | | | | | Branch (68:7): [True: 0, False: 0] | | | | | | | | | | | Branch (68:7): [Folded, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 27| 0| ABSL_PREDICT_FALSE(!(condition))) \ | | | | | | 28| 0| ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream() | | | | | | ------------------ | | | | | | | | 66| 0| ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 5446| | 5447| | // Don't add to options_to_interpret_ unless there were uninterpreted 5448| | // options. This not only avoids unnecessary work, but prevents a 5449| | // bootstrapping problem when building descriptors for descriptor.proto. 5450| | // descriptor.proto does not contain any uninterpreted options, but 5451| | // attempting to interpret options anyway will cause 5452| | // OptionsType::GetDescriptor() to be called which may then deadlock since 5453| | // we're still trying to build it. 5454| 0| if (options->uninterpreted_option_size() > 0) { ------------------ | Branch (5454:7): [True: 0, False: 0] ------------------ 5455| 0| options_to_interpret_.push_back(OptionsToInterpret( 5456| 0| name_scope, element_name, options_path, &orig_options, options)); 5457| 0| } 5458| | 5459| | // If the custom option is in unknown fields, no need to interpret it. 5460| | // Remove the dependency file from unused_dependency. 5461| 0| const UnknownFieldSet& unknown_fields = orig_options.unknown_fields(); 5462| 0| if (!unknown_fields.empty()) { ------------------ | Branch (5462:7): [True: 0, False: 0] ------------------ 5463| | // Can not use options->GetDescriptor() which may case deadlock. 5464| 0| Symbol msg_symbol = tables_->FindSymbol(option_name); 5465| 0| if (msg_symbol.type() == Symbol::MESSAGE) { ------------------ | Branch (5465:9): [True: 0, False: 0] ------------------ 5466| 0| for (int i = 0; i < unknown_fields.field_count(); ++i) { ------------------ | Branch (5466:23): [True: 0, False: 0] ------------------ 5467| 0| assert_mutex_held(pool_); 5468| 0| const FieldDescriptor* field = 5469| 0| pool_->InternalFindExtensionByNumberNoLock( 5470| 0| msg_symbol.descriptor(), unknown_fields.field(i).number()); 5471| 0| if (field) { ------------------ | Branch (5471:13): [True: 0, False: 0] ------------------ 5472| 0| unused_dependency_.erase(field->file()); 5473| 0| } 5474| 0| } 5475| 0| } 5476| 0| } 5477| 0| return options; 5478| 0|} _ZN6google8protobuf17DescriptorBuilder15AllocateOptionsINS0_15OneofDescriptorEEEvRKNT_5ProtoEPS4_iNSt3__117basic_string_viewIcNS9_11char_traitsIcEEEERNS0_8internal13FlatAllocatorE: 5396| 2| internal::FlatAllocator& alloc) { 5397| 2| std::vector options_path; 5398| 2| descriptor->GetLocationPath(&options_path); 5399| 2| options_path.push_back(options_field_tag); 5400| 2| auto options = AllocateOptionsImpl( 5401| 2| descriptor->full_name(), descriptor->full_name(), proto, options_path, 5402| 2| option_name, alloc); 5403| 2| descriptor->options_ = options; 5404| 2| descriptor->proto_features_ = &FeatureSet::default_instance(); 5405| 2| descriptor->merged_features_ = &FeatureSet::default_instance(); 5406| 2|} _ZN6google8protobuf17DescriptorBuilder19AllocateOptionsImplINS0_15OneofDescriptorEEEPKNT_11OptionsTypeENSt3__117basic_string_viewIcNS8_11char_traitsIcEEEESC_RKNS4_5ProtoEN4absl12lts_202401164SpanIKiEESC_RNS0_8internal13FlatAllocatorE: 5428| 2| internal::FlatAllocator& alloc) { 5429| 2| if (!proto.has_options()) { ------------------ | Branch (5429:7): [True: 2, False: 0] ------------------ 5430| 2| return &DescriptorT::OptionsType::default_instance(); 5431| 2| } 5432| 0| const typename DescriptorT::OptionsType& orig_options = proto.options(); 5433| | 5434| 0| auto* options = alloc.AllocateArray(1); 5435| | 5436| 0| if (!orig_options.IsInitialized()) { ------------------ | Branch (5436:7): [True: 0, False: 0] ------------------ 5437| 0| AddError(absl::StrCat(name_scope, ".", element_name), orig_options, 5438| 0| DescriptorPool::ErrorCollector::OPTION_NAME, 5439| 0| "Uninterpreted option is missing name or value."); 5440| 0| return &DescriptorT::OptionsType::default_instance(); 5441| 0| } 5442| | 5443| 0| const bool parse_success = 5444| 0| internal::ParseNoReflection(orig_options.SerializeAsString(), *options); 5445| 0| ABSL_DCHECK(parse_success); ------------------ | | 47| 0| ABSL_LOG_INTERNAL_DCHECK_IMPL((condition), #condition) | | ------------------ | | | | 43| 0| ABSL_LOG_INTERNAL_CHECK_IMPL(true || (condition), "true") | | | | ------------------ | | | | | | 26| 0| ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS, \ | | | | | | ------------------ | | | | | | | | 172| 0| ABSL_LOG_INTERNAL_##type##_CONDITION(condition) | | | | | | | | ------------------ | | | | | | | | | | 65| 0| switch (0) \ | | | | | | | | | | 66| 0| case 0: \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (66:3): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 67| 0| default: \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (67:3): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 68| 0| !(condition) ? (void)0 : ::absl::log_internal::Voidify()&& | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (68:5): [True: 0, Folded] | | | | | | | | | | | Branch (68:7): [True: 0, Folded] | | | | | | | | | | | Branch (68:7): [True: 0, False: 0] | | | | | | | | | | | Branch (68:7): [Folded, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 27| 0| ABSL_PREDICT_FALSE(!(condition))) \ | | | | | | 28| 0| ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream() | | | | | | ------------------ | | | | | | | | 66| 0| ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 5446| | 5447| | // Don't add to options_to_interpret_ unless there were uninterpreted 5448| | // options. This not only avoids unnecessary work, but prevents a 5449| | // bootstrapping problem when building descriptors for descriptor.proto. 5450| | // descriptor.proto does not contain any uninterpreted options, but 5451| | // attempting to interpret options anyway will cause 5452| | // OptionsType::GetDescriptor() to be called which may then deadlock since 5453| | // we're still trying to build it. 5454| 0| if (options->uninterpreted_option_size() > 0) { ------------------ | Branch (5454:7): [True: 0, False: 0] ------------------ 5455| 0| options_to_interpret_.push_back(OptionsToInterpret( 5456| 0| name_scope, element_name, options_path, &orig_options, options)); 5457| 0| } 5458| | 5459| | // If the custom option is in unknown fields, no need to interpret it. 5460| | // Remove the dependency file from unused_dependency. 5461| 0| const UnknownFieldSet& unknown_fields = orig_options.unknown_fields(); 5462| 0| if (!unknown_fields.empty()) { ------------------ | Branch (5462:7): [True: 0, False: 0] ------------------ 5463| | // Can not use options->GetDescriptor() which may case deadlock. 5464| 0| Symbol msg_symbol = tables_->FindSymbol(option_name); 5465| 0| if (msg_symbol.type() == Symbol::MESSAGE) { ------------------ | Branch (5465:9): [True: 0, False: 0] ------------------ 5466| 0| for (int i = 0; i < unknown_fields.field_count(); ++i) { ------------------ | Branch (5466:23): [True: 0, False: 0] ------------------ 5467| 0| assert_mutex_held(pool_); 5468| 0| const FieldDescriptor* field = 5469| 0| pool_->InternalFindExtensionByNumberNoLock( 5470| 0| msg_symbol.descriptor(), unknown_fields.field(i).number()); 5471| 0| if (field) { ------------------ | Branch (5471:13): [True: 0, False: 0] ------------------ 5472| 0| unused_dependency_.erase(field->file()); 5473| 0| } 5474| 0| } 5475| 0| } 5476| 0| } 5477| 0| return options; 5478| 0|} descriptor.cc:_ZN6google8protobuf12_GLOBAL__N_117FlatAllocatorImplIJcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE13AllocateArrayINS0_14EnumDescriptor13ReservedRangeEEEPT_i: 400| 18| U* AllocateArray(int array_size) { 401| 18| constexpr bool trivial = std::is_trivially_destructible::value; 402| 18| using TypeToUse = typename std::conditional::type; 403| | 404| | // We can only allocate after FinalizePlanning has been called. 405| 18| ABSL_CHECK(has_allocated()); ------------------ | | 41| 18| ABSL_LOG_INTERNAL_CHECK_IMPL((condition), #condition) | | ------------------ | | | | 26| 36| ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS, \ | | | | ------------------ | | | | | | 172| 18| ABSL_LOG_INTERNAL_##type##_CONDITION(condition) | | | | | | ------------------ | | | | | | | | 65| 36| switch (0) \ | | | | | | | | 66| 36| case 0: \ | | | | | | | | ------------------ | | | | | | | | | Branch (66:3): [True: 18, False: 0] | | | | | | | | ------------------ | | | | | | | | 67| 18| default: \ | | | | | | | | ------------------ | | | | | | | | | Branch (67:3): [True: 0, False: 18] | | | | | | | | ------------------ | | | | | | | | 68| 36| !(condition) ? (void)0 : ::absl::log_internal::Voidify()&& | | | | | | | | ------------------ | | | | | | | | | Branch (68:5): [True: 18, False: 0] | | | | | | | | | Branch (68:7): [Folded, False: 18] | | | | | | | | | Branch (68:7): [True: 0, False: 18] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 27| 36| ABSL_PREDICT_FALSE(!(condition))) \ | | | | 28| 36| ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream() | | | | ------------------ | | | | | | 66| 0| ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message) | | | | ------------------ | | ------------------ ------------------ 406| | 407| 18| TypeToUse*& data = pointers_.template Get(); 408| 18| int& used = used_.template Get(); 409| 18| U* res = reinterpret_cast(data + used); 410| 18| used += trivial ? RoundUpTo<8>(array_size * sizeof(U)) : array_size; ------------------ | Branch (410:13): [True: 18, Folded] ------------------ 411| 18| ABSL_CHECK_LE(used, total_.template Get()); ------------------ | | 54| 18| ABSL_LOG_INTERNAL_CHECK_LE_IMPL((val1), #val1, (val2), #val2) | | ------------------ | | | | 52| 18| ABSL_LOG_INTERNAL_CHECK_OP(Check_LE, <=, val1, val1_text, val2, val2_text) | | | | ------------------ | | | | | | 61| 18| while ( \ | | | | | | 62| 18| ::std::string* absl_log_internal_check_op_result ABSL_ATTRIBUTE_UNUSED = \ | | | | | | ------------------ | | | | | | | Branch (62:22): [True: 0, False: 18] | | | | | | ------------------ | | | | | | 63| 18| ::absl::log_internal::name##Impl( \ | | | | | | 64| 18| ::absl::log_internal::GetReferenceableValue(val1), \ | | | | | | 65| 18| ::absl::log_internal::GetReferenceableValue(val2), \ | | | | | | 66| 18| ABSL_LOG_INTERNAL_STRIP_STRING_LITERAL(val1_text \ | | | | | | 67| 18| " " #op " " val2_text))) \ | | | | | | 68| 18| ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS, true) \ | | | | | | ------------------ | | | | | | | | 172| 0| ABSL_LOG_INTERNAL_##type##_CONDITION(condition) | | | | | | | | ------------------ | | | | | | | | | | 65| 0| switch (0) \ | | | | | | | | | | 66| 0| case 0: \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (66:3): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 67| 0| default: \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (67:3): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 68| 0| !(condition) ? (void)0 : ::absl::log_internal::Voidify()&& | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (68:5): [Folded, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 69| 0| ABSL_LOG_INTERNAL_CHECK(*absl_log_internal_check_op_result).InternalStream() | | | | | | ------------------ | | | | | | | | 66| 0| ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 412| 18| return res; 413| 18| } _ZN6google8protobuf17DescriptorBuilder15AllocateOptionsINS0_14EnumDescriptorEEEvRKNT_5ProtoEPS4_iNSt3__117basic_string_viewIcNS9_11char_traitsIcEEEERNS0_8internal13FlatAllocatorE: 5396| 18| internal::FlatAllocator& alloc) { 5397| 18| std::vector options_path; 5398| 18| descriptor->GetLocationPath(&options_path); 5399| 18| options_path.push_back(options_field_tag); 5400| 18| auto options = AllocateOptionsImpl( 5401| 18| descriptor->full_name(), descriptor->full_name(), proto, options_path, 5402| 18| option_name, alloc); 5403| 18| descriptor->options_ = options; 5404| 18| descriptor->proto_features_ = &FeatureSet::default_instance(); 5405| 18| descriptor->merged_features_ = &FeatureSet::default_instance(); 5406| 18|} _ZN6google8protobuf17DescriptorBuilder19AllocateOptionsImplINS0_14EnumDescriptorEEEPKNT_11OptionsTypeENSt3__117basic_string_viewIcNS8_11char_traitsIcEEEESC_RKNS4_5ProtoEN4absl12lts_202401164SpanIKiEESC_RNS0_8internal13FlatAllocatorE: 5428| 18| internal::FlatAllocator& alloc) { 5429| 18| if (!proto.has_options()) { ------------------ | Branch (5429:7): [True: 18, False: 0] ------------------ 5430| 18| return &DescriptorT::OptionsType::default_instance(); 5431| 18| } 5432| 0| const typename DescriptorT::OptionsType& orig_options = proto.options(); 5433| | 5434| 0| auto* options = alloc.AllocateArray(1); 5435| | 5436| 0| if (!orig_options.IsInitialized()) { ------------------ | Branch (5436:7): [True: 0, False: 0] ------------------ 5437| 0| AddError(absl::StrCat(name_scope, ".", element_name), orig_options, 5438| 0| DescriptorPool::ErrorCollector::OPTION_NAME, 5439| 0| "Uninterpreted option is missing name or value."); 5440| 0| return &DescriptorT::OptionsType::default_instance(); 5441| 0| } 5442| | 5443| 0| const bool parse_success = 5444| 0| internal::ParseNoReflection(orig_options.SerializeAsString(), *options); 5445| 0| ABSL_DCHECK(parse_success); ------------------ | | 47| 0| ABSL_LOG_INTERNAL_DCHECK_IMPL((condition), #condition) | | ------------------ | | | | 43| 0| ABSL_LOG_INTERNAL_CHECK_IMPL(true || (condition), "true") | | | | ------------------ | | | | | | 26| 0| ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS, \ | | | | | | ------------------ | | | | | | | | 172| 0| ABSL_LOG_INTERNAL_##type##_CONDITION(condition) | | | | | | | | ------------------ | | | | | | | | | | 65| 0| switch (0) \ | | | | | | | | | | 66| 0| case 0: \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (66:3): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 67| 0| default: \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (67:3): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 68| 0| !(condition) ? (void)0 : ::absl::log_internal::Voidify()&& | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (68:5): [True: 0, Folded] | | | | | | | | | | | Branch (68:7): [True: 0, Folded] | | | | | | | | | | | Branch (68:7): [True: 0, False: 0] | | | | | | | | | | | Branch (68:7): [Folded, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 27| 0| ABSL_PREDICT_FALSE(!(condition))) \ | | | | | | 28| 0| ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream() | | | | | | ------------------ | | | | | | | | 66| 0| ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 5446| | 5447| | // Don't add to options_to_interpret_ unless there were uninterpreted 5448| | // options. This not only avoids unnecessary work, but prevents a 5449| | // bootstrapping problem when building descriptors for descriptor.proto. 5450| | // descriptor.proto does not contain any uninterpreted options, but 5451| | // attempting to interpret options anyway will cause 5452| | // OptionsType::GetDescriptor() to be called which may then deadlock since 5453| | // we're still trying to build it. 5454| 0| if (options->uninterpreted_option_size() > 0) { ------------------ | Branch (5454:7): [True: 0, False: 0] ------------------ 5455| 0| options_to_interpret_.push_back(OptionsToInterpret( 5456| 0| name_scope, element_name, options_path, &orig_options, options)); 5457| 0| } 5458| | 5459| | // If the custom option is in unknown fields, no need to interpret it. 5460| | // Remove the dependency file from unused_dependency. 5461| 0| const UnknownFieldSet& unknown_fields = orig_options.unknown_fields(); 5462| 0| if (!unknown_fields.empty()) { ------------------ | Branch (5462:7): [True: 0, False: 0] ------------------ 5463| | // Can not use options->GetDescriptor() which may case deadlock. 5464| 0| Symbol msg_symbol = tables_->FindSymbol(option_name); 5465| 0| if (msg_symbol.type() == Symbol::MESSAGE) { ------------------ | Branch (5465:9): [True: 0, False: 0] ------------------ 5466| 0| for (int i = 0; i < unknown_fields.field_count(); ++i) { ------------------ | Branch (5466:23): [True: 0, False: 0] ------------------ 5467| 0| assert_mutex_held(pool_); 5468| 0| const FieldDescriptor* field = 5469| 0| pool_->InternalFindExtensionByNumberNoLock( 5470| 0| msg_symbol.descriptor(), unknown_fields.field(i).number()); 5471| 0| if (field) { ------------------ | Branch (5471:13): [True: 0, False: 0] ------------------ 5472| 0| unused_dependency_.erase(field->file()); 5473| 0| } 5474| 0| } 5475| 0| } 5476| 0| } 5477| 0| return options; 5478| 0|} descriptor.cc:_ZN6google8protobuf12_GLOBAL__N_117FlatAllocatorImplIJcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_10FeatureSetENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE15AllocateStringsIJRKS9_S9_EEEPSO_DpOT_: 416| 86| const std::string* AllocateStrings(In&&... in) { 417| 86| std::string* strings = AllocateArray(sizeof...(in)); 418| 86| std::string* res = strings; 419| 86| Fold({(*strings++ = std::string(std::forward(in)))...}); 420| 86| return res; 421| 86| } _ZN6google8protobuf17DescriptorBuilder15AllocateOptionsINS0_19EnumValueDescriptorEEEvRKNT_5ProtoEPS4_iNSt3__117basic_string_viewIcNS9_11char_traitsIcEEEERNS0_8internal13FlatAllocatorE: 5396| 86| internal::FlatAllocator& alloc) { 5397| 86| std::vector options_path; 5398| 86| descriptor->GetLocationPath(&options_path); 5399| 86| options_path.push_back(options_field_tag); 5400| 86| auto options = AllocateOptionsImpl( 5401| 86| descriptor->full_name(), descriptor->full_name(), proto, options_path, 5402| 86| option_name, alloc); 5403| 86| descriptor->options_ = options; 5404| 86| descriptor->proto_features_ = &FeatureSet::default_instance(); 5405| 86| descriptor->merged_features_ = &FeatureSet::default_instance(); 5406| 86|} _ZN6google8protobuf17DescriptorBuilder19AllocateOptionsImplINS0_19EnumValueDescriptorEEEPKNT_11OptionsTypeENSt3__117basic_string_viewIcNS8_11char_traitsIcEEEESC_RKNS4_5ProtoEN4absl12lts_202401164SpanIKiEESC_RNS0_8internal13FlatAllocatorE: 5428| 86| internal::FlatAllocator& alloc) { 5429| 86| if (!proto.has_options()) { ------------------ | Branch (5429:7): [True: 86, False: 0] ------------------ 5430| 86| return &DescriptorT::OptionsType::default_instance(); 5431| 86| } 5432| 0| const typename DescriptorT::OptionsType& orig_options = proto.options(); 5433| | 5434| 0| auto* options = alloc.AllocateArray(1); 5435| | 5436| 0| if (!orig_options.IsInitialized()) { ------------------ | Branch (5436:7): [True: 0, False: 0] ------------------ 5437| 0| AddError(absl::StrCat(name_scope, ".", element_name), orig_options, 5438| 0| DescriptorPool::ErrorCollector::OPTION_NAME, 5439| 0| "Uninterpreted option is missing name or value."); 5440| 0| return &DescriptorT::OptionsType::default_instance(); 5441| 0| } 5442| | 5443| 0| const bool parse_success = 5444| 0| internal::ParseNoReflection(orig_options.SerializeAsString(), *options); 5445| 0| ABSL_DCHECK(parse_success); ------------------ | | 47| 0| ABSL_LOG_INTERNAL_DCHECK_IMPL((condition), #condition) | | ------------------ | | | | 43| 0| ABSL_LOG_INTERNAL_CHECK_IMPL(true || (condition), "true") | | | | ------------------ | | | | | | 26| 0| ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS, \ | | | | | | ------------------ | | | | | | | | 172| 0| ABSL_LOG_INTERNAL_##type##_CONDITION(condition) | | | | | | | | ------------------ | | | | | | | | | | 65| 0| switch (0) \ | | | | | | | | | | 66| 0| case 0: \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (66:3): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 67| 0| default: \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (67:3): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 68| 0| !(condition) ? (void)0 : ::absl::log_internal::Voidify()&& | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (68:5): [True: 0, Folded] | | | | | | | | | | | Branch (68:7): [True: 0, Folded] | | | | | | | | | | | Branch (68:7): [True: 0, False: 0] | | | | | | | | | | | Branch (68:7): [Folded, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 27| 0| ABSL_PREDICT_FALSE(!(condition))) \ | | | | | | 28| 0| ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream() | | | | | | ------------------ | | | | | | | | 66| 0| ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 5446| | 5447| | // Don't add to options_to_interpret_ unless there were uninterpreted 5448| | // options. This not only avoids unnecessary work, but prevents a 5449| | // bootstrapping problem when building descriptors for descriptor.proto. 5450| | // descriptor.proto does not contain any uninterpreted options, but 5451| | // attempting to interpret options anyway will cause 5452| | // OptionsType::GetDescriptor() to be called which may then deadlock since 5453| | // we're still trying to build it. 5454| 0| if (options->uninterpreted_option_size() > 0) { ------------------ | Branch (5454:7): [True: 0, False: 0] ------------------ 5455| 0| options_to_interpret_.push_back(OptionsToInterpret( 5456| 0| name_scope, element_name, options_path, &orig_options, options)); 5457| 0| } 5458| | 5459| | // If the custom option is in unknown fields, no need to interpret it. 5460| | // Remove the dependency file from unused_dependency. 5461| 0| const UnknownFieldSet& unknown_fields = orig_options.unknown_fields(); 5462| 0| if (!unknown_fields.empty()) { ------------------ | Branch (5462:7): [True: 0, False: 0] ------------------ 5463| | // Can not use options->GetDescriptor() which may case deadlock. 5464| 0| Symbol msg_symbol = tables_->FindSymbol(option_name); 5465| 0| if (msg_symbol.type() == Symbol::MESSAGE) { ------------------ | Branch (5465:9): [True: 0, False: 0] ------------------ 5466| 0| for (int i = 0; i < unknown_fields.field_count(); ++i) { ------------------ | Branch (5466:23): [True: 0, False: 0] ------------------ 5467| 0| assert_mutex_held(pool_); 5468| 0| const FieldDescriptor* field = 5469| 0| pool_->InternalFindExtensionByNumberNoLock( 5470| 0| msg_symbol.descriptor(), unknown_fields.field(i).number()); 5471| 0| if (field) { ------------------ | Branch (5471:13): [True: 0, False: 0] ------------------ 5472| 0| unused_dependency_.erase(field->file()); 5473| 0| } 5474| 0| } 5475| 0| } 5476| 0| } 5477| 0| return options; 5478| 0|} _ZNK6google8protobuf10Descriptor14ExtensionRange12start_numberEv: 493| 130| int start_number() const { return start_; } _ZNK6google8protobuf10Descriptor14ExtensionRange10end_numberEv: 496| 31| int end_number() const { return end_; } _ZNK6google8protobuf10Descriptor14ExtensionRange9full_nameEv: 511| 28| internal::DescriptorStringView full_name() const { 512| 28| return containing_type_->full_name(); 513| 28| } _ZNK6google8protobuf10Descriptor14ExtensionRange4fileEv: 517| 14| const FileDescriptor* file() const { return containing_type_->file(); } _ZNK6google8protobuf10Descriptor14ExtensionRange15containing_typeEv: 521| 28| const Descriptor* containing_type() const { return containing_type_; } _ZNK6google8protobuf10Descriptor8featuresEv: 667| 241| const FeatureSet& features() const { return *merged_features_; } _ZNK6google8protobuf15FieldDescriptor8featuresEv: 1077| 200k| const FeatureSet& features() const { return *merged_features_; } _ZNK6google8protobuf15OneofDescriptor8featuresEv: 1261| 7| const FeatureSet& features() const { return *merged_features_; } _ZNK6google8protobuf14EnumDescriptor8featuresEv: 1436| 86| const FeatureSet& features() const { return *merged_features_; } _ZNK6google8protobuf14FileDescriptor8featuresEv: 1992| 37| const FeatureSet& features() const { return *merged_features_; } _ZN6google8protobuf14DescriptorPool34InternalSetLazilyBuildDependenciesEv: 2356| 2| void InternalSetLazilyBuildDependencies() { 2357| 2| lazily_build_dependencies_ = true; 2358| | // This needs to be set when lazily building dependencies, as it breaks 2359| | // dependency checking. 2360| 2| InternalDontEnforceDependencies(); 2361| 2| } _ZNK6google8protobuf10Descriptor4nameEv: 2520| 141| inline internal::DescriptorStringView CLASS::name() const { \ 2521| 141| return all_names_[0]; \ 2522| 141| } \ _ZNK6google8protobuf10Descriptor9full_nameEv: 2523| 64.2k| inline internal::DescriptorStringView CLASS::full_name() const { \ 2524| 64.2k| return all_names_[1]; \ 2525| 64.2k| } _ZNK6google8protobuf10Descriptor15containing_typeEv: 2510| 602| inline TYPE CLASS::FIELD() const { return FIELD##_; } _ZNK6google8protobuf10Descriptor16oneof_decl_countEv: 2510| 289| inline TYPE CLASS::FIELD() const { return FIELD##_; } _ZNK6google8protobuf10Descriptor17nested_type_countEv: 2510| 340| inline TYPE CLASS::FIELD() const { return FIELD##_; } _ZNK6google8protobuf10Descriptor15enum_type_countEv: 2510| 310| inline TYPE CLASS::FIELD() const { return FIELD##_; } _ZNK6google8protobuf10Descriptor10oneof_declEi: 2529| 17| inline TYPE CLASS::FIELD(int index) const { \ 2530| 17| ABSL_DCHECK_LE(0, index); \ ------------------ | | 78| 17| ABSL_LOG_INTERNAL_DCHECK_LE_IMPL((val1), #val1, (val2), #val2) | | ------------------ | | | | 90| 17| ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2) | | | | ------------------ | | | | | | 56| 17| while (false && ((void)(x), (void)(y), 0)) \ | | | | | | ------------------ | | | | | | | Branch (56:10): [Folded, False: 17] | | | | | | | Branch (56:19): [Folded, False: 0] | | | | | | ------------------ | | | | | | 57| 17| ::absl::log_internal::NullStream().InternalStream() | | | | ------------------ | | ------------------ ------------------ 2531| 17| ABSL_DCHECK_LT(index, FIELD##_count()); \ ------------------ | | 80| 17| ABSL_LOG_INTERNAL_DCHECK_LT_IMPL((val1), #val1, (val2), #val2) | | ------------------ | | | | 92| 17| ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2) | | | | ------------------ | | | | | | 56| 17| while (false && ((void)(x), (void)(y), 0)) \ | | | | | | ------------------ | | | | | | | Branch (56:10): [Folded, False: 17] | | | | | | | Branch (56:19): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 57| 17| ::absl::log_internal::NullStream().InternalStream() | | | | ------------------ | | ------------------ ------------------ 2532| 17| return FIELD##s_ + index; \ 2533| 17| } _ZNK6google8protobuf10Descriptor11nested_typeEi: 2529| 50| inline TYPE CLASS::FIELD(int index) const { \ 2530| 50| ABSL_DCHECK_LE(0, index); \ ------------------ | | 78| 50| ABSL_LOG_INTERNAL_DCHECK_LE_IMPL((val1), #val1, (val2), #val2) | | ------------------ | | | | 90| 50| ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2) | | | | ------------------ | | | | | | 56| 50| while (false && ((void)(x), (void)(y), 0)) \ | | | | | | ------------------ | | | | | | | Branch (56:10): [Folded, False: 50] | | | | | | | Branch (56:19): [Folded, False: 0] | | | | | | ------------------ | | | | | | 57| 50| ::absl::log_internal::NullStream().InternalStream() | | | | ------------------ | | ------------------ ------------------ 2531| 50| ABSL_DCHECK_LT(index, FIELD##_count()); \ ------------------ | | 80| 50| ABSL_LOG_INTERNAL_DCHECK_LT_IMPL((val1), #val1, (val2), #val2) | | ------------------ | | | | 92| 50| ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2) | | | | ------------------ | | | | | | 56| 50| while (false && ((void)(x), (void)(y), 0)) \ | | | | | | ------------------ | | | | | | | Branch (56:10): [Folded, False: 50] | | | | | | | Branch (56:19): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 57| 50| ::absl::log_internal::NullStream().InternalStream() | | | | ------------------ | | ------------------ ------------------ 2532| 50| return FIELD##s_ + index; \ 2533| 50| } _ZNK6google8protobuf10Descriptor9enum_typeEi: 2529| 85| inline TYPE CLASS::FIELD(int index) const { \ 2530| 85| ABSL_DCHECK_LE(0, index); \ ------------------ | | 78| 85| ABSL_LOG_INTERNAL_DCHECK_LE_IMPL((val1), #val1, (val2), #val2) | | ------------------ | | | | 90| 85| ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2) | | | | ------------------ | | | | | | 56| 85| while (false && ((void)(x), (void)(y), 0)) \ | | | | | | ------------------ | | | | | | | Branch (56:10): [Folded, False: 85] | | | | | | | Branch (56:19): [Folded, False: 0] | | | | | | ------------------ | | | | | | 57| 85| ::absl::log_internal::NullStream().InternalStream() | | | | ------------------ | | ------------------ ------------------ 2531| 85| ABSL_DCHECK_LT(index, FIELD##_count()); \ ------------------ | | 80| 85| ABSL_LOG_INTERNAL_DCHECK_LT_IMPL((val1), #val1, (val2), #val2) | | ------------------ | | | | 92| 85| ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2) | | | | ------------------ | | | | | | 56| 85| while (false && ((void)(x), (void)(y), 0)) \ | | | | | | ------------------ | | | | | | | Branch (56:10): [Folded, False: 85] | | | | | | | Branch (56:19): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 57| 85| ::absl::log_internal::NullStream().InternalStream() | | | | ------------------ | | ------------------ ------------------ 2532| 85| return FIELD##s_ + index; \ 2533| 85| } _ZNK6google8protobuf10Descriptor21extension_range_countEv: 2510| 603| inline TYPE CLASS::FIELD() const { return FIELD##_; } _ZNK6google8protobuf10Descriptor15extension_countEv: 2510| 225| inline TYPE CLASS::FIELD() const { return FIELD##_; } _ZNK6google8protobuf10Descriptor15extension_rangeEi: 2529| 161| inline TYPE CLASS::FIELD(int index) const { \ 2530| 161| ABSL_DCHECK_LE(0, index); \ ------------------ | | 78| 161| ABSL_LOG_INTERNAL_DCHECK_LE_IMPL((val1), #val1, (val2), #val2) | | ------------------ | | | | 90| 161| ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2) | | | | ------------------ | | | | | | 56| 161| while (false && ((void)(x), (void)(y), 0)) \ | | | | | | ------------------ | | | | | | | Branch (56:10): [Folded, False: 161] | | | | | | | Branch (56:19): [Folded, False: 0] | | | | | | ------------------ | | | | | | 57| 161| ::absl::log_internal::NullStream().InternalStream() | | | | ------------------ | | ------------------ ------------------ 2531| 161| ABSL_DCHECK_LT(index, FIELD##_count()); \ ------------------ | | 80| 161| ABSL_LOG_INTERNAL_DCHECK_LT_IMPL((val1), #val1, (val2), #val2) | | ------------------ | | | | 92| 161| ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2) | | | | ------------------ | | | | | | 56| 161| while (false && ((void)(x), (void)(y), 0)) \ | | | | | | ------------------ | | | | | | | Branch (56:10): [Folded, False: 161] | | | | | | | Branch (56:19): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 57| 161| ::absl::log_internal::NullStream().InternalStream() | | | | ------------------ | | ------------------ ------------------ 2532| 161| return FIELD##s_ + index; \ 2533| 161| } _ZNK6google8protobuf10Descriptor20reserved_range_countEv: 2510| 359| inline TYPE CLASS::FIELD() const { return FIELD##_; } _ZNK6google8protobuf10Descriptor14reserved_rangeEi: 2529| 140| inline TYPE CLASS::FIELD(int index) const { \ 2530| 140| ABSL_DCHECK_LE(0, index); \ ------------------ | | 78| 140| ABSL_LOG_INTERNAL_DCHECK_LE_IMPL((val1), #val1, (val2), #val2) | | ------------------ | | | | 90| 140| ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2) | | | | ------------------ | | | | | | 56| 140| while (false && ((void)(x), (void)(y), 0)) \ | | | | | | ------------------ | | | | | | | Branch (56:10): [Folded, False: 140] | | | | | | | Branch (56:19): [Folded, False: 0] | | | | | | ------------------ | | | | | | 57| 140| ::absl::log_internal::NullStream().InternalStream() | | | | ------------------ | | ------------------ ------------------ 2531| 140| ABSL_DCHECK_LT(index, FIELD##_count()); \ ------------------ | | 80| 140| ABSL_LOG_INTERNAL_DCHECK_LT_IMPL((val1), #val1, (val2), #val2) | | ------------------ | | | | 92| 140| ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2) | | | | ------------------ | | | | | | 56| 140| while (false && ((void)(x), (void)(y), 0)) \ | | | | | | ------------------ | | | | | | | Branch (56:10): [Folded, False: 140] | | | | | | | Branch (56:19): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 57| 140| ::absl::log_internal::NullStream().InternalStream() | | | | ------------------ | | ------------------ ------------------ 2532| 140| return FIELD##s_ + index; \ 2533| 140| } _ZNK6google8protobuf10Descriptor19reserved_name_countEv: 2510| 36| inline TYPE CLASS::FIELD() const { return FIELD##_; } _ZNK6google8protobuf15FieldDescriptor4nameEv: 2520| 64.4k| inline internal::DescriptorStringView CLASS::name() const { \ 2521| 64.4k| return all_names_[0]; \ 2522| 64.4k| } \ _ZNK6google8protobuf15FieldDescriptor9full_nameEv: 2523| 1.45k| inline internal::DescriptorStringView CLASS::full_name() const { \ 2524| 1.45k| return all_names_[1]; \ 2525| 1.45k| } _ZNK6google8protobuf15FieldDescriptor4fileEv: 2510| 415| inline TYPE CLASS::FIELD() const { return FIELD##_; } _ZNK6google8protobuf15FieldDescriptor6numberEv: 2510| 29.8k| inline TYPE CLASS::FIELD() const { return FIELD##_; } _ZNK6google8protobuf15FieldDescriptor12is_extensionEv: 2510| 522k| inline TYPE CLASS::FIELD() const { return FIELD##_; } _ZNK6google8protobuf15FieldDescriptor15containing_typeEv: 2510| 1.08M| inline TYPE CLASS::FIELD() const { return FIELD##_; } _ZNK6google8protobuf15FieldDescriptor7optionsEv: 2536| 63.4k| inline const TYPE& CLASS::options() const { return *options_; } _ZNK6google8protobuf15FieldDescriptor17has_default_valueEv: 2510| 92| inline TYPE CLASS::FIELD() const { return FIELD##_; } _ZNK6google8protobuf15OneofDescriptor4nameEv: 2520| 6| inline internal::DescriptorStringView CLASS::name() const { \ 2521| 6| return all_names_[0]; \ 2522| 6| } \ _ZNK6google8protobuf15OneofDescriptor9full_nameEv: 2523| 10| inline internal::DescriptorStringView CLASS::full_name() const { \ 2524| 10| return all_names_[1]; \ 2525| 10| } _ZNK6google8protobuf15OneofDescriptor15containing_typeEv: 2510| 10| inline TYPE CLASS::FIELD() const { return FIELD##_; } _ZNK6google8protobuf14EnumDescriptor4nameEv: 2520| 136| inline internal::DescriptorStringView CLASS::name() const { \ 2521| 136| return all_names_[0]; \ 2522| 136| } \ _ZNK6google8protobuf14EnumDescriptor9full_nameEv: 2523| 307| inline internal::DescriptorStringView CLASS::full_name() const { \ 2524| 307| return all_names_[1]; \ 2525| 307| } _ZNK6google8protobuf14EnumDescriptor4fileEv: 2510| 149| inline TYPE CLASS::FIELD() const { return FIELD##_; } _ZNK6google8protobuf14EnumDescriptor15containing_typeEv: 2510| 521| inline TYPE CLASS::FIELD() const { return FIELD##_; } _ZNK6google8protobuf14EnumDescriptor20reserved_range_countEv: 2510| 89| inline TYPE CLASS::FIELD() const { return FIELD##_; } _ZNK6google8protobuf14EnumDescriptor14reserved_rangeEi: 2529| 3| inline TYPE CLASS::FIELD(int index) const { \ 2530| 3| ABSL_DCHECK_LE(0, index); \ ------------------ | | 78| 3| ABSL_LOG_INTERNAL_DCHECK_LE_IMPL((val1), #val1, (val2), #val2) | | ------------------ | | | | 90| 3| ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2) | | | | ------------------ | | | | | | 56| 3| while (false && ((void)(x), (void)(y), 0)) \ | | | | | | ------------------ | | | | | | | Branch (56:10): [Folded, False: 3] | | | | | | | Branch (56:19): [Folded, False: 0] | | | | | | ------------------ | | | | | | 57| 3| ::absl::log_internal::NullStream().InternalStream() | | | | ------------------ | | ------------------ ------------------ 2531| 3| ABSL_DCHECK_LT(index, FIELD##_count()); \ ------------------ | | 80| 3| ABSL_LOG_INTERNAL_DCHECK_LT_IMPL((val1), #val1, (val2), #val2) | | ------------------ | | | | 92| 3| ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2) | | | | ------------------ | | | | | | 56| 3| while (false && ((void)(x), (void)(y), 0)) \ | | | | | | ------------------ | | | | | | | Branch (56:10): [Folded, False: 3] | | | | | | | Branch (56:19): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 57| 3| ::absl::log_internal::NullStream().InternalStream() | | | | ------------------ | | ------------------ ------------------ 2532| 3| return FIELD##s_ + index; \ 2533| 3| } _ZNK6google8protobuf19EnumValueDescriptor4nameEv: 2520| 597| inline internal::DescriptorStringView CLASS::name() const { \ 2521| 597| return all_names_[0]; \ 2522| 597| } \ _ZNK6google8protobuf19EnumValueDescriptor9full_nameEv: 2523| 525| inline internal::DescriptorStringView CLASS::full_name() const { \ 2524| 525| return all_names_[1]; \ 2525| 525| } _ZNK6google8protobuf19EnumValueDescriptor6numberEv: 2510| 292| inline TYPE CLASS::FIELD() const { return FIELD##_; } _ZNK6google8protobuf14FileDescriptor4nameEv: 2514| 19| inline internal::DescriptorStringView CLASS::FIELD() const { \ 2515| 19| return *FIELD##_; \ 2516| 19| } _ZNK6google8protobuf14FileDescriptor7packageEv: 2514| 76| inline internal::DescriptorStringView CLASS::FIELD() const { \ 2515| 76| return *FIELD##_; \ 2516| 76| } _ZNK6google8protobuf14FileDescriptor18message_type_countEv: 2510| 245| inline TYPE CLASS::FIELD() const { return FIELD##_; } _ZNK6google8protobuf14FileDescriptor15enum_type_countEv: 2510| 25| inline TYPE CLASS::FIELD() const { return FIELD##_; } _ZNK6google8protobuf14FileDescriptor13service_countEv: 2510| 20| inline TYPE CLASS::FIELD() const { return FIELD##_; } _ZNK6google8protobuf14FileDescriptor15extension_countEv: 2510| 25| inline TYPE CLASS::FIELD() const { return FIELD##_; } _ZNK6google8protobuf14FileDescriptor7optionsEv: 2536| 4| inline const TYPE& CLASS::options() const { return *options_; } _ZNK6google8protobuf14FileDescriptor12message_typeEi: 2529| 185| inline TYPE CLASS::FIELD(int index) const { \ 2530| 185| ABSL_DCHECK_LE(0, index); \ ------------------ | | 78| 185| ABSL_LOG_INTERNAL_DCHECK_LE_IMPL((val1), #val1, (val2), #val2) | | ------------------ | | | | 90| 185| ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2) | | | | ------------------ | | | | | | 56| 185| while (false && ((void)(x), (void)(y), 0)) \ | | | | | | ------------------ | | | | | | | Branch (56:10): [Folded, False: 185] | | | | | | | Branch (56:19): [Folded, False: 0] | | | | | | ------------------ | | | | | | 57| 185| ::absl::log_internal::NullStream().InternalStream() | | | | ------------------ | | ------------------ ------------------ 2531| 185| ABSL_DCHECK_LT(index, FIELD##_count()); \ ------------------ | | 80| 185| ABSL_LOG_INTERNAL_DCHECK_LT_IMPL((val1), #val1, (val2), #val2) | | ------------------ | | | | 92| 185| ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2) | | | | ------------------ | | | | | | 56| 185| while (false && ((void)(x), (void)(y), 0)) \ | | | | | | ------------------ | | | | | | | Branch (56:10): [Folded, False: 185] | | | | | | | Branch (56:19): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 57| 185| ::absl::log_internal::NullStream().InternalStream() | | | | ------------------ | | ------------------ ------------------ 2532| 185| return FIELD##s_ + index; \ 2533| 185| } _ZNK6google8protobuf14FileDescriptor9enum_typeEi: 2529| 5| inline TYPE CLASS::FIELD(int index) const { \ 2530| 5| ABSL_DCHECK_LE(0, index); \ ------------------ | | 78| 5| ABSL_LOG_INTERNAL_DCHECK_LE_IMPL((val1), #val1, (val2), #val2) | | ------------------ | | | | 90| 5| ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2) | | | | ------------------ | | | | | | 56| 5| while (false && ((void)(x), (void)(y), 0)) \ | | | | | | ------------------ | | | | | | | Branch (56:10): [Folded, False: 5] | | | | | | | Branch (56:19): [Folded, False: 0] | | | | | | ------------------ | | | | | | 57| 5| ::absl::log_internal::NullStream().InternalStream() | | | | ------------------ | | ------------------ ------------------ 2531| 5| ABSL_DCHECK_LT(index, FIELD##_count()); \ ------------------ | | 80| 5| ABSL_LOG_INTERNAL_DCHECK_LT_IMPL((val1), #val1, (val2), #val2) | | ------------------ | | | | 92| 5| ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2) | | | | ------------------ | | | | | | 56| 5| while (false && ((void)(x), (void)(y), 0)) \ | | | | | | ------------------ | | | | | | | Branch (56:10): [Folded, False: 5] | | | | | | | Branch (56:19): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 57| 5| ::absl::log_internal::NullStream().InternalStream() | | | | ------------------ | | ------------------ ------------------ 2532| 5| return FIELD##s_ + index; \ 2533| 5| } _ZNK6google8protobuf14FileDescriptor9extensionEi: 2529| 4| inline TYPE CLASS::FIELD(int index) const { \ 2530| 4| ABSL_DCHECK_LE(0, index); \ ------------------ | | 78| 4| ABSL_LOG_INTERNAL_DCHECK_LE_IMPL((val1), #val1, (val2), #val2) | | ------------------ | | | | 90| 4| ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2) | | | | ------------------ | | | | | | 56| 4| while (false && ((void)(x), (void)(y), 0)) \ | | | | | | ------------------ | | | | | | | Branch (56:10): [Folded, False: 4] | | | | | | | Branch (56:19): [Folded, False: 0] | | | | | | ------------------ | | | | | | 57| 4| ::absl::log_internal::NullStream().InternalStream() | | | | ------------------ | | ------------------ ------------------ 2531| 4| ABSL_DCHECK_LT(index, FIELD##_count()); \ ------------------ | | 80| 4| ABSL_LOG_INTERNAL_DCHECK_LT_IMPL((val1), #val1, (val2), #val2) | | ------------------ | | | | 92| 4| ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2) | | | | ------------------ | | | | | | 56| 4| while (false && ((void)(x), (void)(y), 0)) \ | | | | | | ------------------ | | | | | | | Branch (56:10): [Folded, False: 4] | | | | | | | Branch (56:19): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 57| 4| ::absl::log_internal::NullStream().InternalStream() | | | | ------------------ | | ------------------ ------------------ 2532| 4| return FIELD##s_ + index; \ 2533| 4| } _ZNK6google8protobuf10Descriptor14IsReservedNameENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEE: 2663| 36|inline bool Descriptor::IsReservedName(absl::string_view name) const { 2664| 36| for (int i = 0; i < reserved_name_count(); i++) { ------------------ | Branch (2664:19): [True: 0, False: 36] ------------------ 2665| 0| if (name == static_cast(reserved_name(i))) { ------------------ | Branch (2665:9): [True: 0, False: 0] ------------------ 2666| 0| return true; 2667| 0| } 2668| 0| } 2669| 36| return false; 2670| 36|} _ZNK6google8protobuf15FieldDescriptor15extension_scopeEv: 2725| 5|inline const Descriptor* FieldDescriptor::extension_scope() const { 2726| 5| ABSL_CHECK(is_extension_); ------------------ | | 41| 5| ABSL_LOG_INTERNAL_CHECK_IMPL((condition), #condition) | | ------------------ | | | | 26| 10| ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS, \ | | | | ------------------ | | | | | | 172| 5| ABSL_LOG_INTERNAL_##type##_CONDITION(condition) | | | | | | ------------------ | | | | | | | | 65| 10| switch (0) \ | | | | | | | | 66| 10| case 0: \ | | | | | | | | ------------------ | | | | | | | | | Branch (66:3): [True: 5, False: 0] | | | | | | | | ------------------ | | | | | | | | 67| 5| default: \ | | | | | | | | ------------------ | | | | | | | | | Branch (67:3): [True: 0, False: 5] | | | | | | | | ------------------ | | | | | | | | 68| 10| !(condition) ? (void)0 : ::absl::log_internal::Voidify()&& | | | | | | | | ------------------ | | | | | | | | | Branch (68:5): [True: 5, False: 0] | | | | | | | | | Branch (68:7): [Folded, False: 5] | | | | | | | | | Branch (68:7): [True: 0, False: 5] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 27| 10| ABSL_PREDICT_FALSE(!(condition))) \ | | | | 28| 10| ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream() | | | | ------------------ | | | | | | 66| 0| ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message) | | | | ------------------ | | ------------------ ------------------ 2727| 5| return scope_.extension_scope; 2728| 5|} _ZNK6google8protobuf15FieldDescriptor5labelEv: 2730| 394k|inline FieldDescriptor::Label FieldDescriptor::label() const { 2731| 394k| return static_cast