../3rdparty/pcre/pcre_compile.c

int newsize = cd->workspace_size * 2;

executed: }

Execution Count:198

198

661

return s;

executed: return s;

Execution Count:12

662 } -

663 -

664 -

665 /************************************************* -

666 * Expand the workspace * -

667 *************************************************/ -

668 -

669 /* This function is called during the second compiling phase, if the number of -

670 forward references fills the existing workspace, which is originally a block on -

671 the stack. A larger block is obtained from malloc() unless the ultimate limit -

672 has been reached or the increase will be rather small. -

673 -

674 Argument: pointer to the compile data block -

675 Returns: 0 if all went well, else an error number -

676 */ -

677 -

678 static int -

679 expand_workspace(compile_data *cd) -

680 { -

681

pcre_uchar *newspace;

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

682

never executed (the execution status of this line is deduced): int newsize = cd->workspace_size * 2;

683 -

684

if (newsize > COMPILE_WORK_SIZE_MAX) newsize = COMPILE_WORK_SIZE_MAX;

never executed: newsize = (100*(2048*1));

never evaluated: newsize > (100*(2048*1))

685

if (cd->workspace_size >= COMPILE_WORK_SIZE_MAX ||

never evaluated: cd->workspace_size >= (100*(2048*1))

686

newsize - cd->workspace_size < WORK_SIZE_SAFETY_MARGIN)

never evaluated: newsize - cd->workspace_size < (100)

687

return ERR72;

never executed: return ERR72;

688 -

689

newspace = (PUBL(malloc))(IN_UCHARS(newsize));

never executed (the execution status of this line is deduced): newspace = (pcre16_malloc)(((newsize) << 1));

690

if (newspace == NULL) return ERR21;

never executed: return ERR21;

never evaluated: newspace == ((void *)0)

691

memcpy(newspace, cd->start_workspace, cd->workspace_size * sizeof(pcre_uchar));

never executed (the execution status of this line is deduced): memcpy(newspace, cd->start_workspace, cd->workspace_size * sizeof(pcre_uchar));

692

cd->hwm = (pcre_uchar *)newspace + (cd->hwm - cd->start_workspace);

never executed (the execution status of this line is deduced): cd->hwm = (pcre_uchar *)newspace + (cd->hwm - cd->start_workspace);

693

if (cd->workspace_size > COMPILE_WORK_SIZE)

never evaluated: cd->workspace_size > (2048*1)

694

(PUBL(free))((void *)cd->start_workspace);

never executed: (pcre16_free)((void *)cd->start_workspace);

695

cd->start_workspace = newspace;

never executed (the execution status of this line is deduced): cd->start_workspace = newspace;

696

cd->workspace_size = newsize;

never executed (the execution status of this line is deduced): cd->workspace_size = newsize;

697

return 0;

never executed: return 0;

698 } -

699 -

700 -

701 -

702 /************************************************* -

703 * Check for counted repeat * -

704 *************************************************/ -

705 -

706 /* This function is called when a '{' is encountered in a place where it might -

707 start a quantifier. It looks ahead to see if it really is a quantifier or not. -

708 It is only a quantifier if it is one of the forms {ddd} {ddd,} or {ddd,ddd} -

709 where the ddds are digits. -

710 -

711 Arguments: -

712 p pointer to the first char after '{' -

713 -

714 Returns: TRUE or FALSE -

715 */ -

716 -

717 static BOOL -

718 is_counted_repeat(const pcre_uchar *p) -

719 { -

720

if (!IS_DIGIT(*p)) return FALSE;

executed: return 0;

Execution Count:2

evaluated: (*p) >= '\060'

TRUE	FALSE
yes Evaluation Count:24	yes Evaluation Count:2

partially evaluated: (*p) <= '\071'

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

0-24

721

p++;

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

722

while (IS_DIGIT(*p)) p++;

never executed: p++;

evaluated: (*p) >= '\060'

TRUE	FALSE
yes Evaluation Count:16	yes Evaluation Count:8

partially evaluated: (*p) <= '\071'

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

0-16

723

if (*p == CHAR_RIGHT_CURLY_BRACKET) return TRUE;

executed: return 1;

Execution Count:16

evaluated: *p == '\175'

TRUE	FALSE
yes Evaluation Count:16	yes Evaluation Count:8

8-16

724 -

725

if (*p++ != CHAR_COMMA) return FALSE;

never executed: return 0;

partially evaluated: *p++ != '\054'

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

0-8

726

if (*p == CHAR_RIGHT_CURLY_BRACKET) return TRUE;

never executed: return 1;

partially evaluated: *p == '\175'

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

0-8

727 -

728

if (!IS_DIGIT(*p)) return FALSE;

never executed: return 0;

partially evaluated: (*p) >= '\060'

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

partially evaluated: (*p) <= '\071'

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

0-8

729

p++;

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

730

while (IS_DIGIT(*p)) p++;

never executed: p++;

partially evaluated: (*p) >= '\060'

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

partially evaluated: (*p) <= '\071'

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

0-8

731 -

732

return (*p == CHAR_RIGHT_CURLY_BRACKET);

executed: return (*p == '\175');

Execution Count:8

733 } -

734 -

735 -

736 -

737 /************************************************* -

738 * Handle escapes * -

739 *************************************************/ -

740 -

741 /* This function is called when a \ has been encountered. It either returns a -

742 positive value for a simple escape such as \n, or a negative value which -

743 encodes one of the more complicated things such as \d. A backreference to group -

744 n is returned as -(ESC_REF + n); ESC_REF is the highest ESC_xxx macro. When -

745 UTF-8 is enabled, a positive value greater than 255 may be returned. On entry, -

746 ptr is pointing at the \. On exit, it is on the final character of the escape -

747 sequence. -

748 -

749 Arguments: -

750 ptrptr points to the pattern position pointer -

751 errorcodeptr points to the errorcode variable -

752 bracount number of previous extracting brackets -

753 options the options bits -

754 isclass TRUE if inside a character class -

755 -

756 Returns: zero or positive => a data character -

757 negative => a special escape sequence -

758 on error, errorcodeptr is set -

759 */ -

760 -

761 static int -

762 check_escape(const pcre_uchar **ptrptr, int *errorcodeptr, int bracount, -

763 int options, BOOL isclass) -

764 { -

765 /* PCRE_UTF16 has the same value as PCRE_UTF8. */ -

766

BOOL utf = (options & PCRE_UTF8) != 0;

executed (the execution status of this line is deduced): BOOL utf = (options & 0x00000800) != 0;

767

const pcre_uchar *ptr = *ptrptr + 1;

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

768

pcre_int32 c;

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

769

int i;

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

770 -

771

GETCHARINCTEST(c, ptr); /* Get character value, increment pointer */

executed: }

Execution Count:6

partially evaluated: utf

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

evaluated: (c & 0xfc00) == 0xd800

TRUE	FALSE
yes Evaluation Count:6	yes Evaluation Count:970

0-976

772

ptr--; /* Set pointer back to the last byte */

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

773 -

774 /* If backslash is at the end of the pattern, it's an error. */ -

775 -

776

if (c == 0) *errorcodeptr = ERR1;

executed: *errorcodeptr = ERR1;

Execution Count:7

evaluated: c == 0

TRUE	FALSE
yes Evaluation Count:7	yes Evaluation Count:969

7-969

777 -

778 /* Non-alphanumerics are literals. For digits or letters, do an initial lookup -

779 in a table. A non-zero result is something that can be returned immediately. -

780 Otherwise further processing may be required. */ -

781 -

782 #ifndef EBCDIC /* ASCII/UTF-8 coding */ -

783 /* Not alphanumeric */ -

784

else if (c < CHAR_0 || c > CHAR_z) {}

executed: }

Execution Count:306

evaluated: c < '\060'

TRUE	FALSE
yes Evaluation Count:266	yes Evaluation Count:703

evaluated: c > '\172'

TRUE	FALSE
yes Evaluation Count:40	yes Evaluation Count:663

40-703

785

else if ((i = escapes[c - CHAR_0]) != 0) c = i;

executed: c = i;

Execution Count:643

evaluated: (i = escapes[c - '\060']) != 0

TRUE	FALSE
yes Evaluation Count:643	yes Evaluation Count:20

20-643

786 -

787 #else /* EBCDIC coding */ -

788 /* Not alphanumeric */ -

789 else if (c < 'a' || (!MAX_255(c) || (ebcdic_chartab[c] & 0x0E) == 0)) {} -

790 else if ((i = escapes[c - 0x48]) != 0) c = i; -

791 #endif -

792 -

793 /* Escapes that need further processing, or are illegal. */ -

794 -

795 else -

796 { -

797

const pcre_uchar *oldptr;

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

798

BOOL braced, negated;

executed (the execution status of this line is deduced): BOOL braced, negated;

799 -

800 switch (c) -

801 { -

802 /* A number of Perl escapes are not handled by PCRE. We give an explicit -

803 error. */ -

804 -

805 case CHAR_l: -

806 case CHAR_L: -

807

*errorcodeptr = ERR37;

never executed (the execution status of this line is deduced): *errorcodeptr = ERR37;

808

if ((options & PCRE_JAVASCRIPT_COMPAT) != 0)

never executed: break;

809 -

810 case CHAR_u: -

811

never evaluated: (options & 0x02000000) != 0

812 { -

813 /* In JavaScript, \u must be followed by four hexadecimal numbers. -

814 Otherwise it is a lowercase u letter. */ -

815

if (MAX_255(ptr[1]) && (digitab[ptr[1]] & ctype_xdigit) != 0

never evaluated: ((ptr[1]) <= 255u)

never evaluated: (digitab[ptr[1]] & 0x08) != 0

816

&& MAX_255(ptr[2]) && (digitab[ptr[2]] & ctype_xdigit) != 0

never evaluated: ((ptr[2]) <= 255u)

never evaluated: (digitab[ptr[2]] & 0x08) != 0

817

&& MAX_255(ptr[3]) && (digitab[ptr[3]] & ctype_xdigit) != 0

never evaluated: ((ptr[3]) <= 255u)

never evaluated: (digitab[ptr[3]] & 0x08) != 0

818

&& MAX_255(ptr[4]) && (digitab[ptr[4]] & ctype_xdigit) != 0)

never evaluated: ((ptr[4]) <= 255u)

never evaluated: (digitab[ptr[4]] & 0x08) != 0

819 { -

820

if (cc >= CHAR_a) cc -= 32; /* Convert to upper case */

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

821

for (i = 0; i < 4; ++i)

never evaluated: i < 4

822 { -

823

never executed (the execution status of this line is deduced): register int cc = *(++ptr);

824 #ifndef EBCDIC /* ASCII/UTF-8 coding */ -

825

never executed: cc -= 32;

never evaluated: cc >= '\141'

826

c = (c << 4) + cc - ((cc < CHAR_A)? CHAR_0 : (CHAR_A - 10));

never evaluated: (cc < '\101')

827 #else /* EBCDIC coding */ -

828 if (cc >= CHAR_a && cc <= CHAR_z) cc += 64; /* Convert to upper case */ -

829 c = (c << 4) + cc - ((cc >= CHAR_0)? CHAR_0 : (CHAR_A - 10)); -

830 #endif -

never executed: }

never executed: }

never executed: }

834 else -

835

*errorcodeptr = ERR37;

never executed: *errorcodeptr = ERR37;

836

if ((options & PCRE_JAVASCRIPT_COMPAT) == 0) *errorcodeptr = ERR37;

never executed: break;

837 -

838 case CHAR_U: -

839 /* In JavaScript, \U is an uppercase U letter. */ -

840

never executed: *errorcodeptr = ERR37;

never evaluated: (options & 0x02000000) == 0

841

if (ptr[1] == CHAR_LESS_THAN_SIGN || ptr[1] == CHAR_APOSTROPHE)

never executed: break;

842 -

843 /* In a character class, \g is just a literal "g". Outside a character -

844 class, \g must be followed by one of a number of specific things: -

845 -

846 (1) A number, either plain or braced. If positive, it is an absolute -

847 backreference. If negative, it is a relative backreference. This is a Perl -

848 5.10 feature. -

849 -

850 (2) Perl 5.10 also supports \g{name} as a reference to a named group. This -

851 is part of Perl's movement towards a unified syntax for back references. As -

852 this is synonymous with \k{name}, we fudge it up by pretending it really -

853 was \k. -

854 -

855 (3) For Oniguruma compatibility we also support \g followed by a name or a -

856 number either in angle brackets or in single quotes. However, these are -

857 (possibly recursive) subroutine calls, _not_ backreferences. Just return -

858 the -ESC_g code (cf \k). */ -

859 -

860 case CHAR_g: -

861

if (isclass) break;

never executed: break;

never evaluated: isclass

862

never evaluated: ptr[1] == '\074'

never evaluated: ptr[1] == '\047'

863 { -

864

c = -ESC_g;

never executed (the execution status of this line is deduced): c = -ESC_g;

865

if (ptr[1] == CHAR_LEFT_CURLY_BRACKET)

never executed: break;

866 } -

867 -

868 /* Handle the Perl-compatible cases */ -

869 -

870

never evaluated: ptr[1] == '\173'

871 { -

872

const pcre_uchar *p;

never executed (the execution status of this line is deduced): const pcre_uchar *p;

873

for (p = ptr+2; *p != 0 && *p != CHAR_RIGHT_CURLY_BRACKET; p++)

never evaluated: *p != 0

never evaluated: *p != '\175'

874

if (*p != CHAR_MINUS && !IS_DIGIT(*p)) break;

never executed: break;

never evaluated: *p != '\055'

never evaluated: (*p) >= '\060'

never evaluated: (*p) <= '\071'

875

if (*p != 0 && *p != CHAR_RIGHT_CURLY_BRACKET)

never evaluated: *p != 0

never evaluated: *p != '\175'

876 { -

877

c = -ESC_k;

never executed (the execution status of this line is deduced): c = -ESC_k;

878

never executed: break;

879 } -

880

braced = TRUE;

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

881

if (ptr[1] == CHAR_MINUS)

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

never executed: }

never executed: braced = 0;

884 -

885

never evaluated: ptr[1] == '\055'

886 { -

887

negated = TRUE;

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

888

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

889

never executed: }

890

else negated = FALSE;

never executed: negated = 0;

891 -

892 /* The integer range is limited by the machine's int representation. */ -

893

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

894

if (((unsigned int)c) > INT_MAX / 10) /* Integer overflow */

never evaluated: (ptr[1]) >= '\060'

never evaluated: (ptr[1]) <= '\071'

895 { -

896

never evaluated: ((unsigned int)c) > 2147483647 / 10

897 { -

898

c = -1;

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

899

c = c * 10 + *(++ptr) - CHAR_0;

never executed: break;

900 } -

901

never executed (the execution status of this line is deduced): c = c * 10 + *(++ptr) - '\060';

902

if (((unsigned int)c) > INT_MAX) /* Integer overflow */

never executed: }

903

never evaluated: ((unsigned int)c) > 2147483647

904 { -

905

never evaluated: (ptr[1]) >= '\060'

never evaluated: (ptr[1]) <= '\071'

906

never executed: ptr++;

907

*errorcodeptr = ERR61;

never executed (the execution status of this line is deduced): *errorcodeptr = ERR61;

908

if (braced && *(++ptr) != CHAR_RIGHT_CURLY_BRACKET)

never executed: break;

909 } -

910 -

911

never evaluated: braced

never evaluated: *(++ptr) != '\175'

912 { -

913

*errorcodeptr = ERR57;

never executed (the execution status of this line is deduced): *errorcodeptr = ERR57;

914

never executed: break;

915 } -

916 -

917

never evaluated: c == 0

918 { -

919

never executed (the execution status of this line is deduced): *errorcodeptr = ERR58;

920

never executed: break;

921 } -

922 -

923

if (negated)

never evaluated: negated

924 { -

925

if (c > bracount)

never evaluated: c > bracount

926 { -

927

never executed (the execution status of this line is deduced): *errorcodeptr = ERR15;

928

never executed: break;

929 } -

930

c = bracount - (c - 1);

never executed (the execution status of this line is deduced): c = bracount - (c - 1);

931

never executed: }

932 -

933

c = -(ESC_REF + c);

never executed (the execution status of this line is deduced): c = -(ESC_REF + c);

934

never executed: break;

935 -

936 /* The handling of escape sequences consisting of a string of digits -

937 starting with one that is not zero is not straightforward. By experiment, -

938 the way Perl works seems to be as follows: -

939 -

940 Outside a character class, the digits are read as a decimal number. If the -

941 number is less than 10, or if there are that many previous extracting -

942 left brackets, then it is a back reference. Otherwise, up to three octal -

943 digits are read to form an escaped byte. Thus \123 is likely to be octal -

944 123 (cf \0123, which is octal 012 followed by the literal 3). If the octal -

945 value is greater than 377, the least significant 8 bits are taken. Inside a -

946 character class, \ followed by a digit is always an octal number. */ -

947 -

948 case CHAR_1: case CHAR_2: case CHAR_3: case CHAR_4: case CHAR_5: -

949 case CHAR_6: case CHAR_7: case CHAR_8: case CHAR_9: -

950 -

951

if (!isclass)

never evaluated: !isclass

952 { -

953

oldptr = ptr;

never executed (the execution status of this line is deduced): oldptr = ptr;

954 /* The integer range is limited by the machine's int representation. */ -

955

c -= CHAR_0;

never executed (the execution status of this line is deduced): c -= '\060';

956

if (((unsigned int)c) > INT_MAX / 10) /* Integer overflow */

never evaluated: (ptr[1]) >= '\060'

never evaluated: (ptr[1]) <= '\071'

957 { -

958

never evaluated: ((unsigned int)c) > 2147483647 / 10

959 { -

960

c = -1;

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

961

c = c * 10 + *(++ptr) - CHAR_0;

never executed: break;

962 } -

963

never executed (the execution status of this line is deduced): c = c * 10 + *(++ptr) - '\060';

964

if (((unsigned int)c) > INT_MAX) /* Integer overflow */

never executed: }

965

never evaluated: ((unsigned int)c) > 2147483647

966 { -

967

never evaluated: (ptr[1]) >= '\060'

never evaluated: (ptr[1]) <= '\071'

968

never executed: ptr++;

969

*errorcodeptr = ERR61;

never executed (the execution status of this line is deduced): *errorcodeptr = ERR61;

970

if (c < 10 || c <= bracount)

never executed: break;

971 } -

972

never evaluated: c < 10

never evaluated: c <= bracount

973 { -

974

c = -(ESC_REF + c);

never executed (the execution status of this line is deduced): c = -(ESC_REF + c);

975

ptr = oldptr; /* Put the pointer back and fall through */

never executed: break;

976 } -

977

never executed (the execution status of this line is deduced): ptr = oldptr;

978

if ((c = *ptr) >= CHAR_8)

never executed: }

979 -

980 /* Handle an octal number following \. If the first digit is 8 or 9, Perl -

981 generates a binary zero byte and treats the digit as a following literal. -

982 Thus we have to pull back the pointer by one. */ -

983 -

984

never evaluated: (c = *ptr) >= '\070'

985 { -

986

ptr--;

never executed (the execution status of this line is deduced): ptr--;

987

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

988

while(i++ < 2 && ptr[1] >= CHAR_0 && ptr[1] <= CHAR_7)

never executed: break;

989 } -

990 -

991 /* \0 always starts an octal number, but we may drop through to here with a -

992 larger first octal digit. The original code used just to take the least -

993 significant 8 bits of octal numbers (I think this is what early Perls used -

994 to do). Nowadays we allow for larger numbers in UTF-8 mode and 16-bit mode, -

995 but no more than 3 octal digits. */ -

996 -

997

case CHAR_0:

code before this statement never executed: case '\060':

998

c -= CHAR_0;

executed (the execution status of this line is deduced): c -= '\060';

999

partially evaluated: i++ < 2

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

partially evaluated: ptr[1] >= '\060'

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

partially evaluated: ptr[1] <= '\067'

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

0-12

1000

c = c * 8 + *(++ptr) - CHAR_0;

never executed: c = c * 8 + *(++ptr) - '\060';

1001 #ifdef COMPILE_PCRE8 -

1002 if (!utf && c > 0xff) *errorcodeptr = ERR51; -

1003 #endif -

1004

if ((options & PCRE_JAVASCRIPT_COMPAT) != 0)

executed: break;

Execution Count:12

1005 -

1006 /* \x is complicated. \x{ddd} is a character number which can be greater -

1007 than 0xff in utf or non-8bit mode, but only if the ddd are hex digits. -

1008 If not, { is treated as a data character. */ -

1009 -

1010 case CHAR_x: -

1011

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

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

0-8

1012 { -

1013 /* In JavaScript, \x must be followed by two hexadecimal numbers. -

1014 Otherwise it is a lowercase x letter. */ -

1015

if (MAX_255(ptr[1]) && (digitab[ptr[1]] & ctype_xdigit) != 0

never evaluated: ((ptr[1]) <= 255u)

never evaluated: (digitab[ptr[1]] & 0x08) != 0

1016

&& MAX_255(ptr[2]) && (digitab[ptr[2]] & ctype_xdigit) != 0)

never evaluated: ((ptr[2]) <= 255u)

never evaluated: (digitab[ptr[2]] & 0x08) != 0

1017 { -

1018

if (cc >= CHAR_a) cc -= 32; /* Convert to upper case */

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

1019

for (i = 0; i < 2; ++i)

never evaluated: i < 2

1020 { -

1021

never executed (the execution status of this line is deduced): register int cc = *(++ptr);

1022 #ifndef EBCDIC /* ASCII/UTF-8 coding */ -

1023

never executed: cc -= 32;

never evaluated: cc >= '\141'

1024

c = (c << 4) + cc - ((cc < CHAR_A)? CHAR_0 : (CHAR_A - 10));

never evaluated: (cc < '\101')

1025 #else /* EBCDIC coding */ -

1026 if (cc >= CHAR_a && cc <= CHAR_z) cc += 64; /* Convert to upper case */ -

1027 c = (c << 4) + cc - ((cc >= CHAR_0)? CHAR_0 : (CHAR_A - 10)); -

1028 #endif -

never executed: }

never executed: }

never executed: break;

1032 } -

1033 -

1034

if (ptr[1] == CHAR_LEFT_CURLY_BRACKET)

partially evaluated: ptr[1] == '\173'

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

0-8

1035 { -

1036

const pcre_uchar *pt = ptr + 2;

executed (the execution status of this line is deduced): const pcre_uchar *pt = ptr + 2;

1037 -

1038

while (MAX_255(*pt) && (digitab[*pt] & ctype_xdigit) != 0)

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

1039

partially evaluated: ((*pt) <= 255u)

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

evaluated: (digitab[*pt] & 0x08) != 0

TRUE	FALSE
yes Evaluation Count:32	yes Evaluation Count:8

0-40

1040 { -

1041

executed (the execution status of this line is deduced): register int cc = *pt++;

1042

if (c == 0 && cc == CHAR_0) continue; /* Leading zeroes */

executed: continue;

Execution Count:16

evaluated: c == 0

TRUE	FALSE
yes Evaluation Count:20	yes Evaluation Count:12

evaluated: cc == '\060'

TRUE	FALSE
yes Evaluation Count:16	yes Evaluation Count:4

4-20

1043 -

1044 #ifndef EBCDIC /* ASCII/UTF-8 coding */ -

1045

if (cc >= CHAR_a) cc -= 32; /* Convert to upper case */

never executed: cc -= 32;

partially evaluated: cc >= '\141'

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

0-16

1046

c = (c << 4) + cc - ((cc < CHAR_A)? CHAR_0 : (CHAR_A - 10));

partially evaluated: (cc < '\101')

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

0-16

1047 #else /* EBCDIC coding */ -

1048 if (cc >= CHAR_a && cc <= CHAR_z) cc += 64; /* Convert to upper case */ -

1049 c = (c << 4) + cc - ((cc >= CHAR_0)? CHAR_0 : (CHAR_A - 10)); -

1050 #endif -

1051 -

1052 #ifdef COMPILE_PCRE8 -

1053 if (c > (utf ? 0x10ffff : 0xff)) { c = -1; break; } -

1054 #else -

1055 #ifdef COMPILE_PCRE16 -

1056

if (c > (utf ? 0x10ffff : 0xffff)) { c = -1; break; }

never executed: break;

partially evaluated: c > (utf ? 0x10ffff : 0xffff)

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

0-16

1057 #endif -

1058 #endif -

1059

while (MAX_255(*pt) && (digitab[*pt] & ctype_xdigit) != 0) pt++;

executed: }

Execution Count:16

1060 -

1061

if (c < 0)

partially evaluated: c < 0

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

0-8

1062 { -

1063

never executed: pt++;

never evaluated: ((*pt) <= 255u)

never evaluated: (digitab[*pt] & 0x08) != 0

1064

*errorcodeptr = ERR34;

never executed (the execution status of this line is deduced): *errorcodeptr = ERR34;

1065

if (*pt == CHAR_RIGHT_CURLY_BRACKET)

never executed: }

1066 -

1067

partially evaluated: *pt == '\175'

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

0-8

1068 { -

1069

if (utf && c >= 0xd800 && c <= 0xdfff) *errorcodeptr = ERR73;

never executed: *errorcodeptr = ERR73;

partially evaluated: utf

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

evaluated: c >= 0xd800

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

partially evaluated: c <= 0xdfff

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

0-8

1070

ptr = pt;

executed (the execution status of this line is deduced): ptr = pt;

1071

executed: break;

Execution Count:8

1072 } -

1073 -

1074 /* If the sequence of hex digits does not end with '}', then we don't -

1075 recognize this construct; fall through to the normal \x handling. */ -

1076

never executed: }

1077 -

1078 /* Read just a single-byte hex-defined char */ -

1079 -

1080

while (i++ < 2 && MAX_255(ptr[1]) && (digitab[ptr[1]] & ctype_xdigit) != 0)

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

1081

never evaluated: i++ < 2

never evaluated: ((ptr[1]) <= 255u)

never evaluated: (digitab[ptr[1]] & 0x08) != 0

1082 { -

1083

int cc; /* Some compilers don't like */

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

1084

cc = *(++ptr); /* ++ in initializers */

never executed (the execution status of this line is deduced): cc = *(++ptr);

1085 #ifndef EBCDIC /* ASCII/UTF-8 coding */ -

1086

if (cc >= CHAR_a) cc -= 32; /* Convert to upper case */

never executed: cc -= 32;

never evaluated: cc >= '\141'

1087

c = c * 16 + cc - ((cc < CHAR_A)? CHAR_0 : (CHAR_A - 10));

never evaluated: (cc < '\101')

1088 #else /* EBCDIC coding */ -

1089 if (cc <= CHAR_z) cc += 64; /* Convert to upper case */ -

1090 c = c * 16 + cc - ((cc >= CHAR_0)? CHAR_0 : (CHAR_A - 10)); -

1091 #endif -

never executed: }

never executed: break;

1094 -

1095 /* For \c, a following letter is upper-cased; then the 0x40 bit is flipped. -

1096 An error is given if the byte following \c is not an ASCII character. This -

1097 coding is ASCII-specific, but then the whole concept of \cx is -

1098 ASCII-specific. (However, an EBCDIC equivalent has now been added.) */ -

1099 -

1100 case CHAR_c: -

1101

never executed (the execution status of this line is deduced): c = *(++ptr);

1102

never evaluated: c == 0

1103 { -

1104

*errorcodeptr = ERR2;

never executed (the execution status of this line is deduced): *errorcodeptr = ERR2;

1105

if (c > 127) /* Excludes all non-ASCII in either mode */

never executed: break;

1106 } -

1107 #ifndef EBCDIC /* ASCII/UTF-8 coding */ -

1108

never evaluated: c > 127

1109 { -

1110

*errorcodeptr = ERR68;

never executed (the execution status of this line is deduced): *errorcodeptr = ERR68;

1111

if (c >= CHAR_a && c <= CHAR_z) c -= 32;

never executed: break;

1112 } -

1113

never executed: c -= 32;

never evaluated: c >= '\141'

never evaluated: c <= '\172'

1114

c ^= 0x40;

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

1115 #else /* EBCDIC coding */ -

1116 if (c >= CHAR_a && c <= CHAR_z) c += 64; -

1117 c ^= 0xC0; -

1118 #endif -

1119

if ((options & PCRE_EXTRA) != 0) switch(c)

never executed: break;

1120 -

1121 /* PCRE_EXTRA enables extensions to Perl in the matter of escapes. Any -

1122 other alphanumeric following \ is an error if PCRE_EXTRA was set; -

1123 otherwise, for Perl compatibility, it is a literal. This code looks a bit -

1124 odd, but there used to be some cases other than the default, and there may -

1125 be again in future, so I haven't "optimized" it. */ -

1126 -

1127 default: -

1128

never evaluated: (options & 0x00000040) != 0

1129 { -

1130 default: -

1131

*errorcodeptr = ERR3;

never executed (the execution status of this line is deduced): *errorcodeptr = ERR3;

1132

never executed: break;

never executed: }

never executed: break;

1135 } -

1136

if (c == -ESC_N && ptr[1] == CHAR_LEFT_CURLY_BRACKET &&

executed: }

Execution Count:20

1137 -

1138 /* Perl supports \N{name} for character names, as well as plain \N for "not -

1139 newline". PCRE does not support \N{name}. However, it does support -

1140 quantification such as \N{2,3}. */ -

1141 -

1142

partially evaluated: c == -ESC_N

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

never evaluated: ptr[1] == '\173'

0-976

1143

!is_counted_repeat(ptr+2))

never evaluated: !is_counted_repeat(ptr+2)

1144

*errorcodeptr = ERR37;

never executed: *errorcodeptr = ERR37;

1145 -

1146 /* If PCRE_UCP is set, we change the values for \d etc. */ -

1147 -

1148

if ((options & PCRE_UCP) != 0 && c <= -ESC_D && c >= -ESC_w)

evaluated: (options & 0x20000000) != 0

TRUE	FALSE
yes Evaluation Count:8	yes Evaluation Count:968

partially evaluated: c <= -ESC_D

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

evaluated: c >= -ESC_w

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

0-968

1149

c -= (ESC_DU - ESC_D);

executed: c -= (ESC_DU - ESC_D);

Execution Count:4

1150 -

1151 /* Set the pointer to the final character before returning. */ -

1152 -

1153

const pcre_uchar *ptr = *ptrptr;

executed (the execution status of this line is deduced): *ptrptr = ptr;

1154

return c;

executed: return c;

Execution Count:976

976

1155 } -

1156 -

1157 -

1158 -

1159 #ifdef SUPPORT_UCP -

1160 /************************************************* -

1161 * Handle \P and \p * -

1162 *************************************************/ -

1163 -

1164 /* This function is called after \P or \p has been encountered, provided that -

1165 PCRE is compiled with support for Unicode properties. On entry, ptrptr is -

1166 pointing at the P or p. On exit, it is pointing at the final character of the -

1167 escape sequence. -

1168 -

1169 Argument: -

1170 ptrptr points to the pattern position pointer -

1171 negptr points to a boolean that is set TRUE for negation else FALSE -

1172 dptr points to an int that is set to the detailed property value -

1173 errorcodeptr points to the error code variable -

1174 -

1175 Returns: type value from ucp_type_table, or -1 for an invalid type -

1176 */ -

1177 -

1178 static int -

1179 get_ucp(const pcre_uchar **ptrptr, BOOL *negptr, int *dptr, int *errorcodeptr) -

1180 { -

1181

int c, i, bot, top;

executed (the execution status of this line is deduced): int c, i, bot, top;

1182

executed (the execution status of this line is deduced): const pcre_uchar *ptr = *ptrptr;

1183

pcre_uchar name[32];

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

1184 -

1185

if (c == 0) goto ERROR_RETURN;

executed (the execution status of this line is deduced): c = *(++ptr);

1186

never executed: goto ERROR_RETURN;

partially evaluated: c == 0

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

0-7

1187 -

1188

*negptr = FALSE;

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

1189 -

1190 /* \P or \p can be followed by a name in {}, optionally preceded by ^ for -

1191 negation. */ -

1192 -

1193

if (c == CHAR_LEFT_CURLY_BRACKET)

partially evaluated: c == '\173'

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

0-7

1194 { -

1195

if (ptr[1] == CHAR_CIRCUMFLEX_ACCENT)

partially evaluated: ptr[1] == '\136'

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

0-7

1196 { -

1197

*negptr = TRUE;

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

1198

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

1199

for (i = 0; i < (int)(sizeof(name) / sizeof(pcre_uchar)) - 1; i++)

never executed: }

1200

partially evaluated: i < (int)(sizeof(name) / sizeof(pcre_uchar)) - 1

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

0-25

1201 { -

1202

if (c == 0) goto ERROR_RETURN;

executed (the execution status of this line is deduced): c = *(++ptr);

1203

never executed: goto ERROR_RETURN;

partially evaluated: c == 0

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

0-25

1204

if (c == CHAR_RIGHT_CURLY_BRACKET) break;

executed: break;

Execution Count:7

evaluated: c == '\175'

TRUE	FALSE
yes Evaluation Count:7	yes Evaluation Count:18

7-18

1205

name[i] = c;

executed (the execution status of this line is deduced): name[i] = c;

1206

if (c != CHAR_RIGHT_CURLY_BRACKET) goto ERROR_RETURN;

executed: }

Execution Count:18

1207

never executed: goto ERROR_RETURN;

partially evaluated: c != '\175'

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

0-7

1208

name[i] = 0;

executed (the execution status of this line is deduced): name[i] = 0;

1209

executed: }

Execution Count:7

1210 -

1211 /* Otherwise there is just one following character */ -

1212 -

1213 else -

1214 { -

1215

name[0] = c;

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

1216

name[1] = 0;

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

1217

never executed: }

1218 -

1219

c = STRCMP_UC_C8(name, PRIV(utt_names) + PRIV(utt)[i].name_offset);

executed (the execution status of this line is deduced): *ptrptr = ptr;

1220 -

1221 /* Search for a recognized property name using binary chop */ -

1222 -

1223

bot = 0;

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

1224

top = PRIV(utt_size);

executed (the execution status of this line is deduced): top = _pcre16_utt_size;

1225 -

1226

while (bot < top)

evaluated: bot < top

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

1-49

1227 { -

1228

i = (bot + top) >> 1;

executed (the execution status of this line is deduced): i = (bot + top) >> 1;

1229

executed (the execution status of this line is deduced): c = _pcre16_strcmp_uc_c8((name), (_pcre16_utt_names + _pcre16_utt[i].name_offset));

1230

*dptr = PRIV(utt)[i].value;

evaluated: c == 0

TRUE	FALSE
yes Evaluation Count:6	yes Evaluation Count:43

6-43

1231 { -

1232

executed (the execution status of this line is deduced): *dptr = _pcre16_utt[i].value;

1233

return PRIV(utt)[i].type;

executed: return _pcre16_utt[i].type;

Execution Count:6

1234 } -

1235

if (c > 0) bot = i + 1; else top = i;

executed: bot = i + 1;

Execution Count:20

executed: top = i;

Execution Count:23

evaluated: c > 0

TRUE	FALSE
yes Evaluation Count:20	yes Evaluation Count:23

20-23

1236 } -

1237 -

1238

*errorcodeptr = ERR47;

executed (the execution status of this line is deduced): *errorcodeptr = ERR47;

1239

executed (the execution status of this line is deduced): *ptrptr = ptr;

1240

executed: return -1;

Execution Count:1

1241 -

1242 ERROR_RETURN: -

1243

*errorcodeptr = ERR46;

never executed (the execution status of this line is deduced): *errorcodeptr = ERR46;

1244

never executed (the execution status of this line is deduced): *ptrptr = ptr;

1245

while (IS_DIGIT(*p)) min = min * 10 + *p++ - CHAR_0;

never executed: return -1;

1246 } -

1247 #endif -

1248 -

1249 -

1250 -

1251 -

1252 /************************************************* -

1253 * Read repeat counts * -

1254 *************************************************/ -

1255 -

1256 /* Read an item of the form {n,m} and return the values. This is called only -

1257 after is_counted_repeat() has confirmed that a repeat-count quantifier exists, -

1258 so the syntax is guaranteed to be correct, but we need to check the values. -

1259 -

1260 Arguments: -

1261 p pointer to first char after '{' -

1262 minp pointer to int for min -

1263 maxp pointer to int for max -

1264 returned as -1 if no max -

1265 errorcodeptr points to error code variable -

1266 -

1267 Returns: pointer to '}' on success; -

1268 current ptr on error, with errorcodeptr set non-zero -

1269 */ -

1270 -

1271 static const pcre_uchar * -

1272 read_repeat_counts(const pcre_uchar *p, int *minp, int *maxp, int *errorcodeptr) -

1273 { -

1274

int min = 0;

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

1275

int max = -1;

executed (the execution status of this line is deduced): int max = -1;

1276 -

1277 /* Read the minimum value and do a paranoid check: a negative value indicates -

1278 an integer overflow. */ -

1279 -

1280

executed: min = min * 10 + *p++ - '\060';

Execution Count:24

evaluated: (*p) >= '\060'

TRUE	FALSE
yes Evaluation Count:40	yes Evaluation Count:8

evaluated: (*p) <= '\071'

TRUE	FALSE
yes Evaluation Count:24	yes Evaluation Count:16

8-40

1281

if (min < 0 || min > 65535)

partially evaluated: min < 0

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

partially evaluated: min > 65535

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

0-24

1282 { -

1283

*errorcodeptr = ERR5;

never executed (the execution status of this line is deduced): *errorcodeptr = ERR5;

1284

if (*p == CHAR_RIGHT_CURLY_BRACKET) max = min; else

never executed: return p;

1285 } -

1286 -

1287 /* Read the maximum value if there is one, and again do a paranoid on its size. -

1288 Also, max must not be less than min. */ -

1289 -

1290

executed: max = min;

Execution Count:16

evaluated: *p == '\175'

TRUE	FALSE
yes Evaluation Count:16	yes Evaluation Count:8

8-16

1291 { -

1292

if (*(++p) != CHAR_RIGHT_CURLY_BRACKET)

partially evaluated: *(++p) != '\175'

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

0-8

1293 { -

1294

max = 0;

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

1295

while(IS_DIGIT(*p)) max = max * 10 + *p++ - CHAR_0;

executed: max = max * 10 + *p++ - '\060';

Execution Count:8

partially evaluated: (*p) >= '\060'

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

evaluated: (*p) <= '\071'

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

0-16

1296

if (max < 0 || max > 65535)

partially evaluated: max < 0

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

partially evaluated: max > 65535

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

0-8

1297 { -

1298

*errorcodeptr = ERR5;

never executed (the execution status of this line is deduced): *errorcodeptr = ERR5;

1299

never executed: return p;

1300 } -

1301

if (max < min)

partially evaluated: max < min

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

0-8

1302 { -

1303

*errorcodeptr = ERR4;

never executed (the execution status of this line is deduced): *errorcodeptr = ERR4;

1304

never executed: return p;

1305 } -

1306

executed: }

Execution Count:8

1307

executed: }

Execution Count:8

1308 -

1309 /* Fill in the required variables, and pass back the pointer to the terminating -

1310 '}'. */ -

1311 -

1312

*minp = min;

executed (the execution status of this line is deduced): *minp = min;

1313

*maxp = max;

executed (the execution status of this line is deduced): *maxp = max;

1314

pcre_uchar *ptr = *ptrptr;

executed: return p;

Execution Count:24

1315 } -

1316 -

1317 -

1318 -

1319 /************************************************* -

1320 * Subroutine for finding forward reference * -

1321 *************************************************/ -

1322 -

1323 /* This recursive function is called only from find_parens() below. The -

1324 top-level call starts at the beginning of the pattern. All other calls must -

1325 start at a parenthesis. It scans along a pattern's text looking for capturing -

1326 subpatterns, and counting them. If it finds a named pattern that matches the -

1327 name it is given, it returns its number. Alternatively, if the name is NULL, it -

1328 returns when it reaches a given numbered subpattern. Recursion is used to keep -

1329 track of subpatterns that reset the capturing group numbers - the (?| feature. -

1330 -

1331 This function was originally called only from the second pass, in which we know -

1332 that if (?< or (?' or (?P< is encountered, the name will be correctly -

1333 terminated because that is checked in the first pass. There is now one call to -

1334 this function in the first pass, to check for a recursive back reference by -

1335 name (so that we can make the whole group atomic). In this case, we need check -

1336 only up to the current position in the pattern, and that is still OK because -

1337 and previous occurrences will have been checked. To make this work, the test -

1338 for "end of pattern" is a check against cd->end_pattern in the main loop, -

1339 instead of looking for a binary zero. This means that the special first-pass -

1340 call can adjust cd->end_pattern temporarily. (Checks for binary zero while -

1341 processing items within the loop are OK, because afterwards the main loop will -

1342 terminate.) -

1343 -

1344 Arguments: -

1345 ptrptr address of the current character pointer (updated) -

1346 cd compile background data -

1347 name name to seek, or NULL if seeking a numbered subpattern -

1348 lorn name length, or subpattern number if name is NULL -

1349 xmode TRUE if we are in /x mode -

1350 utf TRUE if we are in UTF-8 / UTF-16 mode -

1351 count pointer to the current capturing subpattern number (updated) -

1352 -

1353 Returns: the number of the named subpattern, or -1 if not found -

1354 */ -

1355 -

1356 static int -

1357 find_parens_sub(pcre_uchar **ptrptr, compile_data *cd, const pcre_uchar *name, int lorn, -

1358 BOOL xmode, BOOL utf, int *count) -

1359 { -

1360

executed (the execution status of this line is deduced): pcre_uchar *ptr = *ptrptr;

1361

int start_count = *count;

executed (the execution status of this line is deduced): int start_count = *count;

1362

int hwm_count = start_count;

executed (the execution status of this line is deduced): int hwm_count = start_count;

1363

BOOL dup_parens = FALSE;

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

1364 -

1365 /* If the first character is a parenthesis, check on the type of group we are -

1366 dealing with. The very first call may not start with a parenthesis. */ -

1367 -

1368

if (ptr[0] == CHAR_LEFT_PARENTHESIS)

evaluated: ptr[0] == '\050'

TRUE	FALSE
yes Evaluation Count:14	yes Evaluation Count:2

2-14

1369 { -

1370 /* Handle specials such as (*SKIP) or (*UTF8) etc. */ -

1371 -

1372

if (ptr[1] == CHAR_ASTERISK) ptr += 2;

never executed: ptr += 2;

partially evaluated: ptr[1] == '\052'

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

0-14

1373 -

1374 /* Handle a normal, unnamed capturing parenthesis. */ -

1375 -

1376

else if (ptr[1] != CHAR_QUESTION_MARK)

evaluated: ptr[1] != '\077'

TRUE	FALSE
yes Evaluation Count:4	yes Evaluation Count:10

4-10

1377 { -

1378

*count += 1;

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

1379

if (name == NULL && *count == lorn) return *count;

executed: return *count;

Execution Count:2

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

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

partially evaluated: *count == lorn

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

0-2

1380

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

1381

else if (ptr[2] == CHAR_VERTICAL_LINE)

executed: }

Execution Count:2

1382 -

1383 /* All cases now have (? at the start. Remember when we are in a group -

1384 where the parenthesis numbers are duplicated. */ -

1385 -

1386

partially evaluated: ptr[2] == '\174'

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

0-10

1387 { -

1388

ptr += 3;

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

1389

dup_parens = TRUE;

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

1390

else if (ptr[2] == CHAR_NUMBER_SIGN)

never executed: }

1391 -

1392 /* Handle comments; all characters are allowed until a ket is reached. */ -

1393 -

1394

partially evaluated: ptr[2] == '\043'

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

0-10

1395 { -

1396

for (ptr += 3; *ptr != 0; ptr++) if (*ptr == CHAR_RIGHT_PARENTHESIS) break;

never executed: break;

never evaluated: *ptr == '\051'

never evaluated: *ptr != 0

1397

goto FAIL_EXIT;

never executed: goto FAIL_EXIT;

1398 } -

1399 -

1400 /* Handle a condition. If it is an assertion, just carry on so that it -

1401 is processed as normal. If not, skip to the closing parenthesis of the -

1402 condition (there can't be any nested parens). */ -

1403 -

1404

else if (ptr[2] == CHAR_LEFT_PARENTHESIS)

evaluated: ptr[2] == '\050'

TRUE	FALSE
yes Evaluation Count:4	yes Evaluation Count:6

4-6

1405 { -

1406

if (ptr[1] != CHAR_QUESTION_MARK)

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

1407

partially evaluated: ptr[1] != '\077'

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

0-4

1408 { -

1409

while (*ptr != 0 && *ptr != CHAR_RIGHT_PARENTHESIS) ptr++;

executed: ptr++;

Execution Count:8

partially evaluated: *ptr != 0

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

evaluated: *ptr != '\051'

TRUE	FALSE
yes Evaluation Count:8	yes Evaluation Count:4

0-12

1410

if (*ptr != 0) ptr++;

executed: ptr++;

Execution Count:4

partially evaluated: *ptr != 0

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

0-4

1411

executed: }

Execution Count:4

1412

executed: }

Execution Count:4

1413 -

1414 /* Start with (? but not a condition. */ -

1415 -

1416 else -

1417 { -

1418

if (*ptr == CHAR_P) ptr++; /* Allow optional P */

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

1419

never executed: ptr++;

partially evaluated: *ptr == '\120'

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

0-6

1420 -

1421 /* We have to disambiguate (?<! and (?<= from (?<name> for named groups */ -

1422 -

1423

if ((*ptr == CHAR_LESS_THAN_SIGN && ptr[1] != CHAR_EXCLAMATION_MARK &&

partially evaluated: *ptr == '\074'

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

never evaluated: ptr[1] != '\041'

0-6

1424

ptr[1] != CHAR_EQUALS_SIGN) || *ptr == CHAR_APOSTROPHE)

never evaluated: ptr[1] != '\075'

partially evaluated: *ptr == '\047'

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

0-6

1425 { -

1426

int term;

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

1427

const pcre_uchar *thisname;

never executed (the execution status of this line is deduced): const pcre_uchar *thisname;

1428

*count += 1;

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

1429

if (name == NULL && *count == lorn) return *count;

never executed: return *count;

never evaluated: name == ((void *)0)

never evaluated: *count == lorn

1430

term = *ptr++;

never executed (the execution status of this line is deduced): term = *ptr++;

1431

if (term == CHAR_LESS_THAN_SIGN) term = CHAR_GREATER_THAN_SIGN;

never executed: term = '\076';

never evaluated: term == '\074'

1432

thisname = ptr;

never executed (the execution status of this line is deduced): thisname = ptr;

1433

while (*ptr != term) ptr++;

never executed: ptr++;

never evaluated: *ptr != term

1434

if (name != NULL && lorn == ptr - thisname &&

never evaluated: name != ((void *)0)

never evaluated: lorn == ptr - thisname

1435

STRNCMP_UC_UC(name, thisname, lorn) == 0)

never evaluated: _pcre16_strncmp_uc_uc((name), (thisname), (lorn)) == 0

1436

return *count;

never executed: return *count;

1437

term++;

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

never executed: }

executed: }

Execution Count:6

1440 } -

1441 -

1442 /* Past any initial parenthesis handling, scan for parentheses or vertical -

1443 bars. Stop if we get to cd->end_pattern. Note that this is important for the -

1444 first-pass call when this value is temporarily adjusted to stop at the current -

1445 position. So DO NOT change this to a test for binary zero. */ -

1446 -

1447

for (; ptr < cd->end_pattern; ptr++)

evaluated: ptr < cd->end_pattern

TRUE	FALSE
yes Evaluation Count:40	yes Evaluation Count:2

2-40

1448 { -

1449 /* Skip over backslashed characters and also entire \Q...\E */ -

1450 -

1451

if (*ptr == CHAR_BACKSLASH)

partially evaluated: *ptr == '\134'

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

0-40

1452 { -

1453

if (*(++ptr) == 0) goto FAIL_EXIT;

never executed: goto FAIL_EXIT;

never evaluated: *(++ptr) == 0

1454

if (*ptr == CHAR_Q) for (;;)

never evaluated: *ptr == '\121'

1455 { -

1456

while (*(++ptr) != 0 && *ptr != CHAR_BACKSLASH) {};

never executed: }

never evaluated: *(++ptr) != 0

never evaluated: *ptr != '\134'

1457

if (*(++ptr) == CHAR_E) break;

never executed: goto FAIL_EXIT;

never evaluated: *ptr == 0

1458

never executed: break;

never evaluated: *(++ptr) == '\105'

never executed: }

never executed: continue;

1461 } -

1462 -

1463 /* Skip over character classes; this logic must be similar to the way they -

1464 are handled for real. If the first character is '^', skip it. Also, if the -

1465 first few characters (either before or after ^) are \Q\E or \E we skip them -

1466 too. This makes for compatibility with Perl. Note the use of STR macros to -

1467 encode "Q\\E" so that it works in UTF-8 on EBCDIC platforms. */ -

1468 -

1469

if (*ptr == CHAR_LEFT_SQUARE_BRACKET)

partially evaluated: *ptr == '\133'

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

0-40

1470 { -

1471

BOOL negate_class = FALSE;

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

1472

if (ptr[1] == CHAR_BACKSLASH)

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

1473 { -

1474

never evaluated: ptr[1] == '\134'

1475 { -

1476

if (ptr[2] == CHAR_E)

never evaluated: ptr[2] == '\105'

1477

ptr+= 2;

never executed: ptr+= 2;

1478

else if (STRNCMP_UC_C8(ptr + 2,

never evaluated: _pcre16_strncmp_uc_c8((ptr + 2), ("\121" "\134" "\105"), (3)) == 0

1479 STR_Q STR_BACKSLASH STR_E, 3) == 0) -

1480

ptr += 4;

never executed: ptr += 4;

1481 else -

1482

else if (!negate_class && ptr[1] == CHAR_CIRCUMFLEX_ACCENT)

never executed: break;

1483 } -

1484

never evaluated: !negate_class

never evaluated: ptr[1] == '\136'

1485 { -

1486

negate_class = TRUE;

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

1487

if (ptr[1] == CHAR_RIGHT_SQUARE_BRACKET &&

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

never executed: }

never executed: break;

1490 } -

1491 -

1492 /* If the next character is ']', it is a data character that must be -

1493 skipped, except in JavaScript compatibility mode. */ -

1494 -

1495

never evaluated: ptr[1] == '\135'

1496

(cd->external_options & PCRE_JAVASCRIPT_COMPAT) == 0)

never evaluated: (cd->external_options & 0x02000000) == 0

1497

while (*(++ptr) != CHAR_RIGHT_SQUARE_BRACKET)

never executed: ptr++;

1498 -

1499

never evaluated: *(++ptr) != '\135'

1500 { -

1501

if (*ptr == 0) return -1;

never executed: return -1;

never evaluated: *ptr == 0

1502

if (*ptr == CHAR_BACKSLASH)

never evaluated: *ptr == '\134'

1503 { -

1504

if (*(++ptr) == 0) goto FAIL_EXIT;

never executed: goto FAIL_EXIT;

never evaluated: *(++ptr) == 0

1505

if (*ptr == CHAR_Q) for (;;)

never evaluated: *ptr == '\121'

1506 { -

1507

while (*(++ptr) != 0 && *ptr != CHAR_BACKSLASH) {};

never executed: }

never evaluated: *(++ptr) != 0

never evaluated: *ptr != '\134'

1508

if (*(++ptr) == CHAR_E) break;

never executed: goto FAIL_EXIT;

never evaluated: *ptr == 0

1509

never executed: break;

never evaluated: *(++ptr) == '\105'

never executed: }

never executed: continue;

1512 } -

never executed: }

never executed: continue;

1515 } -

1516 -

1517 /* Skip comments in /x mode */ -

1518 -

1519

if (xmode && *ptr == CHAR_NUMBER_SIGN)

partially evaluated: xmode

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

never evaluated: *ptr == '\043'

0-40

1520 { -

1521

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

1522

if (IS_NEWLINE(ptr)) { ptr += cd->nllen - 1; break; }

never evaluated: *ptr != 0

1523 { -

1524

never executed: break;

never evaluated: (cd->nltype != 0)

1525

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

1526 #ifdef SUPPORT_UTF -

1527

never executed: ptr++;

never evaluated: utf

never evaluated: (*ptr & 0xfc00) == 0xdc00

1528 #endif -

1529

never executed: }

1530

never executed: goto FAIL_EXIT;

never evaluated: *ptr == 0

1531

if (*ptr == CHAR_LEFT_PARENTHESIS)

never executed: continue;

1532 } -

1533 -

1534 /* Check for the special metacharacters */ -

1535 -

1536

evaluated: *ptr == '\050'

TRUE	FALSE
yes Evaluation Count:10	yes Evaluation Count:30

10-30

1537 { -

1538

int rc = find_parens_sub(&ptr, cd, name, lorn, xmode, utf, count);

executed (the execution status of this line is deduced): int rc = find_parens_sub(&ptr, cd, name, lorn, xmode, utf, count);

1539

if (rc > 0) return rc;

executed: return rc;

Execution Count:2

evaluated: rc > 0

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

2-8

1540

never executed: goto FAIL_EXIT;

partially evaluated: *ptr == 0

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

0-8

1541

else if (*ptr == CHAR_RIGHT_PARENTHESIS)

executed: }

Execution Count:8

1542 -

1543

evaluated: *ptr == '\051'

TRUE	FALSE
yes Evaluation Count:10	yes Evaluation Count:20

10-20

1544 { -

1545

if (dup_parens && *count < hwm_count) *count = hwm_count;

never executed: *count = hwm_count;

partially evaluated: dup_parens

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

never evaluated: *count < hwm_count

0-10

1546

goto FAIL_EXIT;

executed: goto FAIL_EXIT;

Execution Count:10

1547 } -

1548 -

1549

else if (*ptr == CHAR_VERTICAL_LINE && dup_parens)

evaluated: *ptr == '\174'

TRUE	FALSE
yes Evaluation Count:4	yes Evaluation Count:16

partially evaluated: dup_parens

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

0-16

1550 { -

1551

if (*count > hwm_count) hwm_count = *count;

never executed: hwm_count = *count;

never evaluated: *count > hwm_count

1552

*count = start_count;

never executed (the execution status of this line is deduced): *count = start_count;

1553

never executed: }

1554 } -

1555 -

1556

FAIL_EXIT:

code before this statement executed: FAIL_EXIT:

Execution Count:2

1557

executed (the execution status of this line is deduced): *ptrptr = ptr;

1558

pcre_uchar *ptr = (pcre_uchar *)cd->start_pattern;

executed: return -1;

Execution Count:12

1559 } -

1560 -

1561 -

1562 -

1563 -

1564 /************************************************* -

1565 * Find forward referenced subpattern * -

1566 *************************************************/ -

1567 -

1568 /* This function scans along a pattern's text looking for capturing -

1569 subpatterns, and counting them. If it finds a named pattern that matches the -

1570 name it is given, it returns its number. Alternatively, if the name is NULL, it -

1571 returns when it reaches a given numbered subpattern. This is used for forward -

1572 references to subpatterns. We used to be able to start this scan from the -

1573 current compiling point, using the current count value from cd->bracount, and -

1574 do it all in a single loop, but the addition of the possibility of duplicate -

1575 subpattern numbers means that we have to scan from the very start, in order to -

1576 take account of such duplicates, and to use a recursive function to keep track -

1577 of the different types of group. -

1578 -

1579 Arguments: -

1580 cd compile background data -

1581 name name to seek, or NULL if seeking a numbered subpattern -

1582 lorn name length, or subpattern number if name is NULL -

1583 xmode TRUE if we are in /x mode -

1584 utf TRUE if we are in UTF-8 / UTF-16 mode -

1585 -

1586 Returns: the number of the found subpattern, or -1 if not found -

1587 */ -

1588 -

1589 static int -

1590 find_parens(compile_data *cd, const pcre_uchar *name, int lorn, BOOL xmode, -

1591 BOOL utf) -

1592 { -

1593

executed (the execution status of this line is deduced): pcre_uchar *ptr = (pcre_uchar *)cd->start_pattern;

1594

int count = 0;

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

1595

int rc;

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

1596 -

1597 /* If the pattern does not start with an opening parenthesis, the first call -

1598 to find_parens_sub() will scan right to the end (if necessary). However, if it -

1599 does start with a parenthesis, find_parens_sub() will return when it hits the -

1600 matching closing parens. That is why we have to have a loop. */ -

1601 -

1602

rc = find_parens_sub(&ptr, cd, name, lorn, xmode, utf, &count);

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

1603 { -

1604

executed (the execution status of this line is deduced): rc = find_parens_sub(&ptr, cd, name, lorn, xmode, utf, &count);

1605

if (rc > 0 || *ptr++ == 0) break;

executed: break;

Execution Count:4

evaluated: rc > 0

TRUE	FALSE
yes Evaluation Count:2	yes Evaluation Count:4

evaluated: *ptr++ == 0

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

2-4

1606

executed: }

Execution Count:2

1607 -

1608

return rc;

executed: return rc;

Execution Count:4

1609 } -

1610 -

1611 -

1612 -

1613 -

1614 /************************************************* -

1615 * Find first significant op code * -

1616 *************************************************/ -

1617 -

1618 /* This is called by several functions that scan a compiled expression looking -

1619 for a fixed first character, or an anchoring op code etc. It skips over things -

1620 that do not influence this. For some calls, it makes sense to skip negative -

1621 forward and all backward assertions, and also the \b assertion; for others it -

1622 does not. -

1623 -

1624 Arguments: -

1625 code pointer to the start of the group -

1626 skipassert TRUE if certain assertions are to be skipped -

1627 -

1628 Returns: pointer to the first significant opcode -

1629 */ -

1630 -

1631 static const pcre_uchar* -

1632 first_significant_code(const pcre_uchar *code, BOOL skipassert) -

1633 { -

1634

if (!skipassert) return code;

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

1635 { -

1636 switch ((int)*code) -

1637 { -

1638 case OP_ASSERT_NOT: -

1639 case OP_ASSERTBACK: -

1640 case OP_ASSERTBACK_NOT: -

1641

never executed: return code;

never evaluated: !skipassert

1642

code += PRIV(OP_lengths)[*code];

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

never evaluated: *code == OP_ALT

1643

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

1644

if (!skipassert) return code;

never executed: break;

1645 -

1646 case OP_WORD_BOUNDARY: -

1647 case OP_NOT_WORD_BOUNDARY: -

1648

executed: return code;

Execution Count:37

evaluated: !skipassert

TRUE	FALSE
yes Evaluation Count:37	yes Evaluation Count:3

3-37

1649 /* Fall through */ -

1650 -

1651

case OP_CALLOUT:

code before this statement executed: case OP_CALLOUT:

Execution Count:3

1652 case OP_CREF: -

1653 case OP_NCREF: -

1654 case OP_RREF: -

1655 case OP_NRREF: -

1656 case OP_DEF: -

1657

code += PRIV(OP_lengths)[*code];

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

1658

executed: break;

Execution Count:7

1659 -

1660 default: -

1661

return code;

executed: return code;

Execution Count:645

645

1662 } -

1663

executed: }

Execution Count:7

1664 /* Control never reaches here */ -

1665

never executed: }

1666 -

1667 -

1668 -

1669 -

1670 /************************************************* -

1671 * Find the fixed length of a branch * -

1672 *************************************************/ -

1673 -

1674 /* Scan a branch and compute the fixed length of subject that will match it, -

1675 if the length is fixed. This is needed for dealing with backward assertions. -

1676 In UTF8 mode, the result is in characters rather than bytes. The branch is -

1677 temporarily terminated with OP_END when this function is called. -

1678 -

1679 This function is called when a backward assertion is encountered, so that if it -

1680 fails, the error message can point to the correct place in the pattern. -

1681 However, we cannot do this when the assertion contains subroutine calls, -

1682 because they can be forward references. We solve this by remembering this case -

1683 and doing the check at the end; a flag specifies which mode we are running in. -

1684 -

1685 Arguments: -

1686 code points to the start of the pattern (the bracket) -

1687 utf TRUE in UTF-8 / UTF-16 mode -

1688 atend TRUE if called when the pattern is complete -

1689 cd the "compile data" structure -

1690 -

1691 Returns: the fixed length, -

1692 or -1 if there is no fixed length, -

1693 or -2 if \C was encountered (in UTF-8 mode only) -

1694 or -3 if an OP_RECURSE item was encountered and atend is FALSE -

1695 or -4 if an unknown opcode was encountered (internal error) -

1696 */ -

1697 -

1698 static int -

1699 find_fixedlength(pcre_uchar *code, BOOL utf, BOOL atend, compile_data *cd) -

1700 { -

1701

int length = -1;

never executed (the execution status of this line is deduced): int length = -1;

1702 -

1703

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

1704

never executed (the execution status of this line is deduced): register pcre_uchar *cc = code + 1 + 1;

1705 -

1706 /* Scan along the opcodes for this branch. If we get to the end of the -

1707 branch, check the length against that of the other branches. */ -

1708 -

1709

d = find_fixedlength(cc + ((op == OP_CBRA)? IMM2_SIZE : 0), utf, atend, cd);

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

1710 { -

1711

int d;

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

1712

pcre_uchar *ce, *cs;

never executed (the execution status of this line is deduced): pcre_uchar *ce, *cs;

1713

never executed (the execution status of this line is deduced): register int op = *cc;

1714 -

1715 switch (op) -

1716 { -

1717 /* We only need to continue for OP_CBRA (normal capturing bracket) and -

1718 OP_BRA (normal non-capturing bracket) because the other variants of these -

1719 opcodes are all concerned with unlimited repeated groups, which of course -

1720 are not of fixed length. */ -

1721 -

1722 case OP_CBRA: -

1723 case OP_BRA: -

1724 case OP_ONCE: -

1725 case OP_ONCE_NC: -

1726 case OP_COND: -

1727

never executed (the execution status of this line is deduced): d = find_fixedlength(cc + ((op == OP_CBRA)? 1 : 0), utf, atend, cd);

1728

if (d < 0) return d;

never executed: return d;

never evaluated: d < 0

1729

branchlength += d;

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

1730

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

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

never evaluated: *cc == OP_ALT

1731

cc += 1 + LINK_SIZE;

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

1732

if (length < 0) length = branchlength;

never executed: break;

1733 -

1734 /* Reached end of a branch; if it's a ket it is the end of a nested call. -

1735 If it's ALT it is an alternation in a nested call. An ACCEPT is effectively -

1736 an ALT. If it is END it's the end of the outer call. All can be handled by -

1737 the same code. Note that we must not include the OP_KETRxxx opcodes here, -

1738 because they all imply an unlimited repeat. */ -

1739 -

1740 case OP_ALT: -

1741 case OP_KET: -

1742 case OP_END: -

1743 case OP_ACCEPT: -

1744 case OP_ASSERT_ACCEPT: -

1745

never executed: length = branchlength;

never evaluated: length < 0

1746

else if (length != branchlength) return -1;

never executed: return -1;

never evaluated: length != branchlength

1747

if (*cc != OP_ALT) return length;

never executed: return length;

never evaluated: *cc != OP_ALT

1748

cc += 1 + LINK_SIZE;

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

1749

branchlength = 0;

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

1750

cs = ce = (pcre_uchar *)cd->start_code + GET(cc, 1); /* Start subpattern */

never executed: break;

1751 -

1752 /* A true recursion implies not fixed length, but a subroutine call may -

1753 be OK. If the subroutine is a forward reference, we can't deal with -

1754 it until the end of the pattern, so return -3. */ -

1755 -

1756 case OP_RECURSE: -

1757

if (!atend) return -3;

never executed: return -3;

never evaluated: !atend

1758

never executed (the execution status of this line is deduced): cs = ce = (pcre_uchar *)cd->start_code + (cc[1]);

1759

do ce += GET(ce, 1); while (*ce == OP_ALT); /* End subpattern */

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

never evaluated: *ce == OP_ALT

1760

if (cc > cs && cc < ce) return -1; /* Recursion */

never executed: return -1;

never evaluated: cc > cs

never evaluated: cc < ce

1761

d = find_fixedlength(cs + IMM2_SIZE, utf, atend, cd);

never executed (the execution status of this line is deduced): d = find_fixedlength(cs + 1, utf, atend, cd);

1762

if (d < 0) return d;

never executed: return d;

never evaluated: d < 0

1763

branchlength += d;

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

1764

cc += 1 + LINK_SIZE;

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

1765

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

never executed: break;

1766 -

1767 /* Skip over assertive subpatterns */ -

1768 -

1769 case OP_ASSERT: -

1770 case OP_ASSERT_NOT: -

1771 case OP_ASSERTBACK: -

1772 case OP_ASSERTBACK_NOT: -

1773

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

never evaluated: *cc == OP_ALT

1774

cc += PRIV(OP_lengths)[*cc];

never executed (the execution status of this line is deduced): cc += _pcre16_OP_lengths[*cc];

1775

cc += cc[1] + PRIV(OP_lengths)[*cc];

never executed: break;

1776 -

1777 /* Skip over things that don't match chars */ -

1778 -

1779 case OP_MARK: -

1780 case OP_PRUNE_ARG: -

1781 case OP_SKIP_ARG: -

1782 case OP_THEN_ARG: -

1783

never executed (the execution status of this line is deduced): cc += cc[1] + _pcre16_OP_lengths[*cc];

1784

cc += PRIV(OP_lengths)[*cc];

never executed: break;

1785 -

1786 case OP_CALLOUT: -

1787 case OP_CIRC: -

1788 case OP_CIRCM: -

1789 case OP_CLOSE: -

1790 case OP_COMMIT: -

1791 case OP_CREF: -

1792 case OP_DEF: -

1793 case OP_DOLL: -

1794 case OP_DOLLM: -

1795 case OP_EOD: -

1796 case OP_EODN: -

1797 case OP_FAIL: -

1798 case OP_NCREF: -

1799 case OP_NRREF: -

1800 case OP_NOT_WORD_BOUNDARY: -

1801 case OP_PRUNE: -

1802 case OP_REVERSE: -

1803 case OP_RREF: -

1804 case OP_SET_SOM: -

1805 case OP_SKIP: -

1806 case OP_SOD: -

1807 case OP_SOM: -

1808 case OP_THEN: -

1809 case OP_WORD_BOUNDARY: -

1810

never executed (the execution status of this line is deduced): cc += _pcre16_OP_lengths[*cc];

1811

if (utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);

never executed: break;

1812 -

1813 /* Handle literal characters */ -

1814 -

1815 case OP_CHAR: -

1816 case OP_CHARI: -

1817 case OP_NOT: -

1818 case OP_NOTI: -

1819

branchlength++;

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

1820

cc += 2;

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

1821 #ifdef SUPPORT_UTF -

1822

never executed: cc += 1;

never evaluated: utf

never evaluated: (((cc[-1]) & 0xfc00) == 0xd800)

1823 #endif -

1824

branchlength += GET2(cc,1);

never executed: break;

1825 -

1826 /* Handle exact repetitions. The count is already in characters, but we -

1827 need to skip over a multibyte character in UTF8 mode. */ -

1828 -

1829 case OP_EXACT: -

1830 case OP_EXACTI: -

1831 case OP_NOTEXACT: -

1832 case OP_NOTEXACTI: -

1833

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

1834

cc += 2 + IMM2_SIZE;

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

1835 #ifdef SUPPORT_UTF -

1836

if (utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);

never executed: cc += 1;

never evaluated: utf

never evaluated: (((cc[-1]) & 0xfc00) == 0xd800)

1837 #endif -

1838

branchlength += GET2(cc,1);

never executed: break;

1839 -

1840 case OP_TYPEEXACT: -

1841

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

1842

if (cc[1 + IMM2_SIZE] == OP_PROP || cc[1 + IMM2_SIZE] == OP_NOTPROP) cc += 2;

never executed: cc += 2;

never evaluated: cc[1 + 1] == OP_PROP

never evaluated: cc[1 + 1] == OP_NOTPROP

1843

cc += 1 + IMM2_SIZE + 1;

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

1844

never executed: break;

1845 -

1846 /* Handle single-char matchers */ -

1847 -

1848 case OP_PROP: -

1849 case OP_NOTPROP: -

1850

cc += 2;

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

1851 /* Fall through */ -

1852 -

1853

case OP_HSPACE:

code before this statement never executed: case OP_HSPACE:

1854 case OP_VSPACE: -

1855 case OP_NOT_HSPACE: -

1856 case OP_NOT_VSPACE: -

1857 case OP_NOT_DIGIT: -

1858 case OP_DIGIT: -

1859 case OP_NOT_WHITESPACE: -

1860 case OP_WHITESPACE: -

1861 case OP_NOT_WORDCHAR: -

1862 case OP_WORDCHAR: -

1863 case OP_ANY: -

1864 case OP_ALLANY: -

1865

branchlength++;

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

1866

cc++;

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

1867

cc += GET(cc, 1) - PRIV(OP_lengths)[OP_CLASS];

never executed: break;

1868 -

1869 /* The single-byte matcher isn't allowed. This only happens in UTF-8 mode; -

1870 otherwise \C is coded as OP_ALLANY. */ -

1871 -

1872 case OP_ANYBYTE: -

1873

return -2;

never executed: return -2;

1874 -

1875 /* Check a class for variable quantification */ -

1876 -

1877 #if defined SUPPORT_UTF || defined COMPILE_PCRE16 -

1878 case OP_XCLASS: -

1879

never executed (the execution status of this line is deduced): cc += (cc[1]) - _pcre16_OP_lengths[OP_CLASS];

1880 /* Fall through */ -

1881 #endif -

1882 -

1883

case OP_CLASS:

code before this statement never executed: case OP_CLASS:

1884 case OP_NCLASS: -

1885

cc += PRIV(OP_lengths)[OP_CLASS];

never executed (the execution status of this line is deduced): cc += _pcre16_OP_lengths[OP_CLASS];

1886 -

1887 switch (*cc) -

1888 { -

1889 case OP_CRPLUS: -

1890 case OP_CRMINPLUS: -

1891 case OP_CRSTAR: -

1892 case OP_CRMINSTAR: -

1893 case OP_CRQUERY: -

1894 case OP_CRMINQUERY: -

1895

if (GET2(cc,1) != GET2(cc,1+IMM2_SIZE)) return -1;

never executed: return -1;

1896 -

1897 case OP_CRRANGE: -

1898 case OP_CRMINRANGE: -

1899

never executed: return -1;

never evaluated: cc[1] != cc[1+1]

1900

branchlength += GET2(cc,1);

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

1901

cc += 1 + 2 * IMM2_SIZE;

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

1902

never executed: break;

1903 -

1904 default: -

1905

branchlength++;

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

never executed: }

never executed: break;

1908 -

1909 /* Anything else is variable length */ -

1910 -

1911 case OP_ANYNL: -

1912 case OP_BRAMINZERO: -

1913 case OP_BRAPOS: -

1914 case OP_BRAPOSZERO: -

1915 case OP_BRAZERO: -

1916 case OP_CBRAPOS: -

1917 case OP_EXTUNI: -

1918 case OP_KETRMAX: -

1919 case OP_KETRMIN: -

1920 case OP_KETRPOS: -

1921 case OP_MINPLUS: -

1922 case OP_MINPLUSI: -

1923 case OP_MINQUERY: -

1924 case OP_MINQUERYI: -

1925 case OP_MINSTAR: -

1926 case OP_MINSTARI: -

1927 case OP_MINUPTO: -

1928 case OP_MINUPTOI: -

1929 case OP_NOTMINPLUS: -

1930 case OP_NOTMINPLUSI: -

1931 case OP_NOTMINQUERY: -

1932 case OP_NOTMINQUERYI: -

1933 case OP_NOTMINSTAR: -

1934 case OP_NOTMINSTARI: -

1935 case OP_NOTMINUPTO: -

1936 case OP_NOTMINUPTOI: -

1937 case OP_NOTPLUS: -

1938 case OP_NOTPLUSI: -

1939 case OP_NOTPOSPLUS: -

1940 case OP_NOTPOSPLUSI: -

1941 case OP_NOTPOSQUERY: -

1942 case OP_NOTPOSQUERYI: -

1943 case OP_NOTPOSSTAR: -

1944 case OP_NOTPOSSTARI: -

1945 case OP_NOTPOSUPTO: -

1946 case OP_NOTPOSUPTOI: -

1947 case OP_NOTQUERY: -

1948 case OP_NOTQUERYI: -

1949 case OP_NOTSTAR: -

1950 case OP_NOTSTARI: -

1951 case OP_NOTUPTO: -

1952 case OP_NOTUPTOI: -

1953 case OP_PLUS: -

1954 case OP_PLUSI: -

1955 case OP_POSPLUS: -

1956 case OP_POSPLUSI: -

1957 case OP_POSQUERY: -

1958 case OP_POSQUERYI: -

1959 case OP_POSSTAR: -

1960 case OP_POSSTARI: -

1961 case OP_POSUPTO: -

1962 case OP_POSUPTOI: -

1963 case OP_QUERY: -

1964 case OP_QUERYI: -

1965 case OP_REF: -

1966 case OP_REFI: -

1967 case OP_SBRA: -

1968 case OP_SBRAPOS: -

1969 case OP_SCBRA: -

1970 case OP_SCBRAPOS: -

1971 case OP_SCOND: -

1972 case OP_SKIPZERO: -

1973 case OP_STAR: -

1974 case OP_STARI: -

1975 case OP_TYPEMINPLUS: -

1976 case OP_TYPEMINQUERY: -

1977 case OP_TYPEMINSTAR: -

1978 case OP_TYPEMINUPTO: -

1979 case OP_TYPEPLUS: -

1980 case OP_TYPEPOSPLUS: -

1981 case OP_TYPEPOSQUERY: -

1982 case OP_TYPEPOSSTAR: -

1983 case OP_TYPEPOSUPTO: -

1984 case OP_TYPEQUERY: -

1985 case OP_TYPESTAR: -

1986 case OP_TYPEUPTO: -

1987 case OP_UPTO: -

1988 case OP_UPTOI: -

1989

never executed: return -1;

1990 -

1991 /* Catch unrecognized opcodes so that when new ones are added they -

1992 are not forgotten, as has happened in the past. */ -

1993 -

1994 default: -

1995

return -4;

never executed: return -4;

1996 } -

1997

never executed: }

1998 /* Control never gets here */ -

1999

never executed: }

2000 -

2001 -

2002 -

2003 -

2004 /************************************************* -

2005 * Scan compiled regex for specific bracket * -

2006 *************************************************/ -

2007 -

2008 /* This little function scans through a compiled pattern until it finds a -

2009 capturing bracket with the given number, or, if the number is negative, an -

2010 instance of OP_REVERSE for a lookbehind. The function is global in the C sense -

2011 so that it can be called from pcre_study() when finding the minimum matching -

2012 length. -

2013 -

2014 Arguments: -

2015 code points to start of expression -

2016 utf TRUE in UTF-8 / UTF-16 mode -

2017 number the required bracket number or negative to find a lookbehind -

2018 -

2019 Returns: pointer to the opcode for the bracket, or NULL if not found -

2020 */ -

2021 -

2022 const pcre_uchar * -

2023 PRIV(find_bracket)(const pcre_uchar *code, BOOL utf, int number) -

2024 { -

2025

if (c == OP_END) return NULL;

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

2026 { -

2027

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

2028 -

2029

executed: return ((void *)0);

Execution Count:2

evaluated: c == OP_END

TRUE	FALSE
yes Evaluation Count:2	yes Evaluation Count:22

2-22

2030 -

2031 /* XCLASS is used for classes that cannot be represented just by a bit -

2032 map. This includes negated single high-valued characters. The length in -

2033 the table is zero; the actual length is stored in the compiled code. */ -

2034 -

2035

if (c == OP_XCLASS) code += GET(code, 1);

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

partially evaluated: c == OP_XCLASS

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

0-22

2036 -

2037 /* Handle recursion */ -

2038 -

2039

else if (c == OP_REVERSE)

partially evaluated: c == OP_REVERSE

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

0-22

2040 { -

2041

if (number < 0) return (pcre_uchar *)code;

never executed: return (pcre_uchar *)code;

never evaluated: number < 0

2042

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

2043

else if (c == OP_CBRA || c == OP_SCBRA ||

never executed: }

2044 -

2045 /* Handle capturing bracket */ -

2046 -

2047

evaluated: c == OP_CBRA

TRUE	FALSE
yes Evaluation Count:2	yes Evaluation Count:20

partially evaluated: c == OP_SCBRA

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

0-20

2048

c == OP_CBRAPOS || c == OP_SCBRAPOS)

partially evaluated: c == OP_CBRAPOS

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

partially evaluated: c == OP_SCBRAPOS

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

0-20

2049 { -

2050

int n = GET2(code, 1+LINK_SIZE);

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

2051

if (n == number) return (pcre_uchar *)code;

executed: return (pcre_uchar *)code;

Execution Count:2

partially evaluated: n == number

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

0-2

2052

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

2053

if (code[1] == OP_PROP || code[1] == OP_NOTPROP) code += 2;

never executed: }

2054 -

2055 /* Otherwise, we can get the item's length from the table, except that for -

2056 repeated character types, we have to test for \p and \P, which have an extra -

2057 two bytes of parameters, and for MARK/PRUNE/SKIP/THEN with an argument, we -

2058 must add in its length. */ -

2059 -

2060 else -

2061 { -

2062 switch(c) -

2063 { -

2064 case OP_TYPESTAR: -

2065 case OP_TYPEMINSTAR: -

2066 case OP_TYPEPLUS: -

2067 case OP_TYPEMINPLUS: -

2068 case OP_TYPEQUERY: -

2069 case OP_TYPEMINQUERY: -

2070 case OP_TYPEPOSSTAR: -

2071 case OP_TYPEPOSPLUS: -

2072 case OP_TYPEPOSQUERY: -

2073

never executed: code += 2;

never evaluated: code[1] == OP_PROP

never evaluated: code[1] == OP_NOTPROP

2074

if (code[1 + IMM2_SIZE] == OP_PROP

never executed: break;

2075 -

2076 case OP_TYPEUPTO: -

2077 case OP_TYPEMINUPTO: -

2078 case OP_TYPEEXACT: -

2079 case OP_TYPEPOSUPTO: -

2080

never evaluated: code[1 + 1] == OP_PROP

2081

|| code[1 + IMM2_SIZE] == OP_NOTPROP) code += 2;

never executed: code += 2;

never evaluated: code[1 + 1] == OP_NOTPROP

2082

never executed: break;

2083 -

2084 case OP_MARK: -

2085 case OP_PRUNE_ARG: -

2086 case OP_SKIP_ARG: -

2087

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

2088

never executed: break;

2089 -

2090 case OP_THEN_ARG: -

2091

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

2092

never executed: break;

2093 } -

2094 -

2095 /* Add in the fixed length from the table */ -

2096 -

2097

if (HAS_EXTRALEN(code[-1])) code += GET_EXTRALEN(code[-1]);

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

2098 -

2099 /* In UTF-8 mode, opcodes that are followed by a character may be followed by -

2100 a multi-byte character. The length in the table is a minimum, so we have to -

2101 arrange to skip the extra bytes. */ -

2102 -

2103 #ifdef SUPPORT_UTF -

2104

if (utf) switch(c)

partially evaluated: utf

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

0-20

2105 { -

2106 case OP_CHAR: -

2107 case OP_CHARI: -

2108 case OP_EXACT: -

2109 case OP_EXACTI: -

2110 case OP_UPTO: -

2111 case OP_UPTOI: -

2112 case OP_MINUPTO: -

2113 case OP_MINUPTOI: -

2114 case OP_POSUPTO: -

2115 case OP_POSUPTOI: -

2116 case OP_STAR: -

2117 case OP_STARI: -

2118 case OP_MINSTAR: -

2119 case OP_MINSTARI: -

2120 case OP_POSSTAR: -

2121 case OP_POSSTARI: -

2122 case OP_PLUS: -

2123 case OP_PLUSI: -

2124 case OP_MINPLUS: -

2125 case OP_MINPLUSI: -

2126 case OP_POSPLUS: -

2127 case OP_POSPLUSI: -

2128 case OP_QUERY: -

2129 case OP_QUERYI: -

2130 case OP_MINQUERY: -

2131 case OP_MINQUERYI: -

2132 case OP_POSQUERY: -

2133 case OP_POSQUERYI: -

2134

never executed: code += 1;

partially evaluated: (((code[-1]) & 0xfc00) == 0xd800)

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

0-4

2135

executed: break;

Execution Count:4

2136

never executed: }

2137 #else -

2138 (void)(utf); /* Keep compiler happy by referencing function argument */ -

2139 #endif -

2140

executed: }

Execution Count:20

2141 } -

2142

never executed: }

2143 -

2144 -

2145 -

2146 /************************************************* -

2147 * Scan compiled regex for recursion reference * -

2148 *************************************************/ -

2149 -

2150 /* This little function scans through a compiled pattern until it finds an -

2151 instance of OP_RECURSE. -

2152 -

2153 Arguments: -

2154 code points to start of expression -

2155 utf TRUE in UTF-8 / UTF-16 mode -

2156 -

2157 Returns: pointer to the opcode for OP_RECURSE, or NULL if not found -

2158 */ -

2159 -

2160 static const pcre_uchar * -

2161 find_recurse(const pcre_uchar *code, BOOL utf) -

2162 { -

2163

if (c == OP_END) return NULL;

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

2164 { -

2165

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

2166

executed: return ((void *)0);

Execution Count:106

evaluated: c == OP_END

TRUE	FALSE
yes Evaluation Count:106	yes Evaluation Count:513

106-513

2167

if (c == OP_RECURSE) return code;

never executed: return code;

partially evaluated: c == OP_RECURSE

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

0-513

2168 -

2169 /* XCLASS is used for classes that cannot be represented just by a bit -

2170 map. This includes negated single high-valued characters. The length in -

2171 the table is zero; the actual length is stored in the compiled code. */ -

2172 -

2173

if (c == OP_XCLASS) code += GET(code, 1);

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

partially evaluated: c == OP_XCLASS

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

0-513

2174 -

2175 /* Otherwise, we can get the item's length from the table, except that for -

2176 repeated character types, we have to test for \p and \P, which have an extra -

2177 two bytes of parameters, and for MARK/PRUNE/SKIP/THEN with an argument, we -

2178 must add in its length. */ -

2179 -

2180 else -

2181 { -

2182 switch(c) -

2183 { -

2184 case OP_TYPESTAR: -

2185 case OP_TYPEMINSTAR: -

2186 case OP_TYPEPLUS: -

2187 case OP_TYPEMINPLUS: -

2188 case OP_TYPEQUERY: -

2189 case OP_TYPEMINQUERY: -

2190 case OP_TYPEPOSSTAR: -

2191 case OP_TYPEPOSPLUS: -

2192 case OP_TYPEPOSQUERY: -

2193

if (code[1] == OP_PROP || code[1] == OP_NOTPROP) code += 2;

never executed: code += 2;

partially evaluated: code[1] == OP_PROP

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

partially evaluated: code[1] == OP_NOTPROP

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

0-1

2194

if (code[1 + IMM2_SIZE] == OP_PROP

executed: break;

Execution Count:1

2195 -

2196 case OP_TYPEPOSUPTO: -

2197 case OP_TYPEUPTO: -

2198 case OP_TYPEMINUPTO: -

2199 case OP_TYPEEXACT: -

2200

never evaluated: code[1 + 1] == OP_PROP

2201

|| code[1 + IMM2_SIZE] == OP_NOTPROP) code += 2;

never executed: code += 2;

never evaluated: code[1 + 1] == OP_NOTPROP

2202

never executed: break;

2203 -

2204 case OP_MARK: -

2205 case OP_PRUNE_ARG: -

2206 case OP_SKIP_ARG: -

2207

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

2208

never executed: break;

2209 -

2210 case OP_THEN_ARG: -

2211

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

2212

never executed: break;

2213 } -

2214 -

2215 /* Add in the fixed length from the table */ -

2216 -

2217

if (HAS_EXTRALEN(code[-1])) code += GET_EXTRALEN(code[-1]);

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

2218 -

2219 /* In UTF-8 mode, opcodes that are followed by a character may be followed -

2220 by a multi-byte character. The length in the table is a minimum, so we have -

2221 to arrange to skip the extra bytes. */ -

2222 -

2223 #ifdef SUPPORT_UTF -

2224

if (utf) switch(c)

partially evaluated: utf

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

0-513

2225 { -

2226 case OP_CHAR: -

2227 case OP_CHARI: -

2228 case OP_EXACT: -

2229 case OP_EXACTI: -

2230 case OP_UPTO: -

2231 case OP_UPTOI: -

2232 case OP_MINUPTO: -

2233 case OP_MINUPTOI: -

2234 case OP_POSUPTO: -

2235 case OP_POSUPTOI: -

2236 case OP_STAR: -

2237 case OP_STARI: -

2238 case OP_MINSTAR: -

2239 case OP_MINSTARI: -

2240 case OP_POSSTAR: -

2241 case OP_POSSTARI: -

2242 case OP_PLUS: -

2243 case OP_PLUSI: -

2244 case OP_MINPLUS: -

2245 case OP_MINPLUSI: -

2246 case OP_POSPLUS: -

2247 case OP_POSPLUSI: -

2248 case OP_QUERY: -

2249 case OP_QUERYI: -

2250 case OP_MINQUERY: -

2251 case OP_MINQUERYI: -

2252 case OP_POSQUERY: -

2253 case OP_POSQUERYI: -

2254

never executed: code += 1;

partially evaluated: (((code[-1]) & 0xfc00) == 0xd800)

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

0-294

2255

executed: break;

Execution Count:294

294

2256

never executed: }

2257 #else -

2258 (void)(utf); /* Keep compiler happy by referencing function argument */ -

2259 #endif -

2260

executed: }

Execution Count:513

513

2261 } -

2262

for (code = first_significant_code(code + PRIV(OP_lengths)[*code], TRUE);

never executed: }

2263 -

2264 -

2265 -

2266 /************************************************* -

2267 * Scan compiled branch for non-emptiness * -

2268 *************************************************/ -

2269 -

2270 /* This function scans through a branch of a compiled pattern to see whether it -

2271 can match the empty string or not. It is called from could_be_empty() -

2272 below and from compile_branch() when checking for an unlimited repeat of a -

2273 group that can match nothing. Note that first_significant_code() skips over -

2274 backward and negative forward assertions when its final argument is TRUE. If we -

2275 hit an unclosed bracket, we return "empty" - this means we've struck an inner -

2276 bracket whose current branch will already have been scanned. -

2277 -

2278 Arguments: -

2279 code points to start of search -

2280 endcode points to where to stop -

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

2282 cd contains pointers to tables etc. -

2283 -

2284 Returns: TRUE if what is matched could be empty -

2285 */ -

2286 -

2287 static BOOL -

2288 could_be_empty_branch(const pcre_uchar *code, const pcre_uchar *endcode, -

2289 BOOL utf, compile_data *cd) -

2290 { -

2291

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

2292

executed (the execution status of this line is deduced): for (code = first_significant_code(code + _pcre16_OP_lengths[*code], 1);

2293

code < endcode;

partially evaluated: code < endcode

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

0-3

2294

code = first_significant_code(code + PRIV(OP_lengths)[c], TRUE))

executed (the execution status of this line is deduced): code = first_significant_code(code + _pcre16_OP_lengths[c], 1))

2295 { -

2296

const pcre_uchar *ccode;

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

2297 -

2298

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

2299 -

2300 /* Skip over forward assertions; the other assertions are skipped by -

2301 first_significant_code() with a TRUE final argument. */ -

2302 -

2303

if (c == OP_ASSERT)

partially evaluated: c == OP_ASSERT

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

0-3

2304 { -

2305

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

never evaluated: *code == OP_ALT

2306

never executed (the execution status of this line is deduced): c = *code;

2307

for (scode = cd->start_workspace; scode < cd->hwm; scode += LINK_SIZE)

never executed: continue;

2308 } -

2309 -

2310 /* For a recursion/subroutine call, if its end has been reached, which -

2311 implies a backward reference subroutine call, we can scan it. If it's a -

2312 forward reference subroutine call, we can't. To detect forward reference -

2313 we have to scan up the list that is kept in the workspace. This function is -

2314 called only when doing the real compile, not during the pre-compile that -

2315 measures the size of the compiled pattern. */ -

2316 -

2317

if (c == OP_RECURSE)

partially evaluated: c == OP_RECURSE

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

0-3

2318 { -

2319

const pcre_uchar *scode;

never executed (the execution status of this line is deduced): const pcre_uchar *scode;

2320

BOOL empty_branch;

never executed (the execution status of this line is deduced): BOOL empty_branch;

2321 -

2322 /* Test for forward reference */ -

2323 -

2324

never evaluated: scode < cd->hwm

2325

if (GET(scode, 0) == code + 1 - cd->start_code) return TRUE;

never executed: return 1;

never evaluated: (scode[0]) == code + 1 - cd->start_code

2326 -

2327 /* Not a forward reference, test for completed backward reference */ -

2328 -

2329

empty_branch = FALSE;

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

2330

scode = cd->start_code + GET(code, 1);

never executed (the execution status of this line is deduced): scode = cd->start_code + (code[1]);

2331

if (GET(scode, 1) == 0) return TRUE; /* Unclosed */

never executed: return 1;

never evaluated: (scode[1]) == 0

2332 -

2333 /* Completed backwards reference */ -

2334 -

2335 do -

2336 { -

2337

if (could_be_empty_branch(scode, endcode, utf, cd))

never evaluated: could_be_empty_branch(scode, endcode, utf, cd)

2338 { -

2339

empty_branch = TRUE;

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

2340

never executed: break;

2341 } -

2342

scode += GET(scode, 1);

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

2343

while (*scode == OP_ALT);

never executed: }

2344

never evaluated: *scode == OP_ALT

2345 -

2346

if (!empty_branch) return FALSE; /* All branches are non-empty */

never executed: return 0;

never evaluated: !empty_branch

2347

if (c == OP_BRAZERO || c == OP_BRAMINZERO || c == OP_SKIPZERO ||

never executed: continue;

2348 } -

2349 -

2350 /* Groups with zero repeats can of course be empty; skip them. */ -

2351 -

2352

partially evaluated: c == OP_BRAZERO

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

partially evaluated: c == OP_BRAMINZERO

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

partially evaluated: c == OP_SKIPZERO

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

0-3

2353

c == OP_BRAPOSZERO)

partially evaluated: c == OP_BRAPOSZERO

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

0-3

2354 { -

2355

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

2356

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

never evaluated: *code == OP_ALT

2357

never executed (the execution status of this line is deduced): c = *code;

2358

if (c == OP_SBRA || c == OP_SBRAPOS ||

never executed: continue;

2359 } -

2360 -

2361 /* A nested group that is already marked as "could be empty" can just be -

2362 skipped. */ -

2363 -

2364

partially evaluated: c == OP_SBRA

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

partially evaluated: c == OP_SBRAPOS

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

0-3

2365

c == OP_SCBRA || c == OP_SCBRAPOS)

partially evaluated: c == OP_SCBRA

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

partially evaluated: c == OP_SCBRAPOS

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

0-3

2366 { -

2367

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

never evaluated: *code == OP_ALT

2368

never executed (the execution status of this line is deduced): c = *code;

2369

if (c == OP_BRA || c == OP_BRAPOS ||

never executed: continue;

2370 } -

2371 -

2372 /* For other groups, scan the branches. */ -

2373 -

2374

partially evaluated: c == OP_BRA

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

partially evaluated: c == OP_BRAPOS

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

0-3

2375

c == OP_CBRA || c == OP_CBRAPOS ||

partially evaluated: c == OP_CBRA

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

partially evaluated: c == OP_CBRAPOS

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

0-3

2376

c == OP_ONCE || c == OP_ONCE_NC ||

partially evaluated: c == OP_ONCE

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

partially evaluated: c == OP_ONCE_NC

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

0-3

2377

c == OP_COND)

partially evaluated: c == OP_COND

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

0-3

2378 { -

2379

BOOL empty_branch;

never executed (the execution status of this line is deduced): BOOL empty_branch;

2380

if (GET(code, 1) == 0) return TRUE; /* Hit unclosed bracket */

never executed: return 1;

never evaluated: (code[1]) == 0

2381 -

2382 /* If a conditional group has only one branch, there is a second, implied, -

2383 empty branch, so just skip over the conditional, because it could be empty. -

2384 Otherwise, scan the individual branches of the group. */ -

2385 -

2386

if (c == OP_COND && code[GET(code, 1)] != OP_ALT)

never evaluated: c == OP_COND

never evaluated: code[(code[1])] != OP_ALT

2387

if (!empty_branch && could_be_empty_branch(code, endcode, utf, cd))

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

2388 else -

2389 { -

2390

empty_branch = FALSE;

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

2391 do -

2392 { -

2393

never evaluated: !empty_branch

never evaluated: could_be_empty_branch(code, endcode, utf, cd)

2394

empty_branch = TRUE;

never executed: empty_branch = 1;

2395

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

2396

if (!empty_branch) return FALSE; /* All branches are non-empty */

never executed: }

2397

while (*code == OP_ALT);

never evaluated: *code == OP_ALT

2398

never executed: return 0;

never evaluated: !empty_branch

2399

never executed: }

2400 -

2401

never executed (the execution status of this line is deduced): c = *code;

2402

ccode = code += GET(code, 1);

never executed: continue;

2403 } -

2404 -

2405 /* Handle the other opcodes */ -

2406 -

2407 switch (c) -

2408 { -

2409 /* Check for quantifiers after a class. XCLASS is used for classes that -

2410 cannot be represented just by a bit map. This includes negated single -

2411 high-valued characters. The length in PRIV(OP_lengths)[] is zero; the -

2412 actual length is stored in the compiled code, so we must update "code" -

2413 here. */ -

2414 -

2415 #if defined SUPPORT_UTF || !defined COMPILE_PCRE8 -

2416 case OP_XCLASS: -

2417

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

2418

goto CHECK_CLASS_REPEAT;

never executed: goto CHECK_CLASS_REPEAT;

2419 #endif -

2420 -

2421 case OP_CLASS: -

2422 case OP_NCLASS: -

2423

ccode = code + PRIV(OP_lengths)[OP_CLASS];

never executed (the execution status of this line is deduced): ccode = code + _pcre16_OP_lengths[OP_CLASS];

2424 -

2425 #if defined SUPPORT_UTF || !defined COMPILE_PCRE8 -

2426

CHECK_CLASS_REPEAT:

code before this statement never executed: CHECK_CLASS_REPEAT:

2427 #endif -

2428 -

2429 switch (*ccode) -

2430 { -

2431 case OP_CRSTAR: /* These could be empty; continue */ -

2432 case OP_CRMINSTAR: -

2433 case OP_CRQUERY: -

2434 case OP_CRMINQUERY: -

2435

never executed: break;

2436 -

2437 default: /* Non-repeat => class must match */ -

2438 case OP_CRPLUS: /* These repeats aren't empty */ -

2439 case OP_CRMINPLUS: -

2440

if (GET2(ccode, 1) > 0) return FALSE; /* Minimum > 0 */

never executed: return 0;

2441 -

2442 case OP_CRRANGE: -

2443 case OP_CRMINRANGE: -

2444

never executed: return 0;

never evaluated: ccode[1] > 0

2445

never executed: break;

2446 } -

2447

never executed: break;

2448 -

2449 /* Opcodes that must match a character */ -

2450 -

2451 case OP_PROP: -

2452 case OP_NOTPROP: -

2453 case OP_EXTUNI: -

2454 case OP_NOT_DIGIT: -

2455 case OP_DIGIT: -

2456 case OP_NOT_WHITESPACE: -

2457 case OP_WHITESPACE: -

2458 case OP_NOT_WORDCHAR: -

2459 case OP_WORDCHAR: -

2460 case OP_ANY: -

2461 case OP_ALLANY: -

2462 case OP_ANYBYTE: -

2463 case OP_CHAR: -

2464 case OP_CHARI: -

2465 case OP_NOT: -

2466 case OP_NOTI: -

2467 case OP_PLUS: -

2468 case OP_MINPLUS: -

2469 case OP_POSPLUS: -

2470 case OP_EXACT: -

2471 case OP_NOTPLUS: -

2472 case OP_NOTMINPLUS: -

2473 case OP_NOTPOSPLUS: -

2474 case OP_NOTEXACT: -

2475 case OP_TYPEPLUS: -

2476 case OP_TYPEMINPLUS: -

2477 case OP_TYPEPOSPLUS: -

2478 case OP_TYPEEXACT: -

2479

if (code[1] == OP_PROP || code[1] == OP_NOTPROP) code += 2;

executed: return 0;

Execution Count:3

2480 -

2481 /* These are going to continue, as they may be empty, but we have to -

2482 fudge the length for the \p and \P cases. */ -

2483 -

2484 case OP_TYPESTAR: -

2485 case OP_TYPEMINSTAR: -

2486 case OP_TYPEPOSSTAR: -

2487 case OP_TYPEQUERY: -

2488 case OP_TYPEMINQUERY: -

2489 case OP_TYPEPOSQUERY: -

2490

never executed: code += 2;

never evaluated: code[1] == OP_PROP

never evaluated: code[1] == OP_NOTPROP

2491

if (code[1 + IMM2_SIZE] == OP_PROP

never executed: break;

2492 -

2493 /* Same for these */ -

2494 -

2495 case OP_TYPEUPTO: -

2496 case OP_TYPEMINUPTO: -

2497 case OP_TYPEPOSUPTO: -

2498

never evaluated: code[1 + 1] == OP_PROP

2499

|| code[1 + IMM2_SIZE] == OP_NOTPROP) code += 2;

never executed: code += 2;

never evaluated: code[1 + 1] == OP_NOTPROP

2500

never executed: break;

2501 -

2502 /* End of branch */ -

2503 -

2504 case OP_KET: -

2505 case OP_KETRMAX: -

2506 case OP_KETRMIN: -

2507 case OP_KETRPOS: -

2508 case OP_ALT: -

2509

if (utf && HAS_EXTRALEN(code[1])) code += GET_EXTRALEN(code[1]);

never executed: return 1;

2510 -

2511 /* In UTF-8 mode, STAR, MINSTAR, POSSTAR, QUERY, MINQUERY, POSQUERY, UPTO, -

2512 MINUPTO, and POSUPTO may be followed by a multibyte character */ -

2513 -

2514 #ifdef SUPPORT_UTF -

2515 case OP_STAR: -

2516 case OP_STARI: -

2517 case OP_MINSTAR: -

2518 case OP_MINSTARI: -

2519 case OP_POSSTAR: -

2520 case OP_POSSTARI: -

2521 case OP_QUERY: -

2522 case OP_QUERYI: -

2523 case OP_MINQUERY: -

2524 case OP_MINQUERYI: -

2525 case OP_POSQUERY: -

2526 case OP_POSQUERYI: -

2527

never executed: code += 1;

never evaluated: utf

never evaluated: (((code[1]) & 0xfc00) == 0xd800)

2528

if (utf && HAS_EXTRALEN(code[1 + IMM2_SIZE])) code += GET_EXTRALEN(code[1 + IMM2_SIZE]);

never executed: break;

2529 -

2530 case OP_UPTO: -

2531 case OP_UPTOI: -

2532 case OP_MINUPTO: -

2533 case OP_MINUPTOI: -

2534 case OP_POSUPTO: -

2535 case OP_POSUPTOI: -

2536

never executed: code += 1;

never evaluated: utf

never evaluated: (((code[1 + 1]) & 0xfc00) == 0xd800)

2537

never executed: break;

2538 #endif -

2539 -

2540 /* MARK, and PRUNE/SKIP/THEN with an argument must skip over the argument -

2541 string. */ -

2542 -

2543 case OP_MARK: -

2544 case OP_PRUNE_ARG: -

2545 case OP_SKIP_ARG: -

2546

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

2547

never executed: break;

2548 -

2549 case OP_THEN_ARG: -

2550

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

2551

never executed: break;

2552 -

2553 /* None of the remaining opcodes are required to match a character. */ -

2554 -

2555 default: -

2556

never executed: break;

2557 } -

2558

never executed: }

2559 -

2560

while (bcptr != NULL && bcptr->current_branch >= code)

never executed: return 1;

2561 } -

2562 -

2563 -

2564 -

2565 /************************************************* -

2566 * Scan compiled regex for non-emptiness * -

2567 *************************************************/ -

2568 -

2569 /* This function is called to check for left recursive calls. We want to check -

2570 the current branch of the current pattern to see if it could match the empty -

2571 string. If it could, we must look outwards for branches at other levels, -

2572 stopping when we pass beyond the bracket which is the subject of the recursion. -

2573 This function is called only during the real compile, not during the -

2574 pre-compile. -

2575 -

2576 Arguments: -

2577 code points to start of the recursion -

2578 endcode points to where to stop (current RECURSE item) -

2579 bcptr points to the chain of current (unclosed) branch starts -

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

2581 cd pointers to tables etc -

2582 -

2583 Returns: TRUE if what is matched could be empty -

2584 */ -

2585 -

2586 static BOOL -

2587 could_be_empty(const pcre_uchar *code, const pcre_uchar *endcode, -

2588 branch_chain *bcptr, BOOL utf, compile_data *cd) -

2589 { -

2590

never evaluated: bcptr != ((void *)0)

never evaluated: bcptr->current_branch >= code

2591 { -

2592

if (!could_be_empty_branch(bcptr->current_branch, endcode, utf, cd))

never evaluated: !could_be_empty_branch(bcptr->current_branch, endcode, utf, cd)

2593

int terminator; /* Don't combine these lines; the Solaris cc */

never executed: return 0;

2594

bcptr = bcptr->outer;

never executed (the execution status of this line is deduced): bcptr = bcptr->outer;

never executed: }

never executed: return 1;

2597 } -

2598 -

2599 -

2600 -

2601 /************************************************* -

2602 * Check for POSIX class syntax * -

2603 *************************************************/ -

2604 -

2605 /* This function is called when the sequence "[:" or "[." or "[=" is -

2606 encountered in a character class. It checks whether this is followed by a -

2607 sequence of characters terminated by a matching ":]" or ".]" or "=]". If we -

2608 reach an unescaped ']' without the special preceding character, return FALSE. -

2609 -

2610 Originally, this function only recognized a sequence of letters between the -

2611 terminators, but it seems that Perl recognizes any sequence of characters, -

2612 though of course unknown POSIX names are subsequently rejected. Perl gives an -

2613 "Unknown POSIX class" error for [:f\oo:] for example, where previously PCRE -

2614 didn't consider this to be a POSIX class. Likewise for [:1234:]. -

2615 -

2616 The problem in trying to be exactly like Perl is in the handling of escapes. We -

2617 have to be sure that [abc[:x\]pqr] is *not* treated as containing a POSIX -

2618 class, but [abc[:x\]pqr:]] is (so that an error can be generated). The code -

2619 below handles the special case of \], but does not try to do any other escape -

2620 processing. This makes it different from Perl for cases such as [:l\ower:] -

2621 where Perl recognizes it as the POSIX class "lower" but PCRE does not recognize -

2622 "l\ower". This is a lesser evil that not diagnosing bad classes when Perl does, -

2623 I think. -

2624 -

2625 A user pointed out that PCRE was rejecting [:a[:digit:]] whereas Perl was not. -

2626 It seems that the appearance of a nested POSIX class supersedes an apparent -

2627 external class. For example, [:a[:digit:]b:] matches "a", "b", ":", or -

2628 a digit. -

2629 -

2630 In Perl, unescaped square brackets may also appear as part of class names. For -

2631 example, [:a[:abc]b:] gives unknown POSIX class "[:abc]b:]". However, for -

2632 [:a[:abc]b][b:] it gives unknown POSIX class "[:abc]b][b:]", which does not -

2633 seem right at all. PCRE does not allow closing square brackets in POSIX class -

2634 names. -

2635 -

2636 Arguments: -

2637 ptr pointer to the initial [ -

2638 endptr where to return the end pointer -

2639 -

2640 Returns: TRUE or FALSE -

2641 */ -

2642 -

2643 static BOOL -

2644 check_posix_syntax(const pcre_uchar *ptr, const pcre_uchar **endptr) -

2645 { -

2646

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

2647

terminator = *(++ptr); /* compiler warns about "non-constant" initializer. */

never executed (the execution status of this line is deduced): terminator = *(++ptr);

2648

for (++ptr; *ptr != 0; ptr++)

never evaluated: *ptr != 0

2649 { -

2650

if (*ptr == CHAR_BACKSLASH && ptr[1] == CHAR_RIGHT_SQUARE_BRACKET)

never evaluated: *ptr == '\134'

never evaluated: ptr[1] == '\135'

2651

else if (*ptr == CHAR_RIGHT_SQUARE_BRACKET) return FALSE;

never executed: ptr++;

2652

never executed: return 0;

never evaluated: *ptr == '\135'

2653 else -

2654 { -

2655

if (*ptr == terminator && ptr[1] == CHAR_RIGHT_SQUARE_BRACKET)

never evaluated: *ptr == terminator

never evaluated: ptr[1] == '\135'

2656 { -

2657

*endptr = ptr;

never executed (the execution status of this line is deduced): *endptr = ptr;

2658

if (*ptr == CHAR_LEFT_SQUARE_BRACKET &&

never executed: return 1;

2659 } -

2660

never evaluated: *ptr == '\133'

2661

(ptr[1] == CHAR_COLON || ptr[1] == CHAR_DOT ||

never evaluated: ptr[1] == '\072'

never evaluated: ptr[1] == '\056'

2662

ptr[1] == CHAR_EQUALS_SIGN) &&

never evaluated: ptr[1] == '\075'

2663

check_posix_syntax(ptr, endptr))

never evaluated: check_posix_syntax(ptr, endptr)

2664

never executed: return 0;

2665

never executed: }

2666 } -

2667

const char *pn = posix_names;

never executed: return 0;

2668 } -

2669 -

2670 -

2671 -

2672 -

2673 /************************************************* -

2674 * Check POSIX class name * -

2675 *************************************************/ -

2676 -

2677 /* This function is called to check the name given in a POSIX-style class entry -

2678 such as [:alnum:]. -

2679 -

2680 Arguments: -

2681 ptr points to the first letter -

2682 len the length of the name -

2683 -

2684 Returns: a value representing the name, or -1 if unknown -

2685 */ -

2686 -

2687 static int -

2688 check_posix_name(const pcre_uchar *ptr, int len) -

2689 { -

2690

never executed (the execution status of this line is deduced): const char *pn = posix_names;

2691

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

2692

while (posix_name_lengths[yield] != 0)

never evaluated: posix_name_lengths[yield] != 0

2693 { -

2694

if (len == posix_name_lengths[yield] &&

never evaluated: len == posix_name_lengths[yield]

2695

STRNCMP_UC_C8(ptr, pn, len) == 0) return yield;

never executed: return yield;

never evaluated: _pcre16_strncmp_uc_c8((ptr), (pn), (len)) == 0

2696

pn += posix_name_lengths[yield] + 1;

never executed (the execution status of this line is deduced): pn += posix_name_lengths[yield] + 1;

2697

yield++;

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

never executed: }

never executed: return -1;

2700 } -

2701 -

2702 -

2703 /************************************************* -

2704 * Adjust OP_RECURSE items in repeated group * -

2705 *************************************************/ -

2706 -

2707 /* OP_RECURSE items contain an offset from the start of the regex to the group -

2708 that is referenced. This means that groups can be replicated for fixed -

2709 repetition simply by copying (because the recursion is allowed to refer to -

2710 earlier groups that are outside the current group). However, when a group is -

2711 optional (i.e. the minimum quantifier is zero), OP_BRAZERO or OP_SKIPZERO is -

2712 inserted before it, after it has been compiled. This means that any OP_RECURSE -

2713 items within it that refer to the group itself or any contained groups have to -

2714 have their offsets adjusted. That one of the jobs of this function. Before it -

2715 is called, the partially compiled regex must be temporarily terminated with -

2716 OP_END. -

2717 -

2718 This function has been extended with the possibility of forward references for -

2719 recursions and subroutine calls. It must also check the list of such references -

2720 for the group we are dealing with. If it finds that one of the recursions in -

2721 the current group is on this list, it adjusts the offset in the list, not the -

2722 value in the reference (which is a group number). -

2723 -

2724 Arguments: -

2725 group points to the start of the group -

2726 adjust the amount by which the group is to be moved -

2727 utf TRUE in UTF-8 / UTF-16 mode -

2728 cd contains pointers to tables etc. -

2729 save_hwm the hwm forward reference pointer at the start of the group -

2730 -

2731 Returns: nothing -

2732 */ -

2733 -

2734 static void -

2735 adjust_recurse(pcre_uchar *group, int adjust, BOOL utf, compile_data *cd, -

2736 pcre_uchar *save_hwm) -

2737 { -

2738

pcre_uchar *ptr = group;

executed (the execution status of this line is deduced): pcre_uchar *ptr = group;

2739 -

2740

while ((ptr = (pcre_uchar *)find_recurse(ptr, utf)) != NULL)

partially evaluated: (ptr = (pcre_uchar *)find_recurse(ptr, utf)) != ((void *)0)

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

0-106

2741 { -

2742

int offset;

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

2743

pcre_uchar *hc;

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

2744 -

2745 /* See if this recursion is on the forward reference list. If so, adjust the -

2746 reference. */ -

2747 -

2748

for (hc = save_hwm; hc < cd->hwm; hc += LINK_SIZE)

never evaluated: hc < cd->hwm

2749 { -

2750

offset = GET(hc, 0);

never executed (the execution status of this line is deduced): offset = (hc[0]);

2751

if (cd->start_code + offset == ptr + 1)

never evaluated: cd->start_code + offset == ptr + 1

2752 { -

2753

PUT(hc, 0, offset + adjust);

never executed (the execution status of this line is deduced): (hc[0] = (offset + adjust));

2754

never executed: break;

2755 } -

2756

if (cd->start_code + offset >= group) PUT(ptr, 1, offset + adjust);

never executed: }

2757 -

2758 /* Otherwise, adjust the recursion offset if it's after the start of this -

2759 group. */ -

2760 -

2761

if (hc >= cd->hwm)

never evaluated: hc >= cd->hwm

2762 { -

2763

offset = GET(ptr, 1);

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

2764

never executed: (ptr[1] = (offset + adjust));

never evaluated: cd->start_code + offset >= group

2765

PUT(code, 0, (int)(ptr - cd->start_pattern)); /* Pattern offset */

never executed: }

2766 -

2767

ptr += 1 + LINK_SIZE;

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

never executed: }

executed: }

Execution Count:106

106

2770 -

2771 -

2772 -

2773 /************************************************* -

2774 * Insert an automatic callout point * -

2775 *************************************************/ -

2776 -

2777 /* This function is called when the PCRE_AUTO_CALLOUT option is set, to insert -

2778 callout points before each pattern item. -

2779 -

2780 Arguments: -

2781 code current code pointer -

2782 ptr current pattern pointer -

2783 cd pointers to tables etc -

2784 -

2785 Returns: new code pointer -

2786 */ -

2787 -

2788 static pcre_uchar * -

2789 auto_callout(pcre_uchar *code, const pcre_uchar *ptr, compile_data *cd) -

2790 { -

2791

*code++ = OP_CALLOUT;

never executed (the execution status of this line is deduced): *code++ = OP_CALLOUT;

2792

*code++ = 255;

never executed (the execution status of this line is deduced): *code++ = 255;

2793

never executed (the execution status of this line is deduced): (code[0] = ((int)(ptr - cd->start_pattern)));

2794

PUT(code, LINK_SIZE, 0); /* Default length */

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

2795

return code + 2 * LINK_SIZE;

never executed: return code + 2 * 1;

2796 } -

2797 -

2798 -

2799 -

2800 /************************************************* -

2801 * Complete a callout item * -

2802 *************************************************/ -

2803 -

2804 /* A callout item contains the length of the next item in the pattern, which -

2805 we can't fill in till after we have reached the relevant point. This is used -

2806 for both automatic and manual callouts. -

2807 -

2808 Arguments: -

2809 previous_callout points to previous callout item -

2810 ptr current pattern pointer -

2811 cd pointers to tables etc -

2812 -

2813 Returns: nothing -

2814 */ -

2815 -

2816 static void -

2817 complete_callout(pcre_uchar *previous_callout, const pcre_uchar *ptr, compile_data *cd) -

2818 { -

2819

int length = (int)(ptr - cd->start_pattern - GET(previous_callout, 2));

never executed (the execution status of this line is deduced): int length = (int)(ptr - cd->start_pattern - (previous_callout[2]));

2820

PUT(previous_callout, 2 + LINK_SIZE, length);

never executed (the execution status of this line is deduced): (previous_callout[2 + 1] = (length));

2821

unsigned int c, othercase, next;

never executed: }

2822 -

2823 -

2824 -

2825 #ifdef SUPPORT_UCP -

2826 /************************************************* -

2827 * Get othercase range * -

2828 *************************************************/ -

2829 -

2830 /* This function is passed the start and end of a class range, in UTF-8 mode -

2831 with UCP support. It searches up the characters, looking for internal ranges of -

2832 characters in the "other" case. Each call returns the next one, updating the -

2833 start address. -

2834 -

2835 Arguments: -

2836 cptr points to starting character value; updated -

2837 d end value -

2838 ocptr where to put start of othercase range -

2839 odptr where to put end of othercase range -

2840 -

2841 Yield: TRUE when range returned; FALSE when no more -

2842 */ -

2843 -

2844 static BOOL -

2845 get_othercase_range(unsigned int *cptr, unsigned int d, unsigned int *ocptr, -

2846 unsigned int *odptr) -

2847 { -

2848

never executed (the execution status of this line is deduced): unsigned int c, othercase, next;

2849 -

2850

for (c = *cptr; c <= d; c++)

never evaluated: c <= d

2851

{ if ((othercase = UCD_OTHERCASE(c)) != c) break; }

never executed: break;

never executed: }

never evaluated:

(othercase = (c + (_pcre16_ucd_records + _pcre16_ucd_stage2[_pcre16_ucd_stage1[(c) / 128] * 128 + (c) % 128])->other_case)) != c

2852 -

2853

if (c > d) return FALSE;

never executed: return 0;

never evaluated: c > d

2854 -

2855

*ocptr = othercase;

never executed (the execution status of this line is deduced): *ocptr = othercase;

2856

next = othercase + 1;

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

2857 -

2858

for (++c; c <= d; c++)

never evaluated: c <= d

2859 { -

2860

if (UCD_OTHERCASE(c) != next) break;

never executed: break;

never evaluated: (c + (_pcre16_ucd_records + _pcre16_ucd_stage2[_pcre16_ucd_stage1[(c) / 128] * 128 + (c) % 128])->other_case) != next

2861

next++;

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

2862

never executed: }

2863 -

2864

*odptr = next - 1;

never executed (the execution status of this line is deduced): *odptr = next - 1;

2865

*cptr = c;

never executed (the execution status of this line is deduced): *cptr = c;

2866 -

2867

const ucd_record *prop = GET_UCD(c);

never executed: return 1;

2868 } -

2869 -

2870 -

2871 -

2872 /************************************************* -

2873 * Check a character and a property * -

2874 *************************************************/ -

2875 -

2876 /* This function is called by check_auto_possessive() when a property item -

2877 is adjacent to a fixed character. -

2878 -

2879 Arguments: -

2880 c the character -

2881 ptype the property type -

2882 pdata the data for the type -

2883 negated TRUE if it's a negated property (\P or \p{^) -

2884 -

2885 Returns: TRUE if auto-possessifying is OK -

2886 */ -

2887 -

2888 static BOOL -

2889 check_char_prop(int c, int ptype, int pdata, BOOL negated) -

2890 { -

2891

never executed (the execution status of this line is deduced): const ucd_record *prop = (_pcre16_ucd_records + _pcre16_ucd_stage2[_pcre16_ucd_stage1[(c) / 128] * 128 + (c) % 128]);

2892 switch(ptype) -

2893 { -

2894 case PT_LAMP: -

2895

return (prop->chartype == ucp_Lu ||

never executed: return (prop->chartype == ucp_Lu || prop->chartype == ucp_Ll || prop->chartype == ucp_Lt) == negated;

2896

prop->chartype == ucp_Ll ||

never executed: return (prop->chartype == ucp_Lu || prop->chartype == ucp_Ll || prop->chartype == ucp_Lt) == negated;

2897

prop->chartype == ucp_Lt) == negated;

never executed: return (prop->chartype == ucp_Lu || prop->chartype == ucp_Ll || prop->chartype == ucp_Lt) == negated;

2898 -

2899 case PT_GC: -

2900

return (pdata == PRIV(ucp_gentype)[prop->chartype]) == negated;

never executed: return (pdata == _pcre16_ucp_gentype[prop->chartype]) == negated;

2901 -

2902 case PT_PC: -

2903

return (pdata == prop->chartype) == negated;

never executed: return (pdata == prop->chartype) == negated;

2904 -

2905 case PT_SC: -

2906

return (pdata == prop->script) == negated;

never executed: return (pdata == prop->script) == negated;

2907 -

2908 /* These are specials */ -

2909 -

2910 case PT_ALNUM: -

2911

return (PRIV(ucp_gentype)[prop->chartype] == ucp_L ||

never executed: return (_pcre16_ucp_gentype[prop->chartype] == ucp_L || _pcre16_ucp_gentype[prop->chartype] == ucp_N) == negated;

2912

PRIV(ucp_gentype)[prop->chartype] == ucp_N) == negated;

never executed: return (_pcre16_ucp_gentype[prop->chartype] == ucp_L || _pcre16_ucp_gentype[prop->chartype] == ucp_N) == negated;

2913 -

2914 case PT_SPACE: /* Perl space */ -

2915

return (PRIV(ucp_gentype)[prop->chartype] == ucp_Z ||

never executed:

return (_pcre16_ucp_gentype[prop->chartype] == ucp_Z || c == '\011' || c == '\012' || c == '\014' || c == '\015') == negated;

2916

c == CHAR_HT || c == CHAR_NL || c == CHAR_FF || c == CHAR_CR)

never executed:

return (_pcre16_ucp_gentype[prop->chartype] == ucp_Z || c == '\011' || c == '\012' || c == '\014' || c == '\015') == negated;

2917

== negated;

never executed:

return (_pcre16_ucp_gentype[prop->chartype] == ucp_Z || c == '\011' || c == '\012' || c == '\014' || c == '\015') == negated;

2918 -

2919 case PT_PXSPACE: /* POSIX space */ -

2920

return (PRIV(ucp_gentype)[prop->chartype] == ucp_Z ||

never executed:

return (_pcre16_ucp_gentype[prop->chartype] == ucp_Z || c == '\011' || c == '\012' || c == '\013' || c == '\014' || c == '\015') == negated;

2921

c == CHAR_HT || c == CHAR_NL || c == CHAR_VT ||

never executed:

return (_pcre16_ucp_gentype[prop->chartype] == ucp_Z || c == '\011' || c == '\012' || c == '\013' || c == '\014' || c == '\015') == negated;

2922

c == CHAR_FF || c == CHAR_CR)

never executed:

return (_pcre16_ucp_gentype[prop->chartype] == ucp_Z || c == '\011' || c == '\012' || c == '\013' || c == '\014' || c == '\015') == negated;

2923

== negated;

never executed:

return (_pcre16_ucp_gentype[prop->chartype] == ucp_Z || c == '\011' || c == '\012' || c == '\013' || c == '\014' || c == '\015') == negated;

2924 -

2925 case PT_WORD: -

2926

return (PRIV(ucp_gentype)[prop->chartype] == ucp_L ||

never executed:

return (_pcre16_ucp_gentype[prop->chartype] == ucp_L || _pcre16_ucp_gentype[prop->chartype] == ucp_N || c == '\137') == negated;

2927

PRIV(ucp_gentype)[prop->chartype] == ucp_N ||

never executed:

return (_pcre16_ucp_gentype[prop->chartype] == ucp_L || _pcre16_ucp_gentype[prop->chartype] == ucp_N || c == '\137') == negated;

2928

c == CHAR_UNDERSCORE) == negated;

never executed:

return (_pcre16_ucp_gentype[prop->chartype] == ucp_L || _pcre16_ucp_gentype[prop->chartype] == ucp_N || c == '\137') == negated;

2929 } -

2930

int op_code = *previous++;

never executed: return 0;

2931 } -

2932 #endif /* SUPPORT_UCP */ -

2933 -

2934 -

2935 -

2936 /************************************************* -

2937 * Check if auto-possessifying is possible * -

2938 *************************************************/ -

2939 -

2940 /* This function is called for unlimited repeats of certain items, to see -

2941 whether the next thing could possibly match the repeated item. If not, it makes -

2942 sense to automatically possessify the repeated item. -

2943 -

2944 Arguments: -

2945 previous pointer to the repeated opcode -

2946 utf TRUE in UTF-8 / UTF-16 mode -

2947 ptr next character in pattern -

2948 options options bits -

2949 cd contains pointers to tables etc. -

2950 -

2951 Returns: TRUE if possessifying is wanted -

2952 */ -

2953 -

2954 static BOOL -

2955 check_auto_possessive(const pcre_uchar *previous, BOOL utf, -

2956 const pcre_uchar *ptr, int options, compile_data *cd) -

2957 { -

2958

pcre_int32 c, next;

executed (the execution status of this line is deduced): pcre_int32 c, next;

2959

executed (the execution status of this line is deduced): int op_code = *previous++;

2960 -

2961 /* Skip whitespace and comments in extended mode */ -

2962 -

2963

if ((options & PCRE_EXTENDED) != 0)

evaluated: (options & 0x00000008) != 0

TRUE	FALSE
yes Evaluation Count:4	yes Evaluation Count:353

4-353

2964 { -

2965

while (MAX_255(*ptr) && (cd->ctypes[*ptr] & ctype_space) != 0) ptr++;

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

2966 { -

2967

executed: ptr++;

Execution Count:6

partially evaluated: ((*ptr) <= 255u)

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

evaluated: (cd->ctypes[*ptr] & 0x01) != 0

TRUE	FALSE
yes Evaluation Count:6	yes Evaluation Count:8

0-14

2968

if (*ptr == CHAR_NUMBER_SIGN)

evaluated: *ptr == '\043'

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

2969 { -

2970

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

2971

if (IS_NEWLINE(ptr)) { ptr += cd->nllen; break; }

evaluated: *ptr != 0

TRUE	FALSE
yes Evaluation Count:42	yes Evaluation Count:2

2-42

2972 { -

2973

executed: break;

Execution Count:2

partially evaluated: (cd->nltype != 0)

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

0-42

2974

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

2975 #ifdef SUPPORT_UTF -

2976

never executed: ptr++;

partially evaluated: utf

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

partially evaluated: (*ptr & 0xfc00) == 0xdc00

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

0-40

2977 #endif -

2978

executed: }

Execution Count:40

2979

executed: }

Execution Count:4

2980

executed: break;

Execution Count:4

2981 } -

2982

if (*ptr == CHAR_BACKSLASH)

executed: }

Execution Count:4

2983 -

2984 /* If the next item is one that we can handle, get its value. A non-negative -

2985 value is a character, a negative value is an escape value. */ -

2986 -

2987

evaluated: *ptr == '\134'

TRUE	FALSE
yes Evaluation Count:110	yes Evaluation Count:247

110-247

2988 { -

2989

int temperrorcode = 0;

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

2990

next = check_escape(&ptr, &temperrorcode, cd->bracount, options, FALSE);

executed (the execution status of this line is deduced): next = check_escape(&ptr, &temperrorcode, cd->bracount, options, 0);

2991

if (temperrorcode != 0) return FALSE;

never executed: return 0;

partially evaluated: temperrorcode != 0

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

0-110

2992

ptr++; /* Point after the escape sequence */

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

2993

else if (!MAX_255(*ptr) || (cd->ctypes[*ptr] & ctype_meta) == 0)

executed: }

Execution Count:110

110

2994

partially evaluated: !((*ptr) <= 255u)

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

evaluated: (cd->ctypes[*ptr] & 0x80) == 0

TRUE	FALSE
yes Evaluation Count:66	yes Evaluation Count:181

0-247

2995 { -

2996 #ifdef SUPPORT_UTF -

2997

if (utf) { GETCHARINC(next, ptr); } else

never executed: }

executed: }

Execution Count:66

partially evaluated: (next & 0xfc00) == 0xd800

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

partially evaluated: utf

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

0-66

2998 #endif -

2999

next = *ptr++;

never executed: next = *ptr++;

3000 } -

3001

else return FALSE;

executed: return 0;

Execution Count:181

181

3002 -

3003 /* Skip whitespace and comments in extended mode */ -

3004 -

3005

if ((options & PCRE_EXTENDED) != 0)

evaluated: (options & 0x00000008) != 0

TRUE	FALSE
yes Evaluation Count:2	yes Evaluation Count:174

2-174

3006 { -

3007

while (MAX_255(*ptr) && (cd->ctypes[*ptr] & ctype_space) != 0) ptr++;

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

3008 { -

3009

never executed: ptr++;

partially evaluated: ((*ptr) <= 255u)

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

partially evaluated: (cd->ctypes[*ptr] & 0x01) != 0

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

0-4

3010

if (*ptr == CHAR_NUMBER_SIGN)

evaluated: *ptr == '\043'

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

3011 { -

3012

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

3013

if (IS_NEWLINE(ptr)) { ptr += cd->nllen; break; }

partially evaluated: *ptr != 0

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

0-18

3014 { -

3015

executed: break;

Execution Count:2

partially evaluated: (cd->nltype != 0)

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

0-18

3016

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

3017 #ifdef SUPPORT_UTF -

3018

never executed: ptr++;

partially evaluated: utf

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

partially evaluated: (*ptr & 0xfc00) == 0xdc00

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

0-16

3019 #endif -

3020

executed: }

Execution Count:16

3021

executed: }

Execution Count:2

3022

executed: break;

Execution Count:2

3023 } -

3024

if (*ptr == CHAR_ASTERISK || *ptr == CHAR_QUESTION_MARK ||

executed: }

Execution Count:2

3025 -

3026 /* If the next thing is itself optional, we have to give up. */ -

3027 -

3028

evaluated: *ptr == '\052'

TRUE	FALSE
yes Evaluation Count:2	yes Evaluation Count:174

partially evaluated: *ptr == '\077'

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

0-174

3029

STRNCMP_UC_C8(ptr, STR_LEFT_CURLY_BRACKET STR_0 STR_COMMA, 3) == 0)

partially evaluated: _pcre16_strncmp_uc_c8((ptr), ("\173" "\060" "\054"), (3)) == 0

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

0-174

3030

if (next >= 0) switch(op_code)

executed: return 0;

Execution Count:2

3031 -

3032 /* Now compare the next item with the previous opcode. First, handle cases when -

3033 the next item is a character. */ -

3034 -

3035

evaluated: next >= 0

TRUE	FALSE
yes Evaluation Count:66	yes Evaluation Count:108

66-108

3036 { -

3037 case OP_CHAR: -

3038 #ifdef SUPPORT_UTF -

3039

GETCHARTEST(c, previous);

never executed: }

never evaluated: utf

never evaluated: (c & 0xfc00) == 0xd800

3040 #else -

3041 c = *previous; -

3042 #endif -

3043

return c != next;

never executed: return c != next;

3044 -

3045 /* For CHARI (caseless character) we must check the other case. If we have -

3046 Unicode property support, we can use it to test the other case of -

3047 high-valued characters. */ -

3048 -

3049 case OP_CHARI: -

3050 #ifdef SUPPORT_UTF -

3051

GETCHARTEST(c, previous);

never executed: }

never evaluated: utf

never evaluated: (c & 0xfc00) == 0xd800

3052 #else -

3053 c = *previous; -

3054 #endif -

3055

if (c == next) return FALSE;

never executed: return 0;

never evaluated: c == next

3056 #ifdef SUPPORT_UTF -

3057

if (next < 128) othercase = cd->fcc[next]; else

never evaluated: utf

3058 { -

3059

unsigned int othercase;

never executed (the execution status of this line is deduced): unsigned int othercase;

3060

never executed: othercase = cd->fcc[next];

never evaluated: next < 128

3061 #ifdef SUPPORT_UCP -

3062

othercase = UCD_OTHERCASE((unsigned int)next);

never executed:

othercase = ((unsigned int)next + (_pcre16_ucd_records + _pcre16_ucd_stage2[_pcre16_ucd_stage1[((unsigned int)next) / 128] * 128 + ((unsigned int)next) % 128])->other_case);

3063 #else -

3064 othercase = NOTACHAR; -

3065 #endif -

3066

return (unsigned int)c != othercase;

never executed: return (unsigned int)c != othercase;

3067 } -

3068 else -

3069 #endif /* SUPPORT_UTF */ -

3070

return (c != TABLE_GET((unsigned int)next, cd->fcc, next)); /* Non-UTF-8 mode */

never executed: return (c != ((((unsigned int)next) <= 255u)? ((cd->fcc)[(unsigned int)next]):(next)));

3071 -

3072 /* For OP_NOT and OP_NOTI, the data is always a single-byte character. These -

3073 opcodes are not used for multi-byte characters, because they are coded using -

3074 an XCLASS instead. */ -

3075 -

3076 case OP_NOT: -

3077

return (c = *previous) == next;

never executed: return (c = *previous) == next;

3078 -

3079 case OP_NOTI: -

3080

if ((c = *previous) == next) return TRUE;

never executed: return 1;

never evaluated: (c = *previous) == next

3081 #ifdef SUPPORT_UTF -

3082

if (next < 128) othercase = cd->fcc[next]; else

never evaluated: utf

3083 { -

3084

unsigned int othercase;

never executed (the execution status of this line is deduced): unsigned int othercase;

3085

never executed: othercase = cd->fcc[next];

never evaluated: next < 128

3086 #ifdef SUPPORT_UCP -

3087

othercase = UCD_OTHERCASE(next);

never executed:

othercase = (next + (_pcre16_ucd_records + _pcre16_ucd_stage2[_pcre16_ucd_stage1[(next) / 128] * 128 + (next) % 128])->other_case);

3088 #else -

3089 othercase = NOTACHAR; -

3090 #endif -

3091

return (unsigned int)c == othercase;

never executed: return (unsigned int)c == othercase;

3092 } -

3093 else -

3094 #endif /* SUPPORT_UTF */ -

3095

return (c == (int)(TABLE_GET((unsigned int)next, cd->fcc, next))); /* Non-UTF-8 mode */

never executed: return (c == (int)(((((unsigned int)next) <= 255u)? ((cd->fcc)[(unsigned int)next]):(next))));

3096 -

3097 /* Note that OP_DIGIT etc. are generated only when PCRE_UCP is *not* set. -

3098 When it is set, \d etc. are converted into OP_(NOT_)PROP codes. */ -

3099 -

3100 case OP_DIGIT: -

3101

return next > 127 || (cd->ctypes[next] & ctype_digit) == 0;

never executed: return next > 127 || (cd->ctypes[next] & 0x04) == 0;

3102 -

3103 case OP_NOT_DIGIT: -

3104

return next <= 127 && (cd->ctypes[next] & ctype_digit) != 0;

never executed: return next <= 127 && (cd->ctypes[next] & 0x04) != 0;

3105 -

3106 case OP_WHITESPACE: -

3107

return next > 127 || (cd->ctypes[next] & ctype_space) == 0;

never executed: return next > 127 || (cd->ctypes[next] & 0x01) == 0;

3108 -

3109 case OP_NOT_WHITESPACE: -

3110

return next <= 127 && (cd->ctypes[next] & ctype_space) != 0;

never executed: return next <= 127 && (cd->ctypes[next] & 0x01) != 0;

3111 -

3112 case OP_WORDCHAR: -

3113

return next > 127 || (cd->ctypes[next] & ctype_word) == 0;

executed: return next > 127 || (cd->ctypes[next] & 0x10) == 0;

Execution Count:30

3114 -

3115 case OP_NOT_WORDCHAR: -

3116

return next <= 127 && (cd->ctypes[next] & ctype_word) != 0;

never executed: return next <= 127 && (cd->ctypes[next] & 0x10) != 0;

3117 -

3118 case OP_HSPACE: -

3119 case OP_NOT_HSPACE: -

3120 switch(next) -

3121 { -

3122 case 0x09: -

3123 case 0x20: -

3124 case 0xa0: -

3125 case 0x1680: -

3126 case 0x180e: -

3127 case 0x2000: -

3128 case 0x2001: -

3129 case 0x2002: -

3130 case 0x2003: -

3131 case 0x2004: -

3132 case 0x2005: -

3133 case 0x2006: -

3134 case 0x2007: -

3135 case 0x2008: -

3136 case 0x2009: -

3137 case 0x200A: -

3138 case 0x202f: -

3139 case 0x205f: -

3140 case 0x3000: -

3141

return op_code == OP_NOT_HSPACE;

never executed: return op_code == OP_NOT_HSPACE;

3142 default: -

3143

return op_code != OP_NOT_HSPACE;

never executed: return op_code != OP_NOT_HSPACE;

3144 } -

3145 -

3146

case OP_ANYNL:

code before this statement never executed: case OP_ANYNL:

3147 case OP_VSPACE: -

3148 case OP_NOT_VSPACE: -

3149 switch(next) -

3150 { -

3151 case 0x0a: -

3152 case 0x0b: -

3153 case 0x0c: -

3154 case 0x0d: -

3155 case 0x85: -

3156 case 0x2028: -

3157 case 0x2029: -

3158

return op_code == OP_NOT_VSPACE;

never executed: return op_code == OP_NOT_VSPACE;

3159 default: -

3160

return op_code != OP_NOT_VSPACE;

never executed: return op_code != OP_NOT_VSPACE;

3161 } -

3162 -

3163 #ifdef SUPPORT_UCP -

3164 case OP_PROP: -

3165

return check_char_prop(next, previous[0], previous[1], FALSE);

never executed: return check_char_prop(next, previous[0], previous[1], 0);

3166 -

3167 case OP_NOTPROP: -

3168

return check_char_prop(next, previous[0], previous[1], TRUE);

never executed: return check_char_prop(next, previous[0], previous[1], 1);

3169 #endif -

3170 -

3171 default: -

3172

executed: return 0;

Execution Count:36

3173

GETCHARTEST(c, previous);

never executed: }

3174 -

3175 -

3176 /* Handle the case when the next item is \d, \s, etc. Note that when PCRE_UCP -

3177 is set, \d turns into ESC_du rather than ESC_d, etc., so ESC_d etc. are -

3178 generated only when PCRE_UCP is *not* set, that is, when only ASCII -

3179 characteristics are recognized. Similarly, the opcodes OP_DIGIT etc. are -

3180 replaced by OP_PROP codes when PCRE_UCP is set. */ -

3181 -

3182 switch(op_code) -

3183 { -

3184 case OP_CHAR: -

3185 case OP_CHARI: -

3186 #ifdef SUPPORT_UTF -

3187

never executed: }

never evaluated: utf

never evaluated: (c & 0xfc00) == 0xd800

3188 #else -

3189 c = *previous; -

3190 #endif -

3191 switch(-next) -

3192 { -

3193 case ESC_d: -

3194

return c > 127 || (cd->ctypes[c] & ctype_digit) == 0;

never executed: return c > 127 || (cd->ctypes[c] & 0x04) == 0;

3195 -

3196 case ESC_D: -

3197

return c <= 127 && (cd->ctypes[c] & ctype_digit) != 0;

never executed: return c <= 127 && (cd->ctypes[c] & 0x04) != 0;

3198 -

3199 case ESC_s: -

3200

return c > 127 || (cd->ctypes[c] & ctype_space) == 0;

never executed: return c > 127 || (cd->ctypes[c] & 0x01) == 0;

3201 -

3202 case ESC_S: -

3203

return c <= 127 && (cd->ctypes[c] & ctype_space) != 0;

never executed: return c <= 127 && (cd->ctypes[c] & 0x01) != 0;

3204 -

3205 case ESC_w: -

3206

return c > 127 || (cd->ctypes[c] & ctype_word) == 0;

never executed: return c > 127 || (cd->ctypes[c] & 0x10) == 0;

3207 -

3208 case ESC_W: -

3209

return c <= 127 && (cd->ctypes[c] & ctype_word) != 0;

never executed: return c <= 127 && (cd->ctypes[c] & 0x10) != 0;

3210 -

3211 case ESC_h: -

3212 case ESC_H: -

3213 switch(c) -

3214 { -

3215 case 0x09: -

3216 case 0x20: -

3217 case 0xa0: -

3218 case 0x1680: -

3219 case 0x180e: -

3220 case 0x2000: -

3221 case 0x2001: -

3222 case 0x2002: -

3223 case 0x2003: -

3224 case 0x2004: -

3225 case 0x2005: -

3226 case 0x2006: -

3227 case 0x2007: -

3228 case 0x2008: -

3229 case 0x2009: -

3230 case 0x200A: -

3231 case 0x202f: -

3232 case 0x205f: -

3233 case 0x3000: -

3234

return -next != ESC_h;

never executed: return -next != ESC_h;

3235 default: -

3236

return -next == ESC_h;

never executed: return -next == ESC_h;

3237 } -

3238 -

3239

case ESC_v:

code before this statement never executed: case ESC_v:

3240 case ESC_V: -

3241 switch(c) -

3242 { -

3243 case 0x0a: -

3244 case 0x0b: -

3245 case 0x0c: -

3246 case 0x0d: -

3247 case 0x85: -

3248 case 0x2028: -

3249 case 0x2029: -

3250

return -next != ESC_v;

never executed: return -next != ESC_v;

3251 default: -

3252

return -next == ESC_v;

never executed: return -next == ESC_v;

3253 } -

3254 -

3255 /* When PCRE_UCP is set, these values get generated for \d etc. Find -

3256 their substitutions and process them. The result will always be either -

3257 -ESC_p or -ESC_P. Then fall through to process those values. */ -

3258 -

3259 #ifdef SUPPORT_UCP -

3260

case ESC_du:

code before this statement never executed: case ESC_du:

3261 case ESC_DU: -

3262 case ESC_wu: -

3263 case ESC_WU: -

3264 case ESC_su: -

3265 case ESC_SU: -

3266 { -

3267

int temperrorcode = 0;

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

3268

ptr = substitutes[-next - ESC_DU];

never executed (the execution status of this line is deduced): ptr = substitutes[-next - ESC_DU];

3269

next = check_escape(&ptr, &temperrorcode, 0, options, FALSE);

never executed (the execution status of this line is deduced): next = check_escape(&ptr, &temperrorcode, 0, options, 0);

3270

if (temperrorcode != 0) return FALSE;

never executed: return 0;

never evaluated: temperrorcode != 0

3271

ptr++; /* For compatibility */

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

3272 } -

3273 /* Fall through */ -

3274 -

3275 case ESC_p: -

3276 case ESC_P: -

3277 { -

3278

int ptype, pdata, errorcodeptr;

never executed (the execution status of this line is deduced): int ptype, pdata, errorcodeptr;

3279

BOOL negated;

never executed (the execution status of this line is deduced): BOOL negated;

3280 -

3281

ptr--; /* Make ptr point at the p or P */

never executed (the execution status of this line is deduced): ptr--;

3282

ptype = get_ucp(&ptr, &negated, &pdata, &errorcodeptr);

never executed (the execution status of this line is deduced): ptype = get_ucp(&ptr, &negated, &pdata, &errorcodeptr);

3283

if (ptype < 0) return FALSE;

never executed: return 0;

never evaluated: ptype < 0

3284

ptr++; /* Point past the final curly ket */

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

3285 -

3286 /* If the property item is optional, we have to give up. (When generated -

3287 from \d etc by PCRE_UCP, this test will have been applied much earlier, -

3288 to the original \d etc. At this point, ptr will point to a zero byte. */ -

3289 -

3290

if (*ptr == CHAR_ASTERISK || *ptr == CHAR_QUESTION_MARK ||

never evaluated: *ptr == '\052'

never evaluated: *ptr == '\077'

3291

STRNCMP_UC_C8(ptr, STR_LEFT_CURLY_BRACKET STR_0 STR_COMMA, 3) == 0)

never evaluated: _pcre16_strncmp_uc_c8((ptr), ("\173" "\060" "\054"), (3)) == 0

3292

return check_char_prop(c, ptype, pdata, (next == -ESC_P) != negated);

never executed: return 0;

3293 -

3294 /* Do the property check. */ -

3295 -

3296

never executed: return check_char_prop(c, ptype, pdata, (next == -ESC_P) != negated);

3297 } -

3298 #endif -

3299 -

3300 default: -

3301

return next == -ESC_D || next == -ESC_s || next == -ESC_W ||

never executed: return 0;

3302 } -

3303 -

3304 /* In principle, support for Unicode properties should be integrated here as -

3305 well. It means re-organizing the above code so as to get hold of the property -

3306 values before switching on the op-code. However, I wonder how many patterns -

3307 combine ASCII \d etc with Unicode properties? (Note that if PCRE_UCP is set, -

3308 these op-codes are never generated.) */ -

3309 -

3310 case OP_DIGIT: -

3311

never executed: return next == -ESC_D || next == -ESC_s || next == -ESC_W || next == -ESC_h || next == -ESC_v || next == -ESC_R;

3312

next == -ESC_h || next == -ESC_v || next == -ESC_R;

never executed: return next == -ESC_D || next == -ESC_s || next == -ESC_W || next == -ESC_h || next == -ESC_v || next == -ESC_R;

3313 -

3314 case OP_NOT_DIGIT: -

3315

return next == -ESC_d;

never executed: return next == -ESC_d;

3316 -

3317 case OP_WHITESPACE: -

3318

return next == -ESC_S || next == -ESC_d || next == -ESC_w || next == -ESC_R;

never executed: return next == -ESC_S || next == -ESC_d || next == -ESC_w || next == -ESC_R;

3319 -

3320 case OP_NOT_WHITESPACE: -

3321

return next == -ESC_s || next == -ESC_h || next == -ESC_v;

never executed: return next == -ESC_s || next == -ESC_h || next == -ESC_v;

3322 -

3323 case OP_HSPACE: -

3324

return next == -ESC_S || next == -ESC_H || next == -ESC_d ||

never executed: return next == -ESC_S || next == -ESC_H || next == -ESC_d || next == -ESC_w || next == -ESC_v || next == -ESC_R;

3325

next == -ESC_w || next == -ESC_v || next == -ESC_R;

never executed: return next == -ESC_S || next == -ESC_H || next == -ESC_d || next == -ESC_w || next == -ESC_v || next == -ESC_R;

3326 -

3327 case OP_NOT_HSPACE: -

3328

return next == -ESC_h;

never executed: return next == -ESC_h;

3329 -

3330 /* Can't have \S in here because VT matches \S (Perl anomaly) */ -

3331 case OP_ANYNL: -

3332 case OP_VSPACE: -

3333

return next == -ESC_V || next == -ESC_d || next == -ESC_w;

never executed: return next == -ESC_V || next == -ESC_d || next == -ESC_w;

3334 -

3335 case OP_NOT_VSPACE: -

3336

return next == -ESC_v || next == -ESC_R;

never executed: return next == -ESC_v || next == -ESC_R;

3337 -

3338 case OP_WORDCHAR: -

3339

return next == -ESC_W || next == -ESC_s || next == -ESC_h ||

never executed: return next == -ESC_W || next == -ESC_s || next == -ESC_h || next == -ESC_v || next == -ESC_R;

3340

next == -ESC_v || next == -ESC_R;

never executed: return next == -ESC_W || next == -ESC_s || next == -ESC_h || next == -ESC_v || next == -ESC_R;

3341 -

3342 case OP_NOT_WORDCHAR: -

3343

return next == -ESC_w || next == -ESC_d;

never executed: return next == -ESC_w || next == -ESC_d;

3344 -

3345 default: -

3346

executed: return 0;

Execution Count:108

108

3347 } -

3348 -

3349 /* Control does not reach here */ -

3350

int repeat_type, op_type;

never executed: }

3351 -

3352 -

3353 -

3354 /************************************************* -

3355 * Compile one branch * -

3356 *************************************************/ -

3357 -

3358 /* Scan the pattern, compiling it into the a vector. If the options are -

3359 changed during the branch, the pointer is used to change the external options -

3360 bits. This function is used during the pre-compile phase when we are trying -

3361 to find out the amount of memory needed, as well as during the real compile -

3362 phase. The value of lengthptr distinguishes the two phases. -

3363 -

3364 Arguments: -

3365 optionsptr pointer to the option bits -

3366 codeptr points to the pointer to the current code point -

3367 ptrptr points to the current pattern pointer -

3368 errorcodeptr points to error code variable -

3369 firstcharptr set to initial literal character, or < 0 (REQ_UNSET, REQ_NONE) -

3370 reqcharptr set to the last literal character required, else < 0 -

3371 bcptr points to current branch chain -

3372 cond_depth conditional nesting depth -

3373 cd contains pointers to tables etc. -

3374 lengthptr NULL during the real compile phase -

3375 points to length accumulator during pre-compile phase -

3376 -

3377 Returns: TRUE on success -

3378 FALSE, with *errorcodeptr set non-zero on error -

3379 */ -

3380 -

3381 static BOOL -

3382 compile_branch(int *optionsptr, pcre_uchar **codeptr, -

3383 const pcre_uchar **ptrptr, int *errorcodeptr, pcre_int32 *firstcharptr, -

3384 pcre_int32 *reqcharptr, branch_chain *bcptr, int cond_depth, -

3385 compile_data *cd, int *lengthptr) -

3386 { -

3387

executed (the execution status of this line is deduced): int repeat_type, op_type;

3388

int repeat_min = 0, repeat_max = 0; /* To please picky compilers */

executed (the execution status of this line is deduced): int repeat_min = 0, repeat_max = 0;

3389

int bravalue = 0;

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

3390

int greedy_default, greedy_non_default;

executed (the execution status of this line is deduced): int greedy_default, greedy_non_default;

3391

pcre_int32 firstchar, reqchar;

executed (the execution status of this line is deduced): pcre_int32 firstchar, reqchar;

3392

pcre_int32 zeroreqchar, zerofirstchar;

executed (the execution status of this line is deduced): pcre_int32 zeroreqchar, zerofirstchar;

3393

pcre_int32 req_caseopt, reqvary, tempreqvary;

executed (the execution status of this line is deduced): pcre_int32 req_caseopt, reqvary, tempreqvary;

3394

int options = *optionsptr; /* May change dynamically */

executed (the execution status of this line is deduced): int options = *optionsptr;

3395

int after_manual_callout = 0;

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

3396

int length_prevgroup = 0;

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

3397

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

3398

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

3399

pcre_uchar *last_code = code;

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

3400

pcre_uchar *orig_code = code;

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

3401

pcre_uchar *tempcode;

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

3402

BOOL inescq = FALSE;

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

3403

BOOL groupsetfirstchar = FALSE;

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

3404

const pcre_uchar *ptr = *ptrptr;

executed (the execution status of this line is deduced): const pcre_uchar *ptr = *ptrptr;

3405

const pcre_uchar *tempptr;

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

3406

const pcre_uchar *nestptr = NULL;

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

3407

pcre_uchar *previous = NULL;

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

3408

pcre_uchar *previous_callout = NULL;

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

3409

pcre_uchar *save_hwm = NULL;

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

3410

pcre_uint8 classbits[32];

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

3411 -

3412 /* We can fish out the UTF-8 setting once and for all into a BOOL, but we -

3413 must not do this for other options (e.g. PCRE_EXTENDED) because they may change -

3414 dynamically as we process the pattern. */ -

3415 -

3416 #ifdef SUPPORT_UTF -

3417 /* PCRE_UTF16 has the same value as PCRE_UTF8. */ -

3418

BOOL utf = (options & PCRE_UTF8) != 0;

executed (the execution status of this line is deduced): BOOL utf = (options & 0x00000800) != 0;

3419

pcre_uchar utf_chars[6];

executed (the execution status of this line is deduced): pcre_uchar utf_chars[6];

3420 #else -

3421 BOOL utf = FALSE; -

3422 #endif -

3423 -

3424 /* Helper variables for OP_XCLASS opcode (for characters > 255). */ -

3425 -

3426 #if defined SUPPORT_UTF || !defined COMPILE_PCRE8 -

3427

BOOL xclass;

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

3428

pcre_uchar *class_uchardata;

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

3429

pcre_uchar *class_uchardata_base;

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

3430 #endif -

3431 -

3432 #ifdef PCRE_DEBUG -

3433 if (lengthptr != NULL) DPRINTF((">> start branch\n")); -

3434 #endif -

3435 -

3436 /* Set up the default and non-default settings for greediness */ -

3437 -

3438

greedy_default = ((options & PCRE_UNGREEDY) != 0);

executed (the execution status of this line is deduced): greedy_default = ((options & 0x00000200) != 0);

3439

greedy_non_default = greedy_default ^ 1;

executed (the execution status of this line is deduced): greedy_non_default = greedy_default ^ 1;

3440 -

3441 /* Initialize no first byte, no required byte. REQ_UNSET means "no char -

3442 matching encountered yet". It gets changed to REQ_NONE if we hit something that -

3443 matches a non-fixed char first char; reqchar just remains unset if we never -

3444 find one. -

3445 -

3446 When we hit a repeat whose minimum is zero, we may have to adjust these values -

3447 to take the zero repeat into account. This is implemented by setting them to -

3448 zerofirstbyte and zeroreqchar when such a repeat is encountered. The individual -

3449 item types that can be repeated set these backoff variables appropriately. */ -

3450 -

3451

firstchar = reqchar = zerofirstchar = zeroreqchar = REQ_UNSET;

executed (the execution status of this line is deduced): firstchar = reqchar = zerofirstchar = zeroreqchar = (-2);

3452 -

3453 /* The variable req_caseopt contains either the REQ_CASELESS value -

3454 or zero, according to the current setting of the caseless flag. The -

3455 REQ_CASELESS leaves the lower 28 bit empty. It is added into the -

3456 firstchar or reqchar variables to record the case status of the -

3457 value. This is used only for ASCII characters. */ -

3458 -

3459

req_caseopt = ((options & PCRE_CASELESS) != 0)? REQ_CASELESS:0;

evaluated: ((options & 0x00000001) != 0)

TRUE	FALSE
yes Evaluation Count:80	yes Evaluation Count:1134

80-1134

3460 -

3461 /* Switch on next character until the end of the branch */ -

3462 -

3463

for (;; ptr++)

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

3464 { -

3465

BOOL negate_class;

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

3466

BOOL should_flip_negation;

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

3467

BOOL possessive_quantifier;

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

3468

BOOL is_quantifier;

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

3469

BOOL is_recurse;

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

3470

BOOL reset_bracount;

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

3471

int class_has_8bitchar;

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

3472

int class_single_char;

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

3473

int newoptions;

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

3474

int recno;

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

3475

int refsign;

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

3476

int skipbytes;

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

3477

int subreqchar;

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

3478

int subfirstchar;

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

3479

int terminator;

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

3480

int mclength;

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

3481

int tempbracount;

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

3482

pcre_uchar mcbuffer[8];

executed (the execution status of this line is deduced): pcre_uchar mcbuffer[8];

3483 -

3484 /* Get next character in the pattern */ -

3485 -

3486

c = *ptr;

executed (the execution status of this line is deduced): c = *ptr;

3487 -

3488 /* If we are at the end of a nested substitution, revert to the outer level -

3489 string. Nesting only happens one level deep. */ -

3490 -

3491

if (c == 0 && nestptr != NULL)

evaluated: c == 0

TRUE	FALSE
yes Evaluation Count:718	yes Evaluation Count:20734

evaluated: nestptr != ((void *)0)

TRUE	FALSE
yes Evaluation Count:4	yes Evaluation Count:714

4-20734

3492 { -

3493

ptr = nestptr;

executed (the execution status of this line is deduced): ptr = nestptr;

3494

nestptr = NULL;

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

3495

c = *ptr;

executed (the execution status of this line is deduced): c = *ptr;

3496

executed: }

Execution Count:4

3497 -

3498 /* If we are in the pre-compile phase, accumulate the length used for the -

3499 previous cycle of this loop. */ -

3500 -

3501

if (code > cd->start_workspace + cd->workspace_size -

evaluated: lengthptr != ((void *)0)

TRUE	FALSE
yes Evaluation Count:10776	yes Evaluation Count:10676

10676-10776

3502 { -

3503 #ifdef PCRE_DEBUG -

3504 if (code > cd->hwm) cd->hwm = code; /* High water info */ -

3505 #endif -

3506

partially evaluated: code > cd->start_workspace + cd->workspace_size - (100)

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

0-10776

3507

WORK_SIZE_SAFETY_MARGIN) /* Check for overrun */

partially evaluated: code > cd->start_workspace + cd->workspace_size - (100)

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

0-10776

3508 { -

3509

*errorcodeptr = ERR52;

never executed (the execution status of this line is deduced): *errorcodeptr = ERR52;

3510

if (code < last_code) code = last_code;

never executed: goto FAILED;

3511 } -

3512 -

3513 /* There is at least one situation where code goes backwards: this is the -

3514 case of a zero quantifier after a class (e.g. [ab]{0}). At compile time, -

3515 the class is simply eliminated. However, it is created first, so we have to -

3516 allow memory for it. Therefore, don't ever reduce the length at this point. -

3517 */ -

3518 -

3519

never executed: code = last_code;

partially evaluated: code < last_code

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

0-10776

3520 -

3521 /* Paranoid check for integer overflow */ -

3522 -

3523

if (OFLOW_MAX - *lengthptr < code - last_code)

partially evaluated: (2147483647 - 20) - *lengthptr < code - last_code

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

0-10776

3524 { -

3525

never executed (the execution status of this line is deduced): *errorcodeptr = ERR20;

3526

*lengthptr += (int)(code - last_code);

never executed: goto FAILED;

3527 } -

3528 -

3529

executed (the execution status of this line is deduced): *lengthptr += (int)(code - last_code);

3530 DPRINTF(("length=%d added %d c=%c (0x%x)\n", *lengthptr, -

3531 (int)(code - last_code), c, c)); -

3532 -

3533 /* If "previous" is set and it is not at the start of the work space, move -

3534 it back to there, in order to avoid filling up the work space. Otherwise, -

3535 if "previous" is NULL, reset the current code pointer to the start. */ -

3536 -

3537

if (previous != NULL)

evaluated: previous != ((void *)0)

TRUE	FALSE
yes Evaluation Count:9713	yes Evaluation Count:1063

1063-9713

3538 { -

3539

if (previous > orig_code)

evaluated: previous > orig_code

TRUE	FALSE
yes Evaluation Count:8962	yes Evaluation Count:751

751-8962

3540 { -

3541

memmove(orig_code, previous, IN_UCHARS(code - previous));

executed (the execution status of this line is deduced): memmove(orig_code, previous, ((code - previous) << 1));

3542

code -= previous - orig_code;

executed (the execution status of this line is deduced): code -= previous - orig_code;

3543

previous = orig_code;

executed (the execution status of this line is deduced): previous = orig_code;

3544

executed: }

Execution Count:8962

8962

3545

executed: }

Execution Count:9713

9713

3546

else code = orig_code;

executed: code = orig_code;

Execution Count:1063

1063

3547 -

3548 /* Remember where this code item starts so we can pick up the length -

3549 next time round. */ -

3550 -

3551

last_code = code;

executed (the execution status of this line is deduced): last_code = code;

3552

else if (cd->hwm > cd->start_workspace + cd->workspace_size -

executed: }

Execution Count:10776

10776

3553 -

3554 /* In the real compile phase, just check the workspace used by the forward -

3555 reference list. */ -

3556 -

3557

partially evaluated: cd->hwm > cd->start_workspace + cd->workspace_size - (100)

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

0-10676

3558

WORK_SIZE_SAFETY_MARGIN)

partially evaluated: cd->hwm > cd->start_workspace + cd->workspace_size - (100)

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

0-10676

3559 { -

3560

*errorcodeptr = ERR52;

never executed (the execution status of this line is deduced): *errorcodeptr = ERR52;

3561

if (c == CHAR_BACKSLASH && ptr[1] == CHAR_E)

never executed: goto FAILED;

3562 } -

3563 -

3564 /* If in \Q...\E, check for the end; if not, we have a literal */ -

3565 -

3566

if (inescq && c != 0)

partially evaluated: inescq

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

never evaluated: c != 0

0-21452

3567 { -

3568

never evaluated: c == '\134'

never evaluated: ptr[1] == '\105'

3569 { -

3570

inescq = FALSE;

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

3571

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

3572

if (previous_callout != NULL)

never executed: continue;

3573 } -

3574 else -

3575 { -

3576

never evaluated: previous_callout != ((void *)0)

3577 { -

3578

if (lengthptr == NULL) /* Don't attempt in pre-compile phase */

never evaluated: lengthptr == ((void *)0)

3579

complete_callout(previous_callout, ptr, cd);

never executed: complete_callout(previous_callout, ptr, cd);

3580

previous_callout = NULL;

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

3581

if ((options & PCRE_AUTO_CALLOUT) != 0)

never executed: }

3582

never evaluated: (options & 0x00004000) != 0

3583 { -

3584

previous_callout = code;

never executed (the execution status of this line is deduced): previous_callout = code;

3585

code = auto_callout(code, ptr, cd);

never executed (the execution status of this line is deduced): code = auto_callout(code, ptr, cd);

never executed: }

never executed: goto NORMAL_CHAR;

3588 } -

3589 } -

3590 -

3591 /* Fill in length of a previous callout, except when the next thing is -

3592 a quantifier. */ -

3593 -

3594

is_quantifier =

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

3595

c == CHAR_ASTERISK || c == CHAR_PLUS || c == CHAR_QUESTION_MARK ||

evaluated: c == '\052'

TRUE	FALSE
yes Evaluation Count:247	yes Evaluation Count:21205

evaluated: c == '\053'

TRUE	FALSE
yes Evaluation Count:120	yes Evaluation Count:21085

evaluated: c == '\077'

TRUE	FALSE
yes Evaluation Count:100	yes Evaluation Count:20985

100-21205

3596

(c == CHAR_LEFT_CURLY_BRACKET && is_counted_repeat(ptr+1));

evaluated: c == '\173'

TRUE	FALSE
yes Evaluation Count:26	yes Evaluation Count:20959

evaluated: is_counted_repeat(ptr+1)

TRUE	FALSE
yes Evaluation Count:24	yes Evaluation Count:2

2-20959

3597 -

3598

if (!is_quantifier && previous_callout != NULL &&

evaluated: !is_quantifier

TRUE	FALSE
yes Evaluation Count:20961	yes Evaluation Count:491

partially evaluated: previous_callout != ((void *)0)

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

0-20961

3599

after_manual_callout-- <= 0)

never evaluated: after_manual_callout-- <= 0

3600 { -

3601

if (lengthptr == NULL) /* Don't attempt in pre-compile phase */

never evaluated: lengthptr == ((void *)0)

3602

complete_callout(previous_callout, ptr, cd);

never executed: complete_callout(previous_callout, ptr, cd);

3603

previous_callout = NULL;

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

3604

if ((options & PCRE_EXTENDED) != 0)

never executed: }

3605 -

3606 /* In extended mode, skip white space and comments. */ -

3607 -

3608

evaluated: (options & 0x00000008) != 0

TRUE	FALSE
yes Evaluation Count:22	yes Evaluation Count:21430

22-21430

3609 { -

3610

if (MAX_255(*ptr) && (cd->ctypes[c] & ctype_space) != 0) continue;

executed: continue;

Execution Count:6

partially evaluated: ((*ptr) <= 255u)

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

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

TRUE	FALSE
yes Evaluation Count:6	yes Evaluation Count:16

0-22

3611

if (c == CHAR_NUMBER_SIGN)

evaluated: c == '\043'

TRUE	FALSE
yes Evaluation Count:6	yes Evaluation Count:10

6-10

3612 { -

3613

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

3614

if (IS_NEWLINE(ptr)) { ptr += cd->nllen - 1; break; }

evaluated: *ptr != 0

TRUE	FALSE
yes Evaluation Count:60	yes Evaluation Count:2

2-60

3615 { -

3616

executed: break;

Execution Count:4

partially evaluated: (cd->nltype != 0)

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

0-60

3617

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

3618 #ifdef SUPPORT_UTF -

3619

never executed: ptr++;

partially evaluated: utf

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

partially evaluated: (*ptr & 0xfc00) == 0xdc00

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

0-56

3620 #endif -

3621

executed: }

Execution Count:56

3622

if (*ptr != 0) continue;

executed: continue;

Execution Count:4

evaluated: *ptr != 0

TRUE	FALSE
yes Evaluation Count:4	yes Evaluation Count:2

2-4

3623 -

3624 /* Else fall through to handle end of string */ -

3625

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

3626

executed: }

Execution Count:2

3627

if ((options & PCRE_AUTO_CALLOUT) != 0 && !is_quantifier)

executed: }

Execution Count:12

3628 -

3629 /* No auto callout for quantifiers. */ -

3630 -

3631

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

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

never evaluated: !is_quantifier

0-21442

3632 { -

3633

previous_callout = code;

never executed (the execution status of this line is deduced): previous_callout = code;

3634

code = auto_callout(code, ptr, cd);

never executed (the execution status of this line is deduced): code = auto_callout(code, ptr, cd);

3635

*firstcharptr = firstchar;

never executed: }

3636 -

3637 switch(c) -

3638 { -

3639 /* ===================================================================*/ -

3640 case 0: /* The branch terminates at string end */ -

3641 case CHAR_VERTICAL_LINE: /* or | or ) */ -

3642 case CHAR_RIGHT_PARENTHESIS: -

3643

executed (the execution status of this line is deduced): *firstcharptr = firstchar;

3644

*reqcharptr = reqchar;

executed (the execution status of this line is deduced): *reqcharptr = reqchar;

3645

*codeptr = code;

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

3646

executed (the execution status of this line is deduced): *ptrptr = ptr;

3647

if (OFLOW_MAX - *lengthptr < code - last_code)

evaluated: lengthptr != ((void *)0)

TRUE	FALSE
yes Evaluation Count:603	yes Evaluation Count:600

600-603

3648 { -

3649

partially evaluated: (2147483647 - 20) - *lengthptr < code - last_code

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

0-603

3650 { -

3651

never executed (the execution status of this line is deduced): *errorcodeptr = ERR20;

3652

*lengthptr += (int)(code - last_code); /* To include callout length */

never executed: goto FAILED;

3653 } -

3654

executed (the execution status of this line is deduced): *lengthptr += (int)(code - last_code);

3655 DPRINTF((">> end branch\n")); -

3656

executed: }

Execution Count:603

603

3657

executed: return 1;

Execution Count:1203

1203

3658 -

3659 -

3660 /* ===================================================================*/ -

3661 /* Handle single-character metacharacters. In multiline mode, ^ disables -

3662 the setting of any following char as a first character. */ -

3663 -

3664 case CHAR_CIRCUMFLEX_ACCENT: -

3665

if ((options & PCRE_MULTILINE) != 0)

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

3666

evaluated: (options & 0x00000002) != 0

TRUE	FALSE
yes Evaluation Count:4	yes Evaluation Count:40

4-40

3667 { -

3668

executed: firstchar = (-1);

Execution Count:4

partially evaluated: firstchar == (-2)

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

0-4

3669

*code++ = OP_CIRCM;

executed (the execution status of this line is deduced): *code++ = OP_CIRCM;

3670

executed: }

Execution Count:4

3671

else *code++ = OP_CIRC;

executed: *code++ = OP_CIRC;

Execution Count:40

3672

executed: break;

Execution Count:44

3673 -

3674 case CHAR_DOLLAR_SIGN: -

3675

*code++ = ((options & PCRE_MULTILINE) != 0)? OP_DOLLM : OP_DOLL;

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

3676

evaluated: ((options & 0x00000002) != 0)

TRUE	FALSE
yes Evaluation Count:2	yes Evaluation Count:16

2-16

3677

executed: break;

Execution Count:18

3678 -

3679 /* There can never be a first char if '.' is first, whatever happens about -

3680 repeats. The value of reqchar doesn't change either. */ -

3681 -

3682 case CHAR_DOT: -

3683

executed: firstchar = (-1);

Execution Count:83

evaluated: firstchar == (-2)

TRUE	FALSE
yes Evaluation Count:83	yes Evaluation Count:152

83-152

3684

executed (the execution status of this line is deduced): zerofirstchar = firstchar;

3685

executed (the execution status of this line is deduced): zeroreqchar = reqchar;

3686

*code++ = ((options & PCRE_DOTALL) != 0)? OP_ALLANY: OP_ANY;

executed (the execution status of this line is deduced): previous = code;

3687

evaluated: ((options & 0x00000004) != 0)

TRUE	FALSE
yes Evaluation Count:114	yes Evaluation Count:121

114-121

3688

if ((cd->external_options & PCRE_JAVASCRIPT_COMPAT) != 0)

executed: break;

Execution Count:235

235

3689 -

3690 -

3691 /* ===================================================================*/ -

3692 /* Character classes. If the included characters are all < 256, we build a -

3693 32-byte bitmap of the permitted characters, except in the special case -

3694 where there is only one such character. For negated classes, we build the -

3695 map as usual, then invert it at the end. However, we use a different opcode -

3696 so that data characters > 255 can be handled correctly. -

3697 -

3698 If the class contains characters outside the 0-255 range, a different -

3699 opcode is compiled. It may optionally have a bit map for characters < 256, -

3700 but those above are are explicitly listed afterwards. A flag byte tells -

3701 whether the bitmap is present, and whether this is a negated class or not. -

3702 -

3703 In JavaScript compatibility mode, an isolated ']' causes an error. In -

3704 default (Perl) mode, it is treated as a data character. */ -

3705 -

3706 case CHAR_RIGHT_SQUARE_BRACKET: -

3707

never evaluated: (cd->external_options & 0x02000000) != 0

3708 { -

3709

*errorcodeptr = ERR64;

never executed (the execution status of this line is deduced): *errorcodeptr = ERR64;

3710

never executed: goto FAILED;

3711 } -

3712

goto NORMAL_CHAR;

never executed: goto NORMAL_CHAR;

3713 -

3714 case CHAR_LEFT_SQUARE_BRACKET: -

3715

if ((ptr[1] == CHAR_COLON || ptr[1] == CHAR_DOT ||

executed (the execution status of this line is deduced): previous = code;

3716 -

3717 /* PCRE supports POSIX class stuff inside a class. Perl gives an error if -

3718 they are encountered at the top level, so we'll do that too. */ -

3719 -

3720

partially evaluated: ptr[1] == '\072'

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

partially evaluated: ptr[1] == '\056'

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

0-58

3721

ptr[1] == CHAR_EQUALS_SIGN) &&

partially evaluated: ptr[1] == '\075'

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

0-58

3722

check_posix_syntax(ptr, &tempptr))

never evaluated: check_posix_syntax(ptr, &tempptr)

3723 { -

3724

*errorcodeptr = (ptr[1] == CHAR_COLON)? ERR13 : ERR31;

never evaluated: (ptr[1] == '\072')

3725

never executed: goto FAILED;

3726 } -

3727 -

3728 /* If the first character is '^', set the negation flag and skip it. Also, -

3729 if the first few characters (either before or after ^) are \Q\E or \E we -

3730 skip them too. This makes for compatibility with Perl. */ -

3731 -

3732

negate_class = FALSE;

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

3733

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

3734 { -

3735

executed (the execution status of this line is deduced): c = *(++ptr);

3736

if (c == CHAR_BACKSLASH)

evaluated: c == '\134'

TRUE	FALSE
yes Evaluation Count:4	yes Evaluation Count:56

4-56

3737 { -

3738

if (ptr[1] == CHAR_E)

partially evaluated: ptr[1] == '\105'

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

0-4

3739

else if (STRNCMP_UC_C8(ptr + 1, STR_Q STR_BACKSLASH STR_E, 3) == 0)

never executed: ptr++;

3740

partially evaluated: _pcre16_strncmp_uc_c8((ptr + 1), ("\121" "\134" "\105"), (3)) == 0

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

0-4

3741

ptr += 3;

never executed: ptr += 3;

3742 else -

3743

else if (!negate_class && c == CHAR_CIRCUMFLEX_ACCENT)

executed: break;

Execution Count:4

3744 } -

3745

evaluated: !negate_class

TRUE	FALSE
yes Evaluation Count:54	yes Evaluation Count:2

evaluated: c == '\136'

TRUE	FALSE
yes Evaluation Count:2	yes Evaluation Count:52

2-54

3746

negate_class = TRUE;

executed: negate_class = 1;

Execution Count:2

3747

if (c == CHAR_RIGHT_SQUARE_BRACKET &&

executed: break;

Execution Count:54

3748 } -

3749 -

3750 /* Empty classes are allowed in JavaScript compatibility mode. Otherwise, -

3751 an initial ']' is taken as a data character -- the code below handles -

3752 that. In JS mode, [] must always fail, so generate OP_FAIL, whereas -

3753 [^] must match any character, so generate OP_ALLANY. */ -

3754 -

3755

partially evaluated: c == '\135'

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

0-58

3756

(cd->external_options & PCRE_JAVASCRIPT_COMPAT) != 0)

never evaluated: (cd->external_options & 0x02000000) != 0

3757 { -

3758

*code++ = negate_class? OP_ALLANY : OP_FAIL;

never evaluated: negate_class

3759

never executed: firstchar = (-1);

never evaluated: firstchar == (-2)

3760

never executed (the execution status of this line is deduced): zerofirstchar = firstchar;

3761

should_flip_negation = FALSE;

never executed: break;

3762 } -

3763 -

3764 /* If a class contains a negative special such as \S, we need to flip the -

3765 negation flag at the end, so that support for characters > 255 works -

3766 correctly (they are all included in the class). */ -

3767 -

3768

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

3769 -

3770 /* For optimization purposes, we track some properties of the class. -

3771 class_has_8bitchar will be non-zero, if the class contains at least one -

3772 < 256 character. class_single_char will be 1 if the class contains only -

3773 a single character. */ -

3774 -

3775

class_has_8bitchar = 0;

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

3776

class_single_char = 0;

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

3777 -

3778 /* Initialize the 32-char bit map to all zeros. We build the map in a -

3779 temporary bit of memory, in case the class contains only 1 character (less -

3780 than 256), because in that case the compiled code doesn't use the bit map. -

3781 */ -

3782 -

3783

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

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

3784 -

3785 #if defined SUPPORT_UTF || !defined COMPILE_PCRE8 -

3786

xclass = FALSE; /* No chars >= 256 */

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

3787

class_uchardata = code + LINK_SIZE + 2; /* For UTF-8 items */

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

3788

class_uchardata_base = class_uchardata; /* For resetting in pass 1 */

executed (the execution status of this line is deduced): class_uchardata_base = class_uchardata;

3789 #endif -

3790 -

3791 /* Process characters until ] is reached. By writing this as a "do" it -

3792 means that an initial ] is taken as a data character. At the start of the -

3793 loop, c contains the first byte of the character. */ -

3794 -

3795

if (c != 0) do

partially evaluated: c != 0

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

0-58

3796 { -

3797

const pcre_uchar *oldptr;

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

3798 -

3799 #ifdef SUPPORT_UTF -

3800

if (utf && HAS_EXTRALEN(c))

partially evaluated: utf

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

partially evaluated: (((c) & 0xfc00) == 0xd800)

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

0-112

3801 { /* Braces are required because the */ -

3802

GETCHARLEN(c, ptr, ptr); /* macro generates multiple statements */

never executed: }

never evaluated: (c & 0xfc00) == 0xd800

3803

never executed: }

3804 #endif -

3805 -

3806 #if defined SUPPORT_UTF || !defined COMPILE_PCRE8 -

3807 /* In the pre-compile phase, accumulate the length of any extra -

3808 data and reset the pointer. This is so that very large classes that -

3809 contain a zillion > 255 characters no longer overwrite the work space -

3810 (which is on the stack). */ -

3811 -

3812

*lengthptr += class_uchardata - class_uchardata_base;

evaluated: lengthptr != ((void *)0)

TRUE	FALSE
yes Evaluation Count:56	yes Evaluation Count:56

3813 { -

3814

executed (the execution status of this line is deduced): *lengthptr += class_uchardata - class_uchardata_base;

3815

class_uchardata = class_uchardata_base;

executed (the execution status of this line is deduced): class_uchardata = class_uchardata_base;

3816

if (c == CHAR_BACKSLASH && ptr[1] == CHAR_E) /* If we are at \E */

executed: }

Execution Count:56

3817 #endif -

3818 -

3819 /* Inside \Q...\E everything is literal except \E */ -

3820 -

3821

if (inescq)

partially evaluated: inescq

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

0-112

3822 { -

3823

never evaluated: c == '\134'

never evaluated: ptr[1] == '\105'

3824 { -

3825

inescq = FALSE; /* Reset literal state */

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

3826

ptr++; /* Skip the 'E' */

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

3827

continue; /* Carry on with next */

never executed: continue;

3828 } -

3829

goto CHECK_RANGE; /* Could be range if \E follows */

never executed: goto CHECK_RANGE;

3830 } -

3831 -

3832 /* Handle POSIX class names. Perl allows a negation extension of the -

3833 form [:^name:]. A square bracket that doesn't match the syntax is -

3834 treated as a literal. We also recognize the POSIX constructions -

3835 [.ch.] and [=ch=] ("collating elements") and fault them, as Perl -

3836 5.6 and 5.8 do. */ -

3837 -

3838

if (c == CHAR_LEFT_SQUARE_BRACKET &&

partially evaluated: c == '\133'

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

0-112

3839

(ptr[1] == CHAR_COLON || ptr[1] == CHAR_DOT ||

never evaluated: ptr[1] == '\072'

never evaluated: ptr[1] == '\056'

3840

ptr[1] == CHAR_EQUALS_SIGN) && check_posix_syntax(ptr, &tempptr))

never evaluated: ptr[1] == '\075'

never evaluated: check_posix_syntax(ptr, &tempptr)

3841 { -

3842

BOOL local_negate = FALSE;

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

3843

int posix_class, taboffset, tabopt;

never executed (the execution status of this line is deduced): int posix_class, taboffset, tabopt;

3844

never executed (the execution status of this line is deduced): register const pcre_uint8 *cbits = cd->cbits;

3845

pcre_uint8 pbits[32];

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

3846 -

3847

if (ptr[1] != CHAR_COLON)

never evaluated: ptr[1] != '\072'

3848 { -

3849

*errorcodeptr = ERR31;

never executed (the execution status of this line is deduced): *errorcodeptr = ERR31;

3850

never executed: goto FAILED;

3851 } -

3852 -

3853

if (*ptr == CHAR_CIRCUMFLEX_ACCENT)

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

3854

never evaluated: *ptr == '\136'

3855 { -

3856

local_negate = TRUE;

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

3857

should_flip_negation = TRUE; /* Note negative special */

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

3858

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

3859

posix_class = check_posix_name(ptr, (int)(tempptr - ptr));

never executed: }

3860 -

3861

never executed (the execution status of this line is deduced): posix_class = check_posix_name(ptr, (int)(tempptr - ptr));

3862

if (posix_class < 0)

never evaluated: posix_class < 0

3863 { -

3864

*errorcodeptr = ERR30;

never executed (the execution status of this line is deduced): *errorcodeptr = ERR30;

3865

if ((options & PCRE_CASELESS) != 0 && posix_class <= 2)

never executed: goto FAILED;

3866 } -

3867 -

3868 /* If matching is caseless, upper and lower are converted to -

3869 alpha. This relies on the fact that the class table starts with -

3870 alpha, lower, upper as the first 3 entries. */ -

3871 -

3872

never evaluated: (options & 0x00000001) != 0

never evaluated: posix_class <= 2

3873

posix_class = 0;

never executed: posix_class = 0;

3874 -

3875 /* When PCRE_UCP is set, some of the POSIX classes are converted to -

3876 different escape sequences that use Unicode properties. */ -

3877 -

3878 #ifdef SUPPORT_UCP -

3879

if ((options & PCRE_UCP) != 0)

never evaluated: (options & 0x20000000) != 0

3880 { -

3881

int pc = posix_class + ((local_negate)? POSIX_SUBSIZE/2 : 0);

never evaluated: (local_negate)

3882

if (posix_substitutes[pc] != NULL)

never evaluated: posix_substitutes[pc] != ((void *)0)

3883 { -

3884

nestptr = tempptr + 1;

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

3885

ptr = posix_substitutes[pc] - 1;

never executed (the execution status of this line is deduced): ptr = posix_substitutes[pc] - 1;

3886

never executed: continue;

3887 } -

3888

memcpy(pbits, cbits + posix_class_maps[posix_class],

never executed: }

3889 #endif -

3890 /* In the non-UCP case, we build the bit map for the POSIX class in a -

3891 chunk of local store because we may be adding and subtracting from it, -

3892 and we don't want to subtract bits that may be in the main map already. -

3893 At the end we or the result into the bit map that is being built. */ -

3894 -

3895

posix_class *= 3;

never executed (the execution status of this line is deduced): posix_class *= 3;

3896 -

3897 /* Copy in the first table (always present) */ -

3898 -

3899

never executed (the execution status of this line is deduced): memcpy(pbits, cbits + posix_class_maps[posix_class],

3900

32 * sizeof(pcre_uint8));

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

3901 -

3902 /* If there is a second table, add or remove it as required. */ -

3903 -

3904

taboffset = posix_class_maps[posix_class + 1];

never executed (the execution status of this line is deduced): taboffset = posix_class_maps[posix_class + 1];

3905

tabopt = posix_class_maps[posix_class + 2];

never executed (the execution status of this line is deduced): tabopt = posix_class_maps[posix_class + 2];

3906 -

3907

if (taboffset >= 0)

never evaluated: taboffset >= 0

3908 { -

3909

if (tabopt >= 0)

never evaluated: tabopt >= 0

3910

for (c = 0; c < 32; c++) pbits[c] |= cbits[c + taboffset];

never executed: pbits[c] |= cbits[c + taboffset];

never evaluated: c < 32

3911 else -

3912

for (c = 0; c < 32; c++) pbits[c] &= ~cbits[c + taboffset];

never executed: pbits[c] &= ~cbits[c + taboffset];

never evaluated: c < 32

3913 } -

3914 -

3915 /* Not see if we need to remove any special characters. An option -

3916 value of 1 removes vertical space and 2 removes underscore. */ -

3917 -

3918

if (tabopt < 0) tabopt = -tabopt;

never executed: tabopt = -tabopt;

never evaluated: tabopt < 0

3919

if (tabopt == 1) pbits[1] &= ~0x3c;

never executed: pbits[1] &= ~0x3c;

never evaluated: tabopt == 1

3920

else if (tabopt == 2) pbits[11] &= 0x7f;

never executed: pbits[11] &= 0x7f;

never evaluated: tabopt == 2

3921 -

3922 /* Add the POSIX table or its complement into the main table that is -

3923 being built and we are done. */ -

3924 -

3925

if (local_negate)

never evaluated: local_negate

3926

for (c = 0; c < 32; c++) classbits[c] |= ~pbits[c];

never executed: classbits[c] |= ~pbits[c];

never evaluated: c < 32

3927 else -

3928

for (c = 0; c < 32; c++) classbits[c] |= pbits[c];

never executed: classbits[c] |= pbits[c];

never evaluated: c < 32

3929 -

3930

ptr = tempptr + 1;

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

3931 /* Every class contains at least one < 256 characters. */ -

3932

class_has_8bitchar = 1;

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

3933 /* Every class contains at least two characters. */ -

3934

class_single_char = 2;

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

3935

continue; /* End of POSIX syntax handling */

never executed: continue;

3936 } -

3937 -

3938 /* Backslash may introduce a single character, or it may introduce one -

3939 of the specials, which just set a flag. The sequence \b is a special -

3940 case. Inside a class (and only there) it is treated as backspace. We -

3941 assume that other escapes have more than one character in them, so -

3942 speculatively set both class_has_8bitchar and class_single_char bigger -

3943 than one. Unrecognized escapes fall through and are either treated -

3944 as literal characters (by default), or are faulted if -

3945 PCRE_EXTRA is set. */ -

3946 -

3947

if (c == CHAR_BACKSLASH)

evaluated: c == '\134'

TRUE	FALSE
yes Evaluation Count:4	yes Evaluation Count:108

4-108

3948 { -

3949

c = check_escape(&ptr, errorcodeptr, cd->bracount, options, TRUE);

executed (the execution status of this line is deduced): c = check_escape(&ptr, errorcodeptr, cd->bracount, options, 1);

3950

if (-c == ESC_b) c = CHAR_BS; /* \b is backspace in a class */

never executed: goto FAILED;

partially evaluated: *errorcodeptr != 0

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

0-4

3951 -

3952

never executed: c = '\010';

partially evaluated: -c == ESC_b

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

0-4

3953

else if (-c == ESC_N) /* \N is not supported in a class */

partially evaluated: -c == ESC_N

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

0-4

3954 { -

3955

*errorcodeptr = ERR71;

never executed (the execution status of this line is deduced): *errorcodeptr = ERR71;

3956

else if (-c == ESC_Q) /* Handle start of quoted string */

never executed: goto FAILED;

3957 } -

3958

partially evaluated: -c == ESC_Q

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

0-4

3959 { -

3960

if (ptr[1] == CHAR_BACKSLASH && ptr[2] == CHAR_E)

never evaluated: ptr[1] == '\134'

never evaluated: ptr[2] == '\105'

3961 { -

3962

ptr += 2; /* avoid empty string */

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

never executed: }

never executed: inescq = 1;

3965

else if (-c == ESC_E) continue; /* Ignore orphan \E */

never executed: continue;

3966 } -

3967

never executed: continue;

partially evaluated: -c == ESC_E

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

0-4

3968 -

3969

if (c < 0)

partially evaluated: c < 0

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

0-4

3970 { -

3971

never executed (the execution status of this line is deduced): register const pcre_uint8 *cbits = cd->cbits;

3972 /* Every class contains at least two < 256 characters. */ -

3973

class_has_8bitchar++;

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

3974 /* Every class contains at least two characters. */ -

3975

class_single_char += 2;

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

3976 -

3977 switch (-c) -

3978 { -

3979 #ifdef SUPPORT_UCP -

3980 case ESC_du: /* These are the values given for \d etc */ -

3981 case ESC_DU: /* when PCRE_UCP is set. We replace the */ -

3982 case ESC_wu: /* escape sequence with an appropriate \p */ -

3983 case ESC_WU: /* or \P to test Unicode properties instead */ -

3984 case ESC_su: /* of the default ASCII testing. */ -

3985 case ESC_SU: -

3986

nestptr = ptr;

never executed (the execution status of this line is deduced): nestptr = ptr;

3987

ptr = substitutes[-c - ESC_DU] - 1; /* Just before substitute */

never executed (the execution status of this line is deduced): ptr = substitutes[-c - ESC_DU] - 1;

3988

class_has_8bitchar--; /* Undo! */

never executed (the execution status of this line is deduced): class_has_8bitchar--;

3989

for (c = 0; c < 32; c++) classbits[c] |= cbits[c+cbit_digit];

never executed: continue;

3990 #endif -

3991 case ESC_d: -

3992

never executed: classbits[c] |= cbits[c+64];

never evaluated: c < 32

3993

should_flip_negation = TRUE;

never executed: continue;

3994 -

3995 case ESC_D: -

3996

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

3997

for (c = 0; c < 32; c++) classbits[c] |= ~cbits[c+cbit_digit];

never executed: classbits[c] |= ~cbits[c+64];

never evaluated: c < 32

3998

for (c = 0; c < 32; c++) classbits[c] |= cbits[c+cbit_word];

never executed: continue;

3999 -

4000 case ESC_w: -

4001

never executed: classbits[c] |= cbits[c+160];

never evaluated: c < 32

4002

should_flip_negation = TRUE;

never executed: continue;

4003 -

4004 case ESC_W: -

4005

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

4006

for (c = 0; c < 32; c++) classbits[c] |= ~cbits[c+cbit_word];

never executed: classbits[c] |= ~cbits[c+160];

never evaluated: c < 32

4007

classbits[0] |= cbits[cbit_space];

never executed: continue;

4008 -

4009 /* Perl 5.004 onwards omits VT from \s, but we must preserve it -

4010 if it was previously set by something earlier in the character -

4011 class. */ -

4012 -

4013 case ESC_s: -

4014

never executed (the execution status of this line is deduced): classbits[0] |= cbits[0];

4015

classbits[1] |= cbits[cbit_space+1] & ~0x08;

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

4016

for (c = 2; c < 32; c++) classbits[c] |= cbits[c+cbit_space];

never executed: classbits[c] |= cbits[c+0];

never evaluated: c < 32

4017

should_flip_negation = TRUE;

never executed: continue;

4018 -

4019 case ESC_S: -

4020

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

4021

for (c = 0; c < 32; c++) classbits[c] |= ~cbits[c+cbit_space];

never executed: classbits[c] |= ~cbits[c+0];

never evaluated: c < 32

4022

classbits[1] |= 0x08; /* Perl 5.004 onwards omits VT from \s */

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

4023

SETBIT(classbits, 0x09); /* VT */

never executed: continue;

4024 -

4025 case ESC_h: -

4026

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

4027

SETBIT(classbits, 0x20); /* SPACE */

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

4028

SETBIT(classbits, 0xa0); /* NSBP */

never executed (the execution status of this line is deduced): classbits[0xa0/8] |= (1 << (0xa0%8));

4029 #ifndef COMPILE_PCRE8 -

4030

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

4031

*class_uchardata++ = 0x1680;

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

4032

never executed (the execution status of this line is deduced): *class_uchardata++ = 0x1680;

4033

*class_uchardata++ = 0x180e;

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

4034

never executed (the execution status of this line is deduced): *class_uchardata++ = 0x180e;

4035

*class_uchardata++ = 0x2000;

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

4036

never executed (the execution status of this line is deduced): *class_uchardata++ = 0x2000;

4037

*class_uchardata++ = 0x200a;

never executed (the execution status of this line is deduced): *class_uchardata++ = 0x200a;

4038

*class_uchardata++ = 0x202f;

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

4039

never executed (the execution status of this line is deduced): *class_uchardata++ = 0x202f;

4040

*class_uchardata++ = 0x205f;

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

4041

never executed (the execution status of this line is deduced): *class_uchardata++ = 0x205f;

4042

*class_uchardata++ = 0x3000;

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

4043

never executed (the execution status of this line is deduced): *class_uchardata++ = 0x3000;

4044 #elif defined SUPPORT_UTF -

4045 if (utf) -

4046 { -

4047 xclass = TRUE; -

4048 *class_uchardata++ = XCL_SINGLE; -

4049 class_uchardata += PRIV(ord2utf)(0x1680, class_uchardata); -

4050 *class_uchardata++ = XCL_SINGLE; -

4051 class_uchardata += PRIV(ord2utf)(0x180e, class_uchardata); -

4052 *class_uchardata++ = XCL_RANGE; -

4053 class_uchardata += PRIV(ord2utf)(0x2000, class_uchardata); -

4054 class_uchardata += PRIV(ord2utf)(0x200a, class_uchardata); -

4055 *class_uchardata++ = XCL_SINGLE; -

4056 class_uchardata += PRIV(ord2utf)(0x202f, class_uchardata); -

4057 *class_uchardata++ = XCL_SINGLE; -

4058 class_uchardata += PRIV(ord2utf)(0x205f, class_uchardata); -

4059 *class_uchardata++ = XCL_SINGLE; -

4060 class_uchardata += PRIV(ord2utf)(0x3000, class_uchardata); -

4061 } -

4062 #endif -

4063

case 0x09/8: x ^= 1 << (0x09%8); break;

never executed: continue;

4064 -

4065 case ESC_H: -

4066

for (c = 0; c < 32; c++)

never evaluated: c < 32

4067 { -

4068

int x = 0xff;

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

4069 switch (c) -

4070 { -

4071

never executed: break;

4072

case 0x20/8: x ^= 1 << (0x20%8); break;

never executed: break;

4073

case 0xa0/8: x ^= 1 << (0xa0%8); break;

never executed: break;

4074

default: break;

never executed: break;

4075 } -

4076

classbits[c] |= x;

never executed (the execution status of this line is deduced): classbits[c] |= x;

4077

never executed: }

4078 #ifndef COMPILE_PCRE8 -

4079

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

4080

*class_uchardata++ = 0x0100;

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

4081

never executed (the execution status of this line is deduced): *class_uchardata++ = 0x0100;

4082

*class_uchardata++ = 0x167f;

never executed (the execution status of this line is deduced): *class_uchardata++ = 0x167f;

4083

*class_uchardata++ = 0x1681;

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

4084

never executed (the execution status of this line is deduced): *class_uchardata++ = 0x1681;

4085

*class_uchardata++ = 0x180d;

never executed (the execution status of this line is deduced): *class_uchardata++ = 0x180d;

4086

*class_uchardata++ = 0x180f;

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

4087

never executed (the execution status of this line is deduced): *class_uchardata++ = 0x180f;

4088

*class_uchardata++ = 0x1fff;

never executed (the execution status of this line is deduced): *class_uchardata++ = 0x1fff;

4089

*class_uchardata++ = 0x200b;

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

4090

never executed (the execution status of this line is deduced): *class_uchardata++ = 0x200b;

4091

*class_uchardata++ = 0x202e;

never executed (the execution status of this line is deduced): *class_uchardata++ = 0x202e;

4092

*class_uchardata++ = 0x2030;

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

4093

never executed (the execution status of this line is deduced): *class_uchardata++ = 0x2030;

4094

*class_uchardata++ = 0x205e;

never executed (the execution status of this line is deduced): *class_uchardata++ = 0x205e;

4095

*class_uchardata++ = 0x2060;

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

4096

never executed (the execution status of this line is deduced): *class_uchardata++ = 0x2060;

4097

*class_uchardata++ = 0x2fff;

never executed (the execution status of this line is deduced): *class_uchardata++ = 0x2fff;

4098

*class_uchardata++ = 0x3001;

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

4099

never executed (the execution status of this line is deduced): *class_uchardata++ = 0x3001;

4100 #ifdef SUPPORT_UTF -

4101

class_uchardata += PRIV(ord2utf)(0x10ffff, class_uchardata);

never evaluated: utf

4102

never executed: class_uchardata += _pcre16_ord2utf(0x10ffff, class_uchardata);

4103 else -

4104 #endif -

4105

*class_uchardata++ = 0xffff;

never executed: *class_uchardata++ = 0xffff;

4106 #elif defined SUPPORT_UTF -

4107 if (utf) -

4108 { -

4109 xclass = TRUE; -

4110 *class_uchardata++ = XCL_RANGE; -

4111 class_uchardata += PRIV(ord2utf)(0x0100, class_uchardata); -

4112 class_uchardata += PRIV(ord2utf)(0x167f, class_uchardata); -

4113 *class_uchardata++ = XCL_RANGE; -

4114 class_uchardata += PRIV(ord2utf)(0x1681, class_uchardata); -

4115 class_uchardata += PRIV(ord2utf)(0x180d, class_uchardata); -

4116 *class_uchardata++ = XCL_RANGE; -

4117 class_uchardata += PRIV(ord2utf)(0x180f, class_uchardata); -

4118 class_uchardata += PRIV(ord2utf)(0x1fff, class_uchardata); -

4119 *class_uchardata++ = XCL_RANGE; -

4120 class_uchardata += PRIV(ord2utf)(0x200b, class_uchardata); -

4121 class_uchardata += PRIV(ord2utf)(0x202e, class_uchardata); -

4122 *class_uchardata++ = XCL_RANGE; -

4123 class_uchardata += PRIV(ord2utf)(0x2030, class_uchardata); -

4124 class_uchardata += PRIV(ord2utf)(0x205e, class_uchardata); -

4125 *class_uchardata++ = XCL_RANGE; -

4126 class_uchardata += PRIV(ord2utf)(0x2060, class_uchardata); -

4127 class_uchardata += PRIV(ord2utf)(0x2fff, class_uchardata); -

4128 *class_uchardata++ = XCL_RANGE; -

4129 class_uchardata += PRIV(ord2utf)(0x3001, class_uchardata); -

4130 class_uchardata += PRIV(ord2utf)(0x10ffff, class_uchardata); -

4131 } -

4132 #endif -

4133

SETBIT(classbits, 0x0a); /* LF */

never executed: continue;

4134 -

4135 case ESC_v: -

4136

never executed (the execution status of this line is deduced): classbits[0x0a/8] |= (1 << (0x0a%8));

4137

SETBIT(classbits, 0x0b); /* VT */

never executed (the execution status of this line is deduced): classbits[0x0b/8] |= (1 << (0x0b%8));

4138

SETBIT(classbits, 0x0c); /* FF */

never executed (the execution status of this line is deduced): classbits[0x0c/8] |= (1 << (0x0c%8));

4139

SETBIT(classbits, 0x0d); /* CR */

never executed (the execution status of this line is deduced): classbits[0x0d/8] |= (1 << (0x0d%8));

4140

SETBIT(classbits, 0x85); /* NEL */

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

4141 #ifndef COMPILE_PCRE8 -

4142

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

4143

*class_uchardata++ = 0x2028;

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

4144

never executed (the execution status of this line is deduced): *class_uchardata++ = 0x2028;

4145

*class_uchardata++ = 0x2029;

never executed (the execution status of this line is deduced): *class_uchardata++ = 0x2029;

4146 #elif defined SUPPORT_UTF -

4147 if (utf) -

4148 { -

4149 xclass = TRUE; -

4150 *class_uchardata++ = XCL_RANGE; -

4151 class_uchardata += PRIV(ord2utf)(0x2028, class_uchardata); -

4152 class_uchardata += PRIV(ord2utf)(0x2029, class_uchardata); -

4153 } -

4154 #endif -

4155

case 0x0a/8: x ^= 1 << (0x0a%8);

never executed: continue;

4156 -

4157 case ESC_V: -

4158

for (c = 0; c < 32; c++)

never evaluated: c < 32

4159 { -

4160

int x = 0xff;

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

4161 switch (c) -

4162 { -

4163

never executed (the execution status of this line is deduced): case 0x0a/8: x ^= 1 << (0x0a%8);

4164

x ^= 1 << (0x0b%8);

never executed (the execution status of this line is deduced): x ^= 1 << (0x0b%8);

4165

x ^= 1 << (0x0c%8);

never executed (the execution status of this line is deduced): x ^= 1 << (0x0c%8);

4166

x ^= 1 << (0x0d%8);

never executed (the execution status of this line is deduced): x ^= 1 << (0x0d%8);

4167

case 0x85/8: x ^= 1 << (0x85%8); break;

never executed: break;

4168

never executed: break;

4169

default: break;

never executed: break;

4170 } -

4171

classbits[c] |= x;

never executed (the execution status of this line is deduced): classbits[c] |= x;

4172

never executed: }

4173 -

4174 #ifndef COMPILE_PCRE8 -

4175

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

4176

*class_uchardata++ = 0x0100;

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

4177

never executed (the execution status of this line is deduced): *class_uchardata++ = 0x0100;

4178

*class_uchardata++ = 0x2027;

never executed (the execution status of this line is deduced): *class_uchardata++ = 0x2027;

4179

*class_uchardata++ = 0x202a;

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

4180

never executed (the execution status of this line is deduced): *class_uchardata++ = 0x202a;

4181 #ifdef SUPPORT_UTF -

4182

class_uchardata += PRIV(ord2utf)(0x10ffff, class_uchardata);

never evaluated: utf

4183

never executed: class_uchardata += _pcre16_ord2utf(0x10ffff, class_uchardata);

4184 else -

4185 #endif -

4186

*class_uchardata++ = 0xffff;

never executed: *class_uchardata++ = 0xffff;

4187 #elif defined SUPPORT_UTF -

4188 if (utf) -

4189 { -

4190 xclass = TRUE; -

4191 *class_uchardata++ = XCL_RANGE; -

4192 class_uchardata += PRIV(ord2utf)(0x0100, class_uchardata); -

4193 class_uchardata += PRIV(ord2utf)(0x2027, class_uchardata); -

4194 *class_uchardata++ = XCL_RANGE; -

4195 class_uchardata += PRIV(ord2utf)(0x202a, class_uchardata); -

4196 class_uchardata += PRIV(ord2utf)(0x10ffff, class_uchardata); -

4197 } -

4198 #endif -

4199

int ptype = get_ucp(&ptr, &negated, &pdata, errorcodeptr);

never executed: continue;

4200 -

4201 #ifdef SUPPORT_UCP -

4202 case ESC_p: -

4203 case ESC_P: -

4204 { -

4205

BOOL negated;

never executed (the execution status of this line is deduced): BOOL negated;

4206

int pdata;

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

4207

never executed (the execution status of this line is deduced): int ptype = get_ucp(&ptr, &negated, &pdata, errorcodeptr);

4208

if (ptype < 0) goto FAILED;

never executed: goto FAILED;

never evaluated: ptype < 0

4209

*class_uchardata++ = ((-c == ESC_p) != negated)?

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

4210

never evaluated: ((-c == ESC_p) != negated)

4211

XCL_PROP : XCL_NOTPROP;

never executed (the execution status of this line is deduced): 3 : 4;

4212

*class_uchardata++ = ptype;

never executed (the execution status of this line is deduced): *class_uchardata++ = ptype;

4213

*class_uchardata++ = pdata;

never executed (the execution status of this line is deduced): *class_uchardata++ = pdata;

4214

class_has_8bitchar--; /* Undo! */

never executed (the execution status of this line is deduced): class_has_8bitchar--;

4215

if ((options & PCRE_EXTRA) != 0)

never executed: continue;

4216 } -

4217 #endif -

4218 /* Unrecognized escapes are faulted if PCRE is running in its -

4219 strict mode. By default, for compatibility with Perl, they are -

4220 treated as literals. */ -

4221 -

4222 default: -

4223

never evaluated: (options & 0x00000040) != 0

4224 { -

4225

*errorcodeptr = ERR7;

never executed (the execution status of this line is deduced): *errorcodeptr = ERR7;

4226

class_has_8bitchar--; /* Undo the speculative increase. */

never executed: goto FAILED;

4227 } -

4228

never executed (the execution status of this line is deduced): class_has_8bitchar--;

4229

class_single_char -= 2; /* Undo the speculative increase. */

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

4230

c = *ptr; /* Get the final character and fall through */

never executed (the execution status of this line is deduced): c = *ptr;

4231

never executed: break;

4232 } -

4233

} /* End of backslash handling */

never executed: }

4234 -

4235 /* Fall through if we have a single character (c >= 0). This may be -

4236 greater than 256. */ -

4237 -

4238

executed: }

Execution Count:4

4239 -

4240 /* A single character may be followed by '-' to form a range. However, -

4241 Perl does not permit ']' to be the end of the range. A '-' character -

4242 at the end is treated as a literal. Perl ignores orphaned \E sequences -

4243 entirely. The code for handling \Q and \E is messy. */ -

4244 -

4245

CHECK_RANGE:

code before this statement executed: CHECK_RANGE:

Execution Count:112

112

4246

while (ptr[1] == CHAR_BACKSLASH && ptr[2] == CHAR_E)

partially evaluated: ptr[1] == '\134'

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

never evaluated: ptr[2] == '\105'

0-112

4247 { -

4248

inescq = FALSE;

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

4249

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

4250

if (c == CHAR_CR || c == CHAR_NL) cd->external_flags |= PCRE_HASCRORLF;

never executed: }

4251 -

4252

oldptr = ptr;

executed (the execution status of this line is deduced): oldptr = ptr;

4253 -

4254 /* Remember \r or \n */ -

4255 -

4256

never executed: cd->external_flags |= 0x0800;

partially evaluated: c == '\015'

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

partially evaluated: c == '\012'

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

0-112

4257 -

4258 /* Check for range */ -

4259 -

4260

if (!inescq && ptr[1] == CHAR_MINUS)

partially evaluated: !inescq

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

evaluated: ptr[1] == '\055'

TRUE	FALSE
yes Evaluation Count:14	yes Evaluation Count:98

0-112

4261 { -

4262

int d;

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

4263

while (*ptr == CHAR_BACKSLASH && ptr[1] == CHAR_E) ptr += 2;

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

4264

never executed: ptr += 2;

evaluated: *ptr == '\134'

TRUE	FALSE
yes Evaluation Count:4	yes Evaluation Count:10

partially evaluated: ptr[1] == '\105'

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

0-10

4265 -

4266 /* If we hit \Q (not followed by \E) at this point, go into escaped -

4267 mode. */ -

4268 -

4269

while (*ptr == CHAR_BACKSLASH && ptr[1] == CHAR_Q)

evaluated: *ptr == '\134'

TRUE	FALSE
yes Evaluation Count:4	yes Evaluation Count:10

partially evaluated: ptr[1] == '\121'

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

0-10

4270 { -

4271

if (*ptr == CHAR_BACKSLASH && ptr[1] == CHAR_E)

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

4272

never evaluated: *ptr == '\134'

never evaluated: ptr[1] == '\105'

4273

{ ptr += 2; continue; }

never executed: continue;

4274

inescq = TRUE;

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

4275

if (*ptr == 0 || (!inescq && *ptr == CHAR_RIGHT_SQUARE_BRACKET))

never executed: break;

4276 } -

4277 -

4278

partially evaluated: *ptr == 0

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

partially evaluated: !inescq

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

partially evaluated: *ptr == '\135'

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

0-14

4279 { -

4280

ptr = oldptr;

never executed (the execution status of this line is deduced): ptr = oldptr;

4281

goto LONE_SINGLE_CHARACTER;

never executed: goto LONE_SINGLE_CHARACTER;

4282 } -

4283 -

4284 #ifdef SUPPORT_UTF -

4285

GETCHARLEN(d, ptr, ptr); /* macro generates multiple statements */

partially evaluated: utf

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

0-14

4286 { /* Braces are required because the */ -

4287

never executed: }

partially evaluated: (d & 0xfc00) == 0xd800

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

0-14

4288

d = *ptr; /* Not UTF-8 mode */

executed: }

Execution Count:14

4289 else -

4290 #endif -

4291

never executed: d = *ptr;

4292 -

4293 /* The second part of a range can be a single-character escape, but -

4294 not any of the other escapes. Perl 5.6 treats a hyphen as a literal -

4295 in such circumstances. */ -

4296 -

4297

if (!inescq && d == CHAR_BACKSLASH)

partially evaluated: !inescq

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

evaluated: d == '\134'

TRUE	FALSE
yes Evaluation Count:4	yes Evaluation Count:10

0-14

4298 { -

4299

d = check_escape(&ptr, errorcodeptr, cd->bracount, options, TRUE);

executed (the execution status of this line is deduced): d = check_escape(&ptr, errorcodeptr, cd->bracount, options, 1);

4300

if (d == -ESC_b) d = CHAR_BS; else

never executed: goto FAILED;

partially evaluated: *errorcodeptr != 0

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

0-4

4301 -

4302 /* \b is backspace; any other special means the '-' was literal */ -

4303 -

4304

if (d < 0)

partially evaluated: d < 0

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

0-4

4305 { -

4306

never executed: d = '\010';

never evaluated: d == -ESC_b

4307 { -

4308

ptr = oldptr;

never executed (the execution status of this line is deduced): ptr = oldptr;

4309

goto LONE_SINGLE_CHARACTER; /* A few lines below */

never executed: goto LONE_SINGLE_CHARACTER;

4310 } -

4311 } -

4312

executed: }

Execution Count:4

4313 -

4314 /* Check that the two values are in the correct order. Optimize -

4315 one-character ranges */ -

4316 -

4317

if (d < c)

partially evaluated: d < c

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

0-14

4318 { -

4319

*errorcodeptr = ERR8;

never executed (the execution status of this line is deduced): *errorcodeptr = ERR8;

4320

if (d == c) goto LONE_SINGLE_CHARACTER; /* A few lines below */

never executed: goto FAILED;

4321 } -

4322 -

4323

never executed: goto LONE_SINGLE_CHARACTER;

partially evaluated: d == c

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

0-14

4324 -

4325 /* Remember \r or \n */ -

4326 -

4327

if (d == CHAR_CR || d == CHAR_NL) cd->external_flags |= PCRE_HASCRORLF;

never executed: cd->external_flags |= 0x0800;

partially evaluated: d == '\015'

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

partially evaluated: d == '\012'

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

0-14

4328 -

4329 /* Since we found a character range, single character optimizations -

4330 cannot be done anymore. */ -

4331

class_single_char = 2;

executed (the execution status of this line is deduced): class_single_char = 2;

4332 -

4333 /* In UTF-8 mode, if the upper limit is > 255, or > 127 for caseless -

4334 matching, we have to use an XCLASS with extra data items. Caseless -

4335 matching for characters > 127 is available only if UCP support is -

4336 available. */ -

4337 -

4338 #if defined SUPPORT_UTF && !(defined COMPILE_PCRE8) -

4339

if ((d > 255) || (utf && ((options & PCRE_CASELESS) != 0 && d > 127)))

evaluated: (d > 255)

TRUE	FALSE
yes Evaluation Count:4	yes Evaluation Count:10

partially evaluated: utf

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

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

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

never evaluated: d > 127

0-10

4340 #elif defined SUPPORT_UTF -

4341 if (utf && (d > 255 || ((options & PCRE_CASELESS) != 0 && d > 127))) -

4342 #elif !(defined COMPILE_PCRE8) -

4343 if (d > 255) -

4344 #endif -

4345 #if defined SUPPORT_UTF || !(defined COMPILE_PCRE8) -

4346 { -

4347

if (utf && (options & PCRE_CASELESS) != 0)

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

4348 -

4349 /* With UCP support, we can find the other case equivalents of -

4350 the relevant characters. There may be several ranges. Optimize how -

4351 they fit with the basic range. */ -

4352 -

4353 #ifdef SUPPORT_UCP -

4354 #ifndef COMPILE_PCRE8 -

4355

partially evaluated: utf

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

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

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

0-4

4356 #else -

4357 if ((options & PCRE_CASELESS) != 0) -

4358 #endif -

4359 { -

4360

unsigned int occ, ocd;

never executed (the execution status of this line is deduced): unsigned int occ, ocd;

4361

unsigned int cc = c;

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

4362

unsigned int origd = d;

never executed (the execution status of this line is deduced): unsigned int origd = d;

4363

while (get_othercase_range(&cc, origd, &occ, &ocd))

never evaluated: get_othercase_range(&cc, origd, &occ, &ocd)

4364 { -

4365

if (occ >= (unsigned int)c &&

never evaluated: occ >= (unsigned int)c

4366

ocd <= (unsigned int)d)

never evaluated: ocd <= (unsigned int)d

4367

continue; /* Skip embedded ranges */

never executed: continue;

4368 -

4369

if (occ < (unsigned int)c &&

never evaluated: occ < (unsigned int)c

4370

ocd >= (unsigned int)c - 1) /* Extend the basic range */

never evaluated: ocd >= (unsigned int)c - 1

4371 { /* if there is overlap, */ -

4372

c = occ; /* noting that if occ < c */

never executed (the execution status of this line is deduced): c = occ;

4373

continue; /* we can't have ocd > d */

never executed: continue;

4374 } /* because a subrange is */ -

4375

if (ocd > (unsigned int)d &&

never evaluated: ocd > (unsigned int)d

4376

occ <= (unsigned int)d + 1) /* always shorter than */

never evaluated: occ <= (unsigned int)d + 1

4377 { /* the basic range. */ -

4378

d = ocd;

never executed (the execution status of this line is deduced): d = ocd;

4379

never executed: continue;

4380 } -

4381 -

4382

if (occ == ocd)

never evaluated: occ == ocd

4383 { -

4384

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

4385

never executed: }

4386 else -

4387 { -

4388

class_uchardata += PRIV(ord2utf)(occ, class_uchardata);

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

4389

never executed (the execution status of this line is deduced): class_uchardata += _pcre16_ord2utf(occ, class_uchardata);

4390

class_uchardata += PRIV(ord2utf)(ocd, class_uchardata);

never executed: }

4391

never executed (the execution status of this line is deduced): class_uchardata += _pcre16_ord2utf(ocd, class_uchardata);

never executed: }

never executed: }

4394 #endif /* SUPPORT_UCP */ -

4395 -

4396 /* Now record the original range, possibly modified for UCP caseless -

4397 overlapping ranges. */ -

4398 -

4399

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

4400 #ifdef SUPPORT_UTF -

4401 #ifndef COMPILE_PCRE8 -

4402

class_uchardata += PRIV(ord2utf)(c, class_uchardata);

partially evaluated: utf

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

0-4

4403 { -

4404

executed (the execution status of this line is deduced): class_uchardata += _pcre16_ord2utf(c, class_uchardata);

4405

class_uchardata += PRIV(ord2utf)(d, class_uchardata);

executed (the execution status of this line is deduced): class_uchardata += _pcre16_ord2utf(d, class_uchardata);

4406

executed: }

Execution Count:4

4407 else -

4408 { -

4409

*class_uchardata++ = c;

never executed (the execution status of this line is deduced): *class_uchardata++ = c;

4410

*class_uchardata++ = d;

never executed (the execution status of this line is deduced): *class_uchardata++ = d;

4411

never executed: }

4412 #else -

4413 class_uchardata += PRIV(ord2utf)(c, class_uchardata); -

4414 class_uchardata += PRIV(ord2utf)(d, class_uchardata); -

4415 #endif -

4416 #else /* SUPPORT_UTF */ -

4417 *class_uchardata++ = c; -

4418 *class_uchardata++ = d; -

4419 #endif /* SUPPORT_UTF */ -

4420 -

4421 /* With UCP support, we are done. Without UCP support, there is no -

4422 caseless matching for UTF characters > 127; we can use the bit map -

4423 for the smaller ones. As for 16 bit characters without UTF, we -

4424 can still use */ -

4425 -

4426 #ifdef SUPPORT_UCP -

4427 #ifndef COMPILE_PCRE8 -

4428

continue; /* With next character in the class */

partially evaluated: utf

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

0-4

4429 #endif -

4430

executed: continue;

Execution Count:4

4431 #endif /* SUPPORT_UCP */ -

4432 -

4433 #if defined SUPPORT_UTF && !defined(SUPPORT_UCP) && !(defined COMPILE_PCRE8) -

4434 if (utf) -

4435 { -

4436 if ((options & PCRE_CASELESS) == 0 || c > 127) continue; -

4437 /* Adjust upper limit and fall through to set up the map */ -

4438 d = 127; -

4439 } -

4440 else -

4441 { -

4442 if (c > 255) continue; -

4443 /* Adjust upper limit and fall through to set up the map */ -

4444 d = 255; -

4445 } -

4446 #elif defined SUPPORT_UTF && !defined(SUPPORT_UCP) -

4447 if ((options & PCRE_CASELESS) == 0 || c > 127) continue; -

4448 /* Adjust upper limit and fall through to set up the map */ -

4449 d = 127; -

4450 #else -

4451

if (c > 255) continue;

never executed: continue;

never evaluated: c > 255

4452 /* Adjust upper limit and fall through to set up the map */ -

4453

d = 255;

never executed (the execution status of this line is deduced): d = 255;

4454 #endif /* SUPPORT_UTF && !SUPPORT_UCP && !COMPILE_PCRE8 */ -

4455

if (lengthptr == NULL) for (; c <= d; c++)

never executed: }

4456 #endif /* SUPPORT_UTF || !COMPILE_PCRE8 */ -

4457 -

4458 /* We use the bit map for 8 bit mode, or when the characters fall -

4459 partially or entirely to [0-255] ([0-127] for UCP) ranges. */ -

4460 -

4461

class_has_8bitchar = 1;

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

4462 -

4463 /* We can save a bit of time by skipping this in the pre-compile. */ -

4464 -

4465

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

TRUE	FALSE
yes Evaluation Count:5	yes Evaluation Count:5

evaluated: c <= d

TRUE	FALSE
yes Evaluation Count:130	yes Evaluation Count:5

5-130

4466 { -

4467

classbits[c/8] |= (1 << (c&7));

executed (the execution status of this line is deduced): classbits[c/8] |= (1 << (c&7));

4468

if ((options & PCRE_CASELESS) != 0)

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

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

0-130

4469 { -

4470

int uc = cd->fcc[c]; /* flip case */

never executed (the execution status of this line is deduced): int uc = cd->fcc[c];

4471

classbits[uc/8] |= (1 << (uc&7));

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

never executed: }

executed: }

Execution Count:130

130

4474 -

4475

continue; /* Go get the next char in the class */

executed: continue;

Execution Count:10

4476 } -

4477 -

4478 /* Handle a lone single character - we can get here for a normal -

4479 non-escape char, or after \ that introduces a single character or for an -

4480 apparent range that isn't. */ -

4481 -

4482

LONE_SINGLE_CHARACTER:

code before this statement executed: LONE_SINGLE_CHARACTER:

Execution Count:98

4483 -

4484 /* Only the value of 1 matters for class_single_char. */ -

4485

if (class_single_char < 2) class_single_char++;

executed: class_single_char++;

Execution Count:80

evaluated: class_single_char < 2

TRUE	FALSE
yes Evaluation Count:80	yes Evaluation Count:18

18-80

4486 -

4487 /* If class_charcount is 1, we saw precisely one character. As long as -

4488 there were no negated characters >= 128 and there was no use of \p or \P, -

4489 in other words, no use of any XCLASS features, we can optimize. -

4490 -

4491 In UTF-8 mode, we can optimize the negative case only if there were no -

4492 characters >= 128 because OP_NOT and the related opcodes like OP_NOTSTAR -

4493 operate on single-bytes characters only. This is an historical hangover. -

4494 Maybe one day we can tidy these opcodes to handle multi-byte characters. -

4495 -

4496 The optimization throws away the bit map. We turn the item into a -

4497 1-character OP_CHAR[I] if it's positive, or OP_NOT[I] if it's negative. -

4498 Note that OP_NOT[I] does not support multibyte characters. In the positive -

4499 case, it can cause firstchar to be set. Otherwise, there can be no first -

4500 char if this item is first, whatever repeat count may follow. In the case -

4501 of reqchar, save the previous value for reinstating. */ -

4502 -

4503 #ifdef SUPPORT_UTF -

4504

if (class_single_char == 1 && ptr[1] == CHAR_RIGHT_SQUARE_BRACKET

evaluated: class_single_char == 1

TRUE	FALSE
yes Evaluation Count:44	yes Evaluation Count:54

evaluated: ptr[1] == '\135'

TRUE	FALSE
yes Evaluation Count:8	yes Evaluation Count:36

8-54

4505

&& (!utf || !negate_class || c < (MAX_VALUE_FOR_SINGLE_CHAR + 1)))

partially evaluated: !utf

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

evaluated: !negate_class

TRUE	FALSE
yes Evaluation Count:6	yes Evaluation Count:2

partially evaluated: c < (65535 + 1)

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

0-8

4506 #else -

4507 if (class_single_char == 1 && ptr[1] == CHAR_RIGHT_SQUARE_BRACKET) -

4508 #endif -

4509 { -

4510

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

4511

executed (the execution status of this line is deduced): zeroreqchar = reqchar;

4512 -

4513 /* The OP_NOT[I] opcodes work on single characters only. */ -

4514 -

4515

if (negate_class)

evaluated: negate_class

TRUE	FALSE
yes Evaluation Count:2	yes Evaluation Count:6

2-6

4516 { -

4517

executed: firstchar = (-1);

Execution Count:2

partially evaluated: firstchar == (-2)

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

0-2

4518

*code++ = ((options & PCRE_CASELESS) != 0)? OP_NOTI: OP_NOT;

executed (the execution status of this line is deduced): zerofirstchar = firstchar;

4519

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

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

0-2

4520

if (utf && c > MAX_VALUE_FOR_SINGLE_CHAR)

executed (the execution status of this line is deduced): *code++ = c;

4521

goto NOT_CHAR;

executed: goto NOT_CHAR;

Execution Count:2

4522 } -

4523 -

4524 /* For a single, positive character, get the value into mcbuffer, and -

4525 then we can handle this with the normal one-character code. */ -

4526 -

4527 #ifdef SUPPORT_UTF -

4528

partially evaluated: utf

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

partially evaluated: c > 65535

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

0-6

4529

mclength = PRIV(ord2utf)(c, mcbuffer);

never executed: mclength = _pcre16_ord2utf(c, mcbuffer);

4530 else -

4531 #endif -

4532 { -

4533

mcbuffer[0] = c;

executed (the execution status of this line is deduced): mcbuffer[0] = c;

4534

mclength = 1;

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

4535

if ((c > 255) || (utf && ((options & PCRE_CASELESS) != 0 && c > 127)))

executed: }

Execution Count:6

4536

goto ONE_CHAR;

executed: goto ONE_CHAR;

Execution Count:6

4537 } /* End of 1-char optimization */ -

4538 -

4539 /* Handle a character that cannot go in the bit map. */ -

4540 -

4541 #if defined SUPPORT_UTF && !(defined COMPILE_PCRE8) -

4542

partially evaluated: (c > 255)

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

partially evaluated: utf

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

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

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

never evaluated: c > 127

0-90

4543 #elif defined SUPPORT_UTF -

4544 if (utf && (c > 255 || ((options & PCRE_CASELESS) != 0 && c > 127))) -

4545 #elif !(defined COMPILE_PCRE8) -

4546 if (c > 255) -

4547 #endif -

4548 -

4549 #if defined SUPPORT_UTF || !(defined COMPILE_PCRE8) -

4550 { -

4551

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

4552

class_uchardata += PRIV(ord2utf)(c, class_uchardata);

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

4553 #ifdef SUPPORT_UTF -

4554 #ifndef COMPILE_PCRE8 -

4555 /* In non 8 bit mode, we can get here even if we are not in UTF mode. */ -

4556

if (!utf)

never evaluated: !utf

4557

*class_uchardata++ = c;

never executed: *class_uchardata++ = c;

4558 else -

4559 #endif -

4560

never executed: class_uchardata += _pcre16_ord2utf(c, class_uchardata);

4561 #else /* SUPPORT_UTF */ -

4562 *class_uchardata++ = c; -

4563 #endif /* SUPPORT_UTF */ -

4564 -

4565 #ifdef SUPPORT_UCP -

4566 #ifdef COMPILE_PCRE8 -

4567 if ((options & PCRE_CASELESS) != 0) -

4568 #else -

4569 /* In non 8 bit mode, we can get here even if we are not in UTF mode. */ -

4570

if (utf && (options & PCRE_CASELESS) != 0)

never evaluated: utf

never evaluated: (options & 0x00000001) != 0

4571 #endif -

4572 { -

4573

unsigned int othercase;

never executed (the execution status of this line is deduced): unsigned int othercase;

4574

if ((int)(othercase = UCD_OTHERCASE(c)) != c)

never evaluated:

(int)(othercase = (c + (_pcre16_ucd_records + _pcre16_ucd_stage2[_pcre16_ucd_stage1[(c) / 128] * 128 + (c) % 128])->other_case)) != c

4575 { -

4576

class_uchardata += PRIV(ord2utf)(othercase, class_uchardata);

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

4577

never executed (the execution status of this line is deduced): class_uchardata += _pcre16_ord2utf(othercase, class_uchardata);

never executed: }

never executed: }

4580 #endif /* SUPPORT_UCP */ -

4581 -

4582

classbits[c/8] |= (1 << (c&7));

never executed: }

4583 else -

4584 #endif /* SUPPORT_UTF || COMPILE_PCRE16 */ -

4585 -

4586 /* Handle a single-byte character */ -

4587 { -

4588

class_has_8bitchar = 1;

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

4589

executed (the execution status of this line is deduced): classbits[c/8] |= (1 << (c&7));

4590

if ((options & PCRE_CASELESS) != 0)

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

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

0-90

4591 { -

4592

c = cd->fcc[c]; /* flip case */

never executed (the execution status of this line is deduced): c = cd->fcc[c];

4593

classbits[c/8] |= (1 << (c&7));

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

never executed: }

executed: }

Execution Count:90

4596 } -

4597 -

4598 /* Loop until ']' reached. This "while" is the end of the "do" far above. -

4599 If we are at the end of an internal nested string, revert to the outer -

4600 string. */ -

4601 -

4602

while (((c = *(++ptr)) != 0 ||

partially evaluated: (c = *(++ptr)) != 0

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

0-104

4603

(nestptr != NULL &&

never evaluated: nestptr != ((void *)0)

4604

(ptr = nestptr, nestptr = NULL, c = *(++ptr)) != 0)) &&

never evaluated: (ptr = nestptr, nestptr = ((void *)0), c = *(++ptr)) != 0

4605

(c != CHAR_RIGHT_SQUARE_BRACKET || inescq));

evaluated: c != '\135'

TRUE	FALSE
yes Evaluation Count:54	yes Evaluation Count:50

partially evaluated: inescq

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

0-54

4606 -

4607 /* Check for missing terminating ']' */ -

4608 -

4609

partially evaluated: c == 0

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

0-50

4610 { -

4611

*errorcodeptr = ERR6;

never executed (the execution status of this line is deduced): *errorcodeptr = ERR6;

4612

never executed: goto FAILED;

4613 } -

4614 -

4615 /* If this is the first thing in the branch, there can be no first char -

4616 setting, whatever the repeat count. Any reqchar setting must remain -

4617 unchanged after any kind of repeat. */ -

4618 -

4619

executed: firstchar = (-1);

Execution Count:36

evaluated: firstchar == (-2)

TRUE	FALSE
yes Evaluation Count:36	yes Evaluation Count:14

14-36

4620

executed (the execution status of this line is deduced): zerofirstchar = firstchar;

4621

if (xclass && (!should_flip_negation || (options & PCRE_UCP) != 0))

executed (the execution status of this line is deduced): zeroreqchar = reqchar;

4622 -

4623 /* If there are characters with values > 255, we have to compile an -

4624 extended class, with its own opcode, unless there was a negated special -

4625 such as \S in the class, and PCRE_UCP is not set, because in that case all -

4626 characters > 255 are in the class, so any that were explicitly given as -

4627 well can be ignored. If (when there are explicit characters > 255 that must -

4628 be listed) there are no characters < 256, we can omit the bitmap in the -

4629 actual compiled code. */ -

4630 -

4631 #ifdef SUPPORT_UTF -

4632

evaluated: xclass

TRUE	FALSE
yes Evaluation Count:4	yes Evaluation Count:46

partially evaluated: !should_flip_negation

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

never evaluated: (options & 0x20000000) != 0

0-46

4633 #elif !defined COMPILE_PCRE8 -

4634 if (xclass && !should_flip_negation) -

4635 #endif -

4636 #if defined SUPPORT_UTF || !defined COMPILE_PCRE8 -

4637 { -

4638

*class_uchardata++ = XCL_END; /* Marks the end of extra data */

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

4639

*code++ = OP_XCLASS;

executed (the execution status of this line is deduced): *code++ = OP_XCLASS;

4640

code += LINK_SIZE;

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

4641

*code = negate_class? XCL_NOT:0;

partially evaluated: negate_class

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

0-4

4642 -

4643 /* If the map is required, move up the extra data to make room for it; -

4644 otherwise just move the code pointer to the end of the extra data. */ -

4645 -

4646

if (class_has_8bitchar > 0)

partially evaluated: class_has_8bitchar > 0

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

0-4

4647 { -

4648

*code++ |= XCL_MAP;

never executed (the execution status of this line is deduced): *code++ |= 0x02;

4649

memmove(code + (32 / sizeof(pcre_uchar)), code,

never executed (the execution status of this line is deduced): memmove(code + (32 / sizeof(pcre_uchar)), code,

4650

IN_UCHARS(class_uchardata - code));

never executed (the execution status of this line is deduced): ((class_uchardata - code) << 1));

4651

memcpy(code, classbits, 32);

never executed (the execution status of this line is deduced): memcpy(code, classbits, 32);

4652

code = class_uchardata + (32 / sizeof(pcre_uchar));

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

4653

else code = class_uchardata;

never executed: }

4654

executed: code = class_uchardata;

Execution Count:4

4655 -

4656 /* Now fill in the complete length of the item */ -

4657 -

4658

PUT(previous, 1, (int)(code - previous));

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

4659

break; /* End of class handling */

executed: break;

Execution Count:4

4660 } -

4661 #endif -

4662 -

4663 /* If there are no characters > 255, or they are all to be included or -

4664 excluded, set the opcode to OP_CLASS or OP_NCLASS, depending on whether the -

4665 whole class was negated and whether there were negative specials such as \S -

4666 (non-UCP) in the class. Then copy the 32-byte map into the code vector, -

4667 negating it if necessary. */ -

4668 -

4669

*code++ = (negate_class == should_flip_negation) ? OP_CLASS : OP_NCLASS;

partially evaluated: (negate_class == should_flip_negation)

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

0-46

4670

if (lengthptr == NULL) /* Save time in the pre-compile phase */

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

TRUE	FALSE
yes Evaluation Count:23	yes Evaluation Count:23

4671 { -

4672

if (negate_class)

partially evaluated: negate_class

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

0-23

4673

for (c = 0; c < 32; c++) classbits[c] = ~classbits[c];

never executed: classbits[c] = ~classbits[c];

never evaluated: c < 32

4674

memcpy(code, classbits, 32);

executed (the execution status of this line is deduced): memcpy(code, classbits, 32);

4675

code += 32 / sizeof(pcre_uchar);

executed: }

Execution Count:23

4676

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

4677 NOT_CHAR: -

4678

if (!is_quantifier) goto NORMAL_CHAR;

executed: break;

Execution Count:48

4679 -

4680 -

4681 /* ===================================================================*/ -

4682 /* Various kinds of repeat; '{' is not necessarily a quantifier, but this -

4683 has been tested above. */ -

4684 -

4685 case CHAR_LEFT_CURLY_BRACKET: -

4686

executed: goto NORMAL_CHAR;

Execution Count:2

evaluated: !is_quantifier

TRUE	FALSE
yes Evaluation Count:2	yes Evaluation Count:24

2-24

4687

ptr = read_repeat_counts(ptr+1, &repeat_min, &repeat_max, errorcodeptr);

executed (the execution status of this line is deduced): ptr = read_repeat_counts(ptr+1, &repeat_min, &repeat_max, errorcodeptr);

4688

never executed: goto FAILED;

partially evaluated: *errorcodeptr != 0

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

0-24

4689

goto REPEAT;

executed: goto REPEAT;

Execution Count:24

4690 -

4691 case CHAR_ASTERISK: -

4692

repeat_min = 0;

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

4693

repeat_max = -1;

executed (the execution status of this line is deduced): repeat_max = -1;

4694

goto REPEAT;

executed: goto REPEAT;

Execution Count:247

247

4695 -

4696 case CHAR_PLUS: -

4697

repeat_min = 1;

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

4698

repeat_max = -1;

executed (the execution status of this line is deduced): repeat_max = -1;

4699

goto REPEAT;

executed: goto REPEAT;

Execution Count:120

120

4700 -

4701 case CHAR_QUESTION_MARK: -

4702

repeat_min = 0;

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

4703

repeat_max = 1;

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

4704 -

4705

REPEAT:

code before this statement executed: REPEAT:

Execution Count:100

100

4706

if (previous == NULL)

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

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

0-491

4707 { -

4708

*errorcodeptr = ERR9;

never executed (the execution status of this line is deduced): *errorcodeptr = ERR9;

4709

firstchar = zerofirstchar; /* Adjust for zero repeat */

never executed: goto FAILED;

4710 } -

4711 -

4712

if (repeat_min == 0)

evaluated: repeat_min == 0

TRUE	FALSE
yes Evaluation Count:347	yes Evaluation Count:144

144-347

4713 { -

4714

executed (the execution status of this line is deduced): firstchar = zerofirstchar;

4715

reqchar = zeroreqchar; /* Ditto */

executed (the execution status of this line is deduced): reqchar = zeroreqchar;

4716

reqvary = (repeat_min == repeat_max)? 0 : REQ_VARY;

executed: }

Execution Count:347

347

4717 -

4718 /* Remember whether this is a variable length repeat */ -

4719 -

4720

evaluated: (repeat_min == repeat_max)

TRUE	FALSE
yes Evaluation Count:16	yes Evaluation Count:475

16-475

4721 -

4722

op_type = 0; /* Default single-char op codes */

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

4723

possessive_quantifier = FALSE; /* Default not possessive quantifier */

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

4724 -

4725 /* Save start of previous item, in case we have to move it up in order to -

4726 insert something before it. */ -

4727 -

4728

tempcode = previous;

executed (the execution status of this line is deduced): tempcode = previous;

4729 -

4730 /* If the next character is '+', we have a possessive quantifier. This -

4731 implies greediness, whatever the setting of the PCRE_UNGREEDY option. -

4732 If the next character is '?' this is a minimizing repeat, by default, -

4733 but if PCRE_UNGREEDY is set, it works the other way round. We change the -

4734 repeat type to the non-default. */ -

4735 -

4736

if (ptr[1] == CHAR_PLUS)

partially evaluated: ptr[1] == '\053'

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

0-491

4737 { -

4738

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

4739

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

4740

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

4741

else if (ptr[1] == CHAR_QUESTION_MARK)

never executed: }

4742

evaluated: ptr[1] == '\077'

TRUE	FALSE
yes Evaluation Count:10	yes Evaluation Count:481

10-481

4743 { -

4744

repeat_type = greedy_non_default;

executed (the execution status of this line is deduced): repeat_type = greedy_non_default;

4745

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

4746

else repeat_type = greedy_default;

executed: }

Execution Count:10

4747

executed: repeat_type = greedy_default;

Execution Count:481

481

4748 -

4749 /* If previous was a recursion call, wrap it in atomic brackets so that -

4750 previous becomes the atomic group. All recursions were so wrapped in the -

4751 past, but it no longer happens for non-repeated recursions. In fact, the -

4752 repeated ones could be re-implemented independently so as not to need this, -

4753 but for the moment we rely on the code for repeating groups. */ -

4754 -

4755

if (*previous == OP_RECURSE)

partially evaluated: *previous == OP_RECURSE

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

0-491

4756 { -

4757

memmove(previous + 1 + LINK_SIZE, previous, IN_UCHARS(1 + LINK_SIZE));

never executed (the execution status of this line is deduced): memmove(previous + 1 + 1, previous, ((1 + 1) << 1));

4758

*previous = OP_ONCE;

never executed (the execution status of this line is deduced): *previous = OP_ONCE;

4759

PUT(previous, 1, 2 + 2*LINK_SIZE);

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

4760

previous[2 + 2*LINK_SIZE] = OP_KET;

never executed (the execution status of this line is deduced): previous[2 + 2*1] = OP_KET;

4761

PUT(previous, 3 + 2*LINK_SIZE, 2 + 2*LINK_SIZE);

never executed (the execution status of this line is deduced): (previous[3 + 2*1] = (2 + 2*1));

4762

code += 2 + 2 * LINK_SIZE;

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

4763

length_prevgroup = 3 + 3*LINK_SIZE;

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

4764 -

4765 /* When actually compiling, we need to check whether this was a forward -

4766 reference, and if so, adjust the offset. */ -

4767 -

4768

if (lengthptr == NULL && cd->hwm >= cd->start_workspace + LINK_SIZE)

never evaluated: lengthptr == ((void *)0)

never evaluated: cd->hwm >= cd->start_workspace + 1

4769 { -

4770

int offset = GET(cd->hwm, -LINK_SIZE);

never executed (the execution status of this line is deduced): int offset = (cd->hwm[-1]);

4771

if (offset == previous + 1 - cd->start_code)

never evaluated: offset == previous + 1 - cd->start_code

4772

PUT(cd->hwm, -LINK_SIZE, offset + 1 + LINK_SIZE);

never executed: (cd->hwm[-1] = (offset + 1 + 1));

never executed: }

never executed: }

4775 -

4776 /* Now handle repetition for the different types of item. */ -

4777 -

4778 /* If previous was a character match, abolish the item and generate a -

4779 repeat item instead. If a char item has a minumum of more than one, ensure -

4780 that it is set in reqchar - it might not be if a sequence such as x{3} is -

4781 the first thing in a branch because the x will have gone into firstchar -

4782 instead. */ -

4783 -

4784

if (*previous == OP_CHAR || *previous == OP_CHARI)

evaluated: *previous == OP_CHAR

TRUE	FALSE
yes Evaluation Count:14	yes Evaluation Count:477

partially evaluated: *previous == OP_CHARI

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

0-477

4785 { -

4786

op_type = (*previous == OP_CHAR)? 0 : OP_STARI - OP_STAR;

partially evaluated: (*previous == OP_CHAR)

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

0-14

4787 -

4788 /* Deal with UTF characters that take up more than one character. It's -

4789 easier to write this out separately than try to macrify it. Use c to -

4790 hold the length of the character in bytes, plus UTF_LENGTH to flag that -

4791 it's a length rather than a small character. */ -

4792 -

4793 #ifdef SUPPORT_UTF -

4794

if (utf && NOT_FIRSTCHAR(code[-1]))

partially evaluated: utf

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

partially evaluated: (((code[-1]) & 0xfc00) == 0xdc00)

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

0-14

4795 { -

4796

pcre_uchar *lastchar = code - 1;

never executed (the execution status of this line is deduced): pcre_uchar *lastchar = code - 1;

4797

BACKCHAR(lastchar);

never executed: lastchar--;

never evaluated: (*lastchar & 0xfc00) == 0xdc00

4798

c = (int)(code - lastchar); /* Length of UTF-8 character */

never executed (the execution status of this line is deduced): c = (int)(code - lastchar);

4799

memcpy(utf_chars, lastchar, IN_UCHARS(c)); /* Save the char */

never executed (the execution status of this line is deduced): memcpy(utf_chars, lastchar, ((c) << 1));

4800

c |= UTF_LENGTH; /* Flag c as a length */

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

4801

if (repeat_min > 1) reqchar = c | req_caseopt | cd->req_varyopt;

never executed: }

4802 else -

4803 #endif /* SUPPORT_UTF */ -

4804 -

4805 /* Handle the case of a single charater - either with no UTF support, or -

4806 with UTF disabled, or for a single character UTF character. */ -

4807 { -

4808

c = code[-1];

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

4809

never executed: reqchar = c | req_caseopt | cd->req_varyopt;

partially evaluated: repeat_min > 1

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

0-14

4810

if (!possessive_quantifier &&

executed: }

Execution Count:14

4811 -

4812 /* If the repetition is unlimited, it pays to see if the next thing on -

4813 the line is something that cannot possibly match this character. If so, -

4814 automatically possessifying this item gains some performance in the case -

4815 where the match fails. */ -

4816 -

4817

partially evaluated: !possessive_quantifier

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

0-14

4818

repeat_max < 0 &&

partially evaluated: repeat_max < 0

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

0-14

4819

check_auto_possessive(previous, utf, ptr + 1, options, cd))

partially evaluated: check_auto_possessive(previous, utf, ptr + 1, options, cd)

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

0-14

4820 { -

4821

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

4822

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

4823

goto OUTPUT_SINGLE_REPEAT; /* Code shared with single character types */

never executed: }

4824 -

4825

executed: goto OUTPUT_SINGLE_REPEAT;

Execution Count:14

4826 } -

4827 -

4828 /* If previous was a single negated character ([^a] or similar), we use -

4829 one of the special opcodes, replacing it. The code is shared with single- -

4830 character repeats by setting opt_type to add a suitable offset into -

4831 repeat_type. We can also test for auto-possessification. OP_NOT and OP_NOTI -

4832 are currently used only for single-byte chars. */ -

4833 -

4834

else if (*previous == OP_NOT || *previous == OP_NOTI)

evaluated: *previous == OP_NOT

TRUE	FALSE
yes Evaluation Count:2	yes Evaluation Count:475

partially evaluated: *previous == OP_NOTI

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

0-475

4835 { -

4836

op_type = ((*previous == OP_NOT)? OP_NOTSTAR : OP_NOTSTARI) - OP_STAR;

partially evaluated: (*previous == OP_NOT)

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

0-2

4837

c = previous[1];

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

4838

if (!possessive_quantifier &&

partially evaluated: !possessive_quantifier

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

0-2

4839

repeat_max < 0 &&

partially evaluated: repeat_max < 0

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

0-2

4840

check_auto_possessive(previous, utf, ptr + 1, options, cd))

partially evaluated: check_auto_possessive(previous, utf, ptr + 1, options, cd)

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

0-2

4841 { -

4842

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

4843

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

4844

goto OUTPUT_SINGLE_REPEAT;

never executed: }

4845

executed: goto OUTPUT_SINGLE_REPEAT;

Execution Count:2

4846 } -

4847 -

4848 /* If previous was a character type match (\d or similar), abolish it and -

4849 create a suitable repeat item. The code is shared with single-character -

4850 repeats by setting op_type to add a suitable offset into repeat_type. Note -

4851 the the Unicode property types will be present only when SUPPORT_UCP is -

4852 defined, but we don't wrap the little bits of code here because it just -

4853 makes it horribly messy. */ -

4854 -

4855

else if (*previous < OP_EODN)

evaluated: *previous < OP_EODN

TRUE	FALSE
yes Evaluation Count:365	yes Evaluation Count:110

110-365

4856 { -

4857

pcre_uchar *oldcode;

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

4858

int prop_type, prop_value;

executed (the execution status of this line is deduced): int prop_type, prop_value;

4859

op_type = OP_TYPESTAR - OP_STAR; /* Use type opcodes */

executed (the execution status of this line is deduced): op_type = OP_TYPESTAR - OP_STAR;

4860

c = *previous;

executed (the execution status of this line is deduced): c = *previous;

4861 -

4862

if (!possessive_quantifier &&

partially evaluated: !possessive_quantifier

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

0-365

4863

repeat_max < 0 &&

evaluated: repeat_max < 0

TRUE	FALSE
yes Evaluation Count:341	yes Evaluation Count:24

24-341

4864

check_auto_possessive(previous, utf, ptr + 1, options, cd))

evaluated: check_auto_possessive(previous, utf, ptr + 1, options, cd)

TRUE	FALSE
yes Evaluation Count:10	yes Evaluation Count:331

10-331

4865 { -

4866

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

4867

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

4868

if (*previous == OP_PROP || *previous == OP_NOTPROP)

executed: }

Execution Count:10

4869 -

4870

OUTPUT_SINGLE_REPEAT:

code before this statement executed: OUTPUT_SINGLE_REPEAT:

Execution Count:365

365

4871

evaluated: *previous == OP_PROP

TRUE	FALSE
yes Evaluation Count:4	yes Evaluation Count:377

partially evaluated: *previous == OP_NOTPROP

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

0-377

4872 { -

4873

prop_type = previous[1];

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

4874

prop_value = previous[2];

executed (the execution status of this line is deduced): prop_value = previous[2];

4875

else prop_type = prop_value = -1;

executed: }

Execution Count:4

4876

executed: prop_type = prop_value = -1;

Execution Count:377

377

4877 -

4878

oldcode = code;

executed (the execution status of this line is deduced): oldcode = code;

4879

code = previous; /* Usually overwrite previous item */

executed (the execution status of this line is deduced): code = previous;

4880 -

4881 /* If the maximum is zero then the minimum must also be zero; Perl allows -

4882 this case, so we do too - by simply omitting the item altogether. */ -

4883 -

4884

if (repeat_max == 0) goto END_REPEAT;

never executed: goto END_REPEAT;

partially evaluated: repeat_max == 0

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

0-381

4885 -

4886 /*--------------------------------------------------------------------*/ -

4887 /* This code is obsolete from release 8.00; the restriction was finally -

4888 removed: */ -

4889 -

4890 /* All real repeats make it impossible to handle partial matching (maybe -

4891 one day we will be able to remove this restriction). */ -

4892 -

4893 /* if (repeat_max != 1) cd->external_flags |= PCRE_NOPARTIAL; */ -

4894 /*--------------------------------------------------------------------*/ -

4895 -

4896 /* Combine the op_type with the repeat_type */ -

4897 -

4898

repeat_type += op_type;

executed (the execution status of this line is deduced): repeat_type += op_type;

4899 -

4900 /* A minimum of zero is handled either as the special case * or ?, or as -

4901 an UPTO, with the maximum given. */ -

4902 -

4903

if (repeat_min == 0)

evaluated: repeat_min == 0

TRUE	FALSE
yes Evaluation Count:237	yes Evaluation Count:144

144-237

4904 { -

4905

if (repeat_max == -1) *code++ = OP_STAR + repeat_type;

executed: *code++ = OP_STAR + repeat_type;

Execution Count:237

partially evaluated: repeat_max == -1

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

0-237

4906

else if (repeat_max == 1) *code++ = OP_QUERY + repeat_type;

never executed: *code++ = OP_QUERY + repeat_type;

never evaluated: repeat_max == 1

4907 else -

4908 { -

4909

*code++ = OP_UPTO + repeat_type;

never executed (the execution status of this line is deduced): *code++ = OP_UPTO + repeat_type;

4910

PUT2INC(code, 0, repeat_max);

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

4911

else if (repeat_min == 1)

never executed: }

4912 } -

4913 -

4914 /* A repeat minimum of 1 is optimized into some special cases. If the -

4915 maximum is unlimited, we use OP_PLUS. Otherwise, the original item is -

4916 left in place and, if the maximum is greater than 1, we use OP_UPTO with -

4917 one less than the maximum. */ -

4918 -

4919

evaluated: repeat_min == 1

TRUE	FALSE
yes Evaluation Count:128	yes Evaluation Count:16

16-128

4920 { -

4921

if (repeat_max == -1)

evaluated: repeat_max == -1

TRUE	FALSE
yes Evaluation Count:120	yes Evaluation Count:8

8-120

4922

*code++ = OP_PLUS + repeat_type;

executed: *code++ = OP_PLUS + repeat_type;

Execution Count:120

120

4923 else -

4924 { -

4925

code = oldcode; /* leave previous item in place */

executed (the execution status of this line is deduced): code = oldcode;

4926

if (repeat_max == 1) goto END_REPEAT;

never executed: goto END_REPEAT;

partially evaluated: repeat_max == 1

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

0-8

4927

*code++ = OP_UPTO + repeat_type;

executed (the execution status of this line is deduced): *code++ = OP_UPTO + repeat_type;

4928

PUT2INC(code, 0, repeat_max - 1);

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

4929

*code++ = OP_EXACT + op_type; /* NB EXACT doesn't have repeat_type */

executed: }

Execution Count:8

4930 } -

4931 -

4932 /* The case {n,n} is just an EXACT, while the general case {n,m} is -

4933 handled as an EXACT followed by an UPTO. */ -

4934 -

4935 else -

4936 { -

4937

executed (the execution status of this line is deduced): *code++ = OP_EXACT + op_type;

4938

PUT2INC(code, 0, repeat_min);

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

4939 -

4940 /* If the maximum is unlimited, insert an OP_STAR. Before doing so, -

4941 we have to insert the character for the previous code. For a repeated -

4942 Unicode property match, there are two extra bytes that define the -

4943 required property. In UTF-8 mode, long characters have their length in -

4944 c, with the UTF_LENGTH bit as a flag. */ -

4945 -

4946

if (repeat_max < 0)

partially evaluated: repeat_max < 0

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

0-16

4947 { -

4948 #ifdef SUPPORT_UTF -

4949

if (utf && (c & UTF_LENGTH) != 0)

never evaluated: utf

never evaluated: (c & 0x10000000l) != 0

4950 { -

4951

memcpy(code, utf_chars, IN_UCHARS(c & 7));

never executed (the execution status of this line is deduced): memcpy(code, utf_chars, ((c & 7) << 1));

4952

code += c & 7;

never executed (the execution status of this line is deduced): code += c & 7;

4953

never executed: }

4954 else -

4955 #endif -

4956 { -

4957

*code++ = OP_STAR + repeat_type;

never executed (the execution status of this line is deduced): *code++ = c;

4958

if (prop_type >= 0)

never evaluated: prop_type >= 0

4959 { -

4960

*code++ = prop_type;

never executed (the execution status of this line is deduced): *code++ = prop_type;

4961

*code++ = prop_value;

never executed (the execution status of this line is deduced): *code++ = prop_value;

never executed: }

never executed: }

never executed (the execution status of this line is deduced): *code++ = OP_STAR + repeat_type;

4965

else if (repeat_max != repeat_min)

never executed: }

4966 -

4967 /* Else insert an UPTO if the max is greater than the min, again -

4968 preceded by the character, for the previously inserted code. If the -

4969 UPTO is just for 1 instance, we can use QUERY instead. */ -

4970 -

4971

partially evaluated: repeat_max != repeat_min

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

0-16

4972 { -

4973 #ifdef SUPPORT_UTF -

4974

if (utf && (c & UTF_LENGTH) != 0)

never evaluated: utf

never evaluated: (c & 0x10000000l) != 0

4975 { -

4976

memcpy(code, utf_chars, IN_UCHARS(c & 7));

never executed (the execution status of this line is deduced): memcpy(code, utf_chars, ((c & 7) << 1));

4977

code += c & 7;

never executed (the execution status of this line is deduced): code += c & 7;

4978

never executed: }

4979 else -

4980 #endif -

4981

never executed: *code++ = c;

4982

if (prop_type >= 0)

never evaluated: prop_type >= 0

4983 { -

4984

*code++ = prop_type;

never executed (the execution status of this line is deduced): *code++ = prop_type;

4985

*code++ = prop_value;

never executed (the execution status of this line is deduced): *code++ = prop_value;

4986

repeat_max -= repeat_min;

never executed: }

4987

never executed (the execution status of this line is deduced): repeat_max -= repeat_min;

4988 -

4989

if (repeat_max == 1)

never evaluated: repeat_max == 1

4990 { -

4991

*code++ = OP_QUERY + repeat_type;

never executed (the execution status of this line is deduced): *code++ = OP_QUERY + repeat_type;

4992

*code++ = OP_UPTO + repeat_type;

never executed: }

4993 else -

4994 { -

4995

never executed (the execution status of this line is deduced): *code++ = OP_UPTO + repeat_type;

4996

PUT2INC(code, 0, repeat_max);

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

4997

if (utf && (c & UTF_LENGTH) != 0)

never executed: }

4998 } -

4999 } -

5000 -

5001 /* The character or character type itself comes last in all cases. */ -

5002 -

5003 #ifdef SUPPORT_UTF -

5004

partially evaluated: utf

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

partially evaluated: (c & 0x10000000l) != 0

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

0-381

5005 { -

5006

memcpy(code, utf_chars, IN_UCHARS(c & 7));

never executed (the execution status of this line is deduced): memcpy(code, utf_chars, ((c & 7) << 1));

5007

code += c & 7;

never executed (the execution status of this line is deduced): code += c & 7;

5008

never executed: }

5009 else -

5010 #endif -

5011

executed: *code++ = c;

Execution Count:381

381

5012 -

5013 /* For a repeated Unicode property match, there are two extra bytes that -

5014 define the required property. */ -

5015 -

5016 #ifdef SUPPORT_UCP -

5017

if (prop_type >= 0)

evaluated: prop_type >= 0

TRUE	FALSE
yes Evaluation Count:4	yes Evaluation Count:377

4-377

5018 { -

5019

*code++ = prop_type;

executed (the execution status of this line is deduced): *code++ = prop_type;

5020

*code++ = prop_value;

executed (the execution status of this line is deduced): *code++ = prop_value;

5021

executed: }

Execution Count:4

5022 #endif -

5023

else if (*previous == OP_CLASS ||

executed: }

Execution Count:381

381

5024 -

5025 /* If previous was a character class or a back reference, we put the repeat -

5026 stuff after it, but just skip the item if the repeat was {0,0}. */ -

5027 -

5028

partially evaluated: *previous == OP_CLASS

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

0-110

5029

*previous == OP_NCLASS ||

partially evaluated: *previous == OP_NCLASS

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

0-110

5030

#if defined SUPPORT_UTF || !defined COMPILE_PCRE8

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

5031

*previous == OP_XCLASS ||

evaluated: *previous == OP_XCLASS

TRUE	FALSE
yes Evaluation Count:4	yes Evaluation Count:106

4-106

5032

#endif

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

5033

*previous == OP_REF ||

partially evaluated: *previous == OP_REF

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

0-106

5034

*previous == OP_REFI)

partially evaluated: *previous == OP_REFI

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

0-106

5035 { -

5036

if (repeat_max == 0)

partially evaluated: repeat_max == 0

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

0-4

5037 { -

5038

code = previous;

never executed (the execution status of this line is deduced): code = previous;

5039

goto END_REPEAT;

never executed: goto END_REPEAT;

5040 } -

5041 -

5042 /*--------------------------------------------------------------------*/ -

5043 /* This code is obsolete from release 8.00; the restriction was finally -

5044 removed: */ -

5045 -

5046 /* All real repeats make it impossible to handle partial matching (maybe -

5047 one day we will be able to remove this restriction). */ -

5048 -

5049 /* if (repeat_max != 1) cd->external_flags |= PCRE_NOPARTIAL; */ -

5050 /*--------------------------------------------------------------------*/ -

5051 -

5052

if (repeat_min == 0 && repeat_max == -1)

partially evaluated: repeat_min == 0

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

partially evaluated: repeat_max == -1

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

0-4

5053

*code++ = OP_CRSTAR + repeat_type;

executed: *code++ = OP_CRSTAR + repeat_type;

Execution Count:4

5054

else if (repeat_min == 1 && repeat_max == -1)

never evaluated: repeat_min == 1

never evaluated: repeat_max == -1

5055

*code++ = OP_CRPLUS + repeat_type;

never executed: *code++ = OP_CRPLUS + repeat_type;

5056

else if (repeat_min == 0 && repeat_max == 1)

never evaluated: repeat_min == 0

never evaluated: repeat_max == 1

5057

*code++ = OP_CRQUERY + repeat_type;

never executed: *code++ = OP_CRQUERY + repeat_type;

5058 else -

5059 { -

5060

*code++ = OP_CRRANGE + repeat_type;

never executed (the execution status of this line is deduced): *code++ = OP_CRRANGE + repeat_type;

5061

PUT2INC(code, 0, repeat_min);

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

5062

if (repeat_max == -1) repeat_max = 0; /* 2-byte encoding for max */

never executed: repeat_max = 0;

never evaluated: repeat_max == -1

5063

PUT2INC(code, 0, repeat_max);

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

5064

else if (*previous >= OP_ASSERT && *previous <= OP_COND)

never executed: }

5065 } -

5066 -

5067 /* If previous was a bracket group, we may have to replicate it in certain -

5068 cases. Note that at this point we can encounter only the "basic" bracket -

5069 opcodes such as BRA and CBRA, as this is the place where they get converted -

5070 into the more special varieties such as BRAPOS and SBRA. A test for >= -

5071 OP_ASSERT and <= OP_COND includes ASSERT, ASSERT_NOT, ASSERTBACK, -

5072 ASSERTBACK_NOT, ONCE, BRA, CBRA, and COND. Originally, PCRE did not allow -

5073 repetition of assertions, but now it does, for Perl compatibility. */ -

5074 -

5075

partially evaluated: *previous >= OP_ASSERT

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

partially evaluated: *previous <= OP_COND

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

0-106

5076 { -

5077

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

5078

int len = (int)(code - previous);

executed (the execution status of this line is deduced): int len = (int)(code - previous);

5079

pcre_uchar *bralink = NULL;

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

5080

pcre_uchar *brazeroptr = NULL;

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

5081 -

5082 /* Repeating a DEFINE group is pointless, but Perl allows the syntax, so -

5083 we just ignore the repeat. */ -

5084 -

5085

if (*previous == OP_COND && previous[LINK_SIZE+1] == OP_DEF)

partially evaluated: *previous == OP_COND

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

never evaluated: previous[1 +1] == OP_DEF

0-106

5086

goto END_REPEAT;

never executed: goto END_REPEAT;

5087 -

5088 /* There is no sense in actually repeating assertions. The only potential -

5089 use of repetition is in cases when the assertion is optional. Therefore, -

5090 if the minimum is greater than zero, just ignore the repeat. If the -

5091 maximum is not not zero or one, set it to 1. */ -

5092 -

5093

if (*previous < OP_ONCE) /* Assertion */

partially evaluated: *previous < OP_ONCE

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

0-106

5094 { -

5095

if (repeat_min > 0) goto END_REPEAT;

never executed: goto END_REPEAT;

never evaluated: repeat_min > 0

5096

if (repeat_max < 0 || repeat_max > 1) repeat_max = 1;

never executed: repeat_max = 1;

never evaluated: repeat_max < 0

never evaluated: repeat_max > 1

5097

if (repeat_max <= 1) /* Covers 0, 1, and unlimited */

never executed: }

5098 -

5099 /* The case of a zero minimum is special because of the need to stick -

5100 OP_BRAZERO in front of it, and because the group appears once in the -

5101 data, whereas in other cases it appears the minimum number of times. For -

5102 this reason, it is simplest to treat this case separately, as otherwise -

5103 the code gets far too messy. There are several special subcases when the -

5104 minimum is zero. */ -

5105 -

5106

if (repeat_min == 0)

partially evaluated: repeat_min == 0

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

0-106

5107 { -

5108 /* If the maximum is also zero, we used to just omit the group from the -

5109 output altogether, like this: -

5110 -

5111 ** if (repeat_max == 0) -

5112 ** { -

5113 ** code = previous; -

5114 ** goto END_REPEAT; -

5115 ** } -

5116 -

5117 However, that fails when a group or a subgroup within it is referenced -

5118 as a subroutine from elsewhere in the pattern, so now we stick in -

5119 OP_SKIPZERO in front of it so that it is skipped on execution. As we -

5120 don't have a list of which groups are referenced, we cannot do this -

5121 selectively. -

5122 -

5123 If the maximum is 1 or unlimited, we just have to stick in the BRAZERO -

5124 and do no more at this point. However, we do need to adjust any -

5125 OP_RECURSE calls inside the group that refer to the group itself or any -

5126 internal or forward referenced group, because the offset is from the -

5127 start of the whole regex. Temporarily terminate the pattern while doing -

5128 this. */ -

5129 -

5130

partially evaluated: repeat_max <= 1

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

0-106

5131 { -

5132

adjust_recurse(previous, 1, utf, cd, save_hwm);

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

5133

executed (the execution status of this line is deduced): adjust_recurse(previous, 1, utf, cd, save_hwm);

5134

memmove(previous + 1, previous, IN_UCHARS(len));

executed (the execution status of this line is deduced): memmove(previous + 1, previous, ((len) << 1));

5135

code++;

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

5136

if (repeat_max == 0)

partially evaluated: repeat_max == 0

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

0-106

5137 { -

5138

*previous++ = OP_SKIPZERO;

never executed (the execution status of this line is deduced): *previous++ = OP_SKIPZERO;

5139

goto END_REPEAT;

never executed: goto END_REPEAT;

5140 } -

5141

brazeroptr = previous; /* Save for possessive optimizing */

executed (the execution status of this line is deduced): brazeroptr = previous;

5142

*previous++ = OP_BRAZERO + repeat_type;

executed (the execution status of this line is deduced): *previous++ = OP_BRAZERO + repeat_type;

5143

executed: }

Execution Count:106

106

5144 -

5145 /* If the maximum is greater than 1 and limited, we have to replicate -

5146 in a nested fashion, sticking OP_BRAZERO before each set of brackets. -

5147 The first one has to be handled carefully because it's the original -

5148 copy, which has to be moved up. The remainder can be handled by code -

5149 that is common with the non-zero minimum case below. We have to -

5150 adjust the value or repeat_max, since one less copy is required. Once -

5151 again, we may have to adjust any OP_RECURSE calls inside the group. */ -

5152 -

5153 else -

5154 { -

5155

int offset;

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

5156

adjust_recurse(previous, 2 + LINK_SIZE, utf, cd, save_hwm);

never executed (the execution status of this line is deduced): *code = OP_END;

5157

never executed (the execution status of this line is deduced): adjust_recurse(previous, 2 + 1, utf, cd, save_hwm);

5158

memmove(previous + 2 + LINK_SIZE, previous, IN_UCHARS(len));

never executed (the execution status of this line is deduced): memmove(previous + 2 + 1, previous, ((len) << 1));

5159

code += 2 + LINK_SIZE;

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

5160

*previous++ = OP_BRAZERO + repeat_type;

never executed (the execution status of this line is deduced): *previous++ = OP_BRAZERO + repeat_type;

5161

*previous++ = OP_BRA;

never executed (the execution status of this line is deduced): *previous++ = OP_BRA;

5162 -

5163 /* We chain together the bracket offset fields that have to be -

5164 filled in later when the ends of the brackets are reached. */ -

5165 -

5166

offset = (bralink == NULL)? 0 : (int)(previous - bralink);

never evaluated: (bralink == ((void *)0))

5167

bralink = previous;

never executed (the execution status of this line is deduced): bralink = previous;

5168

PUTINC(previous, 0, offset);

never executed (the execution status of this line is deduced): (previous[0] = (offset)), previous += 1;

5169

never executed: }

5170 -

5171

repeat_max--;

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

5172

executed: }

Execution Count:106

106

5173 -

5174 /* If the minimum is greater than zero, replicate the group as many -

5175 times as necessary, and adjust the maximum to the number of subsequent -

5176 copies that we need. If we set a first char from the group, and didn't -

5177 set a required char, copy the latter from the former. If there are any -

5178 forward reference subroutine calls in the group, there will be entries on -

5179 the workspace list; replicate these with an appropriate increment. */ -

5180 -

5181 else -

5182 { -

5183

if (repeat_min > 1)

never evaluated: repeat_min > 1

5184 { -

5185 /* In the pre-compile phase, we don't actually do the replication. We -

5186 just adjust the length as if we had. Do some paranoid checks for -

5187 potential integer overflow. The INT64_OR_DOUBLE type is a 64-bit -

5188 integer type when available, otherwise double. */ -

5189 -

5190

int delta = (repeat_min - 1)*length_prevgroup;

never evaluated: lengthptr != ((void *)0)

5191 { -

5192

never executed (the execution status of this line is deduced): int delta = (repeat_min - 1)*length_prevgroup;

5193

if ((INT64_OR_DOUBLE)(repeat_min - 1)*

never evaluated: (double)(repeat_min - 1)* (double)length_prevgroup > (double)2147483647

5194

(INT64_OR_DOUBLE)length_prevgroup >

never evaluated: (double)(repeat_min - 1)* (double)length_prevgroup > (double)2147483647

5195

(INT64_OR_DOUBLE)INT_MAX ||

never evaluated: (double)(repeat_min - 1)* (double)length_prevgroup > (double)2147483647

5196

OFLOW_MAX - *lengthptr < delta)

never evaluated: (2147483647 - 20) - *lengthptr < delta

5197 { -

5198

never executed (the execution status of this line is deduced): *errorcodeptr = ERR20;

5199

never executed: goto FAILED;

5200 } -

5201

*lengthptr += delta;

never executed (the execution status of this line is deduced): *lengthptr += delta;

5202

if (groupsetfirstchar && reqchar < 0) reqchar = firstchar;

never executed: }

5203 -

5204 /* This is compiling for real. If there is a set first byte for -

5205 the group, and we have not yet set a "required byte", set it. Make -

5206 sure there is enough workspace for copying forward references before -

5207 doing the copy. */ -

5208 -

5209 else -

5210 { -

5211

never executed: reqchar = firstchar;

never evaluated: groupsetfirstchar

never evaluated: reqchar < 0

5212 -

5213

for (i = 1; i < repeat_min; i++)

never evaluated: i < repeat_min

5214 { -

5215

pcre_uchar *hc;

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

5216

pcre_uchar *this_hwm = cd->hwm;

never executed (the execution status of this line is deduced): pcre_uchar *this_hwm = cd->hwm;

5217

memcpy(code, previous, IN_UCHARS(len));

never executed (the execution status of this line is deduced): memcpy(code, previous, ((len) << 1));

5218 -

5219

while (cd->hwm > cd->start_workspace + cd->workspace_size -

never evaluated: cd->hwm > cd->start_workspace + cd->workspace_size - (100) - (this_hwm - save_hwm)

5220

WORK_SIZE_SAFETY_MARGIN - (this_hwm - save_hwm))

never evaluated: cd->hwm > cd->start_workspace + cd->workspace_size - (100) - (this_hwm - save_hwm)

5221 { -

5222

int save_offset = save_hwm - cd->start_workspace;

never executed (the execution status of this line is deduced): int save_offset = save_hwm - cd->start_workspace;

5223

int this_offset = this_hwm - cd->start_workspace;

never executed (the execution status of this line is deduced): int this_offset = this_hwm - cd->start_workspace;

5224

*errorcodeptr = expand_workspace(cd);

never executed (the execution status of this line is deduced): *errorcodeptr = expand_workspace(cd);

5225

save_hwm = (pcre_uchar *)cd->start_workspace + save_offset;

never executed: goto FAILED;

never evaluated: *errorcodeptr != 0

5226

never executed (the execution status of this line is deduced): save_hwm = (pcre_uchar *)cd->start_workspace + save_offset;

5227

this_hwm = (pcre_uchar *)cd->start_workspace + this_offset;

never executed (the execution status of this line is deduced): this_hwm = (pcre_uchar *)cd->start_workspace + this_offset;

5228

for (hc = save_hwm; hc < this_hwm; hc += LINK_SIZE)

never executed: }

5229 -

5230

never evaluated: hc < this_hwm

5231 { -

5232

PUT(cd->hwm, 0, GET(hc, 0) + len);

never executed (the execution status of this line is deduced): (cd->hwm[0] = ((hc[0]) + len));

5233

cd->hwm += LINK_SIZE;

never executed (the execution status of this line is deduced): cd->hwm += 1;

never executed: }

never executed (the execution status of this line is deduced): save_hwm = this_hwm;

5236

code += len;

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

never executed: }

never executed: }

5239 } -

5240 -

5241

if (repeat_max > 0) repeat_max -= repeat_min;

never executed: repeat_max -= repeat_min;

never evaluated: repeat_max > 0

5242

if (lengthptr != NULL && repeat_max > 0)

never executed: }

5243 -

5244 /* This code is common to both the zero and non-zero minimum cases. If -

5245 the maximum is limited, it replicates the group in a nested fashion, -

5246 remembering the bracket starts on a stack. In the case of a zero minimum, -

5247 the first one was set up above. In all cases the repeat_max now specifies -

5248 the number of additional copies needed. Again, we must remember to -

5249 replicate entries on the forward reference list. */ -

5250 -

5251

if (repeat_max >= 0)

evaluated: repeat_max >= 0

TRUE	FALSE
yes Evaluation Count:100	yes Evaluation Count:6

6-100

5252 { -

5253 /* In the pre-compile phase, we don't actually do the replication. We -

5254 just adjust the length as if we had. For each repetition we must add 1 -

5255 to the length for BRAZERO and for all but the last repetition we must -

5256 add 2 + 2*LINKSIZE to allow for the nesting that occurs. Do some -

5257 paranoid checks to avoid integer overflow. The INT64_OR_DOUBLE type is -

5258 a 64-bit integer type when available, otherwise double. */ -

5259 -

5260

evaluated: lengthptr != ((void *)0)

TRUE	FALSE
yes Evaluation Count:50	yes Evaluation Count:50

partially evaluated: repeat_max > 0

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

0-50

5261 { -

5262

int delta = repeat_max * (length_prevgroup + 1 + 2 + 2*LINK_SIZE) -

never executed (the execution status of this line is deduced): int delta = repeat_max * (length_prevgroup + 1 + 2 + 2*1) -

5263

2 - 2*LINK_SIZE; /* Last one doesn't nest */

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

5264

if ((INT64_OR_DOUBLE)repeat_max *

never evaluated: (double)repeat_max * (double)(length_prevgroup + 1 + 2 + 2*1) > (double)2147483647

5265

(INT64_OR_DOUBLE)(length_prevgroup + 1 + 2 + 2*LINK_SIZE)

never evaluated: (double)repeat_max * (double)(length_prevgroup + 1 + 2 + 2*1) > (double)2147483647

5266

> (INT64_OR_DOUBLE)INT_MAX ||

never evaluated: (double)repeat_max * (double)(length_prevgroup + 1 + 2 + 2*1) > (double)2147483647

5267

OFLOW_MAX - *lengthptr < delta)

never evaluated: (2147483647 - 20) - *lengthptr < delta

5268 { -

5269

never executed (the execution status of this line is deduced): *errorcodeptr = ERR20;

5270

never executed: goto FAILED;

5271 } -

5272

*lengthptr += delta;

never executed (the execution status of this line is deduced): *lengthptr += delta;

5273

else for (i = repeat_max - 1; i >= 0; i--)

never executed: }

5274 -

5275 /* This is compiling for real */ -

5276 -

5277

partially evaluated: i >= 0

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

0-100

5278 { -

5279

pcre_uchar *hc;

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

5280

pcre_uchar *this_hwm = cd->hwm;

never executed (the execution status of this line is deduced): pcre_uchar *this_hwm = cd->hwm;

5281 -

5282

*code++ = OP_BRAZERO + repeat_type;

never executed (the execution status of this line is deduced): *code++ = OP_BRAZERO + repeat_type;

5283 -

5284 /* All but the final copy start a new nesting, maintaining the -

5285 chain of brackets outstanding. */ -

5286 -

5287

if (i != 0)

never evaluated: i != 0

5288 { -

5289

int offset;

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

5290

*code++ = OP_BRA;

never executed (the execution status of this line is deduced): *code++ = OP_BRA;

5291

offset = (bralink == NULL)? 0 : (int)(code - bralink);

never evaluated: (bralink == ((void *)0))

5292

bralink = code;

never executed (the execution status of this line is deduced): bralink = code;

5293

PUTINC(code, 0, offset);

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

5294

memcpy(code, previous, IN_UCHARS(len));

never executed: }

5295 -

5296

never executed (the execution status of this line is deduced): memcpy(code, previous, ((len) << 1));

5297 -

5298 /* Ensure there is enough workspace for forward references before -

5299 copying them. */ -

5300 -

5301

while (cd->hwm > cd->start_workspace + cd->workspace_size -

never evaluated: cd->hwm > cd->start_workspace + cd->workspace_size - (100) - (this_hwm - save_hwm)

5302

WORK_SIZE_SAFETY_MARGIN - (this_hwm - save_hwm))

never evaluated: cd->hwm > cd->start_workspace + cd->workspace_size - (100) - (this_hwm - save_hwm)

5303 { -

5304

int save_offset = save_hwm - cd->start_workspace;

never executed (the execution status of this line is deduced): int save_offset = save_hwm - cd->start_workspace;

5305

int this_offset = this_hwm - cd->start_workspace;

never executed (the execution status of this line is deduced): int this_offset = this_hwm - cd->start_workspace;

5306

*errorcodeptr = expand_workspace(cd);

never executed (the execution status of this line is deduced): *errorcodeptr = expand_workspace(cd);

5307

save_hwm = (pcre_uchar *)cd->start_workspace + save_offset;

never executed: goto FAILED;

never evaluated: *errorcodeptr != 0

5308

never executed (the execution status of this line is deduced): save_hwm = (pcre_uchar *)cd->start_workspace + save_offset;

5309

this_hwm = (pcre_uchar *)cd->start_workspace + this_offset;

never executed (the execution status of this line is deduced): this_hwm = (pcre_uchar *)cd->start_workspace + this_offset;

5310

for (hc = save_hwm; hc < this_hwm; hc += LINK_SIZE)

never executed: }

5311 -

5312

never evaluated: hc < this_hwm

5313 { -

5314

PUT(cd->hwm, 0, GET(hc, 0) + len + ((i != 0)? 2+LINK_SIZE : 1));

never executed (the execution status of this line is deduced): (cd->hwm[0] = ((hc[0]) + len + ((i != 0)? 2+1 : 1)));

5315

cd->hwm += LINK_SIZE;

never executed (the execution status of this line is deduced): cd->hwm += 1;

never executed: }

never executed (the execution status of this line is deduced): save_hwm = this_hwm;

5318

code += len;

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

5319

int offset = (int)(code - bralink + 1);

never executed: }

5320 -

5321 /* Now chain through the pending brackets, and fill in their length -

5322 fields (which are holding the chain links pro tem). */ -

5323 -

5324

while (bralink != NULL)

partially evaluated: bralink != ((void *)0)

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

0-100

5325 { -

5326

int oldlinkoffset;

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

5327

never executed (the execution status of this line is deduced): int offset = (int)(code - bralink + 1);

5328

pcre_uchar *bra = code - offset;

never executed (the execution status of this line is deduced): pcre_uchar *bra = code - offset;

5329

oldlinkoffset = GET(bra, 1);

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

5330

bralink = (oldlinkoffset == 0)? NULL : bralink - oldlinkoffset;

never evaluated: (oldlinkoffset == 0)

5331

*code++ = OP_KET;

never executed (the execution status of this line is deduced): *code++ = OP_KET;

5332

PUTINC(code, 0, offset);

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

5333

PUT(bra, 1, offset);

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

never executed: }

executed: }

Execution Count:100

100

5336 -

5337 /* If the maximum is unlimited, set a repeater in the final copy. For -

5338 ONCE brackets, that's all we need to do. However, possessively repeated -

5339 ONCE brackets can be converted into non-capturing brackets, as the -

5340 behaviour of (?:xx)++ is the same as (?>xx)++ and this saves having to -

5341 deal with possessive ONCEs specially. -

5342 -

5343 Otherwise, when we are doing the actual compile phase, check to see -

5344 whether this group is one that could match an empty string. If so, -

5345 convert the initial operator to the S form (e.g. OP_BRA -> OP_SBRA) so -

5346 that runtime checking can be done. [This check is also applied to ONCE -

5347 groups at runtime, but in a different way.] -

5348 -

5349 Then, if the quantifier was possessive and the bracket is not a -

5350 conditional, we convert the BRA code to the POS form, and the KET code to -

5351 KETRPOS. (It turns out to be convenient at runtime to detect this kind of -

5352 subpattern at both the start and at the end.) The use of special opcodes -

5353 makes it possible to reduce greatly the stack usage in pcre_exec(). If -

5354 the group is preceded by OP_BRAZERO, convert this to OP_BRAPOSZERO. -

5355 -

5356 Then, if the minimum number of matches is 1 or 0, cancel the possessive -

5357 flag so that the default action below, of wrapping everything inside -

5358 atomic brackets, does not happen. When the minimum is greater than 1, -

5359 there will be earlier copies of the group, and so we still have to wrap -

5360 the whole thing. */ -

5361 -

5362 else -

5363 { -

5364

pcre_uchar *ketcode = code - 1 - LINK_SIZE;

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

5365

pcre_uchar *bracode = ketcode - GET(ketcode, 1);

executed (the execution status of this line is deduced): pcre_uchar *bracode = ketcode - (ketcode[1]);

5366 -

5367 /* Convert possessive ONCE brackets to non-capturing */ -

5368 -

5369

if ((*bracode == OP_ONCE || *bracode == OP_ONCE_NC) &&

partially evaluated: *bracode == OP_ONCE

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

partially evaluated: *bracode == OP_ONCE_NC

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

0-6

5370

possessive_quantifier) *bracode = OP_BRA;

never executed: *bracode = OP_BRA;

never evaluated: possessive_quantifier

5371 -

5372 /* For non-possessive ONCE brackets, all we need to do is to -

5373 set the KET. */ -

5374 -

5375

if (*bracode == OP_ONCE || *bracode == OP_ONCE_NC)

partially evaluated: *bracode == OP_ONCE

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

partially evaluated: *bracode == OP_ONCE_NC

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

0-6

5376

*ketcode = OP_KETRMAX + repeat_type;

never executed: *ketcode = OP_KETRMAX + repeat_type;

5377 -

5378 /* Handle non-ONCE brackets and possessive ONCEs (which have been -

5379 converted to non-capturing above). */ -

5380 -

5381 else -

5382 { -

5383 /* In the compile phase, check for empty string matching. */ -

5384 -

5385

pcre_uchar *scode = bracode;

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

TRUE	FALSE
yes Evaluation Count:3	yes Evaluation Count:3

5386 { -

5387

executed (the execution status of this line is deduced): pcre_uchar *scode = bracode;

5388 do -

5389 { -

5390

if (could_be_empty_branch(scode, ketcode, utf, cd))

partially evaluated: could_be_empty_branch(scode, ketcode, utf, cd)

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

0-3

5391 { -

5392

*bracode += OP_SBRA - OP_BRA;

never executed (the execution status of this line is deduced): *bracode += OP_SBRA - OP_BRA;

5393

never executed: break;

5394 } -

5395

scode += GET(scode, 1);

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

5396

while (*scode == OP_ALT);

executed: }

Execution Count:3

5397

partially evaluated: *scode == OP_ALT

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

0-3

5398

if (possessive_quantifier)

executed: }

Execution Count:3

5399 -

5400 /* Handle possessive quantifiers. */ -

5401 -

5402

partially evaluated: possessive_quantifier

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

0-6

5403 { -

5404 /* For COND brackets, we wrap the whole thing in a possessively -

5405 repeated non-capturing bracket, because we have not invented POS -

5406 versions of the COND opcodes. Because we are moving code along, we -

5407 must ensure that any pending recursive references are updated. */ -

5408 -

5409

if (*bracode == OP_COND || *bracode == OP_SCOND)

never evaluated: *bracode == OP_COND

never evaluated: *bracode == OP_SCOND

5410 { -

5411

int nlen = (int)(code - bracode);

never executed (the execution status of this line is deduced): int nlen = (int)(code - bracode);

5412

adjust_recurse(bracode, 1 + LINK_SIZE, utf, cd, save_hwm);

never executed (the execution status of this line is deduced): *code = OP_END;

5413

never executed (the execution status of this line is deduced): adjust_recurse(bracode, 1 + 1, utf, cd, save_hwm);

5414

memmove(bracode + 1 + LINK_SIZE, bracode, IN_UCHARS(nlen));

never executed (the execution status of this line is deduced): memmove(bracode + 1 + 1, bracode, ((nlen) << 1));

5415

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

5416

nlen += 1 + LINK_SIZE;

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

5417

*bracode = OP_BRAPOS;

never executed (the execution status of this line is deduced): *bracode = OP_BRAPOS;

5418

*code++ = OP_KETRPOS;

never executed (the execution status of this line is deduced): *code++ = OP_KETRPOS;

5419

PUTINC(code, 0, nlen);

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

5420

PUT(bracode, 1, nlen);

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

5421

*bracode += 1; /* Switch to xxxPOS opcodes */

never executed: }

5422 -

5423 /* For non-COND brackets, we modify the BRA code and use KETRPOS. */ -

5424 -

5425 else -

5426 { -

5427

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

5428

*ketcode = OP_KETRPOS;

never executed (the execution status of this line is deduced): *ketcode = OP_KETRPOS;

5429

if (brazeroptr != NULL) *brazeroptr = OP_BRAPOSZERO;

never executed: }

5430 -

5431 /* If the minimum is zero, mark it as possessive, then unset the -

5432 possessive flag when the minimum is 0 or 1. */ -

5433 -

5434

never executed: *brazeroptr = OP_BRAPOSZERO;

never evaluated: brazeroptr != ((void *)0)

5435

if (repeat_min < 2) possessive_quantifier = FALSE;

never executed: possessive_quantifier = 0;

never evaluated: repeat_min < 2

5436

else *ketcode = OP_KETRMAX + repeat_type;

never executed: }

5437 -

5438 /* Non-possessive quantifier */ -

5439 -

5440

executed: *ketcode = OP_KETRMAX + repeat_type;

Execution Count:6

5441 } -

5442 } -

5443 } -

5444 -

5445 /* If previous is OP_FAIL, it was generated by an empty class [] in -

5446 JavaScript mode. The other ways in which OP_FAIL can be generated, that is -

5447 by (*FAIL) or (?!) set previous to NULL, which gives a "nothing to repeat" -

5448 error above. We can just ignore the repeat in JS case. */ -

5449 -

5450

else if (*previous == OP_FAIL) goto END_REPEAT;

never executed: goto END_REPEAT;

never evaluated: *previous == OP_FAIL

5451 -

5452 /* Else there's some kind of shambles */ -

5453 -

5454 else -

5455 { -

5456

*errorcodeptr = ERR11;

never executed (the execution status of this line is deduced): *errorcodeptr = ERR11;

5457

if (possessive_quantifier)

never executed: goto FAILED;

5458 } -

5459 -

5460 /* If the character following a repeat is '+', or if certain optimization -

5461 tests above succeeded, possessive_quantifier is TRUE. For some opcodes, -

5462 there are special alternative opcodes for this case. For anything else, we -

5463 wrap the entire repeated item inside OP_ONCE brackets. Logically, the '+' -

5464 notation is just syntactic sugar, taken from Sun's Java package, but the -

5465 special opcodes can optimize it. -

5466 -

5467 Some (but not all) possessively repeated subpatterns have already been -

5468 completely handled in the code just above. For them, possessive_quantifier -

5469 is always FALSE at this stage. -

5470 -

5471 Note that the repeated item starts at tempcode, not at previous, which -

5472 might be the first part of a string whose (former) last char we repeated. -

5473 -

5474 Possessifying an 'exact' quantifier has no effect, so we can ignore it. But -

5475 an 'upto' may follow. We skip over an 'exact' item, and then test the -

5476 length of what remains before proceeding. */ -

5477 -

5478

evaluated: possessive_quantifier

TRUE	FALSE
yes Evaluation Count:10	yes Evaluation Count:481

10-481

5479 { -

5480

int len;

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

5481 -

5482

if (*tempcode == OP_TYPEEXACT)

partially evaluated: *tempcode == OP_TYPEEXACT

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

0-10

5483

tempcode += PRIV(OP_lengths)[*tempcode] +

never executed: tempcode += _pcre16_OP_lengths[*tempcode] + ((tempcode[1 + 1] == OP_PROP || tempcode[1 + 1] == OP_NOTPROP)? 2 : 0);

5484

((tempcode[1 + IMM2_SIZE] == OP_PROP

never executed: tempcode += _pcre16_OP_lengths[*tempcode] + ((tempcode[1 + 1] == OP_PROP || tempcode[1 + 1] == OP_NOTPROP)? 2 : 0);

never evaluated: tempcode[1 + 1] == OP_PROP

5485

|| tempcode[1 + IMM2_SIZE] == OP_NOTPROP)? 2 : 0);

never executed: tempcode += _pcre16_OP_lengths[*tempcode] + ((tempcode[1 + 1] == OP_PROP || tempcode[1 + 1] == OP_NOTPROP)? 2 : 0);

never evaluated: tempcode[1 + 1] == OP_NOTPROP

5486 -

5487

else if (*tempcode == OP_EXACT || *tempcode == OP_NOTEXACT)

partially evaluated: *tempcode == OP_EXACT

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

partially evaluated: *tempcode == OP_NOTEXACT

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

0-10

5488 { -

5489

tempcode += PRIV(OP_lengths)[*tempcode];

never executed (the execution status of this line is deduced): tempcode += _pcre16_OP_lengths[*tempcode];

5490 #ifdef SUPPORT_UTF -

5491

if (utf && HAS_EXTRALEN(tempcode[-1]))

never evaluated: utf

never evaluated: (((tempcode[-1]) & 0xfc00) == 0xd800)

5492

tempcode += GET_EXTRALEN(tempcode[-1]);

never executed: tempcode += 1;

5493 #endif -

5494

len = (int)(code - tempcode);

never executed: }

5495 -

5496

executed (the execution status of this line is deduced): len = (int)(code - tempcode);

5497

if (len > 0) switch (*tempcode)

partially evaluated: len > 0

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

0-10

5498 { -

5499

case OP_STAR: *tempcode = OP_POSSTAR; break;

never executed: break;

5500

case OP_PLUS: *tempcode = OP_POSPLUS; break;

never executed: break;

5501

case OP_QUERY: *tempcode = OP_POSQUERY; break;

never executed: break;

5502

case OP_UPTO: *tempcode = OP_POSUPTO; break;

never executed: break;

5503 -

5504

case OP_STARI: *tempcode = OP_POSSTARI; break;

never executed: break;

5505

case OP_PLUSI: *tempcode = OP_POSPLUSI; break;

never executed: break;

5506

case OP_QUERYI: *tempcode = OP_POSQUERYI; break;

never executed: break;

5507

case OP_UPTOI: *tempcode = OP_POSUPTOI; break;

never executed: break;

5508 -

5509

case OP_NOTSTAR: *tempcode = OP_NOTPOSSTAR; break;

never executed: break;

5510

case OP_NOTPLUS: *tempcode = OP_NOTPOSPLUS; break;

never executed: break;

5511

case OP_NOTQUERY: *tempcode = OP_NOTPOSQUERY; break;

never executed: break;

5512

case OP_NOTUPTO: *tempcode = OP_NOTPOSUPTO; break;

never executed: break;

5513 -

5514

case OP_NOTSTARI: *tempcode = OP_NOTPOSSTARI; break;

never executed: break;

5515

case OP_NOTPLUSI: *tempcode = OP_NOTPOSPLUSI; break;

never executed: break;

5516

case OP_NOTQUERYI: *tempcode = OP_NOTPOSQUERYI; break;

never executed: break;

5517

case OP_NOTUPTOI: *tempcode = OP_NOTPOSUPTOI; break;

never executed: break;

5518 -

5519

case OP_TYPESTAR: *tempcode = OP_TYPEPOSSTAR; break;

executed: break;

Execution Count:6

5520

case OP_TYPEPLUS: *tempcode = OP_TYPEPOSPLUS; break;

executed: break;

Execution Count:4

5521

case OP_TYPEQUERY: *tempcode = OP_TYPEPOSQUERY; break;

never executed: break;

5522

case OP_TYPEUPTO: *tempcode = OP_TYPEPOSUPTO; break;

never executed: break;

5523 -

5524 /* Because we are moving code along, we must ensure that any -

5525 pending recursive references are updated. */ -

5526 -

5527 default: -

5528

adjust_recurse(tempcode, 1 + LINK_SIZE, utf, cd, save_hwm);

never executed (the execution status of this line is deduced): *code = OP_END;

5529

never executed (the execution status of this line is deduced): adjust_recurse(tempcode, 1 + 1, utf, cd, save_hwm);

5530

memmove(tempcode + 1 + LINK_SIZE, tempcode, IN_UCHARS(len));

never executed (the execution status of this line is deduced): memmove(tempcode + 1 + 1, tempcode, ((len) << 1));

5531

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

5532

len += 1 + LINK_SIZE;

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

5533

tempcode[0] = OP_ONCE;

never executed (the execution status of this line is deduced): tempcode[0] = OP_ONCE;

5534

*code++ = OP_KET;

never executed (the execution status of this line is deduced): *code++ = OP_KET;

5535

PUTINC(code, 0, len);

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

5536

PUT(tempcode, 1, len);

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

5537

never executed: break;

never executed: }

executed: }

Execution Count:10

5540 -

5541 /* In all case we no longer have a previous item. We also set the -

5542 "follows varying string" flag for subsequently encountered reqchars if -

5543 it isn't already set and we have just passed a varying length item. */ -

5544 -

5545

END_REPEAT:

code before this statement executed: END_REPEAT:

Execution Count:491

491

5546

cd->req_varyopt |= reqvary;

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

5547

executed (the execution status of this line is deduced): cd->req_varyopt |= reqvary;

5548

executed: break;

Execution Count:491

491

5549 -

5550 -

5551 /* ===================================================================*/ -

5552 /* Start of nested parenthesized sub-expression, or comment or lookahead or -

5553 lookbehind or option setting or condition or all the other extended -

5554 parenthesis forms. */ -

5555 -

5556 case CHAR_LEFT_PARENTHESIS: -

5557

newoptions = options;

executed (the execution status of this line is deduced): newoptions = options;

5558

skipbytes = 0;

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

5559

bravalue = OP_CBRA;

executed (the execution status of this line is deduced): bravalue = OP_CBRA;

5560

save_hwm = cd->hwm;

executed (the execution status of this line is deduced): save_hwm = cd->hwm;

5561

reset_bracount = FALSE;

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

5562 -

5563 /* First deal with various "verbs" that can be introduced by '*'. */ -

5564 -

5565

if (ptr[0] == CHAR_ASTERISK && (ptr[1] == ':'

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

5566

partially evaluated: ptr[0] == '\052'

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

never evaluated: ptr[1] == ':'

0-459

5567

|| (MAX_255(ptr[1]) && ((cd->ctypes[ptr[1]] & ctype_letter) != 0))))

never evaluated: ((ptr[1]) <= 255u)

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

5568 { -

5569

int i, namelen;

never executed (the execution status of this line is deduced): int i, namelen;

5570

int arglen = 0;

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

5571

const char *vn = verbnames;

never executed (the execution status of this line is deduced): const char *vn = verbnames;

5572

const pcre_uchar *name = ptr + 1;

never executed (the execution status of this line is deduced): const pcre_uchar *name = ptr + 1;

5573

const pcre_uchar *arg = NULL;

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

5574

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

5575

while (MAX_255(*ptr) && (cd->ctypes[*ptr] & ctype_letter) != 0) ptr++;

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

5576

never executed: ptr++;

never evaluated: ((*ptr) <= 255u)

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

5577

while (*ptr != 0 && *ptr != CHAR_RIGHT_PARENTHESIS) ptr++;

never executed (the execution status of this line is deduced): namelen = (int)(ptr - name);

5578 -

5579 /* It appears that Perl allows any characters whatsoever, other than -

5580 a closing parenthesis, to appear in arguments, so we no longer insist on -

5581 letters, digits, and underscores. */ -

5582 -

5583

if (*ptr == CHAR_COLON)

never evaluated: *ptr == '\072'

5584 { -

5585

arg = ++ptr;

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

5586

never executed: ptr++;

never evaluated: *ptr != 0

never evaluated: *ptr != '\051'

5587

arglen = (int)(ptr - arg);

never executed (the execution status of this line is deduced): arglen = (int)(ptr - arg);

5588

if (*ptr != CHAR_RIGHT_PARENTHESIS)

never executed: }

5589 -

5590

never evaluated: *ptr != '\051'

5591 { -

5592

*errorcodeptr = ERR60;

never executed (the execution status of this line is deduced): *errorcodeptr = ERR60;

5593

for (i = 0; i < verbcount; i++)

never executed: goto FAILED;

5594 } -

5595 -

5596 /* Scan the table of verb names */ -

5597 -

5598

never evaluated: i < verbcount

5599 { -

5600

if (namelen == verbs[i].len &&

never evaluated: namelen == verbs[i].len

5601

STRNCMP_UC_C8(name, vn, namelen) == 0)

never evaluated: _pcre16_strncmp_uc_c8((name), (vn), (namelen)) == 0

5602 { -

5603 /* Check for open captures before ACCEPT and convert it to -

5604 ASSERT_ACCEPT if in an assertion. */ -

5605 -

5606

if (verbs[i].op == OP_ACCEPT)

never evaluated: verbs[i].op == OP_ACCEPT

5607 { -

5608

open_capitem *oc;

never executed (the execution status of this line is deduced): open_capitem *oc;

5609

if (arglen != 0)

never evaluated: arglen != 0

5610 { -

5611

*errorcodeptr = ERR59;

never executed (the execution status of this line is deduced): *errorcodeptr = ERR59;

5612

for (oc = cd->open_caps; oc != NULL; oc = oc->next)

never executed: goto FAILED;

5613 } -

5614

cd->had_accept = TRUE;

never executed (the execution status of this line is deduced): cd->had_accept = 1;

5615

never evaluated: oc != ((void *)0)

5616 { -

5617

*code++ = OP_CLOSE;

never executed (the execution status of this line is deduced): *code++ = OP_CLOSE;

5618

PUT2INC(code, 0, oc->number);

never executed (the execution status of this line is deduced): code[0] = oc->number, code += 1;

5619

*code++ = (cd->assert_depth > 0)? OP_ASSERT_ACCEPT : OP_ACCEPT;

never executed: }

5620

never evaluated: (cd->assert_depth > 0)

5621 -

5622 /* Do not set firstchar after *ACCEPT */ -

5623

never executed: firstchar = (-1);

never evaluated: firstchar == (-2)

5624

if (verbs[i].op < 0) /* Argument is mandatory */

never executed: }

5625 -

5626 /* Handle other cases with/without an argument */ -

5627 -

5628

else if (arglen == 0)

never evaluated: arglen == 0

5629 { -

5630

never evaluated: verbs[i].op < 0

5631 { -

5632

*errorcodeptr = ERR66;

never executed (the execution status of this line is deduced): *errorcodeptr = ERR66;

5633

if (*code++ == OP_THEN) cd->external_flags |= PCRE_HASTHEN;

never executed: goto FAILED;

5634 } -

5635

*code = verbs[i].op;

never executed (the execution status of this line is deduced): *code = verbs[i].op;

5636

never executed: cd->external_flags |= 0x1000;

never evaluated: *code++ == OP_THEN

5637

if (verbs[i].op_arg < 0) /* Argument is forbidden */

never executed: }

5638 -

5639 else -

5640 { -

5641

never evaluated: verbs[i].op_arg < 0

5642 { -

5643

*errorcodeptr = ERR59;

never executed (the execution status of this line is deduced): *errorcodeptr = ERR59;

5644

if (*code++ == OP_THEN_ARG) cd->external_flags |= PCRE_HASTHEN;

never executed: goto FAILED;

5645 } -

5646

*code = verbs[i].op_arg;

never executed (the execution status of this line is deduced): *code = verbs[i].op_arg;

5647

never executed: cd->external_flags |= 0x1000;

never evaluated: *code++ == OP_THEN_ARG

5648

*code++ = arglen;

never executed (the execution status of this line is deduced): *code++ = arglen;

5649

memcpy(code, arg, IN_UCHARS(arglen));

never executed (the execution status of this line is deduced): memcpy(code, arg, ((arglen) << 1));

5650

code += arglen;

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

5651

*code++ = 0;

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

5652

break; /* Found verb, exit loop */

never executed: }

5653 -

5654

never executed: break;

5655 } -

5656 -

5657

vn += verbs[i].len + 1;

never executed (the execution status of this line is deduced): vn += verbs[i].len + 1;

5658

if (i < verbcount) continue; /* Successfully handled a verb */

never executed: }

5659 -

5660

never executed: continue;

never evaluated: i < verbcount

5661

*errorcodeptr = ERR60; /* Verb not recognized */

never executed (the execution status of this line is deduced): *errorcodeptr = ERR60;

5662

else if (*ptr == CHAR_QUESTION_MARK)

never executed: goto FAILED;

5663 } -

5664 -

5665 /* Deal with the extended parentheses; all are introduced by '?', and the -

5666 appearance of any of them means that this is not a capturing group. */ -

5667 -

5668

evaluated: *ptr == '\077'

TRUE	FALSE
yes Evaluation Count:103	yes Evaluation Count:356

103-356

5669 { -

5670

int i, set, unset, namelen;

executed (the execution status of this line is deduced): int i, set, unset, namelen;

5671

int *optset;

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

5672

const pcre_uchar *name;

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

5673

pcre_uchar *slot;

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

5674 -

5675 switch (*(++ptr)) -

5676 { -

5677 case CHAR_NUMBER_SIGN: /* Comment; skip to ket */ -

5678

while (*ptr != 0 && *ptr != CHAR_RIGHT_PARENTHESIS) ptr++;

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

5679

never executed: ptr++;

never evaluated: *ptr != 0

never evaluated: *ptr != '\051'

5680

if (*ptr == 0)

never evaluated: *ptr == 0

5681 { -

5682

*errorcodeptr = ERR18;

never executed (the execution status of this line is deduced): *errorcodeptr = ERR18;

5683

never executed: goto FAILED;

5684 } -

5685

case CHAR_COLON: /* Non-capturing bracket */

never executed: continue;

5686 -

5687 -

5688 /* ------------------------------------------------------------ */ -

5689 case CHAR_VERTICAL_LINE: /* Reset capture count for each branch */ -

5690

reset_bracount = TRUE;

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

5691 /* Fall through */ -

5692 -

5693 /* ------------------------------------------------------------ */ -

5694

code before this statement executed: case '\072':

Execution Count:8

5695

bravalue = OP_BRA;

executed (the execution status of this line is deduced): bravalue = OP_BRA;

5696

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

5697

bravalue = OP_COND; /* Conditional group */

executed: break;

Execution Count:52

5698 -

5699 -

5700 /* ------------------------------------------------------------ */ -

5701 case CHAR_LEFT_PARENTHESIS: -

5702

executed (the execution status of this line is deduced): bravalue = OP_COND;

5703 -

5704 /* A condition can be an assertion, a number (referring to a numbered -

5705 group), a name (referring to a named group), or 'R', referring to -

5706 recursion. R<digits> and R&name are also permitted for recursion tests. -

5707 -

5708 There are several syntaxes for testing a named group: (?(name)) is used -

5709 by Python; Perl 5.10 onwards uses (?(<name>) or (?('name')). -

5710 -

5711 There are two unfortunate ambiguities, caused by history. (a) 'R' can -

5712 be the recursive thing or the name 'R' (and similarly for 'R' followed -

5713 by digits), and (b) a number could be a name that consists of digits. -

5714 In both cases, we look for a name first; if not found, we try the other -

5715 cases. */ -

5716 -

5717 /* For conditions that are assertions, check the syntax, and then exit -

5718 the switch. This will take control down to where bracketed groups, -

5719 including assertions, are processed. */ -

5720 -

5721

if (ptr[1] == CHAR_QUESTION_MARK && (ptr[2] == CHAR_EQUALS_SIGN ||

partially evaluated: ptr[1] == '\077'

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

never evaluated: ptr[2] == '\075'

0-4

5722

ptr[2] == CHAR_EXCLAMATION_MARK || ptr[2] == CHAR_LESS_THAN_SIGN))

never evaluated: ptr[2] == '\041'

never evaluated: ptr[2] == '\074'

5723

code[1+LINK_SIZE] = OP_CREF;

never executed: break;

5724 -

5725 /* Most other conditions use OP_CREF (a couple change to OP_RREF -

5726 below), and all need to skip 1+IMM2_SIZE bytes at the start of the group. */ -

5727 -

5728

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

5729

skipbytes = 1+IMM2_SIZE;

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

5730

refsign = -1;

executed (the execution status of this line is deduced): refsign = -1;

5731 -

5732 /* Check for a test for recursion in a named group. */ -

5733 -

5734

if (ptr[1] == CHAR_R && ptr[2] == CHAR_AMPERSAND)

partially evaluated: ptr[1] == '\122'

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

partially evaluated: ptr[2] == '\046'

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

0-4

5735 { -

5736

terminator = -1;

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

5737

code[1+LINK_SIZE] = OP_RREF; /* Change the type of test */

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

5738

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

5739

else if (ptr[1] == CHAR_LESS_THAN_SIGN)

never executed: }

5740 -

5741 /* Check for a test for a named group's having been set, using the Perl -

5742 syntax (?(<name>) or (?('name') */ -

5743 -

5744

partially evaluated: ptr[1] == '\074'

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

0-4

5745 { -

5746

terminator = CHAR_GREATER_THAN_SIGN;

never executed (the execution status of this line is deduced): terminator = '\076';

5747

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

5748

else if (ptr[1] == CHAR_APOSTROPHE)

never executed: }

5749

partially evaluated: ptr[1] == '\047'

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

0-4

5750 { -

5751

terminator = CHAR_APOSTROPHE;

never executed (the execution status of this line is deduced): terminator = '\047';

5752

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

5753

if (ptr[1] == CHAR_MINUS || ptr[1] == CHAR_PLUS) refsign = *(++ptr);

never executed: }

5754 else -

5755 { -

5756

terminator = 0;

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

5757

never executed: refsign = *(++ptr);

partially evaluated: ptr[1] == '\055'

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

partially evaluated: ptr[1] == '\053'

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

0-4

5758

if (!MAX_255(ptr[1]) || (cd->ctypes[ptr[1]] & ctype_word) == 0)

executed: }

Execution Count:4

5759 -

5760 /* We now expect to read a name; any thing else is an error */ -

5761 -

5762

partially evaluated: !((ptr[1]) <= 255u)

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

partially evaluated: (cd->ctypes[ptr[1]] & 0x10) == 0

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

0-4

5763 { -

5764

ptr += 1; /* To get the right offset */

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

5765

*errorcodeptr = ERR28;

never executed (the execution status of this line is deduced): *errorcodeptr = ERR28;

5766

while (MAX_255(*ptr) && (cd->ctypes[*ptr] & ctype_word) != 0)

never executed: goto FAILED;

5767 } -

5768 -

5769 /* Read the name, but also get it as a number if it's all digits */ -

5770 -

5771

recno = 0;

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

5772

name = ++ptr;

executed (the execution status of this line is deduced): name = ++ptr;

5773

partially evaluated: ((*ptr) <= 255u)

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

evaluated: (cd->ctypes[*ptr] & 0x10) != 0

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

0-8

5774 { -

5775

if (recno >= 0)

partially evaluated: recno >= 0

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

0-4

5776

recno = (IS_DIGIT(*ptr))? recno * 10 + *ptr - CHAR_0 : -1;

executed: recno = (((*ptr) >= '\060' && (*ptr) <= '\071'))? recno * 10 + *ptr - '\060' : -1;

Execution Count:4

partially evaluated: (*ptr) >= '\060'

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

partially evaluated: (*ptr) <= '\071'

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

0-4

5777

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

5778

executed: }

Execution Count:4

5779

if ((terminator > 0 && *ptr++ != terminator) ||

executed (the execution status of this line is deduced): namelen = (int)(ptr - name);

5780 -

5781

partially evaluated: terminator > 0

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

never evaluated: *ptr++ != terminator

0-4

5782

*ptr++ != CHAR_RIGHT_PARENTHESIS)

partially evaluated: *ptr++ != '\051'

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

0-4

5783 { -

5784

ptr--; /* Error offset */

never executed (the execution status of this line is deduced): ptr--;

5785

*errorcodeptr = ERR26;

never executed (the execution status of this line is deduced): *errorcodeptr = ERR26;

5786

if (lengthptr != NULL) break;

never executed: goto FAILED;

5787 } -

5788 -

5789 /* Do no further checking in the pre-compile phase. */ -

5790 -

5791

executed: break;

Execution Count:2

evaluated: lengthptr != ((void *)0)

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

5792 -

5793 /* In the real compile we do the work of looking for the actual -

5794 reference. If the string started with "+" or "-" we require the rest to -

5795 be digits, in which case recno will be set. */ -

5796 -

5797

if (refsign > 0)

partially evaluated: refsign > 0

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

0-2

5798 { -

5799

if (recno <= 0)

never evaluated: recno <= 0

5800 { -

5801

never executed (the execution status of this line is deduced): *errorcodeptr = ERR58;

5802

recno = (refsign == CHAR_MINUS)?

never executed: goto FAILED;

5803 } -

5804

never evaluated: (refsign == '\055')

5805

cd->bracount - recno + 1 : recno +cd->bracount;

never executed (the execution status of this line is deduced): cd->bracount - recno + 1 : recno +cd->bracount;

5806

if (recno <= 0 || recno > cd->final_bracount)

never evaluated: recno <= 0

never evaluated: recno > cd->final_bracount

5807 { -

5808

never executed (the execution status of this line is deduced): *errorcodeptr = ERR15;

5809

never executed: goto FAILED;

5810 } -

5811

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

5812

never executed: break;

5813 } -

5814 -

5815 /* Otherwise (did not start with "+" or "-"), start by looking for the -

5816 name. If we find a name, add one to the opcode to change OP_CREF or -

5817 OP_RREF into OP_NCREF or OP_NRREF. These behave exactly the same, -

5818 except they record that the reference was originally to a name. The -

5819 information is used to check duplicate names. */ -

5820 -

5821

slot = cd->name_table;

executed (the execution status of this line is deduced): slot = cd->name_table;

5822

if (STRNCMP_UC_UC(name, slot+IMM2_SIZE, namelen) == 0) break;

partially evaluated: i < cd->names_found

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

0-2

5823 { -

5824

never executed: break;

never evaluated: _pcre16_strncmp_uc_uc((name), (slot+1), (namelen)) == 0

5825

slot += cd->name_entry_size;

never executed (the execution status of this line is deduced): slot += cd->name_entry_size;

5826

never executed: }

5827 -

5828 /* Found a previous named subpattern */ -

5829 -

5830

if (i < cd->names_found)

partially evaluated: i < cd->names_found

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

0-2

5831 { -

5832

recno = GET2(slot, 0);

never executed (the execution status of this line is deduced): recno = slot[0];

5833

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

5834

code[1+LINK_SIZE]++;

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

5835

else if ((i = find_parens(cd, name, namelen,

never executed: }

5836 -

5837 /* Search the pattern for a forward reference */ -

5838 -

5839

partially evaluated: (i = find_parens(cd, name, namelen, (options & 0x00000008) != 0, utf)) > 0

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

0-2

5840

(options & PCRE_EXTENDED) != 0, utf)) > 0)

partially evaluated: (i = find_parens(cd, name, namelen, (options & 0x00000008) != 0, utf)) > 0

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

0-2

5841 { -

5842

PUT2(code, 2+LINK_SIZE, i);

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

5843

code[1+LINK_SIZE]++;

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

5844

else if (terminator != 0)

never executed: }

5845 -

5846 /* If terminator == 0 it means that the name followed directly after -

5847 the opening parenthesis [e.g. (?(abc)...] and in this case there are -

5848 some further alternatives to try. For the cases where terminator != 0 -

5849 [things like (?(<name>... or (?('name')... or (?(R&name)... ] we have -

5850 now checked all the possibilities, so give an error. */ -

5851 -

5852

partially evaluated: terminator != 0

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

0-2

5853 { -

5854

never executed (the execution status of this line is deduced): *errorcodeptr = ERR15;

5855

else if (*name == CHAR_R)

never executed: goto FAILED;

5856 } -

5857 -

5858 /* Check for (?(R) for recursion. Allow digits after R to specify a -

5859 specific group number. */ -

5860 -

5861

partially evaluated: *name == '\122'

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

0-2

5862 { -

5863

recno = 0;

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

5864

for (i = 1; i < namelen; i++)

partially evaluated: i < namelen

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

0-2

5865 { -

5866

if (!IS_DIGIT(name[i]))

never evaluated: (name[i]) >= '\060'

never evaluated: (name[i]) <= '\071'

5867 { -

5868

never executed (the execution status of this line is deduced): *errorcodeptr = ERR15;

5869

recno = recno * 10 + name[i] - CHAR_0;

never executed: goto FAILED;

5870 } -

5871

never executed (the execution status of this line is deduced): recno = recno * 10 + name[i] - '\060';

5872

if (recno == 0) recno = RREF_ANY;

never executed: }

5873

executed: recno = 0xffff;

Execution Count:2

partially evaluated: recno == 0

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

0-2

5874

code[1+LINK_SIZE] = OP_RREF; /* Change test type */

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

5875

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

5876

else if (namelen == 6 && STRNCMP_UC_C8(name, STRING_DEFINE, 6) == 0)

executed: }

Execution Count:2

5877 -

5878 /* Similarly, check for the (?(DEFINE) "condition", which is always -

5879 false. */ -

5880 -

5881

never evaluated: namelen == 6

never evaluated: _pcre16_strncmp_uc_c8((name), ("\104" "\105" "\106" "\111" "\116" "\105"), (6)) == 0

5882 { -

5883

code[1+LINK_SIZE] = OP_DEF;

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

5884

skipbytes = 1;

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

5885

else if (recno > 0 && recno <= cd->final_bracount)

never executed: }

5886 -

5887 /* Check for the "name" actually being a subpattern number. We are -

5888 in the second pass here, so final_bracount is set. */ -

5889 -

5890

never evaluated: recno > 0

never evaluated: recno <= cd->final_bracount

5891 { -

5892

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

5893

*errorcodeptr = (recno == 0)? ERR35: ERR15;

never executed: }

5894 -

5895 /* Either an unidentified subpattern, or a reference to (?(0) */ -

5896 -

5897 else -

5898 { -

5899

never evaluated: (recno == 0)

5900

never executed: goto FAILED;

5901 } -

5902

executed: break;

Execution Count:2

5903 -

5904 -

5905 /* ------------------------------------------------------------ */ -

5906 case CHAR_EQUALS_SIGN: /* Positive lookahead */ -

5907

bravalue = OP_ASSERT;

never executed (the execution status of this line is deduced): bravalue = OP_ASSERT;

5908

never executed (the execution status of this line is deduced): cd->assert_depth += 1;

5909

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

5910

never executed: break;

5911 -

5912 -

5913 /* ------------------------------------------------------------ */ -

5914 case CHAR_EXCLAMATION_MARK: /* Negative lookahead */ -

5915

if (*ptr == CHAR_RIGHT_PARENTHESIS) /* Optimize (?!) */

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

5916

partially evaluated: *ptr == '\051'

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

0-8

5917 { -

5918

*code++ = OP_FAIL;

never executed (the execution status of this line is deduced): *code++ = OP_FAIL;

5919

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

5920

bravalue = OP_ASSERT_NOT;

never executed: continue;

5921 } -

5922

executed (the execution status of this line is deduced): bravalue = OP_ASSERT_NOT;

5923

executed (the execution status of this line is deduced): cd->assert_depth += 1;

5924

bravalue = OP_ASSERTBACK;

executed: break;

Execution Count:8

5925 -

5926 -

5927 /* ------------------------------------------------------------ */ -

5928 case CHAR_LESS_THAN_SIGN: /* Lookbehind or named define */ -

5929 switch (ptr[1]) -

5930 { -

5931 case CHAR_EQUALS_SIGN: /* Positive lookbehind */ -

5932

never executed (the execution status of this line is deduced): bravalue = OP_ASSERTBACK;

5933

never executed (the execution status of this line is deduced): cd->assert_depth += 1;

5934

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

5935

bravalue = OP_ASSERTBACK_NOT;

never executed: break;

5936 -

5937 case CHAR_EXCLAMATION_MARK: /* Negative lookbehind */ -

5938

never executed (the execution status of this line is deduced): bravalue = OP_ASSERTBACK_NOT;

5939

never executed (the execution status of this line is deduced): cd->assert_depth += 1;

5940

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

5941

if (MAX_255(ptr[1]) && (cd->ctypes[ptr[1]] & ctype_word) != 0)

never executed: break;

5942 -

5943 default: /* Could be name define, else bad */ -

5944

partially evaluated: ((ptr[1]) <= 255u)

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

partially evaluated: (cd->ctypes[ptr[1]] & 0x10) != 0

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

0-31

5945

goto DEFINE_NAME;

executed: goto DEFINE_NAME;

Execution Count:31

5946

ptr++; /* Correct offset for error */

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

5947

*errorcodeptr = ERR24;

never executed (the execution status of this line is deduced): *errorcodeptr = ERR24;

5948

never executed: goto FAILED;

5949 } -

5950

never executed: break;

5951 -

5952 -

5953 /* ------------------------------------------------------------ */ -

5954 case CHAR_GREATER_THAN_SIGN: /* One-time brackets */ -

5955

bravalue = OP_ONCE;

never executed (the execution status of this line is deduced): bravalue = OP_ONCE;

5956

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

5957

previous_callout = code; /* Save for later completion */

never executed: break;

5958 -

5959 -

5960 /* ------------------------------------------------------------ */ -

5961 case CHAR_C: /* Callout - may be followed by digits; */ -

5962

never executed (the execution status of this line is deduced): previous_callout = code;

5963

after_manual_callout = 1; /* Skip one item before completing */

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

5964

*code++ = OP_CALLOUT;

never executed (the execution status of this line is deduced): *code++ = OP_CALLOUT;

5965 { -

5966

int n = 0;

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

5967

n = n * 10 + *ptr++ - CHAR_0;

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

5968

while(IS_DIGIT(*ptr))

never evaluated: (*ptr) >= '\060'

never evaluated: (*ptr) <= '\071'

5969

never executed: n = n * 10 + *ptr++ - '\060';

5970

if (*ptr != CHAR_RIGHT_PARENTHESIS)

never evaluated: *ptr != '\051'

5971 { -

5972

*errorcodeptr = ERR39;

never executed (the execution status of this line is deduced): *errorcodeptr = ERR39;

5973

never executed: goto FAILED;

5974 } -

5975

if (n > 255)

never evaluated: n > 255

5976 { -

5977

*errorcodeptr = ERR38;

never executed (the execution status of this line is deduced): *errorcodeptr = ERR38;

5978

PUT(code, 0, (int)(ptr - cd->start_pattern + 1)); /* Pattern offset */

never executed: goto FAILED;

5979 } -

5980

*code++ = n;

never executed (the execution status of this line is deduced): *code++ = n;

5981

never executed (the execution status of this line is deduced): (code[0] = ((int)(ptr - cd->start_pattern + 1)));

5982

PUT(code, LINK_SIZE, 0); /* Default length */

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

5983

code += 2 * LINK_SIZE;

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

5984 } -

5985

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

5986

if (*(++ptr) == CHAR_EQUALS_SIGN ||

never executed: continue;

5987 -

5988 -

5989 /* ------------------------------------------------------------ */ -

5990 case CHAR_P: /* Python-style named subpattern handling */ -

5991

never evaluated: *(++ptr) == '\075'

5992

*ptr == CHAR_GREATER_THAN_SIGN) /* Reference or recursion */

never evaluated: *ptr == '\076'

5993 { -

5994

is_recurse = *ptr == CHAR_GREATER_THAN_SIGN;

never executed (the execution status of this line is deduced): is_recurse = *ptr == '\076';

5995

terminator = CHAR_RIGHT_PARENTHESIS;

never executed (the execution status of this line is deduced): terminator = '\051';

5996

goto NAMED_REF_OR_RECURSE;

never executed: goto NAMED_REF_OR_RECURSE;

5997 } -

5998

else if (*ptr != CHAR_LESS_THAN_SIGN) /* Test for Python-style defn */

never evaluated: *ptr != '\074'

5999 { -

6000

*errorcodeptr = ERR41;

never executed (the execution status of this line is deduced): *errorcodeptr = ERR41;

6001

DEFINE_NAME: /* Come here from (?< handling */

never executed: goto FAILED;

6002 } -

6003 /* Fall through to handle (?P< as (?< is handled */ -

6004 -

6005 -

6006 /* ------------------------------------------------------------ */ -

6007

code before this statement never executed: DEFINE_NAME:

6008 case CHAR_APOSTROPHE: -

6009 { -

6010

terminator = (*ptr == CHAR_LESS_THAN_SIGN)?

partially evaluated: (*ptr == '\074')

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

0-31

6011

CHAR_GREATER_THAN_SIGN : CHAR_APOSTROPHE;

executed (the execution status of this line is deduced): '\076' : '\047';

6012

name = ++ptr;

executed (the execution status of this line is deduced): name = ++ptr;

6013 -

6014

while (MAX_255(*ptr) && (cd->ctypes[*ptr] & ctype_word) != 0) ptr++;

executed: ptr++;

Execution Count:158

partially evaluated: ((*ptr) <= 255u)

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

evaluated: (cd->ctypes[*ptr] & 0x10) != 0

TRUE	FALSE
yes Evaluation Count:158	yes Evaluation Count:31

0-189

6015

executed (the execution status of this line is deduced): namelen = (int)(ptr - name);

6016 -

6017 /* In the pre-compile phase, just do a syntax check. */ -

6018 -

6019

evaluated: lengthptr != ((void *)0)

TRUE	FALSE
yes Evaluation Count:16	yes Evaluation Count:15

15-16

6020 { -

6021

if (*ptr != terminator)

evaluated: *ptr != terminator

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

1-15

6022 { -

6023

*errorcodeptr = ERR42;

executed (the execution status of this line is deduced): *errorcodeptr = ERR42;

6024

if (cd->names_found >= MAX_NAME_COUNT)

executed: goto FAILED;

Execution Count:1

6025 } -

6026

partially evaluated: cd->names_found >= 10000

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

0-15

6027 { -

6028

*errorcodeptr = ERR49;

never executed (the execution status of this line is deduced): *errorcodeptr = ERR49;

6029

if (namelen + IMM2_SIZE + 1 > cd->name_entry_size)

never executed: goto FAILED;

6030 } -

6031

evaluated: namelen + 1 + 1 > cd->name_entry_size

TRUE	FALSE
yes Evaluation Count:10	yes Evaluation Count:5

5-10

6032 { -

6033

cd->name_entry_size = namelen + IMM2_SIZE + 1;

executed (the execution status of this line is deduced): cd->name_entry_size = namelen + 1 + 1;

6034

if (namelen > MAX_NAME_SIZE)

partially evaluated: namelen > 32

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

0-10

6035 { -

6036

*errorcodeptr = ERR48;

never executed (the execution status of this line is deduced): *errorcodeptr = ERR48;

6037

never executed: goto FAILED;

6038 } -

6039

executed: }

Execution Count:10

6040

executed: }

Execution Count:15

6041 -

6042 /* In the real compile, create the entry in the table, maintaining -

6043 alphabetical order. Duplicate names for different numbers are -

6044 permitted only if PCRE_DUPNAMES is set. Duplicate names for the same -

6045 number are always OK. (An existing number can be re-used if (?| -

6046 appears in the pattern.) In either event, a duplicate name results in -

6047 a duplicate entry in the table, even if the number is the same. This -

6048 is because the number of names, and hence the table size, is computed -

6049 in the pre-compile, and it affects various numbers and pointers which -

6050 would all have to be modified, and the compiled code moved down, if -

6051 duplicates with the same number were omitted from the table. This -

6052 doesn't seem worth the hassle. However, *different* names for the -

6053 same number are not permitted. */ -

6054 -

6055 else -

6056 { -

6057

BOOL dupname = FALSE;

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

6058

slot = cd->name_table;

executed (the execution status of this line is deduced): slot = cd->name_table;

6059 -

6060

int crc = memcmp(name, slot+IMM2_SIZE, IN_UCHARS(namelen));

evaluated: i < cd->names_found

TRUE	FALSE
yes Evaluation Count:5	yes Evaluation Count:14

5-14

6061 { -

6062

executed (the execution status of this line is deduced): int crc = memcmp(name, slot+1, ((namelen) << 1));

6063

if (crc == 0)

partially evaluated: crc == 0

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

0-5

6064 { -

6065

if (slot[IMM2_SIZE+namelen] == 0)

never evaluated: slot[1 +namelen] == 0

6066 { -

6067

if (GET2(slot, 0) != cd->bracount + 1 &&

never evaluated: slot[0] != cd->bracount + 1

6068

(options & PCRE_DUPNAMES) == 0)

never evaluated: (options & 0x00080000) == 0

6069 { -

6070

*errorcodeptr = ERR43;

never executed (the execution status of this line is deduced): *errorcodeptr = ERR43;

6071

else crc = -1; /* Current name is a substring */

never executed: goto FAILED;

6072 } -

6073

else dupname = TRUE;

never executed: dupname = 1;

6074 } -

6075

never executed: crc = -1;

6076 } -

6077 -

6078 /* Make space in the table and break the loop for an earlier -

6079 name. For a duplicate or later name, carry on. We do this for -

6080 duplicates so that in the simple case (when ?(| is not used) they -

6081 are in order of their numbers. */ -

6082 -

6083

if (crc < 0)

evaluated: crc < 0

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

1-4

6084 { -

6085

memmove(slot + cd->name_entry_size, slot,

executed (the execution status of this line is deduced): memmove(slot + cd->name_entry_size, slot,

6086

IN_UCHARS((cd->names_found - i) * cd->name_entry_size));

executed (the execution status of this line is deduced): (((cd->names_found - i) * cd->name_entry_size) << 1));

6087

slot += cd->name_entry_size;

executed: break;

Execution Count:1

6088 } -

6089 -

6090 /* Continue the loop for a later or duplicate name */ -

6091 -

6092

executed (the execution status of this line is deduced): slot += cd->name_entry_size;

6093

pcre_uchar *cslot = cd->name_table;

executed: }

Execution Count:4

6094 -

6095 /* For non-duplicate names, check for a duplicate number before -

6096 adding the new name. */ -

6097 -

6098

if (!dupname)

partially evaluated: !dupname

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

0-15

6099 { -

6100

executed (the execution status of this line is deduced): pcre_uchar *cslot = cd->name_table;

6101

if (GET2(cslot, 0) == cd->bracount + 1)

evaluated: i < cd->names_found

TRUE	FALSE
yes Evaluation Count:6	yes Evaluation Count:15

6-15

6102 { -

6103

if (cslot != slot)

evaluated: cslot != slot

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

1-5

6104 { -

6105

partially evaluated: cslot[0] == cd->bracount + 1

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

0-5

6106 { -

6107

*errorcodeptr = ERR65;

never executed (the execution status of this line is deduced): *errorcodeptr = ERR65;

6108

never executed: goto FAILED;

6109 } -

6110

cslot += cd->name_entry_size;

executed: }

Execution Count:5

6111

else i--;

executed: i--;

Execution Count:1

6112

executed (the execution status of this line is deduced): cslot += cd->name_entry_size;

6113

executed: }

Execution Count:6

6114

PUT2(slot, 0, cd->bracount + 1);

executed: }

Execution Count:15

6115 -

6116

executed (the execution status of this line is deduced): slot[0] = cd->bracount + 1;

6117

memcpy(slot + IMM2_SIZE, name, IN_UCHARS(namelen));

executed (the execution status of this line is deduced): memcpy(slot + 1, name, ((namelen) << 1));

6118

slot[IMM2_SIZE + namelen] = 0;

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

6119

ptr++; /* Move past > or ' */

executed: }

Execution Count:15

6120 } -

6121 -

6122 /* In both pre-compile and compile, count the number of names we've -

6123 encountered. */ -

6124 -

6125

cd->names_found++;

executed (the execution status of this line is deduced): cd->names_found++;

6126

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

6127

goto NUMBERED_GROUP;

executed: goto NUMBERED_GROUP;

Execution Count:30

6128 -

6129 -

6130 /* ------------------------------------------------------------ */ -

6131 case CHAR_AMPERSAND: /* Perl recursion/subroutine syntax */ -

6132

terminator = CHAR_RIGHT_PARENTHESIS;

never executed (the execution status of this line is deduced): terminator = '\051';

6133

is_recurse = TRUE;

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

6134 /* Fall through */ -

6135 -

6136 /* We come here from the Python syntax above that handles both -

6137 references (?P=name) and recursion (?P>name), as well as falling -

6138 through from the Perl recursion syntax (?&name). We also come here from -

6139 the Perl \k<name> or \k'name' back reference syntax and the \k{name} -

6140 .NET syntax, and the Oniguruma \g<...> and \g'...' subroutine syntax. */ -

6141 -

6142

NAMED_REF_OR_RECURSE:

code before this statement never executed: NAMED_REF_OR_RECURSE:

6143

name = ++ptr;

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

6144

while (MAX_255(*ptr) && (cd->ctypes[*ptr] & ctype_word) != 0) ptr++;

never executed: ptr++;

never evaluated: ((*ptr) <= 255u)

never evaluated: (cd->ctypes[*ptr] & 0x10) != 0

6145

never executed (the execution status of this line is deduced): namelen = (int)(ptr - name);

6146 -

6147 /* In the pre-compile phase, do a syntax check. We used to just set -

6148 a dummy reference number, because it was not used in the first pass. -

6149 However, with the change of recursive back references to be atomic, -

6150 we have to look for the number so that this state can be identified, as -

6151 otherwise the incorrect length is computed. If it's not a backwards -

6152 reference, the dummy number will do. */ -

6153 -

6154

never evaluated: lengthptr != ((void *)0)

6155 { -

6156

const pcre_uchar *temp;

never executed (the execution status of this line is deduced): const pcre_uchar *temp;

6157 -

6158

if (namelen == 0)

never evaluated: namelen == 0

6159 { -

6160

*errorcodeptr = ERR62;

never executed (the execution status of this line is deduced): *errorcodeptr = ERR62;

6161

never executed: goto FAILED;

6162 } -

6163

if (*ptr != terminator)

never evaluated: *ptr != terminator

6164 { -

6165

*errorcodeptr = ERR42;

never executed (the execution status of this line is deduced): *errorcodeptr = ERR42;

6166

if (namelen > MAX_NAME_SIZE)

never executed: goto FAILED;

6167 } -

6168

never evaluated: namelen > 32

6169 { -

6170

*errorcodeptr = ERR48;

never executed (the execution status of this line is deduced): *errorcodeptr = ERR48;

6171

recno = find_parens(cd, name, namelen,

never executed: goto FAILED;

6172 } -

6173 -

6174 /* The name table does not exist in the first pass, so we cannot -

6175 do a simple search as in the code below. Instead, we have to scan the -

6176 pattern to find the number. It is important that we scan it only as -

6177 far as we have got because the syntax of named subpatterns has not -

6178 been checked for the rest of the pattern, and find_parens() assumes -

6179 correct syntax. In any case, it's a waste of resources to scan -

6180 further. We stop the scan at the current point by temporarily -

6181 adjusting the value of cd->endpattern. */ -

6182 -

6183

temp = cd->end_pattern;

never executed (the execution status of this line is deduced): temp = cd->end_pattern;

6184

cd->end_pattern = ptr;

never executed (the execution status of this line is deduced): cd->end_pattern = ptr;

6185

never executed (the execution status of this line is deduced): recno = find_parens(cd, name, namelen,

6186

(options & PCRE_EXTENDED) != 0, utf);

never executed (the execution status of this line is deduced): (options & 0x00000008) != 0, utf);

6187

cd->end_pattern = temp;

never executed (the execution status of this line is deduced): cd->end_pattern = temp;

6188

if (recno < 0) recno = 0; /* Forward ref; set dummy number */

never executed: recno = 0;

never evaluated: recno < 0

6189

never executed: }

6190 -

6191 /* In the real compile, seek the name in the table. We check the name -

6192 first, and then check that we have reached the end of the name in the -

6193 table. That way, if the name that is longer than any in the table, -

6194 the comparison will fail without reading beyond the table entry. */ -

6195 -

6196 else -

6197 { -

6198

slot = cd->name_table;

never executed (the execution status of this line is deduced): slot = cd->name_table;

6199

if (STRNCMP_UC_UC(name, slot+IMM2_SIZE, namelen) == 0 &&

never evaluated: i < cd->names_found

6200 { -

6201

never evaluated: _pcre16_strncmp_uc_uc((name), (slot+1), (namelen)) == 0

6202

slot[IMM2_SIZE+namelen] == 0)

never evaluated: slot[1 +namelen] == 0

6203

slot += cd->name_entry_size;

never executed: break;

6204

never executed (the execution status of this line is deduced): slot += cd->name_entry_size;

6205

if (i < cd->names_found) /* Back reference */

never executed: }

6206 -

6207

never evaluated: i < cd->names_found

6208 { -

6209

recno = GET2(slot, 0);

never executed (the execution status of this line is deduced): recno = slot[0];

6210

else if ((recno = /* Forward back reference */

never executed: }

6211

never evaluated: (recno = find_parens(cd, name, namelen, (options & 0x00000008) != 0, utf)) <= 0

6212

find_parens(cd, name, namelen,

never evaluated: (recno = find_parens(cd, name, namelen, (options & 0x00000008) != 0, utf)) <= 0

6213

(options & PCRE_EXTENDED) != 0, utf)) <= 0)

never evaluated: (recno = find_parens(cd, name, namelen, (options & 0x00000008) != 0, utf)) <= 0

6214 { -

6215

never executed (the execution status of this line is deduced): *errorcodeptr = ERR15;

6216

if (is_recurse) goto HANDLE_RECURSION;

never executed: goto FAILED;

6217 } -

6218 } -

6219 -

6220 /* In both phases, we can now go to the code than handles numerical -

6221 recursion or backreferences. */ -

6222 -

6223

never executed: goto HANDLE_RECURSION;

never evaluated: is_recurse

6224

else goto HANDLE_REFERENCE;

never executed: goto HANDLE_REFERENCE;

6225 -

6226 -

6227 /* ------------------------------------------------------------ */ -

6228 case CHAR_R: /* Recursion */ -

6229

ptr++; /* Same as (?0) */

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

6230 /* Fall through */ -

6231 -

6232 -

6233 /* ------------------------------------------------------------ */ -

6234

case CHAR_MINUS: case CHAR_PLUS: /* Recursion or subroutine */

code before this statement executed: case '\055':

Execution Count:4

6235 case CHAR_0: case CHAR_1: case CHAR_2: case CHAR_3: case CHAR_4: -

6236 case CHAR_5: case CHAR_6: case CHAR_7: case CHAR_8: case CHAR_9: -

6237 { -

6238

const pcre_uchar *called;

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

6239

terminator = CHAR_RIGHT_PARENTHESIS;

executed (the execution status of this line is deduced): terminator = '\051';

6240 -

6241 /* Come here from the \g<...> and \g'...' code (Oniguruma -

6242 compatibility). However, the syntax has been checked to ensure that -

6243 the ... are a (signed) number, so that neither ERR63 nor ERR29 will -

6244 be called on this path, nor with the jump to OTHER_CHAR_AFTER_QUERY -

6245 ever be taken. */ -

6246 -

6247

HANDLE_NUMERICAL_RECURSION:

code before this statement executed: HANDLE_NUMERICAL_RECURSION:

Execution Count:8

6248 -

6249

if ((refsign = *ptr) == CHAR_PLUS)

partially evaluated: (refsign = *ptr) == '\053'

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

0-8

6250 { -

6251

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

6252

if (!IS_DIGIT(*ptr))

never evaluated: (*ptr) >= '\060'

never evaluated: (*ptr) <= '\071'

6253 { -

6254

*errorcodeptr = ERR63;

never executed (the execution status of this line is deduced): *errorcodeptr = ERR63;

6255

never executed: goto FAILED;

6256 } -

6257

else if (refsign == CHAR_MINUS)

never executed: }

6258

partially evaluated: refsign == '\055'

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

0-8

6259 { -

6260

if (!IS_DIGIT(ptr[1]))

never evaluated: (ptr[1]) >= '\060'

never evaluated: (ptr[1]) <= '\071'

6261

goto OTHER_CHAR_AFTER_QUERY;

never executed: goto OTHER_CHAR_AFTER_QUERY;

6262

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

6263

recno = recno * 10 + *ptr++ - CHAR_0;

never executed: }

6264 -

6265

recno = 0;

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

6266

while(IS_DIGIT(*ptr))

evaluated: (*ptr) >= '\060'

TRUE	FALSE
yes Evaluation Count:4	yes Evaluation Count:8

partially evaluated: (*ptr) <= '\071'

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

0-8

6267

executed: recno = recno * 10 + *ptr++ - '\060';

Execution Count:4

6268 -

6269

if (*ptr != terminator)

partially evaluated: *ptr != terminator

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

0-8

6270 { -

6271

*errorcodeptr = ERR29;

never executed (the execution status of this line is deduced): *errorcodeptr = ERR29;

6272

if (refsign == CHAR_MINUS)

never executed: goto FAILED;

6273 } -

6274 -

6275

partially evaluated: refsign == '\055'

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

0-8

6276 { -

6277

if (recno == 0)

never evaluated: recno == 0

6278 { -

6279

never executed (the execution status of this line is deduced): *errorcodeptr = ERR58;

6280

recno = cd->bracount - recno + 1;

never executed: goto FAILED;

6281 } -

6282

never executed (the execution status of this line is deduced): recno = cd->bracount - recno + 1;

6283

if (recno <= 0)

never evaluated: recno <= 0

6284 { -

6285

never executed (the execution status of this line is deduced): *errorcodeptr = ERR15;

6286

never executed: goto FAILED;

6287 } -

6288

else if (refsign == CHAR_PLUS)

never executed: }

6289

partially evaluated: refsign == '\053'

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

0-8

6290 { -

6291

if (recno == 0)

never evaluated: recno == 0

6292 { -

6293

never executed (the execution status of this line is deduced): *errorcodeptr = ERR58;

6294

never executed: goto FAILED;

6295 } -

6296

recno += cd->bracount;

never executed (the execution status of this line is deduced): recno += cd->bracount;

6297

never executed: }

6298 -

6299 /* Come here from code above that handles a named recursion */ -

6300 -

6301

HANDLE_RECURSION:

code before this statement executed: HANDLE_RECURSION:

Execution Count:8

6302 -

6303

executed (the execution status of this line is deduced): previous = code;

6304

called = cd->start_code;

executed (the execution status of this line is deduced): called = cd->start_code;

6305 -

6306 /* When we are actually compiling, find the bracket that is being -

6307 referenced. Temporarily end the regex in case it doesn't exist before -

6308 this point. If we end up with a forward reference, first check that -

6309 the bracket does occur later so we can give the error (and position) -

6310 now. Then remember this forward reference in the workspace so it can -

6311 be filled in at the end. */ -

6312 -

6313

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

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

6314 { -

6315

called = PRIV(find_bracket)(cd->start_code, utf, recno);

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

6316

if (recno != 0)

evaluated: recno != 0

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

6317

executed: called = _pcre16_find_bracket(cd->start_code, utf, recno);

Execution Count:2

6318 -

6319 /* Forward reference */ -

6320 -

6321

if (called == NULL)

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

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

6322 { -

6323

if (find_parens(cd, NULL, recno,

partially evaluated: find_parens(cd, ((void *)0), recno, (options & 0x00000008) != 0, utf) < 0

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

0-2

6324

(options & PCRE_EXTENDED) != 0, utf) < 0)

partially evaluated: find_parens(cd, ((void *)0), recno, (options & 0x00000008) != 0, utf) < 0

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

0-2

6325 { -

6326

never executed (the execution status of this line is deduced): *errorcodeptr = ERR15;

6327

called = cd->start_code + recno;

never executed: goto FAILED;

6328 } -

6329 -

6330 /* Fudge the value of "called" so that when it is inserted as an -

6331 offset below, what it actually inserted is the reference number -

6332 of the group. Then remember the forward reference. */ -

6333 -

6334

executed (the execution status of this line is deduced): called = cd->start_code + recno;

6335

if (cd->hwm >= cd->start_workspace + cd->workspace_size -

partially evaluated: cd->hwm >= cd->start_workspace + cd->workspace_size - (100)

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

0-2

6336

WORK_SIZE_SAFETY_MARGIN)

partially evaluated: cd->hwm >= cd->start_workspace + cd->workspace_size - (100)

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

0-2

6337 { -

6338

*errorcodeptr = expand_workspace(cd);

never executed (the execution status of this line is deduced): *errorcodeptr = expand_workspace(cd);

6339

never executed: goto FAILED;

never evaluated: *errorcodeptr != 0

6340

PUTINC(cd->hwm, 0, (int)(code + 1 - cd->start_code));

never executed: }

6341

executed (the execution status of this line is deduced): (cd->hwm[0] = ((int)(code + 1 - cd->start_code))), cd->hwm += 1;

6342

else if (GET(called, 1) == 0 && cond_depth <= 0 &&

executed: }

Execution Count:2

6343 -

6344 /* If not a forward reference, and the subpattern is still open, -

6345 this is a recursive call. We check to see if this is a left -

6346 recursion that could loop for ever, and diagnose that case. We -

6347 must not, however, do this check if we are in a conditional -

6348 subpattern because the condition might be testing for recursion in -

6349 a pattern such as /(?(R)a+|(?R)b)/, which is perfectly valid. -

6350 Forever loops are also detected at runtime, so those that occur in -

6351 conditional subpatterns will be picked up then. */ -

6352 -

6353

partially evaluated: (called[1]) == 0

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

partially evaluated: cond_depth <= 0

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

0-2

6354

could_be_empty(called, code, bcptr, utf, cd))

never evaluated: could_be_empty(called, code, bcptr, utf, cd)

6355 { -

6356

*errorcodeptr = ERR40;

never executed (the execution status of this line is deduced): *errorcodeptr = ERR40;

6357

PUT(code, 1, (int)(called - cd->start_code));

never executed: goto FAILED;

6358 } -

6359 } -

6360 -

6361 /* Insert the recursion/subroutine item. It does not have a set first -

6362 character (relevant if it is repeated, because it will then be -

6363 wrapped with ONCE brackets). */ -

6364 -

6365

*code = OP_RECURSE;

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

6366

executed (the execution status of this line is deduced): (code[1] = ((int)(called - cd->start_code)));

6367

groupsetfirstchar = FALSE;

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

6368

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

6369 } -

6370 -

6371 /* Can't determine a first byte now */ -

6372 -

6373

executed: firstchar = (-1);

Execution Count:4

evaluated: firstchar == (-2)

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

6374

while (*ptr != CHAR_RIGHT_PARENTHESIS && *ptr != CHAR_COLON)

executed: continue;

Execution Count:8

6375 -

6376 -

6377 /* ------------------------------------------------------------ */ -

6378 default: /* Other characters: check option setting */ -

6379 OTHER_CHAR_AFTER_QUERY: -

6380

set = unset = 0;

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

6381

optset = &set;

never executed (the execution status of this line is deduced): optset = &set;

6382 -

6383

never evaluated: *ptr != '\051'

never evaluated: *ptr != '\072'

6384 { -

6385 switch (*ptr++) -

6386 { -

6387

case CHAR_MINUS: optset = &unset; break;

never executed: break;

6388 -

6389 case CHAR_J: /* Record that it changed in the external options */ -

6390

*optset |= PCRE_DUPNAMES;

never executed (the execution status of this line is deduced): *optset |= 0x00080000;

6391

cd->external_flags |= PCRE_JCHANGED;

never executed (the execution status of this line is deduced): cd->external_flags |= 0x0400;

6392

case CHAR_i: *optset |= PCRE_CASELESS; break;

never executed: break;

6393 -

6394

never executed: break;

6395

case CHAR_m: *optset |= PCRE_MULTILINE; break;

never executed: break;

6396

case CHAR_s: *optset |= PCRE_DOTALL; break;

never executed: break;

6397

case CHAR_x: *optset |= PCRE_EXTENDED; break;

never executed: break;

6398

case CHAR_U: *optset |= PCRE_UNGREEDY; break;

never executed: break;

6399

case CHAR_X: *optset |= PCRE_EXTRA; break;

never executed: break;

6400 -

6401

default: *errorcodeptr = ERR12;

never executed (the execution status of this line is deduced): default: *errorcodeptr = ERR12;

6402

ptr--; /* Correct the offset */

never executed (the execution status of this line is deduced): ptr--;

6403

never executed: goto FAILED;

6404 } -

6405

newoptions = (options | set) & (~unset);

never executed: }

6406 -

6407 /* Set up the changed option bits, but don't change anything yet. */ -

6408 -

6409

never executed (the execution status of this line is deduced): newoptions = (options | set) & (~unset);

6410 -

6411 /* If the options ended with ')' this is not the start of a nested -

6412 group with option changes, so the options change at this level. If this -

6413 item is right at the start of the pattern, the options can be -

6414 abstracted and made external in the pre-compile phase, and ignored in -

6415 the compile phase. This can be helpful when matching -- for instance in -

6416 caseless checking of required bytes. -

6417 -

6418 If the code pointer is not (cd->start_code + 1 + LINK_SIZE), we are -

6419 definitely *not* at the start of the pattern because something has been -

6420 compiled. In the pre-compile phase, however, the code pointer can have -

6421 that value after the start, because it gets reset as code is discarded -

6422 during the pre-compile. However, this can happen only at top level - if -

6423 we are within parentheses, the starting BRA will still be present. At -

6424 any parenthesis level, the length value can be used to test if anything -

6425 has been compiled at that level. Thus, a test for both these conditions -

6426 is necessary to ensure we correctly detect the start of the pattern in -

6427 both phases. -

6428 -

6429 If we are not at the pattern start, reset the greedy defaults and the -

6430 case value for firstchar and reqchar. */ -

6431 -

6432

if (*ptr == CHAR_RIGHT_PARENTHESIS)

never evaluated: *ptr == '\051'

6433 { -

6434

if (code == cd->start_code + 1 + LINK_SIZE &&

never evaluated: code == cd->start_code + 1 + 1

6435

(lengthptr == NULL || *lengthptr == 2 + 2*LINK_SIZE))

never evaluated: lengthptr == ((void *)0)

never evaluated: *lengthptr == 2 + 2*1

6436 { -

6437

cd->external_options = newoptions;

never executed (the execution status of this line is deduced): cd->external_options = newoptions;

6438

greedy_default = ((newoptions & PCRE_UNGREEDY) != 0);

never executed: }

6439 else -

6440 { -

6441

never executed (the execution status of this line is deduced): greedy_default = ((newoptions & 0x00000200) != 0);

6442

greedy_non_default = greedy_default ^ 1;

never executed (the execution status of this line is deduced): greedy_non_default = greedy_default ^ 1;

6443

req_caseopt = ((newoptions & PCRE_CASELESS) != 0)? REQ_CASELESS:0;

never evaluated: ((newoptions & 0x00000001) != 0)

6444

*optionsptr = options = newoptions;

never executed: }

6445 -

6446 /* Change options at this level, and pass them back for use -

6447 in subsequent branches. */ -

6448 -

6449

never executed (the execution status of this line is deduced): *optionsptr = options = newoptions;

6450

previous = NULL; /* This item can't be repeated */

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

6451

continue; /* It is complete */

never executed: continue;

6452 } -

6453 -

6454 /* If the options ended with ':' we are heading into a nested group -

6455 with possible change of options. Such groups are non-capturing and are -

6456 not assertions of any kind. All we need to do is skip over the ':'; -

6457 the newoptions value is handled below. */ -

6458 -

6459

bravalue = OP_BRA;

never executed (the execution status of this line is deduced): bravalue = OP_BRA;

6460

} /* End of switch for character following (? */

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

6461

never executed: }

6462

} /* End of (? handling */

executed: }

Execution Count:64

6463 -

6464 /* Opening parenthesis not followed by '*' or '?'. If PCRE_NO_AUTO_CAPTURE -

6465 is set, all unadorned brackets become non-capturing and behave like (?:...) -

6466 brackets. */ -

6467 -

6468

else if ((options & PCRE_NO_AUTO_CAPTURE) != 0)

evaluated: (options & 0x00001000) != 0

TRUE	FALSE
yes Evaluation Count:4	yes Evaluation Count:352

4-352

6469 { -

6470

bravalue = OP_BRA;

executed (the execution status of this line is deduced): bravalue = OP_BRA;

6471

PUT2(code, 1+LINK_SIZE, cd->bracount);

executed: }

Execution Count:4

6472 -

6473 /* Else we have a capturing group. */ -

6474 -

6475 else -

6476 { -

6477 NUMBERED_GROUP: -

6478

cd->bracount += 1;

executed (the execution status of this line is deduced): cd->bracount += 1;

6479

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

6480

skipbytes = IMM2_SIZE;

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

6481

previous = code; /* For handling repetition */

executed: }

Execution Count:382

382

6482 -

6483 /* Process nested bracketed regex. Assertions used not to be repeatable, -

6484 but this was changed for Perl compatibility, so all kinds can now be -

6485 repeated. We copy code into a non-register variable (tempcode) in order to -

6486 be able to pass its address because some compilers complain otherwise. */ -

6487 -

6488

executed (the execution status of this line is deduced): previous = code;

6489

*code = bravalue;

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

6490

tempcode = code;

executed (the execution status of this line is deduced): tempcode = code;

6491

tempreqvary = cd->req_varyopt; /* Save value before bracket */

executed (the execution status of this line is deduced): tempreqvary = cd->req_varyopt;

6492

tempbracount = cd->bracount; /* Save value before bracket */

executed (the execution status of this line is deduced): tempbracount = cd->bracount;

6493

length_prevgroup = 0; /* Initialize for pre-compile phase */

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

6494 -

6495

if (!compile_regex(

partially evaluated:

!compile_regex( newoptions, &tempcode, &ptr, errorcodeptr, (bravalue == OP_ASSERTBACK || bravalue == OP_ASSERTBACK_NOT), reset_bracount, skipbytes, cond_depth + ((bravalue == OP_COND)?1:0), &subfirstchar, &subreqchar, bcptr, cd, (lengthptr == ((void *)0))? ((void *)0) : &length_prevgroup )

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

0-450

6496

newoptions, /* The complete new option state */

partially evaluated:

!compile_regex( newoptions, &tempcode, &ptr, errorcodeptr, (bravalue == OP_ASSERTBACK || bravalue == OP_ASSERTBACK_NOT), reset_bracount, skipbytes, cond_depth + ((bravalue == OP_COND)?1:0), &subfirstchar, &subreqchar, bcptr, cd, (lengthptr == ((void *)0))? ((void *)0) : &length_prevgroup )

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

0-450

6497

&tempcode, /* Where to put code (updated) */

partially evaluated:

!compile_regex( newoptions, &tempcode, &ptr, errorcodeptr, (bravalue == OP_ASSERTBACK || bravalue == OP_ASSERTBACK_NOT), reset_bracount, skipbytes, cond_depth + ((bravalue == OP_COND)?1:0), &subfirstchar, &subreqchar, bcptr, cd, (lengthptr == ((void *)0))? ((void *)0) : &length_prevgroup )

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

0-450

6498

&ptr, /* Input pointer (updated) */

partially evaluated:

!compile_regex( newoptions, &tempcode, &ptr, errorcodeptr, (bravalue == OP_ASSERTBACK || bravalue == OP_ASSERTBACK_NOT), reset_bracount, skipbytes, cond_depth + ((bravalue == OP_COND)?1:0), &subfirstchar, &subreqchar, bcptr, cd, (lengthptr == ((void *)0))? ((void *)0) : &length_prevgroup )

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

0-450

6499

errorcodeptr, /* Where to put an error message */

partially evaluated:

!compile_regex( newoptions, &tempcode, &ptr, errorcodeptr, (bravalue == OP_ASSERTBACK || bravalue == OP_ASSERTBACK_NOT), reset_bracount, skipbytes, cond_depth + ((bravalue == OP_COND)?1:0), &subfirstchar, &subreqchar, bcptr, cd, (lengthptr == ((void *)0))? ((void *)0) : &length_prevgroup )

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

0-450

6500

(bravalue == OP_ASSERTBACK ||

partially evaluated:

!compile_regex( newoptions, &tempcode, &ptr, errorcodeptr, (bravalue == OP_ASSERTBACK || bravalue == OP_ASSERTBACK_NOT), reset_bracount, skipbytes, cond_depth + ((bravalue == OP_COND)?1:0), &subfirstchar, &subreqchar, bcptr, cd, (lengthptr == ((void *)0))? ((void *)0) : &length_prevgroup )

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

0-450

6501

bravalue == OP_ASSERTBACK_NOT), /* TRUE if back assert */

partially evaluated:

!compile_regex( newoptions, &tempcode, &ptr, errorcodeptr, (bravalue == OP_ASSERTBACK || bravalue == OP_ASSERTBACK_NOT), reset_bracount, skipbytes, cond_depth + ((bravalue == OP_COND)?1:0), &subfirstchar, &subreqchar, bcptr, cd, (lengthptr == ((void *)0))? ((void *)0) : &length_prevgroup )

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

0-450

6502

reset_bracount, /* True if (?| group */

partially evaluated:

!compile_regex( newoptions, &tempcode, &ptr, errorcodeptr, (bravalue == OP_ASSERTBACK || bravalue == OP_ASSERTBACK_NOT), reset_bracount, skipbytes, cond_depth + ((bravalue == OP_COND)?1:0), &subfirstchar, &subreqchar, bcptr, cd, (lengthptr == ((void *)0))? ((void *)0) : &length_prevgroup )

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

0-450

6503

skipbytes, /* Skip over bracket number */

partially evaluated:

!compile_regex( newoptions, &tempcode, &ptr, errorcodeptr, (bravalue == OP_ASSERTBACK || bravalue == OP_ASSERTBACK_NOT), reset_bracount, skipbytes, cond_depth + ((bravalue == OP_COND)?1:0), &subfirstchar, &subreqchar, bcptr, cd, (lengthptr == ((void *)0))? ((void *)0) : &length_prevgroup )

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

0-450

6504

cond_depth +

partially evaluated:

!compile_regex( newoptions, &tempcode, &ptr, errorcodeptr, (bravalue == OP_ASSERTBACK || bravalue == OP_ASSERTBACK_NOT), reset_bracount, skipbytes, cond_depth + ((bravalue == OP_COND)?1:0), &subfirstchar, &subreqchar, bcptr, cd, (lengthptr == ((void *)0))? ((void *)0) : &length_prevgroup )

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

0-450

6505

((bravalue == OP_COND)?1:0), /* Depth of condition subpatterns */

partially evaluated:

!compile_regex( newoptions, &tempcode, &ptr, errorcodeptr, (bravalue == OP_ASSERTBACK || bravalue == OP_ASSERTBACK_NOT), reset_bracount, skipbytes, cond_depth + ((bravalue == OP_COND)?1:0), &subfirstchar, &subreqchar, bcptr, cd, (lengthptr == ((void *)0))? ((void *)0) : &length_prevgroup )

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

0-450

6506

&subfirstchar, /* For possible first char */

partially evaluated:

!compile_regex( newoptions, &tempcode, &ptr, errorcodeptr, (bravalue == OP_ASSERTBACK || bravalue == OP_ASSERTBACK_NOT), reset_bracount, skipbytes, cond_depth + ((bravalue == OP_COND)?1:0), &subfirstchar, &subreqchar, bcptr, cd, (lengthptr == ((void *)0))? ((void *)0) : &length_prevgroup )

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

0-450

6507

&subreqchar, /* For possible last char */

partially evaluated:

!compile_regex( newoptions, &tempcode, &ptr, errorcodeptr, (bravalue == OP_ASSERTBACK || bravalue == OP_ASSERTBACK_NOT), reset_bracount, skipbytes, cond_depth + ((bravalue == OP_COND)?1:0), &subfirstchar, &subreqchar, bcptr, cd, (lengthptr == ((void *)0))? ((void *)0) : &length_prevgroup )

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

0-450

6508

bcptr, /* Current branch chain */

partially evaluated:

!compile_regex( newoptions, &tempcode, &ptr, errorcodeptr, (bravalue == OP_ASSERTBACK || bravalue == OP_ASSERTBACK_NOT), reset_bracount, skipbytes, cond_depth + ((bravalue == OP_COND)?1:0), &subfirstchar, &subreqchar, bcptr, cd, (lengthptr == ((void *)0))? ((void *)0) : &length_prevgroup )

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

0-450

6509

cd, /* Tables block */

partially evaluated:

!compile_regex( newoptions, &tempcode, &ptr, errorcodeptr, (bravalue == OP_ASSERTBACK || bravalue == OP_ASSERTBACK_NOT), reset_bracount, skipbytes, cond_depth + ((bravalue == OP_COND)?1:0), &subfirstchar, &subreqchar, bcptr, cd, (lengthptr == ((void *)0))? ((void *)0) : &length_prevgroup )

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

0-450

6510

(lengthptr == NULL)? NULL : /* Actual compile phase */

partially evaluated:

!compile_regex( newoptions, &tempcode, &ptr, errorcodeptr, (bravalue == OP_ASSERTBACK || bravalue == OP_ASSERTBACK_NOT), reset_bracount, skipbytes, cond_depth + ((bravalue == OP_COND)?1:0), &subfirstchar, &subreqchar, bcptr, cd, (lengthptr == ((void *)0))? ((void *)0) : &length_prevgroup )

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

0-450

6511

&length_prevgroup /* Pre-compile phase */

partially evaluated:

!compile_regex( newoptions, &tempcode, &ptr, errorcodeptr, (bravalue == OP_ASSERTBACK || bravalue == OP_ASSERTBACK_NOT), reset_bracount, skipbytes, cond_depth + ((bravalue == OP_COND)?1:0), &subfirstchar, &subreqchar, bcptr, cd, (lengthptr == ((void *)0))? ((void *)0) : &length_prevgroup )

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

0-450

6512

))

partially evaluated:

!compile_regex( newoptions, &tempcode, &ptr, errorcodeptr, (bravalue == OP_ASSERTBACK || bravalue == OP_ASSERTBACK_NOT), reset_bracount, skipbytes, cond_depth + ((bravalue == OP_COND)?1:0), &subfirstchar, &subreqchar, bcptr, cd, (lengthptr == ((void *)0))? ((void *)0) : &length_prevgroup )

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

0-450

6513

if (bravalue == OP_ONCE && cd->bracount <= tempbracount)

never executed: goto FAILED;

6514 -

6515 /* If this was an atomic group and there are no capturing groups within it, -

6516 generate OP_ONCE_NC instead of OP_ONCE. */ -

6517 -

6518

partially evaluated: bravalue == OP_ONCE

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

never evaluated: cd->bracount <= tempbracount

0-450

6519

*code = OP_ONCE_NC;

never executed: *code = OP_ONCE_NC;

6520 -

6521

if (bravalue >= OP_ASSERT && bravalue <= OP_ASSERTBACK_NOT)

partially evaluated: bravalue >= OP_ASSERT

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

evaluated: bravalue <= OP_ASSERTBACK_NOT

TRUE	FALSE
yes Evaluation Count:8	yes Evaluation Count:442

0-450

6522

cd->assert_depth -= 1;

executed: cd->assert_depth -= 1;

Execution Count:8

6523 -

6524 /* At the end of compiling, code is still pointing to the start of the -

6525 group, while tempcode has been updated to point past the end of the group. -

6526 The pattern pointer (ptr) is on the bracket. -

6527 -

6528 If this is a conditional bracket, check that there are no more than -

6529 two branches in the group, or just one if it's a DEFINE group. We do this -

6530 in the real compile phase, not in the pre-pass, where the whole group may -

6531 not be available. */ -

6532 -

6533

if (bravalue == OP_COND && lengthptr == NULL)

evaluated: bravalue == OP_COND

TRUE	FALSE
yes Evaluation Count:4	yes Evaluation Count:446

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

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

2-446

6534 { -

6535

pcre_uchar *tc = code;

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

6536

int condcount = 0;

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

6537 -

6538 do { -

6539

condcount++;

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

6540

tc += GET(tc,1);

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

6541

if (code[LINK_SIZE+1] == OP_DEF)

executed: }

Execution Count:4

6542

while (*tc != OP_KET);

evaluated: *tc != OP_KET

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

6543 -

6544 /* A DEFINE group is never obeyed inline (the "condition" is always -

6545 false). It must have only one branch. */ -

6546 -

6547

partially evaluated: code[1 +1] == OP_DEF

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

0-2

6548 { -

6549

if (condcount > 1)

never evaluated: condcount > 1

6550 { -

6551

*errorcodeptr = ERR54;

never executed (the execution status of this line is deduced): *errorcodeptr = ERR54;

6552

bravalue = OP_DEF; /* Just a flag to suppress char handling below */

never executed: goto FAILED;

6553 } -

6554

never executed (the execution status of this line is deduced): bravalue = OP_DEF;

6555

never executed: }

6556 -

6557 /* A "normal" conditional group. If there is just one branch, we must not -

6558 make use of its firstchar or reqchar, because this is equivalent to an -

6559 empty second branch. */ -

6560 -

6561 else -

6562 { -

6563

if (condcount > 2)

partially evaluated: condcount > 2

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

0-2

6564 { -

6565

*errorcodeptr = ERR27;

never executed (the execution status of this line is deduced): *errorcodeptr = ERR27;

6566

if (condcount == 1) subfirstchar = subreqchar = REQ_NONE;

never executed: goto FAILED;

6567 } -

6568

never executed: subfirstchar = subreqchar = (-1);

partially evaluated: condcount == 1

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

0-2

6569

if (*ptr != CHAR_RIGHT_PARENTHESIS)

executed: }

Execution Count:2

6570 } -

6571 -

6572 /* Error if hit end of pattern */ -

6573 -

6574

evaluated: *ptr != '\051'

TRUE	FALSE
yes Evaluation Count:2	yes Evaluation Count:448

2-448

6575 { -

6576

*errorcodeptr = ERR14;

executed (the execution status of this line is deduced): *errorcodeptr = ERR14;

6577

executed: goto FAILED;

Execution Count:2

6578 } -

6579 -

6580 /* In the pre-compile phase, update the length by the length of the group, -

6581 less the brackets at either end. Then reduce the compiled code to just a -

6582 set of non-capturing brackets so that it doesn't use much memory if it is -

6583 duplicated by a quantifier.*/ -

6584 -

6585

if (OFLOW_MAX - *lengthptr < length_prevgroup - 2 - 2*LINK_SIZE)

evaluated: lengthptr != ((void *)0)

TRUE	FALSE
yes Evaluation Count:224	yes Evaluation Count:224

224

6586 { -

6587

partially evaluated: (2147483647 - 20) - *lengthptr < length_prevgroup - 2 - 2*1

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

0-224

6588 { -

6589

never executed (the execution status of this line is deduced): *errorcodeptr = ERR20;

6590

*lengthptr += length_prevgroup - 2 - 2*LINK_SIZE;

never executed: goto FAILED;

6591 } -

6592

executed (the execution status of this line is deduced): *lengthptr += length_prevgroup - 2 - 2*1;

6593

code++; /* This already contains bravalue */

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

6594

PUTINC(code, 0, 1 + LINK_SIZE);

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

6595

*code++ = OP_KET;

executed (the execution status of this line is deduced): *code++ = OP_KET;

6596

PUTINC(code, 0, 1 + LINK_SIZE);

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

6597

break; /* No need to waste time with special character handling */

executed: break;

Execution Count:224

224

6598 } -

6599 -

6600 /* Otherwise update the main code pointer to the end of the group. */ -

6601 -

6602

code = tempcode;

executed (the execution status of this line is deduced): code = tempcode;

6603 -

6604 /* For a DEFINE group, required and first character settings are not -

6605 relevant. */ -

6606 -

6607

if (bravalue == OP_DEF) break;

never executed: break;

partially evaluated: bravalue == OP_DEF

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

0-224

6608 -

6609 /* Handle updating of the required and first characters for other types of -

6610 group. Update for normal brackets of all kinds, and conditions with two -

6611 branches (see code above). If the bracket is followed by a quantifier with -

6612 zero repeat, we have to back off. Hence the definition of zeroreqchar and -

6613 zerofirstchar outside the main loop so that they can be accessed for the -

6614 back off. */ -

6615 -

6616

executed (the execution status of this line is deduced): zeroreqchar = reqchar;

6617

groupsetfirstchar = FALSE;

executed (the execution status of this line is deduced): zerofirstchar = firstchar;

6618

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

6619 -

6620

if (bravalue >= OP_ONCE)

evaluated: bravalue >= OP_ONCE

TRUE	FALSE
yes Evaluation Count:220	yes Evaluation Count:4

4-220

6621 { -

6622 /* If we have not yet set a firstchar in this branch, take it from the -

6623 subpattern, remembering that it was set here so that a repeat of more -

6624 than one can replicate it as reqchar if necessary. If the subpattern has -

6625 no firstchar, set "none" for the whole branch. In both cases, a zero -

6626 repeat forces firstchar to "none". */ -

6627 -

6628

if (firstchar == REQ_UNSET)

evaluated: firstchar == (-2)

TRUE	FALSE
yes Evaluation Count:104	yes Evaluation Count:116

104-116

6629 { -

6630

if (subfirstchar >= 0)

evaluated: subfirstchar >= 0

TRUE	FALSE
yes Evaluation Count:34	yes Evaluation Count:70

34-70

6631 { -

6632

firstchar = subfirstchar;

executed (the execution status of this line is deduced): firstchar = subfirstchar;

6633

groupsetfirstchar = TRUE;

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

6634

else firstchar = REQ_NONE;

executed: }

Execution Count:34

6635

executed: firstchar = (-1);

Execution Count:70

6636

zerofirstchar = REQ_NONE;

executed (the execution status of this line is deduced): zerofirstchar = (-1);

6637

else if (subfirstchar >= 0 && subreqchar < 0)

executed: }

Execution Count:104

104

6638 -

6639 /* If firstchar was previously set, convert the subpattern's firstchar -

6640 into reqchar if there wasn't one, using the vary flag that was in -

6641 existence beforehand. */ -

6642 -

6643

evaluated: subfirstchar >= 0

TRUE	FALSE
yes Evaluation Count:85	yes Evaluation Count:31

evaluated: subreqchar < 0

TRUE	FALSE
yes Evaluation Count:29	yes Evaluation Count:56

29-85

6644

subreqchar = subfirstchar | tempreqvary;

executed: subreqchar = subfirstchar | tempreqvary;

Execution Count:29

6645 -

6646 /* If the subpattern set a required byte (or set a first byte that isn't -

6647 really the first byte - see above), set it. */ -

6648 -

6649

if (subreqchar >= 0) reqchar = subreqchar;

executed: reqchar = subreqchar;

Execution Count:120

evaluated: subreqchar >= 0

TRUE	FALSE
yes Evaluation Count:120	yes Evaluation Count:100

100-120

6650

else if (bravalue == OP_ASSERT && subreqchar >= 0) reqchar = subreqchar;

executed: }

Execution Count:220

220

6651 -

6652 /* For a forward assertion, we take the reqchar, if set. This can be -

6653 helpful if the pattern that follows the assertion doesn't set a different -

6654 char. For example, it's useful for /(?=abcde).+/. We can't set firstchar -

6655 for an assertion, however because it leads to incorrect effect for patterns -

6656 such as /(?=a)a.+/ when the "real" "a" would then become a reqchar instead -

6657 of a firstchar. This is overcome by a scan at the end if there's no -

6658 firstchar, looking for an asserted first char. */ -

6659 -

6660

never executed: reqchar = subreqchar;

partially evaluated: bravalue == OP_ASSERT

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

never evaluated: subreqchar >= 0

0-4

6661

break; /* End of processing '(' */

executed: break;

Execution Count:224

224

6662 -

6663 -

6664 /* ===================================================================*/ -

6665 /* Handle metasequences introduced by \. For ones like \d, the ESC_ values -

6666 are arranged to be the negation of the corresponding OP_values in the -

6667 default case when PCRE_UCP is not set. For the back references, the values -

6668 are ESC_REF plus the reference number. Only back references and those types -

6669 that consume a character may be repeated. We can test for values between -

6670 ESC_b and ESC_Z for the latter; this may have to change if any new ones are -

6671 ever created. */ -

6672 -

6673 case CHAR_BACKSLASH: -

6674

tempptr = ptr;

executed (the execution status of this line is deduced): tempptr = ptr;

6675

c = check_escape(&ptr, errorcodeptr, cd->bracount, options, FALSE);

executed (the execution status of this line is deduced): c = check_escape(&ptr, errorcodeptr, cd->bracount, options, 0);

6676

if (-c == ESC_Q) /* Handle start of quoted string */

executed: goto FAILED;

Execution Count:7

evaluated: *errorcodeptr != 0

TRUE	FALSE
yes Evaluation Count:7	yes Evaluation Count:851

7-851

6677 -

6678

if (c < 0)

evaluated: c < 0

TRUE	FALSE
yes Evaluation Count:505	yes Evaluation Count:346

346-505

6679 { -

6680

partially evaluated: -c == ESC_Q

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

0-505

6681 { -

6682

if (ptr[1] == CHAR_BACKSLASH && ptr[2] == CHAR_E)

never evaluated: ptr[1] == '\134'

never evaluated: ptr[2] == '\105'

6683

ptr += 2; /* avoid empty string */

never executed: ptr += 2;

6684

else inescq = TRUE;

never executed: inescq = 1;

6685

if (-c == ESC_E) continue; /* Perl ignores an orphan \E */

never executed: continue;

6686 } -

6687 -

6688

never executed: continue;

partially evaluated: -c == ESC_E

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

0-505

6689 -

6690 /* For metasequences that actually match a character, we disable the -

6691 setting of a first character if it hasn't already been set. */ -

6692 -

6693

if (firstchar == REQ_UNSET && -c > ESC_b && -c < ESC_Z)

evaluated: firstchar == (-2)

TRUE	FALSE
yes Evaluation Count:244	yes Evaluation Count:261

evaluated: -c > ESC_b

TRUE	FALSE
yes Evaluation Count:140	yes Evaluation Count:104

evaluated: -c < ESC_Z

TRUE	FALSE
yes Evaluation Count:120	yes Evaluation Count:20

20-261

6694

firstchar = REQ_NONE;

executed: firstchar = (-1);

Execution Count:120

120

6695 -

6696 /* Set values to reset to if this is followed by a zero repeat. */ -

6697 -

6698

executed (the execution status of this line is deduced): zerofirstchar = firstchar;

6699

save_hwm = cd->hwm; /* Normally this is set when '(' is read */

executed (the execution status of this line is deduced): zeroreqchar = reqchar;

6700 -

6701 /* \g<name> or \g'name' is a subroutine call by name and \g<n> or \g'n' -

6702 is a subroutine call by number (Oniguruma syntax). In fact, the value -

6703 -ESC_g is returned only for these cases. So we don't need to check for < -

6704 or ' if the value is -ESC_g. For the Perl syntax \g{n} the value is -

6705 -ESC_REF+n, and for the Perl syntax \g{name} the result is -ESC_k (as -

6706 that is a synonym for a named back reference). */ -

6707 -

6708

if (-c == ESC_g)

partially evaluated: -c == ESC_g

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

0-505

6709 { -

6710

const pcre_uchar *p;

never executed (the execution status of this line is deduced): const pcre_uchar *p;

6711

never executed (the execution status of this line is deduced): save_hwm = cd->hwm;

6712

terminator = (*(++ptr) == CHAR_LESS_THAN_SIGN)?

never evaluated: (*(++ptr) == '\074')

6713

CHAR_GREATER_THAN_SIGN : CHAR_APOSTROPHE;

never executed (the execution status of this line is deduced): '\076' : '\047';

6714 -

6715 /* These two statements stop the compiler for warning about possibly -

6716 unset variables caused by the jump to HANDLE_NUMERICAL_RECURSION. In -

6717 fact, because we actually check for a number below, the paths that -

6718 would actually be in error are never taken. */ -

6719 -

6720

skipbytes = 0;

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

6721

reset_bracount = FALSE;

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

6722 -

6723 /* Test for a name */ -

6724 -

6725

if (ptr[1] != CHAR_PLUS && ptr[1] != CHAR_MINUS)

never evaluated: ptr[1] != '\053'

never evaluated: ptr[1] != '\055'

6726 { -

6727

BOOL is_a_number = TRUE;

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

6728

for (p = ptr + 1; *p != 0 && *p != terminator; p++)

never evaluated: *p != 0

never evaluated: *p != terminator

6729 { -

6730

if (!MAX_255(*p)) { is_a_number = FALSE; break; }

never executed: break;

never evaluated: !((*p) <= 255u)

6731

if ((cd->ctypes[*p] & ctype_digit) == 0) is_a_number = FALSE;

never executed: is_a_number = 0;

never evaluated: (cd->ctypes[*p] & 0x04) == 0

6732

if ((cd->ctypes[*p] & ctype_word) == 0) break;

never executed: break;

never evaluated: (cd->ctypes[*p] & 0x10) == 0

6733

never executed: }

6734

if (*p != terminator)

never evaluated: *p != terminator

6735 { -

6736

*errorcodeptr = ERR57;

never executed (the execution status of this line is deduced): *errorcodeptr = ERR57;

6737

never executed: break;

6738 } -

6739

if (is_a_number)

never evaluated: is_a_number

6740 { -

6741

goto HANDLE_NUMERICAL_RECURSION;

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

6742

never executed: goto HANDLE_NUMERICAL_RECURSION;

6743 } -

6744

is_recurse = TRUE;

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

6745

goto NAMED_REF_OR_RECURSE;

never executed: goto NAMED_REF_OR_RECURSE;

6746 } -

6747 -

6748 /* Test a signed number in angle brackets or quotes. */ -

6749 -

6750

p = ptr + 2;

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

6751

while (IS_DIGIT(*p)) p++;

never executed: p++;

never evaluated: (*p) >= '\060'

never evaluated: (*p) <= '\071'

6752

if (*p != terminator)

never evaluated: *p != terminator

6753 { -

6754

*errorcodeptr = ERR57;

never executed (the execution status of this line is deduced): *errorcodeptr = ERR57;

6755

never executed: break;

6756 } -

6757

goto HANDLE_NUMERICAL_RECURSION;

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

6758

never executed: goto HANDLE_NUMERICAL_RECURSION;

6759 } -

6760 -

6761 /* \k<name> or \k'name' is a back reference by name (Perl syntax). -

6762 We also support \k{name} (.NET syntax). */ -

6763 -

6764

if (-c == ESC_k)

partially evaluated: -c == ESC_k

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

0-505

6765 { -

6766

if ((ptr[1] != CHAR_LESS_THAN_SIGN &&

never evaluated: ptr[1] != '\074'

6767

ptr[1] != CHAR_APOSTROPHE && ptr[1] != CHAR_LEFT_CURLY_BRACKET))

never evaluated: ptr[1] != '\047'

never evaluated: ptr[1] != '\173'

6768 { -

6769

*errorcodeptr = ERR69;

never executed (the execution status of this line is deduced): *errorcodeptr = ERR69;

6770

terminator = (*(++ptr) == CHAR_LESS_THAN_SIGN)?

never executed: break;

6771 } -

6772

is_recurse = FALSE;

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

6773

never evaluated: (*(++ptr) == '\074')

6774

CHAR_GREATER_THAN_SIGN : (*ptr == CHAR_APOSTROPHE)?

never executed (the execution status of this line is deduced): '\076' : (*ptr == '\047')?

6775

CHAR_APOSTROPHE : CHAR_RIGHT_CURLY_BRACKET;

never executed (the execution status of this line is deduced): '\047' : '\175';

6776

goto NAMED_REF_OR_RECURSE;

never executed: goto NAMED_REF_OR_RECURSE;

6777 } -

6778 -

6779 /* Back references are handled specially; must disable firstchar if -

6780 not set to cope with cases like (?=(\w+))\1: which would otherwise set -

6781 ':' later. */ -

6782 -

6783

if (-c >= ESC_REF)

partially evaluated: -c >= ESC_REF

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

0-505

6784 { -

6785

open_capitem *oc;

never executed (the execution status of this line is deduced): open_capitem *oc;

6786

recno = -c - ESC_REF;

never executed (the execution status of this line is deduced): recno = -c - ESC_REF;

6787 -

6788

HANDLE_REFERENCE: /* Come here from named backref handling */

code before this statement never executed: HANDLE_REFERENCE:

6789

never executed: firstchar = (-1);

never evaluated: firstchar == (-2)

6790

*code++ = ((options & PCRE_CASELESS) != 0)? OP_REFI : OP_REF;

never executed (the execution status of this line is deduced): previous = code;

6791

never evaluated: ((options & 0x00000001) != 0)

6792

PUT2INC(code, 0, recno);

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

6793

cd->backref_map |= (recno < 32)? (1 << recno) : 1;

never evaluated: (recno < 32)

6794

if (recno > cd->top_backref) cd->top_backref = recno;

never executed: cd->top_backref = recno;

never evaluated: recno > cd->top_backref

6795 -

6796 /* Check to see if this back reference is recursive, that it, it -

6797 is inside the group that it references. A flag is set so that the -

6798 group can be made atomic. */ -

6799 -

6800

for (oc = cd->open_caps; oc != NULL; oc = oc->next)

never evaluated: oc != ((void *)0)

6801 { -

6802

if (oc->number == recno)

never evaluated: oc->number == recno

6803 { -

6804

oc->flag = TRUE;

never executed (the execution status of this line is deduced): oc->flag = 1;

6805

else if (-c == ESC_P || -c == ESC_p)

never executed: break;

6806 } -

never executed: }

never executed: }

6809 -

6810 /* So are Unicode property matches, if supported. */ -

6811 -

6812 #ifdef SUPPORT_UCP -

6813

evaluated: -c == ESC_P

TRUE	FALSE
yes Evaluation Count:3	yes Evaluation Count:502

evaluated: -c == ESC_p

TRUE	FALSE
yes Evaluation Count:4	yes Evaluation Count:498

3-502

6814 { -

6815

BOOL negated;

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

6816

int pdata;

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

6817

int ptype = get_ucp(&ptr, &negated, &pdata, errorcodeptr);

executed (the execution status of this line is deduced): int ptype = get_ucp(&ptr, &negated, &pdata, errorcodeptr);

6818

if (ptype < 0) goto FAILED;

executed: goto FAILED;

Execution Count:1

evaluated: ptype < 0

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

1-6

6819

*code++ = ((-c == ESC_p) != negated)? OP_PROP : OP_NOTPROP;

executed (the execution status of this line is deduced): previous = code;

6820

evaluated: ((-c == ESC_p) != negated)

TRUE	FALSE
yes Evaluation Count:4	yes Evaluation Count:2

2-4

6821

*code++ = ptype;

executed (the execution status of this line is deduced): *code++ = ptype;

6822

*code++ = pdata;

executed (the execution status of this line is deduced): *code++ = pdata;

6823

if (-c >= ESC_DU && -c <= ESC_wu)

executed: }

Execution Count:6

6824 #else -

6825 -

6826 /* If Unicode properties are not supported, \X, \P, and \p are not -

6827 allowed. */ -

6828 -

6829 else if (-c == ESC_X || -c == ESC_P || -c == ESC_p) -

6830 { -

6831 *errorcodeptr = ERR45; -

6832 goto FAILED; -

6833 } -

6834 #endif -

6835 -

6836 /* For the rest (including \X when Unicode properties are supported), we -

6837 can obtain the OP value by negating the escape value in the default -

6838 situation when PCRE_UCP is not set. When it *is* set, we substitute -

6839 Unicode property tests. */ -

6840 -

6841 else -

6842 { -

6843 #ifdef SUPPORT_UCP -

6844

evaluated: -c >= ESC_DU

TRUE	FALSE
yes Evaluation Count:4	yes Evaluation Count:494

partially evaluated: -c <= ESC_wu

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

0-494

6845 { -

6846

nestptr = ptr + 1; /* Where to resume */

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

6847

ptr = substitutes[-c - ESC_DU] - 1; /* Just before substitute */

executed (the execution status of this line is deduced): ptr = substitutes[-c - ESC_DU] - 1;

6848

previous = (-c > ESC_b && -c < ESC_Z)? code : NULL;

executed: }

Execution Count:4

6849 else -

6850 #endif -

6851 /* In non-UTF-8 mode, we turn \C into OP_ALLANY instead of OP_ANYBYTE -

6852 so that it works in DFA mode and in lookbehinds. */ -

6853 -

6854 { -

6855

evaluated: -c > ESC_b

TRUE	FALSE
yes Evaluation Count:196	yes Evaluation Count:298

evaluated: -c < ESC_Z

TRUE	FALSE
yes Evaluation Count:162	yes Evaluation Count:34

34-298

6856

*code++ = (!utf && c == -ESC_C)? OP_ALLANY : -c;

partially evaluated: !utf

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

never evaluated: c == -ESC_C

0-494

6857

executed: }

Execution Count:494

494

6858 } -

6859

if (utf && c > MAX_VALUE_FOR_SINGLE_CHAR)

executed: continue;

Execution Count:504

504

6860 } -

6861 -

6862 /* We have a data character whose value is in c. In UTF-8 mode it may have -

6863 a value > 127. We set its representation in the length/buffer, and then -

6864 handle it as a data character. */ -

6865 -

6866 #ifdef SUPPORT_UTF -

6867

partially evaluated: utf

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

evaluated: c > 65535

TRUE	FALSE
yes Evaluation Count:6	yes Evaluation Count:340

0-346

6868

mclength = PRIV(ord2utf)(c, mcbuffer);

executed: mclength = _pcre16_ord2utf(c, mcbuffer);

Execution Count:6

6869 else -

6870 #endif -

6871 -

6872 { -

6873

mcbuffer[0] = c;

executed (the execution status of this line is deduced): mcbuffer[0] = c;

6874

mclength = 1;

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

6875

if (utf && HAS_EXTRALEN(c))

executed: }

Execution Count:340

340

6876

goto ONE_CHAR;

executed: goto ONE_CHAR;

Execution Count:346

346

6877 -

6878 -

6879 /* ===================================================================*/ -

6880 /* Handle a literal character. It is guaranteed not to be whitespace or # -

6881 when the extended flag is set. If we are in UTF-8 mode, it may be a -

6882 multi-byte literal character. */ -

6883 -

6884 default: -

6885 NORMAL_CHAR: -

6886

mclength = 1;

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

6887

mcbuffer[0] = c;

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

6888 -

6889 #ifdef SUPPORT_UTF -

6890

partially evaluated: utf

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

partially evaluated: (((c) & 0xfc00) == 0xd800)

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

0-18076

6891

ACROSSCHAR(TRUE, ptr[1], mcbuffer[mclength++] = *(++ptr));

never executed: mcbuffer[mclength++] = *(++ptr);

never evaluated: (1)

never evaluated: ((ptr[1]) & 0xfc00) == 0xdc00

6892 #endif -

6893 -

6894 /* At this point we have the character's bytes in mcbuffer, and the length -

6895 in mclength. When not in UTF-8 mode, the length is always 1. */ -

6896 -

6897

ONE_CHAR:

code before this statement executed: ONE_CHAR:

Execution Count:18076

18076

6898

*code++ = ((options & PCRE_CASELESS) != 0)? OP_CHARI : OP_CHAR;

executed (the execution status of this line is deduced): previous = code;

6899

evaluated: ((options & 0x00000001) != 0)

TRUE	FALSE
yes Evaluation Count:1138	yes Evaluation Count:17290

1138-17290

6900

for (c = 0; c < mclength; c++) *code++ = mcbuffer[c];

executed: *code++ = mcbuffer[c];

Execution Count:18434

evaluated: c < mclength

TRUE	FALSE
yes Evaluation Count:18434	yes Evaluation Count:18428

18428-18434

6901 -

6902 /* Remember if \r or \n were seen */ -

6903 -

6904

if (mcbuffer[0] == CHAR_CR || mcbuffer[0] == CHAR_NL)

partially evaluated: mcbuffer[0] == '\015'

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

partially evaluated: mcbuffer[0] == '\012'

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

0-18428

6905

cd->external_flags |= PCRE_HASCRORLF;

never executed: cd->external_flags |= 0x0800;

6906 -

6907 /* Set the first and required bytes appropriately. If no previous first -

6908 byte, set it from this character, but revert to none on a zero repeat. -

6909 Otherwise, leave the firstchar value alone, and don't change it on a zero -

6910 repeat. */ -

6911 -

6912

if (firstchar == REQ_UNSET)

evaluated: firstchar == (-2)

TRUE	FALSE
yes Evaluation Count:767	yes Evaluation Count:17661

767-17661

6913 { -

6914

zerofirstchar = REQ_NONE;

executed (the execution status of this line is deduced): zerofirstchar = (-1);

6915

if (mclength == 1 || req_caseopt == 0)

executed (the execution status of this line is deduced): zeroreqchar = reqchar;

6916 -

6917 /* If the character is more than one byte long, we can set firstchar -

6918 only if it is not to be matched caselessly. */ -

6919 -

6920

partially evaluated: mclength == 1

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

never evaluated: req_caseopt == 0

0-767

6921 { -

6922

firstchar = mcbuffer[0] | req_caseopt;

executed (the execution status of this line is deduced): firstchar = mcbuffer[0] | req_caseopt;

6923

if (mclength != 1) reqchar = code[-1] | cd->req_varyopt;

never executed: reqchar = code[-1] | cd->req_varyopt;

partially evaluated: mclength != 1

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

0-767

6924

else firstchar = reqchar = REQ_NONE;

executed: }

Execution Count:767

767

6925

never executed: firstchar = reqchar = (-1);

6926 } -

6927 -

6928 /* firstchar was previously set; we can set reqchar only if the length is -

6929 1 or the matching is caseful. */ -

6930 -

6931 else -

6932 { -

6933

executed (the execution status of this line is deduced): zerofirstchar = firstchar;

6934

if (mclength == 1 || req_caseopt == 0)

executed (the execution status of this line is deduced): zeroreqchar = reqchar;

6935

evaluated: mclength == 1

TRUE	FALSE
yes Evaluation Count:17655	yes Evaluation Count:6

partially evaluated: req_caseopt == 0

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

0-17655

6936

reqchar = code[-1] | req_caseopt | cd->req_varyopt;

executed: reqchar = code[-1] | req_caseopt | cd->req_varyopt;

Execution Count:17661

17661

6937

break; /* End of literal character handling */

executed: }

Execution Count:17661

17661

6938 -

6939

executed: break;

Execution Count:18428

18428

6940 } -

6941

} /* end of big loop */

executed: }

Execution Count:19716

19716

6942 -

6943 -

6944 /* Control never reaches here by falling through, only by a goto for all the -

6945 error states. Pass back the position in the pattern so that it can be displayed -

6946 to the user for diagnosing the error. */ -

6947 -

6948

FAILED:

code before this statement never executed: FAILED:

6949

executed (the execution status of this line is deduced): *ptrptr = ptr;

6950

const pcre_uchar *ptr = *ptrptr;

executed: return 0;

Execution Count:11

6951 } -

6952 -

6953 -

6954 -

6955 -

6956 /************************************************* -

6957 * Compile sequence of alternatives * -

6958 *************************************************/ -

6959 -

6960 /* On entry, ptr is pointing past the bracket character, but on return it -

6961 points to the closing bracket, or vertical bar, or end of string. The code -

6962 variable is pointing at the byte into which the BRA operator has been stored. -

6963 This function is used during the pre-compile phase when we are trying to find -

6964 out the amount of memory needed, as well as during the real compile phase. The -

6965 value of lengthptr distinguishes the two phases. -

6966 -

6967 Arguments: -

6968 options option bits, including any changes for this subpattern -

6969 codeptr -> the address of the current code pointer -

6970 ptrptr -> the address of the current pattern pointer -

6971 errorcodeptr -> pointer to error code variable -

6972 lookbehind TRUE if this is a lookbehind assertion -

6973 reset_bracount TRUE to reset the count for each branch -

6974 skipbytes skip this many bytes at start (for brackets and OP_COND) -

6975 cond_depth depth of nesting for conditional subpatterns -

6976 firstcharptr place to put the first required character, or a negative number -

6977 reqcharptr place to put the last required character, or a negative number -

6978 bcptr pointer to the chain of currently open branches -

6979 cd points to the data block with tables pointers etc. -

6980 lengthptr NULL during the real compile phase -

6981 points to length accumulator during pre-compile phase -

6982 -

6983 Returns: TRUE on success -

6984 */ -

6985 -

6986 static BOOL -

6987 compile_regex(int options, pcre_uchar **codeptr, const pcre_uchar **ptrptr, -

6988 int *errorcodeptr, BOOL lookbehind, BOOL reset_bracount, int skipbytes, -

6989 int cond_depth, pcre_int32 *firstcharptr, pcre_int32 *reqcharptr, -

6990 branch_chain *bcptr, compile_data *cd, int *lengthptr) -

6991 { -

6992

executed (the execution status of this line is deduced): const pcre_uchar *ptr = *ptrptr;

6993

pcre_uchar *code = *codeptr;

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

6994

pcre_uchar *last_branch = code;

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

6995

pcre_uchar *start_bracket = code;

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

6996

pcre_uchar *reverse_count = NULL;

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

6997

open_capitem capitem;

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

6998

int capnumber = 0;

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

6999

pcre_int32 firstchar, reqchar;

executed (the execution status of this line is deduced): pcre_int32 firstchar, reqchar;

7000

pcre_int32 branchfirstchar, branchreqchar;

executed (the execution status of this line is deduced): pcre_int32 branchfirstchar, branchreqchar;

7001

int length;

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

7002

int orig_bracount;

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

7003

int max_bracount;

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

7004

branch_chain bc;

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

7005 -

7006

bc.outer = bcptr;

executed (the execution status of this line is deduced): bc.outer = bcptr;

7007

bc.current_branch = code;

executed (the execution status of this line is deduced): bc.current_branch = code;

7008 -

7009

firstchar = reqchar = REQ_UNSET;

executed (the execution status of this line is deduced): firstchar = reqchar = (-2);

7010 -

7011 /* Accumulate the length for use in the pre-compile phase. Start with the -

7012 length of the BRA and KET and any extra bytes that are required at the -

7013 beginning. We accumulate in a local variable to save frequent testing of -

7014 lenthptr for NULL. We cannot do this by looking at the value of code at the -

7015 start and end of each alternative, because compiled items are discarded during -

7016 the pre-compile phase so that the work space is not exceeded. */ -

7017 -

7018

length = 2 + 2*LINK_SIZE + skipbytes;

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

7019 -

7020 /* WARNING: If the above line is changed for any reason, you must also change -

7021 the code that abstracts option settings at the start of the pattern and makes -

7022 them global. It tests the value of length for (2 + 2*LINK_SIZE) in the -

7023 pre-compile phase to find out whether anything has yet been compiled or not. */ -

7024 -

7025 /* If this is a capturing subpattern, add to the chain of open capturing items -

7026 so that we can detect them if (*ACCEPT) is encountered. This is also used to -

7027 detect groups that contain recursive back references to themselves. Note that -

7028 only OP_CBRA need be tested here; changing this opcode to one of its variants, -

7029 e.g. OP_SCBRAPOS, happens later, after the group has been compiled. */ -

7030 -

7031

if (*code == OP_CBRA)

evaluated: *code == OP_CBRA

TRUE	FALSE
yes Evaluation Count:382	yes Evaluation Count:793

382-793

7032 { -

7033

capnumber = GET2(code, 1 + LINK_SIZE);

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

7034

capitem.number = capnumber;

executed (the execution status of this line is deduced): capitem.number = capnumber;

7035

capitem.next = cd->open_caps;

executed (the execution status of this line is deduced): capitem.next = cd->open_caps;

7036

capitem.flag = FALSE;

executed (the execution status of this line is deduced): capitem.flag = 0;

7037

cd->open_caps = &capitem;

executed (the execution status of this line is deduced): cd->open_caps = &capitem;

7038

code += 1 + LINK_SIZE + skipbytes;

executed: }

Execution Count:382

382

7039 -

7040 /* Offset is set zero to mark that this bracket is still open */ -

7041 -

7042

PUT(code, 1, 0);

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

7043

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

7044 -

7045 /* Loop for each alternative branch */ -

7046 -

7047

orig_bracount = max_bracount = cd->bracount;

executed (the execution status of this line is deduced): orig_bracount = max_bracount = cd->bracount;

7048

if (reset_bracount) cd->bracount = orig_bracount;

executed (the execution status of this line is deduced): for (;;)

7049 { -

7050 /* For a (?| group, reset the capturing bracket count so that each branch -

7051 uses the same numbers. */ -

7052 -

7053

executed: cd->bracount = orig_bracount;

Execution Count:16

evaluated: reset_bracount

TRUE	FALSE
yes Evaluation Count:16	yes Evaluation Count:1198

16-1198

7054 -

7055 /* Set up dummy OP_REVERSE if lookbehind assertion */ -

7056 -

7057

if (lookbehind)

partially evaluated: lookbehind

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:1214

0-1214

7058 { -

7059

*code++ = OP_REVERSE;

never executed (the execution status of this line is deduced): *code++ = OP_REVERSE;

7060

reverse_count = code;

never executed (the execution status of this line is deduced): reverse_count = code;

7061

PUTINC(code, 0, 0);

never executed (the execution status of this line is deduced): (code[0] = (0)), code += 1;

7062

length += 1 + LINK_SIZE;

never executed (the execution status of this line is deduced): length += 1 + 1;

7063

if (!compile_branch(&options, &code, &ptr, errorcodeptr, &branchfirstchar,

never executed: }

7064 -

7065 /* Now compile the branch; in the pre-compile phase its length gets added -

7066 into the length. */ -

7067 -

7068

evaluated:

!compile_branch(&options, &code, &ptr, errorcodeptr, &branchfirstchar, &branchreqchar, &bc, cond_depth, cd, (lengthptr == ((void *)0))? ((void *)0) : &length)

TRUE	FALSE
yes Evaluation Count:11	yes Evaluation Count:1203

11-1203

7069

&branchreqchar, &bc, cond_depth, cd,

evaluated:

!compile_branch(&options, &code, &ptr, errorcodeptr, &branchfirstchar, &branchreqchar, &bc, cond_depth, cd, (lengthptr == ((void *)0))? ((void *)0) : &length)

TRUE	FALSE
yes Evaluation Count:11	yes Evaluation Count:1203

11-1203

7070

(lengthptr == NULL)? NULL : &length))

evaluated:

!compile_branch(&options, &code, &ptr, errorcodeptr, &branchfirstchar, &branchreqchar, &bc, cond_depth, cd, (lengthptr == ((void *)0))? ((void *)0) : &length)

TRUE	FALSE
yes Evaluation Count:11	yes Evaluation Count:1203

11-1203

7071 { -

7072

executed (the execution status of this line is deduced): *ptrptr = ptr;

7073

if (cd->bracount > max_bracount) max_bracount = cd->bracount;

executed: return 0;

Execution Count:11

7074 } -

7075 -

7076 /* Keep the highest bracket count in case (?| was used and some branch -

7077 has fewer than the rest. */ -

7078 -

7079

executed: max_bracount = cd->bracount;

Execution Count:272

evaluated: cd->bracount > max_bracount

TRUE	FALSE
yes Evaluation Count:272	yes Evaluation Count:931

272-931

7080 -

7081 /* In the real compile phase, there is some post-processing to be done. */ -

7082 -

7083

if (*last_branch != OP_ALT)

evaluated: lengthptr == ((void *)0)

TRUE	FALSE
yes Evaluation Count:600	yes Evaluation Count:603

600-603

7084 { -

7085 /* If this is the first branch, the firstchar and reqchar values for the -

7086 branch become the values for the regex. */ -

7087 -

7088

evaluated: *last_branch != OP_ALT

TRUE	FALSE
yes Evaluation Count:581	yes Evaluation Count:19

19-581

7089 { -

7090

firstchar = branchfirstchar;

executed (the execution status of this line is deduced): firstchar = branchfirstchar;

7091

reqchar = branchreqchar;

executed (the execution status of this line is deduced): reqchar = branchreqchar;

7092

if (firstchar >= 0 && firstchar != branchfirstchar)

executed: }

Execution Count:581

581

7093 -

7094 /* If this is not the first branch, the first char and reqchar have to -

7095 match the values from all the previous branches, except that if the -

7096 previous value for reqchar didn't have REQ_VARY set, it can still match, -

7097 and we set REQ_VARY for the regex. */ -

7098 -

7099 else -

7100 { -

7101 /* If we previously had a firstchar, but it doesn't match the new branch, -

7102 we have to abandon the firstchar for the regex, but if there was -

7103 previously no reqchar, it takes on the value of the old firstchar. */ -

7104 -

7105

evaluated: firstchar >= 0

TRUE	FALSE
yes Evaluation Count:16	yes Evaluation Count:3

evaluated: firstchar != branchfirstchar

TRUE	FALSE
yes Evaluation Count:15	yes Evaluation Count:1

1-16

7106 { -

7107

if (reqchar < 0) reqchar = firstchar;

executed: reqchar = firstchar;

Execution Count:1

evaluated: reqchar < 0

TRUE	FALSE
yes Evaluation Count:1	yes Evaluation Count:14

1-14

7108

firstchar = REQ_NONE;

executed (the execution status of this line is deduced): firstchar = (-1);

7109

if (firstchar < 0 && branchfirstchar >= 0 && branchreqchar < 0)

executed: }

Execution Count:15

7110 -

7111 /* If we (now or from before) have no firstchar, a firstchar from the -

7112 branch becomes a reqchar if there isn't a branch reqchar. */ -

7113 -

7114

evaluated: firstchar < 0

TRUE	FALSE
yes Evaluation Count:18	yes Evaluation Count:1

evaluated: branchfirstchar >= 0

TRUE	FALSE
yes Evaluation Count:16	yes Evaluation Count:2

evaluated: branchreqchar < 0

TRUE	FALSE
yes Evaluation Count:1	yes Evaluation Count:15

1-18

7115

branchreqchar = branchfirstchar;

executed: branchreqchar = branchfirstchar;

Execution Count:1

7116 -

7117 /* Now ensure that the reqchars match */ -

7118 -

7119

if ((reqchar & ~REQ_VARY) != (branchreqchar & ~REQ_VARY))

partially evaluated: (reqchar & ~0x20000000l) != (branchreqchar & ~0x20000000l)

TRUE	FALSE
yes Evaluation Count:19	no Evaluation Count:0

0-19

7120

reqchar = REQ_NONE;

executed: reqchar = (-1);

Execution Count:19

7121

else reqchar |= branchreqchar; /* To "or" REQ_VARY */

never executed: reqchar |= branchreqchar;

7122 } -

7123 -

7124 /* If lookbehind, check that this branch matches a fixed-length string, and -

7125 put the length into the OP_REVERSE item. Temporarily mark the end of the -

7126 branch with OP_END. If the branch contains OP_RECURSE, the result is -3 -

7127 because there may be forward references that we can't check here. Set a -

7128 flag to cause another lookbehind check at the end. Why not do it all at the -

7129 end? Because common, erroneous checks are picked up here and the offset of -

7130 the problem can be shown. */ -

7131 -

7132

if (lookbehind)

partially evaluated: lookbehind

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:600

0-600

7133 { -

7134

int fixed_length;

never executed (the execution status of this line is deduced): int fixed_length;

7135

fixed_length = find_fixedlength(last_branch, (options & PCRE_UTF8) != 0,

never executed (the execution status of this line is deduced): *code = OP_END;

7136

never executed (the execution status of this line is deduced): fixed_length = find_fixedlength(last_branch, (options & 0x00000800) != 0,

7137

FALSE, cd);

never executed (the execution status of this line is deduced): 0, cd);

7138 DPRINTF(("fixed length = %d\n", fixed_length)); -

7139

if (fixed_length == -3)

never evaluated: fixed_length == -3

7140 { -

7141

cd->check_lookbehind = TRUE;

never executed (the execution status of this line is deduced): cd->check_lookbehind = 1;

7142

else if (fixed_length < 0)

never executed: }

7143

never evaluated: fixed_length < 0

7144 { -

7145

*errorcodeptr = (fixed_length == -2)? ERR36 :

never evaluated: (fixed_length == -2)

7146

(fixed_length == -4)? ERR70: ERR25;

never executed (the execution status of this line is deduced): (fixed_length == -4)? ERR70: ERR25;

7147

never executed (the execution status of this line is deduced): *ptrptr = ptr;

7148

else { PUT(reverse_count, 0, fixed_length); }

never executed: return 0;

7149 } -

7150

never executed: }

7151 } -

7152

if (*ptr != CHAR_VERTICAL_LINE)

executed: }

Execution Count:600

600

7153 -

7154 /* Reached end of expression, either ')' or end of pattern. In the real -

7155 compile phase, go back through the alternative branches and reverse the chain -

7156 of offsets, with the field in the BRA item now becoming an offset to the -

7157 first alternative. If there are no alternatives, it points to the end of the -

7158 group. The length in the terminating ket is always the length of the whole -

7159 bracketed item. Return leaving the pointer at the terminating char. */ -

7160 -

7161

evaluated: *ptr != '\174'

TRUE	FALSE
yes Evaluation Count:1164	yes Evaluation Count:39

39-1164

7162 { -

7163

int branch_length = (int)(code - last_branch);

evaluated: lengthptr == ((void *)0)

TRUE	FALSE
yes Evaluation Count:581	yes Evaluation Count:583

581-583

7164 { -

7165

executed (the execution status of this line is deduced): int branch_length = (int)(code - last_branch);

7166 do -

7167 { -

7168

int prev_length = GET(last_branch, 1);

executed (the execution status of this line is deduced): int prev_length = (last_branch[1]);

7169

PUT(last_branch, 1, branch_length);

executed (the execution status of this line is deduced): (last_branch[1] = (branch_length));

7170

branch_length = prev_length;

executed (the execution status of this line is deduced): branch_length = prev_length;

7171

last_branch -= branch_length;

executed (the execution status of this line is deduced): last_branch -= branch_length;

7172

while (branch_length > 0);

executed: }

Execution Count:600

600

7173

evaluated: branch_length > 0

TRUE	FALSE
yes Evaluation Count:19	yes Evaluation Count:581

19-581

7174

PUT(code, 1, (int)(code - start_bracket));

executed: }

Execution Count:581

581

7175 -

7176 /* Fill in the ket */ -

7177 -

7178

*code = OP_KET;

executed (the execution status of this line is deduced): *code = OP_KET;

7179

executed (the execution status of this line is deduced): (code[1] = ((int)(code - start_bracket)));

7180

memmove(start_bracket + 1 + LINK_SIZE, start_bracket,

executed (the execution status of this line is deduced): code += 1 + 1;

7181 -

7182 /* If it was a capturing subpattern, check to see if it contained any -

7183 recursive back references. If so, we must wrap it in atomic brackets. -

7184 In any event, remove the block from the chain. */ -

7185 -

7186

if (capnumber > 0)

evaluated: capnumber > 0

TRUE	FALSE
yes Evaluation Count:382	yes Evaluation Count:782

382-782

7187 { -

7188

if (cd->open_caps->flag)

partially evaluated: cd->open_caps->flag

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:382

0-382

7189 { -

7190

never executed (the execution status of this line is deduced): memmove(start_bracket + 1 + 1, start_bracket,

7191

IN_UCHARS(code - start_bracket));

never executed (the execution status of this line is deduced): ((code - start_bracket) << 1));

7192

*start_bracket = OP_ONCE;

never executed (the execution status of this line is deduced): *start_bracket = OP_ONCE;

7193

PUT(start_bracket, 1, (int)(code - start_bracket));

never executed (the execution status of this line is deduced): code += 1 + 1;

7194

never executed (the execution status of this line is deduced): (start_bracket[1] = ((int)(code - start_bracket)));

7195

*code = OP_KET;

never executed (the execution status of this line is deduced): *code = OP_KET;

7196

PUT(code, 1, (int)(code - start_bracket));

never executed (the execution status of this line is deduced): (code[1] = ((int)(code - start_bracket)));

7197

length += 2 + 2*LINK_SIZE;

never executed (the execution status of this line is deduced): code += 1 + 1;

7198

never executed (the execution status of this line is deduced): length += 2 + 2*1;

7199

cd->open_caps = cd->open_caps->next;

never executed: }

7200

executed (the execution status of this line is deduced): cd->open_caps = cd->open_caps->next;

7201

cd->bracount = max_bracount;

executed: }

Execution Count:382

382

7202 -

7203 /* Retain the highest bracket number, in case resetting was used. */ -

7204 -

7205

executed (the execution status of this line is deduced): cd->bracount = max_bracount;

7206 -

7207 /* Set values to pass back */ -

7208 -

7209

*codeptr = code;

executed (the execution status of this line is deduced): *codeptr = code;

7210

*firstcharptr = firstchar;

executed (the execution status of this line is deduced): *ptrptr = ptr;

7211

executed (the execution status of this line is deduced): *firstcharptr = firstchar;

7212

*reqcharptr = reqchar;

executed (the execution status of this line is deduced): *reqcharptr = reqchar;

7213

if (OFLOW_MAX - *lengthptr < length)

evaluated: lengthptr != ((void *)0)

TRUE	FALSE
yes Evaluation Count:583	yes Evaluation Count:581

581-583

7214 { -

7215

partially evaluated: (2147483647 - 20) - *lengthptr < length

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:583

0-583

7216 { -

7217

never executed (the execution status of this line is deduced): *errorcodeptr = ERR20;

7218

never executed: return 0;

7219 } -

7220

*lengthptr += length;

executed (the execution status of this line is deduced): *lengthptr += length;

7221

executed: }

Execution Count:583

583

7222

executed: return 1;

Execution Count:1164

1164

7223 } -

7224 -

7225 /* Another branch follows. In the pre-compile phase, we can move the code -

7226 pointer back to where it was for the start of the first branch. (That is, -

7227 pretend that each branch is the only one.) -

7228 -

7229 In the real compile phase, insert an ALT node. Its length field points back -

7230 to the previous branch while the bracket remains open. At the end the chain -

7231 is reversed. It's done like this so that the start of the bracket has a -

7232 zero offset until it is closed, making it possible to detect recursion. */ -

7233 -

7234

code = *codeptr + 1 + LINK_SIZE + skipbytes;

evaluated: lengthptr != ((void *)0)

TRUE	FALSE
yes Evaluation Count:20	yes Evaluation Count:19

19-20

7235 { -

7236

executed (the execution status of this line is deduced): code = *codeptr + 1 + 1 + skipbytes;

7237

length += 1 + LINK_SIZE;

executed (the execution status of this line is deduced): length += 1 + 1;

7238

PUT(code, 1, (int)(code - last_branch));

executed: }

Execution Count:20

7239 else -

7240 { -

7241

*code = OP_ALT;

executed (the execution status of this line is deduced): *code = OP_ALT;

7242

executed (the execution status of this line is deduced): (code[1] = ((int)(code - last_branch)));

7243

bc.current_branch = last_branch = code;

executed (the execution status of this line is deduced): bc.current_branch = last_branch = code;

7244

executed (the execution status of this line is deduced): code += 1 + 1;

7245

executed: }

Execution Count:19

7246 -

7247

executed (the execution status of this line is deduced): ptr++;

7248

executed: }

Execution Count:39

7249 /* Control never reaches here */ -

7250

const pcre_uchar *scode = first_significant_code(

never executed: }

7251 -

7252 -

7253 -

7254 -

7255 /************************************************* -

7256 * Check for anchored expression * -

7257 *************************************************/ -

7258 -

7259 /* Try to find out if this is an anchored regular expression. Consider each -

7260 alternative branch. If they all start with OP_SOD or OP_CIRC, or with a bracket -

7261 all of whose alternatives start with OP_SOD or OP_CIRC (recurse ad lib), then -

7262 it's anchored. However, if this is a multiline pattern, then only OP_SOD will -

7263 be found, because ^ generates OP_CIRCM in that mode. -

7264 -

7265 We can also consider a regex to be anchored if OP_SOM starts all its branches. -

7266 This is the code for \G, which means "match at start of match position, taking -

7267 into account the match offset". -

7268 -

7269 A branch is also implicitly anchored if it starts with .* and DOTALL is set, -

7270 because that will try the rest of the pattern at all possible matching points, -

7271 so there is no point trying again.... er .... -

7272 -

7273 .... except when the .* appears inside capturing parentheses, and there is a -

7274 subsequent back reference to those parentheses. We haven't enough information -

7275 to catch that case precisely. -

7276 -

7277 At first, the best we could do was to detect when .* was in capturing brackets -

7278 and the highest back reference was greater than or equal to that level. -

7279 However, by keeping a bitmap of the first 31 back references, we can catch some -

7280 of the more common cases more precisely. -

7281 -

7282 Arguments: -

7283 code points to start of expression (the bracket) -

7284 bracket_map a bitmap of which brackets we are inside while testing; this -

7285 handles up to substring 31; after that we just have to take -

7286 the less precise approach -

7287 backref_map the back reference bitmap -

7288 -

7289 Returns: TRUE or FALSE -

7290 */ -

7291 -

7292 static BOOL -

7293 is_anchored(register const pcre_uchar *code, unsigned int bracket_map, -

7294 unsigned int backref_map) -

7295 { -

7296 do { -

7297

executed (the execution status of this line is deduced): const pcre_uchar *scode = first_significant_code(

7298

code + PRIV(OP_lengths)[*code], FALSE);

executed (the execution status of this line is deduced): code + _pcre16_OP_lengths[*code], 0);

7299

executed (the execution status of this line is deduced): register int op = *scode;

7300 -

7301 /* Non-capturing brackets */ -

7302 -

7303

if (op == OP_BRA || op == OP_BRAPOS ||

evaluated: op == OP_BRA

TRUE	FALSE
yes Evaluation Count:6	yes Evaluation Count:421

partially evaluated: op == OP_BRAPOS

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:421

0-421

7304

op == OP_SBRA || op == OP_SBRAPOS)

partially evaluated: op == OP_SBRA

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:421

partially evaluated: op == OP_SBRAPOS

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:421

0-421

7305 { -

7306

if (!is_anchored(scode, bracket_map, backref_map)) return FALSE;

executed: return 0;

Execution Count:6

partially evaluated: !is_anchored(scode, bracket_map, backref_map)

TRUE	FALSE
yes Evaluation Count:6	no Evaluation Count:0

0-6

7307

else if (op == OP_CBRA || op == OP_CBRAPOS ||

never executed: }

7308 -

7309 /* Capturing brackets */ -

7310 -

7311

evaluated: op == OP_CBRA

TRUE	FALSE
yes Evaluation Count:62	yes Evaluation Count:359

partially evaluated: op == OP_CBRAPOS

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:359

0-359

7312

op == OP_SCBRA || op == OP_SCBRAPOS)

partially evaluated: op == OP_SCBRA

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:359

partially evaluated: op == OP_SCBRAPOS

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:359

0-359

7313 { -

7314

int n = GET2(scode, 1+LINK_SIZE);

executed (the execution status of this line is deduced): int n = scode[1+1];

7315

int new_map = bracket_map | ((n < 32)? (1 << n) : 1);

executed (the execution status of this line is deduced): int new_map = bracket_map | ((n < 32)? (1 << n) : 1);

7316

if (!is_anchored(scode, new_map, backref_map)) return FALSE;

executed: return 0;

Execution Count:62

partially evaluated: !is_anchored(scode, new_map, backref_map)

TRUE	FALSE
yes Evaluation Count:62	no Evaluation Count:0

0-62

7317

else if (op == OP_ASSERT || op == OP_ONCE || op == OP_ONCE_NC ||

never executed: }

7318 -

7319 /* Other brackets */ -

7320 -

7321

partially evaluated: op == OP_ASSERT

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:359

partially evaluated: op == OP_ONCE

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:359

partially evaluated: op == OP_ONCE_NC

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:359

0-359

7322

op == OP_COND)

evaluated: op == OP_COND

TRUE	FALSE
yes Evaluation Count:2	yes Evaluation Count:357

2-357

7323 { -

7324

if (!is_anchored(scode, bracket_map, backref_map)) return FALSE;

executed: return 0;

Execution Count:2

partially evaluated: !is_anchored(scode, bracket_map, backref_map)

TRUE	FALSE
yes Evaluation Count:2	no Evaluation Count:0

0-2

7325

else if ((op == OP_TYPESTAR || op == OP_TYPEMINSTAR ||

never executed: }

7326 -

7327 /* .* is not anchored unless DOTALL is set (which generates OP_ALLANY) and -

7328 it isn't in brackets that are or may be referenced. */ -

7329 -

7330

evaluated: op == OP_TYPESTAR

TRUE	FALSE
yes Evaluation Count:12	yes Evaluation Count:345

evaluated: op == OP_TYPEMINSTAR

TRUE	FALSE
yes Evaluation Count:1	yes Evaluation Count:344

1-345

7331

op == OP_TYPEPOSSTAR))

partially evaluated: op == OP_TYPEPOSSTAR

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:344

0-344

7332 { -

7333

if (scode[1] != OP_ALLANY || (bracket_map & backref_map) != 0)

partially evaluated: scode[1] != OP_ALLANY

TRUE	FALSE
yes Evaluation Count:13	no Evaluation Count:0

never evaluated: (bracket_map & backref_map) != 0

0-13

7334

executed: return 0;

Execution Count:13

7335

else if (op != OP_SOD && op != OP_SOM && op != OP_CIRC) return FALSE;

never executed: }

7336 -

7337 /* Check for explicit anchoring */ -

7338 -

7339

executed: return 0;

Execution Count:306

evaluated: op != OP_SOD

TRUE	FALSE
yes Evaluation Count:327	yes Evaluation Count:17

evaluated: op != OP_SOM

TRUE	FALSE
yes Evaluation Count:326	yes Evaluation Count:1

evaluated: op != OP_CIRC

TRUE	FALSE
yes Evaluation Count:306	yes Evaluation Count:20

1-327

7340

executed (the execution status of this line is deduced): code += (code[1]);

7341

while (*code == OP_ALT); /* Loop for each alternative */

executed: }

Execution Count:38

7342

partially evaluated: *code == OP_ALT

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:38

0-38

7343

const pcre_uchar *scode = first_significant_code(

executed: return 1;

Execution Count:38

7344 } -

7345 -

7346 -

7347 -

7348 /************************************************* -

7349 * Check for starting with ^ or .* * -

7350 *************************************************/ -

7351 -

7352 /* This is called to find out if every branch starts with ^ or .* so that -

7353 "first char" processing can be done to speed things up in multiline -

7354 matching and for non-DOTALL patterns that start with .* (which must start at -

7355 the beginning or after \n). As in the case of is_anchored() (see above), we -

7356 have to take account of back references to capturing brackets that contain .* -

7357 because in that case we can't make the assumption. -

7358 -

7359 Arguments: -

7360 code points to start of expression (the bracket) -

7361 bracket_map a bitmap of which brackets we are inside while testing; this -

7362 handles up to substring 31; after that we just have to take -

7363 the less precise approach -

7364 backref_map the back reference bitmap -

7365 -

7366 Returns: TRUE or FALSE -

7367 */ -

7368 -

7369 static BOOL -

7370 is_startline(const pcre_uchar *code, unsigned int bracket_map, -

7371 unsigned int backref_map) -

7372 { -

7373 do { -

7374

executed (the execution status of this line is deduced): const pcre_uchar *scode = first_significant_code(

7375

code + PRIV(OP_lengths)[*code], FALSE);

executed (the execution status of this line is deduced): code + _pcre16_OP_lengths[*code], 0);

7376

executed (the execution status of this line is deduced): register int op = *scode;

7377 -

7378 /* If we are at the start of a conditional assertion group, *both* the -

7379 conditional assertion *and* what follows the condition must satisfy the test -

7380 for start of line. Other kinds of condition fail. Note that there may be an -

7381 auto-callout at the start of a condition. */ -

7382 -

7383

if (op == OP_COND)

evaluated: op == OP_COND

TRUE	FALSE
yes Evaluation Count:2	yes Evaluation Count:123

2-123

7384 { -

7385

scode += 1 + LINK_SIZE;

executed (the execution status of this line is deduced): scode += 1 + 1;

7386

if (*scode == OP_CALLOUT) scode += PRIV(OP_lengths)[OP_CALLOUT];

never executed: scode += _pcre16_OP_lengths[OP_CALLOUT];

partially evaluated: *scode == OP_CALLOUT

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:2

0-2

7387 switch (*scode) -

7388 { -

7389 case OP_CREF: -

7390 case OP_NCREF: -

7391 case OP_RREF: -

7392 case OP_NRREF: -

7393 case OP_DEF: -

7394

if (!is_startline(scode, bracket_map, backref_map)) return FALSE;

executed: return 0;

Execution Count:2

7395 -

7396 default: /* Assertion */ -

7397

never executed: return 0;

never evaluated: !is_startline(scode, bracket_map, backref_map)

7398

do scode += GET(scode, 1); while (*scode == OP_ALT);

never executed: scode += (scode[1]);

never evaluated: *scode == OP_ALT

7399

scode += 1 + LINK_SIZE;

never executed (the execution status of this line is deduced): scode += 1 + 1;

7400

scode = first_significant_code(scode, FALSE);

never executed: break;

7401 } -

7402

never executed (the execution status of this line is deduced): scode = first_significant_code(scode, 0);

7403

op = *scode;

never executed (the execution status of this line is deduced): op = *scode;

7404

if (op == OP_BRA || op == OP_BRAPOS ||

never executed: }

7405 -

7406 /* Non-capturing brackets */ -

7407 -

7408

evaluated: op == OP_BRA

TRUE	FALSE
yes Evaluation Count:5	yes Evaluation Count:118

partially evaluated: op == OP_BRAPOS

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:118

0-118

7409

op == OP_SBRA || op == OP_SBRAPOS)

partially evaluated: op == OP_SBRA

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:118

partially evaluated: op == OP_SBRAPOS

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:118

0-118

7410 { -

7411

if (!is_startline(scode, bracket_map, backref_map)) return FALSE;

executed: return 0;

Execution Count:5

partially evaluated: !is_startline(scode, bracket_map, backref_map)

TRUE	FALSE
yes Evaluation Count:5	no Evaluation Count:0

0-5

7412

else if (op == OP_CBRA || op == OP_CBRAPOS ||

never executed: }

7413 -

7414 /* Capturing brackets */ -

7415 -

7416

evaluated: op == OP_CBRA

TRUE	FALSE
yes Evaluation Count:39	yes Evaluation Count:79

partially evaluated: op == OP_CBRAPOS

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:79

0-79

7417

op == OP_SCBRA || op == OP_SCBRAPOS)

partially evaluated: op == OP_SCBRA

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:79

partially evaluated: op == OP_SCBRAPOS

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:79

0-79

7418 { -

7419

int n = GET2(scode, 1+LINK_SIZE);

executed (the execution status of this line is deduced): int n = scode[1+1];

7420

int new_map = bracket_map | ((n < 32)? (1 << n) : 1);

executed (the execution status of this line is deduced): int new_map = bracket_map | ((n < 32)? (1 << n) : 1);

7421

if (!is_startline(scode, new_map, backref_map)) return FALSE;

executed: return 0;

Execution Count:37

evaluated: !is_startline(scode, new_map, backref_map)

TRUE	FALSE
yes Evaluation Count:37	yes Evaluation Count:2

2-37

7422

else if (op == OP_ASSERT || op == OP_ONCE || op == OP_ONCE_NC)

executed: }

Execution Count:2

7423 -

7424 /* Other brackets */ -

7425 -

7426

partially evaluated: op == OP_ASSERT

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:79

partially evaluated: op == OP_ONCE

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:79

partially evaluated: op == OP_ONCE_NC

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:79

0-79

7427 { -

7428

if (!is_startline(scode, bracket_map, backref_map)) return FALSE;

never executed: return 0;

never evaluated: !is_startline(scode, bracket_map, backref_map)

7429

else if (op == OP_TYPESTAR || op == OP_TYPEMINSTAR || op == OP_TYPEPOSSTAR)

never executed: }

7430 -

7431 /* .* means "start at start or after \n" if it isn't in brackets that -

7432 may be referenced. */ -

7433 -

7434

evaluated: op == OP_TYPESTAR

TRUE	FALSE
yes Evaluation Count:12	yes Evaluation Count:67

evaluated: op == OP_TYPEMINSTAR

TRUE	FALSE
yes Evaluation Count:1	yes Evaluation Count:66

partially evaluated: op == OP_TYPEPOSSTAR

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:66

0-67

7435 { -

7436

if (scode[1] != OP_ANY || (bracket_map & backref_map) != 0) return FALSE;

executed: return 0;

Execution Count:5

evaluated: scode[1] != OP_ANY

TRUE	FALSE
yes Evaluation Count:5	yes Evaluation Count:8

partially evaluated: (bracket_map & backref_map) != 0

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:8

0-8

7437

else if (op != OP_CIRC && op != OP_CIRCM) return FALSE;

executed: }

Execution Count:8

7438 -

7439 /* Check for explicit circumflex */ -

7440 -

7441

executed: return 0;

Execution Count:64

partially evaluated: op != OP_CIRC

TRUE	FALSE
yes Evaluation Count:66	no Evaluation Count:0

evaluated: op != OP_CIRCM

TRUE	FALSE
yes Evaluation Count:64	yes Evaluation Count:2

0-66

7442 -

7443 /* Move on to the next alternative */ -

7444 -

7445

executed (the execution status of this line is deduced): code += (code[1]);

7446

while (*code == OP_ALT); /* Loop for each alternative */

executed: }

Execution Count:12

7447

partially evaluated: *code == OP_ALT

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:12

0-12

7448

int xl = (*code == OP_CBRA || *code == OP_SCBRA ||

executed: return 1;

Execution Count:12

7449 } -

7450 -

7451 -

7452 -

7453 /************************************************* -

7454 * Check for asserted fixed first char * -

7455 *************************************************/ -

7456 -

7457 /* During compilation, the "first char" settings from forward assertions are -

7458 discarded, because they can cause conflicts with actual literals that follow. -

7459 However, if we end up without a first char setting for an unanchored pattern, -

7460 it is worth scanning the regex to see if there is an initial asserted first -

7461 char. If all branches start with the same asserted char, or with a bracket all -

7462 of whose alternatives start with the same asserted char (recurse ad lib), then -

7463 we return that char, otherwise -1. -

7464 -

7465 Arguments: -

7466 code points to start of expression (the bracket) -

7467 inassert TRUE if in an assertion -

7468 -

7469 Returns: -1 or the fixed first char -

7470 */ -

7471 -

7472 static int -

7473 find_firstassertedchar(const pcre_uchar *code, BOOL inassert) -

7474 { -

7475

executed (the execution status of this line is deduced): register int c = -1;

7476 do { -

7477

int d;

executed (the execution status of this line is deduced): int d;

7478

evaluated: *code == OP_CBRA

TRUE	FALSE
yes Evaluation Count:39	yes Evaluation Count:88

partially evaluated: *code == OP_SCBRA

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:88

0-88

7479

*code == OP_CBRAPOS || *code == OP_SCBRAPOS)? IMM2_SIZE:0;

partially evaluated: *code == OP_CBRAPOS

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:88

partially evaluated: *code == OP_SCBRAPOS

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:88

0-88

7480

const pcre_uchar *scode = first_significant_code(code + 1+LINK_SIZE + xl,

executed (the execution status of this line is deduced): const pcre_uchar *scode = first_significant_code(code + 1+1 + xl,

7481

TRUE);

executed (the execution status of this line is deduced): 1);

7482

executed (the execution status of this line is deduced): register int op = *scode;

7483 -

7484 switch(op) -

7485 { -

7486 default: -

7487

if ((d = find_firstassertedchar(scode, op == OP_ASSERT)) < 0)

executed: return -1;

Execution Count:66

7488 -

7489 case OP_BRA: -

7490 case OP_BRAPOS: -

7491 case OP_CBRA: -

7492 case OP_SCBRA: -

7493 case OP_CBRAPOS: -

7494 case OP_SCBRAPOS: -

7495 case OP_ASSERT: -

7496 case OP_ONCE: -

7497 case OP_ONCE_NC: -

7498 case OP_COND: -

7499

partially evaluated: (d = find_firstassertedchar(scode, op == OP_ASSERT)) < 0

TRUE	FALSE
yes Evaluation Count:46	no Evaluation Count:0

0-46

7500

if (c < 0) c = d; else if (c != d) return -1;

executed: return -1;

Execution Count:46

7501

never executed: c = d;

never executed: return -1;

never evaluated: c != d

never evaluated: c < 0

7502

if (!inassert) return -1;

never executed: break;

7503 -

7504 case OP_EXACT: -

7505

scode += IMM2_SIZE;

executed (the execution status of this line is deduced): scode += 1;

7506 /* Fall through */ -

7507 -

7508

case OP_CHAR:

code before this statement never executed: case OP_CHAR:

7509 case OP_PLUS: -

7510 case OP_MINPLUS: -

7511 case OP_POSPLUS: -

7512

executed: return -1;

Execution Count:15

partially evaluated: !inassert

TRUE	FALSE
yes Evaluation Count:15	no Evaluation Count:0

0-15

7513

if (c < 0) c = scode[1];

never executed: c = scode[1];

never evaluated: c < 0

7514

else if (c != scode[1]) return -1;

never executed: return -1;

never evaluated: c != scode[1]

7515

if (!inassert) return -1;

never executed: break;

7516 -

7517 case OP_EXACTI: -

7518

scode += IMM2_SIZE;

never executed (the execution status of this line is deduced): scode += 1;

7519 /* Fall through */ -

7520 -

7521

case OP_CHARI:

code before this statement never executed: case OP_CHARI:

7522 case OP_PLUSI: -

7523 case OP_MINPLUSI: -

7524 case OP_POSPLUSI: -

7525

never executed: return -1;

never evaluated: !inassert

7526

if (c < 0) c = scode[1] | REQ_CASELESS;

never executed: c = scode[1] | 0x10000000l;

never evaluated: c < 0

7527

else if (c != scode[1]) return -1;

never executed: return -1;

never evaluated: c != scode[1]

7528

never executed: break;

7529 } -

7530 -

7531

never executed (the execution status of this line is deduced): code += (code[1]);

7532

return pcre16_compile2(pattern, options, NULL, errorptr, erroroffset, tables);

never executed: }

7533

while (*code == OP_ALT);

never evaluated: *code == OP_ALT

7534

return c;

never executed: return c;

7535 } -

7536 -

7537 -

7538 -

7539 /************************************************* -

7540 * Compile a Regular Expression * -

7541 *************************************************/ -

7542 -

7543 /* This function takes a string and returns a pointer to a block of store -

7544 holding a compiled version of the expression. The original API for this -

7545 function had no error code return variable; it is retained for backwards -

7546 compatibility. The new function is given a new name. -

7547 -

7548 Arguments: -

7549 pattern the regular expression -

7550 options various option bits -

7551 errorcodeptr pointer to error code variable (pcre_compile2() only) -

7552 can be NULL if you don't want a code value -

7553 errorptr pointer to pointer to error text -

7554 erroroffset ptr offset in pattern where error was detected -

7555 tables pointer to character tables or NULL -

7556 -

7557 Returns: pointer to compiled data block, or NULL on error, -

7558 with errorptr and erroroffset set -

7559 */ -

7560 -

7561 #ifdef COMPILE_PCRE8 -

7562 PCRE_EXP_DEFN pcre * PCRE_CALL_CONVENTION -

7563 pcre_compile(const char *pattern, int options, const char **errorptr, -

7564 int *erroroffset, const unsigned char *tables) -

7565 #else -

7566 PCRE_EXP_DEFN pcre16 * PCRE_CALL_CONVENTION -

7567 pcre16_compile(PCRE_SPTR16 pattern, int options, const char **errorptr, -

7568 int *erroroffset, const unsigned char *tables) -

7569 #endif -

7570 { -

7571 #ifdef COMPILE_PCRE8 -

7572 return pcre_compile2(pattern, options, NULL, errorptr, erroroffset, tables); -

7573 #else -

7574

never executed: return pcre16_compile2(pattern, options, ((void *)0), errorptr, erroroffset, tables);

7575 #endif -

7576 } -

7577 -

7578 -

7579 #ifdef COMPILE_PCRE8 -

7580 PCRE_EXP_DEFN pcre * PCRE_CALL_CONVENTION -

7581 pcre_compile2(const char *pattern, int options, int *errorcodeptr, -

7582 const char **errorptr, int *erroroffset, const unsigned char *tables) -

7583 #else -

7584 PCRE_EXP_DEFN pcre16 * PCRE_CALL_CONVENTION -

7585 pcre16_compile2(PCRE_SPTR16 pattern, int options, int *errorcodeptr, -

7586 const char **errorptr, int *erroroffset, const unsigned char *tables) -

7587 #endif -

7588 { -

7589

REAL_PCRE *re;

executed (the execution status of this line is deduced): real_pcre16 *re;

7590

int length = 1; /* For final END opcode */

executed (the execution status of this line is deduced): int length = 1;

7591

pcre_int32 firstchar, reqchar;

executed (the execution status of this line is deduced): pcre_int32 firstchar, reqchar;

7592

int newline;

executed (the execution status of this line is deduced): int newline;

7593

int errorcode = 0;

executed (the execution status of this line is deduced): int errorcode = 0;

7594

int skipatstart = 0;

executed (the execution status of this line is deduced): int skipatstart = 0;

7595

BOOL utf;

executed (the execution status of this line is deduced): BOOL utf;

7596

size_t size;

executed (the execution status of this line is deduced): size_t size;

7597

pcre_uchar *code;

executed (the execution status of this line is deduced): pcre_uchar *code;

7598

const pcre_uchar *codestart;

executed (the execution status of this line is deduced): const pcre_uchar *codestart;

7599

const pcre_uchar *ptr;

executed (the execution status of this line is deduced): const pcre_uchar *ptr;

7600

compile_data compile_block;

executed (the execution status of this line is deduced): compile_data compile_block;

7601

compile_data *cd = &compile_block;

executed (the execution status of this line is deduced): compile_data *cd = &compile_block;

7602 -

7603 /* This space is used for "compiling" into during the first phase, when we are -

7604 computing the amount of memory that is needed. Compiled items are thrown away -

7605 as soon as possible, so that a fairly large buffer should be sufficient for -

7606 this purpose. The same space is used in the second phase for remembering where -

7607 to fill in forward references to subpatterns. That may overflow, in which case -

7608 new memory is obtained from malloc(). */ -

7609 -

7610

pcre_uchar cworkspace[COMPILE_WORK_SIZE];

executed (the execution status of this line is deduced): pcre_uchar cworkspace[(2048*1)];

7611 -

7612 /* Set this early so that early errors get offset 0. */ -

7613 -

7614

ptr = (const pcre_uchar *)pattern;

executed (the execution status of this line is deduced): ptr = (const pcre_uchar *)pattern;

7615 -

7616 /* We can't pass back an error message if errorptr is NULL; I guess the best we -

7617 can do is just return NULL, but we can set a code value if there is a code -

7618 pointer. */ -

7619 -

7620

if (errorptr == NULL)

partially evaluated: errorptr == ((void *)0)

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:369

0-369

7621 { -

7622

if (errorcodeptr != NULL) *errorcodeptr = 99;

never executed: *errorcodeptr = 99;

never evaluated: errorcodeptr != ((void *)0)

7623

return NULL;

never executed: return ((void *)0);

7624 } -

7625 -

7626

*errorptr = NULL;

executed (the execution status of this line is deduced): *errorptr = ((void *)0);

7627

if (errorcodeptr != NULL) *errorcodeptr = ERR0;

executed: *errorcodeptr = ERR0;

Execution Count:369

partially evaluated: errorcodeptr != ((void *)0)

TRUE	FALSE
yes Evaluation Count:369	no Evaluation Count:0

0-369

7628 -

7629 /* However, we can give a message for this error */ -

7630 -

7631

if (erroroffset == NULL)

partially evaluated: erroroffset == ((void *)0)

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:369

0-369

7632 { -

7633

errorcode = ERR16;

never executed (the execution status of this line is deduced): errorcode = ERR16;

7634

goto PCRE_EARLY_ERROR_RETURN2;

never executed: goto PCRE_EARLY_ERROR_RETURN2;

7635 } -

7636 -

7637

*erroroffset = 0;

executed (the execution status of this line is deduced): *erroroffset = 0;

7638 -

7639 /* Set up pointers to the individual character tables */ -

7640 -

7641

if (tables == NULL) tables = PRIV(default_tables);

executed: tables = _pcre16_default_tables;

Execution Count:369

partially evaluated: tables == ((void *)0)

TRUE	FALSE
yes Evaluation Count:369	no Evaluation Count:0

0-369

7642

cd->lcc = tables + lcc_offset;

executed (the execution status of this line is deduced): cd->lcc = tables + 0;

7643

cd->fcc = tables + fcc_offset;

executed (the execution status of this line is deduced): cd->fcc = tables + 256;

7644

cd->cbits = tables + cbits_offset;

executed (the execution status of this line is deduced): cd->cbits = tables + 512;

7645

cd->ctypes = tables + ctypes_offset;

executed (the execution status of this line is deduced): cd->ctypes = tables + (512 + 320);

7646 -

7647 /* Check that all undefined public option bits are zero */ -

7648 -

7649

if ((options & ~PUBLIC_COMPILE_OPTIONS) != 0)

partially evaluated:

(options & ~(0x00000001|0x00000008|0x00000010|0x00000002| 0x00000004|0x00000020|0x00000040|0x00000200|0x00000800| 0x00001000|0x00002000|0x00004000|0x00040000| 0x00080000|(0x00100000|0x00200000|0x00400000| 0x00500000)|0x00800000|0x01000000| 0x02000000|0x20000000|0x04000000)) != 0

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:369

0-369

7650 { -

7651

errorcode = ERR17;

never executed (the execution status of this line is deduced): errorcode = ERR17;

7652

while (ptr[skipatstart] == CHAR_LEFT_PARENTHESIS &&

never executed: goto PCRE_EARLY_ERROR_RETURN;

7653 } -

7654 -

7655 /* Check for global one-time settings at the start of the pattern, and remember -

7656 the offset for later. */ -

7657 -

7658

evaluated: ptr[skipatstart] == '\050'

TRUE	FALSE
yes Evaluation Count:49	yes Evaluation Count:323

49-323

7659

ptr[skipatstart+1] == CHAR_ASTERISK)

evaluated: ptr[skipatstart+1] == '\052'

TRUE	FALSE
yes Evaluation Count:3	yes Evaluation Count:46

3-46

7660 { -

7661

int newnl = 0;

executed (the execution status of this line is deduced): int newnl = 0;

7662

int newbsr = 0;

executed (the execution status of this line is deduced): int newbsr = 0;

7663 -

7664 #ifdef COMPILE_PCRE8 -

7665 if (STRNCMP_UC_C8(ptr+skipatstart+2, STRING_UTF_RIGHTPAR, 5) == 0) -

7666 { skipatstart += 7; options |= PCRE_UTF8; continue; } -

7667 #endif -

7668 #ifdef COMPILE_PCRE16 -

7669

if (STRNCMP_UC_C8(ptr+skipatstart+2, STRING_UTF_RIGHTPAR, 6) == 0)

partially evaluated: _pcre16_strncmp_uc_c8((ptr+skipatstart+2), ("\125" "\124" "\106" "\061" "\066" "\051"), (6)) == 0

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:3

0-3

7670

{ skipatstart += 8; options |= PCRE_UTF16; continue; }

never executed: continue;

7671 #endif -

7672

else if (STRNCMP_UC_C8(ptr+skipatstart+2, STRING_UCP_RIGHTPAR, 4) == 0)

partially evaluated: _pcre16_strncmp_uc_c8((ptr+skipatstart+2), ("\125" "\103" "\120" "\051"), (4)) == 0

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:3

0-3

7673

{ skipatstart += 6; options |= PCRE_UCP; continue; }

never executed: continue;

7674

else if (STRNCMP_UC_C8(ptr+skipatstart+2, STRING_NO_START_OPT_RIGHTPAR, 13) == 0)

partially evaluated:

_pcre16_strncmp_uc_c8((ptr+skipatstart+2), ("\116" "\117" "\137" "\123" "\124" "\101" "\122" "\124" "\137" "\117" "\120" "\124" "\051"), (13)) == 0

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:3

0-3

7675

{ skipatstart += 15; options |= PCRE_NO_START_OPTIMIZE; continue; }

never executed: continue;

7676 -

7677

if (STRNCMP_UC_C8(ptr+skipatstart+2, STRING_CR_RIGHTPAR, 3) == 0)

partially evaluated: _pcre16_strncmp_uc_c8((ptr+skipatstart+2), ("\103" "\122" "\051"), (3)) == 0

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:3

0-3

7678

{ skipatstart += 5; newnl = PCRE_NEWLINE_CR; }

never executed: }

7679

else if (STRNCMP_UC_C8(ptr+skipatstart+2, STRING_LF_RIGHTPAR, 3) == 0)

partially evaluated: _pcre16_strncmp_uc_c8((ptr+skipatstart+2), ("\114" "\106" "\051"), (3)) == 0

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:3

0-3

7680

{ skipatstart += 5; newnl = PCRE_NEWLINE_LF; }

never executed: }

7681

else if (STRNCMP_UC_C8(ptr+skipatstart+2, STRING_CRLF_RIGHTPAR, 5) == 0)

evaluated: _pcre16_strncmp_uc_c8((ptr+skipatstart+2), ("\103" "\122" "\114" "\106" "\051"), (5)) == 0

TRUE	FALSE
yes Evaluation Count:2	yes Evaluation Count:1

1-2

7682

{ skipatstart += 7; newnl = PCRE_NEWLINE_CR + PCRE_NEWLINE_LF; }

executed: }

Execution Count:2

7683

else if (STRNCMP_UC_C8(ptr+skipatstart+2, STRING_ANY_RIGHTPAR, 4) == 0)

partially evaluated: _pcre16_strncmp_uc_c8((ptr+skipatstart+2), ("\101" "\116" "\131" "\051"), (4)) == 0

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:1

0-1

7684

{ skipatstart += 6; newnl = PCRE_NEWLINE_ANY; }

never executed: }

7685

else if (STRNCMP_UC_C8(ptr+skipatstart+2, STRING_ANYCRLF_RIGHTPAR, 8) == 0)

partially evaluated: _pcre16_strncmp_uc_c8((ptr+skipatstart+2), ("\101" "\116" "\131" "\103" "\122" "\114" "\106" "\051"), (8)) == 0

TRUE	FALSE
yes Evaluation Count:1	no Evaluation Count:0

0-1

7686

{ skipatstart += 10; newnl = PCRE_NEWLINE_ANYCRLF; }

executed: }

Execution Count:1

7687 -

7688

else if (STRNCMP_UC_C8(ptr+skipatstart+2, STRING_BSR_ANYCRLF_RIGHTPAR, 12) == 0)

never evaluated:

_pcre16_strncmp_uc_c8((ptr+skipatstart+2), ("\102" "\123" "\122" "\137" "\101" "\116" "\131" "\103" "\122" "\114" "\106" "\051"), (12)) == 0

7689

{ skipatstart += 14; newbsr = PCRE_BSR_ANYCRLF; }

never executed: }

7690

else if (STRNCMP_UC_C8(ptr+skipatstart+2, STRING_BSR_UNICODE_RIGHTPAR, 12) == 0)

never evaluated:

_pcre16_strncmp_uc_c8((ptr+skipatstart+2), ("\102" "\123" "\122" "\137" "\125" "\116" "\111" "\103" "\117" "\104" "\105" "\051"), (12)) == 0

7691

{ skipatstart += 14; newbsr = PCRE_BSR_UNICODE; }

never executed: }

7692 -

7693

if (newnl != 0)

partially evaluated: newnl != 0

TRUE	FALSE
yes Evaluation Count:3	no Evaluation Count:0

0-3

7694

options = (options & ~PCRE_NEWLINE_BITS) | newnl;

executed: options = (options & ~(0x00100000|0x00200000|0x00400000| 0x00500000)) | newnl;

Execution Count:3

7695

else if (newbsr != 0)

never evaluated: newbsr != 0

7696

options = (options & ~(PCRE_BSR_ANYCRLF|PCRE_BSR_UNICODE)) | newbsr;

never executed: options = (options & ~(0x00800000|0x01000000)) | newbsr;

7697

utf = (options & PCRE_UTF8) != 0;

never executed: break;

7698 } -

7699 -

7700 /* PCRE_UTF16 has the same value as PCRE_UTF8. */ -

7701

executed (the execution status of this line is deduced): utf = (options & 0x00000800) != 0;

7702 -

7703 /* Can't support UTF unless PCRE has been compiled to include the code. The -

7704 return of an error code from PRIV(valid_utf)() is a new feature, introduced in -

7705 release 8.13. It is passed back from pcre_[dfa_]exec(), but at the moment is -

7706 not used here. */ -

7707 -

7708 #ifdef SUPPORT_UTF -

7709

if (utf && (options & PCRE_NO_UTF8_CHECK) == 0 &&

partially evaluated: utf

TRUE	FALSE
yes Evaluation Count:369	no Evaluation Count:0

partially evaluated: (options & 0x00002000) == 0

TRUE	FALSE
yes Evaluation Count:369	no Evaluation Count:0

0-369

7710

(errorcode = PRIV(valid_utf)((PCRE_PUCHAR)pattern, -1, erroroffset)) != 0)

evaluated: (errorcode = _pcre16_valid_utf((const pcre_uchar *)pattern, -1, erroroffset)) != 0

TRUE	FALSE
yes Evaluation Count:1	yes Evaluation Count:368

1-368

7711 { -

7712 #ifdef COMPILE_PCRE8 -

7713 errorcode = ERR44; -

7714 #else -

7715

errorcode = ERR74;

executed (the execution status of this line is deduced): errorcode = ERR74;

7716 #endif -

7717

goto PCRE_EARLY_ERROR_RETURN2;

executed: goto PCRE_EARLY_ERROR_RETURN2;

Execution Count:1

7718 } -

7719 #else -

7720 if (utf) -

7721 { -

7722 errorcode = ERR32; -

7723 goto PCRE_EARLY_ERROR_RETURN; -

7724 } -

7725 #endif -

7726 -

7727 /* Can't support UCP unless PCRE has been compiled to include the code. */ -

7728 -

7729 #ifndef SUPPORT_UCP -

7730 if ((options & PCRE_UCP) != 0) -

7731 { -

7732 errorcode = ERR67; -

7733 goto PCRE_EARLY_ERROR_RETURN; -

7734 } -

7735 #endif -

7736 -

7737 /* Check validity of \R options. */ -

7738 -

7739

if ((options & (PCRE_BSR_ANYCRLF|PCRE_BSR_UNICODE)) ==

partially evaluated: (options & (0x00800000|0x01000000)) == (0x00800000|0x01000000)

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:368

0-368

7740

(PCRE_BSR_ANYCRLF|PCRE_BSR_UNICODE))

partially evaluated: (options & (0x00800000|0x01000000)) == (0x00800000|0x01000000)

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:368

0-368

7741 { -

7742

errorcode = ERR56;

never executed (the execution status of this line is deduced): errorcode = ERR56;

7743

case 0: newline = NEWLINE; break; /* Build-time default */

never executed: goto PCRE_EARLY_ERROR_RETURN;

7744 } -

7745 -

7746 /* Handle different types of newline. The three bits give seven cases. The -

7747 current code allows for fixed one- or two-byte sequences, plus "any" and -

7748 "anycrlf". */ -

7749 -

7750 switch (options & PCRE_NEWLINE_BITS) -

7751 { -

7752

executed: break;

Execution Count:365

365

7753

case PCRE_NEWLINE_CR: newline = CHAR_CR; break;

never executed: break;

7754

case PCRE_NEWLINE_LF: newline = CHAR_NL; break;

never executed: break;

7755 case PCRE_NEWLINE_CR+ -

7756

PCRE_NEWLINE_LF: newline = (CHAR_CR << 8) | CHAR_NL; break;

executed: break;

Execution Count:2

7757

case PCRE_NEWLINE_ANY: newline = -1; break;

never executed: break;

7758

case PCRE_NEWLINE_ANYCRLF: newline = -2; break;

executed: break;

Execution Count:1

7759

default: errorcode = ERR56; goto PCRE_EARLY_ERROR_RETURN;

never executed: goto PCRE_EARLY_ERROR_RETURN;

7760 } -

7761 -

7762

if (newline == -2)

evaluated: newline == -2

TRUE	FALSE
yes Evaluation Count:1	yes Evaluation Count:367

1-367

7763 { -

7764

cd->nltype = NLTYPE_ANYCRLF;

executed (the execution status of this line is deduced): cd->nltype = 2;

7765

executed: }

Execution Count:1

7766

else if (newline < 0)

partially evaluated: newline < 0

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:367

0-367

7767 { -

7768

cd->nltype = NLTYPE_ANY;

never executed (the execution status of this line is deduced): cd->nltype = 1;

7769

cd->nltype = NLTYPE_FIXED;

never executed: }

7770 else -

7771 { -

7772

executed (the execution status of this line is deduced): cd->nltype = 0;

7773

if (newline > 255)

evaluated: newline > 255

TRUE	FALSE
yes Evaluation Count:2	yes Evaluation Count:365

2-365

7774 { -

7775

cd->nllen = 2;

executed (the execution status of this line is deduced): cd->nllen = 2;

7776

cd->nl[0] = (newline >> 8) & 255;

executed (the execution status of this line is deduced): cd->nl[0] = (newline >> 8) & 255;

7777

cd->nl[1] = newline & 255;

executed (the execution status of this line is deduced): cd->nl[1] = newline & 255;

7778

executed: }

Execution Count:2

7779 else -

7780 { -

7781

cd->nllen = 1;

executed (the execution status of this line is deduced): cd->nllen = 1;

7782

cd->nl[0] = newline;

executed (the execution status of this line is deduced): cd->nl[0] = newline;

7783

cd->bracount = cd->final_bracount = 0;

executed: }

Execution Count:365

365

7784 } -

7785 -

7786 /* Maximum back reference and backref bitmap. The bitmap records up to 31 back -

7787 references to help in deciding whether (.*) can be treated as anchored or not. -

7788 */ -

7789 -

7790

cd->top_backref = 0;

executed (the execution status of this line is deduced): cd->top_backref = 0;

7791

cd->backref_map = 0;

executed (the execution status of this line is deduced): cd->backref_map = 0;

7792 -

7793 /* Reflect pattern for debugging output */ -

7794 -

7795 DPRINTF(("------------------------------------------------------------------\n")); -

7796 #ifdef PCRE_DEBUG -

7797 print_puchar(stdout, (PCRE_PUCHAR)pattern); -

7798 #endif -

7799 DPRINTF(("\n")); -

7800 -

7801 /* Pretend to compile the pattern while actually just accumulating the length -

7802 of memory required. This behaviour is triggered by passing a non-NULL final -

7803 argument to compile_regex(). We pass a block of workspace (cworkspace) for it -

7804 to compile parts of the pattern into; the compiled code is discarded when it is -

7805 no longer needed, so hopefully this workspace will never overflow, though there -

7806 is a test for its doing so. */ -

7807 -

7808

executed (the execution status of this line is deduced): cd->bracount = cd->final_bracount = 0;

7809

cd->names_found = 0;

executed (the execution status of this line is deduced): cd->names_found = 0;

7810

cd->name_entry_size = 0;

executed (the execution status of this line is deduced): cd->name_entry_size = 0;

7811

cd->name_table = NULL;

executed (the execution status of this line is deduced): cd->name_table = ((void *)0);

7812

cd->start_code = cworkspace;

executed (the execution status of this line is deduced): cd->start_code = cworkspace;

7813

cd->hwm = cworkspace;

executed (the execution status of this line is deduced): cd->hwm = cworkspace;

7814

cd->start_workspace = cworkspace;

executed (the execution status of this line is deduced): cd->start_workspace = cworkspace;

7815

cd->workspace_size = COMPILE_WORK_SIZE;

executed (the execution status of this line is deduced): cd->workspace_size = (2048*1);

7816

cd->start_pattern = (const pcre_uchar *)pattern;

executed (the execution status of this line is deduced): cd->start_pattern = (const pcre_uchar *)pattern;

7817

cd->end_pattern = (const pcre_uchar *)(pattern + STRLEN_UC((const pcre_uchar *)pattern));

executed (the execution status of this line is deduced): cd->end_pattern = (const pcre_uchar *)(pattern + _pcre16_strlen_uc((const pcre_uchar *)pattern));

7818

cd->req_varyopt = 0;

executed (the execution status of this line is deduced): cd->req_varyopt = 0;

7819

cd->assert_depth = 0;

executed (the execution status of this line is deduced): cd->assert_depth = 0;

7820

cd->external_options = options;

executed (the execution status of this line is deduced): cd->external_options = options;

7821

cd->external_flags = 0;

executed (the execution status of this line is deduced): cd->external_flags = 0;

7822

cd->open_caps = NULL;

executed (the execution status of this line is deduced): cd->open_caps = ((void *)0);

7823 -

7824 /* Now do the pre-compile. On error, errorcode will be set non-zero, so we -

7825 don't need to look at the result of the function here. The initial options have -

7826 been put into the cd block so that they can be changed if an option setting is -

7827 found within the regex right at the beginning. Bringing initial option settings -

7828 outside can help speed up starting point checks. */ -

7829 -

7830

ptr += skipatstart;

executed (the execution status of this line is deduced): ptr += skipatstart;

7831

code = cworkspace;

executed (the execution status of this line is deduced): code = cworkspace;

7832

*code = OP_BRA;

executed (the execution status of this line is deduced): *code = OP_BRA;

7833

(void)compile_regex(cd->external_options, &code, &ptr, &errorcode, FALSE,

executed (the execution status of this line is deduced): (void)compile_regex(cd->external_options, &code, &ptr, &errorcode, 0,

7834

FALSE, 0, 0, &firstchar, &reqchar, NULL, cd, &length);

executed (the execution status of this line is deduced): 0, 0, 0, &firstchar, &reqchar, ((void *)0), cd, &length);

7835

if (errorcode != 0) goto PCRE_EARLY_ERROR_RETURN;

executed: goto PCRE_EARLY_ERROR_RETURN;

Execution Count:11

evaluated: errorcode != 0

TRUE	FALSE
yes Evaluation Count:11	yes Evaluation Count:357

11-357

7836 -

7837 DPRINTF(("end pre-compile: length=%d workspace=%d\n", length, -

7838 (int)(cd->hwm - cworkspace))); -

7839 -

7840

if (length > MAX_PATTERN_SIZE)

partially evaluated: length > (1 << 16)

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:357

0-357

7841 { -

7842

errorcode = ERR20;

never executed (the execution status of this line is deduced): errorcode = ERR20;

7843

size = sizeof(REAL_PCRE) + (length + cd->names_found * cd->name_entry_size) * sizeof(pcre_uchar);

never executed: goto PCRE_EARLY_ERROR_RETURN;

7844 } -

7845 -

7846 /* Compute the size of data block needed and get it, either from malloc or -

7847 externally provided function. Integer overflow should no longer be possible -

7848 because nowadays we limit the maximum value of cd->names_found and -

7849 cd->name_entry_size. */ -

7850 -

7851

executed (the execution status of this line is deduced): size = sizeof(real_pcre16) + (length + cd->names_found * cd->name_entry_size) * sizeof(pcre_uchar);

7852

re = (REAL_PCRE *)(PUBL(malloc))(size);

executed (the execution status of this line is deduced): re = (real_pcre16 *)(pcre16_malloc)(size);

7853 -

7854

if (re == NULL)

partially evaluated: re == ((void *)0)

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:357

0-357

7855 { -

7856

errorcode = ERR21;

never executed (the execution status of this line is deduced): errorcode = ERR21;

7857

re->magic_number = MAGIC_NUMBER;

never executed: goto PCRE_EARLY_ERROR_RETURN;

7858 } -

7859 -

7860 /* Put in the magic number, and save the sizes, initial options, internal -

7861 flags, and character table pointer. NULL is used for the default character -

7862 tables. The nullpad field is at the end; it's there to help in the case when a -

7863 regex compiled on a system with 4-byte pointers is run on another with 8-byte -

7864 pointers. */ -

7865 -

7866

executed (the execution status of this line is deduced): re->magic_number = 0x50435245UL;

7867

re->size = (int)size;

executed (the execution status of this line is deduced): re->size = (int)size;

7868

re->options = cd->external_options;

executed (the execution status of this line is deduced): re->options = cd->external_options;

7869

re->flags = cd->external_flags;

executed (the execution status of this line is deduced): re->flags = cd->external_flags;

7870

re->dummy1 = 0;

executed (the execution status of this line is deduced): re->dummy1 = 0;

7871

re->first_char = 0;

executed (the execution status of this line is deduced): re->first_char = 0;

7872

re->req_char = 0;

executed (the execution status of this line is deduced): re->req_char = 0;

7873

re->name_table_offset = sizeof(REAL_PCRE) / sizeof(pcre_uchar);

executed (the execution status of this line is deduced): re->name_table_offset = sizeof(real_pcre16) / sizeof(pcre_uchar);

7874

re->name_entry_size = cd->name_entry_size;

executed (the execution status of this line is deduced): re->name_entry_size = cd->name_entry_size;

7875

re->name_count = cd->names_found;

executed (the execution status of this line is deduced): re->name_count = cd->names_found;

7876

re->ref_count = 0;

executed (the execution status of this line is deduced): re->ref_count = 0;

7877

re->tables = (tables == PRIV(default_tables))? NULL : tables;

partially evaluated: (tables == _pcre16_default_tables)

TRUE	FALSE
yes Evaluation Count:357	no Evaluation Count:0

0-357

7878

re->nullpad = NULL;

executed (the execution status of this line is deduced): re->nullpad = ((void *)0);

7879 -

7880 /* The starting points of the name/number translation table and of the code are -

7881 passed around in the compile data block. The start/end pattern and initial -

7882 options are already set from the pre-compile phase, as is the name_entry_size -

7883 field. Reset the bracket count and the names_found field. Also reset the hwm -

7884 field; this time it's used for remembering forward references to subpatterns. -

7885 */ -

7886 -

7887

cd->final_bracount = cd->bracount; /* Save for checking forward references */

executed (the execution status of this line is deduced): cd->final_bracount = cd->bracount;

7888

cd->assert_depth = 0;

executed (the execution status of this line is deduced): cd->assert_depth = 0;

7889

cd->bracount = 0;

executed (the execution status of this line is deduced): cd->bracount = 0;

7890

cd->names_found = 0;

executed (the execution status of this line is deduced): cd->names_found = 0;

7891

cd->name_table = (pcre_uchar *)re + re->name_table_offset;

executed (the execution status of this line is deduced): cd->name_table = (pcre_uchar *)re + re->name_table_offset;

7892

codestart = cd->name_table + re->name_entry_size * re->name_count;

executed (the execution status of this line is deduced): codestart = cd->name_table + re->name_entry_size * re->name_count;

7893

cd->start_code = codestart;

executed (the execution status of this line is deduced): cd->start_code = codestart;

7894

cd->hwm = (pcre_uchar *)(cd->start_workspace);

executed (the execution status of this line is deduced): cd->hwm = (pcre_uchar *)(cd->start_workspace);

7895

cd->req_varyopt = 0;

executed (the execution status of this line is deduced): cd->req_varyopt = 0;

7896

cd->had_accept = FALSE;

executed (the execution status of this line is deduced): cd->had_accept = 0;

7897

cd->check_lookbehind = FALSE;

executed (the execution status of this line is deduced): cd->check_lookbehind = 0;

7898

cd->open_caps = NULL;

executed (the execution status of this line is deduced): cd->open_caps = ((void *)0);

7899 -

7900 /* Set up a starting, non-extracting bracket, then compile the expression. On -

7901 error, errorcode will be set non-zero, so we don't need to look at the result -

7902 of the function here. */ -

7903 -

7904

ptr = (const pcre_uchar *)pattern + skipatstart;

executed (the execution status of this line is deduced): ptr = (const pcre_uchar *)pattern + skipatstart;

7905

code = (pcre_uchar *)codestart;

executed (the execution status of this line is deduced): code = (pcre_uchar *)codestart;

7906

*code = OP_BRA;

executed (the execution status of this line is deduced): *code = OP_BRA;

7907

(void)compile_regex(re->options, &code, &ptr, &errorcode, FALSE, FALSE, 0, 0,

executed (the execution status of this line is deduced): (void)compile_regex(re->options, &code, &ptr, &errorcode, 0, 0, 0, 0,

7908

&firstchar, &reqchar, NULL, cd, NULL);

executed (the execution status of this line is deduced): &firstchar, &reqchar, ((void *)0), cd, ((void *)0));

7909

re->top_bracket = cd->bracount;

executed (the execution status of this line is deduced): re->top_bracket = cd->bracount;

7910

re->top_backref = cd->top_backref;

executed (the execution status of this line is deduced): re->top_backref = cd->top_backref;

7911

re->flags = cd->external_flags | PCRE_MODE;

executed (the execution status of this line is deduced): re->flags = cd->external_flags | 0x0002;

7912 -

7913

if (cd->had_accept) reqchar = REQ_NONE; /* Must disable after (*ACCEPT) */

never executed: reqchar = (-1);

partially evaluated: cd->had_accept

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:357

0-357

7914 -

7915 /* If not reached end of pattern on success, there's an excess bracket. */ -

7916 -

7917

if (errorcode == 0 && *ptr != 0) errorcode = ERR22;

never executed: errorcode = ERR22;

partially evaluated: errorcode == 0

TRUE	FALSE
yes Evaluation Count:357	no Evaluation Count:0

partially evaluated: *ptr != 0

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:357

0-357

7918 -

7919 /* Fill in the terminating state and check for disastrous overflow, but -

7920 if debugging, leave the test till after things are printed out. */ -

7921 -

7922

*code++ = OP_END;

executed (the execution status of this line is deduced): *code++ = OP_END;

7923 -

7924 #ifndef PCRE_DEBUG -

7925

if (code - codestart > length) errorcode = ERR23;

never executed: errorcode = ERR23;

partially evaluated: code - codestart > length

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:357

0-357

7926 #endif -

7927 -

7928 /* Fill in any forward references that are required. There may be repeated -

7929 references; optimize for them, as searching a large regex takes time. */ -

7930 -

7931

if (cd->hwm > cd->start_workspace)

evaluated: cd->hwm > cd->start_workspace

TRUE	FALSE
yes Evaluation Count:2	yes Evaluation Count:355

2-355

7932 { -

7933

int prev_recno = -1;

executed (the execution status of this line is deduced): int prev_recno = -1;

7934

const pcre_uchar *groupptr = NULL;

executed (the execution status of this line is deduced): const pcre_uchar *groupptr = ((void *)0);

7935

while (errorcode == 0 && cd->hwm > cd->start_workspace)

partially evaluated: errorcode == 0

TRUE	FALSE
yes Evaluation Count:4	no Evaluation Count:0

evaluated: cd->hwm > cd->start_workspace

TRUE	FALSE
yes Evaluation Count:2	yes Evaluation Count:2

0-4

7936 { -

7937

int offset, recno;

executed (the execution status of this line is deduced): int offset, recno;

7938

cd->hwm -= LINK_SIZE;

executed (the execution status of this line is deduced): cd->hwm -= 1;

7939

offset = GET(cd->hwm, 0);

executed (the execution status of this line is deduced): offset = (cd->hwm[0]);

7940

recno = GET(codestart, offset);

executed (the execution status of this line is deduced): recno = (codestart[offset]);

7941

if (recno != prev_recno)

partially evaluated: recno != prev_recno

TRUE	FALSE
yes Evaluation Count:2	no Evaluation Count:0

0-2

7942 { -

7943

groupptr = PRIV(find_bracket)(codestart, utf, recno);

executed (the execution status of this line is deduced): groupptr = _pcre16_find_bracket(codestart, utf, recno);

7944

prev_recno = recno;

executed (the execution status of this line is deduced): prev_recno = recno;

7945

if (groupptr == NULL) errorcode = ERR53;

executed: }

Execution Count:2

7946

never executed: errorcode = ERR53;

partially evaluated: groupptr == ((void *)0)

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:2

0-2

7947

else PUT(((pcre_uchar *)codestart), offset, (int)(groupptr - codestart));

executed: (((pcre_uchar *)codestart)[offset] = ((int)(groupptr - codestart)));

Execution Count:2

7948 } -

7949

if (cd->workspace_size > COMPILE_WORK_SIZE)

executed: }

Execution Count:2

7950 -

7951 /* If the workspace had to be expanded, free the new memory. */ -

7952 -

7953

partially evaluated: cd->workspace_size > (2048*1)

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:357

0-357

7954

(PUBL(free))((void *)cd->start_workspace);

never executed: (pcre16_free)((void *)cd->start_workspace);

7955 -

7956 /* Give an error if there's back reference to a non-existent capturing -

7957 subpattern. */ -

7958 -

7959

if (errorcode == 0 && re->top_backref > re->top_bracket) errorcode = ERR15;

never executed: errorcode = ERR15;

partially evaluated: errorcode == 0

TRUE	FALSE
yes Evaluation Count:357	no Evaluation Count:0

partially evaluated: re->top_backref > re->top_bracket

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:357

0-357

7960 -

7961 /* If there were any lookbehind assertions that contained OP_RECURSE -

7962 (recursions or subroutine calls), a flag is set for them to be checked here, -

7963 because they may contain forward references. Actual recursions can't be fixed -

7964 length, but subroutine calls can. It is done like this so that those without -

7965 OP_RECURSE that are not fixed length get a diagnosic with a useful offset. The -

7966 exceptional ones forgo this. We scan the pattern to check that they are fixed -

7967 length, and set their lengths. */ -

7968 -

7969

if (cd->check_lookbehind)

partially evaluated: cd->check_lookbehind

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:357

0-357

7970 { -

7971

pcre_uchar *cc = (pcre_uchar *)codestart;

never executed (the execution status of this line is deduced): pcre_uchar *cc = (pcre_uchar *)codestart;

7972 -

7973 /* Loop, searching for OP_REVERSE items, and process those that do not have -

7974 their length set. (Actually, it will also re-process any that have a length -

7975 of zero, but that is a pathological case, and it does no harm.) When we find -

7976 one, we temporarily terminate the branch it is in while we scan it. */ -

7977 -

7978

for (cc = (pcre_uchar *)PRIV(find_bracket)(codestart, utf, -1);

never executed (the execution status of this line is deduced): for (cc = (pcre_uchar *)_pcre16_find_bracket(codestart, utf, -1);

7979

cc != NULL;

never evaluated: cc != ((void *)0)

7980

cc = (pcre_uchar *)PRIV(find_bracket)(cc, utf, -1))

never executed (the execution status of this line is deduced): cc = (pcre_uchar *)_pcre16_find_bracket(cc, utf, -1))

7981 { -

7982

if (GET(cc, 1) == 0)

never evaluated: (cc[1]) == 0

7983 { -

7984

int fixed_length;

never executed (the execution status of this line is deduced): int fixed_length;

7985

pcre_uchar *be = cc - 1 - LINK_SIZE + GET(cc, -LINK_SIZE);

never executed (the execution status of this line is deduced): pcre_uchar *be = cc - 1 - 1 + (cc[-1]);

7986

int end_op = *be;

never executed (the execution status of this line is deduced): int end_op = *be;

7987

*be = OP_END;

never executed (the execution status of this line is deduced): *be = OP_END;

7988

fixed_length = find_fixedlength(cc, (re->options & PCRE_UTF8) != 0, TRUE,

never executed (the execution status of this line is deduced): fixed_length = find_fixedlength(cc, (re->options & 0x00000800) != 0, 1,

7989

cd);

never executed (the execution status of this line is deduced): cd);

7990

*be = end_op;

never executed (the execution status of this line is deduced): *be = end_op;

7991 DPRINTF(("fixed length = %d\n", fixed_length)); -

7992

if (fixed_length < 0)

never evaluated: fixed_length < 0

7993 { -

7994

errorcode = (fixed_length == -2)? ERR36 :

never evaluated: (fixed_length == -2)

7995

(fixed_length == -4)? ERR70 : ERR25;

never executed (the execution status of this line is deduced): (fixed_length == -4)? ERR70 : ERR25;

7996

PUT(cc, 1, fixed_length);

never executed: break;

7997 } -

7998

never executed (the execution status of this line is deduced): (cc[1] = (fixed_length));

never executed: }

never executed (the execution status of this line is deduced): cc += 1 + 1;

never executed: }

never executed: }

8003 -

8004 /* Failed to compile, or error while post-processing */ -

8005 -

8006

if (errorcode != 0)

partially evaluated: errorcode != 0

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:357

0-357

8007 { -

8008

(PUBL(free))(re);

never executed (the execution status of this line is deduced): (pcre16_free)(re);

8009

PCRE_EARLY_ERROR_RETURN:

code before this statement never executed: PCRE_EARLY_ERROR_RETURN:

8010

*erroroffset = (int)(ptr - (const pcre_uchar *)pattern);

executed (the execution status of this line is deduced): *erroroffset = (int)(ptr - (const pcre_uchar *)pattern);

8011

PCRE_EARLY_ERROR_RETURN2:

code before this statement executed: PCRE_EARLY_ERROR_RETURN2:

Execution Count:11

8012

*errorptr = find_error_text(errorcode);

executed (the execution status of this line is deduced): *errorptr = find_error_text(errorcode);

8013

if (errorcodeptr != NULL) *errorcodeptr = errorcode;

executed: *errorcodeptr = errorcode;

Execution Count:12

partially evaluated: errorcodeptr != ((void *)0)

TRUE	FALSE
yes Evaluation Count:12	no Evaluation Count:0

0-12

8014

return NULL;

executed: return ((void *)0);

Execution Count:12

8015 } -

8016 -

8017 /* If the anchored option was not passed, set the flag if we can determine that -

8018 the pattern is anchored by virtue of ^ characters or \A or anything else (such -

8019 as starting with .* when DOTALL is set). -

8020 -

8021 Otherwise, if we know what the first byte has to be, save it, because that -

8022 speeds up unanchored matches no end. If not, see if we can set the -

8023 PCRE_STARTLINE flag. This is helpful for multiline matches when all branches -

8024 start with ^. and also when all branches start with .* for non-DOTALL matches. -

8025 */ -

8026 -

8027

if ((re->options & PCRE_ANCHORED) == 0)

partially evaluated: (re->options & 0x00000010) == 0

TRUE	FALSE
yes Evaluation Count:357	no Evaluation Count:0

0-357

8028 { -

8029

if (is_anchored(codestart, 0, cd->backref_map))

evaluated: is_anchored(codestart, 0, cd->backref_map)

TRUE	FALSE
yes Evaluation Count:38	yes Evaluation Count:319

38-319

8030

re->options |= PCRE_ANCHORED;

executed: re->options |= 0x00000010;

Execution Count:38

8031 else -

8032 { -

8033

if (firstchar < 0)

evaluated: firstchar < 0

TRUE	FALSE
yes Evaluation Count:81	yes Evaluation Count:238

81-238

8034

firstchar = find_firstassertedchar(codestart, FALSE);

executed: firstchar = find_firstassertedchar(codestart, 0);

Execution Count:81

8035

if (firstchar >= 0) /* Remove caseless flag for non-caseable chars */

evaluated: firstchar >= 0

TRUE	FALSE
yes Evaluation Count:238	yes Evaluation Count:81

81-238

8036 { -

8037 #ifdef COMPILE_PCRE8 -

8038 re->first_char = firstchar & 0xff; -

8039 #else -

8040 #ifdef COMPILE_PCRE16 -

8041

re->first_char = firstchar & 0xffff;

executed (the execution status of this line is deduced): re->first_char = firstchar & 0xffff;

8042 #endif -

8043 #endif -

8044

if ((firstchar & REQ_CASELESS) != 0)

evaluated: (firstchar & 0x10000000l) != 0

TRUE	FALSE
yes Evaluation Count:39	yes Evaluation Count:199

39-199

8045 { -

8046 #if defined SUPPORT_UCP && !(defined COMPILE_PCRE8) -

8047 /* We ignore non-ASCII first chars in 8 bit mode. */ -

8048

if (re->first_char < 128)

partially evaluated: utf

TRUE	FALSE
yes Evaluation Count:39	no Evaluation Count:0

0-39

8049 { -

8050

evaluated: re->first_char < 128

TRUE	FALSE
yes Evaluation Count:38	yes Evaluation Count:1

1-38

8051 { -

8052

if (cd->fcc[re->first_char] != re->first_char)

partially evaluated: cd->fcc[re->first_char] != re->first_char

TRUE	FALSE
yes Evaluation Count:38	no Evaluation Count:0

0-38

8053

re->flags |= PCRE_FCH_CASELESS;

executed: re->flags |= 0x0020;

Execution Count:38

8054

else if (UCD_OTHERCASE(re->first_char) != re->first_char)

executed: }

Execution Count:38

8055

partially evaluated:

(re->first_char + (_pcre16_ucd_records + _pcre16_ucd_stage2[_pcre16_ucd_stage1[(re->first_char) / 128] * 128 + (re->first_char) % 128])->other_case) != re->first_char

TRUE	FALSE
yes Evaluation Count:1	no Evaluation Count:0

0-1

8056

re->flags |= PCRE_FCH_CASELESS;

executed: re->flags |= 0x0020;

Execution Count:1

8057 } -

8058 else -

8059 #endif -

8060

if (MAX_255(re->first_char)

never evaluated: ((re->first_char) <= 255u)

8061

&& cd->fcc[re->first_char] != re->first_char)

never evaluated: cd->fcc[re->first_char] != re->first_char

8062

re->flags |= PCRE_FCH_CASELESS;

never executed: re->flags |= 0x0020;

8063 } -

8064 -

8065

re->flags |= PCRE_FIRSTSET;

executed (the execution status of this line is deduced): re->flags |= 0x0010;

8066

else if (is_startline(codestart, 0, cd->backref_map))

executed: }

Execution Count:238

238

8067

evaluated: is_startline(codestart, 0, cd->backref_map)

TRUE	FALSE
yes Evaluation Count:10	yes Evaluation Count:71

10-71

8068

re->flags |= PCRE_STARTLINE;

executed: re->flags |= 0x0100;

Execution Count:10

8069 } -

8070 } -

8071 -

8072 /* For an anchored pattern, we use the "required byte" only if it follows a -

8073 variable length item in the regex. Remove the caseless flag for non-caseable -

8074 bytes. */ -

8075 -

8076

if (reqchar >= 0 &&

evaluated: reqchar >= 0

TRUE	FALSE
yes Evaluation Count:199	yes Evaluation Count:158

158-199

8077

((re->options & PCRE_ANCHORED) == 0 || (reqchar & REQ_VARY) != 0))

evaluated: (re->options & 0x00000010) == 0

TRUE	FALSE
yes Evaluation Count:164	yes Evaluation Count:35

evaluated: (reqchar & 0x20000000l) != 0

TRUE	FALSE
yes Evaluation Count:24	yes Evaluation Count:11

11-164

8078 { -

8079 #ifdef COMPILE_PCRE8 -

8080 re->req_char = reqchar & 0xff; -

8081 #else -

8082 #ifdef COMPILE_PCRE16 -

8083

re->req_char = reqchar & 0xffff;

executed (the execution status of this line is deduced): re->req_char = reqchar & 0xffff;

8084 #endif -

8085 #endif -

8086

if ((reqchar & REQ_CASELESS) != 0)

evaluated: (reqchar & 0x10000000l) != 0

TRUE	FALSE
yes Evaluation Count:20	yes Evaluation Count:168

20-168

8087 { -

8088 #if defined SUPPORT_UCP && !(defined COMPILE_PCRE8) -

8089 /* We ignore non-ASCII first chars in 8 bit mode. */ -

8090

if (cd->fcc[re->req_char] != re->req_char)

partially evaluated: utf

TRUE	FALSE
yes Evaluation Count:20	no Evaluation Count:0

0-20

8091 { -

8092

if (re->req_char < 128)

evaluated: re->req_char < 128

TRUE	FALSE
yes Evaluation Count:18	yes Evaluation Count:2

2-18

8093 { -

8094

partially evaluated: cd->fcc[re->req_char] != re->req_char

TRUE	FALSE
yes Evaluation Count:18	no Evaluation Count:0

0-18

8095

re->flags |= PCRE_RCH_CASELESS;

executed: re->flags |= 0x0080;

Execution Count:18

8096

else if (UCD_OTHERCASE(re->req_char) != re->req_char)

executed: }

Execution Count:18

8097

partially evaluated:

(re->req_char + (_pcre16_ucd_records + _pcre16_ucd_stage2[_pcre16_ucd_stage1[(re->req_char) / 128] * 128 + (re->req_char) % 128])->other_case) != re->req_char

TRUE	FALSE
yes Evaluation Count:2	no Evaluation Count:0

0-2

8098

re->flags |= PCRE_RCH_CASELESS;

executed: re->flags |= 0x0080;

Execution Count:2

8099 } -

8100 else -

8101 #endif -

8102

if (MAX_255(re->req_char) && cd->fcc[re->req_char] != re->req_char)

never evaluated: ((re->req_char) <= 255u)

never evaluated: cd->fcc[re->req_char] != re->req_char

8103

re->flags |= PCRE_RCH_CASELESS;

never executed: re->flags |= 0x0080;

8104 } -

8105 -

8106

re->flags |= PCRE_REQCHSET;

executed (the execution status of this line is deduced): re->flags |= 0x0040;

8107