../3rdparty/pcre/pcre_study.c

if (caseless && (cd->ctypes[c] & ctype_letter) != 0) SET_BIT(cd->fcc[c]);

never executed: }

598 #endif -

599

return p;

never executed: return p;

600 } -

601 #endif -

602 -

603

never executed: start_bits[cd->fcc[c]/8] |= (1 << (cd->fcc[c]&7));

partially evaluated: caseless

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:3

never evaluated: (cd->ctypes[c] & 0x02) != 0

0-3

604

return p + 1;

executed: return p + 1;

Execution Count:3

605 #endif -

606 } -

607 -

608 -

609 -

610 /************************************************* -

611 * Set bits for a positive character type * -

612 *************************************************/ -

613 -

614 /* This function sets starting bits for a character type. In UTF-8 mode, we can -

615 only do a direct setting for bytes less than 128, as otherwise there can be -

616 confusion with bytes in the middle of UTF-8 characters. In a "traditional" -

617 environment, the tables will only recognize ASCII characters anyway, but in at -

618 least one Windows environment, some higher bytes bits were set in the tables. -

619 So we deal with that case by considering the UTF-8 encoding. -

620 -

621 Arguments: -

622 start_bits the starting bitmap -

623 cbit type the type of character wanted -

624 table_limit 32 for non-UTF-8; 16 for UTF-8 -

625 cd the block with char table pointers -

626 -

627 Returns: nothing -

628 */ -

629 -

630 static void -

631 set_type_bits(pcre_uint8 *start_bits, int cbit_type, int table_limit, -

632 compile_data *cd) -

633 { -

634

never executed (the execution status of this line is deduced): register int c;

635

for (c = 0; c < table_limit; c++) start_bits[c] |= cd->cbits[c+cbit_type];

never executed: start_bits[c] |= cd->cbits[c+cbit_type];

never evaluated: c < table_limit

636 #if defined SUPPORT_UTF && defined COMPILE_PCRE8 -

637 if (table_limit == 32) return; -

638 for (c = 128; c < 256; c++) -

639 { -

640 if ((cd->cbits[c/8] & (1 << (c&7))) != 0) -

641 { -

642 pcre_uchar buff[6]; -

643 (void)PRIV(ord2utf)(c, buff); -

644 SET_BIT(buff[0]); -

645 } -

646 } -

647 #endif -

648

for (c = 0; c < table_limit; c++) start_bits[c] |= ~cd->cbits[c+cbit_type];

never executed: }

649 -

650 -

651 /************************************************* -

652 * Set bits for a negative character type * -

653 *************************************************/ -

654 -

655 /* This function sets starting bits for a negative character type such as \D. -

656 In UTF-8 mode, we can only do a direct setting for bytes less than 128, as -

657 otherwise there can be confusion with bytes in the middle of UTF-8 characters. -

658 Unlike in the positive case, where we can set appropriate starting bits for -

659 specific high-valued UTF-8 characters, in this case we have to set the bits for -

660 all high-valued characters. The lowest is 0xc2, but we overkill by starting at -

661 0xc0 (192) for simplicity. -

662 -

663 Arguments: -

664 start_bits the starting bitmap -

665 cbit type the type of character wanted -

666 table_limit 32 for non-UTF-8; 16 for UTF-8 -

667 cd the block with char table pointers -

668 -

669 Returns: nothing -

670 */ -

671 -

672 static void -

673 set_nottype_bits(pcre_uint8 *start_bits, int cbit_type, int table_limit, -

674 compile_data *cd) -

675 { -

676

never executed (the execution status of this line is deduced): register int c;

677

never executed: start_bits[c] |= ~cd->cbits[c+cbit_type];

never evaluated: c < table_limit

678 #if defined SUPPORT_UTF && defined COMPILE_PCRE8 -

679 if (table_limit != 32) for (c = 24; c < 32; c++) start_bits[c] = 0xff; -

680 #endif -

681

const pcre_uchar *tcode = code + 1 + LINK_SIZE;

never executed: }

682 -

683 -

684 -

685 /************************************************* -

686 * Create bitmap of starting bytes * -

687 *************************************************/ -

688 -

689 /* This function scans a compiled unanchored expression recursively and -

690 attempts to build a bitmap of the set of possible starting bytes. As time goes -

691 by, we may be able to get more clever at doing this. The SSB_CONTINUE return is -

692 useful for parenthesized groups in patterns such as (a*)b where the group -

693 provides some optional starting bytes but scanning must continue at the outer -

694 level to find at least one mandatory byte. At the outermost level, this -

695 function fails unless the result is SSB_DONE. -

696 -

697 Arguments: -

698 code points to an expression -

699 start_bits points to a 32-byte table, initialized to 0 -

700 utf TRUE if in UTF-8 / UTF-16 mode -

701 cd the block with char table pointers -

702 -

703 Returns: SSB_FAIL => Failed to find any starting bytes -

704 SSB_DONE => Found mandatory starting bytes -

705 SSB_CONTINUE => Found optional starting bytes -

706 SSB_UNKNOWN => Hit an unrecognized opcode -

707 */ -

708 -

709 static int -

710 set_start_bits(const pcre_uchar *code, pcre_uint8 *start_bits, BOOL utf, -

711 compile_data *cd) -

