VEP_Parse: 613| 1.59k|{ 614| 1.59k| const char *e; 615| 1.59k| struct vep_match *vm; 616| 1.59k| int i; 617| | 618| 1.59k| CHECK_OBJ_NOTNULL(vep, VEP_MAGIC); ------------------ | | 66| 1.59k| do { \ | | 67| 1.59k| assert((ptr) != NULL); \ | | ------------------ | | | | 65| 1.59k|#define assert(e) \ | | | | 66| 1.59k|do { \ | | | | 67| 1.59k| if (!(e)) { \ | | | | ------------------ | | | | | Branch (67:6): [True: 0, False: 1.59k] | | | | ------------------ | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | 69| 0| #e, VAS_ASSERT); \ | | | | 70| 0| } \ | | | | 71| 1.59k|} while (0) | | | | ------------------ | | | | | Branch (71:10): [Folded, False: 1.59k] | | | | ------------------ | | ------------------ | | 68| 1.59k| assert((ptr)->magic == type_magic); \ | | ------------------ | | | | 65| 1.59k|#define assert(e) \ | | | | 66| 1.59k|do { \ | | | | 67| 1.59k| if (!(e)) { \ | | | | ------------------ | | | | | Branch (67:6): [True: 0, False: 1.59k] | | | | ------------------ | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | 69| 0| #e, VAS_ASSERT); \ | | | | 70| 0| } \ | | | | 71| 1.59k|} while (0) | | | | ------------------ | | | | | Branch (71:10): [Folded, False: 1.59k] | | | | ------------------ | | ------------------ | | 69| 1.59k| } while (0) | | ------------------ | | | Branch (69:11): [Folded, False: 1.59k] | | ------------------ ------------------ 619| 1.59k| assert(l > 0); ------------------ | | 65| 1.59k|#define assert(e) \ | | 66| 1.59k|do { \ | | 67| 1.59k| if (!(e)) { \ | | ------------------ | | | Branch (67:6): [True: 0, False: 1.59k] | | ------------------ | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | 69| 0| #e, VAS_ASSERT); \ | | 70| 0| } \ | | 71| 1.59k|} while (0) | | ------------------ | | | Branch (71:10): [Folded, False: 1.59k] | | ------------------ ------------------ 620| | 621| 1.59k| if (vep->startup) { ------------------ | Branch (621:6): [True: 1.59k, False: 0] ------------------ 622| | /* 623| | * We must force the GZIP header out as a SKIP string, 624| | * otherwise an object starting with ver_p = ""; 629| 1.59k| vep->last_mark = SKIP; 630| 1.59k| vep_mark_common(vep, vep->ver_p, VERBATIM); 631| 1.59k| vep->startup = 0; 632| 1.59k| AZ(vep->hack_p); ------------------ | | 83| 1.59k|#define AZ(foo) do { assert((foo) == 0); } while (0) | | ------------------ | | | | 65| 1.59k|#define assert(e) \ | | | | 66| 1.59k|do { \ | | | | 67| 1.59k| if (!(e)) { \ | | | | ------------------ | | | | | Branch (67:6): [True: 0, False: 1.59k] | | | | ------------------ | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | 69| 0| #e, VAS_ASSERT); \ | | | | 70| 0| } \ | | | | 71| 1.59k|} while (0) | | | | ------------------ | | | | | Branch (71:10): [Folded, False: 1.59k] | | | | ------------------ | | ------------------ | | | Branch (83:52): [Folded, False: 1.59k] | | ------------------ ------------------ 633| 1.59k| vep->hack_p = p; 634| 1.59k| } 635| | 636| 1.59k| vep->ver_p = p; 637| | 638| 1.59k| e = p + l; 639| | 640| 841k| while (p < e) { ------------------ | Branch (640:9): [True: 840k, False: 1.59k] ------------------ 641| 840k| AN(vep->state); ------------------ | | 84| 840k|#define AN(foo) do { assert((foo) != 0); } while (0) | | ------------------ | | | | 65| 840k|#define assert(e) \ | | | | 66| 840k|do { \ | | | | 67| 840k| if (!(e)) { \ | | | | ------------------ | | | | | Branch (67:6): [True: 0, False: 840k] | | | | ------------------ | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | 69| 0| #e, VAS_ASSERT); \ | | | | 70| 0| } \ | | | | 71| 840k|} while (0) | | | | ------------------ | | | | | Branch (71:10): [Folded, False: 840k] | | | | ------------------ | | ------------------ | | | Branch (84:52): [Folded, False: 840k] | | ------------------ ------------------ 642| 840k| Debug("EP %s %d (%.*s) [%.*s]\n", 643| 840k| vep->state, 644| 840k| vep->remove, 645| 840k| vep->tag_i, vep->tag, 646| 840k| (e - p) > 10 ? 10 : (int)(e-p), p); 647| 840k| assert(p >= vep->ver_p); ------------------ | | 65| 840k|#define assert(e) \ | | 66| 840k|do { \ | | 67| 840k| if (!(e)) { \ | | ------------------ | | | Branch (67:6): [True: 0, False: 840k] | | ------------------ | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | 69| 0| #e, VAS_ASSERT); \ | | 70| 0| } \ | | 71| 840k|} while (0) | | ------------------ | | | Branch (71:10): [Folded, False: 840k] | | ------------------ ------------------ 648| | 649| | /****************************************************** 650| | * SECTION A 651| | */ 652| | 653| 840k| if (vep->state == VEP_START) { ------------------ | Branch (653:7): [True: 3.34k, False: 837k] ------------------ 654| 3.34k| if (vep->flags.esi_remove_bom && ------------------ | Branch (654:8): [True: 3.23k, False: 110] ------------------ 655| 3.23k| *p == (char)0xeb) { ------------------ | Branch (655:8): [True: 1.78k, False: 1.44k] ------------------ 656| 1.78k| vep->match = vep_match_bom; 657| 1.78k| vep->state = VEP_MATCH; 658| 1.78k| } else 659| 1.55k| vep->state = VEP_BOM; 660| 837k| } else if (vep->state == VEP_BOM) { ------------------ | Branch (660:14): [True: 1.57k, False: 835k] ------------------ 661| 1.57k| vep_mark_skip(vep, p); 662| 1.57k| if (vep->flags.esi_disable_xml_check) ------------------ | Branch (662:8): [True: 1.48k, False: 83] ------------------ 663| 1.48k| vep->state = VEP_NEXTTAG; 664| 83| else 665| 83| vep->state = VEP_TESTXML; 666| 835k| } else if (vep->state == VEP_TESTXML) { ------------------ | Branch (666:14): [True: 83, False: 835k] ------------------ 667| | /* 668| | * If the first non-whitespace char is different 669| | * from '<' we assume this is not XML. 670| | */ 671| 475| while (p < e && vct_islws(*p)) ------------------ | | 72| 467|#define vct_islws(x) vct_is(x, VCT_LWS) | | ------------------ | | | | 39| 467|#define VCT_LWS (VCT_CRLF | VCT_OWS) | | | | ------------------ | | | | | | 38| 467|#define VCT_CRLF (1<<1) | | | | ------------------ | | | | #define VCT_LWS (VCT_CRLF | VCT_OWS) | | | | ------------------ | | | | | | 37| 467|#define VCT_OWS (1<<0) | | | | ------------------ | | ------------------ | | | Branch (72:22): [True: 392, False: 75] | | ------------------ ------------------ | Branch (671:11): [True: 467, False: 8] ------------------ 672| 392| p++; 673| 83| vep_mark_verbatim(vep, p); 674| 83| if (p < e && *p == '<') { ------------------ | Branch (674:8): [True: 75, False: 8] | Branch (674:17): [True: 14, False: 61] ------------------ 675| 14| p++; 676| 14| vep->state = VEP_STARTTAG; 677| 69| } else if (p < e && *p == (char)0xeb) { ------------------ | Branch (677:15): [True: 61, False: 8] | Branch (677:24): [True: 1, False: 60] ------------------ 678| 1| VSLb(vep->vc->wrk->vsl, SLT_ESI_xmlerror, 679| 1| "WARN: No ESI processing, " 680| 1| "first char not '<' but BOM." 681| 1| " (See feature esi_remove_bom)" 682| 1| ); 683| 1| vep->state = VEP_NOTXML; 684| 68| } else if (p < e) { ------------------ | Branch (684:15): [True: 60, False: 8] ------------------ 685| 60| VSLb(vep->vc->wrk->vsl, SLT_ESI_xmlerror, 686| 60| "WARN: No ESI processing, " 687| 60| "first char not '<'." 688| 60| " (See feature esi_disable_xml_check)" 689| 60| ); 690| 60| vep->state = VEP_NOTXML; 691| 60| } 692| 835k| } else if (vep->state == VEP_NOTXML) { ------------------ | Branch (692:14): [True: 61, False: 835k] ------------------ 693| | /* 694| | * This is not recognized as XML, just skip thru 695| | * vfp_esi_end() will handle the rest 696| | */ 697| 61| p = e; 698| 61| vep_mark_verbatim(vep, p); 699| | 700| | /****************************************************** 701| | * SECTION B 702| | */ 703| | 704| 835k| } else if (vep->state == VEP_NOTMYTAG) { ------------------ | Branch (704:14): [True: 22.6k, False: 812k] ------------------ 705| 22.6k| if (vep->flags.esi_ignore_other_elements) { ------------------ | Branch (705:8): [True: 22.1k, False: 540] ------------------ 706| 22.1k| p++; 707| 22.1k| vep->state = VEP_NEXTTAG; 708| 22.1k| } else { 709| 540| vep->tag_i = 0; 710| 54.9k| while (p < e) { ------------------ | Branch (710:12): [True: 54.9k, False: 21] ------------------ 711| 54.9k| if (*p++ == '>') { ------------------ | Branch (711:10): [True: 519, False: 54.4k] ------------------ 712| 519| vep->state = VEP_NEXTTAG; 713| 519| break; 714| 519| } 715| 54.9k| } 716| 540| } 717| 22.6k| if (p == e && !vep->remove) ------------------ | Branch (717:8): [True: 58, False: 22.5k] | Branch (717:18): [True: 57, False: 1] ------------------ 718| 57| vep_mark_verbatim(vep, p); 719| 812k| } else if (vep->state == VEP_NEXTTAG) { ------------------ | Branch (719:14): [True: 133k, False: 678k] ------------------ 720| | /* 721| | * Hunt for start of next tag and keep an eye 722| | * out for end of EsiCmt if armed. 723| | */ 724| 133k| vep->emptytag = 0; 725| 133k| vep->attr = NULL; 726| 133k| vep->dostuff = NULL; 727| 14.4M| while (p < e && *p != '<') { ------------------ | Branch (727:11): [True: 14.4M, False: 317] | Branch (727:20): [True: 14.3M, False: 133k] ------------------ 728| 14.3M| if (vep->esicmt_p == NULL) { ------------------ | Branch (728:9): [True: 13.7M, False: 569k] ------------------ 729| 13.7M| p++; 730| 13.7M| continue; 731| 13.7M| } 732| 569k| if (*p != *vep->esicmt_p) { ------------------ | Branch (732:9): [True: 368k, False: 200k] ------------------ 733| 368k| p++; 734| 368k| vep->esicmt_p = vep->esicmt; 735| 368k| continue; 736| 368k| } 737| 200k| if (!vep->remove && vep->esicmt_p == vep->esicmt) ------------------ | Branch (737:9): [True: 198k, False: 1.30k] | Branch (737:25): [True: 68.2k, False: 130k] ------------------ 738| 68.2k| vep_mark_verbatim(vep, p); 739| 200k| p++; 740| 200k| if (*++vep->esicmt_p == '\0') { ------------------ | Branch (740:9): [True: 64.6k, False: 135k] ------------------ 741| 64.6k| vep->esi_found = 1; 742| 64.6k| vep->esicmt = NULL; 743| 64.6k| vep->esicmt_p = NULL; 744| | /* 745| | * The end of the esicmt 746| | * should not be emitted. 747| | * But the stuff before should 748| | */ 749| 64.6k| vep_mark_skip(vep, p); 750| 64.6k| } 751| 200k| } 752| 133k| if (p < e) { ------------------ | Branch (752:8): [True: 133k, False: 317] ------------------ 753| 133k| if (!vep->remove) ------------------ | Branch (753:9): [True: 126k, False: 6.87k] ------------------ 754| 126k| vep_mark_verbatim(vep, p); 755| 133k| assert(*p == '<'); ------------------ | | 65| 133k|#define assert(e) \ | | 66| 133k|do { \ | | 67| 133k| if (!(e)) { \ | | ------------------ | | | Branch (67:6): [True: 0, False: 133k] | | ------------------ | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | 69| 0| #e, VAS_ASSERT); \ | | 70| 0| } \ | | 71| 133k|} while (0) | | ------------------ | | | Branch (71:10): [Folded, False: 133k] | | ------------------ ------------------ 756| 133k| p++; 757| 133k| vep->state = VEP_STARTTAG; 758| 133k| } else if (vep->esicmt_p == vep->esicmt && !vep->remove) ------------------ | Branch (758:15): [True: 247, False: 70] | Branch (758:47): [True: 227, False: 20] ------------------ 759| 227| vep_mark_verbatim(vep, p); 760| | 761| | /****************************************************** 762| | * SECTION C 763| | */ 764| | 765| 678k| } else if (vep->state == VEP_STARTTAG) { ------------------ | Branch (765:14): [True: 133k, False: 545k] ------------------ 766| | /* Start of tag, set up match table */ 767| 133k| vep->endtag = 0; 768| 133k| vep->match = vep_match_starttag; 769| 133k| vep->state = VEP_MATCH; 770| 545k| } else if (vep->state == VEP_COMMENT) { ------------------ | Branch (770:14): [True: 1.53k, False: 543k] ------------------ 771| 1.53k| vep->esicmt_p = vep->esicmt = NULL; 772| 1.53k| vep->until_p = vep->until = "-->"; 773| 1.53k| vep->until_s = VEP_NEXTTAG; 774| 1.53k| vep->state = VEP_UNTIL; 775| 543k| } else if (vep->state == VEP_COMMENTESI) { ------------------ | Branch (775:14): [True: 65.8k, False: 478k] ------------------ 776| 65.8k| if (vep->remove) ------------------ | Branch (776:8): [True: 591, False: 65.2k] ------------------ 777| 591| vep_error(vep, 778| 591| "ESI 1.0 Nested "; 781| 65.8k| vep->state = VEP_NEXTTAG; 782| 65.8k| vep_mark_skip(vep, p); 783| 478k| } else if (vep->state == VEP_CDATA) { ------------------ | Branch (783:14): [True: 3.53k, False: 474k] ------------------ 784| | /* 785| | * Easy: just look for the end of CDATA 786| | */ 787| 3.53k| vep->until_p = vep->until = "]]>"; 788| 3.53k| vep->until_s = VEP_NEXTTAG; 789| 3.53k| vep->state = VEP_UNTIL; 790| 474k| } else if (vep->state == VEP_ESIENDTAG) { ------------------ | Branch (790:14): [True: 1.74k, False: 472k] ------------------ 791| 1.74k| vep->endtag = 1; 792| 1.74k| vep->state = VEP_ESITAG; 793| 472k| } else if (vep->state == VEP_ESITAG) { ------------------ | Branch (793:14): [True: 39.5k, False: 433k] ------------------ 794| 39.5k| vep->in_esi_tag = 1; 795| 39.5k| vep->esi_found = 1; 796| 39.5k| vep_mark_skip(vep, p); 797| 39.5k| vep->match = vep_match_esi; 798| 39.5k| vep->state = VEP_MATCH; 799| 433k| } else if (vep->state == VEP_ESIINCLUDE) { ------------------ | Branch (799:14): [True: 28.3k, False: 404k] ------------------ 800| 28.3k| if (vep->remove) { ------------------ | Branch (800:8): [True: 1.85k, False: 26.4k] ------------------ 801| 1.85k| vep_error(vep, 802| 1.85k| "ESI 1.0 element" 803| 1.85k| " nested in "); 804| 1.85k| vep->state = VEP_TAGERROR; 805| 26.4k| } else if (vep->endtag) { ------------------ | Branch (805:15): [True: 221, False: 26.2k] ------------------ 806| 221| vep_error(vep, 807| 221| "ESI 1.0 illegal end-tag"); 808| 221| vep->state = VEP_TAGERROR; 809| 26.2k| } else { 810| 26.2k| vep->dostuff = vep_do_include; 811| 26.2k| vep->state = VEP_INTAG; 812| 26.2k| vep->attr = vep_match_attr_include; 813| 26.2k| } 814| 404k| } else if (vep->state == VEP_ESIREMOVE) { ------------------ | Branch (814:14): [True: 3.67k, False: 401k] ------------------ 815| 3.67k| vep->dostuff = vep_do_remove; 816| 3.67k| vep->state = VEP_INTAG; 817| 401k| } else if (vep->state == VEP_ESICOMMENT) { ------------------ | Branch (817:14): [True: 1.76k, False: 399k] ------------------ 818| 1.76k| if (vep->remove) { ------------------ | Branch (818:8): [True: 602, False: 1.15k] ------------------ 819| 602| vep_error(vep, 820| 602| "ESI 1.0 element" 821| 602| " nested in "); 822| 602| vep->state = VEP_TAGERROR; 823| 1.15k| } else if (vep->endtag) { ------------------ | Branch (823:15): [True: 269, False: 890] ------------------ 824| 269| vep_error(vep, 825| 269| "ESI 1.0 illegal end-tag"); 826| 269| vep->state = VEP_TAGERROR; 827| 890| } else { 828| 890| vep->dostuff = vep_do_comment; 829| 890| vep->state = VEP_INTAG; 830| 890| } 831| 399k| } else if (vep->state == VEP_ESIBOGON) { ------------------ | Branch (831:14): [True: 5.83k, False: 393k] ------------------ 832| 5.83k| vep_error(vep, 833| 5.83k| "ESI 1.0 element"); 834| 5.83k| vep->state = VEP_TAGERROR; 835| | 836| | /****************************************************** 837| | * SECTION D 838| | */ 839| | 840| 393k| } else if (vep->state == VEP_INTAG) { ------------------ | Branch (840:14): [True: 57.0k, False: 336k] ------------------ 841| 57.0k| vep->tag_i = 0; 842| 62.7k| while (p < e && vct_islws(*p) && !vep->emptytag) { ------------------ | | 72| 125k|#define vct_islws(x) vct_is(x, VCT_LWS) | | ------------------ | | | | 39| 62.7k|#define VCT_LWS (VCT_CRLF | VCT_OWS) | | | | ------------------ | | | | | | 38| 62.7k|#define VCT_CRLF (1<<1) | | | | ------------------ | | | | #define VCT_LWS (VCT_CRLF | VCT_OWS) | | | | ------------------ | | | | | | 37| 62.7k|#define VCT_OWS (1<<0) | | | | ------------------ | | ------------------ | | | Branch (72:22): [True: 5.75k, False: 57.0k] | | ------------------ ------------------ | Branch (842:11): [True: 62.7k, False: 21] | Branch (842:37): [True: 5.75k, False: 0] ------------------ 843| 5.75k| p++; 844| 5.75k| vep->canattr = 1; 845| 5.75k| } 846| 57.0k| if (p < e && *p == '/' && !vep->emptytag) { ------------------ | Branch (846:8): [True: 57.0k, False: 21] | Branch (846:17): [True: 2.23k, False: 54.7k] | Branch (846:30): [True: 2.23k, False: 0] ------------------ 847| 2.23k| p++; 848| 2.23k| vep->emptytag = 1; 849| 2.23k| vep->canattr = 0; 850| 2.23k| } 851| 57.0k| if (p < e && *p == '>') { ------------------ | Branch (851:8): [True: 56.9k, False: 34] | Branch (851:17): [True: 23.5k, False: 33.4k] ------------------ 852| 23.5k| p++; 853| 23.5k| AN(vep->dostuff); ------------------ | | 84| 23.5k|#define AN(foo) do { assert((foo) != 0); } while (0) | | ------------------ | | | | 65| 23.5k|#define assert(e) \ | | | | 66| 23.5k|do { \ | | | | 67| 23.5k| if (!(e)) { \ | | | | ------------------ | | | | | Branch (67:6): [True: 0, False: 23.5k] | | | | ------------------ | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | 69| 0| #e, VAS_ASSERT); \ | | | | 70| 0| } \ | | | | 71| 23.5k|} while (0) | | | | ------------------ | | | | | Branch (71:10): [Folded, False: 23.5k] | | | | ------------------ | | ------------------ | | | Branch (84:52): [Folded, False: 23.5k] | | ------------------ ------------------ 854| 23.5k| vep_mark_skip(vep, p); 855| 23.5k| vep->dostuff(vep, DO_TAG); 856| 23.5k| vep->in_esi_tag = 0; 857| 23.5k| vep->state = VEP_NEXTTAG; 858| 33.4k| } else if (p < e && vep->emptytag) { ------------------ | Branch (858:15): [True: 33.4k, False: 34] | Branch (858:24): [True: 792, False: 32.6k] ------------------ 859| 792| vep_error(vep, 860| 792| "XML 1.0 '>' does not follow '/' in tag"); 861| 792| vep->state = VEP_TAGERROR; 862| 32.6k| } else if (p < e && vep->canattr && ------------------ | Branch (862:15): [True: 32.6k, False: 34] | Branch (862:24): [True: 31.3k, False: 1.26k] ------------------ 863| 31.3k| vct_isxmlnamestart(*p)) { ------------------ | | 85| 31.3k|#define vct_isxmlnamestart(x) vct_is(x, VCT_XMLNAMESTART) | | ------------------ | | | | 45| 31.3k|#define VCT_XMLNAMESTART (1<<7) | | ------------------ | | | Branch (85:31): [True: 30.5k, False: 807] | | ------------------ ------------------ 864| 30.5k| vep->state = VEP_ATTR; 865| 30.5k| } else if (p < e) { ------------------ | Branch (865:15): [True: 2.06k, False: 34] ------------------ 866| 2.06k| vep_error(vep, 867| 2.06k| "XML 1.0 Illegal attribute start char"); 868| 2.06k| vep->state = VEP_TAGERROR; 869| 2.06k| } 870| 336k| } else if (vep->state == VEP_TAGERROR) { ------------------ | Branch (870:14): [True: 15.8k, False: 320k] ------------------ 871| 5.87M| while (p < e && *p != '>') ------------------ | Branch (871:11): [True: 5.87M, False: 129] | Branch (871:20): [True: 5.85M, False: 15.6k] ------------------ 872| 5.85M| p++; 873| 15.8k| if (p < e) { ------------------ | Branch (873:8): [True: 15.6k, False: 129] ------------------ 874| 15.6k| p++; 875| 15.6k| vep_mark_skip(vep, p); 876| 15.6k| vep->in_esi_tag = 0; 877| 15.6k| vep->state = VEP_NEXTTAG; 878| 15.6k| if (vep->attr_vsb) ------------------ | Branch (878:9): [True: 1.22k, False: 14.4k] ------------------ 879| 1.22k| VSB_destroy(&vep->attr_vsb); 880| 15.6k| } 881| | 882| | /****************************************************** 883| | * SECTION E 884| | */ 885| | 886| 320k| } else if (vep->state == VEP_ATTR) { ------------------ | Branch (886:14): [True: 30.5k, False: 290k] ------------------ 887| 30.5k| AZ(vep->attr_delim); ------------------ | | 83| 30.5k|#define AZ(foo) do { assert((foo) == 0); } while (0) | | ------------------ | | | | 65| 30.5k|#define assert(e) \ | | | | 66| 30.5k|do { \ | | | | 67| 30.5k| if (!(e)) { \ | | | | ------------------ | | | | | Branch (67:6): [True: 0, False: 30.5k] | | | | ------------------ | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | 69| 0| #e, VAS_ASSERT); \ | | | | 70| 0| } \ | | | | 71| 30.5k|} while (0) | | | | ------------------ | | | | | Branch (71:10): [Folded, False: 30.5k] | | | | ------------------ | | ------------------ | | | Branch (83:52): [Folded, False: 30.5k] | | ------------------ ------------------ 888| 30.5k| if (vep->attr == NULL) { ------------------ | Branch (888:8): [True: 3.66k, False: 26.9k] ------------------ 889| 3.66k| p++; 890| 3.66k| AZ(vep->attr_vsb); ------------------ | | 83| 3.66k|#define AZ(foo) do { assert((foo) == 0); } while (0) | | ------------------ | | | | 65| 3.66k|#define assert(e) \ | | | | 66| 3.66k|do { \ | | | | 67| 3.66k| if (!(e)) { \ | | | | ------------------ | | | | | Branch (67:6): [True: 0, False: 3.66k] | | | | ------------------ | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | 69| 0| #e, VAS_ASSERT); \ | | | | 70| 0| } \ | | | | 71| 3.66k|} while (0) | | | | ------------------ | | | | | Branch (71:10): [Folded, False: 3.66k] | | | | ------------------ | | ------------------ | | | Branch (83:52): [Folded, False: 3.66k] | | ------------------ ------------------ 891| 3.66k| vep->state = VEP_SKIPATTR; 892| 26.9k| } else { 893| 26.9k| vep->match = vep->attr; 894| 26.9k| vep->state = VEP_MATCH; 895| 26.9k| } 896| 290k| } else if (vep->state == VEP_SKIPATTR) { ------------------ | Branch (896:14): [True: 7.18k, False: 282k] ------------------ 897| 23.5k| while (p < e && vct_isxmlname(*p)) ------------------ | | 86| 23.5k|#define vct_isxmlname(x) vct_is(x, VCT_XMLNAMESTART | VCT_XMLNAME) | | ------------------ | | | | 45| 23.5k|#define VCT_XMLNAMESTART (1<<7) | | ------------------ | | #define vct_isxmlname(x) vct_is(x, VCT_XMLNAMESTART | VCT_XMLNAME) | | ------------------ | | | | 46| 23.5k|#define VCT_XMLNAME (1<<8) | | ------------------ | | | Branch (86:26): [True: 16.3k, False: 7.17k] | | ------------------ ------------------ | Branch (897:11): [True: 23.5k, False: 14] ------------------ 898| 16.3k| p++; 899| 7.18k| if (p < e && *p == '=') { ------------------ | Branch (899:8): [True: 7.17k, False: 14] | Branch (899:17): [True: 3.75k, False: 3.42k] ------------------ 900| 3.75k| p++; 901| 3.75k| vep->state = VEP_ATTRDELIM; 902| 3.75k| } else if (p < e && *p == '>') { ------------------ | Branch (902:15): [True: 3.42k, False: 14] | Branch (902:24): [True: 693, False: 2.73k] ------------------ 903| 693| vep->state = VEP_INTAG; 904| 2.74k| } else if (p < e && *p == '/') { ------------------ | Branch (904:15): [True: 2.73k, False: 14] | Branch (904:24): [True: 855, False: 1.87k] ------------------ 905| 855| vep->state = VEP_INTAG; 906| 1.89k| } else if (p < e && vct_issp(*p)) { ------------------ | | 70| 1.87k|#define vct_issp(x) vct_is(x, VCT_OWS) | | ------------------ | | | | 37| 1.87k|#define VCT_OWS (1<<0) | | ------------------ | | | Branch (70:21): [True: 1.11k, False: 760] | | ------------------ ------------------ | Branch (906:15): [True: 1.87k, False: 14] ------------------ 907| 1.11k| vep->state = VEP_INTAG; 908| 1.11k| } else if (p < e) { ------------------ | Branch (908:15): [True: 760, False: 14] ------------------ 909| 760| vep_error(vep, 910| 760| "XML 1.0 Illegal attr char"); 911| 760| vep->state = VEP_TAGERROR; 912| 760| } 913| 282k| } else if (vep->state == VEP_ATTRGETVAL) { ------------------ | Branch (913:14): [True: 23.3k, False: 259k] ------------------ 914| 23.3k| AZ(vep->attr_vsb); ------------------ | | 83| 23.3k|#define AZ(foo) do { assert((foo) == 0); } while (0) | | ------------------ | | | | 65| 23.3k|#define assert(e) \ | | | | 66| 23.3k|do { \ | | | | 67| 23.3k| if (!(e)) { \ | | | | ------------------ | | | | | Branch (67:6): [True: 0, False: 23.3k] | | | | ------------------ | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | 69| 0| #e, VAS_ASSERT); \ | | | | 70| 0| } \ | | | | 71| 23.3k|} while (0) | | | | ------------------ | | | | | Branch (71:10): [Folded, False: 23.3k] | | | | ------------------ | | ------------------ | | | Branch (83:52): [Folded, False: 23.3k] | | ------------------ ------------------ 915| 23.3k| vep->attr_vsb = VSB_new_auto(); 916| 23.3k| vep->state = VEP_ATTRDELIM; 917| 259k| } else if (vep->state == VEP_ATTRDELIM) { ------------------ | Branch (917:14): [True: 27.1k, False: 232k] ------------------ 918| 27.1k| AZ(vep->attr_delim); ------------------ | | 83| 27.1k|#define AZ(foo) do { assert((foo) == 0); } while (0) | | ------------------ | | | | 65| 27.1k|#define assert(e) \ | | | | 66| 27.1k|do { \ | | | | 67| 27.1k| if (!(e)) { \ | | | | ------------------ | | | | | Branch (67:6): [True: 0, False: 27.1k] | | | | ------------------ | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | 69| 0| #e, VAS_ASSERT); \ | | | | 70| 0| } \ | | | | 71| 27.1k|} while (0) | | | | ------------------ | | | | | Branch (71:10): [Folded, False: 27.1k] | | | | ------------------ | | ------------------ | | | Branch (83:52): [Folded, False: 27.1k] | | ------------------ ------------------ 919| 27.1k| if (*p == '"' || *p == '\'') { ------------------ | Branch (919:8): [True: 690, False: 26.4k] | Branch (919:21): [True: 490, False: 25.9k] ------------------ 920| 1.18k| vep->attr_delim = *p++; 921| 1.18k| vep->state = VEP_ATTRVAL; 922| 25.9k| } else if (!vct_issp(*p)) { ------------------ | | 70| 25.9k|#define vct_issp(x) vct_is(x, VCT_OWS) | | ------------------ | | | | 37| 25.9k|#define VCT_OWS (1<<0) | | ------------------ ------------------ | Branch (922:15): [True: 24.5k, False: 1.42k] ------------------ 923| 24.5k| vep->attr_delim = ' '; 924| 24.5k| vep->state = VEP_ATTRVAL; 925| 24.5k| } else { 926| 1.42k| vep_error(vep, 927| 1.42k| "XML 1.0 Illegal attribute delimiter"); 928| 1.42k| vep->state = VEP_TAGERROR; 929| 1.42k| } 930| | 931| 232k| } else if (vep->state == VEP_ATTRVAL) { ------------------ | Branch (931:14): [True: 25.6k, False: 206k] ------------------ 932| 16.9M| while (p < e && *p != '>' && *p != vep->attr_delim && ------------------ | Branch (932:11): [True: 16.9M, False: 86] | Branch (932:20): [True: 16.9M, False: 855] | Branch (932:33): [True: 16.9M, False: 24.5k] ------------------ 933| 16.9M| (vep->attr_delim != ' ' || !vct_issp(*p))) { ------------------ | | 70| 16.9M|#define vct_issp(x) vct_is(x, VCT_OWS) | | ------------------ | | | | 37| 16.9M|#define VCT_OWS (1<<0) | | ------------------ ------------------ | Branch (933:8): [True: 1.46k, False: 16.9M] | Branch (933:34): [True: 16.9M, False: 204] ------------------ 934| 16.9M| if (vep->attr_vsb != NULL) ------------------ | Branch (934:9): [True: 16.9M, False: 21.6k] ------------------ 935| 16.9M| VSB_putc(vep->attr_vsb, *p); 936| 16.9M| p++; 937| 16.9M| } 938| 25.6k| if (p < e && *p == '>') { ------------------ | Branch (938:8): [True: 25.5k, False: 86] | Branch (938:17): [True: 855, False: 24.7k] ------------------ 939| 855| vep_error(vep, 940| 855| "XML 1.0 Missing end attribute delimiter"); 941| 855| vep->state = VEP_TAGERROR; 942| 855| vep->attr_delim = 0; 943| 855| if (vep->attr_vsb != NULL) { ------------------ | Branch (943:9): [True: 585, False: 270] ------------------ 944| 585| AZ(VSB_finish(vep->attr_vsb)); ------------------ | | 83| 585|#define AZ(foo) do { assert((foo) == 0); } while (0) | | ------------------ | | | | 65| 585|#define assert(e) \ | | | | 66| 585|do { \ | | | | 67| 585| if (!(e)) { \ | | | | ------------------ | | | | | Branch (67:6): [True: 0, False: 585] | | | | ------------------ | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | 69| 0| #e, VAS_ASSERT); \ | | | | 70| 0| } \ | | | | 71| 585|} while (0) | | | | ------------------ | | | | | Branch (71:10): [Folded, False: 585] | | | | ------------------ | | ------------------ | | | Branch (83:52): [Folded, False: 585] | | ------------------ ------------------ 945| 585| VSB_destroy(&vep->attr_vsb); 946| 585| } 947| 24.8k| } else if (p < e) { ------------------ | Branch (947:15): [True: 24.7k, False: 86] ------------------ 948| 24.7k| vep->attr_delim = 0; 949| 24.7k| p++; 950| 24.7k| vep->state = VEP_INTAG; 951| 24.7k| if (vep->attr_vsb != NULL) { ------------------ | Branch (951:9): [True: 21.5k, False: 3.21k] ------------------ 952| 21.5k| AZ(VSB_finish(vep->attr_vsb)); ------------------ | | 83| 21.5k|#define AZ(foo) do { assert((foo) == 0); } while (0) | | ------------------ | | | | 65| 21.5k|#define assert(e) \ | | | | 66| 21.5k|do { \ | | | | 67| 21.5k| if (!(e)) { \ | | | | ------------------ | | | | | Branch (67:6): [True: 0, False: 21.5k] | | | | ------------------ | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | 69| 0| #e, VAS_ASSERT); \ | | | | 70| 0| } \ | | | | 71| 21.5k|} while (0) | | | | ------------------ | | | | | Branch (71:10): [Folded, False: 21.5k] | | | | ------------------ | | ------------------ | | | Branch (83:52): [Folded, False: 21.5k] | | ------------------ ------------------ 953| 21.5k| AN(vep->dostuff); ------------------ | | 84| 21.5k|#define AN(foo) do { assert((foo) != 0); } while (0) | | ------------------ | | | | 65| 21.5k|#define assert(e) \ | | | | 66| 21.5k|do { \ | | | | 67| 21.5k| if (!(e)) { \ | | | | ------------------ | | | | | Branch (67:6): [True: 0, False: 21.5k] | | | | ------------------ | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | 69| 0| #e, VAS_ASSERT); \ | | | | 70| 0| } \ | | | | 71| 21.5k|} while (0) | | | | ------------------ | | | | | Branch (71:10): [Folded, False: 21.5k] | | | | ------------------ | | ------------------ | | | Branch (84:52): [Folded, False: 21.5k] | | ------------------ ------------------ 954| 21.5k| vep->dostuff(vep, DO_ATTR); 955| 21.5k| vep->attr_vsb = NULL; 956| 21.5k| } 957| 24.7k| } 958| | 959| | /****************************************************** 960| | * Utility Section 961| | */ 962| | 963| 206k| } else if (vep->state == VEP_MATCH) { ------------------ | Branch (963:14): [True: 201k, False: 5.06k] ------------------ 964| | /* 965| | * Match against a table 966| | */ 967| 201k| vm = vep_match(vep, p, e); 968| 201k| vep->match_hit = vm; 969| 201k| if (vm != NULL) { ------------------ | Branch (969:8): [True: 201k, False: 44] ------------------ 970| 201k| if (vm->match != NULL) ------------------ | Branch (970:9): [True: 169k, False: 32.0k] ------------------ 971| 169k| p += vstrlen(vm->match); ------------------ | | 342| 169k|# define vstrlen(s) __builtin_strlen(s) ------------------ 972| 201k| vep->state = *vm->state; 973| 201k| vep->match = NULL; 974| 201k| vep->tag_i = 0; 975| 201k| } else { 976| 44| assert(p + sizeof(vep->tag) >= e); ------------------ | | 65| 44|#define assert(e) \ | | 66| 44|do { \ | | 67| 44| if (!(e)) { \ | | ------------------ | | | Branch (67:6): [True: 0, False: 44] | | ------------------ | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | 69| 0| #e, VAS_ASSERT); \ | | 70| 0| } \ | | 71| 44|} while (0) | | ------------------ | | | Branch (71:10): [Folded, False: 44] | | ------------------ ------------------ 977| 44| memcpy(vep->tag, p, e - p); 978| 44| vep->tag_i = e - p; 979| 44| vep->state = VEP_MATCHBUF; 980| 44| p = e; 981| 44| } 982| 201k| } else if (vep->state == VEP_MATCHBUF) { ------------------ | Branch (982:14): [True: 0, False: 5.06k] ------------------ 983| | /* 984| | * Match against a table while split over input 985| | * sections. 986| | */ 987| 0| AN(vep->match); ------------------ | | 84| 0|#define AN(foo) do { assert((foo) != 0); } while (0) | | ------------------ | | | | 65| 0|#define assert(e) \ | | | | 66| 0|do { \ | | | | 67| 0| if (!(e)) { \ | | | | ------------------ | | | | | Branch (67:6): [True: 0, False: 0] | | | | ------------------ | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | 69| 0| #e, VAS_ASSERT); \ | | | | 70| 0| } \ | | | | 71| 0|} while (0) | | | | ------------------ | | | | | Branch (71:10): [Folded, False: 0] | | | | ------------------ | | ------------------ | | | Branch (84:52): [Folded, False: 0] | | ------------------ ------------------ 988| 0| i = sizeof(vep->tag) - vep->tag_i; 989| 0| if (i > e - p) ------------------ | Branch (989:8): [True: 0, False: 0] ------------------ 990| 0| i = e - p; 991| 0| memcpy(vep->tag + vep->tag_i, p, i); 992| 0| vm = vep_match(vep, vep->tag, 993| 0| vep->tag + vep->tag_i + i); 994| 0| Debug("MB (%.*s) tag_i %d i %d = vm %p match %s\n", 995| 0| vep->tag_i + i, vep->tag, 996| 0| vep->tag_i, 997| 0| i, 998| 0| vm, 999| 0| vm ? vm->match : "(nil)"); 1000| | 1001| 0| if (vm == NULL) { ------------------ | Branch (1001:8): [True: 0, False: 0] ------------------ 1002| 0| vep->tag_i += i; 1003| 0| p += i; 1004| 0| assert(p == e); ------------------ | | 65| 0|#define assert(e) \ | | 66| 0|do { \ | | 67| 0| if (!(e)) { \ | | ------------------ | | | Branch (67:6): [True: 0, False: 0] | | ------------------ | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | 69| 0| #e, VAS_ASSERT); \ | | 70| 0| } \ | | 71| 0|} while (0) | | ------------------ | | | Branch (71:10): [Folded, False: 0] | | ------------------ ------------------ 1005| 0| } else { 1006| 0| vep->match_hit = vm; 1007| 0| vep->state = *vm->state; 1008| 0| if (vm->match != NULL) { ------------------ | Branch (1008:9): [True: 0, False: 0] ------------------ 1009| 0| i = vstrlen(vm->match); ------------------ | | 342| 0|# define vstrlen(s) __builtin_strlen(s) ------------------ 1010| 0| if (i > vep->tag_i) ------------------ | Branch (1010:10): [True: 0, False: 0] ------------------ 1011| 0| p += i - vep->tag_i; 1012| 0| } 1013| 0| vep->match = NULL; 1014| 0| vep->tag_i = 0; 1015| 0| } 1016| 5.06k| } else if (vep->state == VEP_UNTIL) { ------------------ | Branch (1016:14): [True: 5.06k, False: 0] ------------------ 1017| | /* 1018| | * Skip until we see magic string 1019| | */ 1020| 8.80M| while (p < e) { ------------------ | Branch (1020:11): [True: 8.80M, False: 71] ------------------ 1021| 8.80M| if (*p++ != *vep->until_p++) { ------------------ | Branch (1021:9): [True: 8.77M, False: 24.7k] ------------------ 1022| 8.77M| vep->until_p = vep->until; 1023| 8.77M| } else if (*vep->until_p == '\0') { ------------------ | Branch (1023:16): [True: 4.99k, False: 19.7k] ------------------ 1024| 4.99k| vep->state = vep->until_s; 1025| 4.99k| break; 1026| 4.99k| } 1027| 8.80M| } 1028| 5.06k| if (p == e && !vep->remove) ------------------ | Branch (1028:8): [True: 80, False: 4.98k] | Branch (1028:18): [True: 72, False: 8] ------------------ 1029| 72| vep_mark_verbatim(vep, p); 1030| 5.06k| } else { 1031| 0| Debug("*** Unknown state %s\n", vep->state); 1032| 0| WRONG("WRONG ESI PARSER STATE"); ------------------ | | 88| 0|#define WRONG(expl) \ | | 89| 0|do { \ | | 90| 0| VAS_Fail(__func__, __FILE__, __LINE__, expl, VAS_WRONG); \ | | 91| 0|} while (0) | | ------------------ | | | Branch (91:10): [Folded, False: 0] | | ------------------ ------------------ 1033| 0| } 1034| 840k| } 1035| | /* 1036| | * We must always mark up the storage we got, try to do so 1037| | * in the most efficient way, in particular with respect to 1038| | * minimizing and limiting use of pending. 1039| | */ 1040| 1.59k| if (p == vep->ver_p) ------------------ | Branch (1040:6): [True: 998, False: 596] ------------------ 1041| 998| ; 1042| 596| else if (vep->in_esi_tag) ------------------ | Branch (1042:11): [True: 353, False: 243] ------------------ 1043| 353| vep_mark_skip(vep, p); 1044| 243| else if (vep->remove) ------------------ | Branch (1044:11): [True: 37, False: 206] ------------------ 1045| 37| vep_mark_skip(vep, p); 1046| 206| else 1047| 206| vep_mark_pending(vep, p); 1048| 1.59k|} VEP_Init: 1072| 1.59k|{ 1073| 1.59k| struct vep_state *vep; 1074| | 1075| 1.59k| CHECK_OBJ_NOTNULL(vc, VFP_CTX_MAGIC); ------------------ | | 66| 1.59k| do { \ | | 67| 1.59k| assert((ptr) != NULL); \ | | ------------------ | | | | 65| 1.59k|#define assert(e) \ | | | | 66| 1.59k|do { \ | | | | 67| 1.59k| if (!(e)) { \ | | | | ------------------ | | | | | Branch (67:6): [True: 0, False: 1.59k] | | | | ------------------ | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | 69| 0| #e, VAS_ASSERT); \ | | | | 70| 0| } \ | | | | 71| 1.59k|} while (0) | | | | ------------------ | | | | | Branch (71:10): [Folded, False: 1.59k] | | | | ------------------ | | ------------------ | | 68| 1.59k| assert((ptr)->magic == type_magic); \ | | ------------------ | | | | 65| 1.59k|#define assert(e) \ | | | | 66| 1.59k|do { \ | | | | 67| 1.59k| if (!(e)) { \ | | | | ------------------ | | | | | Branch (67:6): [True: 0, False: 1.59k] | | | | ------------------ | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | 69| 0| #e, VAS_ASSERT); \ | | | | 70| 0| } \ | | | | 71| 1.59k|} while (0) | | | | ------------------ | | | | | Branch (71:10): [Folded, False: 1.59k] | | | | ------------------ | | ------------------ | | 69| 1.59k| } while (0) | | ------------------ | | | Branch (69:11): [Folded, False: 1.59k] | | ------------------ ------------------ 1076| 1.59k| CHECK_OBJ_NOTNULL(req, HTTP_MAGIC); ------------------ | | 66| 1.59k| do { \ | | 67| 1.59k| assert((ptr) != NULL); \ | | ------------------ | | | | 65| 1.59k|#define assert(e) \ | | | | 66| 1.59k|do { \ | | | | 67| 1.59k| if (!(e)) { \ | | | | ------------------ | | | | | Branch (67:6): [True: 0, False: 1.59k] | | | | ------------------ | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | 69| 0| #e, VAS_ASSERT); \ | | | | 70| 0| } \ | | | | 71| 1.59k|} while (0) | | | | ------------------ | | | | | Branch (71:10): [Folded, False: 1.59k] | | | | ------------------ | | ------------------ | | 68| 1.59k| assert((ptr)->magic == type_magic); \ | | ------------------ | | | | 65| 1.59k|#define assert(e) \ | | | | 66| 1.59k|do { \ | | | | 67| 1.59k| if (!(e)) { \ | | | | ------------------ | | | | | Branch (67:6): [True: 0, False: 1.59k] | | | | ------------------ | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | 69| 0| #e, VAS_ASSERT); \ | | | | 70| 0| } \ | | | | 71| 1.59k|} while (0) | | | | ------------------ | | | | | Branch (71:10): [Folded, False: 1.59k] | | | | ------------------ | | ------------------ | | 69| 1.59k| } while (0) | | ------------------ | | | Branch (69:11): [Folded, False: 1.59k] | | ------------------ ------------------ 1077| 1.59k| vep = WS_Alloc(vc->resp->ws, sizeof *vep); 1078| 1.59k| if (vep == NULL) { ------------------ | Branch (1078:6): [True: 0, False: 1.59k] ------------------ 1079| 0| VSLb(vc->wrk->vsl, SLT_VCL_Error, 1080| 0| "VEP_Init() workspace overflow"); 1081| 0| return (NULL); 1082| 0| } 1083| | 1084| 1.59k| INIT_OBJ(vep, VEP_MAGIC); ------------------ | | 15| 1.59k| do { \ | | 16| 1.59k| (void)memset(to, 0, sizeof *(to)); \ | | 17| 1.59k| (to)->magic = (type_magic); \ | | 18| 1.59k| } while (0) | | ------------------ | | | Branch (18:11): [Folded, False: 1.59k] | | ------------------ ------------------ 1085| 1.59k| vep->flags = flags; 1086| 1.59k| vep->url = req->hd[HTTP_HDR_URL].b; 1087| 1.59k| vep->vc = vc; 1088| 1.59k| vep->vsb = VSB_new_auto(); 1089| 1.59k| AN(vep->vsb); ------------------ | | 84| 1.59k|#define AN(foo) do { assert((foo) != 0); } while (0) | | ------------------ | | | | 65| 1.59k|#define assert(e) \ | | | | 66| 1.59k|do { \ | | | | 67| 1.59k| if (!(e)) { \ | | | | ------------------ | | | | | Branch (67:6): [True: 0, False: 1.59k] | | | | ------------------ | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | 69| 0| #e, VAS_ASSERT); \ | | | | 70| 0| } \ | | | | 71| 1.59k|} while (0) | | | | ------------------ | | | | | Branch (71:10): [Folded, False: 1.59k] | | | | ------------------ | | ------------------ | | | Branch (84:52): [Folded, False: 1.59k] | | ------------------ ------------------ 1090| | 1091| 1.59k| if (cb != NULL) { ------------------ | Branch (1091:6): [True: 0, False: 1.59k] ------------------ 1092| 0| vep->dogzip = 1; 1093| | /* XXX */ 1094| 0| VSB_printf(vep->vsb, "%c", VEC_GZ); ------------------ | | 32| 0|#define VEC_GZ (0x21) ------------------ 1095| 0| vep->cb = cb; 1096| 0| vep->cb_priv = cb_priv; 1097| 1.59k| } else { 1098| 1.59k| vep->cb = vep_default_cb; 1099| 1.59k| vep->cb_priv = &vep->cb_x; 1100| 1.59k| } 1101| | 1102| 1.59k| vep->state = VEP_START; 1103| 1.59k| vep->crc = crc32(0L, Z_NULL, 0); ------------------ | | 38| 1.59k|# define crc32 z_crc32 ------------------ vep->crc = crc32(0L, Z_NULL, 0); ------------------ | | 217| 1.59k|#define Z_NULL 0 /* for initializing zalloc, zfree, opaque */ ------------------ 1104| 1.59k| vep->crcp = crc32(0L, Z_NULL, 0); ------------------ | | 38| 1.59k|# define crc32 z_crc32 ------------------ vep->crcp = crc32(0L, Z_NULL, 0); ------------------ | | 217| 1.59k|#define Z_NULL 0 /* for initializing zalloc, zfree, opaque */ ------------------ 1105| | 1106| 1.59k| vep->startup = 1; 1107| 1.59k| return (vep); 1108| 1.59k|} VEP_Finish: 1115| 1.59k|{ 1116| 1.59k| ssize_t l, lcb; 1117| | 1118| 1.59k| CHECK_OBJ_NOTNULL(vep, VEP_MAGIC); ------------------ | | 66| 1.59k| do { \ | | 67| 1.59k| assert((ptr) != NULL); \ | | ------------------ | | | | 65| 1.59k|#define assert(e) \ | | | | 66| 1.59k|do { \ | | | | 67| 1.59k| if (!(e)) { \ | | | | ------------------ | | | | | Branch (67:6): [True: 0, False: 1.59k] | | | | ------------------ | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | 69| 0| #e, VAS_ASSERT); \ | | | | 70| 0| } \ | | | | 71| 1.59k|} while (0) | | | | ------------------ | | | | | Branch (71:10): [Folded, False: 1.59k] | | | | ------------------ | | ------------------ | | 68| 1.59k| assert((ptr)->magic == type_magic); \ | | ------------------ | | | | 65| 1.59k|#define assert(e) \ | | | | 66| 1.59k|do { \ | | | | 67| 1.59k| if (!(e)) { \ | | | | ------------------ | | | | | Branch (67:6): [True: 0, False: 1.59k] | | | | ------------------ | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | 69| 0| #e, VAS_ASSERT); \ | | | | 70| 0| } \ | | | | 71| 1.59k|} while (0) | | | | ------------------ | | | | | Branch (71:10): [Folded, False: 1.59k] | | | | ------------------ | | ------------------ | | 69| 1.59k| } while (0) | | ------------------ | | | Branch (69:11): [Folded, False: 1.59k] | | ------------------ ------------------ 1119| | 1120| 1.59k| if (vep->include_src) ------------------ | Branch (1120:6): [True: 49, False: 1.54k] ------------------ 1121| 49| VSB_destroy(&vep->include_src); 1122| 1.59k| if (vep->attr_vsb) ------------------ | Branch (1122:6): [True: 42, False: 1.55k] ------------------ 1123| 42| VSB_destroy(&vep->attr_vsb); 1124| | 1125| 1.59k| if (vep->state != VEP_START && ------------------ | Branch (1125:6): [True: 1.58k, False: 11] ------------------ 1126| 1.58k| vep->state != VEP_BOM && ------------------ | Branch (1126:6): [True: 1.58k, False: 0] ------------------ 1127| 1.58k| vep->state != VEP_TESTXML && ------------------ | Branch (1127:6): [True: 1.57k, False: 8] ------------------ 1128| 1.57k| vep->state != VEP_NOTXML && ------------------ | Branch (1128:6): [True: 1.51k, False: 61] ------------------ 1129| 1.51k| vep->state != VEP_NEXTTAG) { ------------------ | Branch (1129:6): [True: 584, False: 930] ------------------ 1130| 584| vep_error(vep, "VEP ended inside a tag"); 1131| 584| } 1132| | 1133| 1.59k| if (vep->o_pending) ------------------ | Branch (1133:6): [True: 206, False: 1.38k] ------------------ 1134| 206| vep_mark_common(vep, vep->ver_p, vep->last_mark); 1135| 1.59k| if (vep->o_wait > 0) { ------------------ | Branch (1135:6): [True: 1.56k, False: 30] ------------------ 1136| 1.56k| lcb = vep->cb(vep->vc, vep->cb_priv, 0, VGZ_ALIGN); 1137| 1.56k| vep_emit_common(vep, lcb - vep->o_last, vep->last_mark); 1138| 1.56k| } 1139| | // NB: We don't account for PAD+SUM+LEN in gzipped objects 1140| 1.59k| (void)vep->cb(vep->vc, vep->cb_priv, 0, VGZ_FINISH); 1141| | 1142| 1.59k| AZ(VSB_finish(vep->vsb)); ------------------ | | 83| 1.59k|#define AZ(foo) do { assert((foo) == 0); } while (0) | | ------------------ | | | | 65| 1.59k|#define assert(e) \ | | | | 66| 1.59k|do { \ | | | | 67| 1.59k| if (!(e)) { \ | | | | ------------------ | | | | | Branch (67:6): [True: 0, False: 1.59k] | | | | ------------------ | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | 69| 0| #e, VAS_ASSERT); \ | | | | 70| 0| } \ | | | | 71| 1.59k|} while (0) | | | | ------------------ | | | | | Branch (71:10): [Folded, False: 1.59k] | | | | ------------------ | | ------------------ | | | Branch (83:52): [Folded, False: 1.59k] | | ------------------ ------------------ 1143| 1.59k| l = VSB_len(vep->vsb); 1144| 1.59k| if (vep->esi_found && l > 0) ------------------ | Branch (1144:6): [True: 1.10k, False: 486] | Branch (1144:24): [True: 1.10k, False: 0] ------------------ 1145| 1.10k| return (vep->vsb); 1146| 486| VSB_destroy(&vep->vsb); 1147| | return (NULL); 1148| 1.59k|} cache_esi_parse.c:vep_mark_common: 320| 408k|{ 321| 408k| ssize_t l, lcb; 322| | 323| 408k| assert(mark == SKIP || mark == VERBATIM); ------------------ | | 65| 408k|#define assert(e) \ | | 66| 408k|do { \ | | 67| 605k| if (!(e)) { \ | | ------------------ | | | Branch (67:8): [True: 211k, False: 197k] | | | Branch (67:8): [True: 197k, False: 0] | | ------------------ | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | 69| 0| #e, VAS_ASSERT); \ | | 70| 0| } \ | | 71| 408k|} while (0) | | ------------------ | | | Branch (71:10): [Folded, False: 408k] | | ------------------ ------------------ 324| | 325| | /* The NO-OP case, no data, no pending data & no change of mode */ 326| 408k| if (vep->last_mark == mark && p == vep->ver_p && vep->o_pending == 0) ------------------ | Branch (326:6): [True: 74.3k, False: 334k] | Branch (326:32): [True: 206, False: 74.1k] | Branch (326:51): [True: 0, False: 206] ------------------ 327| 0| return; 328| | 329| | /* 330| | * If we changed mode, emit whatever the opposite mode 331| | * assembled before the pending bytes. 332| | */ 333| | 334| 408k| if (vep->last_mark != mark && (vep->o_wait > 0 || vep->startup)) { ------------------ | Branch (334:6): [True: 334k, False: 74.3k] | Branch (334:33): [True: 297k, False: 36.7k] | Branch (334:52): [True: 1.59k, False: 35.1k] ------------------ 335| 298k| lcb = vep->cb(vep->vc, vep->cb_priv, 0, 336| 298k| mark == VERBATIM ? VGZ_RESET : VGZ_ALIGN); ------------------ | Branch (336:7): [True: 165k, False: 133k] ------------------ 337| 298k| vep_emit_common(vep, lcb - vep->o_last, vep->last_mark); 338| 298k| vep->o_last = lcb; 339| 298k| vep->o_wait = 0; 340| 298k| } 341| | 342| | /* Transfer pending bytes CRC into active mode CRC */ 343| 408k| if (vep->o_pending) { ------------------ | Branch (343:6): [True: 206, False: 408k] ------------------ 344| 206| (void)vep->cb(vep->vc, vep->cb_priv, vep->o_pending, 345| 206| VGZ_NORMAL); 346| 206| if (vep->o_crc == 0) { ------------------ | Branch (346:7): [True: 59, False: 147] ------------------ 347| 59| vep->crc = vep->crcp; 348| 59| vep->o_crc = vep->o_pending; 349| 147| } else { 350| 147| vep->crc = crc32_combine(vep->crc, ------------------ | | 39| 147|# define crc32_combine z_crc32_combine ------------------ 351| 147| vep->crcp, vep->o_pending); 352| 147| vep->o_crc += vep->o_pending; 353| 147| } 354| 206| vep->crcp = crc32(0L, Z_NULL, 0); ------------------ | | 38| 206|# define crc32 z_crc32 ------------------ vep->crcp = crc32(0L, Z_NULL, 0); ------------------ | | 217| 206|#define Z_NULL 0 /* for initializing zalloc, zfree, opaque */ ------------------ 355| 206| vep->o_wait += vep->o_pending; 356| 206| vep->o_pending = 0; 357| 206| } 358| | 359| | /* * Process this bit of input */ 360| 408k| AN(vep->ver_p); ------------------ | | 84| 408k|#define AN(foo) do { assert((foo) != 0); } while (0) | | ------------------ | | | | 65| 408k|#define assert(e) \ | | | | 66| 408k|do { \ | | | | 67| 408k| if (!(e)) { \ | | | | ------------------ | | | | | Branch (67:6): [True: 0, False: 408k] | | | | ------------------ | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | 69| 0| #e, VAS_ASSERT); \ | | | | 70| 0| } \ | | | | 71| 408k|} while (0) | | | | ------------------ | | | | | Branch (71:10): [Folded, False: 408k] | | | | ------------------ | | ------------------ | | | Branch (84:52): [Folded, False: 408k] | | ------------------ ------------------ 361| 408k| l = p - vep->ver_p; 362| 408k| assert(l >= 0); ------------------ | | 65| 408k|#define assert(e) \ | | 66| 408k|do { \ | | 67| 408k| if (!(e)) { \ | | ------------------ | | | Branch (67:6): [True: 0, False: 408k] | | ------------------ | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | 69| 0| #e, VAS_ASSERT); \ | | 70| 0| } \ | | 71| 408k|} while (0) | | ------------------ | | | Branch (71:10): [Folded, False: 408k] | | ------------------ ------------------ 363| 408k| vep->crc = crc32(vep->crc, (const void*)vep->ver_p, l); ------------------ | | 38| 408k|# define crc32 z_crc32 ------------------ 364| 408k| vep->o_crc += l; 365| 408k| vep->ver_p = p; 366| | 367| 408k| vep->o_wait += l; 368| 408k| vep->last_mark = mark; 369| 408k| (void)vep->cb(vep->vc, vep->cb_priv, l, VGZ_NORMAL); 370| 408k|} cache_esi_parse.c:vep_mark_skip: 382| 211k|{ 383| | 384| 211k| vep_mark_common(vep, p, SKIP); 385| 211k| vep->nm_skip++; 386| 211k|} cache_esi_parse.c:vep_mark_verbatim: 374| 195k|{ 375| | 376| 195k| vep_mark_common(vep, p, VERBATIM); 377| 195k| vep->nm_verbatim++; 378| 195k|} cache_esi_parse.c:vep_error: 205| 21.1k|{ 206| 21.1k| VSC_C_main->esi_errors++; 207| 21.1k| VSLb(vep->vc->wrk->vsl, SLT_ESI_xmlerror, "ERR: after %zd %s", 208| 21.1k| vep->o_last, p); 209| 21.1k|} cache_esi_parse.c:vep_do_include: 478| 41.8k|{ 479| 41.8k| const char *p, *q, *h; 480| 41.8k| ssize_t l; 481| 41.8k| char incl; 482| | 483| 41.8k| Debug("DO_INCLUDE(%d)\n", what); 484| 41.8k| if (what == DO_ATTR) { ------------------ | Branch (484:6): [True: 21.5k, False: 20.3k] ------------------ 485| 21.5k| Debug("ATTR (%s) (%s)\n", vep->match_hit->match, 486| 21.5k| VSB_data(vep->attr_vsb)); 487| 21.5k| if (!vstrcmp("src=", vep->match_hit->match)) { ------------------ | | 336| 21.5k|# define vstrcmp(s1, s2) __builtin_strcmp(s1, s2) ------------------ | Branch (487:7): [True: 21.5k, False: 0] ------------------ 488| 21.5k| include_attr_src(vep); 489| 21.5k| return; 490| 21.5k| } 491| 0| if (!vstrcmp("onerror=", vep->match_hit->match)) { ------------------ | | 336| 0|# define vstrcmp(s1, s2) __builtin_strcmp(s1, s2) ------------------ | Branch (491:7): [True: 0, False: 0] ------------------ 492| 0| include_attr_onerror(vep); 493| 0| return; 494| 0| } 495| 0| WRONG("Unhandled attribute"); ------------------ | | 88| 0|#define WRONG(expl) \ | | 89| 0|do { \ | | 90| 0| VAS_Fail(__func__, __FILE__, __LINE__, expl, VAS_WRONG); \ | | 91| 0|} while (0) | | ------------------ | | | Branch (91:10): [Folded, False: 0] | | ------------------ ------------------ 496| 0| } 497| 20.3k| assert(what == DO_TAG); ------------------ | | 65| 20.3k|#define assert(e) \ | | 66| 20.3k|do { \ | | 67| 20.3k| if (!(e)) { \ | | ------------------ | | | Branch (67:6): [True: 0, False: 20.3k] | | ------------------ | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | 69| 0| #e, VAS_ASSERT); \ | | 70| 0| } \ | | 71| 20.3k|} while (0) | | ------------------ | | | Branch (71:10): [Folded, False: 20.3k] | | ------------------ ------------------ 498| 20.3k| if (!vep->emptytag) ------------------ | Branch (498:6): [True: 20.0k, False: 314] ------------------ 499| 20.0k| vep_warn(vep, "ESI 1.0 lacks final '/'"); 500| 20.3k| if (vep->include_src == NULL) { ------------------ | Branch (500:6): [True: 917, False: 19.4k] ------------------ 501| 917| vep_error(vep, "ESI 1.0 lacks src attr"); 502| 917| return; 503| 917| } 504| | 505| | /* 506| | * Strictly speaking, we ought to spit out any piled up skip before 507| | * emitting the VEC for the include, but objectively that makes no 508| | * difference and robs us of a chance to collapse another skip into 509| | * this on so we don't do that. 510| | * However, we cannot tolerate any verbatim stuff piling up. 511| | * The mark_skip() before calling dostuff should have taken 512| | * care of that. Make sure. 513| | */ 514| 19.4k| assert(vep->o_wait == 0 || vep->last_mark == SKIP); ------------------ | | 65| 19.4k|#define assert(e) \ | | 66| 19.4k|do { \ | | 67| 38.9k| if (!(e)) { \ | | ------------------ | | | Branch (67:8): [True: 0, False: 19.4k] | | | Branch (67:8): [True: 19.4k, False: 0] | | ------------------ | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | 69| 0| #e, VAS_ASSERT); \ | | 70| 0| } \ | | 71| 19.4k|} while (0) | | ------------------ | | | Branch (71:10): [Folded, False: 19.4k] | | ------------------ ------------------ 515| | /* XXX: what if it contains NUL bytes ?? */ 516| 19.4k| p = VSB_data(vep->include_src); 517| 19.4k| l = VSB_len(vep->include_src); 518| 19.4k| h = 0; 519| | 520| 19.4k| incl = vep->include_continue ? VEC_IC : VEC_IA; ------------------ | | 43| 0|#define VEC_IC (0x60 + 9) ------------------ incl = vep->include_continue ? VEC_IC : VEC_IA; ------------------ | | 42| 38.9k|#define VEC_IA (0x40 + 9) ------------------ | Branch (520:9): [True: 0, False: 19.4k] ------------------ 521| | 522| 19.4k| if (l > 7 && !memcmp(p, "http://", 7)) { ------------------ | Branch (522:6): [True: 4.91k, False: 14.5k] | Branch (522:15): [True: 1.56k, False: 3.34k] ------------------ 523| 1.56k| h = p + 7; 524| 1.56k| p = strchr(h, '/'); 525| 1.56k| if (p == NULL) { ------------------ | Branch (525:7): [True: 409, False: 1.15k] ------------------ 526| 409| vep_error(vep, 527| 409| "ESI 1.0 invalid src= URL"); 528| 409| vep->state = VEP_TAGERROR; 529| 409| AZ(vep->attr_vsb); ------------------ | | 83| 409|#define AZ(foo) do { assert((foo) == 0); } while (0) | | ------------------ | | | | 65| 409|#define assert(e) \ | | | | 66| 409|do { \ | | | | 67| 409| if (!(e)) { \ | | | | ------------------ | | | | | Branch (67:6): [True: 0, False: 409] | | | | ------------------ | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | 69| 0| #e, VAS_ASSERT); \ | | | | 70| 0| } \ | | | | 71| 409|} while (0) | | | | ------------------ | | | | | Branch (71:10): [Folded, False: 409] | | | | ------------------ | | ------------------ | | | Branch (83:52): [Folded, False: 409] | | ------------------ ------------------ 530| 409| VSB_destroy(&vep->include_src); 531| 409| return; 532| 409| } 533| 1.15k| Debug("HOST <%.*s> PATH <%s>\n", (int)(p-h),h, p); 534| 1.15k| VSB_printf(vep->vsb, "%c", incl); 535| 1.15k| VSB_printf(vep->vsb, "Host: %.*s%c", (int)(p-h), h, 0); 536| 17.8k| } else if (l > 8 && !memcmp(p, "https://", 8)) { ------------------ | Branch (536:13): [True: 3.10k, False: 14.7k] | Branch (536:22): [True: 1.66k, False: 1.44k] ------------------ 537| 1.66k| if (!vep->flags.esi_ignore_https) { ------------------ | Branch (537:7): [True: 266, False: 1.39k] ------------------ 538| 266| vep_warn(vep, 539| 266| "ESI 1.0 with https:// ignored"); 540| 266| vep->state = VEP_TAGERROR; 541| 266| AZ(vep->attr_vsb); ------------------ | | 83| 266|#define AZ(foo) do { assert((foo) == 0); } while (0) | | ------------------ | | | | 65| 266|#define assert(e) \ | | | | 66| 266|do { \ | | | | 67| 266| if (!(e)) { \ | | | | ------------------ | | | | | Branch (67:6): [True: 0, False: 266] | | | | ------------------ | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | 69| 0| #e, VAS_ASSERT); \ | | | | 70| 0| } \ | | | | 71| 266|} while (0) | | | | ------------------ | | | | | Branch (71:10): [Folded, False: 266] | | | | ------------------ | | ------------------ | | | Branch (83:52): [Folded, False: 266] | | ------------------ ------------------ 542| 266| VSB_destroy(&vep->include_src); 543| 266| return; 544| 266| } 545| 1.39k| vep_warn(vep, 546| 1.39k| "ESI 1.0 https:// treated as http://"); 547| 1.39k| h = p + 8; 548| 1.39k| p = strchr(h, '/'); 549| 1.39k| if (p == NULL) { ------------------ | Branch (549:7): [True: 516, False: 878] ------------------ 550| 516| vep_error(vep, 551| 516| "ESI 1.0 invalid src= URL"); 552| 516| vep->state = VEP_TAGERROR; 553| 516| AZ(vep->attr_vsb); ------------------ | | 83| 516|#define AZ(foo) do { assert((foo) == 0); } while (0) | | ------------------ | | | | 65| 516|#define assert(e) \ | | | | 66| 516|do { \ | | | | 67| 516| if (!(e)) { \ | | | | ------------------ | | | | | Branch (67:6): [True: 0, False: 516] | | | | ------------------ | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | 69| 0| #e, VAS_ASSERT); \ | | | | 70| 0| } \ | | | | 71| 516|} while (0) | | | | ------------------ | | | | | Branch (71:10): [Folded, False: 516] | | | | ------------------ | | ------------------ | | | Branch (83:52): [Folded, False: 516] | | ------------------ ------------------ 554| 516| VSB_destroy(&vep->include_src); 555| 516| return; 556| 516| } 557| 878| VSB_printf(vep->vsb, "%c", incl); 558| 878| VSB_printf(vep->vsb, "Host: %.*s%c", (int)(p-h), h, 0); 559| 16.2k| } else if (*p == '/') { ------------------ | Branch (559:13): [True: 561, False: 15.6k] ------------------ 560| 561| VSB_printf(vep->vsb, "%c", incl); 561| 561| VSB_printf(vep->vsb, "%c", 0); 562| 15.6k| } else { 563| 15.6k| VSB_printf(vep->vsb, "%c", incl); 564| 15.6k| VSB_printf(vep->vsb, "%c", 0); 565| | /* Look for the last / before a '?' */ 566| 15.6k| h = NULL; 567| 31.3k| for (q = vep->url; *q && *q != '?'; q++) ------------------ | Branch (567:22): [True: 15.6k, False: 15.6k] | Branch (567:28): [True: 15.6k, False: 0] ------------------ 568| 15.6k| if (*q == '/') ------------------ | Branch (568:8): [True: 15.6k, False: 0] ------------------ 569| 15.6k| h = q; 570| 15.6k| if (h == NULL) ------------------ | Branch (570:7): [True: 0, False: 15.6k] ------------------ 571| 0| h = q + 1; 572| | 573| 15.6k| Debug("INCL:: [%.*s]/[%s]\n", 574| 15.6k| (int)(h - vep->url), vep->url, p); 575| 15.6k| VSB_printf(vep->vsb, "%.*s/", (int)(h - vep->url), vep->url); 576| 15.6k| } 577| 18.2k| l -= (p - VSB_data(vep->include_src)); 578| 4.70M| for (q = p; *q != '\0'; ) { ------------------ | Branch (578:14): [True: 4.68M, False: 18.2k] ------------------ 579| 4.68M| if (*q == '&') { ------------------ | Branch (579:7): [True: 41.9k, False: 4.64M] ------------------ 580| 41.9k|#define R(w,f,r) \ 581| 41.9k| if (q + w <= p + l && !memcmp(q, f, w)) { \ 582| 41.9k| VSB_printf(vep->vsb, "%c", r); \ 583| 41.9k| q += w; \ 584| 41.9k| continue; \ 585| 41.9k| } 586| 41.9k| R(6, "'", '\''); ------------------ | | 581| 41.9k| if (q + w <= p + l && !memcmp(q, f, w)) { \ | | ------------------ | | | Branch (581:8): [True: 41.0k, False: 892] | | | Branch (581:26): [True: 5.42k, False: 35.6k] | | ------------------ | | 582| 5.42k| VSB_printf(vep->vsb, "%c", r); \ | | 583| 5.42k| q += w; \ | | 584| 5.42k| continue; \ | | 585| 5.42k| } ------------------ 587| 36.5k| R(6, """, '"'); ------------------ | | 581| 36.5k| if (q + w <= p + l && !memcmp(q, f, w)) { \ | | ------------------ | | | Branch (581:8): [True: 35.6k, False: 892] | | | Branch (581:26): [True: 962, False: 34.6k] | | ------------------ | | 582| 962| VSB_printf(vep->vsb, "%c", r); \ | | 583| 962| q += w; \ | | 584| 962| continue; \ | | 585| 962| } ------------------ 588| 35.5k| R(4, "<", '<'); ------------------ | | 581| 35.5k| if (q + w <= p + l && !memcmp(q, f, w)) { \ | | ------------------ | | | Branch (581:8): [True: 34.9k, False: 563] | | | Branch (581:26): [True: 357, False: 34.6k] | | ------------------ | | 582| 357| VSB_printf(vep->vsb, "%c", r); \ | | 583| 357| q += w; \ | | 584| 357| continue; \ | | 585| 357| } ------------------ 589| 35.1k| R(4, ">", '>'); ------------------ | | 581| 35.1k| if (q + w <= p + l && !memcmp(q, f, w)) { \ | | ------------------ | | | Branch (581:8): [True: 34.6k, False: 563] | | | Branch (581:26): [True: 4.23k, False: 30.3k] | | ------------------ | | 582| 4.23k| VSB_printf(vep->vsb, "%c", r); \ | | 583| 4.23k| q += w; \ | | 584| 4.23k| continue; \ | | 585| 4.23k| } ------------------ 590| 30.9k| R(5, "&", '&'); ------------------ | | 581| 30.9k| if (q + w <= p + l && !memcmp(q, f, w)) { \ | | ------------------ | | | Branch (581:8): [True: 30.2k, False: 744] | | | Branch (581:26): [True: 622, False: 29.5k] | | ------------------ | | 582| 622| VSB_printf(vep->vsb, "%c", r); \ | | 583| 622| q += w; \ | | 584| 622| continue; \ | | 585| 622| } ------------------ 591| 30.3k| } 592| 4.67M| VSB_printf(vep->vsb, "%c", *q++); 593| 4.67M| } 594| 18.2k|#undef R 595| 18.2k| VSB_printf(vep->vsb, "%c", 0); 596| 18.2k| VSB_destroy(&vep->include_src); 597| 18.2k| vep->include_continue = 0; 598| 18.2k|} cache_esi_parse.c:include_attr_src: 439| 21.5k|{ 440| 21.5k| const char *p; 441| | 442| 21.5k| if (vep->include_src != NULL) { ------------------ | Branch (442:6): [True: 878, False: 20.6k] ------------------ 443| 878| vep_error(vep, 444| 878| "ESI 1.0 " 445| 878| "has multiple src= attributes"); 446| 878| vep->state = VEP_TAGERROR; 447| 878| VSB_destroy(&vep->attr_vsb); 448| 878| VSB_destroy(&vep->include_src); 449| 878| return; 450| 878| } 451| 11.9M| for (p = VSB_data(vep->attr_vsb); *p != '\0'; p++) ------------------ | Branch (451:36): [True: 11.9M, False: 20.3k] ------------------ 452| 11.9M| if (vct_islws(*p)) ------------------ | | 72| 11.9M|#define vct_islws(x) vct_is(x, VCT_LWS) | | ------------------ | | | | 39| 11.9M|#define VCT_LWS (VCT_CRLF | VCT_OWS) | | | | ------------------ | | | | | | 38| 11.9M|#define VCT_CRLF (1<<1) | | | | ------------------ | | | | #define VCT_LWS (VCT_CRLF | VCT_OWS) | | | | ------------------ | | | | | | 37| 11.9M|#define VCT_OWS (1<<0) | | | | ------------------ | | ------------------ | | | Branch (72:22): [True: 263, False: 11.9M] | | ------------------ ------------------ 453| 263| break; 454| 20.6k| if (*p != '\0') { ------------------ | Branch (454:6): [True: 263, False: 20.3k] ------------------ 455| 263| vep_error(vep, 456| 263| "ESI 1.0 " 457| 263| "has whitespace in src= attribute"); 458| 263| vep->state = VEP_TAGERROR; 459| 263| VSB_destroy(&vep->attr_vsb); 460| 263| if (vep->include_src != NULL) ------------------ | Branch (460:7): [True: 0, False: 263] ------------------ 461| 0| VSB_destroy(&vep->include_src); 462| 263| return; 463| 263| } 464| 20.3k| vep->include_src = vep->attr_vsb; 465| | vep->attr_vsb = NULL; 466| 20.3k|} cache_esi_parse.c:vep_warn: 217| 21.7k|{ 218| 21.7k| VSC_C_main->esi_warnings++; 219| 21.7k| VSLb(vep->vc->wrk->vsl, SLT_ESI_xmlerror, "WARN: after %zd %s", 220| 21.7k| vep->o_last, p); 221| 21.7k|} cache_esi_parse.c:vep_do_remove: 420| 2.39k|{ 421| 2.39k| Debug("DO_REMOVE(%d, end %d empty %d remove %d)\n", 422| 2.39k| what, vep->endtag, vep->emptytag, vep->remove); 423| 2.39k| assert(what == DO_TAG); ------------------ | | 65| 2.39k|#define assert(e) \ | | 66| 2.39k|do { \ | | 67| 2.39k| if (!(e)) { \ | | ------------------ | | | Branch (67:6): [True: 0, False: 2.39k] | | ------------------ | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | 69| 0| #e, VAS_ASSERT); \ | | 70| 0| } \ | | 71| 2.39k|} while (0) | | ------------------ | | | Branch (71:10): [Folded, False: 2.39k] | | ------------------ ------------------ 424| 2.39k| if (vep->emptytag) ------------------ | Branch (424:6): [True: 878, False: 1.51k] ------------------ 425| 878| vep_error(vep, "ESI 1.0 not legal"); 426| 1.51k| else if (vep->remove && !vep->endtag) ------------------ | Branch (426:11): [True: 827, False: 685] | Branch (426:26): [True: 539, False: 288] ------------------ 427| 539| vep_error(vep, "ESI 1.0 already open"); 428| 973| else if (!vep->remove && vep->endtag) ------------------ | Branch (428:11): [True: 685, False: 288] | Branch (428:27): [True: 304, False: 381] ------------------ 429| 304| vep_error(vep, "ESI 1.0 not open"); 430| 669| else 431| 669| vep->remove = !vep->endtag; 432| 2.39k|} cache_esi_parse.c:vep_do_comment: 408| 802|{ 409| 802| Debug("DO_COMMENT(%d)\n", what); 410| 802| assert(what == DO_TAG); ------------------ | | 65| 802|#define assert(e) \ | | 66| 802|do { \ | | 67| 802| if (!(e)) { \ | | ------------------ | | | Branch (67:6): [True: 0, False: 802] | | ------------------ | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | 69| 0| #e, VAS_ASSERT); \ | | 70| 0| } \ | | 71| 802|} while (0) | | ------------------ | | | Branch (71:10): [Folded, False: 802] | | ------------------ ------------------ 411| 802| if (!vep->emptytag) ------------------ | Branch (411:6): [True: 561, False: 241] ------------------ 412| 561| vep_error(vep, "ESI 1.0 needs final '/'"); 413| 802|} cache_esi_parse.c:vep_match: 229| 201k|{ 230| 201k| struct vep_match *vm; 231| 201k| const char *q, *r; 232| | 233| 201k| AN(vep->match); ------------------ | | 84| 201k|#define AN(foo) do { assert((foo) != 0); } while (0) | | ------------------ | | | | 65| 201k|#define assert(e) \ | | | | 66| 201k|do { \ | | | | 67| 201k| if (!(e)) { \ | | | | ------------------ | | | | | Branch (67:6): [True: 0, False: 201k] | | | | ------------------ | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | 69| 0| #e, VAS_ASSERT); \ | | | | 70| 0| } \ | | | | 71| 201k|} while (0) | | | | ------------------ | | | | | Branch (71:10): [Folded, False: 201k] | | | | ------------------ | | ------------------ | | | Branch (84:52): [Folded, False: 201k] | | ------------------ ------------------ 234| 547k| for (vm = vep->match; vm->match != NULL; vm++) { ------------------ | Branch (234:24): [True: 515k, False: 32.0k] ------------------ 235| 515k| assert(vstrlen(vm->match) <= sizeof (vep->tag)); ------------------ | | 65| 515k|#define assert(e) \ | | 66| 515k|do { \ | | 67| 515k| if (!(e)) { \ | | ------------------ | | | Branch (67:6): [True: 0, False: 515k] | | ------------------ | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | 69| 0| #e, VAS_ASSERT); \ | | 70| 0| } \ | | 71| 515k|} while (0) | | ------------------ | | | Branch (71:10): [Folded, False: 515k] | | ------------------ ------------------ 236| 515k| r = b; 237| 1.49M| for (q = vm->match; *q != '\0' && r < e; q++, r++) ------------------ | Branch (237:23): [True: 1.32M, False: 169k] | Branch (237:37): [True: 1.32M, False: 44] ------------------ 238| 1.32M| if (*q != *r) ------------------ | Branch (238:8): [True: 345k, False: 976k] ------------------ 239| 345k| break; 240| 515k| if (*q == '\0') ------------------ | Branch (240:7): [True: 169k, False: 345k] ------------------ 241| 169k| break; 242| 345k| if (r == e) ------------------ | Branch (242:7): [True: 44, False: 345k] ------------------ 243| 44| return (NULL); 244| 345k| } 245| 201k| return (vm); 246| 201k|} cache_esi_parse.c:vep_mark_pending: 390| 206|{ 391| 206| ssize_t l; 392| | 393| 206| AN(vep->ver_p); ------------------ | | 84| 206|#define AN(foo) do { assert((foo) != 0); } while (0) | | ------------------ | | | | 65| 206|#define assert(e) \ | | | | 66| 206|do { \ | | | | 67| 206| if (!(e)) { \ | | | | ------------------ | | | | | Branch (67:6): [True: 0, False: 206] | | | | ------------------ | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | 69| 0| #e, VAS_ASSERT); \ | | | | 70| 0| } \ | | | | 71| 206|} while (0) | | | | ------------------ | | | | | Branch (71:10): [Folded, False: 206] | | | | ------------------ | | ------------------ | | | Branch (84:52): [Folded, False: 206] | | ------------------ ------------------ 394| 206| l = p - vep->ver_p; 395| 206| assert(l > 0); ------------------ | | 65| 206|#define assert(e) \ | | 66| 206|do { \ | | 67| 206| if (!(e)) { \ | | ------------------ | | | Branch (67:6): [True: 0, False: 206] | | ------------------ | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | 69| 0| #e, VAS_ASSERT); \ | | 70| 0| } \ | | 71| 206|} while (0) | | ------------------ | | | Branch (71:10): [Folded, False: 206] | | ------------------ ------------------ 396| 206| vep->crcp = crc32(vep->crcp, (const void *)vep->ver_p, l); ------------------ | | 38| 206|# define crc32 z_crc32 ------------------ 397| 206| vep->ver_p = p; 398| | 399| 206| vep->o_pending += l; 400| 206| vep->nm_pending++; 401| 206|} cache_esi_parse.c:vep_default_cb: 1055| 710k|{ 1056| 710k| ssize_t *s; 1057| | 1058| 710k| CHECK_OBJ_NOTNULL(vc, VFP_CTX_MAGIC); ------------------ | | 66| 710k| do { \ | | 67| 710k| assert((ptr) != NULL); \ | | ------------------ | | | | 65| 710k|#define assert(e) \ | | | | 66| 710k|do { \ | | | | 67| 710k| if (!(e)) { \ | | | | ------------------ | | | | | Branch (67:6): [True: 0, False: 710k] | | | | ------------------ | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | 69| 0| #e, VAS_ASSERT); \ | | | | 70| 0| } \ | | | | 71| 710k|} while (0) | | | | ------------------ | | | | | Branch (71:10): [Folded, False: 710k] | | | | ------------------ | | ------------------ | | 68| 710k| assert((ptr)->magic == type_magic); \ | | ------------------ | | | | 65| 710k|#define assert(e) \ | | | | 66| 710k|do { \ | | | | 67| 710k| if (!(e)) { \ | | | | ------------------ | | | | | Branch (67:6): [True: 0, False: 710k] | | | | ------------------ | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | 69| 0| #e, VAS_ASSERT); \ | | | | 70| 0| } \ | | | | 71| 710k|} while (0) | | | | ------------------ | | | | | Branch (71:10): [Folded, False: 710k] | | | | ------------------ | | ------------------ | | 69| 710k| } while (0) | | ------------------ | | | Branch (69:11): [Folded, False: 710k] | | ------------------ ------------------ 1059| 710k| AN(priv); ------------------ | | 84| 710k|#define AN(foo) do { assert((foo) != 0); } while (0) | | ------------------ | | | | 65| 710k|#define assert(e) \ | | | | 66| 710k|do { \ | | | | 67| 710k| if (!(e)) { \ | | | | ------------------ | | | | | Branch (67:6): [True: 0, False: 710k] | | | | ------------------ | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | 69| 0| #e, VAS_ASSERT); \ | | | | 70| 0| } \ | | | | 71| 710k|} while (0) | | | | ------------------ | | | | | Branch (71:10): [Folded, False: 710k] | | | | ------------------ | | ------------------ | | | Branch (84:52): [Folded, False: 710k] | | ------------------ ------------------ 1060| 710k| s = priv; 1061| 710k| *s += l; 1062| 710k| (void)flg; 1063| 710k| return (*s); 1064| 710k|} cache_esi_parse.c:vep_emit_common: 298| 300k|{ 299| | 300| 300k| assert(l >= 0); ------------------ | | 65| 300k|#define assert(e) \ | | 66| 300k|do { \ | | 67| 300k| if (!(e)) { \ | | ------------------ | | | Branch (67:6): [True: 0, False: 300k] | | ------------------ | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | 69| 0| #e, VAS_ASSERT); \ | | 70| 0| } \ | | 71| 300k|} while (0) | | ------------------ | | | Branch (71:10): [Folded, False: 300k] | | ------------------ ------------------ 301| 300k| if (l == 0) ------------------ | Branch (301:6): [True: 1.59k, False: 298k] ------------------ 302| 1.59k| return; 303| 298k| assert(mark == SKIP || mark == VERBATIM); ------------------ | | 65| 298k|#define assert(e) \ | | 66| 298k|do { \ | | 67| 432k| if (!(e)) { \ | | ------------------ | | | Branch (67:8): [True: 165k, False: 133k] | | | Branch (67:8): [True: 133k, False: 0] | | ------------------ | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | 69| 0| #e, VAS_ASSERT); \ | | 70| 0| } \ | | 71| 298k|} while (0) | | ------------------ | | | Branch (71:10): [Folded, False: 298k] | | ------------------ ------------------ 304| 298k| if (mark == SKIP) ------------------ | Branch (304:6): [True: 165k, False: 133k] ------------------ 305| 165k| vep_emit_skip(vep, l); 306| 133k| else 307| 133k| vep_emit_verbatim(vep, l, vep->o_crc); 308| | 309| 298k| vep->crc = crc32(0L, Z_NULL, 0); ------------------ | | 38| 298k|# define crc32 z_crc32 ------------------ vep->crc = crc32(0L, Z_NULL, 0); ------------------ | | 217| 298k|#define Z_NULL 0 /* for initializing zalloc, zfree, opaque */ ------------------ 310| 298k| vep->o_crc = 0; 311| 298k| vep->o_total += l; 312| 298k|} cache_esi_parse.c:vep_emit_skip: 278| 165k|{ 279| | 280| 165k| vep_emit_len(vep, l, VEC_S1, VEC_S2, VEC_S8); ------------------ | | 39| 165k|#define VEC_S1 (0x60 + 1) ------------------ vep_emit_len(vep, l, VEC_S1, VEC_S2, VEC_S8); ------------------ | | 40| 165k|#define VEC_S2 (0x60 + 2) ------------------ vep_emit_len(vep, l, VEC_S1, VEC_S2, VEC_S8); ------------------ | | 41| 165k|#define VEC_S8 (0x60 + 8) ------------------ 281| 165k|} cache_esi_parse.c:vep_emit_len: 254| 298k|{ 255| 298k| uint8_t buf[9]; 256| | 257| 298k| assert(l > 0); ------------------ | | 65| 298k|#define assert(e) \ | | 66| 298k|do { \ | | 67| 298k| if (!(e)) { \ | | ------------------ | | | Branch (67:6): [True: 0, False: 298k] | | ------------------ | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | 69| 0| #e, VAS_ASSERT); \ | | 70| 0| } \ | | 71| 298k|} while (0) | | ------------------ | | | Branch (71:10): [Folded, False: 298k] | | ------------------ ------------------ 258| 298k| if (l < 256) { ------------------ | Branch (258:6): [True: 297k, False: 1.52k] ------------------ 259| 297k| buf[0] = (uint8_t)m8; 260| 297k| buf[1] = (uint8_t)l; 261| 297k| assert((ssize_t)buf[1] == l); ------------------ | | 65| 297k|#define assert(e) \ | | 66| 297k|do { \ | | 67| 297k| if (!(e)) { \ | | ------------------ | | | Branch (67:6): [True: 0, False: 297k] | | ------------------ | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | 69| 0| #e, VAS_ASSERT); \ | | 70| 0| } \ | | 71| 297k|} while (0) | | ------------------ | | | Branch (71:10): [Folded, False: 297k] | | ------------------ ------------------ 262| 297k| VSB_bcat(vep->vsb, buf, 2); 263| 297k| } else if (l < 65536) { ------------------ | Branch (263:13): [True: 1.37k, False: 148] ------------------ 264| 1.37k| buf[0] = (uint8_t)m16; 265| 1.37k| vbe16enc(buf + 1, (uint16_t)l); 266| 1.37k| assert((ssize_t)vbe16dec(buf + 1) == l); ------------------ | | 65| 1.37k|#define assert(e) \ | | 66| 1.37k|do { \ | | 67| 1.37k| if (!(e)) { \ | | ------------------ | | | Branch (67:6): [True: 0, False: 1.37k] | | ------------------ | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | 69| 0| #e, VAS_ASSERT); \ | | 70| 0| } \ | | 71| 1.37k|} while (0) | | ------------------ | | | Branch (71:10): [Folded, False: 1.37k] | | ------------------ ------------------ 267| 1.37k| VSB_bcat(vep->vsb, buf, 3); 268| 1.37k| } else { 269| 148| buf[0] = (uint8_t)m64; 270| 148| vbe64enc(buf + 1, l); 271| 148| assert((ssize_t)vbe64dec(buf + 1) == l); ------------------ | | 65| 148|#define assert(e) \ | | 66| 148|do { \ | | 67| 148| if (!(e)) { \ | | ------------------ | | | Branch (67:6): [True: 0, False: 148] | | ------------------ | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | 69| 0| #e, VAS_ASSERT); \ | | 70| 0| } \ | | 71| 148|} while (0) | | ------------------ | | | Branch (71:10): [Folded, False: 148] | | ------------------ ------------------ 272| 148| VSB_bcat(vep->vsb, buf, 9); 273| 148| } 274| 298k|} cache_esi_parse.c:vep_emit_verbatim: 285| 133k|{ 286| 133k| uint8_t buf[4]; 287| | 288| 133k| vep_emit_len(vep, l, VEC_V1, VEC_V2, VEC_V8); ------------------ | | 33| 133k|#define VEC_V1 (0x40 + 1) ------------------ vep_emit_len(vep, l, VEC_V1, VEC_V2, VEC_V8); ------------------ | | 34| 133k|#define VEC_V2 (0x40 + 2) ------------------ vep_emit_len(vep, l, VEC_V1, VEC_V2, VEC_V8); ------------------ | | 35| 133k|#define VEC_V8 (0x40 + 8) ------------------ 289| 133k| if (vep->dogzip) { ------------------ | Branch (289:6): [True: 0, False: 133k] ------------------ 290| 0| vep_emit_len(vep, l_crc, VEC_C1, VEC_C2, VEC_C8); ------------------ | | 36| 0|#define VEC_C1 (0x50 + 1) ------------------ vep_emit_len(vep, l_crc, VEC_C1, VEC_C2, VEC_C8); ------------------ | | 37| 0|#define VEC_C2 (0x50 + 2) ------------------ vep_emit_len(vep, l_crc, VEC_C1, VEC_C2, VEC_C8); ------------------ | | 38| 0|#define VEC_C8 (0x50 + 8) ------------------ 291| 0| vbe32enc(buf, vep->crc); 292| 0| VSB_bcat(vep->vsb, buf, sizeof buf); 293| 0| } 294| 133k|} WS_Rollback: 85| 1.59k|{ 86| | 87| 1.59k| WS_Assert(ws); 88| | 89| 1.59k| if (pp == 0) ------------------ | Branch (89:6): [True: 1.59k, False: 0] ------------------ 90| 1.59k| pp = (uintptr_t)ws->s; 91| 1.59k| ws_ClearOverflow(ws); 92| 1.59k| WS_Reset(ws, pp); 93| 1.59k|} cache_ws_common.c:ws_ClearOverflow: 60| 1.59k|{ 61| 1.59k| CHECK_OBJ_NOTNULL(ws, WS_MAGIC); ------------------ | | 66| 1.59k| do { \ | | 67| 1.59k| assert((ptr) != NULL); \ | | ------------------ | | | | 65| 1.59k|#define assert(e) \ | | | | 66| 1.59k|do { \ | | | | 67| 1.59k| if (!(e)) { \ | | | | ------------------ | | | | | Branch (67:6): [True: 0, False: 1.59k] | | | | ------------------ | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | 69| 0| #e, VAS_ASSERT); \ | | | | 70| 0| } \ | | | | 71| 1.59k|} while (0) | | | | ------------------ | | | | | Branch (71:10): [Folded, False: 1.59k] | | | | ------------------ | | ------------------ | | 68| 1.59k| assert((ptr)->magic == type_magic); \ | | ------------------ | | | | 65| 1.59k|#define assert(e) \ | | | | 66| 1.59k|do { \ | | | | 67| 1.59k| if (!(e)) { \ | | | | ------------------ | | | | | Branch (67:6): [True: 0, False: 1.59k] | | | | ------------------ | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | 69| 0| #e, VAS_ASSERT); \ | | | | 70| 0| } \ | | | | 71| 1.59k|} while (0) | | | | ------------------ | | | | | Branch (71:10): [Folded, False: 1.59k] | | | | ------------------ | | ------------------ | | 69| 1.59k| } while (0) | | ------------------ | | | Branch (69:11): [Folded, False: 1.59k] | | ------------------ ------------------ 62| | 63| 1.59k| ws->id[0] |= 0x20; // cheesy tolower() 64| 1.59k|} WS_Assert: 76| 9.56k|{ 77| 9.56k| struct ws_emu *we; 78| 9.56k| struct ws_alloc *wa, *wa2 = NULL; 79| 9.56k| size_t len; 80| | 81| 9.56k| CHECK_OBJ_NOTNULL(ws, WS_MAGIC); ------------------ | | 66| 9.56k| do { \ | | 67| 9.56k| assert((ptr) != NULL); \ | | ------------------ | | | | 65| 9.56k|#define assert(e) \ | | | | 66| 9.56k|do { \ | | | | 67| 9.56k| if (!(e)) { \ | | | | ------------------ | | | | | Branch (67:6): [True: 0, False: 9.56k] | | | | ------------------ | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | 69| 0| #e, VAS_ASSERT); \ | | | | 70| 0| } \ | | | | 71| 9.56k|} while (0) | | | | ------------------ | | | | | Branch (71:10): [Folded, False: 9.56k] | | | | ------------------ | | ------------------ | | 68| 9.56k| assert((ptr)->magic == type_magic); \ | | ------------------ | | | | 65| 9.56k|#define assert(e) \ | | | | 66| 9.56k|do { \ | | | | 67| 9.56k| if (!(e)) { \ | | | | ------------------ | | | | | Branch (67:6): [True: 0, False: 9.56k] | | | | ------------------ | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | 69| 0| #e, VAS_ASSERT); \ | | | | 70| 0| } \ | | | | 71| 9.56k|} while (0) | | | | ------------------ | | | | | Branch (71:10): [Folded, False: 9.56k] | | | | ------------------ | | ------------------ | | 69| 9.56k| } while (0) | | ------------------ | | | Branch (69:11): [Folded, False: 9.56k] | | ------------------ ------------------ 82| 9.56k| assert(ws->s != NULL); ------------------ | | 65| 9.56k|#define assert(e) \ | | 66| 9.56k|do { \ | | 67| 9.56k| if (!(e)) { \ | | ------------------ | | | Branch (67:6): [True: 0, False: 9.56k] | | ------------------ | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | 69| 0| #e, VAS_ASSERT); \ | | 70| 0| } \ | | 71| 9.56k|} while (0) | | ------------------ | | | Branch (71:10): [Folded, False: 9.56k] | | ------------------ ------------------ 83| 9.56k| assert(PAOK(ws->s)); ------------------ | | 65| 9.56k|#define assert(e) \ | | 66| 9.56k|do { \ | | 67| 9.56k| if (!(e)) { \ | | ------------------ | | | Branch (67:6): [True: 0, False: 9.56k] | | ------------------ | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | 69| 0| #e, VAS_ASSERT); \ | | 70| 0| } \ | | 71| 9.56k|} while (0) | | ------------------ | | | Branch (71:10): [Folded, False: 9.56k] | | ------------------ ------------------ 84| 9.56k| assert(ws->e != NULL); ------------------ | | 65| 9.56k|#define assert(e) \ | | 66| 9.56k|do { \ | | 67| 9.56k| if (!(e)) { \ | | ------------------ | | | Branch (67:6): [True: 0, False: 9.56k] | | ------------------ | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | 69| 0| #e, VAS_ASSERT); \ | | 70| 0| } \ | | 71| 9.56k|} while (0) | | ------------------ | | | Branch (71:10): [Folded, False: 9.56k] | | ------------------ ------------------ 85| 9.56k| assert(PAOK(ws->e)); ------------------ | | 65| 9.56k|#define assert(e) \ | | 66| 9.56k|do { \ | | 67| 9.56k| if (!(e)) { \ | | ------------------ | | | Branch (67:6): [True: 0, False: 9.56k] | | ------------------ | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | 69| 0| #e, VAS_ASSERT); \ | | 70| 0| } \ | | 71| 9.56k|} while (0) | | ------------------ | | | Branch (71:10): [Folded, False: 9.56k] | | ------------------ ------------------ 86| | 87| 9.56k| we = ws_emu(ws); 88| 9.56k| len = pdiff(ws->s, ws->e); 89| 9.56k| assert(len == we->len); ------------------ | | 65| 9.56k|#define assert(e) \ | | 66| 9.56k|do { \ | | 67| 9.56k| if (!(e)) { \ | | ------------------ | | | Branch (67:6): [True: 0, False: 9.56k] | | ------------------ | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | 69| 0| #e, VAS_ASSERT); \ | | 70| 0| } \ | | 71| 9.56k|} while (0) | | ------------------ | | | Branch (71:10): [Folded, False: 9.56k] | | ------------------ ------------------ 90| | 91| 9.56k| len = 0; 92| 9.56k| VTAILQ_FOREACH(wa, &we->head, list) { ------------------ | | 460| 9.56k| for ((var) = VTAILQ_FIRST((head)); \ | | ------------------ | | | | 457| 9.56k|#define VTAILQ_FIRST(head) ((head)->vtqh_first) | | ------------------ | | 461| 14.3k| (var); \ | | ------------------ | | | Branch (461:6): [True: 4.78k, False: 9.56k] | | ------------------ | | 462| 9.56k| (var) = VTAILQ_NEXT((var), field)) | | ------------------ | | | | 542| 4.78k|#define VTAILQ_NEXT(elm, field) ((elm)->field.vtqe_next) | | ------------------ ------------------ 93| 4.78k| CHECK_OBJ_NOTNULL(wa, WS_ALLOC_MAGIC); ------------------ | | 66| 4.78k| do { \ | | 67| 4.78k| assert((ptr) != NULL); \ | | ------------------ | | | | 65| 4.78k|#define assert(e) \ | | | | 66| 4.78k|do { \ | | | | 67| 4.78k| if (!(e)) { \ | | | | ------------------ | | | | | Branch (67:6): [True: 0, False: 4.78k] | | | | ------------------ | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | 69| 0| #e, VAS_ASSERT); \ | | | | 70| 0| } \ | | | | 71| 4.78k|} while (0) | | | | ------------------ | | | | | Branch (71:10): [Folded, False: 4.78k] | | | | ------------------ | | ------------------ | | 68| 4.78k| assert((ptr)->magic == type_magic); \ | | ------------------ | | | | 65| 4.78k|#define assert(e) \ | | | | 66| 4.78k|do { \ | | | | 67| 4.78k| if (!(e)) { \ | | | | ------------------ | | | | | Branch (67:6): [True: 0, False: 4.78k] | | | | ------------------ | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | 69| 0| #e, VAS_ASSERT); \ | | | | 70| 0| } \ | | | | 71| 4.78k|} while (0) | | | | ------------------ | | | | | Branch (71:10): [Folded, False: 4.78k] | | | | ------------------ | | ------------------ | | 69| 4.78k| } while (0) | | ------------------ | | | Branch (69:11): [Folded, False: 4.78k] | | ------------------ ------------------ 94| 4.78k| wa2 = wa; 95| 4.78k| assert(len == wa->off); ------------------ | | 65| 4.78k|#define assert(e) \ | | 66| 4.78k|do { \ | | 67| 4.78k| if (!(e)) { \ | | ------------------ | | | Branch (67:6): [True: 0, False: 4.78k] | | ------------------ | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | 69| 0| #e, VAS_ASSERT); \ | | 70| 0| } \ | | 71| 4.78k|} while (0) | | ------------------ | | | Branch (71:10): [Folded, False: 4.78k] | | ------------------ ------------------ 96| 4.78k| if (wa->ptr == ws->f || wa->ptr == NULL) /* reservation */ ------------------ | Branch (96:7): [True: 0, False: 4.78k] | Branch (96:27): [True: 0, False: 4.78k] ------------------ 97| 0| break; 98| 4.78k| AN(wa->len); ------------------ | | 84| 4.78k|#define AN(foo) do { assert((foo) != 0); } while (0) | | ------------------ | | | | 65| 4.78k|#define assert(e) \ | | | | 66| 4.78k|do { \ | | | | 67| 4.78k| if (!(e)) { \ | | | | ------------------ | | | | | Branch (67:6): [True: 0, False: 4.78k] | | | | ------------------ | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | 69| 0| #e, VAS_ASSERT); \ | | | | 70| 0| } \ | | | | 71| 4.78k|} while (0) | | | | ------------------ | | | | | Branch (71:10): [Folded, False: 4.78k] | | | | ------------------ | | ------------------ | | | Branch (84:52): [Folded, False: 4.78k] | | ------------------ ------------------ 99| 4.78k| len += PRNDUP(wa->len); ------------------ | | 153| 4.78k|#define PRNDUP(p) (((uintptr_t)(p) + PALGN) & ~PALGN) /* Round up */ | | ------------------ | | | | 149| 4.78k|# define PALGN (sizeof(void *) - 1) /* size of alignment */ | | ------------------ | | #define PRNDUP(p) (((uintptr_t)(p) + PALGN) & ~PALGN) /* Round up */ | | ------------------ | | | | 149| 4.78k|# define PALGN (sizeof(void *) - 1) /* size of alignment */ | | ------------------ ------------------ 100| 4.78k| assert(len <= we->len); ------------------ | | 65| 4.78k|#define assert(e) \ | | 66| 4.78k|do { \ | | 67| 4.78k| if (!(e)) { \ | | ------------------ | | | Branch (67:6): [True: 0, False: 4.78k] | | ------------------ | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | 69| 0| #e, VAS_ASSERT); \ | | 70| 0| } \ | | 71| 4.78k|} while (0) | | ------------------ | | | Branch (71:10): [Folded, False: 4.78k] | | ------------------ ------------------ 101| 4.78k| } 102| | 103| 9.56k| if (wa != NULL) { ------------------ | Branch (103:6): [True: 0, False: 9.56k] ------------------ 104| 0| AZ(VTAILQ_NEXT(wa, list)); ------------------ | | 83| 0|#define AZ(foo) do { assert((foo) == 0); } while (0) | | ------------------ | | | | 65| 0|#define assert(e) \ | | | | 66| 0|do { \ | | | | 67| 0| if (!(e)) { \ | | | | ------------------ | | | | | Branch (67:6): [True: 0, False: 0] | | | | ------------------ | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | 69| 0| #e, VAS_ASSERT); \ | | | | 70| 0| } \ | | | | 71| 0|} while (0) | | | | ------------------ | | | | | Branch (71:10): [Folded, False: 0] | | | | ------------------ | | ------------------ | | | Branch (83:52): [Folded, False: 0] | | ------------------ ------------------ 105| 0| if (wa->ptr == NULL) { ------------------ | Branch (105:7): [True: 0, False: 0] ------------------ 106| 0| AZ(wa->len); ------------------ | | 83| 0|#define AZ(foo) do { assert((foo) == 0); } while (0) | | ------------------ | | | | 65| 0|#define assert(e) \ | | | | 66| 0|do { \ | | | | 67| 0| if (!(e)) { \ | | | | ------------------ | | | | | Branch (67:6): [True: 0, False: 0] | | | | ------------------ | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | 69| 0| #e, VAS_ASSERT); \ | | | | 70| 0| } \ | | | | 71| 0|} while (0) | | | | ------------------ | | | | | Branch (71:10): [Folded, False: 0] | | | | ------------------ | | ------------------ | | | Branch (83:52): [Folded, False: 0] | | ------------------ ------------------ 107| 0| assert(ws->f == ws->e); ------------------ | | 65| 0|#define assert(e) \ | | 66| 0|do { \ | | 67| 0| if (!(e)) { \ | | ------------------ | | | Branch (67:6): [True: 0, False: 0] | | ------------------ | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | 69| 0| #e, VAS_ASSERT); \ | | 70| 0| } \ | | 71| 0|} while (0) | | ------------------ | | | Branch (71:10): [Folded, False: 0] | | ------------------ ------------------ 108| 0| assert(ws->r == ws->e); ------------------ | | 65| 0|#define assert(e) \ | | 66| 0|do { \ | | 67| 0| if (!(e)) { \ | | ------------------ | | | Branch (67:6): [True: 0, False: 0] | | ------------------ | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | 69| 0| #e, VAS_ASSERT); \ | | 70| 0| } \ | | 71| 0|} while (0) | | ------------------ | | | Branch (71:10): [Folded, False: 0] | | ------------------ ------------------ 109| 0| } else { 110| 0| AN(wa->len); ------------------ | | 84| 0|#define AN(foo) do { assert((foo) != 0); } while (0) | | ------------------ | | | | 65| 0|#define assert(e) \ | | | | 66| 0|do { \ | | | | 67| 0| if (!(e)) { \ | | | | ------------------ | | | | | Branch (67:6): [True: 0, False: 0] | | | | ------------------ | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | 69| 0| #e, VAS_ASSERT); \ | | | | 70| 0| } \ | | | | 71| 0|} while (0) | | | | ------------------ | | | | | Branch (71:10): [Folded, False: 0] | | | | ------------------ | | ------------------ | | | Branch (84:52): [Folded, False: 0] | | ------------------ ------------------ 111| 0| assert(ws->f == wa->ptr); ------------------ | | 65| 0|#define assert(e) \ | | 66| 0|do { \ | | 67| 0| if (!(e)) { \ | | ------------------ | | | Branch (67:6): [True: 0, False: 0] | | ------------------ | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | 69| 0| #e, VAS_ASSERT); \ | | 70| 0| } \ | | 71| 0|} while (0) | | ------------------ | | | Branch (71:10): [Folded, False: 0] | | ------------------ ------------------ 112| 0| assert(ws->r == ws->f + wa->len); ------------------ | | 65| 0|#define assert(e) \ | | 66| 0|do { \ | | 67| 0| if (!(e)) { \ | | ------------------ | | | Branch (67:6): [True: 0, False: 0] | | ------------------ | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | 69| 0| #e, VAS_ASSERT); \ | | 70| 0| } \ | | 71| 0|} while (0) | | ------------------ | | | Branch (71:10): [Folded, False: 0] | | ------------------ ------------------ 113| 0| } 114| 0| len += PRNDUP(wa->len); ------------------ | | 153| 0|#define PRNDUP(p) (((uintptr_t)(p) + PALGN) & ~PALGN) /* Round up */ | | ------------------ | | | | 149| 0|# define PALGN (sizeof(void *) - 1) /* size of alignment */ | | ------------------ | | #define PRNDUP(p) (((uintptr_t)(p) + PALGN) & ~PALGN) /* Round up */ | | ------------------ | | | | 149| 0|# define PALGN (sizeof(void *) - 1) /* size of alignment */ | | ------------------ ------------------ 115| 0| assert(len <= we->len); ------------------ | | 65| 0|#define assert(e) \ | | 66| 0|do { \ | | 67| 0| if (!(e)) { \ | | ------------------ | | | Branch (67:6): [True: 0, False: 0] | | ------------------ | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | 69| 0| #e, VAS_ASSERT); \ | | 70| 0| } \ | | 71| 0|} while (0) | | ------------------ | | | Branch (71:10): [Folded, False: 0] | | ------------------ ------------------ 116| 9.56k| } else { 117| 9.56k| AZ(ws->f); ------------------ | | 83| 9.56k|#define AZ(foo) do { assert((foo) == 0); } while (0) | | ------------------ | | | | 65| 9.56k|#define assert(e) \ | | | | 66| 9.56k|do { \ | | | | 67| 9.56k| if (!(e)) { \ | | | | ------------------ | | | | | Branch (67:6): [True: 0, False: 9.56k] | | | | ------------------ | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | 69| 0| #e, VAS_ASSERT); \ | | | | 70| 0| } \ | | | | 71| 9.56k|} while (0) | | | | ------------------ | | | | | Branch (71:10): [Folded, False: 9.56k] | | | | ------------------ | | ------------------ | | | Branch (83:52): [Folded, False: 9.56k] | | ------------------ ------------------ 118| 9.56k| AZ(ws->r); ------------------ | | 83| 9.56k|#define AZ(foo) do { assert((foo) == 0); } while (0) | | ------------------ | | | | 65| 9.56k|#define assert(e) \ | | | | 66| 9.56k|do { \ | | | | 67| 9.56k| if (!(e)) { \ | | | | ------------------ | | | | | Branch (67:6): [True: 0, False: 9.56k] | | | | ------------------ | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | 69| 0| #e, VAS_ASSERT); \ | | | | 70| 0| } \ | | | | 71| 9.56k|} while (0) | | | | ------------------ | | | | | Branch (71:10): [Folded, False: 9.56k] | | | | ------------------ | | ------------------ | | | Branch (83:52): [Folded, False: 9.56k] | | ------------------ ------------------ 119| 9.56k| } 120| | 121| 9.56k| DSLb(DBG_WORKSPACE, "WS(%p) = (%s, %p %zu %zu %zu)", ------------------ | | 621| 9.56k| do { \ | | 622| 9.56k| if (DO_DEBUG(debug_bit)) \ | | ------------------ | | | | 612| 9.56k|#define DO_DEBUG(x) COM_DO_DEBUG(cache_param->debug_bits, x) | | | | ------------------ | | | | | Branch (612:21): [True: 0, False: 9.56k] | | | | ------------------ | | ------------------ | | 623| 9.56k| WRK_Log(SLT_Debug, __VA_ARGS__); \ | | ------------------ | | | Branch (623:23): [True: 0, False: 0] | | | Branch (623:23): [True: 0, False: 0] | | ------------------ | | 624| 9.56k| } while (0) | | ------------------ | | | Branch (624:11): [Folded, False: 9.56k] | | ------------------ ------------------ 122| 9.56k| ws, ws->id, ws->s, wa2 == NULL ? 0 : wa2->off + PRNDUP(wa2->len), 123| 9.56k| ws->r == NULL ? 0 : pdiff(ws->f, ws->r), 124| 9.56k| pdiff(ws->s, ws->e)); 125| 9.56k|} WS_Init: 159| 1.59k|{ 160| 1.59k| struct ws_emu *we; 161| | 162| 1.59k| DSLb(DBG_WORKSPACE, ------------------ | | 621| 1.59k| do { \ | | 622| 1.59k| if (DO_DEBUG(debug_bit)) \ | | ------------------ | | | | 612| 1.59k|#define DO_DEBUG(x) COM_DO_DEBUG(cache_param->debug_bits, x) | | | | ------------------ | | | | | Branch (612:21): [True: 0, False: 1.59k] | | | | ------------------ | | ------------------ | | 623| 1.59k| WRK_Log(SLT_Debug, __VA_ARGS__); \ | | 624| 1.59k| } while (0) | | ------------------ | | | Branch (624:11): [Folded, False: 1.59k] | | ------------------ ------------------ 163| 1.59k| "WS_Init(%p, \"%s\", %p, %u)", ws, id, space, len); 164| 1.59k| assert(space != NULL); ------------------ | | 65| 1.59k|#define assert(e) \ | | 66| 1.59k|do { \ | | 67| 1.59k| if (!(e)) { \ | | ------------------ | | | Branch (67:6): [True: 0, False: 1.59k] | | ------------------ | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | 69| 0| #e, VAS_ASSERT); \ | | 70| 0| } \ | | 71| 1.59k|} while (0) | | ------------------ | | | Branch (71:10): [Folded, False: 1.59k] | | ------------------ ------------------ 165| 1.59k| assert(PAOK(space)); ------------------ | | 65| 1.59k|#define assert(e) \ | | 66| 1.59k|do { \ | | 67| 1.59k| if (!(e)) { \ | | ------------------ | | | Branch (67:6): [True: 0, False: 1.59k] | | ------------------ | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | 69| 0| #e, VAS_ASSERT); \ | | 70| 0| } \ | | 71| 1.59k|} while (0) | | ------------------ | | | Branch (71:10): [Folded, False: 1.59k] | | ------------------ ------------------ 166| 1.59k| assert(len >= sizeof *we); ------------------ | | 65| 1.59k|#define assert(e) \ | | 66| 1.59k|do { \ | | 67| 1.59k| if (!(e)) { \ | | ------------------ | | | Branch (67:6): [True: 0, False: 1.59k] | | ------------------ | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | 69| 0| #e, VAS_ASSERT); \ | | 70| 0| } \ | | 71| 1.59k|} while (0) | | ------------------ | | | Branch (71:10): [Folded, False: 1.59k] | | ------------------ ------------------ 167| | 168| 1.59k| len = PRNDDN(len - 1); ------------------ | | 152| 1.59k|#define PRNDDN(p) ((uintptr_t)(p) & ~PALGN) /* Round down */ | | ------------------ | | | | 149| 1.59k|# define PALGN (sizeof(void *) - 1) /* size of alignment */ | | ------------------ ------------------ 169| 1.59k| INIT_OBJ(ws, WS_MAGIC); ------------------ | | 15| 1.59k| do { \ | | 16| 1.59k| (void)memset(to, 0, sizeof *(to)); \ | | 17| 1.59k| (to)->magic = (type_magic); \ | | 18| 1.59k| } while (0) | | ------------------ | | | Branch (18:11): [Folded, False: 1.59k] | | ------------------ ------------------ 170| 1.59k| ws->s = space; 171| 1.59k| ws->e = ws->s + len; 172| | 173| 1.59k| assert(id[0] & 0x20); // cheesy islower() ------------------ | | 65| 1.59k|#define assert(e) \ | | 66| 1.59k|do { \ | | 67| 1.59k| if (!(e)) { \ | | ------------------ | | | Branch (67:6): [True: 0, False: 1.59k] | | ------------------ | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | 69| 0| #e, VAS_ASSERT); \ | | 70| 0| } \ | | 71| 1.59k|} while (0) | | ------------------ | | | Branch (71:10): [Folded, False: 1.59k] | | ------------------ ------------------ 174| 1.59k| bstrcpy(ws->id, id); ------------------ | | 66| 1.59k| do { \ | | 67| 1.59k| assert(vstrlen(src) + 1 <= sizeof (dst)); \ | | ------------------ | | | | 65| 1.59k|#define assert(e) \ | | | | 66| 1.59k|do { \ | | | | 67| 1.59k| if (!(e)) { \ | | | | ------------------ | | | | | Branch (67:6): [True: 0, False: 1.59k] | | | | ------------------ | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | 69| 0| #e, VAS_ASSERT); \ | | | | 70| 0| } \ | | | | 71| 1.59k|} while (0) | | | | ------------------ | | | | | Branch (71:10): [Folded, False: 1.59k] | | | | ------------------ | | ------------------ | | 68| 1.59k| strcpy((dst), (src)); \ | | 69| 1.59k| } while (0) | | ------------------ | | | Branch (69:11): [Folded, False: 1.59k] | | ------------------ ------------------ 175| | 176| 1.59k| we = space; 177| 1.59k| INIT_OBJ(we, WS_EMU_MAGIC); ------------------ | | 15| 1.59k| do { \ | | 16| 1.59k| (void)memset(to, 0, sizeof *(to)); \ | | 17| 1.59k| (to)->magic = (type_magic); \ | | 18| 1.59k| } while (0) | | ------------------ | | | Branch (18:11): [Folded, False: 1.59k] | | ------------------ ------------------ 178| 1.59k| VTAILQ_INIT(&we->head); ------------------ | | 499| 1.59k|#define VTAILQ_INIT(head) do { \ | | 500| 1.59k| VTAILQ_FIRST((head)) = NULL; \ | | ------------------ | | | | 457| 1.59k|#define VTAILQ_FIRST(head) ((head)->vtqh_first) | | ------------------ | | 501| 1.59k| (head)->vtqh_last = &VTAILQ_FIRST((head)); \ | | ------------------ | | | | 457| 1.59k|#define VTAILQ_FIRST(head) ((head)->vtqh_first) | | ------------------ | | 502| 1.59k|} while (0) | | ------------------ | | | Branch (502:10): [Folded, False: 1.59k] | | ------------------ ------------------ 179| 1.59k| we->len = len; 180| | 181| 1.59k| WS_Assert(ws); 182| 1.59k|} WS_Reset: 198| 1.59k|{ 199| 1.59k| struct ws_emu *we; 200| 1.59k| struct ws_alloc *wa; 201| 1.59k| char *p; 202| | 203| 1.59k| WS_Assert(ws); 204| 1.59k| AN(pp); ------------------ | | 84| 1.59k|#define AN(foo) do { assert((foo) != 0); } while (0) | | ------------------ | | | | 65| 1.59k|#define assert(e) \ | | | | 66| 1.59k|do { \ | | | | 67| 1.59k| if (!(e)) { \ | | | | ------------------ | | | | | Branch (67:6): [True: 0, False: 1.59k] | | | | ------------------ | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | 69| 0| #e, VAS_ASSERT); \ | | | | 70| 0| } \ | | | | 71| 1.59k|} while (0) | | | | ------------------ | | | | | Branch (71:10): [Folded, False: 1.59k] | | | | ------------------ | | ------------------ | | | Branch (84:52): [Folded, False: 1.59k] | | ------------------ ------------------ 205| 1.59k| if (pp == snap_overflowed) { ------------------ | Branch (205:6): [True: 0, False: 1.59k] ------------------ 206| 0| DSLb(DBG_WORKSPACE, "WS_Reset(%p, overflowed)", ws); ------------------ | | 621| 0| do { \ | | 622| 0| if (DO_DEBUG(debug_bit)) \ | | ------------------ | | | | 612| 0|#define DO_DEBUG(x) COM_DO_DEBUG(cache_param->debug_bits, x) | | | | ------------------ | | | | | Branch (612:21): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 623| 0| WRK_Log(SLT_Debug, __VA_ARGS__); \ | | 624| 0| } while (0) | | ------------------ | | | Branch (624:11): [Folded, False: 0] | | ------------------ ------------------ 207| 0| AN(WS_Overflowed(ws)); ------------------ | | 84| 0|#define AN(foo) do { assert((foo) != 0); } while (0) | | ------------------ | | | | 65| 0|#define assert(e) \ | | | | 66| 0|do { \ | | | | 67| 0| if (!(e)) { \ | | | | ------------------ | | | | | Branch (67:6): [True: 0, False: 0] | | | | ------------------ | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | 69| 0| #e, VAS_ASSERT); \ | | | | 70| 0| } \ | | | | 71| 0|} while (0) | | | | ------------------ | | | | | Branch (71:10): [Folded, False: 0] | | | | ------------------ | | ------------------ | | | Branch (84:52): [Folded, False: 0] | | ------------------ ------------------ 208| 0| return; 209| 0| } 210| 1.59k| p = (char *)pp; 211| 1.59k| DSLb(DBG_WORKSPACE, "WS_Reset(%p, %p)", ws, p); ------------------ | | 621| 1.59k| do { \ | | 622| 1.59k| if (DO_DEBUG(debug_bit)) \ | | ------------------ | | | | 612| 1.59k|#define DO_DEBUG(x) COM_DO_DEBUG(cache_param->debug_bits, x) | | | | ------------------ | | | | | Branch (612:21): [True: 0, False: 1.59k] | | | | ------------------ | | ------------------ | | 623| 1.59k| WRK_Log(SLT_Debug, __VA_ARGS__); \ | | 624| 1.59k| } while (0) | | ------------------ | | | Branch (624:11): [Folded, False: 1.59k] | | ------------------ ------------------ 212| 1.59k| AZ(ws->r); ------------------ | | 83| 1.59k|#define AZ(foo) do { assert((foo) == 0); } while (0) | | ------------------ | | | | 65| 1.59k|#define assert(e) \ | | | | 66| 1.59k|do { \ | | | | 67| 1.59k| if (!(e)) { \ | | | | ------------------ | | | | | Branch (67:6): [True: 0, False: 1.59k] | | | | ------------------ | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | 69| 0| #e, VAS_ASSERT); \ | | | | 70| 0| } \ | | | | 71| 1.59k|} while (0) | | | | ------------------ | | | | | Branch (71:10): [Folded, False: 1.59k] | | | | ------------------ | | ------------------ | | | Branch (83:52): [Folded, False: 1.59k] | | ------------------ ------------------ 213| | 214| 1.59k| we = ws_emu(ws); 215| 3.18k| while ((wa = VTAILQ_LAST(&we->head, ws_alloc_head)) != NULL && ------------------ | | 540| 3.18k| (*(((struct headname *)((head)->vtqh_last))->vtqh_last)) ------------------ | Branch (215:9): [True: 1.59k, False: 1.59k] ------------------ 216| 1.59k| wa->ptr != p) ------------------ | Branch (216:6): [True: 1.59k, False: 0] ------------------ 217| 1.59k| ws_alloc_free(we, &wa); 218| 1.59k| if (wa == NULL) ------------------ | Branch (218:6): [True: 1.59k, False: 0] ------------------ 219| 1.59k| assert(p == ws->s); ------------------ | | 65| 1.59k|#define assert(e) \ | | 66| 1.59k|do { \ | | 67| 1.59k| if (!(e)) { \ | | ------------------ | | | Branch (67:6): [True: 0, False: 1.59k] | | ------------------ | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | 69| 0| #e, VAS_ASSERT); \ | | 70| 0| } \ | | 71| 1.59k|} while (0) | | ------------------ | | | Branch (71:10): [Folded, False: 1.59k] | | ------------------ ------------------ 220| | 221| 1.59k| WS_Assert(ws); 222| 1.59k|} WS_Alloc: 304| 1.59k|{ 305| 1.59k| struct ws_alloc *wa; 306| | 307| 1.59k| assert(bytes > 0); ------------------ | | 65| 1.59k|#define assert(e) \ | | 66| 1.59k|do { \ | | 67| 1.59k| if (!(e)) { \ | | ------------------ | | | Branch (67:6): [True: 0, False: 1.59k] | | ------------------ | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | 69| 0| #e, VAS_ASSERT); \ | | 70| 0| } \ | | 71| 1.59k|} while (0) | | ------------------ | | | Branch (71:10): [Folded, False: 1.59k] | | ------------------ ------------------ 308| 1.59k| wa = ws_emu_alloc(ws, bytes); 309| 1.59k| WS_Assert(ws); 310| 1.59k| if (wa != NULL) { ------------------ | Branch (310:6): [True: 1.59k, False: 0] ------------------ 311| 1.59k| AN(wa->ptr); ------------------ | | 84| 1.59k|#define AN(foo) do { assert((foo) != 0); } while (0) | | ------------------ | | | | 65| 1.59k|#define assert(e) \ | | | | 66| 1.59k|do { \ | | | | 67| 1.59k| if (!(e)) { \ | | | | ------------------ | | | | | Branch (67:6): [True: 0, False: 1.59k] | | | | ------------------ | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | 69| 0| #e, VAS_ASSERT); \ | | | | 70| 0| } \ | | | | 71| 1.59k|} while (0) | | | | ------------------ | | | | | Branch (71:10): [Folded, False: 1.59k] | | | | ------------------ | | ------------------ | | | Branch (84:52): [Folded, False: 1.59k] | | ------------------ ------------------ 312| 1.59k| DSLb(DBG_WORKSPACE, "WS_Alloc(%p, %u) = %p", ------------------ | | 621| 1.59k| do { \ | | 622| 1.59k| if (DO_DEBUG(debug_bit)) \ | | ------------------ | | | | 612| 1.59k|#define DO_DEBUG(x) COM_DO_DEBUG(cache_param->debug_bits, x) | | | | ------------------ | | | | | Branch (612:21): [True: 0, False: 1.59k] | | | | ------------------ | | ------------------ | | 623| 1.59k| WRK_Log(SLT_Debug, __VA_ARGS__); \ | | 624| 1.59k| } while (0) | | ------------------ | | | Branch (624:11): [Folded, False: 1.59k] | | ------------------ ------------------ 313| 1.59k| ws, bytes, wa->ptr); 314| 1.59k| return (wa->ptr); 315| 1.59k| } 316| 0| return (NULL); 317| 1.59k|} cache_ws_emu.c:ws_emu: 67| 12.7k|{ 68| 12.7k| struct ws_emu *we; 69| | 70| 12.7k| CAST_OBJ_NOTNULL(we, (void *)ws->s, WS_EMU_MAGIC); ------------------ | | 85| 12.7k| do { \ | | 86| 12.7k| (to) = (from); \ | | 87| 12.7k| AN((to)); \ | | ------------------ | | | | 84| 12.7k|#define AN(foo) do { assert((foo) != 0); } while (0) | | | | ------------------ | | | | | | 65| 12.7k|#define assert(e) \ | | | | | | 66| 12.7k|do { \ | | | | | | 67| 12.7k| if (!(e)) { \ | | | | | | ------------------ | | | | | | | Branch (67:6): [True: 0, False: 12.7k] | | | | | | ------------------ | | | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | | | 69| 0| #e, VAS_ASSERT); \ | | | | | | 70| 0| } \ | | | | | | 71| 12.7k|} while (0) | | | | | | ------------------ | | | | | | | Branch (71:10): [Folded, False: 12.7k] | | | | | | ------------------ | | | | ------------------ | | | | | Branch (84:52): [Folded, False: 12.7k] | | | | ------------------ | | ------------------ | | 88| 12.7k| CHECK_OBJ((to), (type_magic)); \ | | ------------------ | | | | 61| 12.7k| do { \ | | | | 62| 12.7k| assert((ptr)->magic == type_magic); \ | | | | ------------------ | | | | | | 65| 12.7k|#define assert(e) \ | | | | | | 66| 12.7k|do { \ | | | | | | 67| 12.7k| if (!(e)) { \ | | | | | | ------------------ | | | | | | | Branch (67:6): [True: 0, False: 12.7k] | | | | | | ------------------ | | | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | | | 69| 0| #e, VAS_ASSERT); \ | | | | | | 70| 0| } \ | | | | | | 71| 12.7k|} while (0) | | | | | | ------------------ | | | | | | | Branch (71:10): [Folded, False: 12.7k] | | | | | | ------------------ | | | | ------------------ | | | | 63| 12.7k| } while (0) | | | | ------------------ | | | | | Branch (63:11): [Folded, False: 12.7k] | | | | ------------------ | | ------------------ | | 89| 12.7k| } while (0) | | ------------------ | | | Branch (89:11): [Folded, False: 12.7k] | | ------------------ ------------------ 71| 12.7k| return (we); 72| 12.7k|} cache_ws_emu.c:ws_alloc_free: 186| 1.59k|{ 187| 1.59k| struct ws_alloc *wa; 188| | 189| 1.59k| TAKE_OBJ_NOTNULL(wa, wap, WS_ALLOC_MAGIC); ------------------ | | 92| 1.59k| do { \ | | 93| 1.59k| AN((pfrom)); \ | | ------------------ | | | | 84| 1.59k|#define AN(foo) do { assert((foo) != 0); } while (0) | | | | ------------------ | | | | | | 65| 1.59k|#define assert(e) \ | | | | | | 66| 1.59k|do { \ | | | | | | 67| 1.59k| if (!(e)) { \ | | | | | | ------------------ | | | | | | | Branch (67:6): [True: 0, False: 1.59k] | | | | | | ------------------ | | | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | | | 69| 0| #e, VAS_ASSERT); \ | | | | | | 70| 0| } \ | | | | | | 71| 1.59k|} while (0) | | | | | | ------------------ | | | | | | | Branch (71:10): [Folded, False: 1.59k] | | | | | | ------------------ | | | | ------------------ | | | | | Branch (84:52): [Folded, False: 1.59k] | | | | ------------------ | | ------------------ | | 94| 1.59k| (to) = *(pfrom); \ | | 95| 1.59k| *(pfrom) = NULL; \ | | 96| 1.59k| CHECK_OBJ_NOTNULL((to), (type_magic)); \ | | ------------------ | | | | 66| 1.59k| do { \ | | | | 67| 1.59k| assert((ptr) != NULL); \ | | | | ------------------ | | | | | | 65| 1.59k|#define assert(e) \ | | | | | | 66| 1.59k|do { \ | | | | | | 67| 1.59k| if (!(e)) { \ | | | | | | ------------------ | | | | | | | Branch (67:6): [True: 0, False: 1.59k] | | | | | | ------------------ | | | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | | | 69| 0| #e, VAS_ASSERT); \ | | | | | | 70| 0| } \ | | | | | | 71| 1.59k|} while (0) | | | | | | ------------------ | | | | | | | Branch (71:10): [Folded, False: 1.59k] | | | | | | ------------------ | | | | ------------------ | | | | 68| 1.59k| assert((ptr)->magic == type_magic); \ | | | | ------------------ | | | | | | 65| 1.59k|#define assert(e) \ | | | | | | 66| 1.59k|do { \ | | | | | | 67| 1.59k| if (!(e)) { \ | | | | | | ------------------ | | | | | | | Branch (67:6): [True: 0, False: 1.59k] | | | | | | ------------------ | | | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | | | 69| 0| #e, VAS_ASSERT); \ | | | | | | 70| 0| } \ | | | | | | 71| 1.59k|} while (0) | | | | | | ------------------ | | | | | | | Branch (71:10): [Folded, False: 1.59k] | | | | | | ------------------ | | | | ------------------ | | | | 69| 1.59k| } while (0) | | | | ------------------ | | | | | Branch (69:11): [Folded, False: 1.59k] | | | | ------------------ | | ------------------ | | 97| 1.59k| } while (0) | | ------------------ | | | Branch (97:11): [Folded, False: 1.59k] | | ------------------ ------------------ 190| 1.59k| AZ(VTAILQ_NEXT(wa, list)); ------------------ | | 83| 1.59k|#define AZ(foo) do { assert((foo) == 0); } while (0) | | ------------------ | | | | 65| 1.59k|#define assert(e) \ | | | | 66| 1.59k|do { \ | | | | 67| 1.59k| if (!(e)) { \ | | | | ------------------ | | | | | Branch (67:6): [True: 0, False: 1.59k] | | | | ------------------ | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | 69| 0| #e, VAS_ASSERT); \ | | | | 70| 0| } \ | | | | 71| 1.59k|} while (0) | | | | ------------------ | | | | | Branch (71:10): [Folded, False: 1.59k] | | | | ------------------ | | ------------------ | | | Branch (83:52): [Folded, False: 1.59k] | | ------------------ ------------------ 191| 1.59k| VTAILQ_REMOVE(&we->head, wa, list); ------------------ | | 547| 1.59k|#define VTAILQ_REMOVE(head, elm, field) do { \ | | 548| 1.59k| if ((VTAILQ_NEXT((elm), field)) != NULL) \ | | ------------------ | | | | 542| 1.59k|#define VTAILQ_NEXT(elm, field) ((elm)->field.vtqe_next) | | ------------------ | | | Branch (548:6): [True: 0, False: 1.59k] | | ------------------ | | 549| 1.59k| VTAILQ_NEXT((elm), field)->field.vtqe_prev = \ | | ------------------ | | | | 542| 0|#define VTAILQ_NEXT(elm, field) ((elm)->field.vtqe_next) | | ------------------ | | 550| 0| (elm)->field.vtqe_prev; \ | | 551| 1.59k| else { \ | | 552| 1.59k| (head)->vtqh_last = (elm)->field.vtqe_prev; \ | | 553| 1.59k| } \ | | 554| 1.59k| *(elm)->field.vtqe_prev = VTAILQ_NEXT((elm), field); \ | | ------------------ | | | | 542| 1.59k|#define VTAILQ_NEXT(elm, field) ((elm)->field.vtqe_next) | | ------------------ | | 555| 1.59k| TRASHIT(*oldnext); \ | | 556| 1.59k| TRASHIT(*oldprev); \ | | 557| 1.59k|} while (0) | | ------------------ | | | Branch (557:10): [Folded, False: 1.59k] | | ------------------ ------------------ 192| 1.59k| free(wa->ptr); 193| | FREE_OBJ(wa); ------------------ | | 51| 1.59k| do { \ | | 52| 1.59k| ZERO_OBJ(&(to)->magic, sizeof (to)->magic); \ | | ------------------ | | | | 9| 1.59k| do { \ | | | | 10| 1.59k| void *(*volatile z_obj)(void *, int, size_t) = memset; \ | | | | 11| 1.59k| (void)z_obj(to, 0, sz); \ | | | | 12| 1.59k| } while (0) | | | | ------------------ | | | | | Branch (12:11): [Folded, False: 1.59k] | | | | ------------------ | | ------------------ | | 53| 1.59k| free(to); \ | | 54| 1.59k| to = NULL; \ | | 55| 1.59k| } while (0) | | ------------------ | | | Branch (55:11): [Folded, False: 1.59k] | | ------------------ ------------------ 194| 1.59k|} cache_ws_emu.c:ws_emu_alloc: 269| 1.59k|{ 270| 1.59k| struct ws_emu *we; 271| 1.59k| struct ws_alloc *wa; 272| 1.59k| size_t off = 0; 273| | 274| 1.59k| WS_Assert(ws); 275| 1.59k| AZ(ws->r); ------------------ | | 83| 1.59k|#define AZ(foo) do { assert((foo) == 0); } while (0) | | ------------------ | | | | 65| 1.59k|#define assert(e) \ | | | | 66| 1.59k|do { \ | | | | 67| 1.59k| if (!(e)) { \ | | | | ------------------ | | | | | Branch (67:6): [True: 0, False: 1.59k] | | | | ------------------ | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | 69| 0| #e, VAS_ASSERT); \ | | | | 70| 0| } \ | | | | 71| 1.59k|} while (0) | | | | ------------------ | | | | | Branch (71:10): [Folded, False: 1.59k] | | | | ------------------ | | ------------------ | | | Branch (83:52): [Folded, False: 1.59k] | | ------------------ ------------------ 276| | 277| 1.59k| we = ws_emu(ws); 278| 1.59k| wa = VTAILQ_LAST(&we->head, ws_alloc_head); ------------------ | | 540| 1.59k| (*(((struct headname *)((head)->vtqh_last))->vtqh_last)) ------------------ 279| 1.59k| CHECK_OBJ_ORNULL(wa, WS_ALLOC_MAGIC); ------------------ | | 72| 1.59k| do { \ | | 73| 1.59k| if ((ptr) != NULL) \ | | ------------------ | | | Branch (73:7): [True: 0, False: 1.59k] | | ------------------ | | 74| 1.59k| assert((ptr)->magic == type_magic); \ | | ------------------ | | | | 65| 0|#define assert(e) \ | | | | 66| 0|do { \ | | | | 67| 0| if (!(e)) { \ | | | | ------------------ | | | | | Branch (67:6): [True: 0, False: 0] | | | | ------------------ | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | 69| 0| #e, VAS_ASSERT); \ | | | | 70| 0| } \ | | | | 71| 0|} while (0) | | | | ------------------ | | | | | Branch (71:10): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 75| 1.59k| } while (0) | | ------------------ | | | Branch (75:11): [Folded, False: 1.59k] | | ------------------ ------------------ 280| | 281| 1.59k| if (wa != NULL) ------------------ | Branch (281:6): [True: 0, False: 1.59k] ------------------ 282| 0| off = wa->off + PRNDUP(wa->len); ------------------ | | 153| 0|#define PRNDUP(p) (((uintptr_t)(p) + PALGN) & ~PALGN) /* Round up */ | | ------------------ | | | | 149| 0|# define PALGN (sizeof(void *) - 1) /* size of alignment */ | | ------------------ | | #define PRNDUP(p) (((uintptr_t)(p) + PALGN) & ~PALGN) /* Round up */ | | ------------------ | | | | 149| 0|# define PALGN (sizeof(void *) - 1) /* size of alignment */ | | ------------------ ------------------ 283| 1.59k| if (off + len > we->len) { ------------------ | Branch (283:6): [True: 0, False: 1.59k] ------------------ 284| 0| WS_MarkOverflow(ws); 285| 0| return (NULL); 286| 0| } 287| 1.59k| if (len == 0) ------------------ | Branch (287:6): [True: 0, False: 1.59k] ------------------ 288| 0| len = we->len - off; 289| | 290| 1.59k| ALLOC_OBJ(wa, WS_ALLOC_MAGIC); ------------------ | | 27| 1.59k| do { \ | | 28| 1.59k| (to) = calloc((size_t)1, sizeof *(to)); \ | | 29| 1.59k| if ((to) != NULL) \ | | ------------------ | | | Branch (29:7): [True: 1.59k, False: 0] | | ------------------ | | 30| 1.59k| (to)->magic = (type_magic); \ | | 31| 1.59k| } while (0) | | ------------------ | | | Branch (31:11): [Folded, False: 1.59k] | | ------------------ ------------------ 291| 1.59k| AN(wa); ------------------ | | 84| 1.59k|#define AN(foo) do { assert((foo) != 0); } while (0) | | ------------------ | | | | 65| 1.59k|#define assert(e) \ | | | | 66| 1.59k|do { \ | | | | 67| 1.59k| if (!(e)) { \ | | | | ------------------ | | | | | Branch (67:6): [True: 0, False: 1.59k] | | | | ------------------ | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | 69| 0| #e, VAS_ASSERT); \ | | | | 70| 0| } \ | | | | 71| 1.59k|} while (0) | | | | ------------------ | | | | | Branch (71:10): [Folded, False: 1.59k] | | | | ------------------ | | ------------------ | | | Branch (84:52): [Folded, False: 1.59k] | | ------------------ ------------------ 292| 1.59k| wa->off = off; 293| 1.59k| wa->len = len; 294| 1.59k| if (len > 0) { ------------------ | Branch (294:6): [True: 1.59k, False: 0] ------------------ 295| 1.59k| wa->ptr = malloc(len); 296| 1.59k| AN(wa->ptr); ------------------ | | 84| 1.59k|#define AN(foo) do { assert((foo) != 0); } while (0) | | ------------------ | | | | 65| 1.59k|#define assert(e) \ | | | | 66| 1.59k|do { \ | | | | 67| 1.59k| if (!(e)) { \ | | | | ------------------ | | | | | Branch (67:6): [True: 0, False: 1.59k] | | | | ------------------ | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | 69| 0| #e, VAS_ASSERT); \ | | | | 70| 0| } \ | | | | 71| 1.59k|} while (0) | | | | ------------------ | | | | | Branch (71:10): [Folded, False: 1.59k] | | | | ------------------ | | ------------------ | | | Branch (84:52): [Folded, False: 1.59k] | | ------------------ ------------------ 297| 1.59k| } 298| 1.59k| VTAILQ_INSERT_TAIL(&we->head, wa, list); ------------------ | | 532| 1.59k|#define VTAILQ_INSERT_TAIL(head, elm, field) do { \ | | 533| 1.59k| VTAILQ_NEXT((elm), field) = NULL; \ | | ------------------ | | | | 542| 1.59k|#define VTAILQ_NEXT(elm, field) ((elm)->field.vtqe_next) | | ------------------ | | 534| 1.59k| (elm)->field.vtqe_prev = (head)->vtqh_last; \ | | 535| 1.59k| *(head)->vtqh_last = (elm); \ | | 536| 1.59k| (head)->vtqh_last = &VTAILQ_NEXT((elm), field); \ | | ------------------ | | | | 542| 1.59k|#define VTAILQ_NEXT(elm, field) ((elm)->field.vtqe_next) | | ------------------ | | 537| 1.59k|} while (0) | | ------------------ | | | Branch (537:10): [Folded, False: 1.59k] | | ------------------ ------------------ 299| 1.59k| return (wa); 300| 1.59k|} cache_ws_emu.c:COM_DO_DEBUG: 51| 14.3k|{ 52| 14.3k| return ((p[(unsigned)x>>3] & (0x80U >> ((unsigned)x & 7))) != 0); 53| 14.3k|} VSLb: 76| 42.8k|{ 77| 42.8k| (void)vsl; 78| 42.8k| (void)tag; 79| 42.8k| (void)fmt; 80| 42.8k|} LLVMFuzzerTestOneInput: 121| 1.59k|{ 122| 1.59k| struct VSC_main __VSC_C_main; 123| 1.59k| struct params __cache_param; 124| 1.59k| struct http req[1]; 125| 1.59k| struct http resp[1]; 126| 1.59k| struct vfp_ctx vc[1]; 127| 1.59k| struct worker wrk[1]; 128| 1.59k| struct ws ws[1]; 129| 1.59k| struct vep_state *vep; 130| 1.59k| struct vsb *vsb; 131| 1.59k| txt hd[HTTP_HDR_URL + 1]; 132| 1.59k| struct vep_flags flags = {0}; 133| 1.59k| char ws_buf[1024]; 134| | 135| 1.59k| if (size < 1) ------------------ | Branch (135:6): [True: 0, False: 1.59k] ------------------ 136| 0| return (0); 137| | 138| 1.59k| AN(data); ------------------ | | 84| 1.59k|#define AN(foo) do { assert((foo) != 0); } while (0) | | ------------------ | | | | 65| 1.59k|#define assert(e) \ | | | | 66| 1.59k|do { \ | | | | 67| 1.59k| if (!(e)) { \ | | | | ------------------ | | | | | Branch (67:6): [True: 0, False: 1.59k] | | | | ------------------ | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | 69| 0| #e, VAS_ASSERT); \ | | | | 70| 0| } \ | | | | 71| 1.59k|} while (0) | | | | ------------------ | | | | | Branch (71:10): [Folded, False: 1.59k] | | | | ------------------ | | ------------------ | | | Branch (84:52): [Folded, False: 1.59k] | | ------------------ ------------------ 139| | 140| 1.59k| VSC_C_main = &__VSC_C_main; 141| 1.59k| cache_param = &__cache_param; 142| | 143| 1.59k| memset(&__cache_param, 0, sizeof(__cache_param)); 144| 1.59k| if (data[0] & 0x8f) ------------------ | Branch (144:6): [True: 1.55k, False: 40] ------------------ 145| 1.55k| flags.esi_ignore_https = 1; 146| 1.59k| if (size > 1 && data[1] & 0x8f) ------------------ | Branch (146:6): [True: 1.56k, False: 30] | Branch (146:18): [True: 1.51k, False: 53] ------------------ 147| 1.51k| flags.esi_disable_xml_check = 1; 148| 1.59k| if (size > 2 && data[2] & 0x8f) ------------------ | Branch (148:6): [True: 1.53k, False: 55] | Branch (148:18): [True: 1.47k, False: 67] ------------------ 149| 1.47k| flags.esi_ignore_other_elements = 1; 150| 1.59k| if (size > 3 && data[3] & 0x8f) ------------------ | Branch (150:6): [True: 1.52k, False: 67] | Branch (150:18): [True: 1.48k, False: 43] ------------------ 151| 1.48k| flags.esi_remove_bom = 1; 152| | 153| | /* Setup ws */ 154| 1.59k| WS_Init(ws, "req", ws_buf, sizeof ws_buf); 155| | 156| | /* Setup req */ 157| 1.59k| INIT_OBJ(req, HTTP_MAGIC); ------------------ | | 15| 1.59k| do { \ | | 16| 1.59k| (void)memset(to, 0, sizeof *(to)); \ | | 17| 1.59k| (to)->magic = (type_magic); \ | | 18| 1.59k| } while (0) | | ------------------ | | | Branch (18:11): [Folded, False: 1.59k] | | ------------------ ------------------ 158| 1.59k| req->hd = hd; 159| 1.59k| req->hd[HTTP_HDR_URL].b = "/"; 160| 1.59k| req->ws = ws; 161| | 162| | /* Setup resp */ 163| 1.59k| INIT_OBJ(resp, HTTP_MAGIC); ------------------ | | 15| 1.59k| do { \ | | 16| 1.59k| (void)memset(to, 0, sizeof *(to)); \ | | 17| 1.59k| (to)->magic = (type_magic); \ | | 18| 1.59k| } while (0) | | ------------------ | | | Branch (18:11): [Folded, False: 1.59k] | | ------------------ ------------------ 164| 1.59k| resp->ws = ws; 165| | 166| | /* Setup wrk */ 167| 1.59k| INIT_OBJ(wrk, WORKER_MAGIC); ------------------ | | 15| 1.59k| do { \ | | 16| 1.59k| (void)memset(to, 0, sizeof *(to)); \ | | 17| 1.59k| (to)->magic = (type_magic); \ | | 18| 1.59k| } while (0) | | ------------------ | | | Branch (18:11): [Folded, False: 1.59k] | | ------------------ ------------------ 168| | 169| | /* Setup vc */ 170| 1.59k| INIT_OBJ(vc, VFP_CTX_MAGIC); ------------------ | | 15| 1.59k| do { \ | | 16| 1.59k| (void)memset(to, 0, sizeof *(to)); \ | | 17| 1.59k| (to)->magic = (type_magic); \ | | 18| 1.59k| } while (0) | | ------------------ | | | Branch (18:11): [Folded, False: 1.59k] | | ------------------ ------------------ 171| 1.59k| vc->wrk = wrk; 172| 1.59k| vc->resp = resp; 173| | 174| 1.59k| vep = VEP_Init(vc, req, NULL, NULL, flags); 175| | 176| 1.59k| AN(vep); ------------------ | | 84| 1.59k|#define AN(foo) do { assert((foo) != 0); } while (0) | | ------------------ | | | | 65| 1.59k|#define assert(e) \ | | | | 66| 1.59k|do { \ | | | | 67| 1.59k| if (!(e)) { \ | | | | ------------------ | | | | | Branch (67:6): [True: 0, False: 1.59k] | | | | ------------------ | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | 69| 0| #e, VAS_ASSERT); \ | | | | 70| 0| } \ | | | | 71| 1.59k|} while (0) | | | | ------------------ | | | | | Branch (71:10): [Folded, False: 1.59k] | | | | ------------------ | | ------------------ | | | Branch (84:52): [Folded, False: 1.59k] | | ------------------ ------------------ 177| 1.59k| VEP_Parse(vep, (const char *)data, size); 178| 1.59k| vsb = VEP_Finish(vep); 179| 1.59k| if (vsb != NULL) ------------------ | Branch (179:6): [True: 1.10k, False: 486] ------------------ 180| 1.10k| VSB_destroy(&vsb); 181| 1.59k| WS_Rollback(ws, 0); 182| | 183| 1.59k| return (0); 184| 1.59k|} cache_ws_emu.c:pdiff: 143| 9.56k|{ 144| | 145| 9.56k| AN(b); ------------------ | | 84| 9.56k|#define AN(foo) do { assert((foo) != 0); } while (0) | | ------------------ | | | | 65| 9.56k|#define assert(e) \ | | | | 66| 9.56k|do { \ | | | | 67| 9.56k| if (!(e)) { \ | | | | ------------------ | | | | | Branch (67:6): [True: 0, False: 9.56k] | | | | ------------------ | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | 69| 0| #e, VAS_ASSERT); \ | | | | 70| 0| } \ | | | | 71| 9.56k|} while (0) | | | | ------------------ | | | | | Branch (71:10): [Folded, False: 9.56k] | | | | ------------------ | | ------------------ | | | Branch (84:52): [Folded, False: 9.56k] | | ------------------ ------------------ 146| 9.56k| AN(e); ------------------ | | 84| 9.56k|#define AN(foo) do { assert((foo) != 0); } while (0) | | ------------------ | | | | 65| 9.56k|#define assert(e) \ | | | | 66| 9.56k|do { \ | | | | 67| 9.56k| if (!(e)) { \ | | | | ------------------ | | | | | Branch (67:6): [True: 0, False: 9.56k] | | | | ------------------ | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | 69| 0| #e, VAS_ASSERT); \ | | | | 70| 0| } \ | | | | 71| 9.56k|} while (0) | | | | ------------------ | | | | | Branch (71:10): [Folded, False: 9.56k] | | | | ------------------ | | ------------------ | | | Branch (84:52): [Folded, False: 9.56k] | | ------------------ ------------------ 147| 9.56k| assert(b <= e); ------------------ | | 65| 9.56k|#define assert(e) \ | | 66| 9.56k|do { \ | | 67| 9.56k| if (!(e)) { \ | | ------------------ | | | Branch (67:6): [True: 0, False: 9.56k] | | ------------------ | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | 69| 0| #e, VAS_ASSERT); \ | | 70| 0| } \ | | 71| 9.56k|} while (0) | | ------------------ | | | Branch (71:10): [Folded, False: 9.56k] | | ------------------ ------------------ 148| 9.56k| return ((size_t)((const char *)e - (const char *)b)); 149| 9.56k|} cache_esi_parse.c:vct_is: 63| 29.0M|{ 64| | 65| 29.0M| x &= 0xff; 66| 29.0M| return (vct_typtab[x] & (y)); 67| 29.0M|} cache_esi_parse.c:vbe16enc: 93| 1.37k|{ 94| 1.37k| uint8_t *p = (uint8_t *)pp; 95| | 96| 1.37k| p[0] = (u >> 8) & 0xff; 97| 1.37k| p[1] = u & 0xff; 98| 1.37k|} cache_esi_parse.c:vbe16dec: 41| 1.37k|{ 42| 1.37k| uint8_t const *p = (uint8_t const *)pp; 43| | 44| 1.37k| return ((p[0] << 8) | p[1]); 45| 1.37k|} cache_esi_parse.c:vbe64enc: 113| 148|{ 114| 148| uint8_t *p = (uint8_t *)pp; 115| | 116| 148| vbe32enc(p, (uint32_t)(u >> 32)); 117| 148| vbe32enc(p + 4, (uint32_t)(u & 0xffffffffU)); 118| 148|} cache_esi_parse.c:vbe32enc: 102| 296|{ 103| 296| uint8_t *p = (uint8_t *)pp; 104| | 105| 296| p[0] = (u >> 24) & 0xff; 106| 296| p[1] = (u >> 16) & 0xff; 107| 296| p[2] = (u >> 8) & 0xff; 108| 296| p[3] = u & 0xff; 109| 296|} cache_esi_parse.c:vbe64dec: 57| 148|{ 58| 148| uint8_t const *p = (uint8_t const *)pp; 59| | 60| 148| return (((uint64_t)vbe32dec(p) << 32) | vbe32dec(p + 4)); 61| 148|} cache_esi_parse.c:vbe32dec: 49| 296|{ 50| 296| uint8_t const *p = (uint8_t const *)pp; 51| | 52| 296| return (((unsigned)p[0] << 24) | (p[1] << 16) | (p[2] << 8) | p[3]); 53| 296|} z_crc32_z: 695| 710k| z_size_t len) { 696| | /* Return initial CRC, if requested. */ 697| 710k| if (buf == Z_NULL) return 0; ------------------ | | 217| 710k|#define Z_NULL 0 /* for initializing zalloc, zfree, opaque */ ------------------ | Branch (697:9): [True: 302k, False: 408k] ------------------ 698| | 699| |#ifdef DYNAMIC_CRC_TABLE 700| | once(&made, make_crc_table); 701| |#endif /* DYNAMIC_CRC_TABLE */ 702| | 703| | /* Pre-condition the CRC */ 704| 408k| crc = (~crc) & 0xffffffff; 705| | 706| 408k|#ifdef W 707| | 708| | /* If provided enough bytes, do a braided CRC calculation. */ 709| 408k| if (len >= N * W + W - 1) { ------------------ | | 57| 408k|# define N 5 ------------------ if (len >= N * W + W - 1) { ------------------ | | 83| 408k|# define W 8 ------------------ if (len >= N * W + W - 1) { ------------------ | | 83| 408k|# define W 8 ------------------ | Branch (709:9): [True: 10.2k, False: 398k] ------------------ 710| 10.2k| z_size_t blks; 711| 10.2k| z_word_t const *words; 712| 10.2k| unsigned endian; 713| 10.2k| int k; 714| | 715| | /* Compute the CRC up to a z_word_t boundary. */ 716| 44.2k| while (len && ((z_size_t)buf & (W - 1)) != 0) { ------------------ | | 83| 44.2k|# define W 8 ------------------ | Branch (716:16): [True: 44.2k, False: 0] | Branch (716:23): [True: 34.0k, False: 10.2k] ------------------ 717| 34.0k| len--; 718| 34.0k| crc = (crc >> 8) ^ crc_table[(crc ^ *buf++) & 0xff]; 719| 34.0k| } 720| | 721| | /* Compute the CRC on as many N z_word_t blocks as are available. */ 722| 10.2k| blks = len / (N * W); ------------------ | | 57| 10.2k|# define N 5 ------------------ blks = len / (N * W); ------------------ | | 83| 10.2k|# define W 8 ------------------ 723| 10.2k| len -= blks * N * W; ------------------ | | 57| 10.2k|# define N 5 ------------------ len -= blks * N * W; ------------------ | | 83| 10.2k|# define W 8 ------------------ 724| 10.2k| words = (z_word_t const *)(intptr_t)buf; 725| | 726| | /* Do endian check at execution time instead of compile time, since ARM 727| | processors can change the endianness at execution time. If the 728| | compiler knows what the endianness will be, it can optimize out the 729| | check and the unused branch. */ 730| 10.2k| endian = 1; 731| 10.2k| if (*(unsigned char *)&endian) { ------------------ | Branch (731:13): [True: 10.2k, False: 0] ------------------ 732| | /* Little endian. */ 733| | 734| 10.2k| z_crc_t crc0; 735| 10.2k| z_word_t word0; 736| 10.2k|#if N > 1 737| 10.2k| z_crc_t crc1; 738| 10.2k| z_word_t word1; 739| 10.2k|#if N > 2 740| 10.2k| z_crc_t crc2; 741| 10.2k| z_word_t word2; 742| 10.2k|#if N > 3 743| 10.2k| z_crc_t crc3; 744| 10.2k| z_word_t word3; 745| 10.2k|#if N > 4 746| 10.2k| z_crc_t crc4; 747| 10.2k| z_word_t word4; 748| |#if N > 5 749| | z_crc_t crc5; 750| | z_word_t word5; 751| |#endif 752| 10.2k|#endif 753| 10.2k|#endif 754| 10.2k|#endif 755| 10.2k|#endif 756| | 757| | /* Initialize the CRC for each braid. */ 758| 10.2k| crc0 = crc; 759| 10.2k|#if N > 1 760| 10.2k| crc1 = 0; 761| 10.2k|#if N > 2 762| 10.2k| crc2 = 0; 763| 10.2k|#if N > 3 764| 10.2k| crc3 = 0; 765| 10.2k|#if N > 4 766| 10.2k| crc4 = 0; 767| |#if N > 5 768| | crc5 = 0; 769| |#endif 770| 10.2k|#endif 771| 10.2k|#endif 772| 10.2k|#endif 773| 10.2k|#endif 774| | 775| | /* 776| | Process the first blks-1 blocks, computing the CRCs on each braid 777| | independently. 778| | */ 779| 1.31M| while (--blks) { ------------------ | Branch (779:20): [True: 1.30M, False: 10.2k] ------------------ 780| | /* Load the word for each braid into registers. */ 781| 1.30M| word0 = crc0 ^ words[0]; 782| 1.30M|#if N > 1 783| 1.30M| word1 = crc1 ^ words[1]; 784| 1.30M|#if N > 2 785| 1.30M| word2 = crc2 ^ words[2]; 786| 1.30M|#if N > 3 787| 1.30M| word3 = crc3 ^ words[3]; 788| 1.30M|#if N > 4 789| 1.30M| word4 = crc4 ^ words[4]; 790| |#if N > 5 791| | word5 = crc5 ^ words[5]; 792| |#endif 793| 1.30M|#endif 794| 1.30M|#endif 795| 1.30M|#endif 796| 1.30M|#endif 797| 1.30M| words += N; ------------------ | | 57| 1.30M|# define N 5 ------------------ 798| | 799| | /* Compute and update the CRC for each word. The loop should 800| | get unrolled. */ 801| 1.30M| crc0 = crc_braid_table[0][word0 & 0xff]; 802| 1.30M|#if N > 1 803| 1.30M| crc1 = crc_braid_table[0][word1 & 0xff]; 804| 1.30M|#if N > 2 805| 1.30M| crc2 = crc_braid_table[0][word2 & 0xff]; 806| 1.30M|#if N > 3 807| 1.30M| crc3 = crc_braid_table[0][word3 & 0xff]; 808| 1.30M|#if N > 4 809| 1.30M| crc4 = crc_braid_table[0][word4 & 0xff]; 810| |#if N > 5 811| | crc5 = crc_braid_table[0][word5 & 0xff]; 812| |#endif 813| 1.30M|#endif 814| 1.30M|#endif 815| 1.30M|#endif 816| 1.30M|#endif 817| 10.4M| for (k = 1; k < W; k++) { ------------------ | | 83| 10.4M|# define W 8 ------------------ | Branch (817:29): [True: 9.12M, False: 1.30M] ------------------ 818| 9.12M| crc0 ^= crc_braid_table[k][(word0 >> (k << 3)) & 0xff]; 819| 9.12M|#if N > 1 820| 9.12M| crc1 ^= crc_braid_table[k][(word1 >> (k << 3)) & 0xff]; 821| 9.12M|#if N > 2 822| 9.12M| crc2 ^= crc_braid_table[k][(word2 >> (k << 3)) & 0xff]; 823| 9.12M|#if N > 3 824| 9.12M| crc3 ^= crc_braid_table[k][(word3 >> (k << 3)) & 0xff]; 825| 9.12M|#if N > 4 826| 9.12M| crc4 ^= crc_braid_table[k][(word4 >> (k << 3)) & 0xff]; 827| |#if N > 5 828| | crc5 ^= crc_braid_table[k][(word5 >> (k << 3)) & 0xff]; 829| |#endif 830| 9.12M|#endif 831| 9.12M|#endif 832| 9.12M|#endif 833| 9.12M|#endif 834| 9.12M| } 835| 1.30M| } 836| | 837| | /* 838| | Process the last block, combining the CRCs of the N braids at the 839| | same time. 840| | */ 841| 10.2k| crc = crc_word(crc0 ^ words[0]); 842| 10.2k|#if N > 1 843| 10.2k| crc = crc_word(crc1 ^ words[1] ^ crc); 844| 10.2k|#if N > 2 845| 10.2k| crc = crc_word(crc2 ^ words[2] ^ crc); 846| 10.2k|#if N > 3 847| 10.2k| crc = crc_word(crc3 ^ words[3] ^ crc); 848| 10.2k|#if N > 4 849| 10.2k| crc = crc_word(crc4 ^ words[4] ^ crc); 850| |#if N > 5 851| | crc = crc_word(crc5 ^ words[5] ^ crc); 852| |#endif 853| 10.2k|#endif 854| 10.2k|#endif 855| 10.2k|#endif 856| 10.2k|#endif 857| 10.2k| words += N; ------------------ | | 57| 10.2k|# define N 5 ------------------ 858| 10.2k| } 859| 0| else { 860| | /* Big endian. */ 861| | 862| 0| z_word_t crc0, word0, comb; 863| 0|#if N > 1 864| 0| z_word_t crc1, word1; 865| 0|#if N > 2 866| 0| z_word_t crc2, word2; 867| 0|#if N > 3 868| 0| z_word_t crc3, word3; 869| 0|#if N > 4 870| 0| z_word_t crc4, word4; 871| |#if N > 5 872| | z_word_t crc5, word5; 873| |#endif 874| 0|#endif 875| 0|#endif 876| 0|#endif 877| 0|#endif 878| | 879| | /* Initialize the CRC for each braid. */ 880| 0| crc0 = byte_swap(crc); 881| 0|#if N > 1 882| 0| crc1 = 0; 883| 0|#if N > 2 884| 0| crc2 = 0; 885| 0|#if N > 3 886| 0| crc3 = 0; 887| 0|#if N > 4 888| 0| crc4 = 0; 889| |#if N > 5 890| | crc5 = 0; 891| |#endif 892| 0|#endif 893| 0|#endif 894| 0|#endif 895| 0|#endif 896| | 897| | /* 898| | Process the first blks-1 blocks, computing the CRCs on each braid 899| | independently. 900| | */ 901| 0| while (--blks) { ------------------ | Branch (901:20): [True: 0, False: 0] ------------------ 902| | /* Load the word for each braid into registers. */ 903| 0| word0 = crc0 ^ words[0]; 904| 0|#if N > 1 905| 0| word1 = crc1 ^ words[1]; 906| 0|#if N > 2 907| 0| word2 = crc2 ^ words[2]; 908| 0|#if N > 3 909| 0| word3 = crc3 ^ words[3]; 910| 0|#if N > 4 911| 0| word4 = crc4 ^ words[4]; 912| |#if N > 5 913| | word5 = crc5 ^ words[5]; 914| |#endif 915| 0|#endif 916| 0|#endif 917| 0|#endif 918| 0|#endif 919| 0| words += N; ------------------ | | 57| 0|# define N 5 ------------------ 920| | 921| | /* Compute and update the CRC for each word. The loop should 922| | get unrolled. */ 923| 0| crc0 = crc_braid_big_table[0][word0 & 0xff]; 924| 0|#if N > 1 925| 0| crc1 = crc_braid_big_table[0][word1 & 0xff]; 926| 0|#if N > 2 927| 0| crc2 = crc_braid_big_table[0][word2 & 0xff]; 928| 0|#if N > 3 929| 0| crc3 = crc_braid_big_table[0][word3 & 0xff]; 930| 0|#if N > 4 931| 0| crc4 = crc_braid_big_table[0][word4 & 0xff]; 932| |#if N > 5 933| | crc5 = crc_braid_big_table[0][word5 & 0xff]; 934| |#endif 935| 0|#endif 936| 0|#endif 937| 0|#endif 938| 0|#endif 939| 0| for (k = 1; k < W; k++) { ------------------ | | 83| 0|# define W 8 ------------------ | Branch (939:29): [True: 0, False: 0] ------------------ 940| 0| crc0 ^= crc_braid_big_table[k][(word0 >> (k << 3)) & 0xff]; 941| 0|#if N > 1 942| 0| crc1 ^= crc_braid_big_table[k][(word1 >> (k << 3)) & 0xff]; 943| 0|#if N > 2 944| 0| crc2 ^= crc_braid_big_table[k][(word2 >> (k << 3)) & 0xff]; 945| 0|#if N > 3 946| 0| crc3 ^= crc_braid_big_table[k][(word3 >> (k << 3)) & 0xff]; 947| 0|#if N > 4 948| 0| crc4 ^= crc_braid_big_table[k][(word4 >> (k << 3)) & 0xff]; 949| |#if N > 5 950| | crc5 ^= crc_braid_big_table[k][(word5 >> (k << 3)) & 0xff]; 951| |#endif 952| 0|#endif 953| 0|#endif 954| 0|#endif 955| 0|#endif 956| 0| } 957| 0| } 958| | 959| | /* 960| | Process the last block, combining the CRCs of the N braids at the 961| | same time. 962| | */ 963| 0| comb = crc_word_big(crc0 ^ words[0]); 964| 0|#if N > 1 965| 0| comb = crc_word_big(crc1 ^ words[1] ^ comb); 966| 0|#if N > 2 967| 0| comb = crc_word_big(crc2 ^ words[2] ^ comb); 968| 0|#if N > 3 969| 0| comb = crc_word_big(crc3 ^ words[3] ^ comb); 970| 0|#if N > 4 971| 0| comb = crc_word_big(crc4 ^ words[4] ^ comb); 972| |#if N > 5 973| | comb = crc_word_big(crc5 ^ words[5] ^ comb); 974| |#endif 975| 0|#endif 976| 0|#endif 977| 0|#endif 978| 0|#endif 979| 0| words += N; ------------------ | | 57| 0|# define N 5 ------------------ 980| 0| crc = byte_swap(comb); 981| 0| } 982| | 983| | /* 984| | Update the pointer to the remaining bytes to process. 985| | */ 986| 10.2k| buf = (unsigned char const *)words; 987| 10.2k| } 988| | 989| 408k|#endif /* W */ 990| | 991| | /* Complete the computation of the CRC on any remaining bytes. */ 992| 490k| while (len >= 8) { ------------------ | Branch (992:12): [True: 81.5k, False: 408k] ------------------ 993| 81.5k| len -= 8; 994| 81.5k| crc = (crc >> 8) ^ crc_table[(crc ^ *buf++) & 0xff]; 995| 81.5k| crc = (crc >> 8) ^ crc_table[(crc ^ *buf++) & 0xff]; 996| 81.5k| crc = (crc >> 8) ^ crc_table[(crc ^ *buf++) & 0xff]; 997| 81.5k| crc = (crc >> 8) ^ crc_table[(crc ^ *buf++) & 0xff]; 998| 81.5k| crc = (crc >> 8) ^ crc_table[(crc ^ *buf++) & 0xff]; 999| 81.5k| crc = (crc >> 8) ^ crc_table[(crc ^ *buf++) & 0xff]; 1000| 81.5k| crc = (crc >> 8) ^ crc_table[(crc ^ *buf++) & 0xff]; 1001| 81.5k| crc = (crc >> 8) ^ crc_table[(crc ^ *buf++) & 0xff]; 1002| 81.5k| } 1003| 1.67M| while (len) { ------------------ | Branch (1003:12): [True: 1.26M, False: 408k] ------------------ 1004| 1.26M| len--; 1005| 1.26M| crc = (crc >> 8) ^ crc_table[(crc ^ *buf++) & 0xff]; 1006| 1.26M| } 1007| | 1008| | /* Return the CRC, post-conditioned. */ 1009| 408k| return crc ^ 0xffffffff; 1010| 710k|} z_crc32: 1016| 710k| uInt len) { 1017| 710k| return crc32_z(crc, buf, len); ------------------ | | 44| 710k|# define crc32_z z_crc32_z ------------------ 1018| 710k|} z_crc32_combine64: 1021| 147|uLong ZEXPORT crc32_combine64(uLong crc1, uLong crc2, z_off64_t len2) { 1022| |#ifdef DYNAMIC_CRC_TABLE 1023| | once(&made, make_crc_table); 1024| |#endif /* DYNAMIC_CRC_TABLE */ 1025| 147| return multmodp(x2nmodp(len2, 3), crc1) ^ (crc2 & 0xffffffff); 1026| 147|} z_crc32_combine: 1029| 147|uLong ZEXPORT crc32_combine(uLong crc1, uLong crc2, z_off_t len2) { 1030| 147| return crc32_combine64(crc1, crc2, (z_off64_t)len2); ------------------ | | 40| 147|# define crc32_combine64 z_crc32_combine64 ------------------ 1031| 147|} crc32.c:crc_word: 676| 51.2k|local z_crc_t crc_word (z_word_t data) { 677| 51.2k| int k; 678| 461k| for (k = 0; k < W; k++) ------------------ | | 83| 461k|# define W 8 ------------------ | Branch (678:17): [True: 410k, False: 51.2k] ------------------ 679| 410k| data = (data >> 8) ^ crc_table[data & 0xff]; 680| 51.2k| return (z_crc_t)data; 681| 51.2k|} crc32.c:multmodp: 155| 708|local z_crc_t multmodp(z_crc_t a, z_crc_t b) { 156| 708| z_crc_t m, p; 157| | 158| 708| m = (z_crc_t)1 << 31; 159| 708| p = 0; 160| 16.5k| for (;;) { 161| 16.5k| if (a & m) { ------------------ | Branch (161:13): [True: 7.40k, False: 9.19k] ------------------ 162| 7.40k| p ^= b; 163| 7.40k| if ((a & (m - 1)) == 0) ------------------ | Branch (163:17): [True: 708, False: 6.69k] ------------------ 164| 708| break; 165| 7.40k| } 166| 15.8k| m >>= 1; 167| 15.8k| b = b & 1 ? (b >> 1) ^ POLY : b >> 1; ------------------ | | 149| 6.72k|#define POLY 0xedb88320 /* p(x) reflected, with x^32 implied */ ------------------ | Branch (167:13): [True: 6.72k, False: 9.15k] ------------------ 168| 15.8k| } 169| 708| return p; 170| 708|} crc32.c:x2nmodp: 176| 147|local z_crc_t x2nmodp(z_off64_t n, unsigned k) { 177| 147| z_crc_t p; 178| | 179| 147| p = (z_crc_t)1 << 31; /* x^0 == 1 */ 180| 862| while (n) { ------------------ | Branch (180:12): [True: 715, False: 147] ------------------ 181| 715| if (n & 1) ------------------ | Branch (181:13): [True: 561, False: 154] ------------------ 182| 561| p = multmodp(x2n_table[k & 31], p); 183| 715| n >>= 1; 184| 715| k++; 185| 715| } 186| 147| return p; 187| 147|} VSB_new_auto: 227| 24.9k|{ 228| 24.9k| struct vsb *s; 229| | 230| 24.9k| s = SBMALLOC(sizeof(*s)); ------------------ | | 47| 24.9k|#define SBMALLOC(size) malloc(size) ------------------ 231| 24.9k| if (s == NULL) ------------------ | Branch (231:6): [True: 0, False: 24.9k] ------------------ 232| 0| return (NULL); 233| 24.9k| if (VSB_newbuf(s, NULL, 0, VSB_AUTOEXTEND) == NULL) { ------------------ | | 47| 24.9k|#define VSB_AUTOEXTEND 0x00000001 /* automatically extend buffer */ ------------------ | Branch (233:6): [True: 0, False: 24.9k] ------------------ 234| 0| SBFREE(s); ------------------ | | 48| 0|#define SBFREE(buf) free(buf) ------------------ 235| 0| return (NULL); 236| 0| } 237| 24.9k| VSB_SETFLAG(s, VSB_DYNSTRUCT); ------------------ | | 64| 24.9k|#define VSB_SETFLAG(s, f) do { (s)->s_flags |= (f); } while (0) | | ------------------ | | | Branch (64:62): [Folded, False: 24.9k] | | ------------------ ------------------ 238| 24.9k| return (s); 239| 24.9k|} VSB_bcat: 286| 298k|{ 287| 298k| assert_VSB_integrity(s); ------------------ | | 108| 298k|#define assert_VSB_integrity(s) _assert_VSB_integrity(__func__, (s)) ------------------ 288| 298k| assert_VSB_state(s, 0); ------------------ | | 109| 298k|#define assert_VSB_state(s, i) _assert_VSB_state(__func__, (s), (i)) ------------------ 289| | 290| 298k| assert(len >= 0); ------------------ | | 65| 298k|#define assert(e) \ | | 66| 298k|do { \ | | 67| 298k| if (!(e)) { \ | | ------------------ | | | Branch (67:6): [True: 0, False: 298k] | | ------------------ | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | 69| 0| #e, VAS_ASSERT); \ | | 70| 0| } \ | | 71| 298k|} while (0) | | ------------------ | | | Branch (71:10): [Folded, False: 298k] | | ------------------ ------------------ 291| 298k| if (s->s_error != 0) ------------------ | Branch (291:6): [True: 0, False: 298k] ------------------ 292| 0| return (-1); 293| 298k| if (len == 0) ------------------ | Branch (293:6): [True: 0, False: 298k] ------------------ 294| 0| return (0); 295| 298k| _vsb_indent(s); 296| 298k| if (len > VSB_FREESPACE(s)) { ------------------ | | 58| 298k|#define VSB_FREESPACE(s) ((s)->s_size - ((s)->s_len + 1L)) ------------------ | Branch (296:6): [True: 915, False: 297k] ------------------ 297| 915| if (VSB_extend(s, len - VSB_FREESPACE(s)) < 0) ------------------ | | 58| 915|#define VSB_FREESPACE(s) ((s)->s_size - ((s)->s_len + 1L)) ------------------ | Branch (297:7): [True: 0, False: 915] ------------------ 298| 0| s->s_error = ENOMEM; 299| 915| if (s->s_error != 0) ------------------ | Branch (299:7): [True: 0, False: 915] ------------------ 300| 0| return (-1); 301| 915| } 302| 298k| memcpy(s->s_buf + s->s_len, buf, len); 303| 298k| s->s_len += len; 304| 298k| return (0); 305| 298k|} VSB_vprintf: 340| 4.75M|{ 341| 4.75M| va_list ap_copy; 342| 4.75M| int len; 343| | 344| 4.75M| assert_VSB_integrity(s); ------------------ | | 108| 4.75M|#define assert_VSB_integrity(s) _assert_VSB_integrity(__func__, (s)) ------------------ 345| 4.75M| assert_VSB_state(s, 0); ------------------ | | 109| 4.75M|#define assert_VSB_state(s, i) _assert_VSB_state(__func__, (s), (i)) ------------------ 346| | 347| 4.75M| KASSERT(fmt != NULL, ------------------ | | 46| 4.75M|#define KASSERT(e, m) assert(e) | | ------------------ | | | | 65| 4.75M|#define assert(e) \ | | | | 66| 4.75M|do { \ | | | | 67| 4.75M| if (!(e)) { \ | | | | ------------------ | | | | | Branch (67:6): [True: 0, False: 4.75M] | | | | ------------------ | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | 69| 0| #e, VAS_ASSERT); \ | | | | 70| 0| } \ | | | | 71| 4.75M|} while (0) | | | | ------------------ | | | | | Branch (71:10): [Folded, False: 4.75M] | | | | ------------------ | | ------------------ ------------------ 348| 4.75M| ("%s called with a NULL format string", __func__)); 349| | 350| 4.75M| if (s->s_error != 0) ------------------ | Branch (350:6): [True: 0, False: 4.75M] ------------------ 351| 0| return (-1); 352| 4.75M| _vsb_indent(s); 353| | 354| | /* 355| | * For the moment, there is no way to get vsnprintf(3) to hand 356| | * back a character at a time, to push everything into 357| | * VSB_putc_func() as was done for the kernel. 358| | * 359| | * In userspace, while drains are useful, there's generally 360| | * not a problem attempting to malloc(3) on out of space. So 361| | * expand a userland vsb if there is not enough room for the 362| | * data produced by VSB_[v]printf(3). 363| | */ 364| | 365| 4.75M| do { 366| 4.75M| va_copy(ap_copy, ap); 367| 4.75M| len = vsnprintf(&s->s_buf[s->s_len], VSB_FREESPACE(s) + 1, ------------------ | | 58| 4.75M|#define VSB_FREESPACE(s) ((s)->s_size - ((s)->s_len + 1L)) ------------------ 368| 4.75M| fmt, ap_copy); 369| 4.75M| va_end(ap_copy); 370| 4.75M| if (len < 0) { ------------------ | Branch (370:7): [True: 0, False: 4.75M] ------------------ 371| 0| s->s_error = errno; 372| 0| return (-1); 373| 0| } 374| 4.75M| } while (len > VSB_FREESPACE(s) && ------------------ | | 58| 9.51M|#define VSB_FREESPACE(s) ((s)->s_size - ((s)->s_len + 1L)) ------------------ | Branch (374:11): [True: 2.18k, False: 4.75M] ------------------ 375| 2.18k| VSB_extend(s, len - VSB_FREESPACE(s)) == 0); ------------------ | | 58| 2.18k|#define VSB_FREESPACE(s) ((s)->s_size - ((s)->s_len + 1L)) ------------------ | Branch (375:6): [True: 2.18k, False: 0] ------------------ 376| | 377| | /* 378| | * s->s_len is the length of the string, without the terminating nul. 379| | * When updating s->s_len, we must subtract 1 from the length that 380| | * we passed into vsnprintf() because that length includes the 381| | * terminating nul. 382| | * 383| | * vsnprintf() returns the amount that would have been copied, 384| | * given sufficient space, so don't over-increment s_len. 385| | */ 386| 4.75M| s->s_len += vmin_t(ssize_t, len, VSB_FREESPACE(s)); ------------------ | | 206| 4.75M|#define vmin_t(type, a, b) vtake(min, type, type, a, b) | | ------------------ | | | | 200| 4.75M|#define vtake(n, ta, tb, a, b) _vtake(op ## n, ta, tb, a, b, \ | | | | ------------------ | | | | | | 191| 4.75M| ({ \ | | | | | | 192| 4.75M| ta _va = (a); \ | | | | | | 193| 4.75M| tb _vb = (b); \ | | | | | | 194| 4.75M| (void)(&_va == &_vb); \ | | | | | | 195| 4.75M| _va op _vb ? _va : _vb; \ | | | | | | ------------------ | | | | | | | Branch (195:2): [True: 4.75M, False: 2.05k] | | | | | | ------------------ | | | | | | 196| 4.75M|}) | | | | ------------------ | | | | 201| 4.75M| VUNIQ_NAME(_v ## n ## A), VUNIQ_NAME(_v ## n ## B)) | | ------------------ ------------------ 387| 4.75M| if (!VSB_HASROOM(s) && !VSB_CANEXTEND(s)) ------------------ | | 57| 9.51M|#define VSB_HASROOM(s) ((s)->s_len < (s)->s_size - 1L) ------------------ if (!VSB_HASROOM(s) && !VSB_CANEXTEND(s)) ------------------ | | 59| 2.05k|#define VSB_CANEXTEND(s) ((s)->s_flags & VSB_AUTOEXTEND) | | ------------------ | | | | 47| 2.05k|#define VSB_AUTOEXTEND 0x00000001 /* automatically extend buffer */ | | ------------------ ------------------ | Branch (387:6): [True: 2.05k, False: 4.75M] | Branch (387:25): [True: 0, False: 2.05k] ------------------ 388| 0| s->s_error = ENOMEM; 389| | 390| 4.75M| KASSERT(s->s_len < s->s_size, ------------------ | | 46| 4.75M|#define KASSERT(e, m) assert(e) | | ------------------ | | | | 65| 4.75M|#define assert(e) \ | | | | 66| 4.75M|do { \ | | | | 67| 4.75M| if (!(e)) { \ | | | | ------------------ | | | | | Branch (67:6): [True: 0, False: 4.75M] | | | | ------------------ | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | 69| 0| #e, VAS_ASSERT); \ | | | | 70| 0| } \ | | | | 71| 4.75M|} while (0) | | | | ------------------ | | | | | Branch (71:10): [Folded, False: 4.75M] | | | | ------------------ | | ------------------ ------------------ 391| 4.75M| ("wrote past end of vsb (%d >= %d)", s->s_len, s->s_size)); 392| | 393| 4.75M| if (s->s_error != 0) ------------------ | Branch (393:6): [True: 0, False: 4.75M] ------------------ 394| 0| return (-1); 395| 4.75M| return (0); 396| 4.75M|} VSB_printf: 403| 4.75M|{ 404| 4.75M| va_list ap; 405| 4.75M| int result; 406| | 407| 4.75M| va_start(ap, fmt); 408| 4.75M| result = VSB_vprintf(s, fmt, ap); 409| | va_end(ap); 410| 4.75M| return (result); 411| 4.75M|} VSB_putc: 418| 16.9M|{ 419| | 420| 16.9M| VSB_put_byte(s, c); 421| 16.9M| if (s->s_error != 0) ------------------ | Branch (421:6): [True: 0, False: 16.9M] ------------------ 422| 0| return (-1); 423| 16.9M| return (0); 424| 16.9M|} VSB_finish: 441| 23.7k|{ 442| | 443| 23.7k| assert_VSB_integrity(s); ------------------ | | 108| 23.7k|#define assert_VSB_integrity(s) _assert_VSB_integrity(__func__, (s)) ------------------ 444| 23.7k| assert_VSB_state(s, 0); ------------------ | | 109| 23.7k|#define assert_VSB_state(s, i) _assert_VSB_state(__func__, (s), (i)) ------------------ 445| | 446| 23.7k| s->s_buf[s->s_len] = '\0'; 447| 23.7k| VSB_SETFLAG(s, VSB_FINISHED); ------------------ | | 64| 23.7k|#define VSB_SETFLAG(s, f) do { (s)->s_flags |= (f); } while (0) | | ------------------ | | | Branch (64:62): [Folded, False: 23.7k] | | ------------------ ------------------ 448| 23.7k| errno = s->s_error; 449| 23.7k| if (s->s_error) ------------------ | Branch (449:6): [True: 0, False: 23.7k] ------------------ 450| 0| return (-1); 451| 23.7k| return (0); 452| 23.7k|} VSB_data: 459| 58.3k|{ 460| | 461| 58.3k| assert_VSB_integrity(s); ------------------ | | 108| 58.3k|#define assert_VSB_integrity(s) _assert_VSB_integrity(__func__, (s)) ------------------ 462| 58.3k| assert_VSB_state(s, VSB_FINISHED); ------------------ | | 109| 58.3k|#define assert_VSB_state(s, i) _assert_VSB_state(__func__, (s), (i)) ------------------ 463| | 464| 58.3k| return (s->s_buf); 465| 58.3k|} VSB_len: 472| 21.0k|{ 473| | 474| 21.0k| assert_VSB_integrity(s); ------------------ | | 108| 21.0k|#define assert_VSB_integrity(s) _assert_VSB_integrity(__func__, (s)) ------------------ 475| | /* don't care if it's finished or not */ 476| | 477| 21.0k| if (s->s_error != 0) ------------------ | Branch (477:6): [True: 0, False: 21.0k] ------------------ 478| 0| return (-1); 479| 21.0k| return (s->s_len); 480| 21.0k|} VSB_destroy: 494| 24.9k|{ 495| | 496| 24.9k| AN(s); ------------------ | | 84| 24.9k|#define AN(foo) do { assert((foo) != 0); } while (0) | | ------------------ | | | | 65| 24.9k|#define assert(e) \ | | | | 66| 24.9k|do { \ | | | | 67| 24.9k| if (!(e)) { \ | | | | ------------------ | | | | | Branch (67:6): [True: 0, False: 24.9k] | | | | ------------------ | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | 69| 0| #e, VAS_ASSERT); \ | | | | 70| 0| } \ | | | | 71| 24.9k|} while (0) | | | | ------------------ | | | | | Branch (71:10): [Folded, False: 24.9k] | | | | ------------------ | | ------------------ | | | Branch (84:52): [Folded, False: 24.9k] | | ------------------ ------------------ 497| 24.9k| assert_VSB_integrity(*s); ------------------ | | 108| 24.9k|#define assert_VSB_integrity(s) _assert_VSB_integrity(__func__, (s)) ------------------ 498| 24.9k| assert(VSB_ISDYNAMIC(*s)); ------------------ | | 65| 24.9k|#define assert(e) \ | | 66| 24.9k|do { \ | | 67| 24.9k| if (!(e)) { \ | | ------------------ | | | Branch (67:6): [True: 0, False: 24.9k] | | ------------------ | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | 69| 0| #e, VAS_ASSERT); \ | | 70| 0| } \ | | 71| 24.9k|} while (0) | | ------------------ | | | Branch (71:10): [Folded, False: 24.9k] | | ------------------ ------------------ 499| 24.9k| assert(VSB_ISDYNSTRUCT(*s)); ------------------ | | 65| 24.9k|#define assert(e) \ | | 66| 24.9k|do { \ | | 67| 24.9k| if (!(e)) { \ | | ------------------ | | | Branch (67:6): [True: 0, False: 24.9k] | | ------------------ | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | 69| 0| #e, VAS_ASSERT); \ | | 70| 0| } \ | | 71| 24.9k|} while (0) | | ------------------ | | | Branch (71:10): [Folded, False: 24.9k] | | ------------------ ------------------ 500| 24.9k| SBFREE((*s)->s_buf); ------------------ | | 48| 24.9k|#define SBFREE(buf) free(buf) ------------------ 501| 24.9k| memset(*s, 0, sizeof(**s)); 502| 24.9k| SBFREE(*s); ------------------ | | 48| 24.9k|#define SBFREE(buf) free(buf) ------------------ 503| | *s = NULL; 504| 24.9k|} vsb.c:VSB_newbuf: 185| 24.9k|{ 186| | 187| 24.9k| memset(s, 0, sizeof(*s)); 188| 24.9k| s->magic = VSB_MAGIC; ------------------ | | 41| 24.9k|#define VSB_MAGIC 0x4a82dd8a ------------------ 189| 24.9k| s->s_flags = flags; 190| 24.9k| s->s_size = length; 191| 24.9k| s->s_buf = buf; 192| | 193| 24.9k| if ((s->s_flags & VSB_AUTOEXTEND) == 0) { ------------------ | | 47| 24.9k|#define VSB_AUTOEXTEND 0x00000001 /* automatically extend buffer */ ------------------ | Branch (193:6): [True: 0, False: 24.9k] ------------------ 194| 0| KASSERT(s->s_size > 1, ------------------ | | 46| 0|#define KASSERT(e, m) assert(e) | | ------------------ | | | | 65| 0|#define assert(e) \ | | | | 66| 0|do { \ | | | | 67| 0| if (!(e)) { \ | | | | ------------------ | | | | | Branch (67:6): [True: 0, False: 0] | | | | ------------------ | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | 69| 0| #e, VAS_ASSERT); \ | | | | 70| 0| } \ | | | | 71| 0|} while (0) | | | | ------------------ | | | | | Branch (71:10): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 195| 0| ("attempt to create a too small vsb")); 196| 0| } 197| | 198| 24.9k| if (s->s_buf != NULL) ------------------ | Branch (198:6): [True: 0, False: 24.9k] ------------------ 199| 0| return (s); 200| | 201| 24.9k| if ((flags & VSB_AUTOEXTEND) != 0) ------------------ | | 47| 24.9k|#define VSB_AUTOEXTEND 0x00000001 /* automatically extend buffer */ ------------------ | Branch (201:6): [True: 24.9k, False: 0] ------------------ 202| 24.9k| s->s_size = VSB_extendsize(s->s_size); 203| | 204| 24.9k| s->s_buf = SBMALLOC(s->s_size); ------------------ | | 47| 24.9k|#define SBMALLOC(size) malloc(size) ------------------ 205| 24.9k| if (s->s_buf == NULL) ------------------ | Branch (205:6): [True: 0, False: 24.9k] ------------------ 206| 0| return (NULL); 207| 24.9k| VSB_SETFLAG(s, VSB_DYNAMIC); ------------------ | | 64| 24.9k|#define VSB_SETFLAG(s, f) do { (s)->s_flags |= (f); } while (0) | | ------------------ | | | Branch (64:62): [Folded, False: 24.9k] | | ------------------ ------------------ 208| 24.9k| return (s); 209| 24.9k|} vsb.c:VSB_extendsize: 122| 39.1k|{ 123| 39.1k| ssize_t newsize; 124| | 125| 39.1k| if (size < (int)VSB_MAXEXTENDSIZE) { ------------------ | | 73| 39.1k|#define VSB_MAXEXTENDSIZE 4096 ------------------ | Branch (125:6): [True: 33.9k, False: 5.14k] ------------------ 126| 33.9k| newsize = VSB_MINEXTENDSIZE; ------------------ | | 67| 33.9k|#define VSB_MINEXTENDSIZE 16 /* Should be power of 2. */ ------------------ 127| 61.7k| while (newsize < size) ------------------ | Branch (127:10): [True: 27.7k, False: 33.9k] ------------------ 128| 27.7k| newsize *= 2; 129| 33.9k| } else { 130| 5.14k| newsize = rndup2(size, VSB_MAXEXTENDINCR); ------------------ | | 50| 5.14k|#define rndup2(x, y) (((x)+((y)-1))&(~((y)-1))) /* if y is powers of two */ ------------------ 131| 5.14k| } 132| 39.1k| KASSERT(newsize >= size, ("%s: %d < %d\n", __func__, newsize, size)); ------------------ | | 46| 39.1k|#define KASSERT(e, m) assert(e) | | ------------------ | | | | 65| 39.1k|#define assert(e) \ | | | | 66| 39.1k|do { \ | | | | 67| 39.1k| if (!(e)) { \ | | | | ------------------ | | | | | Branch (67:6): [True: 0, False: 39.1k] | | | | ------------------ | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | 69| 0| #e, VAS_ASSERT); \ | | | | 70| 0| } \ | | | | 71| 39.1k|} while (0) | | | | ------------------ | | | | | Branch (71:10): [Folded, False: 39.1k] | | | | ------------------ | | ------------------ ------------------ 133| 39.1k| return (newsize); 134| 39.1k|} vsb.c:_assert_VSB_integrity: 83| 22.1M|{ 84| | 85| 22.1M| (void)fun; 86| 22.1M| (void)s; 87| 22.1M| KASSERT(s != NULL, ------------------ | | 46| 22.1M|#define KASSERT(e, m) assert(e) | | ------------------ | | | | 65| 22.1M|#define assert(e) \ | | | | 66| 22.1M|do { \ | | | | 67| 22.1M| if (!(e)) { \ | | | | ------------------ | | | | | Branch (67:6): [True: 0, False: 22.1M] | | | | ------------------ | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | 69| 0| #e, VAS_ASSERT); \ | | | | 70| 0| } \ | | | | 71| 22.1M|} while (0) | | | | ------------------ | | | | | Branch (71:10): [Folded, False: 22.1M] | | | | ------------------ | | ------------------ ------------------ 88| 22.1M| ("%s called with a NULL vsb pointer", fun)); 89| 22.1M| KASSERT(s->magic == VSB_MAGIC, ------------------ | | 46| 22.1M|#define KASSERT(e, m) assert(e) | | ------------------ | | | | 65| 22.1M|#define assert(e) \ | | | | 66| 22.1M|do { \ | | | | 67| 22.1M| if (!(e)) { \ | | | | ------------------ | | | | | Branch (67:6): [True: 0, False: 22.1M] | | | | ------------------ | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | 69| 0| #e, VAS_ASSERT); \ | | | | 70| 0| } \ | | | | 71| 22.1M|} while (0) | | | | ------------------ | | | | | Branch (71:10): [Folded, False: 22.1M] | | | | ------------------ | | ------------------ ------------------ 90| 22.1M| ("%s called with a bogus vsb pointer", fun)); 91| 22.1M| KASSERT(s->s_buf != NULL, ------------------ | | 46| 22.1M|#define KASSERT(e, m) assert(e) | | ------------------ | | | | 65| 22.1M|#define assert(e) \ | | | | 66| 22.1M|do { \ | | | | 67| 22.1M| if (!(e)) { \ | | | | ------------------ | | | | | Branch (67:6): [True: 0, False: 22.1M] | | | | ------------------ | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | 69| 0| #e, VAS_ASSERT); \ | | | | 70| 0| } \ | | | | 71| 22.1M|} while (0) | | | | ------------------ | | | | | Branch (71:10): [Folded, False: 22.1M] | | | | ------------------ | | ------------------ ------------------ 92| 22.1M| ("%s called with uninitialized or corrupt vsb", fun)); 93| 22.1M| KASSERT(s->s_len < s->s_size, ------------------ | | 46| 22.1M|#define KASSERT(e, m) assert(e) | | ------------------ | | | | 65| 22.1M|#define assert(e) \ | | | | 66| 22.1M|do { \ | | | | 67| 22.1M| if (!(e)) { \ | | | | ------------------ | | | | | Branch (67:6): [True: 0, False: 22.1M] | | | | ------------------ | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | 69| 0| #e, VAS_ASSERT); \ | | | | 70| 0| } \ | | | | 71| 22.1M|} while (0) | | | | ------------------ | | | | | Branch (71:10): [Folded, False: 22.1M] | | | | ------------------ | | ------------------ ------------------ 94| 22.1M| ("wrote past end of vsb (%d >= %d)", s->s_len, s->s_size)); 95| 22.1M|} vsb.c:_assert_VSB_state: 99| 22.0M|{ 100| | 101| 22.0M| (void)fun; 102| 22.0M| (void)s; 103| 22.0M| (void)state; 104| 22.0M| KASSERT((s->s_flags & VSB_FINISHED) == state, ------------------ | | 46| 22.0M|#define KASSERT(e, m) assert(e) | | ------------------ | | | | 65| 22.0M|#define assert(e) \ | | | | 66| 22.0M|do { \ | | | | 67| 22.0M| if (!(e)) { \ | | | | ------------------ | | | | | Branch (67:6): [True: 0, False: 22.0M] | | | | ------------------ | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | 69| 0| #e, VAS_ASSERT); \ | | | | 70| 0| } \ | | | | 71| 22.0M|} while (0) | | | | ------------------ | | | | | Branch (71:10): [Folded, False: 22.0M] | | | | ------------------ | | ------------------ ------------------ 105| 22.0M| ("%s called with %sfinished or corrupt vsb", fun, 106| 22.0M| (state ? "un" : ""))); 107| 22.0M|} vsb.c:_vsb_indent: 165| 21.9M|{ 166| 21.9M| if (s->s_indent == 0 || s->s_error != 0 || ------------------ | Branch (166:6): [True: 21.9M, False: 0] | Branch (166:26): [True: 0, False: 0] ------------------ 167| 0| (s->s_len > 0 && s->s_buf[s->s_len - 1] != '\n')) ------------------ | Branch (167:7): [True: 0, False: 0] | Branch (167:23): [True: 0, False: 0] ------------------ 168| 21.9M| return; 169| 0| if (VSB_FREESPACE(s) <= s->s_indent && ------------------ | | 58| 0|#define VSB_FREESPACE(s) ((s)->s_size - ((s)->s_len + 1L)) ------------------ | Branch (169:6): [True: 0, False: 0] ------------------ 170| 0| VSB_extend(s, s->s_indent) < 0) { ------------------ | Branch (170:6): [True: 0, False: 0] ------------------ 171| 0| s->s_error = ENOMEM; 172| 0| return; 173| 0| } 174| 0| memset(s->s_buf + s->s_len, ' ', s->s_indent); 175| 0| s->s_len += s->s_indent; 176| 0|} vsb.c:VSB_extend: 141| 14.1k|{ 142| 14.1k| char *newbuf; 143| 14.1k| ssize_t newsize; 144| | 145| 14.1k| if (!VSB_CANEXTEND(s)) ------------------ | | 59| 14.1k|#define VSB_CANEXTEND(s) ((s)->s_flags & VSB_AUTOEXTEND) | | ------------------ | | | | 47| 14.1k|#define VSB_AUTOEXTEND 0x00000001 /* automatically extend buffer */ | | ------------------ ------------------ | Branch (145:6): [True: 0, False: 14.1k] ------------------ 146| 0| return (-1); 147| 14.1k| newsize = VSB_extendsize(s->s_size + addlen); 148| 14.1k| if (VSB_ISDYNAMIC(s)) ------------------ | | 55| 14.1k|#define VSB_ISDYNAMIC(s) ((s)->s_flags & VSB_DYNAMIC) | | ------------------ | | | | 49| 14.1k|#define VSB_DYNAMIC 0x00010000 /* s_buf must be freed */ | | ------------------ | | | Branch (55:26): [True: 14.1k, False: 0] | | ------------------ ------------------ 149| 14.1k| newbuf = realloc(s->s_buf, newsize); 150| 0| else 151| 0| newbuf = SBMALLOC(newsize); ------------------ | | 47| 0|#define SBMALLOC(size) malloc(size) ------------------ 152| 14.1k| if (newbuf == NULL) ------------------ | Branch (152:6): [True: 0, False: 14.1k] ------------------ 153| 0| return (-1); 154| 14.1k| if (!VSB_ISDYNAMIC(s)) { ------------------ | | 55| 14.1k|#define VSB_ISDYNAMIC(s) ((s)->s_flags & VSB_DYNAMIC) | | ------------------ | | | | 49| 14.1k|#define VSB_DYNAMIC 0x00010000 /* s_buf must be freed */ | | ------------------ ------------------ | Branch (154:6): [True: 0, False: 14.1k] ------------------ 155| 0| memcpy(newbuf, s->s_buf, s->s_size); 156| 0| VSB_SETFLAG(s, VSB_DYNAMIC); ------------------ | | 64| 0|#define VSB_SETFLAG(s, f) do { (s)->s_flags |= (f); } while (0) | | ------------------ | | | Branch (64:62): [Folded, False: 0] | | ------------------ ------------------ 157| 0| } 158| 14.1k| s->s_buf = newbuf; 159| 14.1k| s->s_size = newsize; 160| 14.1k| return (0); 161| 14.1k|} vsb.c:VSB_put_byte: 264| 16.9M|{ 265| | 266| 16.9M| assert_VSB_integrity(s); ------------------ | | 108| 16.9M|#define assert_VSB_integrity(s) _assert_VSB_integrity(__func__, (s)) ------------------ 267| 16.9M| assert_VSB_state(s, 0); ------------------ | | 109| 16.9M|#define assert_VSB_state(s, i) _assert_VSB_state(__func__, (s), (i)) ------------------ 268| | 269| 16.9M| if (s->s_error != 0) ------------------ | Branch (269:6): [True: 0, False: 16.9M] ------------------ 270| 0| return; 271| 16.9M| _vsb_indent(s); 272| 16.9M| if (VSB_FREESPACE(s) <= 0) { ------------------ | | 58| 16.9M|#define VSB_FREESPACE(s) ((s)->s_size - ((s)->s_len + 1L)) ------------------ | Branch (272:6): [True: 11.0k, False: 16.9M] ------------------ 273| 11.0k| if (VSB_extend(s, 1) < 0) ------------------ | Branch (273:7): [True: 0, False: 11.0k] ------------------ 274| 0| s->s_error = ENOMEM; 275| 11.0k| if (s->s_error != 0) ------------------ | Branch (275:7): [True: 0, False: 11.0k] ------------------ 276| 0| return; 277| 11.0k| } 278| 16.9M| s->s_buf[s->s_len++] = (char)c; 279| 16.9M|}