712 { -

713

executed (the execution status of this line is deduced): register int c;

714

int yield = SSB_DONE;

executed (the execution status of this line is deduced): int yield = SSB_DONE;

715 #if defined SUPPORT_UTF && defined COMPILE_PCRE8 -

716 int table_limit = utf? 16:32; -

717 #else -

718

int table_limit = 32;

executed (the execution status of this line is deduced): int table_limit = 32;

719 #endif -

720 -

721 #if 0 -

722 /* ========================================================================= */ -

723 /* The following comment and code was inserted in January 1999. In May 2006, -

724 when it was observed to cause compiler warnings about unused values, I took it -

725 out again. If anybody is still using OS/2, they will have to put it back -

726 manually. */ -

727 -

728 /* This next statement and the later reference to dummy are here in order to -

729 trick the optimizer of the IBM C compiler for OS/2 into generating correct -

730 code. Apparently IBM isn't going to fix the problem, and we would rather not -

731 disable optimization (in this module it actually makes a big difference, and -

732 the pcre module can use all the optimization it can get). */ -

733 -

734 volatile int dummy; -

735 /* ========================================================================= */ -

736 #endif -

737 -

738 do -

739 { -

740

BOOL try_next = TRUE;

executed (the execution status of this line is deduced): BOOL try_next = 1;

741

executed (the execution status of this line is deduced): const pcre_uchar *tcode = code + 1 + 1;

742 -

743

if (*code == OP_CBRA || *code == OP_SCBRA ||

partially evaluated: *code == OP_CBRA

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:5

partially evaluated: *code == OP_SCBRA

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:5

0-5

744

*code == OP_CBRAPOS || *code == OP_SCBRAPOS) tcode += IMM2_SIZE;

never executed: tcode += 1;

partially evaluated: *code == OP_CBRAPOS

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:5

partially evaluated: *code == OP_SCBRAPOS

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:5

0-5

745 -

746

while (try_next) /* Loop for items in this branch */

evaluated: try_next

TRUE	FALSE
yes Evaluation Count:8	yes Evaluation Count:2

2-8

747 { -

748

int rc;

executed (the execution status of this line is deduced): int rc;

749 -

750 switch(*tcode) -

751 { -

752 /* If we reach something we don't understand, it means a new opcode has -

753 been created that hasn't been added to this code. Hopefully this problem -

754 will be discovered during testing. */ -

755 -

756 default: -

757

return SSB_UNKNOWN;

never executed: return SSB_UNKNOWN;

758 -

759 /* Fail for a valid opcode that implies no starting bits. */ -

760 -

761 case OP_ACCEPT: -

762 case OP_ASSERT_ACCEPT: -

763 case OP_ALLANY: -

764 case OP_ANY: -

765 case OP_ANYBYTE: -

766 case OP_CIRC: -

767 case OP_CIRCM: -

768 case OP_CLOSE: -

769 case OP_COMMIT: -

770 case OP_COND: -

771 case OP_CREF: -

772 case OP_DEF: -

773 case OP_DOLL: -

774 case OP_DOLLM: -

775 case OP_END: -

776 case OP_EOD: -

777 case OP_EODN: -

778 case OP_EXTUNI: -

779 case OP_FAIL: -

780 case OP_MARK: -

781 case OP_NCREF: -

782 case OP_NOT: -

783 case OP_NOTEXACT: -

784 case OP_NOTEXACTI: -

785 case OP_NOTI: -

786 case OP_NOTMINPLUS: -

787 case OP_NOTMINPLUSI: -

788 case OP_NOTMINQUERY: -

789 case OP_NOTMINQUERYI: -

790 case OP_NOTMINSTAR: -

791 case OP_NOTMINSTARI: -

792 case OP_NOTMINUPTO: -

793 case OP_NOTMINUPTOI: -

794 case OP_NOTPLUS: -

795 case OP_NOTPLUSI: -

796 case OP_NOTPOSPLUS: -

797 case OP_NOTPOSPLUSI: -

798 case OP_NOTPOSQUERY: -

799 case OP_NOTPOSQUERYI: -

800 case OP_NOTPOSSTAR: -

801 case OP_NOTPOSSTARI: -

802 case OP_NOTPOSUPTO: -

803 case OP_NOTPOSUPTOI: -

804 case OP_NOTPROP: -

805 case OP_NOTQUERY: -

806 case OP_NOTQUERYI: -

807 case OP_NOTSTAR: -

808 case OP_NOTSTARI: -

809 case OP_NOTUPTO: -

810 case OP_NOTUPTOI: -

811 case OP_NOT_HSPACE: -

812 case OP_NOT_VSPACE: -

813 case OP_NRREF: -

814 case OP_PROP: -

815 case OP_PRUNE: -

816 case OP_PRUNE_ARG: -

817 case OP_RECURSE: -

818 case OP_REF: -

819 case OP_REFI: -

820 case OP_REVERSE: -

821 case OP_RREF: -

822 case OP_SCOND: -

823 case OP_SET_SOM: -

824 case OP_SKIP: -

825 case OP_SKIP_ARG: -

826 case OP_SOD: -

827 case OP_SOM: -

828 case OP_THEN: -

829 case OP_THEN_ARG: -

830 #if defined SUPPORT_UTF || !defined COMPILE_PCRE8 -

831 case OP_XCLASS: -

832 #endif -

833

return SSB_FAIL;

executed: return SSB_FAIL;

Execution Count:1

834 -

835 /* We can ignore word boundary tests. */ -

836 -

837 case OP_WORD_BOUNDARY: -

838 case OP_NOT_WORD_BOUNDARY: -

839

executed (the execution status of this line is deduced): tcode++;

840

rc = set_start_bits(tcode, start_bits, utf, cd);

executed: break;

Execution Count:1

841 -

842 /* If we hit a bracket or a positive lookahead assertion, recurse to set -

843 bits from within the subpattern. If it can't find anything, we have to -

844 give up. If it finds some mandatory character(s), we are done for this -

845 branch. Otherwise, carry on scanning after the subpattern. */ -

846 -

847 case OP_BRA: -

848 case OP_SBRA: -

849 case OP_CBRA: -

850 case OP_SCBRA: -

851 case OP_BRAPOS: -

852 case OP_SBRAPOS: -

853 case OP_CBRAPOS: -

854 case OP_SCBRAPOS: -

855 case OP_ONCE: -

856 case OP_ONCE_NC: -

857 case OP_ASSERT: -

858

never executed (the execution status of this line is deduced): rc = set_start_bits(tcode, start_bits, utf, cd);

859

if (rc == SSB_FAIL || rc == SSB_UNKNOWN) return rc;

never executed: return rc;

never evaluated: rc == SSB_FAIL

never evaluated: rc == SSB_UNKNOWN

860

if (rc == SSB_DONE) try_next = FALSE; else

never executed: try_next = 0;

never evaluated: rc == SSB_DONE

861 { -

862

do tcode += GET(tcode, 1); while (*tcode == OP_ALT);

never executed: tcode += (tcode[1]);

never evaluated: *tcode == OP_ALT

863

never executed (the execution status of this line is deduced): tcode += 1 + 1;

never executed: }

never executed: break;

866 -

867 /* If we hit ALT or KET, it means we haven't found anything mandatory in -

868 this branch, though we might have found something optional. For ALT, we -

869 continue with the next alternative, but we have to arrange that the final -

870 result from subpattern is SSB_CONTINUE rather than SSB_DONE. For KET, -

871 return SSB_CONTINUE: if this is the top level, that indicates failure, -

872 but after a nested subpattern, it causes scanning to continue. */ -

873 -

874 case OP_ALT: -

875

yield = SSB_CONTINUE;

executed (the execution status of this line is deduced): yield = SSB_CONTINUE;

876

executed (the execution status of this line is deduced): try_next = 0;

877

tcode += 2 + 2*LINK_SIZE;

executed: break;

Execution Count:1

878 -

879 case OP_KET: -

880 case OP_KETRMAX: -

881 case OP_KETRMIN: -

882 case OP_KETRPOS: -

883

return SSB_CONTINUE;

executed: return SSB_CONTINUE;

Execution Count:2

884 -

885 /* Skip over callout */ -

886 -

887 case OP_CALLOUT: -

888

never executed (the execution status of this line is deduced): tcode += 2 + 2*1;

889

do tcode += GET(tcode, 1); while (*tcode == OP_ALT);

never executed: break;

890 -

891 /* Skip over lookbehind and negative lookahead assertions */ -

892 -

893 case OP_ASSERT_NOT: -

894 case OP_ASSERTBACK: -

895 case OP_ASSERTBACK_NOT: -

896

never executed: tcode += (tcode[1]);

never evaluated: *tcode == OP_ALT

897

never executed (the execution status of this line is deduced): tcode += 1 + 1;

898

rc = set_start_bits(++tcode, start_bits, utf, cd);

never executed: break;

899 -

900 /* BRAZERO does the bracket, but carries on. */ -

901 -

902 case OP_BRAZERO: -

903 case OP_BRAMINZERO: -

904 case OP_BRAPOSZERO: -

905

never executed (the execution status of this line is deduced): rc = set_start_bits(++tcode, start_bits, utf, cd);

906

if (rc == SSB_FAIL || rc == SSB_UNKNOWN) return rc;

never executed: return rc;

never evaluated: rc == SSB_FAIL

never evaluated: rc == SSB_UNKNOWN

907 /* ========================================================================= -

908 See the comment at the head of this function concerning the next line, -

909 which was an old fudge for the benefit of OS/2. -

910 dummy = 1; -

911 ========================================================================= */ -

912

do tcode += GET(tcode,1); while (*tcode == OP_ALT);

never executed: tcode += (tcode[1]);

never evaluated: *tcode == OP_ALT

913

never executed (the execution status of this line is deduced): tcode += 1 + 1;

914

never executed: break;

915 -

916 /* SKIPZERO skips the bracket. */ -

917 -

918 case OP_SKIPZERO: -

919

do tcode += GET(tcode,1); while (*tcode == OP_ALT);

never executed (the execution status of this line is deduced): tcode++;

920

never executed: tcode += (tcode[1]);

never evaluated: *tcode == OP_ALT

921

never executed (the execution status of this line is deduced): tcode += 1 + 1;

922

tcode = set_table_bit(start_bits, tcode + 1, FALSE, cd, utf);

never executed: break;

923 -

924 /* Single-char * or ? sets the bit and tries the next item */ -

925 -

926 case OP_STAR: -

927 case OP_MINSTAR: -

928 case OP_POSSTAR: -

929 case OP_QUERY: -

930 case OP_MINQUERY: -

931 case OP_POSQUERY: -

932

executed (the execution status of this line is deduced): tcode = set_table_bit(start_bits, tcode + 1, 0, cd, utf);

933

tcode = set_table_bit(start_bits, tcode + 1, TRUE, cd, utf);

executed: break;

Execution Count:2

934 -

935 case OP_STARI: -

936 case OP_MINSTARI: -

937 case OP_POSSTARI: -

938 case OP_QUERYI: -

939 case OP_MINQUERYI: -

940 case OP_POSQUERYI: -

941

never executed (the execution status of this line is deduced): tcode = set_table_bit(start_bits, tcode + 1, 1, cd, utf);

942

tcode = set_table_bit(start_bits, tcode + 1 + IMM2_SIZE, FALSE, cd, utf);

never executed: break;

943 -

944 /* Single-char upto sets the bit and tries the next */ -

945 -

946 case OP_UPTO: -

947 case OP_MINUPTO: -

948 case OP_POSUPTO: -

949

never executed (the execution status of this line is deduced): tcode = set_table_bit(start_bits, tcode + 1 + 1, 0, cd, utf);

950

tcode = set_table_bit(start_bits, tcode + 1 + IMM2_SIZE, TRUE, cd, utf);

never executed: break;

951 -

952 case OP_UPTOI: -

953 case OP_MINUPTOI: -

954 case OP_POSUPTOI: -

955

never executed (the execution status of this line is deduced): tcode = set_table_bit(start_bits, tcode + 1 + 1, 1, cd, utf);

956

(void)set_table_bit(start_bits, tcode + 1, FALSE, cd, utf);

never executed: break;

957 -

958 /* At least one single char sets the bit and stops */ -

959 -

960 case OP_EXACT: -

961

tcode += IMM2_SIZE;

never executed (the execution status of this line is deduced): tcode += 1;

962 /* Fall through */ -

963

case OP_CHAR:

code before this statement never executed: case OP_CHAR:

964 case OP_PLUS: -

965 case OP_MINPLUS: -

966 case OP_POSPLUS: -

967

executed (the execution status of this line is deduced): (void)set_table_bit(start_bits, tcode + 1, 0, cd, utf);

968

executed (the execution status of this line is deduced): try_next = 0;

969

(void)set_table_bit(start_bits, tcode + 1, TRUE, cd, utf);

executed: break;

Execution Count:1

970 -

971 case OP_EXACTI: -

972

tcode += IMM2_SIZE;

never executed (the execution status of this line is deduced): tcode += 1;

973 /* Fall through */ -

974

case OP_CHARI:

code before this statement never executed: case OP_CHARI:

975 case OP_PLUSI: -

976 case OP_MINPLUSI: -

977 case OP_POSPLUSI: -

978

never executed (the execution status of this line is deduced): (void)set_table_bit(start_bits, tcode + 1, 1, cd, utf);

979

never executed (the execution status of this line is deduced): try_next = 0;

980

never executed: break;

981 -

982 /* Special spacing and line-terminating items. These recognize specific -

983 lists of characters. The difference between VSPACE and ANYNL is that the -

984 latter can match the two-character CRLF sequence, but that is not -

985 relevant for finding the first character, so their code here is -

986 identical. */ -

987 -

988 case OP_HSPACE: -

989

SET_BIT(0x09);

never executed (the execution status of this line is deduced): start_bits[0x09/8] |= (1 << (0x09&7));

990

SET_BIT(0x20);

never executed (the execution status of this line is deduced): start_bits[0x20/8] |= (1 << (0x20&7));

991 #ifdef SUPPORT_UTF -

992

if (utf)

never evaluated: utf

993 { -

994 #ifdef COMPILE_PCRE8 -

995 SET_BIT(0xC2); /* For U+00A0 */ -

996 SET_BIT(0xE1); /* For U+1680, U+180E */ -

997 SET_BIT(0xE2); /* For U+2000 - U+200A, U+202F, U+205F */ -

998 SET_BIT(0xE3); /* For U+3000 */ -

999 #endif -

1000 #ifdef COMPILE_PCRE16 -

1001

SET_BIT(0xA0);

never executed (the execution status of this line is deduced): start_bits[0xA0/8] |= (1 << (0xA0&7));

1002

never executed (the execution status of this line is deduced): start_bits[0xFF/8] |= (1 << (0xFF&7));

1003 #endif -

1004

never executed: }

1005 else -

1006 #endif /* SUPPORT_UTF */ -

1007 { -

1008

SET_BIT(0xA0);

never executed (the execution status of this line is deduced): start_bits[0xA0/8] |= (1 << (0xA0&7));

1009 #ifdef COMPILE_PCRE16 -

1010

never executed (the execution status of this line is deduced): start_bits[0xFF/8] |= (1 << (0xFF&7));

1011 #endif -

never executed: }

never executed (the execution status of this line is deduced): try_next = 0;

1014

never executed: break;

1015 -

1016 case OP_ANYNL: -

1017 case OP_VSPACE: -

1018

SET_BIT(0x0A);

never executed (the execution status of this line is deduced): start_bits[0x0A/8] |= (1 << (0x0A&7));

1019

SET_BIT(0x0B);

never executed (the execution status of this line is deduced): start_bits[0x0B/8] |= (1 << (0x0B&7));

1020

SET_BIT(0x0C);

never executed (the execution status of this line is deduced): start_bits[0x0C/8] |= (1 << (0x0C&7));

1021

SET_BIT(0x0D);

never executed (the execution status of this line is deduced): start_bits[0x0D/8] |= (1 << (0x0D&7));

1022 #ifdef SUPPORT_UTF -

1023

if (utf)

never evaluated: utf

1024 { -

1025 #ifdef COMPILE_PCRE8 -

1026 SET_BIT(0xC2); /* For U+0085 */ -

1027 SET_BIT(0xE2); /* For U+2028, U+2029 */ -

1028 #endif -

1029 #ifdef COMPILE_PCRE16 -

1030

SET_BIT(0x85);

never executed (the execution status of this line is deduced): start_bits[0x85/8] |= (1 << (0x85&7));

1031

never executed (the execution status of this line is deduced): start_bits[0xFF/8] |= (1 << (0xFF&7));

1032 #endif -

1033

never executed: }

1034 else -

1035 #endif /* SUPPORT_UTF */ -

1036 { -

1037

SET_BIT(0x85);

never executed (the execution status of this line is deduced): start_bits[0x85/8] |= (1 << (0x85&7));

1038 #ifdef COMPILE_PCRE16 -

1039

never executed (the execution status of this line is deduced): start_bits[0xFF/8] |= (1 << (0xFF&7));

1040 #endif -

never executed: }

never executed (the execution status of this line is deduced): try_next = 0;

1043

set_nottype_bits(start_bits, cbit_digit, table_limit, cd);

never executed: break;

1044 -

1045 /* Single character types set the bits and stop. Note that if PCRE_UCP -

1046 is set, we do not see these op codes because \d etc are converted to -

1047 properties. Therefore, these apply in the case when only characters less -

1048 than 256 are recognized to match the types. */ -

1049 -

1050 case OP_NOT_DIGIT: -

1051

never executed (the execution status of this line is deduced): set_nottype_bits(start_bits, 64, table_limit, cd);

1052

never executed (the execution status of this line is deduced): try_next = 0;

1053

set_type_bits(start_bits, cbit_digit, table_limit, cd);

never executed: break;

1054 -

1055 case OP_DIGIT: -

1056

never executed (the execution status of this line is deduced): set_type_bits(start_bits, 64, table_limit, cd);

1057

never executed (the execution status of this line is deduced): try_next = 0;

1058

set_nottype_bits(start_bits, cbit_space, table_limit, cd);

never executed: break;

1059 -

1060 /* The cbit_space table has vertical tab as whitespace; we have to -

1061 ensure it is set as not whitespace. */ -

1062 -

1063 case OP_NOT_WHITESPACE: -

1064

never executed (the execution status of this line is deduced): set_nottype_bits(start_bits, 0, table_limit, cd);

1065

start_bits[1] |= 0x08;

never executed (the execution status of this line is deduced): start_bits[1] |= 0x08;

1066

never executed (the execution status of this line is deduced): try_next = 0;

1067

c = start_bits[1]; /* Save in case it was already set */

never executed: break;

1068 -

1069 /* The cbit_space table has vertical tab as whitespace; we have to -

1070 not set it from the table. */ -

1071 -

1072 case OP_WHITESPACE: -

1073

never executed (the execution status of this line is deduced): c = start_bits[1];

1074

set_type_bits(start_bits, cbit_space, table_limit, cd);

never executed (the execution status of this line is deduced): set_type_bits(start_bits, 0, table_limit, cd);

1075

start_bits[1] = (start_bits[1] & ~0x08) | c;

never executed (the execution status of this line is deduced): start_bits[1] = (start_bits[1] & ~0x08) | c;

1076

never executed (the execution status of this line is deduced): try_next = 0;

1077

set_nottype_bits(start_bits, cbit_word, table_limit, cd);

never executed: break;

1078 -

1079 case OP_NOT_WORDCHAR: -

1080

never executed (the execution status of this line is deduced): set_nottype_bits(start_bits, 160, table_limit, cd);

1081

never executed (the execution status of this line is deduced): try_next = 0;

1082

set_type_bits(start_bits, cbit_word, table_limit, cd);

never executed: break;

1083 -

1084 case OP_WORDCHAR: -

1085

never executed (the execution status of this line is deduced): set_type_bits(start_bits, 160, table_limit, cd);

1086

never executed (the execution status of this line is deduced): try_next = 0;

1087

never executed: break;

1088 -

1089 /* One or more character type fudges the pointer and restarts, knowing -

1090 it will hit a single character type and stop there. */ -

1091 -

1092 case OP_TYPEPLUS: -

1093 case OP_TYPEMINPLUS: -

1094 case OP_TYPEPOSPLUS: -

1095

never executed (the execution status of this line is deduced): tcode++;

1096

never executed: break;

1097 -

1098 case OP_TYPEEXACT: -

1099

tcode += 1 + IMM2_SIZE;

never executed (the execution status of this line is deduced): tcode += 1 + 1;

1100

tcode += IMM2_SIZE; /* Fall through */

never executed: break;

1101 -

1102 /* Zero or more repeats of character types set the bits and then -

1103 try again. */ -

1104 -

1105 case OP_TYPEUPTO: -

1106 case OP_TYPEMINUPTO: -

1107 case OP_TYPEPOSUPTO: -

1108

never executed (the execution status of this line is deduced): tcode += 1;

1109 -

1110

case OP_TYPESTAR:

code before this statement never executed: case OP_TYPESTAR:

1111 case OP_TYPEMINSTAR: -

1112 case OP_TYPEPOSSTAR: -

1113 case OP_TYPEQUERY: -

1114 case OP_TYPEMINQUERY: -

1115 case OP_TYPEPOSQUERY: -

1116 switch(tcode[1]) -

1117 { -

1118 default: -

1119 case OP_ANY: -

1120 case OP_ALLANY: -

1121

return SSB_FAIL;

never executed: return SSB_FAIL;

1122 -

1123 case OP_HSPACE: -

1124

SET_BIT(0x09);

never executed (the execution status of this line is deduced): start_bits[0x09/8] |= (1 << (0x09&7));

1125

SET_BIT(0x20);

never executed (the execution status of this line is deduced): start_bits[0x20/8] |= (1 << (0x20&7));

1126 #ifdef COMPILE_PCRE8 -

1127 if (utf) -

1128 { -

1129 #ifdef COMPILE_PCRE8 -

1130 SET_BIT(0xC2); /* For U+00A0 */ -

1131 SET_BIT(0xE1); /* For U+1680, U+180E */ -

1132 SET_BIT(0xE2); /* For U+2000 - U+200A, U+202F, U+205F */ -

1133 SET_BIT(0xE3); /* For U+3000 */ -

1134 #endif -

1135 #ifdef COMPILE_PCRE16 -

1136 SET_BIT(0xA0); -

1137 SET_BIT(0xFF); /* For characters > 255 */ -

1138 #endif -

1139 } -

1140 else -

1141 #endif /* SUPPORT_UTF */ -

1142

SET_BIT(0xA0);

never executed (the execution status of this line is deduced): start_bits[0xA0/8] |= (1 << (0xA0&7));

1143

never executed: break;

1144 -

1145 case OP_ANYNL: -

1146 case OP_VSPACE: -

1147

SET_BIT(0x0A);

never executed (the execution status of this line is deduced): start_bits[0x0A/8] |= (1 << (0x0A&7));

1148

SET_BIT(0x0B);

never executed (the execution status of this line is deduced): start_bits[0x0B/8] |= (1 << (0x0B&7));

1149

SET_BIT(0x0C);

never executed (the execution status of this line is deduced): start_bits[0x0C/8] |= (1 << (0x0C&7));

1150

SET_BIT(0x0D);

never executed (the execution status of this line is deduced): start_bits[0x0D/8] |= (1 << (0x0D&7));

1151 #ifdef COMPILE_PCRE8 -

1152 if (utf) -

1153 { -

1154 #ifdef COMPILE_PCRE8 -

1155 SET_BIT(0xC2); /* For U+0085 */ -

1156 SET_BIT(0xE2); /* For U+2028, U+2029 */ -

1157 #endif -

1158 #ifdef COMPILE_PCRE16 -

1159 SET_BIT(0x85); -

1160 SET_BIT(0xFF); /* For characters > 255 */ -

1161 #endif -

1162 } -

1163 else -

1164 #endif /* SUPPORT_UTF */ -

1165

SET_BIT(0x85);

never executed (the execution status of this line is deduced): start_bits[0x85/8] |= (1 << (0x85&7));

1166

set_nottype_bits(start_bits, cbit_digit, table_limit, cd);

never executed: break;

1167 -

1168 case OP_NOT_DIGIT: -

1169

never executed (the execution status of this line is deduced): set_nottype_bits(start_bits, 64, table_limit, cd);

1170

set_type_bits(start_bits, cbit_digit, table_limit, cd);

never executed: break;

1171 -

1172 case OP_DIGIT: -

1173

never executed (the execution status of this line is deduced): set_type_bits(start_bits, 64, table_limit, cd);

1174

set_nottype_bits(start_bits, cbit_space, table_limit, cd);

never executed: break;

1175 -

1176 /* The cbit_space table has vertical tab as whitespace; we have to -

1177 ensure it gets set as not whitespace. */ -

1178 -

1179 case OP_NOT_WHITESPACE: -

1180

never executed (the execution status of this line is deduced): set_nottype_bits(start_bits, 0, table_limit, cd);

1181

start_bits[1] |= 0x08;

never executed (the execution status of this line is deduced): start_bits[1] |= 0x08;

1182

c = start_bits[1]; /* Save in case it was already set */

never executed: break;

1183 -

1184 /* The cbit_space table has vertical tab as whitespace; we have to -

1185 avoid setting it. */ -

1186 -

1187 case OP_WHITESPACE: -

1188

never executed (the execution status of this line is deduced): c = start_bits[1];

1189

set_type_bits(start_bits, cbit_space, table_limit, cd);

never executed (the execution status of this line is deduced): set_type_bits(start_bits, 0, table_limit, cd);

1190

start_bits[1] = (start_bits[1] & ~0x08) | c;

never executed (the execution status of this line is deduced): start_bits[1] = (start_bits[1] & ~0x08) | c;

1191

set_nottype_bits(start_bits, cbit_word, table_limit, cd);

never executed: break;

1192 -

1193 case OP_NOT_WORDCHAR: -

1194

never executed (the execution status of this line is deduced): set_nottype_bits(start_bits, 160, table_limit, cd);

1195

set_type_bits(start_bits, cbit_word, table_limit, cd);

never executed: break;

1196 -

1197 case OP_WORDCHAR: -

1198

never executed (the execution status of this line is deduced): set_type_bits(start_bits, 160, table_limit, cd);

1199

never executed: break;

1200 } -

1201 -

1202

tcode += 2;

never executed (the execution status of this line is deduced): tcode += 2;

1203

never executed: break;

1204 -

1205 /* Character class where all the information is in a bit map: set the -

1206 bits and either carry on or not, according to the repeat count. If it was -

1207 a negative class, and we are operating with UTF-8 characters, any byte -

1208 with a value >= 0xc4 is a potentially valid starter because it starts a -

1209 character with a value > 255. */ -

1210 -

1211 case OP_NCLASS: -

1212 #if defined SUPPORT_UTF && defined COMPILE_PCRE8 -

1213 if (utf) -

1214 { -

1215 start_bits[24] |= 0xf0; /* Bits for 0xc4 - 0xc8 */ -

1216 memset(start_bits+25, 0xff, 7); /* Bits for 0xc9 - 0xff */ -

1217 } -

1218 #endif -

1219 #ifdef COMPILE_PCRE16 -

1220

never executed (the execution status of this line is deduced): start_bits[0xFF/8] |= (1 << (0xFF&7));

1221 #endif -

1222 /* Fall through */ -

1223 -

1224

case OP_CLASS:

code before this statement never executed: case OP_CLASS:

1225 { -

1226

pcre_uint8 *map;

never executed (the execution status of this line is deduced): pcre_uint8 *map;

1227

map = (pcre_uint8 *)tcode;

never executed (the execution status of this line is deduced): tcode++;

1228

never executed (the execution status of this line is deduced): map = (pcre_uint8 *)tcode;

1229 -

1230 /* In UTF-8 mode, the bits in a bit map correspond to character -

1231 values, not to byte values. However, the bit map we are constructing is -

1232 for byte values. So we have to do a conversion for characters whose -

1233 value is > 127. In fact, there are only two possible starting bytes for -

1234 characters in the range 128 - 255. */ -

1235 -

1236 #if defined SUPPORT_UTF && defined COMPILE_PCRE8 -

1237 if (utf) -

1238 { -

1239 for (c = 0; c < 16; c++) start_bits[c] |= map[c]; -

1240 for (c = 128; c < 256; c++) -

1241 { -

1242 if ((map[c/8] && (1 << (c&7))) != 0) -

1243 { -

1244 int d = (c >> 6) | 0xc0; /* Set bit for this starter */ -

1245 start_bits[d/8] |= (1 << (d&7)); /* and then skip on to the */ -

1246 c = (c & 0xc0) + 0x40 - 1; /* next relevant character. */ -

1247 } -

1248 } -

1249 } -

1250 else -

1251 #endif -

1252 { -

1253 /* In non-UTF-8 mode, the two bit maps are completely compatible. */ -

1254

for (c = 0; c < 32; c++) start_bits[c] |= map[c];

never executed: start_bits[c] |= map[c];

never evaluated: c < 32

1255 } -

1256 -

1257 /* Advance past the bit map, and act on what follows. For a zero -

1258 minimum repeat, continue; otherwise stop processing. */ -

1259 -

1260

tcode += 32 / sizeof(pcre_uchar);

never executed (the execution status of this line is deduced): tcode += 32 / sizeof(pcre_uchar);

1261 switch (*tcode) -

1262 { -

1263 case OP_CRSTAR: -

1264 case OP_CRMINSTAR: -

1265 case OP_CRQUERY: -

1266 case OP_CRMINQUERY: -

1267

never executed (the execution status of this line is deduced): tcode++;

1268

if (GET2(tcode, 1) == 0) tcode += 1 + 2 * IMM2_SIZE;

never executed: break;

1269 -

1270 case OP_CRRANGE: -

1271 case OP_CRMINRANGE: -

1272

never executed: tcode += 1 + 2 * 1;

never evaluated: tcode[1] == 0

1273

else try_next = FALSE;

never executed: try_next = 0;

1274

never executed: break;

1275 -

1276 default: -

1277

never executed (the execution status of this line is deduced): try_next = 0;

1278

break; /* End of bitmap class handling */

never executed: break;

1279 } -

1280 } -

1281

never executed: break;

1282 -

1283 } /* End of switch */ -

1284

} /* End of try_next loop */

executed: }

Execution Count:5

1285 -

1286

code += GET(code, 1); /* Advance to next branch */

executed (the execution status of this line is deduced): code += (code[1]);

1287

pcre_uint8 start_bits[32];

executed: }

Execution Count:2

1288

while (*code == OP_ALT);

evaluated: *code == OP_ALT

TRUE	FALSE
yes Evaluation Count:1	yes Evaluation Count:1

1289

return yield;

executed: return yield;

Execution Count:1

1290 } -

1291 -

1292 -

1293 -

1294 -

1295 -

1296 /************************************************* -

1297 * Study a compiled expression * -

1298 *************************************************/ -

1299 -

1300 /* This function is handed a compiled expression that it must study to produce -

1301 information that will speed up the matching. It returns a pcre[16]_extra block -

1302 which then gets handed back to pcre_exec(). -

1303 -

1304 Arguments: -

1305 re points to the compiled expression -

1306 options contains option bits -

1307 errorptr points to where to place error messages; -

1308 set NULL unless error -

1309 -

1310 Returns: pointer to a pcre[16]_extra block, with study_data filled in and -

1311 the appropriate flags set; -

1312 NULL on error or if no optimization possible -

1313 */ -

1314 -

1315 #ifdef COMPILE_PCRE8 -

1316 PCRE_EXP_DEFN pcre_extra * PCRE_CALL_CONVENTION -

1317 pcre_study(const pcre *external_re, int options, const char **errorptr) -

1318 #else -

1319 PCRE_EXP_DEFN pcre16_extra * PCRE_CALL_CONVENTION -

1320 pcre16_study(const pcre16 *external_re, int options, const char **errorptr) -

1321 #endif -

1322 { -

1323

int min;

executed (the execution status of this line is deduced): int min;

1324

BOOL bits_set = FALSE;

executed (the execution status of this line is deduced): BOOL bits_set = 0;

1325

executed (the execution status of this line is deduced): pcre_uint8 start_bits[32];

1326

PUBL(extra) *extra = NULL;

executed (the execution status of this line is deduced): pcre16_extra *extra = ((void *)0);

1327

pcre_study_data *study;

executed (the execution status of this line is deduced): pcre_study_data *study;

1328

const pcre_uint8 *tables;

executed (the execution status of this line is deduced): const pcre_uint8 *tables;

1329

pcre_uchar *code;

executed (the execution status of this line is deduced): pcre_uchar *code;

1330

compile_data compile_block;

executed (the execution status of this line is deduced): compile_data compile_block;

1331

const REAL_PCRE *re = (const REAL_PCRE *)external_re;

executed (the execution status of this line is deduced): const real_pcre16 *re = (const real_pcre16 *)external_re;

1332 -

1333

*errorptr = NULL;

executed (the execution status of this line is deduced): *errorptr = ((void *)0);

1334 -

1335

if (re == NULL || re->magic_number != MAGIC_NUMBER)

partially evaluated: re == ((void *)0)

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:15

partially evaluated: re->magic_number != 0x50435245UL

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:15

0-15

1336 { -

1337

*errorptr = "argument is not a compiled regular expression";

never executed (the execution status of this line is deduced): *errorptr = "argument is not a compiled regular expression";

1338

if ((re->flags & PCRE_MODE) == 0)

never executed: return ((void *)0);

1339 } -

1340 -

1341

partially evaluated: (re->flags & 0x0002) == 0

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:15

0-15

1342 { -

1343 #ifdef COMPILE_PCRE8 -

1344 *errorptr = "argument is compiled in 16 bit mode"; -

1345 #else -

1346

*errorptr = "argument is compiled in 8 bit mode";

never executed (the execution status of this line is deduced): *errorptr = "argument is compiled in 8 bit mode";

1347 #endif -

1348

if ((options & ~PUBLIC_STUDY_OPTIONS) != 0)

never executed: return ((void *)0);

1349 } -

1350 -

1351

partially evaluated: (options & ~0x0001) != 0

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:15

0-15

1352 { -

1353

*errorptr = "unknown or incorrect option bit(s) set";

never executed (the execution status of this line is deduced): *errorptr = "unknown or incorrect option bit(s) set";

1354

code = (pcre_uchar *)re + re->name_table_offset +

never executed: return ((void *)0);

1355 } -

1356 -

1357

executed (the execution status of this line is deduced): code = (pcre_uchar *)re + re->name_table_offset +

1358

(re->name_count * re->name_entry_size);

executed (the execution status of this line is deduced): (re->name_count * re->name_entry_size);

1359 -

1360 /* For an anchored pattern, or an unanchored pattern that has a first char, or -

1361 a multiline pattern that matches only at "line starts", there is no point in -

1362 seeking a list of starting bytes. */ -

1363 -

1364

if ((re->options & PCRE_ANCHORED) == 0 &&

partially evaluated: (re->options & 0x00000010) == 0

TRUE	FALSE
yes Evaluation Count:15	no Evaluation Count:0

0-15

1365

(re->flags & (PCRE_FIRSTSET|PCRE_STARTLINE)) == 0)

evaluated: (re->flags & (0x0010|0x0100)) == 0

TRUE	FALSE
yes Evaluation Count:4	yes Evaluation Count:11

4-11

1366 { -

1367

int rc;

executed (the execution status of this line is deduced): int rc;

1368 -

1369 /* Set the character tables in the block that is passed around */ -

1370 -

1371

tables = re->tables;

executed (the execution status of this line is deduced): tables = re->tables;

1372 -

1373 #ifdef COMPILE_PCRE8 -

1374 if (tables == NULL) -

1375 (void)pcre_fullinfo(external_re, NULL, PCRE_INFO_DEFAULT_TABLES, -

1376 (void *)(&tables)); -

1377 #else -

1378

if (tables == NULL)

partially evaluated: tables == ((void *)0)

TRUE	FALSE
yes Evaluation Count:4	no Evaluation Count:0

0-4

1379

(void)pcre16_fullinfo(external_re, NULL, PCRE_INFO_DEFAULT_TABLES,

executed: (void)pcre16_fullinfo(external_re, ((void *)0), 11, (void *)(&tables));

Execution Count:4

1380

(void *)(&tables));

executed: (void)pcre16_fullinfo(external_re, ((void *)0), 11, (void *)(&tables));

Execution Count:4

1381 #endif -

1382 -

1383

compile_block.lcc = tables + lcc_offset;

executed (the execution status of this line is deduced): compile_block.lcc = tables + 0;

1384

compile_block.fcc = tables + fcc_offset;

executed (the execution status of this line is deduced): compile_block.fcc = tables + 256;

1385

compile_block.cbits = tables + cbits_offset;

executed (the execution status of this line is deduced): compile_block.cbits = tables + 512;

1386

compile_block.ctypes = tables + ctypes_offset;

executed (the execution status of this line is deduced): compile_block.ctypes = tables + (512 + 320);

1387 -

1388 /* See if we can find a fixed set of initial characters for the pattern. */ -

1389 -

1390

memset(start_bits, 0, 32 * sizeof(pcre_uint8));

executed (the execution status of this line is deduced): memset(start_bits, 0, 32 * sizeof(pcre_uint8));

1391

rc = set_start_bits(code, start_bits, (re->options & PCRE_UTF8) != 0,

executed (the execution status of this line is deduced): rc = set_start_bits(code, start_bits, (re->options & 0x00000800) != 0,

1392

&compile_block);

executed (the execution status of this line is deduced): &compile_block);

1393

bits_set = rc == SSB_DONE;

executed (the execution status of this line is deduced): bits_set = rc == SSB_DONE;

1394

if (rc == SSB_UNKNOWN)

partially evaluated: rc == SSB_UNKNOWN

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:4

0-4

1395 { -

1396

*errorptr = "internal error: opcode not recognized";

never executed (the execution status of this line is deduced): *errorptr = "internal error: opcode not recognized";

1397

never executed: return ((void *)0);

1398 } -

1399

case -2: *errorptr = "internal error: missing capturing bracket"; return NULL;

executed: }

Execution Count:4

1400 -

1401 /* Find the minimum length of subject string. */ -

1402 -

1403 switch(min = find_minlength(code, code, re->options, 0)) -

1404 { -

1405

never executed: return ((void *)0);

1406

case -3: *errorptr = "internal error: opcode not recognized"; return NULL;

never executed: return ((void *)0);

1407

default: break;

executed: break;

Execution Count:15

1408 } -

1409 -

1410 /* If a set of starting bytes has been identified, or if the minimum length is -

1411 greater than zero, or if JIT optimization has been requested, get a -

1412 pcre[16]_extra block and a pcre_study_data block. The study data is put in the -

1413 latter, which is pointed to by the former, which may also get additional data -

1414 set later by the calling program. At the moment, the size of pcre_study_data -

1415 is fixed. We nevertheless save it in a field for returning via the -

1416 pcre_fullinfo() function so that if it becomes variable in the future, -

1417 we don't have to change that code. */ -

1418 -

1419

if (bits_set || min > 0

partially evaluated: bits_set

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:15

evaluated: min > 0

TRUE	FALSE
yes Evaluation Count:6	yes Evaluation Count:9

0-15

1420

#ifdef SUPPORT_JIT

executed (the execution status of this line is deduced):

1421

|| (options & PCRE_STUDY_JIT_COMPILE) != 0

partially evaluated: (options & 0x0001) != 0

TRUE	FALSE
yes Evaluation Count:9	no Evaluation Count:0

0-9

1422 #endif -

1423 ) -

1424 { -

1425

extra = (PUBL(extra) *)(PUBL(malloc))

executed (the execution status of this line is deduced): extra = (pcre16_extra *)(pcre16_malloc)

1426

(sizeof(PUBL(extra)) + sizeof(pcre_study_data));

executed (the execution status of this line is deduced): (sizeof(pcre16_extra) + sizeof(pcre_study_data));

1427

if (extra == NULL)

partially evaluated: extra == ((void *)0)

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:15

0-15

1428 { -

1429

*errorptr = "failed to get memory";

never executed (the execution status of this line is deduced): *errorptr = "failed to get memory";

1430

study = (pcre_study_data *)((char *)extra + sizeof(PUBL(extra)));

never executed: return ((void *)0);

1431 } -

1432 -

1433

executed (the execution status of this line is deduced): study = (pcre_study_data *)((char *)extra + sizeof(pcre16_extra));

1434

extra->flags = PCRE_EXTRA_STUDY_DATA;

executed (the execution status of this line is deduced): extra->flags = 0x0001;

1435

extra->study_data = study;

executed (the execution status of this line is deduced): extra->study_data = study;

1436 -

1437

study->size = sizeof(pcre_study_data);

executed (the execution status of this line is deduced): study->size = sizeof(pcre_study_data);

1438

study->flags = 0;

executed (the execution status of this line is deduced): study->flags = 0;

1439 -

1440 /* Set the start bits always, to avoid unset memory errors if the -

1441 study data is written to a file, but set the flag only if any of the bits -

1442 are set, to save time looking when none are. */ -

1443 -

1444

if (bits_set)

partially evaluated: bits_set

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:15

0-15

1445 { -

1446

study->flags |= PCRE_STUDY_MAPPED;

never executed (the execution status of this line is deduced): study->flags |= 0x0001;

1447

memcpy(study->start_bits, start_bits, sizeof(start_bits));

never executed (the execution status of this line is deduced): memcpy(study->start_bits, start_bits, sizeof(start_bits));

1448

else memset(study->start_bits, 0, 32 * sizeof(pcre_uint8));

never executed: }

1449

executed: memset(study->start_bits, 0, 32 * sizeof(pcre_uint8));

Execution Count:15

1450 -

1451 #ifdef PCRE_DEBUG -

1452 if (bits_set) -

1453 { -

1454 pcre_uint8 *ptr = start_bits; -

1455 int i; -

1456 -

1457 printf("Start bits:\n"); -

1458 for (i = 0; i < 32; i++) -

1459 printf("%3d: %02x%s", i * 8, *ptr++, ((i + 1) & 0x7) != 0? " " : "\n"); -

1460 } -

1461 #endif -

1462 -

1463 /* Always set the minlength value in the block, because the JIT compiler -

1464 makes use of it. However, don't set the bit unless the length is greater than -

1465 zero - the interpretive pcre_exec() and pcre_dfa_exec() needn't waste time -

1466 checking the zero case. */ -

1467 -

1468

if (min > 0)

evaluated: min > 0

TRUE	FALSE
yes Evaluation Count:6	yes Evaluation Count:9

6-9

1469 { -

1470

study->flags |= PCRE_STUDY_MINLEN;

executed (the execution status of this line is deduced): study->flags |= 0x0002;

1471

study->minlength = min;

executed (the execution status of this line is deduced): study->minlength = min;

1472

else study->minlength = 0;

executed: }

Execution Count:6

1473

executed: study->minlength = 0;

Execution Count:9

1474 -

1475 /* If JIT support was compiled and requested, attempt the JIT compilation. -

1476 If no starting bytes were found, and the minimum length is zero, and JIT -

1477 compilation fails, abandon the extra block and return NULL. */ -

1478 -

1479 #ifdef SUPPORT_JIT -

1480

extra->executable_jit = NULL;

executed (the execution status of this line is deduced): extra->executable_jit = ((void *)0);

1481

if ((options & PCRE_STUDY_JIT_COMPILE) != 0) PRIV(jit_compile)(re, extra);

executed: _pcre16_jit_compile(re, extra);

Execution Count:15

partially evaluated: (options & 0x0001) != 0

TRUE	FALSE
yes Evaluation Count:15	no Evaluation Count:0

0-15

1482

if (study->flags == 0 && (extra->flags & PCRE_EXTRA_EXECUTABLE_JIT) == 0)

evaluated: study->flags == 0

TRUE	FALSE
yes Evaluation Count:9	yes Evaluation Count:6

partially evaluated: (extra->flags & 0x0040) == 0

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:9

0-9

1483 { -

1484 #ifdef COMPILE_PCRE8 -

1485 pcre_free_study(extra); -

1486 #endif -

1487 #ifdef COMPILE_PCRE16 -

1488

pcre16_free_study(extra);

never executed (the execution status of this line is deduced): pcre16_free_study(extra);

1489 #endif -

1490

extra = NULL;

never executed (the execution status of this line is deduced): extra = ((void *)0);

1491

never executed: }

1492 #endif -

1493

if ((extra->flags & PCRE_EXTRA_EXECUTABLE_JIT) != 0 &&

executed: }

Execution Count:15

1494 -

1495

return extra;

executed: return extra;

Execution Count:15

1496 } -

1497 -

1498 -

1499 /************************************************* -

1500 * Free the study data * -

1501 *************************************************/ -

1502 -

1503 /* This function frees the memory that was obtained by pcre_study(). -

1504 -

1505 Argument: a pointer to the pcre[16]_extra block -

1506 Returns: nothing -

1507 */ -

1508 -

1509 #ifdef COMPILE_PCRE8 -

1510 PCRE_EXP_DEFN void -

1511 pcre_free_study(pcre_extra *extra) -

1512 #else -

1513 PCRE_EXP_DEFN void -

1514 pcre16_free_study(pcre16_extra *extra) -

1515 #endif -

1516 { -

1517

if (extra == NULL)

evaluated: extra == ((void *)0)

TRUE	FALSE
yes Evaluation Count:937	yes Evaluation Count:15

15-937

1518

return;

executed: return;

Execution Count:937

937

1519 #ifdef SUPPORT_JIT -

1520

partially evaluated: (extra->flags & 0x0040) != 0

TRUE	FALSE
yes Evaluation Count:15	no Evaluation Count:0

0-15

1521

extra->executable_jit != NULL)

partially evaluated: extra->executable_jit != ((void *)0)

TRUE	FALSE
yes Evaluation Count:15	no Evaluation Count:0

0-15

1522

PRIV(jit_free)(extra->executable_jit);

executed: _pcre16_jit_free(extra->executable_jit);

Execution Count:15

1523 #endif -

1524

PUBL(free)(extra);

executed (the execution status of this line is deduced): pcre16_free(extra);

1525