subst.c

executed 11 times by 1 test: ret = expand_no_split_dollar_star ? string_list_dollar_star (list, quoted, 0) : string_list_dollar_at (list, quoted, 0);

Executed by:

Self test

expand_no_split_dollar_star	Description
TRUE	evaluated 2 times by 1 test Evaluated by: Self test
FALSE	evaluated 9 times by 1 test Evaluated by: Self test

2-11

2692

else if (pchar == '*')

pchar == '*'	Description
TRUE	evaluated 118 times by 1 test Evaluated by: Self test
FALSE	evaluated 300 times by 1 test Evaluated by: Self test

118-300

2693

{

-

2694

/* Even when unquoted, string_list_dollar_star does the right thing

-

2695

making sure that the first character of $IFS is used as the

-

2696

separator. */

-

2697

ret = string_list_dollar_star (list, quoted, 0);

-

2698

}

executed 118 times by 1 test: end of block

Executed by:

Self test

118

2699

else if (pchar == '@' && (quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)))

pchar == '@'	Description
TRUE	evaluated 300 times by 1 test Evaluated by: Self test
FALSE	never evaluated

(quoted & (0x002\|0x001))	Description
TRUE	evaluated 112 times by 1 test Evaluated by: Self test
FALSE	evaluated 188 times by 1 test Evaluated by: Self test

0-300

2700

/* We use string_list_dollar_at, but only if the string is quoted, since

-

2701

that quotes the escapes if it's not, which we don't want. We could

-

2702

use string_list (the old code did), but that doesn't do the right

-

2703

thing if the first character of $IFS is not a space. We use

-

2704

string_list_dollar_star if the string is unquoted so we make sure that

-

2705

the elements of $@ are separated by the first character of $IFS for

-

2706

later splitting. */

-

2707

ret = string_list_dollar_at (list, quoted, 0);

executed 112 times by 1 test: ret = string_list_dollar_at (list, quoted, 0);

Executed by:

Self test

112

2708

else if (pchar == '@' && quoted == 0 && ifs_is_null) /* XXX */

pchar == '@'	Description
TRUE	evaluated 188 times by 1 test Evaluated by: Self test
FALSE	never evaluated

quoted == 0	Description
TRUE	evaluated 188 times by 1 test Evaluated by: Self test
FALSE	never evaluated

ifs_is_null	Description
TRUE	evaluated 7 times by 1 test Evaluated by: Self test
FALSE	evaluated 181 times by 1 test Evaluated by: Self test

0-188

2709

ret = string_list_dollar_at (list, quoted, 0); /* Posix interp 888 */

executed 7 times by 1 test: ret = string_list_dollar_at (list, quoted, 0);

Executed by:

Self test

7

2710

else if (pchar == '@')

pchar == '@'	Description
TRUE	evaluated 181 times by 1 test Evaluated by: Self test
FALSE	never evaluated

0-181

2711

ret = string_list_dollar_star (list, quoted, 0);

executed 181 times by 1 test: ret = string_list_dollar_star (list, quoted, 0);

Executed by:

Self test

181

2712

else

-

2713

ret = string_list ((quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)) ? quote_list (list) : list);

never executed: ret = string_list ((quoted & (0x002|0x001)) ? quote_list (list) : list);

0

2714

-

2715

return ret;

executed 519 times by 1 test: return ret;

Executed by:

Self test

519

2716

}

-

2717

-

2718

/* Return the list of words present in STRING. Separate the string into

-

2719

words at any of the characters found in SEPARATORS. If QUOTED is

-

2720

non-zero then word in the list will have its quoted flag set, otherwise

-

2721

the quoted flag is left as make_word () deemed fit.

-

2722

-

2723

This obeys the P1003.2 word splitting semantics. If `separators' is

-

2724

exactly <space><tab><newline>, then the splitting algorithm is that of

-

2725

the Bourne shell, which treats any sequence of characters from `separators'

-

2726

as a delimiter. If IFS is unset, which results in `separators' being set

-

2727

to "", no splitting occurs. If separators has some other value, the

-

2728

following rules are applied (`IFS white space' means zero or more

-

2729

occurrences of <space>, <tab>, or <newline>, as long as those characters

-

2730

are in `separators'):

-

2731

-

2732

1) IFS white space is ignored at the start and the end of the

-

2733

string.

-

2734

2) Each occurrence of a character in `separators' that is not

-

2735

IFS white space, along with any adjacent occurrences of

-

2736

IFS white space delimits a field.

-

2737

3) Any nonzero-length sequence of IFS white space delimits a field.

-

2738

*/

-

2739

-

2740

/* BEWARE! list_string strips null arguments. Don't call it twice and

-

2741

expect to have "" preserved! */

-

2742

-

2743

/* This performs word splitting and quoted null character removal on

-

2744

STRING. */

-

2745

#define issep(c) \

-

2746

(((separators)[0]) ? ((separators)[1] ? isifs(c) \

-

2747

: (c) == (separators)[0]) \

-

2748

: 0)

-

2749

-

2750

WORD_LIST *

-

2751

list_string (string, separators, quoted)

-

2752

register char *string, *separators;

-

2753

int quoted;

-

2754

{

-

2755

WORD_LIST *result;

-

2756

WORD_DESC *t;

-

2757

char *current_word, *s;

-

2758

int sindex, sh_style_split, whitesep, xflags;

-

2759

size_t slen;

-

2760

-

2761

if (!string || !*string)

!string	Description
TRUE	never evaluated
FALSE	evaluated 3294725 times by 1 test Evaluated by: Self test

!*string	Description
TRUE	never evaluated
FALSE	evaluated 3294725 times by 1 test Evaluated by: Self test

0-3294725

2762

return ((WORD_LIST *)NULL);

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

0

2763

-

2764

sh_style_split = separators && separators[0] == ' ' &&

separators	Description
TRUE	evaluated 3294725 times by 1 test Evaluated by: Self test
FALSE	never evaluated

separators[0] == ' '	Description
TRUE	evaluated 1663239 times by 1 test Evaluated by: Self test
FALSE	evaluated 1631486 times by 1 test Evaluated by: Self test

0-3294725

2765

separators[1] == '\t' &&

separators[1] == '\t'	Description
TRUE	evaluated 30812 times by 1 test Evaluated by: Self test
FALSE	evaluated 1632427 times by 1 test Evaluated by: Self test

30812-1632427

2766

separators[2] == '\n' &&

separators[2] == '\n'	Description
TRUE	evaluated 30812 times by 1 test Evaluated by: Self test
FALSE	never evaluated

0-30812

2767

separators[3] == '\0';

separators[3] == '\0'	Description
TRUE	evaluated 30812 times by 1 test Evaluated by: Self test
FALSE	never evaluated

0-30812

2768

for (xflags = 0, s = ifs_value; s && *s; s++)

s	Description
TRUE	evaluated 9900006 times by 1 test Evaluated by: Self test
FALSE	never evaluated

*s	Description
TRUE	evaluated 6605281 times by 1 test Evaluated by: Self test
FALSE	evaluated 3294725 times by 1 test Evaluated by: Self test

0-9900006

2769

{

-

2770

if (*s == CTLESC) xflags |= SX_NOCTLESC;

executed 181 times by 1 test: xflags |= 0x0010;

Executed by:

Self test

*s == '\001'	Description
TRUE	evaluated 181 times by 1 test Evaluated by: Self test
FALSE	evaluated 6605100 times by 1 test Evaluated by: Self test

181-6605100

2771

else if (*s == CTLNUL) xflags |= SX_NOESCCTLNUL;

executed 20 times by 1 test: xflags |= 0x0020;

Executed by:

Self test

*s == '\177'	Description
TRUE	evaluated 20 times by 1 test Evaluated by: Self test
FALSE	evaluated 6605080 times by 1 test Evaluated by: Self test

20-6605080

2772

}

executed 6605281 times by 1 test: end of block

Executed by:

Self test

6605281

2773

-

2774

slen = 0;

-

2775

/* Remove sequences of whitespace at the beginning of STRING, as

-

2776

long as those characters appear in IFS. Do not do this if

-

2777

STRING is quoted or if there are no separator characters. */

-

2778

if (!quoted || !separators || !*separators)

!quoted	Description
TRUE	evaluated 3270660 times by 1 test Evaluated by: Self test
FALSE	evaluated 24065 times by 1 test Evaluated by: Self test

!separators	Description
TRUE	never evaluated
FALSE	evaluated 24065 times by 1 test Evaluated by: Self test

!*separators	Description
TRUE	evaluated 15844 times by 1 test Evaluated by: Self test
FALSE	evaluated 8221 times by 1 test Evaluated by: Self test

0-3270660

2779

{

-

2780

for (s = string; *s && spctabnl (*s) && issep (*s); s++);

executed 2387281 times by 1 test: ;

Executed by:

Self test

((separators)[0])	Description
TRUE	evaluated 2387283 times by 1 test Evaluated by: Self test
FALSE	evaluated 4 times by 1 test Evaluated by: Self test

(separators)[1]	Description
TRUE	evaluated 2387281 times by 1 test Evaluated by: Self test
FALSE	evaluated 2 times by 1 test Evaluated by: Self test

*s	Description
TRUE	evaluated 5669320 times by 1 test Evaluated by: Self test
FALSE	evaluated 4465 times by 1 test Evaluated by: Self test

(*s) == ' '	Description
TRUE	evaluated 2387261 times by 1 test Evaluated by: Self test
FALSE	evaluated 3282059 times by 1 test Evaluated by: Self test

(*s) == '\t'	Description
TRUE	evaluated 23 times by 1 test Evaluated by: Self test
FALSE	evaluated 3282036 times by 1 test Evaluated by: Self test

(*s) == '\n'	Description
TRUE	evaluated 3 times by 1 test Evaluated by: Self test
FALSE	evaluated 3282033 times by 1 test Evaluated by: Self test

(((separators)...tors)[0]) : 0)	Description
TRUE	evaluated 2387281 times by 1 test Evaluated by: Self test
FALSE	evaluated 6 times by 1 test Evaluated by: Self test

2-5669320

2781

-

2782

if (!*s)

!*s	Description
TRUE	evaluated 4465 times by 1 test Evaluated by: Self test
FALSE	evaluated 3282039 times by 1 test Evaluated by: Self test

4465-3282039

2783

return ((WORD_LIST *)NULL);

executed 4465 times by 1 test: return ((WORD_LIST *) ((void *)0) );

Executed by:

Self test

4465

2784

-

2785

string = s;

-

2786

}

executed 3282039 times by 1 test: end of block

Executed by:

Self test

3282039

2787

-

2788

/* OK, now STRING points to a word that does not begin with white space.

-

2789

The splitting algorithm is:

-

2790

extract a word, stopping at a separator

-

2791

skip sequences of spc, tab, or nl as long as they are separators

-

2792

This obeys the field splitting rules in Posix.2. */

-

2793

slen = STRLEN (string);

(string)[1]	Description
TRUE	evaluated 3231574 times by 1 test Evaluated by: Self test
FALSE	evaluated 58686 times by 1 test Evaluated by: Self test

(string)[2]	Description
TRUE	evaluated 3130833 times by 1 test Evaluated by: Self test
FALSE	evaluated 100741 times by 1 test Evaluated by: Self test

(string)	Description
TRUE	evaluated 3290260 times by 1 test Evaluated by: Self test
FALSE	never evaluated

(string)[0]	Description
TRUE	evaluated 3290260 times by 1 test Evaluated by: Self test
FALSE	never evaluated

0-3290260

2794

for (result = (WORD_LIST *)NULL, sindex = 0; string[sindex]; )

string[sindex]	Description
TRUE	evaluated 8711954 times by 1 test Evaluated by: Self test
FALSE	evaluated 3290260 times by 1 test Evaluated by: Self test

3290260-8711954

2795

{

-

2796

/* Don't need string length in ADVANCE_CHAR unless multibyte chars are

-

2797

possible, but need it in string_extract_verbatim for bounds checking */

-

2798

current_word = string_extract_verbatim (string, slen, &sindex, separators, xflags);

-

2799

if (current_word == 0)

current_word == 0	Description
TRUE	never evaluated
FALSE	evaluated 8711954 times by 1 test Evaluated by: Self test

0-8711954

2800

break;

never executed: break;

0

2801

-

2802

/* If we have a quoted empty string, add a quoted null argument. We

-

2803

want to preserve the quoted null character iff this is a quoted

-

2804

empty string; otherwise the quoted null characters are removed

-

2805

below. */

-

2806

if (QUOTED_NULL (current_word))

(current_word)[0] == '\177'	Description
TRUE	evaluated 835 times by 1 test Evaluated by: Self test
FALSE	evaluated 8711119 times by 1 test Evaluated by: Self test

(current_word)[1] == '\0'	Description
TRUE	evaluated 792 times by 1 test Evaluated by: Self test
FALSE	evaluated 43 times by 1 test Evaluated by: Self test

43-8711119

2807

{

-

2808

t = alloc_word_desc ();

-

2809

t->word = make_quoted_char ('\0');

-

2810

t->flags |= W_QUOTED|W_HASQUOTEDNULL;

-

2811

result = make_word_list (t, result);

-

2812

}

executed 792 times by 1 test: end of block

Executed by:

Self test

792

2813

else if (current_word[0] != '\0')

current_word[0] != '\0'	Description
TRUE	evaluated 4621690 times by 1 test Evaluated by: Self test
FALSE	evaluated 4089472 times by 1 test Evaluated by: Self test

4089472-4621690

2814

{

-

2815

/* If we have something, then add it regardless. However,

-

2816

perform quoted null character removal on the current word. */

-

2817

remove_quoted_nulls (current_word);

-

2818

result = add_string_to_list (current_word, result);

-

2819

result->word->flags &= ~W_HASQUOTEDNULL; /* just to be sure */

-

2820

if (quoted & (Q_DOUBLE_QUOTES|Q_HERE_DOCUMENT))

quoted & (0x001\|0x002)	Description
TRUE	evaluated 28995 times by 1 test Evaluated by: Self test
FALSE	evaluated 4592695 times by 1 test Evaluated by: Self test

28995-4592695

2821

result->word->flags |= W_QUOTED;

executed 28995 times by 1 test: result->word->flags |= 0x000002;

Executed by:

Self test

28995

2822

}

executed 4621690 times by 1 test: end of block

Executed by:

Self test

4621690

2823

-

2824

/* If we're not doing sequences of separators in the traditional

-

2825

Bourne shell style, then add a quoted null argument. */

-

2826

else if (!sh_style_split && !spctabnl (string[sindex]))

!sh_style_split	Description
TRUE	evaluated 4089423 times by 1 test Evaluated by: Self test
FALSE	evaluated 49 times by 1 test Evaluated by: Self test

(string[sindex]) == ' '	Description
TRUE	never evaluated
FALSE	evaluated 4089423 times by 1 test Evaluated by: Self test

(string[sindex]) == '\t'	Description
TRUE	never evaluated
FALSE	evaluated 4089423 times by 1 test Evaluated by: Self test

(string[sindex]) == '\n'	Description
TRUE	never evaluated
FALSE	evaluated 4089423 times by 1 test Evaluated by: Self test

0-4089423

2827

{

-

2828

t = alloc_word_desc ();

-

2829

t->word = make_quoted_char ('\0');

-

2830

t->flags |= W_QUOTED|W_HASQUOTEDNULL;

-

2831

result = make_word_list (t, result);

-

2832

}

executed 4089423 times by 1 test: end of block

Executed by:

Self test

4089423

2833

-

2834

free (current_word);

-

2835

-

2836

/* Note whether or not the separator is IFS whitespace, used later. */

-

2837

whitesep = string[sindex] && spctabnl (string[sindex]);

string[sindex]	Description
TRUE	evaluated 8346290 times by 1 test Evaluated by: Self test
FALSE	evaluated 365664 times by 1 test Evaluated by: Self test

(string[sindex]) == ' '	Description
TRUE	evaluated 2362413 times by 1 test Evaluated by: Self test
FALSE	evaluated 5983877 times by 1 test Evaluated by: Self test

(string[sindex]) == '\t'	Description
TRUE	never evaluated
FALSE	evaluated 5983877 times by 1 test Evaluated by: Self test

(string[sindex]) == '\n'	Description
TRUE	evaluated 509 times by 1 test Evaluated by: Self test
FALSE	evaluated 5983368 times by 1 test Evaluated by: Self test

0-8346290

2838

-

2839

/* Move past the current separator character. */

-

2840

if (string[sindex])

string[sindex]	Description
TRUE	evaluated 8346290 times by 1 test Evaluated by: Self test
FALSE	evaluated 365664 times by 1 test Evaluated by: Self test

365664-8346290

2841

{

-

2842

DECLARE_MBSTATE;

-

2843

ADVANCE_CHAR (string, slen, sindex);

executed 8345105 times by 1 test: mblength = 1;

Executed by:

Self test

executed 788 times by 1 test: mblength = 1;

Executed by:

Self test

executed 3 times by 1 test: end of block

Executed by:

Self test

never executed: end of block

never executed: (sindex)++;

executed 8345896 times by 1 test: (sindex) += mblength;

Executed by:

Self test

executed 394 times by 1 test: (sindex)++;

Executed by:

Self test

locale_mb_cur_max > 1	Description
TRUE	evaluated 8345896 times by 1 test Evaluated by: Self test
FALSE	evaluated 394 times by 1 test Evaluated by: Self test

_f	Description
TRUE	evaluated 8345105 times by 1 test Evaluated by: Self test
FALSE	evaluated 791 times by 1 test Evaluated by: Self test

mblength == 0	Description
TRUE	never evaluated
FALSE	evaluated 8345896 times by 1 test Evaluated by: Self test

locale_utf8locale	Description
TRUE	evaluated 791 times by 1 test Evaluated by: Self test
FALSE	never evaluated

(((string)[sin... & 0x80) == 0)	Description
TRUE	evaluated 788 times by 1 test Evaluated by: Self test
FALSE	evaluated 3 times by 1 test Evaluated by: Self test

mblength == (size_t)-2	Description
TRUE	never evaluated
FALSE	evaluated 8345896 times by 1 test Evaluated by: Self test

mblength == (size_t)-1	Description
TRUE	never evaluated
FALSE	evaluated 8345896 times by 1 test Evaluated by: Self test

0-8345896

2844

}

executed 8346290 times by 1 test: end of block

Executed by:

Self test

8346290

2845

-

2846

/* Now skip sequences of space, tab, or newline characters if they are

-

2847

in the list of separators. */

-

2848

while (string[sindex] && spctabnl (string[sindex]) && issep (string[sindex]))

((separators)[0])	Description
TRUE	evaluated 3871062 times by 1 test Evaluated by: Self test
FALSE	never evaluated

(separators)[1]	Description
TRUE	evaluated 3871062 times by 1 test Evaluated by: Self test
FALSE	never evaluated

string[sindex]	Description
TRUE	evaluated 9948438 times by 1 test Evaluated by: Self test
FALSE	evaluated 2634578 times by 1 test Evaluated by: Self test

(string[sindex]) == ' '	Description
TRUE	evaluated 3871025 times by 1 test Evaluated by: Self test
FALSE	evaluated 6077413 times by 1 test Evaluated by: Self test

(string[sindex]) == '\t'	Description
TRUE	never evaluated
FALSE	evaluated 6077413 times by 1 test Evaluated by: Self test

(string[sindex]) == '\n'	Description
TRUE	evaluated 37 times by 1 test Evaluated by: Self test
FALSE	evaluated 6077376 times by 1 test Evaluated by: Self test

(((separators)...tors)[0]) : 0)	Description
TRUE	evaluated 3871062 times by 1 test Evaluated by: Self test
FALSE	never evaluated

0-9948438

2849

sindex++;

executed 3871062 times by 1 test: sindex++;

Executed by:

Self test

3871062

2850

-

2851

/* If the first separator was IFS whitespace and the current character

-

2852

is a non-whitespace IFS character, it should be part of the current

-

2853

field delimiter, not a separate delimiter that would result in an

-

2854

empty field. Look at POSIX.2, 3.6.5, (3)(b). */

-

2855

if (string[sindex] && whitesep && issep (string[sindex]) && !spctabnl (string[sindex]))

((separators)[0])	Description
TRUE	evaluated 2067783 times by 1 test Evaluated by: Self test
FALSE	never evaluated

(separators)[1]	Description
TRUE	evaluated 2045931 times by 1 test Evaluated by: Self test
FALSE	evaluated 21852 times by 1 test Evaluated by: Self test

string[sindex]	Description
TRUE	evaluated 6077376 times by 1 test Evaluated by: Self test
FALSE	evaluated 2634578 times by 1 test Evaluated by: Self test

whitesep	Description
TRUE	evaluated 2067783 times by 1 test Evaluated by: Self test
FALSE	evaluated 4009593 times by 1 test Evaluated by: Self test

(((separators)...tors)[0]) : 0)	Description
TRUE	evaluated 1858829 times by 1 test Evaluated by: Self test
FALSE	evaluated 208954 times by 1 test Evaluated by: Self test

(string[sindex]) == ' '	Description
TRUE	never evaluated
FALSE	evaluated 1858829 times by 1 test Evaluated by: Self test

(string[sindex]) == '\t'	Description
TRUE	never evaluated
FALSE	evaluated 1858829 times by 1 test Evaluated by: Self test

(string[sindex]) == '\n'	Description
TRUE	never evaluated
FALSE	evaluated 1858829 times by 1 test Evaluated by: Self test

0-6077376

2856

{

-

2857

sindex++;

-

2858

/* An IFS character that is not IFS white space, along with any

-

2859

adjacent IFS white space, shall delimit a field. (SUSv3) */

-

2860

while (string[sindex] && spctabnl (string[sindex]) && isifs (string[sindex]))

string[sindex]	Description
TRUE	evaluated 2408683 times by 1 test Evaluated by: Self test
FALSE	evaluated 655682 times by 1 test Evaluated by: Self test

(string[sindex]) == ' '	Description
TRUE	evaluated 1205536 times by 1 test Evaluated by: Self test
FALSE	evaluated 1203147 times by 1 test Evaluated by: Self test

(string[sindex]) == '\t'	Description
TRUE	never evaluated
FALSE	evaluated 1203147 times by 1 test Evaluated by: Self test

(string[sindex]) == '\n'	Description
TRUE	never evaluated
FALSE	evaluated 1203147 times by 1 test Evaluated by: Self test

(ifs_cmap[(uns...index])] != 0)	Description
TRUE	evaluated 1205536 times by 1 test Evaluated by: Self test
FALSE	never evaluated

0-2408683

2861

sindex++;

executed 1205536 times by 1 test: sindex++;

Executed by:

Self test

1205536

2862

}

executed 1858829 times by 1 test: end of block

Executed by:

Self test

1858829

2863

}

executed 8711954 times by 1 test: end of block

Executed by:

Self test

8711954

2864

return (REVERSE_LIST (result, WORD_LIST *));

executed 3290260 times by 1 test: return (((result && result->next) ? (WORD_LIST *)list_reverse ((GENERIC_LIST *)result) : (WORD_LIST *)(result)));

Executed by:

Self test

3290260

2865

}

-

2866

-

2867

/* Parse a single word from STRING, using SEPARATORS to separate fields.

-

2868

ENDPTR is set to the first character after the word. This is used by

-

2869

the `read' builtin.

-

2870

-

2871

This is never called with SEPARATORS != $IFS, and takes advantage of that.

-

2872

-

2873

XXX - this function is very similar to list_string; they should be

-

2874

combined - XXX */

-

2875

-

2876

#define islocalsep(c) (local_cmap[(unsigned char)(c)] != 0)

-

2877

-

2878

char *

-

2879

get_word_from_string (stringp, separators, endptr)

-

2880

char **stringp, *separators, **endptr;

-

2881

{

-

2882

register char *s;

-

2883

char *current_word;

-

2884

int sindex, sh_style_split, whitesep, xflags;

-

2885

unsigned char local_cmap[UCHAR_MAX+1]; /* really only need single-byte chars here */

-

2886

size_t slen;

-

2887

-

2888

if (!stringp || !*stringp || !**stringp)

!stringp	Description
TRUE	never evaluated
FALSE	evaluated 662841 times by 1 test Evaluated by: Self test

!*stringp	Description
TRUE	never evaluated
FALSE	evaluated 662841 times by 1 test Evaluated by: Self test

!**stringp	Description
TRUE	never evaluated
FALSE	evaluated 662841 times by 1 test Evaluated by: Self test

0-662841

2889

return ((char *)NULL);

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

0

2890

-

2891

sh_style_split = separators && separators[0] == ' ' &&

separators	Description
TRUE	evaluated 662841 times by 1 test Evaluated by: Self test
FALSE	never evaluated

separators[0] == ' '	Description
TRUE	evaluated 662052 times by 1 test Evaluated by: Self test
FALSE	evaluated 789 times by 1 test Evaluated by: Self test

0-662841

2892

separators[1] == '\t' &&

separators[1] == '\t'	Description
TRUE	evaluated 661337 times by 1 test Evaluated by: Self test
FALSE	evaluated 715 times by 1 test Evaluated by: Self test

715-661337

2893

separators[2] == '\n' &&

separators[2] == '\n'	Description
TRUE	evaluated 661337 times by 1 test Evaluated by: Self test
FALSE	never evaluated

0-661337

2894

separators[3] == '\0';

separators[3] == '\0'	Description
TRUE	evaluated 661337 times by 1 test Evaluated by: Self test
FALSE	never evaluated

0-661337

2895

memset (local_cmap, '\0', sizeof (local_cmap));

-

2896

for (xflags = 0, s = separators; s && *s; s++)

s	Description
TRUE	evaluated 2649780 times by 1 test Evaluated by: Self test
FALSE	never evaluated

*s	Description
TRUE	evaluated 1986939 times by 1 test Evaluated by: Self test
FALSE	evaluated 662841 times by 1 test Evaluated by: Self test

0-2649780

2897

{

-

2898

if (*s == CTLESC) xflags |= SX_NOCTLESC;

executed 9 times by 1 test: xflags |= 0x0010;

Executed by:

Self test

*s == '\001'	Description
TRUE	evaluated 9 times by 1 test Evaluated by: Self test
FALSE	evaluated 1986930 times by 1 test Evaluated by: Self test

9-1986930

2899

if (*s == CTLNUL) xflags |= SX_NOESCCTLNUL;

executed 3 times by 1 test: xflags |= 0x0020;

Executed by:

Self test

*s == '\177'	Description
TRUE	evaluated 3 times by 1 test Evaluated by: Self test
FALSE	evaluated 1986936 times by 1 test Evaluated by: Self test

3-1986936

2900

local_cmap[(unsigned char)*s] = 1; /* local charmap of separators */

-

2901

}

executed 1986939 times by 1 test: end of block

Executed by:

Self test

1986939

2902

-

2903

s = *stringp;

-

2904

slen = 0;

-

2905

-

2906

/* Remove sequences of whitespace at the beginning of STRING, as

-

2907

long as those characters appear in SEPARATORS. This happens if

-

2908

SEPARATORS == $' \t\n' or if IFS is unset. */

-

2909

if (sh_style_split || separators == 0)

sh_style_split	Description
TRUE	evaluated 661337 times by 1 test Evaluated by: Self test
FALSE	evaluated 1504 times by 1 test Evaluated by: Self test

separators == 0	Description
TRUE	never evaluated
FALSE	evaluated 1504 times by 1 test Evaluated by: Self test

0-661337

2910

{

-

2911

for (; *s && spctabnl (*s) && islocalsep (*s); s++);

never executed: ;

*s	Description
TRUE	evaluated 661337 times by 1 test Evaluated by: Self test
FALSE	never evaluated

(*s) == ' '	Description
TRUE	never evaluated
FALSE	evaluated 661337 times by 1 test Evaluated by: Self test

(*s) == '\t'	Description
TRUE	never evaluated
FALSE	evaluated 661337 times by 1 test Evaluated by: Self test

(*s) == '\n'	Description
TRUE	never evaluated
FALSE	evaluated 661337 times by 1 test Evaluated by: Self test

(local_cmap[(u...ar)(*s)] != 0)	Description
TRUE	never evaluated
FALSE	never evaluated

0-661337

2912

-

2913

/* If the string is nothing but whitespace, update it and return. */

-

2914

if (!*s)

!*s	Description
TRUE	never evaluated
FALSE	evaluated 661337 times by 1 test Evaluated by: Self test

0-661337

2915

{

-

2916

*stringp = s;

-

2917

if (endptr)

endptr	Description
TRUE	never evaluated
FALSE	never evaluated

0

2918

*endptr = s;

never executed: *endptr = s;

0

2919

return ((char *)NULL);

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

0

2920

}

-

2921

}

executed 661337 times by 1 test: end of block

Executed by:

Self test

661337

2922

-

2923

/* OK, S points to a word that does not begin with white space.

-

2924

Now extract a word, stopping at a separator, save a pointer to

-

2925

the first character after the word, then skip sequences of spc,

-

2926

tab, or nl as long as they are separators.

-

2927

-

2928

This obeys the field splitting rules in Posix.2. */

-

2929

sindex = 0;

-

2930

/* Don't need string length in ADVANCE_CHAR unless multibyte chars are

-

2931

possible, but need it in string_extract_verbatim for bounds checking */

-

2932

slen = STRLEN (s);

(s)[1]	Description
TRUE	evaluated 1927 times by 1 test Evaluated by: Self test
FALSE	evaluated 660914 times by 1 test Evaluated by: Self test

(s)[2]	Description
TRUE	evaluated 1561 times by 1 test Evaluated by: Self test
FALSE	evaluated 366 times by 1 test Evaluated by: Self test

(s)	Description
TRUE	evaluated 662841 times by 1 test Evaluated by: Self test
FALSE	never evaluated

(s)[0]	Description
TRUE	evaluated 662841 times by 1 test Evaluated by: Self test
FALSE	never evaluated

0-662841

2933

current_word = string_extract_verbatim (s, slen, &sindex, separators, xflags);

-

2934

-

2935

/* Set ENDPTR to the first character after the end of the word. */

-

2936

if (endptr)

endptr	Description
TRUE	evaluated 662841 times by 1 test Evaluated by: Self test
FALSE	never evaluated

0-662841

2937

*endptr = s + sindex;

executed 662841 times by 1 test: *endptr = s + sindex;

Executed by:

Self test

662841

2938

-

2939

/* Note whether or not the separator is IFS whitespace, used later. */

-

2940

whitesep = s[sindex] && spctabnl (s[sindex]);

s[sindex]	Description
TRUE	evaluated 1685 times by 1 test Evaluated by: Self test
FALSE	evaluated 661156 times by 1 test Evaluated by: Self test

(s[sindex]) == ' '	Description
TRUE	evaluated 835 times by 1 test Evaluated by: Self test
FALSE	evaluated 850 times by 1 test Evaluated by: Self test

(s[sindex]) == '\t'	Description
TRUE	never evaluated
FALSE	evaluated 850 times by 1 test Evaluated by: Self test

(s[sindex]) == '\n'	Description
TRUE	never evaluated
FALSE	evaluated 850 times by 1 test Evaluated by: Self test

0-661156

2941

-

2942

/* Move past the current separator character. */

-

2943

if (s[sindex])

s[sindex]	Description
TRUE	evaluated 1685 times by 1 test Evaluated by: Self test
FALSE	evaluated 661156 times by 1 test Evaluated by: Self test

1685-661156

2944

{

-

2945

DECLARE_MBSTATE;

-

2946

ADVANCE_CHAR (s, slen, sindex);

executed 1657 times by 1 test: mblength = 1;

Executed by:

Self test

executed 8 times by 1 test: mblength = 1;

Executed by:

Self test

executed 3 times by 1 test: end of block

Executed by:

Self test

never executed: end of block

never executed: (sindex)++;

executed 1668 times by 1 test: (sindex) += mblength;

Executed by:

Self test

executed 17 times by 1 test: (sindex)++;

Executed by:

Self test

locale_mb_cur_max > 1	Description
TRUE	evaluated 1668 times by 1 test Evaluated by: Self test
FALSE	evaluated 17 times by 1 test Evaluated by: Self test

_f	Description
TRUE	evaluated 1657 times by 1 test Evaluated by: Self test
FALSE	evaluated 11 times by 1 test Evaluated by: Self test

mblength == 0	Description
TRUE	never evaluated
FALSE	evaluated 1668 times by 1 test Evaluated by: Self test

locale_utf8locale	Description
TRUE	evaluated 11 times by 1 test Evaluated by: Self test
FALSE	never evaluated

(((s)[sindex] & 0x80) == 0)	Description
TRUE	evaluated 8 times by 1 test Evaluated by: Self test
FALSE	evaluated 3 times by 1 test Evaluated by: Self test

mblength == (size_t)-2	Description
TRUE	never evaluated
FALSE	evaluated 1668 times by 1 test Evaluated by: Self test

mblength == (size_t)-1	Description
TRUE	never evaluated
FALSE	evaluated 1668 times by 1 test Evaluated by: Self test

0-1668

2947

}

executed 1685 times by 1 test: end of block

Executed by:

Self test

1685

2948

-

2949

/* Now skip sequences of space, tab, or newline characters if they are

-

2950

in the list of separators. */

-

2951

while (s[sindex] && spctabnl (s[sindex]) && islocalsep (s[sindex]))

s[sindex]	Description
TRUE	evaluated 2326 times by 1 test Evaluated by: Self test
FALSE	evaluated 661475 times by 1 test Evaluated by: Self test

(s[sindex]) == ' '	Description
TRUE	evaluated 960 times by 1 test Evaluated by: Self test
FALSE	evaluated 1366 times by 1 test Evaluated by: Self test

(s[sindex]) == '\t'	Description
TRUE	never evaluated
FALSE	evaluated 1366 times by 1 test Evaluated by: Self test

(s[sindex]) == '\n'	Description
TRUE	never evaluated
FALSE	evaluated 1366 times by 1 test Evaluated by: Self test

(local_cmap[(u...index])] != 0)	Description
TRUE	evaluated 960 times by 1 test Evaluated by: Self test
FALSE	never evaluated

0-661475

2952

sindex++;

executed 960 times by 1 test: sindex++;

Executed by:

Self test

960

2953

-

2954

/* If the first separator was IFS whitespace and the current character is

-

2955

a non-whitespace IFS character, it should be part of the current field

-

2956

delimiter, not a separate delimiter that would result in an empty field.

-

2957

Look at POSIX.2, 3.6.5, (3)(b). */

-

2958

if (s[sindex] && whitesep && islocalsep (s[sindex]) && !spctabnl (s[sindex]))

s[sindex]	Description
TRUE	evaluated 1366 times by 1 test Evaluated by: Self test
FALSE	evaluated 661475 times by 1 test Evaluated by: Self test

whitesep	Description
TRUE	evaluated 776 times by 1 test Evaluated by: Self test
FALSE	evaluated 590 times by 1 test Evaluated by: Self test

(local_cmap[(u...index])] != 0)	Description
TRUE	evaluated 464 times by 1 test Evaluated by: Self test
FALSE	evaluated 312 times by 1 test Evaluated by: Self test

(s[sindex]) == ' '	Description
TRUE	never evaluated
FALSE	evaluated 464 times by 1 test Evaluated by: Self test

(s[sindex]) == '\t'	Description
TRUE	never evaluated
FALSE	evaluated 464 times by 1 test Evaluated by: Self test

(s[sindex]) == '\n'	Description
TRUE	never evaluated
FALSE	evaluated 464 times by 1 test Evaluated by: Self test

0-661475

2959

{

-

2960

sindex++;

-

2961

/* An IFS character that is not IFS white space, along with any adjacent

-

2962

IFS white space, shall delimit a field. */

-

2963

while (s[sindex] && spctabnl (s[sindex]) && islocalsep(s[sindex]))

s[sindex]	Description
TRUE	evaluated 652 times by 1 test Evaluated by: Self test
FALSE	evaluated 88 times by 1 test Evaluated by: Self test

(s[sindex]) == ' '	Description
TRUE	evaluated 276 times by 1 test Evaluated by: Self test
FALSE	evaluated 376 times by 1 test Evaluated by: Self test

(s[sindex]) == '\t'	Description
TRUE	never evaluated
FALSE	evaluated 376 times by 1 test Evaluated by: Self test

(s[sindex]) == '\n'	Description
TRUE	never evaluated
FALSE	evaluated 376 times by 1 test Evaluated by: Self test

(local_cmap[(u...index])] != 0)	Description
TRUE	evaluated 276 times by 1 test Evaluated by: Self test
FALSE	never evaluated

0-652

2964

sindex++;

executed 276 times by 1 test: sindex++;

Executed by:

Self test

276

2965

}

executed 464 times by 1 test: end of block

Executed by:

Self test

464

2966

-

2967

/* Update STRING to point to the next field. */

-

2968

*stringp = s + sindex;

-

2969

return (current_word);

executed 662841 times by 1 test: return (current_word);

Executed by:

Self test

662841

2970

}

-

2971

-

2972

/* Remove IFS white space at the end of STRING. Start at the end

-

2973

of the string and walk backwards until the beginning of the string

-

2974

or we find a character that's not IFS white space and not CTLESC.

-

2975

Only let CTLESC escape a white space character if SAW_ESCAPE is

-

2976

non-zero. */

-

2977

char *

-

2978

strip_trailing_ifs_whitespace (string, separators, saw_escape)

-

2979

char *string, *separators;

-

2980

int saw_escape;

-

2981

{

-

2982

char *s;

-

2983

-

2984

s = string + STRLEN (string) - 1;

(string)[1]	Description
TRUE	evaluated 389 times by 1 test Evaluated by: Self test
FALSE	never evaluated

(string)[2]	Description
TRUE	evaluated 385 times by 1 test Evaluated by: Self test
FALSE	evaluated 4 times by 1 test Evaluated by: Self test

(string)	Description
TRUE	evaluated 389 times by 1 test Evaluated by: Self test
FALSE	never evaluated

(string)[0]	Description
TRUE	evaluated 389 times by 1 test Evaluated by: Self test
FALSE	never evaluated

0-389

2985

while (s > string && ((spctabnl (*s) && isifs (*s)) ||

s > string	Description
TRUE	evaluated 575 times by 1 test Evaluated by: Self test
FALSE	never evaluated

(*s) == ' '	Description
TRUE	evaluated 185 times by 1 test Evaluated by: Self test
FALSE	evaluated 390 times by 1 test Evaluated by: Self test

(*s) == '\t'	Description
TRUE	never evaluated
FALSE	evaluated 390 times by 1 test Evaluated by: Self test

(*s) == '\n'	Description
TRUE	never evaluated
FALSE	evaluated 390 times by 1 test Evaluated by: Self test

(ifs_cmap[(uns...ar)(*s)] != 0)	Description
TRUE	evaluated 185 times by 1 test Evaluated by: Self test
FALSE	never evaluated

0-575

2986

(saw_escape && *s == CTLESC && spctabnl (s[1]))))

saw_escape	Description
TRUE	evaluated 2 times by 1 test Evaluated by: Self test
FALSE	evaluated 388 times by 1 test Evaluated by: Self test

*s == '\001'	Description
TRUE	evaluated 1 time by 1 test Evaluated by: Self test
FALSE	evaluated 1 time by 1 test Evaluated by: Self test

(s[1]) == ' '	Description
TRUE	evaluated 1 time by 1 test Evaluated by: Self test
FALSE	never evaluated

(s[1]) == '\t'	Description
TRUE	never evaluated
FALSE	never evaluated

(s[1]) == '\n'	Description
TRUE	never evaluated
FALSE	never evaluated

0-388

2987

s--;

executed 186 times by 1 test: s--;

Executed by:

Self test

186

2988

*++s = '\0';

-

2989

return string;

executed 389 times by 1 test: return string;

Executed by:

Self test

389

2990

}

-

2991

-

2992

#if 0

-

2993

/* UNUSED */

-

2994

/* Split STRING into words at whitespace. Obeys shell-style quoting with

-

2995

backslashes, single and double quotes. */

-

2996

WORD_LIST *

-

2997

list_string_with_quotes (string)

-

2998

char *string;

-

2999

{

-

3000

WORD_LIST *list;

-

3001

char *token, *s;

-

3002

size_t s_len;

-

3003

int c, i, tokstart, len;

-

3004

-

3005

for (s = string; s && *s && spctabnl (*s); s++)

-

3006

;

-

3007

if (s == 0 || *s == 0)

-

3008

return ((WORD_LIST *)NULL);

-

3009

-

3010

s_len = strlen (s);

-

3011

tokstart = i = 0;

-

3012

list = (WORD_LIST *)NULL;

-

3013

while (1)

-

3014

{

-

3015

c = s[i];

-

3016

if (c == '\\')

-

3017

{

-

3018

i++;

-

3019

if (s[i])

-

3020

i++;

-

3021

}

-

3022

else if (c == '\'')

-

3023

i = skip_single_quoted (s, s_len, ++i, 0);

-

3024

else if (c == '"')

-

3025

i = skip_double_quoted (s, s_len, ++i, 0);

-

3026

else if (c == 0 || spctabnl (c))

-

3027

{

-

3028

/* We have found the end of a token. Make a word out of it and

-

3029

add it to the word list. */

-

3030

token = substring (s, tokstart, i);

-

3031

list = add_string_to_list (token, list);

-

3032

free (token);

-

3033

while (spctabnl (s[i]))

-

3034

i++;

-

3035

if (s[i])

-

3036

tokstart = i;

-

3037

else

-

3038

break;

-

3039

}

-

3040

else

-

3041

i++; /* normal character */

-

3042

}

-

3043

return (REVERSE_LIST (list, WORD_LIST *));

-

3044

}

-

3045

#endif

-

3046

-

3047

/********************************************************/

-

3048

/* */

-

3049

/* Functions to perform assignment statements */

-

3050

/* */

-

3051

/********************************************************/

-

3052

-

3053

#if defined (ARRAY_VARS)

-

3054

static SHELL_VAR *

-

3055

do_compound_assignment (name, value, flags)

-

3056

char *name, *value;

-

3057

int flags;

-

3058

{

-

3059

SHELL_VAR *v;

-

3060

int mklocal, mkassoc, mkglobal, chklocal;

-

3061

WORD_LIST *list;

-

3062

-

3063

mklocal = flags & ASS_MKLOCAL;

-

3064

mkassoc = flags & ASS_MKASSOC;

-

3065

mkglobal = flags & ASS_MKGLOBAL;

-

3066

chklocal = flags & ASS_CHKLOCAL;

-

3067

-

3068

if (mklocal && variable_context)

mklocal	Description
TRUE	evaluated 50 times by 1 test Evaluated by: Self test
FALSE	evaluated 404 times by 1 test Evaluated by: Self test

variable_context	Description
TRUE	evaluated 10 times by 1 test Evaluated by: Self test
FALSE	evaluated 40 times by 1 test Evaluated by: Self test

10-404

3069

{

-

3070

v = find_variable (name);

-

3071

if (v && ((readonly_p (v) && (flags & ASS_FORCE) == 0) || noassign_p (v)))

v	Description
TRUE	evaluated 10 times by 1 test Evaluated by: Self test
FALSE	never evaluated

((((v)->attrib... (0x0000002)))	Description
TRUE	evaluated 1 time by 1 test Evaluated by: Self test
FALSE	evaluated 9 times by 1 test Evaluated by: Self test

(flags & 0x0020) == 0	Description
TRUE	evaluated 1 time by 1 test Evaluated by: Self test
FALSE	never evaluated

((((v)->attrib... (0x0004000)))	Description
TRUE	never evaluated
FALSE	evaluated 9 times by 1 test Evaluated by: Self test

0-10

3072

{

-

3073

if (readonly_p (v))

((((v)->attrib... (0x0000002)))	Description
TRUE	evaluated 1 time by 1 test Evaluated by: Self test
FALSE	never evaluated

0-1

3074

err_readonly (name);

Executed by:

Self test

1

3075

return (v); /* XXX */

executed 1 time by 1 test: return (v);

Executed by:

Self test

1

3076

}

-

3077

list = expand_compound_array_assignment (v, value, flags);

-

3078

if (mkassoc)

mkassoc	Description
TRUE	evaluated 1 time by 1 test Evaluated by: Self test
FALSE	evaluated 8 times by 1 test Evaluated by: Self test

1-8

3079

v = make_local_assoc_variable (name);

executed 1 time by 1 test: v = make_local_assoc_variable (name);

Executed by:

Self test

1

3080

else if (v == 0 || (array_p (v) == 0 && assoc_p (v) == 0) || v->context != variable_context)

v == 0	Description
TRUE	never evaluated
FALSE	evaluated 8 times by 1 test Evaluated by: Self test

((((v)->attrib...000004))) == 0	Description
TRUE	never evaluated
FALSE	evaluated 8 times by 1 test Evaluated by: Self test

((((v)->attrib...000040))) == 0	Description
TRUE	never evaluated
FALSE	never evaluated

v->context != variable_context	Description
TRUE	never evaluated
FALSE	evaluated 8 times by 1 test Evaluated by: Self test

0-8

3081

v = make_local_array_variable (name, 0);

never executed: v = make_local_array_variable (name, 0);

0

3082

if (v)

v	Description
TRUE	evaluated 9 times by 1 test Evaluated by: Self test
FALSE	never evaluated

0-9

3083

assign_compound_array_list (v, list, flags);

executed 9 times by 1 test: assign_compound_array_list (v, list, flags);

Executed by:

Self test

9

3084

if (list)

list	Description
TRUE	evaluated 8 times by 1 test Evaluated by: Self test
FALSE	evaluated 1 time by 1 test Evaluated by: Self test

1-8

3085

dispose_words (list);

executed 8 times by 1 test: dispose_words (list);

Executed by:

Self test

8

3086

}

executed 9 times by 1 test: end of block

Executed by:

Self test

9

3087

/* In a function but forcing assignment in global context. CHKLOCAL means to

-

3088

check for an existing local variable first. */

-

3089

else if (mkglobal && variable_context)

mkglobal	Description
TRUE	evaluated 29 times by 1 test Evaluated by: Self test
FALSE	evaluated 415 times by 1 test Evaluated by: Self test

variable_context	Description
TRUE	evaluated 25 times by 1 test Evaluated by: Self test
FALSE	evaluated 4 times by 1 test Evaluated by: Self test

4-415

3090

{

-

3091

v = chklocal ? find_variable (name) : 0;

chklocal	Description
TRUE	evaluated 15 times by 1 test Evaluated by: Self test
FALSE	evaluated 10 times by 1 test Evaluated by: Self test

10-15

3092

if (v && (local_p (v) == 0 || v->context != variable_context))

v	Description
TRUE	evaluated 15 times by 1 test Evaluated by: Self test
FALSE	evaluated 10 times by 1 test Evaluated by: Self test

((((v)->attrib...000020))) == 0	Description
TRUE	evaluated 13 times by 1 test Evaluated by: Self test
FALSE	evaluated 2 times by 1 test Evaluated by: Self test

v->context != variable_context	Description
TRUE	never evaluated
FALSE	evaluated 2 times by 1 test Evaluated by: Self test

0-15

3093

v = 0;

executed 13 times by 1 test: v = 0;

Executed by:

Self test

13

3094

if (v == 0)

v == 0	Description
TRUE	evaluated 23 times by 1 test Evaluated by: Self test
FALSE	evaluated 2 times by 1 test Evaluated by: Self test

2-23

3095

v = find_global_variable (name);

executed 23 times by 1 test: v = find_global_variable (name);

Executed by:

Self test

23

3096

if (v && ((readonly_p (v) && (flags & ASS_FORCE) == 0) || noassign_p (v)))

v	Description
TRUE	evaluated 25 times by 1 test Evaluated by: Self test
FALSE	never evaluated

((((v)->attrib... (0x0000002)))	Description
TRUE	evaluated 3 times by 1 test Evaluated by: Self test
FALSE	evaluated 22 times by 1 test Evaluated by: Self test

(flags & 0x0020) == 0	Description
TRUE	evaluated 3 times by 1 test Evaluated by: Self test
FALSE	never evaluated

((((v)->attrib... (0x0004000)))	Description
TRUE	never evaluated
FALSE	evaluated 22 times by 1 test Evaluated by: Self test

0-25

3097

{

-

3098

if (readonly_p (v))

((((v)->attrib... (0x0000002)))	Description
TRUE	evaluated 3 times by 1 test Evaluated by: Self test
FALSE	never evaluated

0-3

3099

err_readonly (name);

Executed by:

Self test

3

3100

return (v); /* XXX */

executed 3 times by 1 test: return (v);

Executed by:

Self test

3

3101

}

-

3102

list = expand_compound_array_assignment (v, value, flags);

-

3103

if (v == 0 && mkassoc)

v == 0	Description
TRUE	never evaluated
FALSE	evaluated 22 times by 1 test Evaluated by: Self test

mkassoc	Description
TRUE	never evaluated
FALSE	never evaluated

0-22

3104

v = make_new_assoc_variable (name);

never executed: v = make_new_assoc_variable (name);

0

3105

else if (v && mkassoc && assoc_p (v) == 0)

v	Description
TRUE	evaluated 22 times by 1 test Evaluated by: Self test
FALSE	never evaluated

mkassoc	Description
TRUE	evaluated 3 times by 1 test Evaluated by: Self test
FALSE	evaluated 19 times by 1 test Evaluated by: Self test

((((v)->attrib...000040))) == 0	Description
TRUE	never evaluated
FALSE	evaluated 3 times by 1 test Evaluated by: Self test

0-22

3106

v = convert_var_to_assoc (v);

never executed: v = convert_var_to_assoc (v);

0

3107

else if (v == 0)

v == 0	Description
TRUE	never evaluated
FALSE	evaluated 22 times by 1 test Evaluated by: Self test

0-22

3108

v = make_new_array_variable (name);

never executed: v = make_new_array_variable (name);

0

3109

else if (v && mkassoc == 0 && array_p (v) == 0)

v	Description
TRUE	evaluated 22 times by 1 test Evaluated by: Self test
FALSE	never evaluated

mkassoc == 0	Description
TRUE	evaluated 19 times by 1 test Evaluated by: Self test
FALSE	evaluated 3 times by 1 test Evaluated by: Self test

((((v)->attrib...000004))) == 0	Description
TRUE	evaluated 5 times by 1 test Evaluated by: Self test
FALSE	evaluated 14 times by 1 test Evaluated by: Self test

0-22

3110

v = convert_var_to_array (v);

executed 5 times by 1 test: v = convert_var_to_array (v);

Executed by:

Self test

5

3111

if (v)

v	Description
TRUE	evaluated 22 times by 1 test Evaluated by: Self test
FALSE	never evaluated

0-22

3112

assign_compound_array_list (v, list, flags);

executed 22 times by 1 test: assign_compound_array_list (v, list, flags);

Executed by:

Self test

22

3113

if (list)

list	Description
TRUE	evaluated 21 times by 1 test Evaluated by: Self test
FALSE	evaluated 1 time by 1 test Evaluated by: Self test

1-21

3114

dispose_words (list);

executed 21 times by 1 test: dispose_words (list);

Executed by:

Self test

21

3115

}

executed 22 times by 1 test: end of block

Executed by:

Self test

22

3116

else

-

3117

{

-

3118

v = assign_array_from_string (name, value, flags);

-

3119

if (v && ((readonly_p (v) && (flags & ASS_FORCE) == 0) || noassign_p (v)))

v	Description
TRUE	evaluated 402 times by 1 test Evaluated by: Self test
FALSE	evaluated 15 times by 1 test Evaluated by: Self test

((((v)->attrib... (0x0000002)))	Description
TRUE	never evaluated
FALSE	evaluated 402 times by 1 test Evaluated by: Self test

(flags & 0x0020) == 0	Description
TRUE	never evaluated
FALSE	never evaluated

((((v)->attrib... (0x0004000)))	Description
TRUE	never evaluated
FALSE	evaluated 402 times by 1 test Evaluated by: Self test

0-402

3120

{

-

3121

if (readonly_p (v))

((((v)->attrib... (0x0000002)))	Description
TRUE	never evaluated
FALSE	never evaluated

0

3122

err_readonly (name);

never executed: err_readonly (name);

0

3123

return (v); /* XXX */

never executed: return (v);

0

3124

}

-

3125

}

executed 417 times by 1 test: end of block

Executed by:

Self test

417

3126

-

3127

return (v);

executed 448 times by 1 test: return (v);

Executed by:

Self test

448

3128

}

-

3129

#endif

-

3130

-

3131

/* Given STRING, an assignment string, get the value of the right side

-

3132

of the `=', and bind it to the left side. If EXPAND is true, then

-

3133

perform parameter expansion, command substitution, and arithmetic

-

3134

expansion on the right-hand side. Perform tilde expansion in any

-

3135

case. Do not perform word splitting on the result of expansion. */

-

3136

static int

-

3137

do_assignment_internal (word, expand)

-

3138

const WORD_DESC *word;

-

3139

int expand;

-

3140

{

-

3141

int offset, appendop, assign_list, aflags, retval;

-

3142

char *name, *value, *temp;

-

3143

SHELL_VAR *entry;

-

3144

#if defined (ARRAY_VARS)

-

3145

char *t;

-

3146

int ni;

-

3147

#endif

-

3148

const char *string;

-

3149

-

3150

if (word == 0 || word->word == 0)

word == 0	Description
TRUE	never evaluated
FALSE	evaluated 36424573 times by 1 test Evaluated by: Self test

word->word == 0	Description
TRUE	never evaluated
FALSE	evaluated 36424573 times by 1 test Evaluated by: Self test

0-36424573

3151

return 0;

never executed: return 0;

0

3152

-

3153

appendop = assign_list = aflags = 0;

-

3154

string = word->word;

-

3155

offset = assignment (string, 0);

-

3156

name = savestring (string);

-

3157

value = (char *)NULL;

-

3158

-

3159

if (name[offset] == '=')

name[offset] == '='	Description
TRUE	evaluated 36424573 times by 1 test Evaluated by: Self test
FALSE	never evaluated

0-36424573

3160

{

-

3161

if (name[offset - 1] == '+')

name[offset - 1] == '+'	Description
TRUE	evaluated 88 times by 1 test Evaluated by: Self test
FALSE	evaluated 36424485 times by 1 test Evaluated by: Self test

88-36424485

3162

{

-

3163

appendop = 1;

-

3164

name[offset - 1] = '\0';

-

3165

}

executed 88 times by 1 test: end of block

Executed by:

Self test

88

3166

-

3167

name[offset] = 0; /* might need this set later */

-

3168

temp = name + offset + 1;

-

3169

-

3170

#if defined (ARRAY_VARS)

-

3171

if (expand && (word->flags & W_COMPASSIGN))

expand	Description
TRUE	evaluated 36424369 times by 1 test Evaluated by: Self test
FALSE	evaluated 204 times by 1 test Evaluated by: Self test

(word->flags & 0x008000)	Description
TRUE	evaluated 464 times by 1 test Evaluated by: Self test
FALSE	evaluated 36423905 times by 1 test Evaluated by: Self test

204-36424369

3172

{

-

3173

assign_list = ni = 1;

-

3174

value = extract_array_assignment_list (temp, &ni);

-

3175

}

executed 464 times by 1 test: end of block

Executed by:

Self test

464

3176

else

-

3177

#endif

-

3178

if (expand && temp[0])

expand	Description
TRUE	evaluated 36423905 times by 1 test Evaluated by: Self test
FALSE	evaluated 204 times by 1 test Evaluated by: Self test

temp[0]	Description
TRUE	evaluated 36421320 times by 1 test Evaluated by: Self test
FALSE	evaluated 2585 times by 1 test Evaluated by: Self test

204-36423905

3179

value = expand_string_if_necessary (temp, 0, expand_string_assignment);

executed 36421320 times by 1 test: value = expand_string_if_necessary (temp, 0, expand_string_assignment);

Executed by:

Self test

36421320

3180

else

-

3181

value = savestring (temp);

executed 2789 times by 1 test: value = (char *)strcpy (sh_xmalloc((1 + strlen (temp)), "subst.c", 3181), (temp));

Executed by:

Self test

2789

3182

}

-

3183

-

3184

if (value == 0)

value == 0	Description
TRUE	evaluated 2404 times by 1 test Evaluated by: Self test
FALSE	evaluated 36419714 times by 1 test Evaluated by: Self test

2404-36419714

3185

{

-

3186

value = (char *)xmalloc (1);

-

3187

value[0] = '\0';

-

3188

}

executed 2404 times by 1 test: end of block

Executed by:

Self test

2404

3189

-

3190

if (echo_command_at_execute)

echo_command_at_execute	Description
TRUE	evaluated 12 times by 1 test Evaluated by: Self test
FALSE	evaluated 36422106 times by 1 test Evaluated by: Self test

12-36422106

3191

{

-

3192

if (appendop)

appendop	Description
TRUE	evaluated 1 time by 1 test Evaluated by: Self test
FALSE	evaluated 11 times by 1 test Evaluated by: Self test

1-11

3193

name[offset - 1] = '+';

executed 1 time by 1 test: name[offset - 1] = '+';

Executed by:

Self test

1

3194

xtrace_print_assignment (name, value, assign_list, 1);

-

3195

if (appendop)

appendop	Description
TRUE	evaluated 1 time by 1 test Evaluated by: Self test
FALSE	evaluated 11 times by 1 test Evaluated by: Self test

1-11

3196

name[offset - 1] = '\0';

executed 1 time by 1 test: name[offset - 1] = '\0';

Executed by:

Self test

1

3197

}

executed 12 times by 1 test: end of block

Executed by:

Self test

12

3198

-

3199

#define ASSIGN_RETURN(r) do { FREE (value); free (name); return (r); } while (0)

-

3200

-

3201

if (appendop)

appendop	Description
TRUE	evaluated 88 times by 1 test Evaluated by: Self test
FALSE	evaluated 36422030 times by 1 test Evaluated by: Self test

88-36422030

3202

aflags |= ASS_APPEND;

executed 88 times by 1 test: aflags |= 0x0001;

Executed by:

Self test

88

3203

-

3204

#if defined (ARRAY_VARS)

-

3205

if (t = mbschr (name, LBRACK))

t = mbschr (name, '[')	Description
TRUE	evaluated 704 times by 1 test Evaluated by: Self test
FALSE	evaluated 36421414 times by 1 test Evaluated by: Self test

704-36421414

3206

{

-

3207

if (assign_list)

assign_list	Description
TRUE	evaluated 10 times by 1 test Evaluated by: Self test
FALSE	evaluated 694 times by 1 test Evaluated by: Self test

10-694

3208

{

-

3209

report_error (_("%s: cannot assign list to array member"), name);

-

3210

ASSIGN_RETURN (0);

executed 10 times by 1 test: sh_xfree((value), "subst.c", 3210);

Executed by:

Self test

executed 10 times by 1 test: return (0);

Executed by:

Self test

value	Description
TRUE	evaluated 10 times by 1 test Evaluated by: Self test
FALSE	never evaluated

0-10

3211

}

-

3212

entry = assign_array_element (name, value, aflags);

-

3213

if (entry == 0)

entry == 0	Description
TRUE	evaluated 37 times by 1 test Evaluated by: Self test
FALSE	evaluated 649 times by 1 test Evaluated by: Self test

37-649

3214

ASSIGN_RETURN (0);

executed 37 times by 1 test: sh_xfree((value), "subst.c", 3214);

Executed by:

Self test

executed 37 times by 1 test: return (0);

Executed by:

Self test

never executed: end of block

value	Description
TRUE	evaluated 37 times by 1 test Evaluated by: Self test
FALSE	never evaluated

0-37

3215

}

executed 649 times by 1 test: end of block

Executed by:

Self test

649

3216

else if (assign_list)

assign_list	Description
TRUE	evaluated 454 times by 1 test Evaluated by: Self test
FALSE	evaluated 36420960 times by 1 test Evaluated by: Self test

454-36420960

3217

{

-

3218

if ((word->flags & W_ASSIGNARG) && (word->flags & W_CHKLOCAL))

(word->flags & 0x020000)	Description
TRUE	evaluated 79 times by 1 test Evaluated by: Self test
FALSE	evaluated 375 times by 1 test Evaluated by: Self test

(word->flags & 0x10000000)	Description
TRUE	evaluated 16 times by 1 test Evaluated by: Self test
FALSE	evaluated 63 times by 1 test Evaluated by: Self test

16-375

3219

aflags |= ASS_CHKLOCAL;

executed 16 times by 1 test: aflags |= 0x0040;

Executed by:

Self test

16

3220

if ((word->flags & W_ASSIGNARG) && (word->flags & W_ASSNGLOBAL) == 0)

(word->flags & 0x020000)	Description
TRUE	evaluated 79 times by 1 test Evaluated by: Self test
FALSE	evaluated 375 times by 1 test Evaluated by: Self test

(word->flags & 0x2000000) == 0	Description
TRUE	evaluated 50 times by 1 test Evaluated by: Self test
FALSE	evaluated 29 times by 1 test Evaluated by: Self test

29-375

3221

aflags |= ASS_MKLOCAL;

executed 50 times by 1 test: aflags |= 0x0002;

Executed by:

Self test

50

3222

if ((word->flags & W_ASSIGNARG) && (word->flags & W_ASSNGLOBAL))

(word->flags & 0x020000)	Description
TRUE	evaluated 79 times by 1 test Evaluated by: Self test
FALSE	evaluated 375 times by 1 test Evaluated by: Self test

(word->flags & 0x2000000)	Description
TRUE	evaluated 29 times by 1 test Evaluated by: Self test
FALSE	evaluated 50 times by 1 test Evaluated by: Self test

29-375

3223

aflags |= ASS_MKGLOBAL;

executed 29 times by 1 test: aflags |= 0x0008;

Executed by:

Self test

29

3224

if (word->flags & W_ASSIGNASSOC)

word->flags & 0x400000	Description
TRUE	evaluated 16 times by 1 test Evaluated by: Self test
FALSE	evaluated 438 times by 1 test Evaluated by: Self test

16-438

3225

aflags |= ASS_MKASSOC;

executed 16 times by 1 test: aflags |= 0x0004;

Executed by:

Self test

16

3226

entry = do_compound_assignment (name, value, aflags);

-

3227

}

executed 452 times by 1 test: end of block

Executed by:

Self test

452

3228

else

-

3229

#endif /* ARRAY_VARS */

-

3230

entry = bind_variable (name, value, aflags);

executed 36420960 times by 1 test: entry = bind_variable (name, value, aflags);

Executed by:

Self test

36420960

3231

-

3232

stupidly_hack_special_variables (name);

-

3233

-

3234

/* Return 1 if the assignment seems to have been performed correctly. */

-

3235

if (entry == 0 || readonly_p (entry))

entry == 0	Description
TRUE	evaluated 33 times by 1 test Evaluated by: Self test
FALSE	evaluated 36422012 times by 1 test Evaluated by: Self test

((((entry)->at... (0x0000002)))	Description
TRUE	evaluated 37 times by 1 test Evaluated by: Self test
FALSE	evaluated 36421975 times by 1 test Evaluated by: Self test

33-36422012

3236

retval = 0; /* assignment failure */

executed 70 times by 1 test: retval = 0;

Executed by:

Self test

70

3237

else if (noassign_p (entry))

((((entry)->at... (0x0004000)))	Description
TRUE	evaluated 4 times by 1 test Evaluated by: Self test
FALSE	evaluated 36421971 times by 1 test Evaluated by: Self test

4-36421971

3238

{

-

3239

last_command_exit_value = EXECUTION_FAILURE;

-

3240

retval = 1; /* error status, but not assignment failure */

-

3241

}

executed 4 times by 1 test: end of block

Executed by:

Self test

4

3242

else

-

3243

retval = 1;

executed 36421971 times by 1 test: retval = 1;

Executed by:

Self test

36421971

3244

-

3245

if (entry && retval != 0 && noassign_p (entry) == 0)

entry	Description
TRUE	evaluated 36422012 times by 1 test Evaluated by: Self test
FALSE	evaluated 33 times by 1 test Evaluated by: Self test

retval != 0	Description
TRUE	evaluated 36421975 times by 1 test Evaluated by: Self test
FALSE	evaluated 37 times by 1 test Evaluated by: Self test

((((entry)->at...004000))) == 0	Description
TRUE	evaluated 36421971 times by 1 test Evaluated by: Self test
FALSE	evaluated 4 times by 1 test Evaluated by: Self test

4-36422012

3246

VUNSETATTR (entry, att_invisible);

executed 36421971 times by 1 test: ((entry)->attributes &= ~(0x0001000));

Executed by:

Self test

36421971

3247

-

3248

ASSIGN_RETURN (retval);

executed 36422045 times by 1 test: sh_xfree((value), "subst.c", 3248);

Executed by:

Self test

executed 36422045 times by 1 test: return (retval);

Executed by:

Self test

value	Description
TRUE	evaluated 36422045 times by 1 test Evaluated by: Self test
FALSE	never evaluated

0-36422045

3249

}

-

3250

-

3251

/* Perform the assignment statement in STRING, and expand the

-

3252

right side by doing tilde, command and parameter expansion. */

-

3253

int

-

3254

do_assignment (string)

-

3255

char *string;

-

3256

{

-

3257

WORD_DESC td;

-

3258

-

3259

td.flags = W_ASSIGNMENT;

-

3260

td.word = string;

-

3261

-

3262

return do_assignment_internal (&td, 1);

never executed: return do_assignment_internal (&td, 1);

0

3263

}

-

3264

-

3265

int

-

3266

do_word_assignment (word, flags)

-

3267

WORD_DESC *word;

-

3268

int flags;

-

3269

{

-

3270

return do_assignment_internal (word, 1);

executed 36424369 times by 1 test: return do_assignment_internal (word, 1);

Executed by:

Self test

36424369

3271

}

-

3272

-

3273

/* Given STRING, an assignment string, get the value of the right side

-

3274

of the `=', and bind it to the left side. Do not perform any word

-

3275

expansions on the right hand side. */

-

3276

int

-

3277

do_assignment_no_expand (string)

-

3278

char *string;

-

3279

{

-

3280

WORD_DESC td;

-

3281

-

3282

td.flags = W_ASSIGNMENT;

-

3283

td.word = string;

-

3284

-

3285

return (do_assignment_internal (&td, 0));

executed 204 times by 1 test: return (do_assignment_internal (&td, 0));

Executed by:

Self test

204

3286

}

-

3287

-

3288

/***************************************************

-

3289

* *

-

3290

* Functions to manage the positional parameters *

-

3291

* *

-

3292

***************************************************/

-

3293

-

3294

/* Return the word list that corresponds to `$*'. */

-

3295

WORD_LIST *

-

3296

list_rest_of_args ()

-

3297

{

-

3298

register WORD_LIST *list, *args;

-

3299

int i;

-

3300

-

3301

/* Break out of the loop as soon as one of the dollar variables is null. */

-

3302

for (i = 1, list = (WORD_LIST *)NULL; i < 10 && dollar_vars[i]; i++)

i < 10	Description
TRUE	evaluated 1687610 times by 1 test Evaluated by: Self test
FALSE	evaluated 198 times by 1 test Evaluated by: Self test

dollar_vars[i]	Description
TRUE	evaluated 35538 times by 1 test Evaluated by: Self test
FALSE	evaluated 1652072 times by 1 test Evaluated by: Self test

198-1687610

3303

list = make_word_list (make_bare_word (dollar_vars[i]), list);

executed 35538 times by 1 test: list = make_word_list (make_bare_word (dollar_vars[i]), list);

Executed by:

Self test

35538

3304

-

3305

for (args = rest_of_args; args; args = args->next)

args	Description
TRUE	evaluated 353 times by 1 test Evaluated by: Self test
FALSE	evaluated 1652270 times by 1 test Evaluated by: Self test

353-1652270

3306

list = make_word_list (make_bare_word (args->word->word), list);

executed 353 times by 1 test: list = make_word_list (make_bare_word (args->word->word), list);

Executed by:

Self test

353

3307

-

3308

return (REVERSE_LIST (list, WORD_LIST *));

executed 1652270 times by 1 test: return (((list && list->next) ? (WORD_LIST *)list_reverse ((GENERIC_LIST *)list) : (WORD_LIST *)(list)));

Executed by:

Self test

1652270

3309

}

-

3310

-

3311

int

-

3312

number_of_args ()

-

3313

{

-

3314

register WORD_LIST *list;

-

3315

int n;

-

3316

-

3317

for (n = 0; n < 9 && dollar_vars[n+1]; n++)

n < 9	Description
TRUE	evaluated 80311693 times by 1 test Evaluated by: Self test
FALSE	evaluated 29 times by 1 test Evaluated by: Self test

dollar_vars[n+1]	Description
TRUE	evaluated 53283592 times by 1 test Evaluated by: Self test
FALSE	evaluated 27028101 times by 1 test Evaluated by: Self test

29-80311693

3318

;

executed 53283592 times by 1 test: ;

Executed by:

Self test

53283592

3319

for (list = rest_of_args; list; list = list->next)

list	Description
TRUE	evaluated 38 times by 1 test Evaluated by: Self test
FALSE	evaluated 27028130 times by 1 test Evaluated by: Self test

38-27028130

3320

n++;

executed 38 times by 1 test: n++;

Executed by:

Self test

38

3321

return n;

executed 27028130 times by 1 test: return n;

Executed by:

Self test

27028130

3322

}

-

3323

-

3324

/* Return the value of a positional parameter. This handles values > 10. */

-

3325

char *

-

3326

get_dollar_var_value (ind)

-

3327

intmax_t ind;

-

3328

{

-

3329

char *temp;

-

3330

WORD_LIST *p;

-

3331

-

3332

if (ind < 10)

ind < 10	Description
TRUE	evaluated 14893 times by 1 test Evaluated by: Self test
FALSE	evaluated 1 time by 1 test Evaluated by: Self test

1-14893

3333

temp = dollar_vars[ind] ? savestring (dollar_vars[ind]) : (char *)NULL;

executed 14893 times by 1 test:

temp = dollar_vars[ind] ? (char *)strcpy (sh_xmalloc((1 + strlen (dollar_vars[ind])), "subst.c", 3333), (dollar_vars[ind])) : (char *) ((void *)0) ;

Executed by:

Self test

dollar_vars[ind]	Description
TRUE	evaluated 14652 times by 1 test Evaluated by: Self test
FALSE	evaluated 241 times by 1 test Evaluated by: Self test

241-14893

3334

else /* We want something like ${11} */

-

3335

{

-

3336

ind -= 10;

-

3337

for (p = rest_of_args; p && ind--; p = p->next)

p	Description
TRUE	evaluated 1 time by 1 test Evaluated by: Self test
FALSE	never evaluated

ind--	Description
TRUE	never evaluated
FALSE	evaluated 1 time by 1 test Evaluated by: Self test

0-1

3338

;

never executed: ;

0

3339

temp = p ? savestring (p->word->word) : (char *)NULL;

p	Description
TRUE	evaluated 1 time by 1 test Evaluated by: Self test
FALSE	never evaluated

0-1

3340

}

executed 1 time by 1 test: end of block

Executed by:

Self test

1

3341

return (temp);

executed 14894 times by 1 test: return (temp);

Executed by:

Self test

14894

3342

}

-

3343

-

3344

/* Make a single large string out of the dollar digit variables,

-

3345

and the rest_of_args. If DOLLAR_STAR is 1, then obey the special

-

3346

case of "$*" with respect to IFS. */

-

3347

char *

-

3348

string_rest_of_args (dollar_star)

-

3349

int dollar_star;

-

3350

{

-

3351

register WORD_LIST *list;

-

3352

char *string;

-

3353

-

3354

list = list_rest_of_args ();

-

3355

string = dollar_star ? string_list_dollar_star (list, 0, 0) : string_list (list);

dollar_star	Description
TRUE	never evaluated
FALSE	never evaluated

0

3356

dispose_words (list);

-

3357

return (string);

never executed: return (string);

0

3358

}

-

3359

-

3360

/* Return a string containing the positional parameters from START to

-

3361

END, inclusive. If STRING[0] == '*', we obey the rules for $*,

-

3362

which only makes a difference if QUOTED is non-zero. If QUOTED includes

-

3363

Q_HERE_DOCUMENT or Q_DOUBLE_QUOTES, this returns a quoted list, otherwise

-

3364

no quoting chars are added. */

-

3365

static char *

-

3366

pos_params (string, start, end, quoted)

-

3367

char *string;

-

3368

int start, end, quoted;

-

3369

{

-

3370

WORD_LIST *save, *params, *h, *t;

-

3371

char *ret;

-

3372

int i;

-

3373

-

3374

/* see if we can short-circuit. if start == end, we want 0 parameters. */

-

3375

if (start == end)

start == end	Description
TRUE	evaluated 6 times by 1 test Evaluated by: Self test
FALSE	evaluated 215 times by 1 test Evaluated by: Self test

6-215

3376

return ((char *)NULL);

executed 6 times by 1 test: return ((char *) ((void *)0) );

Executed by:

Self test

6

3377

-

3378

save = params = list_rest_of_args ();

-

3379

if (save == 0 && start > 0)

save == 0	Description
TRUE	evaluated 8 times by 1 test Evaluated by: Self test
FALSE	evaluated 207 times by 1 test Evaluated by: Self test

start > 0	Description
TRUE	never evaluated
FALSE	evaluated 8 times by 1 test Evaluated by: Self test

0-207

3380

return ((char *)NULL);

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

0

3381

-

3382

if (start == 0) /* handle ${@:0[:x]} specially */

start == 0	Description
TRUE	evaluated 8 times by 1 test Evaluated by: Self test
FALSE	evaluated 207 times by 1 test Evaluated by: Self test

8-207

3383

{

-

3384

t = make_word_list (make_word (dollar_vars[0]), params);

-

3385

save = params = t;

-

3386

}

executed 8 times by 1 test: end of block

Executed by:

Self test

8

3387

-

3388

for (i = start ? 1 : 0; params && i < start; i++)

params	Description
TRUE	evaluated 296 times by 1 test Evaluated by: Self test
FALSE	never evaluated

i < start	Description
TRUE	evaluated 81 times by 1 test Evaluated by: Self test
FALSE	evaluated 215 times by 1 test Evaluated by: Self test

0-296

3389

params = params->next;

executed 81 times by 1 test: params = params->next;

Executed by:

Self test

81

3390

if (params == 0)

params == 0	Description
TRUE	never evaluated
FALSE	evaluated 215 times by 1 test Evaluated by: Self test

0-215

3391

{

-

3392

dispose_words (save);

-

3393

return ((char *)NULL);

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

0

3394

}

-

3395

for (h = t = params; params && i < end; i++)

params	Description
TRUE	evaluated 423 times by 1 test Evaluated by: Self test
FALSE	evaluated 170 times by 1 test Evaluated by: Self test

i < end	Description
TRUE	evaluated 378 times by 1 test Evaluated by: Self test
FALSE	evaluated 45 times by 1 test Evaluated by: Self test

45-423

3396

{

-

3397

t = params;

-

3398

params = params->next;

-

3399

}

executed 378 times by 1 test: end of block

Executed by:

Self test

378

3400

t->next = (WORD_LIST *)NULL;

-

3401

-

3402

ret = string_list_pos_params (string[0], h, quoted);

-

3403

-

3404

if (t != params)

t != params	Description
TRUE	evaluated 215 times by 1 test Evaluated by: Self test
FALSE	never evaluated

0-215

3405

t->next = params;

executed 215 times by 1 test: t->next = params;

Executed by:

Self test

215

3406

-

3407

dispose_words (save);

-

3408

return (ret);

executed 215 times by 1 test: return (ret);

Executed by:

Self test

215

3409

}

-

3410

-

3411

/******************************************************************/

-

3412

/* */

-

3413

/* Functions to expand strings to strings or WORD_LISTs */

-

3414

/* */

-

3415

/******************************************************************/

-

3416

-

3417

#if defined (PROCESS_SUBSTITUTION)

-

3418

#define EXP_CHAR(s) (s == '$' || s == '`' || s == '<' || s == '>' || s == CTLESC || s == '~')

-

3419

#else

-

3420

#define EXP_CHAR(s) (s == '$' || s == '`' || s == CTLESC || s == '~')

-

3421

#endif

-

3422

-

3423

/* If there are any characters in STRING that require full expansion,

-

3424

then call FUNC to expand STRING; otherwise just perform quote

-

3425

removal if necessary. This returns a new string. */

-

3426

static char *

-

3427

expand_string_if_necessary (string, quoted, func)

-

3428

char *string;

-

3429

int quoted;

-

3430

EXPFUNC *func;

-

3431

{

-

3432

WORD_LIST *list;

-

3433

size_t slen;

-

3434

int i, saw_quote;

-

3435

char *ret;

-

3436

DECLARE_MBSTATE;

-

3437

-

3438

/* Don't need string length for ADVANCE_CHAR unless multibyte chars possible. */

-

3439

slen = (MB_CUR_MAX > 1) ? strlen (string) : 0;

( (__ctype_get...r_max ()) > 1)	Description
TRUE	evaluated 36421009 times by 1 test Evaluated by: Self test
FALSE	evaluated 900 times by 1 test Evaluated by: Self test

900-36421009

3440

i = saw_quote = 0;

-

3441

while (string[i])

string[i]	Description
TRUE	evaluated 61299003 times by 1 test Evaluated by: Self test
FALSE	evaluated 6522001 times by 1 test Evaluated by: Self test

6522001-61299003

3442

{

-

3443

if (EXP_CHAR (string[i]))

string[i] == '$'	Description
TRUE	evaluated 26668544 times by 1 test Evaluated by: Self test
FALSE	evaluated 34630459 times by 1 test Evaluated by: Self test

string[i] == '`'	Description
TRUE	evaluated 3230002 times by 1 test Evaluated by: Self test
FALSE	evaluated 31400457 times by 1 test Evaluated by: Self test

string[i] == '<'	Description
TRUE	evaluated 1144 times by 1 test Evaluated by: Self test
FALSE	evaluated 31399313 times by 1 test Evaluated by: Self test

string[i] == '>'	Description
TRUE	evaluated 9 times by 1 test Evaluated by: Self test
FALSE	evaluated 31399304 times by 1 test Evaluated by: Self test

string[i] == '\001'	Description
TRUE	evaluated 190 times by 1 test Evaluated by: Self test
FALSE	evaluated 31399114 times by 1 test Evaluated by: Self test

string[i] == '~'	Description
TRUE	evaluated 19 times by 1 test Evaluated by: Self test
FALSE	evaluated 31399095 times by 1 test Evaluated by: Self test

9-34630459

3444

break;

executed 29899908 times by 1 test: break;

Executed by:

Self test

29899908

3445

else if (string[i] == '\'' || string[i] == '\\' || string[i] == '"')

string[i] == '\''	Description
TRUE	evaluated 13006906 times by 1 test Evaluated by: Self test
FALSE	evaluated 18392189 times by 1 test Evaluated by: Self test

string[i] == '\\'	Description
TRUE	evaluated 141 times by 1 test Evaluated by: Self test
FALSE	evaluated 18392048 times by 1 test Evaluated by: Self test

string[i] == '"'	Description
TRUE	evaluated 11845252 times by 1 test Evaluated by: Self test
FALSE	evaluated 6546796 times by 1 test Evaluated by: Self test

141-18392189

3446

saw_quote = 1;

executed 24852299 times by 1 test: saw_quote = 1;

Executed by:

Self test

24852299

3447

ADVANCE_CHAR (string, slen, i);

executed 31397685 times by 1 test: mblength = 1;

Executed by:

Self test

executed 130 times by 1 test: mblength = 1;

Executed by:

Self test

executed 61 times by 1 test: end of block

Executed by:

Self test

executed 26 times by 1 test: end of block

Executed by:

Self test

never executed: (i)++;

executed 31397850 times by 1 test: (i) += mblength;

Executed by:

Self test

executed 1219 times by 1 test: (i)++;

Executed by:

Self test

locale_mb_cur_max > 1	Description
TRUE	evaluated 31397876 times by 1 test Evaluated by: Self test
FALSE	evaluated 1219 times by 1 test Evaluated by: Self test

_f	Description
TRUE	evaluated 31397685 times by 1 test Evaluated by: Self test
FALSE	evaluated 191 times by 1 test Evaluated by: Self test

mblength == 0	Description
TRUE	never evaluated
FALSE	evaluated 31397850 times by 1 test Evaluated by: Self test

locale_utf8locale	Description
TRUE	evaluated 191 times by 1 test Evaluated by: Self test
FALSE	never evaluated

(((string)[i] & 0x80) == 0)	Description
TRUE	evaluated 130 times by 1 test Evaluated by: Self test
FALSE	evaluated 61 times by 1 test Evaluated by: Self test

mblength == (size_t)-2	Description
TRUE	never evaluated
FALSE	evaluated 31397876 times by 1 test Evaluated by: Self test

mblength == (size_t)-1	Description
TRUE	evaluated 26 times by 1 test Evaluated by: Self test
FALSE	evaluated 31397850 times by 1 test Evaluated by: Self test

0-31397876

3448

}

executed 31399095 times by 1 test: end of block

Executed by:

Self test

31399095

3449

-

3450

if (string[i])

string[i]	Description
TRUE	evaluated 29899908 times by 1 test Evaluated by: Self test
FALSE	evaluated 6522001 times by 1 test Evaluated by: Self test

6522001-29899908

3451

{

-

3452

list = (*func) (string, quoted);

-

3453

if (list)

list	Description
TRUE	evaluated 29895048 times by 1 test Evaluated by: Self test
FALSE	evaluated 2405 times by 1 test Evaluated by: Self test

2405-29895048

3454

{

-

3455

ret = string_list (list);

-

3456

dispose_words (list);

-

3457

}

executed 29895048 times by 1 test: end of block

Executed by:

Self test

29895048

3458

else

-

3459

ret = (char *)NULL;

executed 2405 times by 1 test: ret = (char *) ((void *)0) ;

Executed by:

Self test

2405

3460

}

-

3461

else if (saw_quote && ((quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)) == 0))

saw_quote	Description
TRUE	evaluated 6503628 times by 1 test Evaluated by: Self test
FALSE	evaluated 18373 times by 1 test Evaluated by: Self test

((quoted & (0x...\|0x001)) == 0)	Description
TRUE	evaluated 6503628 times by 1 test Evaluated by: Self test
FALSE	never evaluated

0-6503628

3462

ret = string_quote_removal (string, quoted);

executed 6503628 times by 1 test: ret = string_quote_removal (string, quoted);

Executed by:

Self test

6503628

3463

else

-

3464

ret = savestring (string);

executed 18373 times by 1 test: ret = (char *)strcpy (sh_xmalloc((1 + strlen (string)), "subst.c", 3464), (string));

Executed by:

Self test

18373

3465

-

3466

return ret;

executed 36419454 times by 1 test: return ret;

Executed by:

Self test

36419454

3467

}

-

3468

-

3469

static inline char *

-

3470

expand_string_to_string_internal (string, quoted, func)

-

3471

char *string;

-

3472

int quoted;

-

3473

EXPFUNC *func;

-

3474

{

-

3475

WORD_LIST *list;

-

3476

char *ret;

-

3477

-

3478

if (string == 0 || *string == '\0')

string == 0	Description
TRUE	never evaluated
FALSE	evaluated 2630 times by 1 test Evaluated by: Self test

*string == '\0'	Description
TRUE	evaluated 21 times by 1 test Evaluated by: Self test
FALSE	evaluated 2609 times by 1 test Evaluated by: Self test

0-2630

3479

return ((char *)NULL);

executed 21 times by 1 test: return ((char *) ((void *)0) );

Executed by:

Self test

21

3480

-

3481

list = (*func) (string, quoted);

-

3482

if (list)

list	Description
TRUE	evaluated 2604 times by 1 test Evaluated by: Self test
FALSE	evaluated 3 times by 1 test Evaluated by: Self test

3-2604

3483

{

-

3484

ret = string_list (list);

-

3485

dispose_words (list);

-

3486

}

executed 2604 times by 1 test: end of block

Executed by:

Self test

2604

3487

else

-

3488

ret = (char *)NULL;

executed 3 times by 1 test: ret = (char *) ((void *)0) ;

Executed by:

Self test

3

3489

-

3490

return (ret);

executed 2607 times by 1 test: return (ret);

Executed by:

Self test

2607

3491

}

-

3492

-

3493

char *

-

3494

expand_string_to_string (string, quoted)

-

3495

char *string;

-

3496

int quoted;

-

3497

{

-

3498

return (expand_string_to_string_internal (string, quoted, expand_string));

never executed: return (expand_string_to_string_internal (string, quoted, expand_string));

0

3499

}

-

3500

-

3501

char *

-

3502

expand_string_unsplit_to_string (string, quoted)

-

3503

char *string;

-

3504

int quoted;

-

3505

{

-

3506

return (expand_string_to_string_internal (string, quoted, expand_string_unsplit));

executed 67 times by 1 test: return (expand_string_to_string_internal (string, quoted, expand_string_unsplit));

Executed by:

Self test

67

3507

}

-

3508

-

3509

char *

-

3510

expand_assignment_string_to_string (string, quoted)

-

3511

char *string;

-

3512

int quoted;

-

3513

{

-

3514

return (expand_string_to_string_internal (string, quoted, expand_string_assignment));

executed 2563 times by 1 test: return (expand_string_to_string_internal (string, quoted, expand_string_assignment));

Executed by:

Self test

2563

3515

}

-

3516

-

3517

char *

-

3518

expand_arith_string (string, quoted)

-

3519

char *string;

-

3520

int quoted;

-

3521

{

-

3522

WORD_DESC td;

-

3523

WORD_LIST *list, *tlist;

-

3524

size_t slen;

-

3525

int i, saw_quote;

-

3526

char *ret;

-

3527

DECLARE_MBSTATE;

-

3528

-

3529

/* Don't need string length for ADVANCE_CHAR unless multibyte chars possible. */

-

3530

slen = (MB_CUR_MAX > 1) ? strlen (string) : 0;

( (__ctype_get...r_max ()) > 1)	Description
TRUE	evaluated 35264 times by 1 test Evaluated by: Self test
FALSE	evaluated 21 times by 1 test Evaluated by: Self test

21-35264

3531

i = saw_quote = 0;

-

3532

while (string[i])

string[i]	Description
TRUE	evaluated 277455 times by 1 test Evaluated by: Self test
FALSE	evaluated 31924 times by 1 test Evaluated by: Self test

31924-277455

3533

{

-

3534

if (EXP_CHAR (string[i]))

string[i] == '$'	Description
TRUE	evaluated 3180 times by 1 test Evaluated by: Self test
FALSE	evaluated 274275 times by 1 test Evaluated by: Self test

string[i] == '`'	Description
TRUE	evaluated 29 times by 1 test Evaluated by: Self test
FALSE	evaluated 274246 times by 1 test Evaluated by: Self test

string[i] == '<'	Description
TRUE	evaluated 91 times by 1 test Evaluated by: Self test
FALSE	evaluated 274155 times by 1 test Evaluated by: Self test

string[i] == '>'	Description
TRUE	evaluated 41 times by 1 test Evaluated by: Self test
FALSE	evaluated 274114 times by 1 test Evaluated by: Self test

string[i] == '\001'	Description
TRUE	evaluated 1 time by 1 test Evaluated by: Self test
FALSE	evaluated 274113 times by 1 test Evaluated by: Self test

string[i] == '~'	Description
TRUE	evaluated 19 times by 1 test Evaluated by: Self test
FALSE	evaluated 274094 times by 1 test Evaluated by: Self test

1-274275

3535

break;

executed 3361 times by 1 test: break;

Executed by:

Self test

3361

3536

else if (string[i] == '\'' || string[i] == '\\' || string[i] == '"')

string[i] == '\''	Description
TRUE	evaluated 4 times by 1 test Evaluated by: Self test
FALSE	evaluated 274090 times by 1 test Evaluated by: Self test

string[i] == '\\'	Description
TRUE	evaluated 10 times by 1 test Evaluated by: Self test
FALSE	evaluated 274080 times by 1 test Evaluated by: Self test

string[i] == '"'	Description
TRUE	evaluated 1794 times by 1 test Evaluated by: Self test
FALSE	evaluated 272286 times by 1 test Evaluated by: Self test

4-274090

3537

saw_quote = 1;

executed 1808 times by 1 test: saw_quote = 1;

Executed by:

Self test

1808

3538

ADVANCE_CHAR (string, slen, i);

executed 274037 times by 1 test: mblength = 1;

Executed by:

Self test

executed 8 times by 1 test: mblength = 1;

Executed by:

Self test

never executed: end of block

never executed: (i)++;

executed 274045 times by 1 test: (i) += mblength;

Executed by:

Self test

executed 49 times by 1 test: (i)++;

Executed by:

Self test

locale_mb_cur_max > 1	Description
TRUE	evaluated 274045 times by 1 test Evaluated by: Self test
FALSE	evaluated 49 times by 1 test Evaluated by: Self test

_f	Description
TRUE	evaluated 274037 times by 1 test Evaluated by: Self test
FALSE	evaluated 8 times by 1 test Evaluated by: Self test

mblength == 0	Description
TRUE	never evaluated
FALSE	evaluated 274045 times by 1 test Evaluated by: Self test

locale_utf8locale	Description
TRUE	evaluated 8 times by 1 test Evaluated by: Self test
FALSE	never evaluated

(((string)[i] & 0x80) == 0)	Description
TRUE	evaluated 8 times by 1 test Evaluated by: Self test
FALSE	never evaluated

mblength == (size_t)-2	Description
TRUE	never evaluated
FALSE	evaluated 274045 times by 1 test Evaluated by: Self test

mblength == (size_t)-1	Description
TRUE	never evaluated
FALSE	evaluated 274045 times by 1 test Evaluated by: Self test

0-274045

3539

}

executed 274094 times by 1 test: end of block

Executed by:

Self test

274094

3540

-

3541

if (string[i])

string[i]	Description
TRUE	evaluated 3361 times by 1 test Evaluated by: Self test
FALSE	evaluated 31924 times by 1 test Evaluated by: Self test

3361-31924

3542

{

-

3543

/* This is expanded version of expand_string_internal as it's called by

-

3544

expand_string_leave_quoted */

-

3545

td.flags = W_NOPROCSUB; /* don't want process substitution */

-

3546

td.word = savestring (string);

-

3547

list = call_expand_word_internal (&td, quoted, 0, (int *)NULL, (int *)NULL);

-

3548

/* This takes care of the calls from expand_string_leave_quoted and

-

3549

expand_string */

-

3550

if (list)

list	Description
TRUE	evaluated 3323 times by 1 test Evaluated by: Self test
FALSE	evaluated 3 times by 1 test Evaluated by: Self test

3-3323

3551

{

-

3552

tlist = word_list_split (list);

-

3553

dispose_words (list);

-

3554

list = tlist;

-

3555

if (list)

list	Description
TRUE	evaluated 3323 times by 1 test Evaluated by: Self test
FALSE	never evaluated

0-3323

3556

dequote_list (list);

executed 3323 times by 1 test: dequote_list (list);

Executed by:

Self test

3323

3557

}

executed 3323 times by 1 test: end of block

Executed by:

Self test

3323

3558

/* This comes from expand_string_if_necessary */

-

3559

if (list)

list	Description
TRUE	evaluated 3323 times by 1 test Evaluated by: Self test
FALSE	evaluated 3 times by 1 test Evaluated by: Self test

3-3323

3560

{

-

3561

ret = string_list (list);

-

3562

dispose_words (list);

-

3563

}

executed 3323 times by 1 test: end of block

Executed by:

Self test

3323

3564

else

-

3565

ret = (char *)NULL;

executed 3 times by 1 test: ret = (char *) ((void *)0) ;

Executed by:

Self test

3

3566

FREE (td.word);

executed 3326 times by 1 test: sh_xfree((td.word), "subst.c", 3566);

Executed by:

Self test

td.word	Description
TRUE	evaluated 3326 times by 1 test Evaluated by: Self test
FALSE	never evaluated

0-3326

3567

}

executed 3326 times by 1 test: end of block

Executed by:

Self test

3326

3568

else if (saw_quote && (quoted & Q_ARITH))

saw_quote	Description
TRUE	evaluated 9 times by 1 test Evaluated by: Self test
FALSE	evaluated 31915 times by 1 test Evaluated by: Self test

(quoted & 0x100)	Description
TRUE	evaluated 9 times by 1 test Evaluated by: Self test
FALSE	never evaluated

0-31915

3569

ret = string_quote_removal (string, quoted);

executed 9 times by 1 test: ret = string_quote_removal (string, quoted);

Executed by:

Self test

9

3570

else if (saw_quote && ((quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)) == 0))

saw_quote	Description
TRUE	never evaluated
FALSE	evaluated 31915 times by 1 test Evaluated by: Self test

((quoted & (0x...\|0x001)) == 0)	Description
TRUE	never evaluated
FALSE	never evaluated

0-31915

3571

ret = string_quote_removal (string, quoted);

never executed: ret = string_quote_removal (string, quoted);

0

3572

else

-

3573

ret = savestring (string);

executed 31915 times by 1 test: ret = (char *)strcpy (sh_xmalloc((1 + strlen (string)), "subst.c", 3573), (string));

Executed by:

Self test

31915

3574

-

3575

return ret;

executed 35250 times by 1 test: return ret;

Executed by:

Self test

35250

3576

}

-

3577

-

3578

#if defined (COND_COMMAND)

-

3579

/* Just remove backslashes in STRING. Returns a new string. */

-

3580

char *

-

3581

remove_backslashes (string)

-

3582

char *string;

-

3583

{

-

3584

char *r, *ret, *s;

-

3585

-

3586

r = ret = (char *)xmalloc (strlen (string) + 1);

-

3587

for (s = string; s && *s; )

s	Description
TRUE	never evaluated
FALSE	never evaluated

*s	Description
TRUE	never evaluated
FALSE	never evaluated

0

3588

{

-

3589

if (*s == '\\')

*s == '\\'	Description
TRUE	never evaluated
FALSE	never evaluated

0

3590

s++;

never executed: s++;

0

3591

if (*s == 0)

*s == 0	Description
TRUE	never evaluated
FALSE	never evaluated

0

3592

break;

never executed: break;

0

3593

*r++ = *s++;

-

3594

}

never executed: end of block

0

3595

*r = '\0';

-

3596

return ret;

never executed: return ret;

0

3597

}

-

3598

-

3599

/* This needs better error handling. */

-

3600

/* Expand W for use as an argument to a unary or binary operator in a

-

3601

[[...]] expression. If SPECIAL is 1, this is the rhs argument

-

3602

to the != or == operator, and should be treated as a pattern. In

-

3603

this case, we quote the string specially for the globbing code. If

-

3604

SPECIAL is 2, this is an rhs argument for the =~ operator, and should

-

3605

be quoted appropriately for regcomp/regexec. The caller is responsible

-

3606

for removing the backslashes if the unquoted word is needed later. */

-

3607

char *

-

3608

cond_expand_word (w, special)

-

3609

WORD_DESC *w;

-

3610

int special;

-

3611

{

-

3612

char *r, *p;

-

3613

WORD_LIST *l;

-

3614

int qflags;

-

3615

-

3616

if (w->word == 0 || w->word[0] == '\0')

w->word == 0	Description
TRUE	never evaluated
FALSE	evaluated 1460 times by 1 test Evaluated by: Self test

w->word[0] == '\0'	Description
TRUE	never evaluated
FALSE	evaluated 1460 times by 1 test Evaluated by: Self test

0-1460

3617

return ((char *)NULL);

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

0

3618

-

3619

expand_no_split_dollar_star = 1;

-

3620

w->flags |= W_NOSPLIT2;

-

3621

l = call_expand_word_internal (w, 0, 0, (int *)0, (int *)0);

-

3622

expand_no_split_dollar_star = 0;

-

3623

if (l)

l	Description
TRUE	evaluated 1367 times by 1 test Evaluated by: Self test
FALSE	evaluated 92 times by 1 test Evaluated by: Self test

92-1367

3624

{

-

3625

if (special == 0) /* LHS */

special == 0	Description
TRUE	evaluated 858 times by 1 test Evaluated by: Self test
FALSE	evaluated 509 times by 1 test Evaluated by: Self test

509-858

3626

{

-

3627

dequote_list (l);

-

3628

r = string_list (l);

-

3629

}

executed 858 times by 1 test: end of block

Executed by:

Self test

858

3630

else

-

3631

{

-

3632

/* Need to figure out whether or not we should call dequote_escapes

-

3633

or a new dequote_ctlnul function here, and under what

-

3634

circumstances. */

-

3635

qflags = QGLOB_CVTNULL;

-

3636

if (special == 2)

special == 2	Description
TRUE	evaluated 89 times by 1 test Evaluated by: Self test
FALSE	evaluated 420 times by 1 test Evaluated by: Self test

89-420

3637

qflags |= QGLOB_REGEXP;

executed 89 times by 1 test: qflags |= 0x04;

Executed by:

Self test

89

3638

word_list_remove_quoted_nulls (l);

-

3639

p = string_list (l);

-

3640

r = quote_string_for_globbing (p, qflags);

-

3641

free (p);

-

3642

}

executed 509 times by 1 test: end of block

Executed by:

Self test

509

3643

dispose_words (l);

-

3644

}

executed 1367 times by 1 test: end of block

Executed by:

Self test

1367

3645

else

-

3646

r = (char *)NULL;

executed 92 times by 1 test: r = (char *) ((void *)0) ;

Executed by:

Self test

92

3647

-

3648

return r;

executed 1459 times by 1 test: return r;

Executed by:

Self test

1459

3649

}

-

3650

#endif

-

3651

-

3652

/* Call expand_word_internal to expand W and handle error returns.

-

3653

A convenience function for functions that don't want to handle

-

3654

any errors or free any memory before aborting. */

-

3655

static WORD_LIST *

-

3656

call_expand_word_internal (w, q, i, c, e)

-

3657

WORD_DESC *w;

-

3658

int q, i, *c, *e;

-

3659

{

-

3660

WORD_LIST *result;

-

3661

-

3662

result = expand_word_internal (w, q, i, c, e);

-

3663

if (result == &expand_word_error || result == &expand_word_fatal)

result == &expand_word_error	Description
TRUE	evaluated 11 times by 1 test Evaluated by: Self test
FALSE	evaluated 116033927 times by 1 test Evaluated by: Self test

result == &expand_word_fatal	Description
TRUE	evaluated 3 times by 1 test Evaluated by: Self test
FALSE	evaluated 116033924 times by 1 test Evaluated by: Self test

3-116033927

3664

{

-

3665

/* By convention, each time this error is returned, w->word has

-

3666

already been freed (it sometimes may not be in the fatal case,

-

3667

but that doesn't result in a memory leak because we're going

-

3668

to exit in most cases). */

-

3669

w->word = (char *)NULL;

-

3670

last_command_exit_value = EXECUTION_FAILURE;

-

3671

exp_jump_to_top_level ((result == &expand_word_error) ? DISCARD : FORCE_EOF);

-

3672

/* NOTREACHED */

-

3673

return (NULL);

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

0

3674

}

-

3675

else

-

3676

return (result);

executed 116033924 times by 1 test: return (result);

Executed by:

Self test

116033924

3677

}

-

3678

-

3679

/* Perform parameter expansion, command substitution, and arithmetic

-

3680

expansion on STRING, as if it were a word. Leave the result quoted.

-

3681

Since this does not perform word splitting, it leaves quoted nulls

-

3682

in the result. */

-

3683

static WORD_LIST *

-

3684

expand_string_internal (string, quoted)

-

3685

char *string;

-

3686

int quoted;

-

3687

{

-

3688

WORD_DESC td;

-

3689

WORD_LIST *tresult;

-

3690

-

3691

if (string == 0 || *string == 0)

string == 0	Description
TRUE	never evaluated
FALSE	evaluated 343 times by 1 test Evaluated by: Self test

*string == 0	Description
TRUE	never evaluated
FALSE	evaluated 343 times by 1 test Evaluated by: Self test

0-343

3692

return ((WORD_LIST *)NULL);

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

0

3693

-

3694

td.flags = 0;

-

3695

td.word = savestring (string);

-

3696

-

3697

tresult = call_expand_word_internal (&td, quoted, 0, (int *)NULL, (int *)NULL);

-

3698

-

3699

FREE (td.word);

executed 339 times by 1 test: sh_xfree((td.word), "subst.c", 3699);

Executed by:

Self test

td.word	Description
TRUE	evaluated 339 times by 1 test Evaluated by: Self test
FALSE	never evaluated

0-339

3700

return (tresult);

executed 339 times by 1 test: return (tresult);

Executed by:

Self test

339

3701

}

-

3702

-

3703

/* Expand STRING by performing parameter expansion, command substitution,

-

3704

and arithmetic expansion. Dequote the resulting WORD_LIST before

-

3705

returning it, but do not perform word splitting. The call to

-

3706

remove_quoted_nulls () is in here because word splitting normally

-

3707

takes care of quote removal. */

-

3708

WORD_LIST *

-

3709

expand_string_unsplit (string, quoted)

-

3710

char *string;

-

3711

int quoted;

-

3712

{

-

3713

WORD_LIST *value;

-

3714

-

3715

if (string == 0 || *string == '\0')

string == 0	Description
TRUE	never evaluated
FALSE	evaluated 70 times by 1 test Evaluated by: Self test

*string == '\0'	Description
TRUE	never evaluated
FALSE	evaluated 70 times by 1 test Evaluated by: Self test

0-70

3716

return ((WORD_LIST *)NULL);

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

0

3717

-

3718

expand_no_split_dollar_star = 1;

-

3719

value = expand_string_internal (string, quoted);

-

3720

expand_no_split_dollar_star = 0;

-

3721

-

3722

if (value)

value	Description
TRUE	evaluated 68 times by 1 test Evaluated by: Self test
FALSE	evaluated 1 time by 1 test Evaluated by: Self test

1-68

3723

{

-

3724

if (value->word)

value->word	Description
TRUE	evaluated 68 times by 1 test Evaluated by: Self test
FALSE	never evaluated

0-68

3725

{

-

3726

remove_quoted_nulls (value->word->word);

-

3727

value->word->flags &= ~W_HASQUOTEDNULL;

-

3728

}

executed 68 times by 1 test: end of block

Executed by:

Self test

68

3729

dequote_list (value);

-

3730

}

executed 68 times by 1 test: end of block

Executed by:

Self test

68

3731

return (value);

executed 69 times by 1 test: return (value);

Executed by:

Self test

69

3732

}

-

3733

-

3734

/* Expand the rhs of an assignment statement */

-

3735

WORD_LIST *

-

3736

expand_string_assignment (string, quoted)

-

3737

char *string;

-

3738

int quoted;

-

3739

{

-

3740

WORD_DESC td;

-

3741

WORD_LIST *value;

-

3742

-

3743

if (string == 0 || *string == '\0')

string == 0	Description
TRUE	never evaluated
FALSE	evaluated 29902447 times by 1 test Evaluated by: Self test

*string == '\0'	Description
TRUE	never evaluated
FALSE	evaluated 29902447 times by 1 test Evaluated by: Self test

0-29902447

3744

return ((WORD_LIST *)NULL);

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

0

3745

-

3746

expand_no_split_dollar_star = 1;

-

3747

-

3748

#if 0

-

3749

/* Other shells (ksh93) do it this way, which affects how $@ is expanded

-

3750

in constructs like bar=${@#0} (preserves the spaces resulting from the

-

3751

expansion of $@ in a context where you don't do word splitting); Posix

-

3752

interp 888 makes the expansion of $@ in contexts where word splitting

-

3753

is not performed unspecified. */

-

3754

td.flags = W_ASSIGNRHS|W_NOSPLIT2; /* Posix interp 888 */

-

3755

#else

-

3756

td.flags = W_ASSIGNRHS;

-

3757

#endif

-

3758

td.word = savestring (string);

-

3759

value = call_expand_word_internal (&td, quoted, 0, (int *)NULL, (int *)NULL);

-

3760

FREE (td.word);

executed 29899991 times by 1 test: sh_xfree((td.word), "subst.c", 3760);

Executed by:

Self test

td.word	Description
TRUE	evaluated 29899991 times by 1 test Evaluated by: Self test
FALSE	never evaluated

0-29899991

3761

-

3762

expand_no_split_dollar_star = 0;

-

3763

-

3764

if (value)

value	Description
TRUE	evaluated 29897584 times by 1 test Evaluated by: Self test
FALSE	evaluated 2407 times by 1 test Evaluated by: Self test

2407-29897584

3765

{

-

3766

if (value->word)

value->word	Description
TRUE	evaluated 29897584 times by 1 test Evaluated by: Self test
FALSE	never evaluated

0-29897584

3767

{

-

3768

remove_quoted_nulls (value->word->word);

-

3769

value->word->flags &= ~W_HASQUOTEDNULL;

-

3770

}

executed 29897584 times by 1 test: end of block

Executed by:

Self test

29897584

3771

dequote_list (value);

-

3772

}

executed 29897584 times by 1 test: end of block

Executed by:

Self test

29897584

3773

return (value);

executed 29899991 times by 1 test: return (value);

Executed by:

Self test

29899991

3774

}

-

3775

-

3776

-

3777

/* Expand one of the PS? prompt strings. This is a sort of combination of

-

3778

expand_string_unsplit and expand_string_internal, but returns the

-

3779

passed string when an error occurs. Might want to trap other calls

-

3780

to jump_to_top_level here so we don't endlessly loop. */

-

3781

WORD_LIST *

-

3782

expand_prompt_string (string, quoted, wflags)

-

3783

char *string;

-

3784

int quoted;

-

3785

int wflags;

-

3786

{

-

3787

WORD_LIST *value;

-

3788

WORD_DESC td;

-

3789

-

3790

if (string == 0 || *string == 0)

string == 0	Description
TRUE	never evaluated
FALSE	evaluated 61 times by 1 test Evaluated by: Self test

*string == 0	Description
TRUE	never evaluated
FALSE	evaluated 61 times by 1 test Evaluated by: Self test

0-61

3791

return ((WORD_LIST *)NULL);

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

0

3792

-

3793

td.flags = wflags;

-

3794

td.word = savestring (string);

-

3795

-

3796

no_longjmp_on_fatal_error = 1;

-

3797

value = expand_word_internal (&td, quoted, 0, (int *)NULL, (int *)NULL);

-

3798

no_longjmp_on_fatal_error = 0;

-

3799

-

3800

if (value == &expand_word_error || value == &expand_word_fatal)

value == &expand_word_error	Description
TRUE	never evaluated
FALSE	evaluated 61 times by 1 test Evaluated by: Self test

value == &expand_word_fatal	Description
TRUE	never evaluated
FALSE	evaluated 61 times by 1 test Evaluated by: Self test

0-61

3801

{

-

3802

value = make_word_list (make_bare_word (string), (WORD_LIST *)NULL);

-

3803

return value;

never executed: return value;

0

3804

}

-

3805

FREE (td.word);

executed 61 times by 1 test: sh_xfree((td.word), "subst.c", 3805);

Executed by:

Self test

td.word	Description
TRUE	evaluated 61 times by 1 test Evaluated by: Self test
FALSE	never evaluated

0-61

3806

if (value)

value	Description
TRUE	evaluated 61 times by 1 test Evaluated by: Self test
FALSE	never evaluated

0-61

3807

{

-

3808

if (value->word)

value->word	Description
TRUE	evaluated 61 times by 1 test Evaluated by: Self test
FALSE	never evaluated

0-61

3809

{

-

3810

remove_quoted_nulls (value->word->word);

-

3811

value->word->flags &= ~W_HASQUOTEDNULL;

-

3812

}

executed 61 times by 1 test: end of block

Executed by:

Self test

61

3813

dequote_list (value);

-

3814

}

executed 61 times by 1 test: end of block

Executed by:

Self test

61

3815

return (value);

executed 61 times by 1 test: return (value);

Executed by:

Self test

61

3816

}

-

3817

-

3818

/* Expand STRING just as if you were expanding a word, but do not dequote

-

3819

the resultant WORD_LIST. This is called only from within this file,

-

3820

and is used to correctly preserve quoted characters when expanding

-

3821

things like ${1+"$@"}. This does parameter expansion, command

-

3822

substitution, arithmetic expansion, and word splitting. */

-

3823

static WORD_LIST *

-

3824

expand_string_leave_quoted (string, quoted)

-

3825

char *string;

-

3826

int quoted;

-

3827

{

-

3828

WORD_LIST *tlist;

-

3829

WORD_LIST *tresult;

-

3830

-

3831

if (string == 0 || *string == '\0')

string == 0	Description
TRUE	never evaluated
FALSE	evaluated 273 times by 1 test Evaluated by: Self test

*string == '\0'	Description
TRUE	never evaluated
FALSE	evaluated 273 times by 1 test Evaluated by: Self test

0-273

3832

return ((WORD_LIST *)NULL);

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

0

3833

-

3834

tlist = expand_string_internal (string, quoted);

-

3835

-

3836

if (tlist)

tlist	Description
TRUE	evaluated 264 times by 1 test Evaluated by: Self test
FALSE	evaluated 6 times by 1 test Evaluated by: Self test

6-264

3837

{

-

3838

tresult = word_list_split (tlist);

-

3839

dispose_words (tlist);

-

3840

return (tresult);

executed 264 times by 1 test: return (tresult);

Executed by:

Self test

264

3841

}

-

3842

return ((WORD_LIST *)NULL);

executed 6 times by 1 test: return ((WORD_LIST *) ((void *)0) );

Executed by:

Self test

6

3843

}

-

3844

-

3845

/* This does not perform word splitting or dequote the WORD_LIST

-

3846

it returns. */

-

3847

static WORD_LIST *

-

3848

expand_string_for_rhs (string, quoted, op, pflags, dollar_at_p, expanded_p)

-

3849

char *string;

-

3850

int quoted, op, pflags;

-

3851

int *dollar_at_p, *expanded_p;

-

3852

{

-

3853

WORD_DESC td;

-

3854

WORD_LIST *tresult;

-

3855

int old_nosplit;

-

3856

-

3857

if (string == 0 || *string == '\0')

string == 0	Description
TRUE	never evaluated
FALSE	evaluated 10971 times by 1 test Evaluated by: Self test

*string == '\0'	Description
TRUE	never evaluated
FALSE	evaluated 10971 times by 1 test Evaluated by: Self test

0-10971

3858

return (WORD_LIST *)NULL;

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

0

3859

-

3860

/* We want field splitting to be determined by what is going to be done with

-

3861

the entire ${parameterOPword} expansion, so we don't want to split the RHS

-

3862

we expand here. However, the expansion of $* is determined by whether we

-

3863

are going to eventually perform word splitting, so we want to set this

-

3864

depending on whether or not are are going to be splitting: if the expansion

-

3865

is quoted, if the OP is `=', or if IFS is set to the empty string, we

-

3866

are not going to be splitting, so we set expand_no_split_dollar_star to

-

3867

We pass through PF_ASSIGNRHS as W_ASSIGNRHS if this is on the RHS of an

-

3868

assignment statement. */

-

3869

/* The updated treatment of $* is the result of Posix interp 888 */

-

3870

/* This was further clarified on the austin-group list in March, 2017 and

-

3871

in Posix bug 1129 */

-

3872

old_nosplit = expand_no_split_dollar_star;

-

3873

expand_no_split_dollar_star = (quoted & (Q_DOUBLE_QUOTES|Q_HERE_DOCUMENT)) || op == '=' || ifs_is_null == 0; /* XXX - was 1 */

(quoted & (0x001\|0x002))	Description
TRUE	evaluated 2049 times by 1 test Evaluated by: Self test
FALSE	evaluated 8922 times by 1 test Evaluated by: Self test

op == '='	Description
TRUE	evaluated 3480 times by 1 test Evaluated by: Self test
FALSE	evaluated 5442 times by 1 test Evaluated by: Self test

ifs_is_null == 0	Description
TRUE	evaluated 3809 times by 1 test Evaluated by: Self test
FALSE	evaluated 1633 times by 1 test Evaluated by: Self test

1633-8922

3874

td.flags = W_NOSPLIT2; /* no splitting, remove "" and '' */

-

3875

if (pflags & PF_ASSIGNRHS) /* pass through */

pflags & 0x08	Description
TRUE	evaluated 231 times by 1 test Evaluated by: Self test
FALSE	evaluated 10740 times by 1 test Evaluated by: Self test

231-10740

3876

td.flags |= W_ASSIGNRHS;

executed 231 times by 1 test: td.flags |= 0x000800;

Executed by:

Self test

231

3877

if (op == '=')

op == '='	Description
TRUE	evaluated 5136 times by 1 test Evaluated by: Self test
FALSE	evaluated 5835 times by 1 test Evaluated by: Self test

5136-5835

3878

#if 0

-

3879

td.flags |= W_ASSIGNRHS; /* expand b in ${a=b} like assignment */

-

3880

#else

-

3881

td.flags |= W_ASSIGNRHS|W_NOASSNTILDE; /* expand b in ${a=b} like assignment */

executed 5136 times by 1 test: td.flags |= 0x000800|0x20000000;

Executed by:

Self test

5136

3882

#endif

-

3883

td.word = string;

-

3884

tresult = call_expand_word_internal (&td, quoted, 1, dollar_at_p, expanded_p);

-

3885

expand_no_split_dollar_star = old_nosplit;

-

3886

-

3887

return (tresult);

executed 10956 times by 1 test: return (tresult);

Executed by:

Self test

10956

3888

}

-

3889

-

3890

/* This does not perform word splitting or dequote the WORD_LIST

-

3891

it returns and it treats $* as if it were quoted. */

-

3892

static WORD_LIST *

-

3893

expand_string_for_pat (string, quoted, dollar_at_p, expanded_p)

-

3894

char *string;

-

3895

int quoted, *dollar_at_p, *expanded_p;

-

3896

{

-

3897

WORD_DESC td;

-

3898

WORD_LIST *tresult;

-

3899

-

3900

if (string == 0 || *string == '\0')

string == 0	Description
TRUE	never evaluated
FALSE	evaluated 2316712 times by 1 test Evaluated by: Self test

*string == '\0'	Description
TRUE	never evaluated
FALSE	evaluated 2316712 times by 1 test Evaluated by: Self test

0-2316712

3901

return (WORD_LIST *)NULL;

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

0

3902

-

3903

expand_no_split_dollar_star = 1;

-

3904

td.flags = W_NOSPLIT2; /* no splitting, remove "" and '' */

-

3905

td.word = string;

-

3906

tresult = call_expand_word_internal (&td, quoted, 1, dollar_at_p, expanded_p);

-

3907

expand_no_split_dollar_star = 0;

-

3908

-

3909

return (tresult);

executed 2316708 times by 1 test: return (tresult);

Executed by:

Self test

2316708

3910

}

-

3911

-

3912

/* Expand STRING just as if you were expanding a word. This also returns

-

3913

a list of words. Note that filename globbing is *NOT* done for word

-

3914

or string expansion, just when the shell is expanding a command. This

-

3915

does parameter expansion, command substitution, arithmetic expansion,

-

3916

and word splitting. Dequote the resultant WORD_LIST before returning. */

-

3917

WORD_LIST *

-

3918

expand_string (string, quoted)

-

3919

char *string;

-

3920

int quoted;

-

3921

{

-

3922

WORD_LIST *result;

-

3923

-

3924

if (string == 0 || *string == '\0')

string == 0	Description
TRUE	never evaluated
FALSE	evaluated 273 times by 1 test Evaluated by: Self test

*string == '\0'	Description
TRUE	never evaluated
FALSE	evaluated 273 times by 1 test Evaluated by: Self test

0-273

3925

return ((WORD_LIST *)NULL);

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

0

3926

-

3927

result = expand_string_leave_quoted (string, quoted);

-

3928

return (result ? dequote_list (result) : result);

executed 270 times by 1 test: return (result ? dequote_list (result) : result);

Executed by:

Self test

270

3929

}

-

3930

-

3931

/*******************************************

-

3932

* *

-

3933

* Functions to expand WORD_DESCs *

-

3934

* *

-

3935

*******************************************/

-

3936

-

3937

/* Expand WORD, performing word splitting on the result. This does

-

3938

parameter expansion, command substitution, arithmetic expansion,

-

3939

word splitting, and quote removal. */

-

3940

-

3941

WORD_LIST *

-

3942

expand_word (word, quoted)

-

3943

WORD_DESC *word;

-

3944

int quoted;

-

3945

{

-

3946

WORD_LIST *result, *tresult;

-

3947

-

3948

tresult = call_expand_word_internal (word, quoted, 0, (int *)NULL, (int *)NULL);

-

3949

result = word_list_split (tresult);

-

3950

dispose_words (tresult);

-

3951

return (result ? dequote_list (result) : result);

never executed: return (result ? dequote_list (result) : result);

0

3952

}

-

3953

-

3954

/* Expand WORD, but do not perform word splitting on the result. This

-

3955

does parameter expansion, command substitution, arithmetic expansion,

-

3956

and quote removal. */

-

3957

WORD_LIST *

-

3958

expand_word_unsplit (word, quoted)

-

3959

WORD_DESC *word;

-

3960

int quoted;

-

3961

{

-

3962

WORD_LIST *result;

-

3963

-

3964

expand_no_split_dollar_star = 1;

-

3965

if (ifs_is_null)

ifs_is_null	Description
TRUE	evaluated 1614 times by 1 test Evaluated by: Self test
FALSE	evaluated 36945557 times by 1 test Evaluated by: Self test

1614-36945557

3966

word->flags |= W_NOSPLIT;

executed 1614 times by 1 test: word->flags |= 0x000010;

Executed by:

Self test

1614

3967

word->flags |= W_NOSPLIT2;

-

3968

result = call_expand_word_internal (word, quoted, 0, (int *)NULL, (int *)NULL);

-

3969

expand_no_split_dollar_star = 0;

-

3970

-

3971

return (result ? dequote_list (result) : result);

executed 36947163 times by 1 test: return (result ? dequote_list (result) : result);

Executed by:

Self test

36947163

3972

}

-

3973

-

3974

/* Perform shell expansions on WORD, but do not perform word splitting or

-

3975

quote removal on the result. Virtually identical to expand_word_unsplit;

-

3976

could be combined if implementations don't diverge. */

-

3977

WORD_LIST *

-

3978

expand_word_leave_quoted (word, quoted)

-

3979

WORD_DESC *word;

-

3980

int quoted;

-

3981

{

-

3982

WORD_LIST *result;

-

3983

-

3984

expand_no_split_dollar_star = 1;

-

3985

if (ifs_is_null)

ifs_is_null	Description
TRUE	evaluated 3224 times by 1 test Evaluated by: Self test
FALSE	evaluated 46850759 times by 1 test Evaluated by: Self test

3224-46850759

3986

word->flags |= W_NOSPLIT;

executed 3224 times by 1 test: word->flags |= 0x000010;

Executed by:

Self test

3224

3987

word->flags |= W_NOSPLIT2;

-

3988

result = call_expand_word_internal (word, quoted, 0, (int *)NULL, (int *)NULL);

-

3989

expand_no_split_dollar_star = 0;

-

3990

-

3991

return result;

executed 46853982 times by 1 test: return result;

Executed by:

Self test

46853982

3992

}

-

3993

-

3994

/***************************************************

-

3995

* *

-

3996

* Functions to handle quoting chars *

-

3997

* *

-

3998

***************************************************/

-

3999

-

4000

/* Conventions:

-

4001

-

4002

A string with s[0] == CTLNUL && s[1] == 0 is a quoted null string.

-

4003

The parser passes CTLNUL as CTLESC CTLNUL. */

-

4004

-

4005

/* Quote escape characters in string s, but no other characters. This is

-

4006

used to protect CTLESC and CTLNUL in variable values from the rest of

-

4007

the word expansion process after the variable is expanded (word splitting

-

4008

and filename generation). If IFS is null, we quote spaces as well, just

-

4009

in case we split on spaces later (in the case of unquoted $@, we will

-

4010

eventually attempt to split the entire word on spaces). Corresponding

-

4011

code exists in dequote_escapes. Even if we don't end up splitting on

-

4012

spaces, quoting spaces is not a problem. This should never be called on

-

4013

a string that is quoted with single or double quotes or part of a here

-

4014

document (effectively double-quoted). */

-

4015

char *

-

4016

quote_escapes (string)

-

4017

const char *string;

-

4018

{

-

4019

const char *s, *send;

-

4020

char *t, *result;

-

4021

size_t slen;

-

4022

int quote_spaces, skip_ctlesc, skip_ctlnul;

-

4023

DECLARE_MBSTATE;

-

4024

-

4025

slen = strlen (string);

-

4026

send = string + slen;

-

4027

-

4028

quote_spaces = (ifs_value && *ifs_value == 0);

ifs_value	Description
TRUE	evaluated 62557889 times by 1 test Evaluated by: Self test
FALSE	never evaluated

*ifs_value == 0	Description
TRUE	evaluated 5724 times by 1 test Evaluated by: Self test
FALSE	evaluated 62552165 times by 1 test Evaluated by: Self test

0-62557889

4029

-

4030

for (skip_ctlesc = skip_ctlnul = 0, s = ifs_value; s && *s; s++)

s	Description
TRUE	evaluated 128440759 times by 1 test Evaluated by: Self test
FALSE	never evaluated

*s	Description
TRUE	evaluated 65882870 times by 1 test Evaluated by: Self test
FALSE	evaluated 62557889 times by 1 test Evaluated by: Self test

0-128440759

4031

skip_ctlesc |= *s == CTLESC, skip_ctlnul |= *s == CTLNUL;

executed 65882870 times by 1 test: skip_ctlesc |= *s == '\001', skip_ctlnul |= *s == '\177';

Executed by:

Self test

65882870

4032

-

4033

t = result = (char *)xmalloc ((slen * 2) + 1);

-

4034

s = string;

-

4035

-

4036

while (*s)

*s	Description
TRUE	evaluated 221002151 times by 1 test Evaluated by: Self test
FALSE	evaluated 62557889 times by 1 test Evaluated by: Self test

62557889-221002151

4037

{

-

4038

if ((skip_ctlesc == 0 && *s == CTLESC) || (skip_ctlnul == 0 && *s == CTLNUL) || (quote_spaces && *s == ' '))

skip_ctlesc == 0	Description
TRUE	evaluated 221000859 times by 1 test Evaluated by: Self test
FALSE	evaluated 1292 times by 1 test Evaluated by: Self test

*s == '\001'	Description
TRUE	evaluated 4414 times by 1 test Evaluated by: Self test
FALSE	evaluated 220996445 times by 1 test Evaluated by: Self test

skip_ctlnul == 0	Description
TRUE	evaluated 220997557 times by 1 test Evaluated by: Self test
FALSE	evaluated 180 times by 1 test Evaluated by: Self test

*s == '\177'	Description
TRUE	evaluated 3908 times by 1 test Evaluated by: Self test
FALSE	evaluated 220993649 times by 1 test Evaluated by: Self test

quote_spaces	Description
TRUE	evaluated 4250 times by 1 test Evaluated by: Self test
FALSE	evaluated 220989579 times by 1 test Evaluated by: Self test

*s == ' '	Description
TRUE	evaluated 286 times by 1 test Evaluated by: Self test
FALSE	evaluated 3964 times by 1 test Evaluated by: Self test

180-221000859

4039

*t++ = CTLESC;

executed 8608 times by 1 test: *t++ = '\001';

Executed by:

Self test

8608

4040

COPY_CHAR_P (t, s, send);

executed 220571463 times by 1 test: mblength = 1;

Executed by:

Self test

executed 17557 times by 1 test: mblength = 1;

Executed by:

Self test

executed 156 times by 1 test: end of block

Executed by:

Self test

executed 8 times by 1 test: end of block

Executed by:

Self test

executed 220589168 times by 1 test: mblength = (mblength < 1) ? 1 : mblength;

Executed by:

Self test

executed 220589363 times by 1 test: *(t)++ = *(s)++;

Executed by:

Self test

executed 220589176 times by 1 test: end of block

Executed by:

Self test

executed 412975 times by 1 test: *(t)++ = *(s)++;

Executed by:

Self test

locale_mb_cur_max > 1	Description
TRUE	evaluated 220589176 times by 1 test Evaluated by: Self test
FALSE	evaluated 412975 times by 1 test Evaluated by: Self test

_k	Description
TRUE	evaluated 220571463 times by 1 test Evaluated by: Self test
FALSE	evaluated 17713 times by 1 test Evaluated by: Self test

_k < mblength	Description
TRUE	evaluated 220589363 times by 1 test Evaluated by: Self test
FALSE	evaluated 220589176 times by 1 test Evaluated by: Self test

(mblength < 1)	Description
TRUE	never evaluated
FALSE	evaluated 220589168 times by 1 test Evaluated by: Self test

locale_utf8locale	Description
TRUE	evaluated 17713 times by 1 test Evaluated by: Self test
FALSE	never evaluated

((*(s) & 0x80) == 0)	Description
TRUE	evaluated 17557 times by 1 test Evaluated by: Self test
FALSE	evaluated 156 times by 1 test Evaluated by: Self test

mblength == (size_t)-2	Description
TRUE	never evaluated
FALSE	evaluated 220589176 times by 1 test Evaluated by: Self test

mblength == (size_t)-1	Description
TRUE	evaluated 8 times by 1 test Evaluated by: Self test
FALSE	evaluated 220589168 times by 1 test Evaluated by: Self test

0-220589363

4041

}

executed 221002151 times by 1 test: end of block

Executed by:

Self test

221002151

4042

*t = '\0';

-

4043

-

4044

return (result);

executed 62557889 times by 1 test: return (result);

Executed by:

Self test

62557889

4045

}

-

4046

-

4047

static WORD_LIST *

-

4048

list_quote_escapes (list)

-

4049

WORD_LIST *list;

-

4050

{

-

4051

register WORD_LIST *w;

-

4052

char *t;

-

4053

-

4054

for (w = list; w; w = w->next)

w	Description
TRUE	evaluated 4753 times by 1 test Evaluated by: Self test
FALSE	evaluated 1270 times by 1 test Evaluated by: Self test

1270-4753

4055

{

-

4056

t = w->word->word;

-

4057

w->word->word = quote_escapes (t);

-

4058

free (t);

-

4059

}

executed 4753 times by 1 test: end of block

Executed by:

Self test

4753

4060

return list;

executed 1270 times by 1 test: return list;

Executed by:

Self test

1270

4061

}

-

4062

-

4063

/* Inverse of quote_escapes; remove CTLESC protecting CTLESC or CTLNUL.

-

4064

-

4065

The parser passes us CTLESC as CTLESC CTLESC and CTLNUL as CTLESC CTLNUL.

-

4066

This is necessary to make unquoted CTLESC and CTLNUL characters in the

-

4067

data stream pass through properly.

-

4068

-

4069

We need to remove doubled CTLESC characters inside quoted strings before

-

4070

quoting the entire string, so we do not double the number of CTLESC

-

4071

characters.

-

4072

-

4073

Also used by parts of the pattern substitution code. */

-

4074

char *

-

4075

dequote_escapes (string)

-

4076

const char *string;

-

4077

{

-

4078

const char *s, *send;

-

4079

char *t, *result;

-

4080

size_t slen;

-

4081

int quote_spaces;

-

4082

DECLARE_MBSTATE;

-

4083

-

4084

if (string == 0)

string == 0	Description
TRUE	never evaluated
FALSE	evaluated 12109353 times by 1 test Evaluated by: Self test

0-12109353

4085

return (char *)0;

never executed: return (char *)0;

0

4086

-

4087

slen = strlen (string);

-

4088

send = string + slen;

-

4089

-

4090

t = result = (char *)xmalloc (slen + 1);

-

4091

-

4092

if (strchr (string, CTLESC) == 0)

(__extension__...\001' ))) == 0	Description
TRUE	evaluated 12108850 times by 1 test Evaluated by: Self test
FALSE	evaluated 503 times by 1 test Evaluated by: Self test

__builtin_cons...t_p ( '\001' )	Description
TRUE	evaluated 12109353 times by 1 test Evaluated by: Self test
FALSE	never evaluated

!__builtin_con...t_p ( string )	Description
TRUE	evaluated 12109353 times by 1 test Evaluated by: Self test
FALSE	never evaluated

( '\001' ) == '\0'	Description
TRUE	never evaluated
FALSE	evaluated 12109353 times by 1 test Evaluated by: Self test

0-12109353

4093

return (strcpy (result, string));

executed 12108850 times by 1 test: return (strcpy (result, string));

Executed by:

Self test

12108850

4094

-

4095

quote_spaces = (ifs_value && *ifs_value == 0);

ifs_value	Description
TRUE	evaluated 503 times by 1 test Evaluated by: Self test
FALSE	never evaluated

*ifs_value == 0	Description
TRUE	evaluated 1 time by 1 test Evaluated by: Self test
FALSE	evaluated 502 times by 1 test Evaluated by: Self test

0-503

4096

-

4097

s = string;

-

4098

while (*s)

*s	Description
TRUE	evaluated 1596 times by 1 test Evaluated by: Self test
FALSE	evaluated 503 times by 1 test Evaluated by: Self test

503-1596

4099

{

-

4100

if (*s == CTLESC && (s[1] == CTLESC || s[1] == CTLNUL || (quote_spaces && s[1] == ' ')))

*s == '\001'	Description
TRUE	evaluated 674 times by 1 test Evaluated by: Self test
FALSE	evaluated 922 times by 1 test Evaluated by: Self test

s[1] == '\001'	Description
TRUE	evaluated 331 times by 1 test Evaluated by: Self test
FALSE	evaluated 343 times by 1 test Evaluated by: Self test

s[1] == '\177'	Description
TRUE	evaluated 288 times by 1 test Evaluated by: Self test
FALSE	evaluated 55 times by 1 test Evaluated by: Self test

quote_spaces	Description
TRUE	evaluated 1 time by 1 test Evaluated by: Self test
FALSE	evaluated 54 times by 1 test Evaluated by: Self test

s[1] == ' '	Description
TRUE	evaluated 1 time by 1 test Evaluated by: Self test
FALSE	never evaluated

0-922

4101

{

-

4102

s++;

-

4103

if (*s == '\0')

*s == '\0'	Description
TRUE	never evaluated
FALSE	evaluated 620 times by 1 test Evaluated by: Self test

0-620

4104

break;

never executed: break;

0

4105

}

executed 620 times by 1 test: end of block

Executed by:

Self test

620

4106

COPY_CHAR_P (t, s, send);

executed 913 times by 1 test: mblength = 1;

Executed by:

Self test

executed 683 times by 1 test: mblength = 1;

Executed by:

Self test

never executed: end of block

executed 1596 times by 1 test: mblength = (mblength < 1) ? 1 : mblength;

Executed by:

Self test

executed 1596 times by 1 test: *(t)++ = *(s)++;

Executed by:

Self test

executed 1596 times by 1 test: end of block

Executed by:

Self test

never executed: *(t)++ = *(s)++;

locale_mb_cur_max > 1	Description
TRUE	evaluated 1596 times by 1 test Evaluated by: Self test
FALSE	never evaluated

_k	Description
TRUE	evaluated 913 times by 1 test Evaluated by: Self test
FALSE	evaluated 683 times by 1 test Evaluated by: Self test

_k < mblength	Description
TRUE	evaluated 1596 times by 1 test Evaluated by: Self test
FALSE	evaluated 1596 times by 1 test Evaluated by: Self test

(mblength < 1)	Description
TRUE	never evaluated
FALSE	evaluated 1596 times by 1 test Evaluated by: Self test

locale_utf8locale	Description
TRUE	evaluated 683 times by 1 test Evaluated by: Self test
FALSE	never evaluated

((*(s) & 0x80) == 0)	Description
TRUE	evaluated 683 times by 1 test Evaluated by: Self test
FALSE	never evaluated

mblength == (size_t)-2	Description
TRUE	never evaluated
FALSE	evaluated 1596 times by 1 test Evaluated by: Self test

mblength == (size_t)-1	Description
TRUE	never evaluated
FALSE	evaluated 1596 times by 1 test Evaluated by: Self test

0-1596

4107

}

executed 1596 times by 1 test: end of block

Executed by:

Self test

1596

4108

*t = '\0';

-

4109

-

4110

return result;

executed 503 times by 1 test: return result;

Executed by:

Self test

503

4111

}

-

4112

-

4113

#if defined (INCLUDE_UNUSED)

-

4114

static WORD_LIST *

-

4115

list_dequote_escapes (list)

-

4116

WORD_LIST *list;

-

4117

{

-

4118

register WORD_LIST *w;

-

4119

char *t;

-

4120

-

4121

for (w = list; w; w = w->next)

-

4122

{

-

4123

t = w->word->word;

-

4124

w->word->word = dequote_escapes (t);

-

4125

free (t);

-

4126

}

-

4127

return list;

-

4128

}

-

4129

#endif

-

4130

-

4131

/* Return a new string with the quoted representation of character C.

-

4132

This turns "" into QUOTED_NULL, so the W_HASQUOTEDNULL flag needs to be

-

4133

set in any resultant WORD_DESC where this value is the word. */

-

4134

static char *

-

4135

make_quoted_char (c)

-

4136

int c;

-

4137

{

-

4138

char *temp;

-

4139

-

4140

temp = (char *)xmalloc (3);

-

4141

if (c == 0)

c == 0	Description
TRUE	evaluated 4090250 times by 1 test Evaluated by: Self test
FALSE	never evaluated

0-4090250

4142

{

-

4143

temp[0] = CTLNUL;

-

4144

temp[1] = '\0';

-

4145

}

executed 4090250 times by 1 test: end of block

Executed by:

Self test

4090250

4146

else

-

4147

{

-

4148

temp[0] = CTLESC;

-

4149

temp[1] = c;

-

4150

temp[2] = '\0';

-

4151

}

never executed: end of block

0

4152

return (temp);

executed 4090250 times by 1 test: return (temp);

Executed by:

Self test

4090250

4153

}

-

4154

-

4155

/* Quote STRING, returning a new string. This turns "" into QUOTED_NULL, so

-

4156

the W_HASQUOTEDNULL flag needs to be set in any resultant WORD_DESC where

-

4157

this value is the word. */

-

4158

char *

-

4159

quote_string (string)

-

4160

char *string;

-

4161

{

-

4162

register char *t;

-

4163

size_t slen;

-

4164

char *result, *send;

-

4165

-

4166

if (*string == 0)

*string == 0	Description
TRUE	evaluated 714 times by 1 test Evaluated by: Self test
FALSE	evaluated 70765794 times by 1 test Evaluated by: Self test

714-70765794

4167

{

-

4168

result = (char *)xmalloc (2);

-

4169

result[0] = CTLNUL;

-

4170

result[1] = '\0';

-

4171

}

executed 714 times by 1 test: end of block

Executed by:

Self test

714

4172

else

-

4173

{

-

4174

DECLARE_MBSTATE;

-

4175

-

4176

slen = strlen (string);

-

4177

send = string + slen;

-

4178

-

4179

result = (char *)xmalloc ((slen * 2) + 1);

-

4180

-

4181

for (t = result; string < send; )

string < send	Description
TRUE	evaluated 387339420 times by 1 test Evaluated by: Self test
FALSE	evaluated 70765794 times by 1 test Evaluated by: Self test

70765794-387339420

4182

{

-

4183

*t++ = CTLESC;

-

4184

COPY_CHAR_P (t, string, send);

executed 386874408 times by 1 test: mblength = 1;

Executed by:

Self test

executed 182047 times by 1 test: mblength = 1;

Executed by:

Self test

executed 10217 times by 1 test: end of block

Executed by:

Self test

executed 1297 times by 1 test: end of block

Executed by:

Self test

executed 387065375 times by 1 test: mblength = (mblength < 1) ? 1 : mblength;

Executed by:

Self test

executed 387076390 times by 1 test: *(t)++ = *(string)++;

Executed by:

Self test

executed 387066672 times by 1 test: end of block

Executed by:

Self test

executed 272748 times by 1 test: *(t)++ = *(string)++;

Executed by:

Self test

locale_mb_cur_max > 1	Description
TRUE	evaluated 387066672 times by 1 test Evaluated by: Self test
FALSE	evaluated 272748 times by 1 test Evaluated by: Self test

_k	Description
TRUE	evaluated 386874408 times by 1 test Evaluated by: Self test
FALSE	evaluated 192264 times by 1 test Evaluated by: Self test

_k < mblength	Description
TRUE	evaluated 387076390 times by 1 test Evaluated by: Self test
FALSE	evaluated 387066672 times by 1 test Evaluated by: Self test

(mblength < 1)	Description
TRUE	never evaluated
FALSE	evaluated 387065375 times by 1 test Evaluated by: Self test

locale_utf8locale	Description
TRUE	evaluated 192264 times by 1 test Evaluated by: Self test
FALSE	never evaluated

((*(string) & 0x80) == 0)	Description
TRUE	evaluated 182047 times by 1 test Evaluated by: Self test
FALSE	evaluated 10217 times by 1 test Evaluated by: Self test

mblength == (size_t)-2	Description
TRUE	evaluated 591 times by 1 test Evaluated by: Self test
FALSE	evaluated 387066081 times by 1 test Evaluated by: Self test

mblength == (size_t)-1	Description
TRUE	evaluated 706 times by 1 test Evaluated by: Self test
FALSE	evaluated 387065375 times by 1 test Evaluated by: Self test

0-387076390

4185

}

executed 387339420 times by 1 test: end of block

Executed by:

Self test

387339420

4186

*t = '\0';

-

4187

}

executed 70765794 times by 1 test: end of block

Executed by:

Self test

70765794

4188

return (result);

executed 70766508 times by 1 test: return (result);

Executed by:

Self test

70766508

4189

}

-

4190

-

4191

/* De-quote quoted characters in STRING. */

-

4192

char *

-

4193

dequote_string (string)

-

4194

char *string;

-

4195

{

-

4196

register char *s, *t;

-

4197

size_t slen;

-

4198

char *result, *send;

-

4199

DECLARE_MBSTATE;

-

4200

-

4201

#if defined (DEBUG)

-

4202

if (string[0] == CTLESC && string[1] == 0)

string[0] == '\001'	Description
TRUE	evaluated 48806861 times by 1 test Evaluated by: Self test
FALSE	evaluated 110194750 times by 1 test Evaluated by: Self test

string[1] == 0	Description
TRUE	evaluated 2 times by 1 test Evaluated by: Self test
FALSE	evaluated 48806859 times by 1 test Evaluated by: Self test

2-110194750

4203

internal_inform ("dequote_string: string with bare CTLESC");

executed 2 times by 1 test: internal_inform ("dequote_string: string with bare CTLESC");

Executed by:

Self test

2

4204

#endif

-

4205

-

4206

slen = STRLEN (string);

(string)[1]	Description
TRUE	evaluated 110736598 times by 1 test Evaluated by: Self test
FALSE	evaluated 47947940 times by 1 test Evaluated by: Self test

(string)[2]	Description
TRUE	evaluated 104663761 times by 1 test Evaluated by: Self test
FALSE	evaluated 6072837 times by 1 test Evaluated by: Self test

(string)	Description
TRUE	evaluated 159001611 times by 1 test Evaluated by: Self test
FALSE	never evaluated

(string)[0]	Description
TRUE	evaluated 158684538 times by 1 test Evaluated by: Self test
FALSE	evaluated 317073 times by 1 test Evaluated by: Self test

0-159001611

4207

-

4208

t = result = (char *)xmalloc (slen + 1);

-

4209

-

4210

if (QUOTED_NULL (string))

(string)[0] == '\177'	Description
TRUE	evaluated 4089997 times by 1 test Evaluated by: Self test
FALSE	evaluated 154911614 times by 1 test Evaluated by: Self test

(string)[1] == '\0'	Description
TRUE	evaluated 4089997 times by 1 test Evaluated by: Self test
FALSE	never evaluated

0-154911614

4211

{

-

4212

result[0] = '\0';

-

4213

return (result);

executed 4089997 times by 1 test: return (result);

Executed by:

Self test

4089997

4214

}

-

4215

-

4216

/* A string consisting of only a single CTLESC should pass through unchanged */

-

4217

if (string[0] == CTLESC && string[1] == 0)

string[0] == '\001'	Description
TRUE	evaluated 48806861 times by 1 test Evaluated by: Self test
FALSE	evaluated 106104753 times by 1 test Evaluated by: Self test

string[1] == 0	Description
TRUE	evaluated 2 times by 1 test Evaluated by: Self test
FALSE	evaluated 48806859 times by 1 test Evaluated by: Self test

2-106104753

4218

{

-

4219

result[0] = CTLESC;

-

4220

result[1] = '\0';

-

4221

return (result);

executed 2 times by 1 test: return (result);

Executed by:

Self test

2

4222

}

-

4223

-

4224

/* If no character in the string can be quoted, don't bother examining

-

4225

each character. Just return a copy of the string passed to us. */

-

4226

if (strchr (string, CTLESC) == NULL)

(__extension__...== ((void *)0)	Description
TRUE	evaluated 106102661 times by 1 test Evaluated by: Self test
FALSE	evaluated 48808951 times by 1 test Evaluated by: Self test

__builtin_cons...t_p ( '\001' )	Description
TRUE	evaluated 154911612 times by 1 test Evaluated by: Self test
FALSE	never evaluated

!__builtin_con...t_p ( string )	Description
TRUE	evaluated 154911612 times by 1 test Evaluated by: Self test
FALSE	never evaluated

( '\001' ) == '\0'	Description
TRUE	never evaluated
FALSE	evaluated 154911612 times by 1 test Evaluated by: Self test

0-154911612

4227

return (strcpy (result, string));

executed 106102661 times by 1 test: return (strcpy (result, string));

Executed by:

Self test

106102661

4228

-

4229

send = string + slen;

-

4230

s = string;

-

4231

while (*s)

*s	Description
TRUE	evaluated 347228404 times by 1 test Evaluated by: Self test
FALSE	evaluated 48808951 times by 1 test Evaluated by: Self test

48808951-347228404

4232

{

-

4233

if (*s == CTLESC)

*s == '\001'	Description
TRUE	evaluated 343656626 times by 1 test Evaluated by: Self test
FALSE	evaluated 3571778 times by 1 test Evaluated by: Self test

3571778-343656626

4234

{

-

4235

s++;

-

4236

if (*s == '\0')

*s == '\0'	Description
TRUE	never evaluated
FALSE	evaluated 343656626 times by 1 test Evaluated by: Self test

0-343656626

4237

break;

never executed: break;

0

4238

}

executed 343656626 times by 1 test: end of block

Executed by:

Self test

343656626

4239

COPY_CHAR_P (t, s, send);

executed 346436594 times by 1 test: mblength = 1;

Executed by:

Self test

executed 200505 times by 1 test: mblength = 1;

Executed by:

Self test

executed 10217 times by 1 test: end of block

Executed by:

Self test

executed 1299 times by 1 test: end of block

Executed by:

Self test

executed 346646017 times by 1 test: mblength = (mblength < 1) ? 1 : mblength;

Executed by:

Self test

executed 346657032 times by 1 test: *(t)++ = *(s)++;

Executed by:

Self test

executed 346647316 times by 1 test: end of block

Executed by:

Self test

executed 581088 times by 1 test: *(t)++ = *(s)++;

Executed by:

Self test

locale_mb_cur_max > 1	Description
TRUE	evaluated 346647316 times by 1 test Evaluated by: Self test
FALSE	evaluated 581088 times by 1 test Evaluated by: Self test

_k	Description
TRUE	evaluated 346436594 times by 1 test Evaluated by: Self test
FALSE	evaluated 210722 times by 1 test Evaluated by: Self test

_k < mblength	Description
TRUE	evaluated 346657032 times by 1 test Evaluated by: Self test
FALSE	evaluated 346647316 times by 1 test Evaluated by: Self test

(mblength < 1)	Description
TRUE	never evaluated
FALSE	evaluated 346646017 times by 1 test Evaluated by: Self test

locale_utf8locale	Description
TRUE	evaluated 210722 times by 1 test Evaluated by: Self test
FALSE	never evaluated

((*(s) & 0x80) == 0)	Description
TRUE	evaluated 200505 times by 1 test Evaluated by: Self test
FALSE	evaluated 10217 times by 1 test Evaluated by: Self test

mblength == (size_t)-2	Description
TRUE	evaluated 581 times by 1 test Evaluated by: Self test
FALSE	evaluated 346646735 times by 1 test Evaluated by: Self test

mblength == (size_t)-1	Description
TRUE	evaluated 718 times by 1 test Evaluated by: Self test
FALSE	evaluated 346646017 times by 1 test Evaluated by: Self test

0-346657032

4240

}

executed 347228404 times by 1 test: end of block

Executed by:

Self test

347228404

4241

-

4242

*t = '\0';

-

4243

return (result);

executed 48808951 times by 1 test: return (result);

Executed by:

Self test

48808951

4244

}

-

4245

-

4246

/* Quote the entire WORD_LIST list. */

-

4247

static WORD_LIST *

-

4248

quote_list (list)

-

4249

WORD_LIST *list;

-

4250

{

-

4251

register WORD_LIST *w;

-

4252

char *t;

-

4253

-

4254

for (w = list; w; w = w->next)

w	Description
TRUE	evaluated 10768 times by 1 test Evaluated by: Self test
FALSE	evaluated 7128 times by 1 test Evaluated by: Self test

7128-10768

4255

{

-

4256

t = w->word->word;

-

4257

w->word->word = quote_string (t);

-

4258

if (*t == 0)

*t == 0	Description
TRUE	evaluated 372 times by 1 test Evaluated by: Self test
FALSE	evaluated 10396 times by 1 test Evaluated by: Self test

372-10396

4259

w->word->flags |= W_HASQUOTEDNULL; /* XXX - turn on W_HASQUOTEDNULL here? */

executed 372 times by 1 test: w->word->flags |= 0x040000;

Executed by:

Self test

372

4260

w->word->flags |= W_QUOTED;

-

4261

free (t);

-

4262

}

executed 10768 times by 1 test: end of block

Executed by:

Self test

10768

4263

return list;

executed 7128 times by 1 test: return list;

Executed by:

Self test

7128

4264

}

-

4265

-

4266

/* De-quote quoted characters in each word in LIST. */

-

4267

WORD_LIST *

-

4268

dequote_list (list)

-

4269

WORD_LIST *list;

-

4270

{

-

4271

register char *s;

-

4272

register WORD_LIST *tlist;

-

4273

-

4274

for (tlist = list; tlist; tlist = tlist->next)

tlist	Description
TRUE	evaluated 90034639 times by 1 test Evaluated by: Self test
FALSE	evaluated 89971816 times by 1 test Evaluated by: Self test

89971816-90034639

4275

{

-

4276

s = dequote_string (tlist->word->word);

-

4277

if (QUOTED_NULL (tlist->word->word))

(tlist->word->...)[0] == '\177'	Description
TRUE	evaluated 258 times by 1 test Evaluated by: Self test
FALSE	evaluated 90034381 times by 1 test Evaluated by: Self test

(tlist->word->word)[1] == '\0'	Description
TRUE	evaluated 258 times by 1 test Evaluated by: Self test
FALSE	never evaluated

0-90034381

4278

tlist->word->flags &= ~W_HASQUOTEDNULL;

executed 258 times by 1 test: tlist->word->flags &= ~0x040000;

Executed by:

Self test

258

4279

free (tlist->word->word);

-

4280

tlist->word->word = s;

-

4281

}

executed 90034639 times by 1 test: end of block

Executed by:

Self test

90034639

4282

return list;

executed 89971816 times by 1 test: return list;

Executed by:

Self test

89971816

4283

}

-

4284

-

4285

/* Remove CTLESC protecting a CTLESC or CTLNUL in place. Return the passed

-

4286

string. */

-

4287

char *

-

4288

remove_quoted_escapes (string)

-

4289

char *string;

-

4290

{

-

4291

char *t;

-

4292

-

4293

if (string)

string	Description
TRUE	evaluated 9793033 times by 1 test Evaluated by: Self test
FALSE	never evaluated

0-9793033

4294

{

-

4295

t = dequote_escapes (string);

-

4296

strcpy (string, t);

-

4297

free (t);

-

4298

}

executed 9793033 times by 1 test: end of block

Executed by:

Self test

9793033

4299

-

4300

return (string);

executed 9793033 times by 1 test: return (string);

Executed by:

Self test

9793033

4301

}

-

4302

-

4303

/* Remove quoted $IFS characters from STRING. Quoted IFS characters are

-

4304

added to protect them from word splitting, but we need to remove them

-

4305

if no word splitting takes place. This returns newly-allocated memory,

-

4306

so callers can use it to replace savestring(). */

-

4307

char *

-

4308

remove_quoted_ifs (string)

-

4309

char *string;

-

4310

{

-

4311

register size_t slen;

-

4312

register int i, j;

-

4313

char *ret, *send;

-

4314

DECLARE_MBSTATE;

-

4315

-

4316

slen = strlen (string);

-

4317

send = string + slen;

-

4318

-

4319

i = j = 0;

-

4320

ret = (char *)xmalloc (slen + 1);

-

4321

-

4322

while (i < slen)

i < slen	Description
TRUE	evaluated 68 times by 1 test Evaluated by: Self test
FALSE	evaluated 15 times by 1 test Evaluated by: Self test

15-68

4323

{

-

4324

if (string[i] == CTLESC)

string[i] == '\001'	Description
TRUE	evaluated 22 times by 1 test Evaluated by: Self test
FALSE	evaluated 46 times by 1 test Evaluated by: Self test

22-46

4325

{

-

4326

i++;

-

4327

if (string[i] == 0 || isifs (string[i]) == 0)

string[i] == 0	Description
TRUE	never evaluated
FALSE	evaluated 22 times by 1 test Evaluated by: Self test

(ifs_cmap[(uns...])] != 0) == 0	Description
TRUE	never evaluated
FALSE	evaluated 22 times by 1 test Evaluated by: Self test

0-22

4328

ret[j++] = CTLESC;

never executed: ret[j++] = '\001';

0

4329

if (i == slen)

i == slen	Description
TRUE	never evaluated
FALSE	evaluated 22 times by 1 test Evaluated by: Self test

0-22

4330

break;

never executed: break;

0

4331

}

executed 22 times by 1 test: end of block

Executed by:

Self test

22

4332

-

4333

COPY_CHAR_I (ret, j, string, send, i);

executed 67 times by 1 test: mblength = 1;

Executed by:

Self test

executed 1 time by 1 test: end of block

Executed by:

Self test

never executed: end of block

executed 68 times by 1 test: mblength = (mblength < 1) ? 1 : mblength;

Executed by:

Self test

executed 68 times by 1 test: ret[j++] = string[i++];

Executed by:

Self test

executed 68 times by 1 test: end of block

Executed by:

Self test

never executed: ret[j++] = string[i++];

locale_mb_cur_max > 1	Description
TRUE	evaluated 68 times by 1 test Evaluated by: Self test
FALSE	never evaluated

_k	Description
TRUE	evaluated 67 times by 1 test Evaluated by: Self test
FALSE	evaluated 1 time by 1 test Evaluated by: Self test

_k < mblength	Description
TRUE	evaluated 68 times by 1 test Evaluated by: Self test
FALSE	evaluated 68 times by 1 test Evaluated by: Self test

(mblength < 1)	Description
TRUE	never evaluated
FALSE	evaluated 68 times by 1 test Evaluated by: Self test

mblength == (size_t)-2	Description
TRUE	never evaluated
FALSE	evaluated 68 times by 1 test Evaluated by: Self test

mblength == (size_t)-1	Description
TRUE	never evaluated
FALSE	evaluated 68 times by 1 test Evaluated by: Self test

0-68

4334

}

executed 68 times by 1 test: end of block

Executed by:

Self test

68

4335

ret[j] = '\0';

-

4336

-

4337

return (ret);

executed 15 times by 1 test: return (ret);

Executed by:

Self test

15

4338

}

-

4339

-

4340

char *

-

4341

remove_quoted_nulls (string)

-

4342

char *string;

-

4343

{

-

4344

register size_t slen;

-

4345

register int i, j, prev_i;

-

4346

DECLARE_MBSTATE;

-

4347

-

4348

if (strchr (string, CTLNUL) == 0) /* XXX */

(__extension__...\177' ))) == 0	Description
TRUE	evaluated 94544531 times by 1 test Evaluated by: Self test
FALSE	evaluated 334449 times by 1 test Evaluated by: Self test

__builtin_cons...t_p ( '\177' )	Description
TRUE	evaluated 94878980 times by 1 test Evaluated by: Self test
FALSE	never evaluated

!__builtin_con...t_p ( string )	Description
TRUE	evaluated 94878980 times by 1 test Evaluated by: Self test
FALSE	never evaluated

( '\177' ) == '\0'	Description
TRUE	never evaluated
FALSE	evaluated 94878980 times by 1 test Evaluated by: Self test

0-94878980

4349

return string; /* XXX */

executed 94544531 times by 1 test: return string;

Executed by:

Self test

94544531

4350

-

4351

slen = strlen (string);

-

4352

i = j = 0;

-

4353

-

4354

while (i < slen)

i < slen	Description
TRUE	evaluated 385693 times by 1 test Evaluated by: Self test
FALSE	evaluated 334449 times by 1 test Evaluated by: Self test

334449-385693

4355

{

-

4356

if (string[i] == CTLESC)

string[i] == '\001'	Description
TRUE	evaluated 56296 times by 1 test Evaluated by: Self test
FALSE	evaluated 329397 times by 1 test Evaluated by: Self test

56296-329397

4357

{

-

4358

/* Old code had j++, but we cannot assume that i == j at this

-

4359

point -- what if a CTLNUL has already been removed from the

-

4360

string? We don't want to drop the CTLESC or recopy characters

-

4361

that we've already copied down. */

-

4362

i++;

-

4363

string[j++] = CTLESC;

-

4364

if (i == slen)

i == slen	Description
TRUE	never evaluated
FALSE	evaluated 56296 times by 1 test Evaluated by: Self test

0-56296

4365

break;

never executed: break;

0

4366

}

executed 56296 times by 1 test: end of block

Executed by:

Self test

56296

4367

else if (string[i] == CTLNUL)

string[i] == '\177'	Description
TRUE	evaluated 317417 times by 1 test Evaluated by: Self test
FALSE	evaluated 11980 times by 1 test Evaluated by: Self test

11980-317417

4368

{

-

4369

i++;

-

4370

continue;

executed 317417 times by 1 test: continue;

Executed by:

Self test

317417

4371

}

-

4372

-

4373

prev_i = i;

-

4374

ADVANCE_CHAR (string, slen, i); /* COPY_CHAR_I? */

executed 2733 times by 1 test: mblength = 1;

Executed by:

Self test

executed 65543 times by 1 test: mblength = 1;

Executed by:

Self test

never executed: end of block

never executed: (i)++;

executed 68276 times by 1 test: (i) += mblength;

Executed by:

Self test

never executed: (i)++;

locale_mb_cur_max > 1	Description
TRUE	evaluated 68276 times by 1 test Evaluated by: Self test
FALSE	never evaluated

_f	Description
TRUE	evaluated 2733 times by 1 test Evaluated by: Self test
FALSE	evaluated 65543 times by 1 test Evaluated by: Self test

mblength == 0	Description
TRUE	never evaluated
FALSE	evaluated 68276 times by 1 test Evaluated by: Self test

locale_utf8locale	Description
TRUE	evaluated 65543 times by 1 test Evaluated by: Self test
FALSE	never evaluated

(((string)[i] & 0x80) == 0)	Description
TRUE	evaluated 65543 times by 1 test Evaluated by: Self test
FALSE	never evaluated

mblength == (size_t)-2	Description
TRUE	never evaluated
FALSE	evaluated 68276 times by 1 test Evaluated by: Self test

mblength == (size_t)-1	Description
TRUE	never evaluated
FALSE	evaluated 68276 times by 1 test Evaluated by: Self test

0-68276

4375

if (j < prev_i)

j < prev_i	Description
TRUE	evaluated 644 times by 1 test Evaluated by: Self test
FALSE	evaluated 67632 times by 1 test Evaluated by: Self test

644-67632

4376

{

-

4377

do string[j++] = string[prev_i++]; while (prev_i < i);

executed 644 times by 1 test: string[j++] = string[prev_i++];

Executed by:

Self test

prev_i < i	Description
TRUE	never evaluated
FALSE	evaluated 644 times by 1 test Evaluated by: Self test

0-644

4378

}

executed 644 times by 1 test: end of block

Executed by:

Self test

644

4379

else

-

4380

j = i;

executed 67632 times by 1 test: j = i;

Executed by:

Self test

67632

4381

}

-

4382

string[j] = '\0';

-

4383

-

4384

return (string);

executed 334449 times by 1 test: return (string);

Executed by:

Self test

334449

4385

}

-

4386

-

4387

/* Perform quoted null character removal on each element of LIST.

-

4388

This modifies LIST. */

-

4389

void

-

4390

word_list_remove_quoted_nulls (list)

-

4391

WORD_LIST *list;

-

4392

{

-

4393

register WORD_LIST *t;

-

4394

-

4395

for (t = list; t; t = t->next)

t	Description
TRUE	evaluated 60359365 times by 1 test Evaluated by: Self test
FALSE	evaluated 60359261 times by 1 test Evaluated by: Self test

60359261-60359365

4396

{

-

4397

remove_quoted_nulls (t->word->word);

-

4398

t->word->flags &= ~W_HASQUOTEDNULL;

-

4399

}

executed 60359365 times by 1 test: end of block

Executed by:

Self test

60359365

4400

}

executed 60359261 times by 1 test: end of block

Executed by:

Self test

60359261

4401

-

4402

/* **************************************************************** */

-

4403

/* */

-

4404

/* Functions for Matching and Removing Patterns */

-

4405

/* */

-

4406

/* **************************************************************** */

-

4407

-

4408

#if defined (HANDLE_MULTIBYTE)

-

4409

# ifdef INCLUDE_UNUSED

-

4410

static unsigned char *

-

4411

mb_getcharlens (string, len)

-

4412

char *string;

-

4413

int len;

-

4414

{

-

4415

int i, offset, last;

-

4416

unsigned char *ret;

-

4417

char *p;

-

4418

DECLARE_MBSTATE;

-

4419

-

4420

i = offset = 0;

-

4421

last = 0;

-

4422

ret = (unsigned char *)xmalloc (len);

-

4423

memset (ret, 0, len);

-

4424

while (string[last])

-

4425

{

-

4426

ADVANCE_CHAR (string, len, offset);

-

4427

ret[last] = offset - last;

-

4428

last = offset;

-

4429

}

-

4430

return ret;

-

4431

}

-

4432

# endif

-

4433

#endif

-

4434

-

4435

/* Remove the portion of PARAM matched by PATTERN according to OP, where OP

-

4436

can have one of 4 values:

-

4437

RP_LONG_LEFT remove longest matching portion at start of PARAM

-

4438

RP_SHORT_LEFT remove shortest matching portion at start of PARAM

-

4439

RP_LONG_RIGHT remove longest matching portion at end of PARAM

-

4440

RP_SHORT_RIGHT remove shortest matching portion at end of PARAM

-

4441

*/

-

4442

-

4443

#define RP_LONG_LEFT 1

-

4444

#define RP_SHORT_LEFT 2

-

4445

#define RP_LONG_RIGHT 3

-

4446

#define RP_SHORT_RIGHT 4

-

4447

-

4448

/* Returns its first argument if nothing matched; new memory otherwise */

-

4449

static char *

-

4450

remove_upattern (param, pattern, op)

-

4451

char *param, *pattern;

-

4452

int op;

-

4453

{

-

4454

register size_t len;

-

4455

register char *end;

-

4456

register char *p, *ret, c;

-

4457

-

4458

len = STRLEN (param);

(param)[1]	Description
TRUE	evaluated 28 times by 1 test Evaluated by: Self test
FALSE	never evaluated

(param)[2]	Description
TRUE	evaluated 28 times by 1 test Evaluated by: Self test
FALSE	never evaluated

(param)	Description
TRUE	evaluated 28 times by 1 test Evaluated by: Self test
FALSE	never evaluated

(param)[0]	Description
TRUE	evaluated 28 times by 1 test Evaluated by: Self test
FALSE	never evaluated

0-28

4459

end = param + len;

-

4460

-

4461

switch (op)

-

4462

{

-

4463

case RP_LONG_LEFT: /* remove longest match at start */

executed 14 times by 1 test: case 1:

Executed by:

Self test

14

4464

for (p = end; p >= param; p--)

p >= param	Description
TRUE	evaluated 82 times by 1 test Evaluated by: Self test
FALSE	never evaluated

0-82

4465

{

-

4466

c = *p; *p = '\0';

-

4467

if (strmatch (pattern, param, FNMATCH_EXTFLAG) != FNM_NOMATCH)

strmatch (patt... 5) : 0)) != 1	Description
TRUE	evaluated 14 times by 1 test Evaluated by: Self test
FALSE	evaluated 68 times by 1 test Evaluated by: Self test

14-68

4468

{

-

4469

*p = c;

-

4470

return (savestring (p));

executed 14 times by 1 test: return ((char *)strcpy (sh_xmalloc((1 + strlen (p)), "subst.c", 4470), (p)));

Executed by:

Self test

14

4471

}

-

4472

*p = c;

-

4473

-

4474

}

executed 68 times by 1 test: end of block

Executed by:

Self test

68

4475

break;

never executed: break;

0

4476

-

4477

case RP_SHORT_LEFT: /* remove shortest match at start */

executed 6 times by 1 test: case 2:

Executed by:

Self test

6

4478

for (p = param; p <= end; p++)

p <= end	Description
TRUE	evaluated 61 times by 1 test Evaluated by: Self test
FALSE	evaluated 4 times by 1 test Evaluated by: Self test

4-61

4479

{

-

4480

c = *p; *p = '\0';

-

4481

if (strmatch (pattern, param, FNMATCH_EXTFLAG) != FNM_NOMATCH)

strmatch (patt... 5) : 0)) != 1	Description
TRUE	evaluated 2 times by 1 test Evaluated by: Self test
FALSE	evaluated 59 times by 1 test Evaluated by: Self test

2-59

4482

{

-

4483

*p = c;

-

4484

return (savestring (p));

executed 2 times by 1 test: return ((char *)strcpy (sh_xmalloc((1 + strlen (p)), "subst.c", 4484), (p)));

Executed by:

Self test

2

4485

}

-

4486

*p = c;

-

4487

}

executed 59 times by 1 test: end of block

Executed by:

Self test

59

4488

break;

executed 4 times by 1 test: break;

Executed by:

Self test

4

4489

-

4490

case RP_LONG_RIGHT: /* remove longest match at end */

executed 3 times by 1 test: case 3:

Executed by:

Self test

3

4491

for (p = param; p <= end; p++)

p <= end	Description
TRUE	evaluated 28 times by 1 test Evaluated by: Self test
FALSE	never evaluated

0-28

4492

{

-

4493

if (strmatch (pattern, p, FNMATCH_EXTFLAG) != FNM_NOMATCH)

strmatch (patt... 5) : 0)) != 1	Description
TRUE	evaluated 3 times by 1 test Evaluated by: Self test
FALSE	evaluated 25 times by 1 test Evaluated by: Self test

3-25

4494

{

-

4495

c = *p; *p = '\0';

-

4496

ret = savestring (param);

-

4497

*p = c;

-

4498

return (ret);

executed 3 times by 1 test: return (ret);

Executed by:

Self test

3

4499

}

-

4500

}

executed 25 times by 1 test: end of block

Executed by:

Self test

25

4501

break;

never executed: break;

0

4502

-

4503

case RP_SHORT_RIGHT: /* remove shortest match at end */

executed 5 times by 1 test: case 4:

Executed by:

Self test

5

4504

for (p = end; p >= param; p--)

p >= param	Description
TRUE	evaluated 30 times by 1 test Evaluated by: Self test
FALSE	evaluated 3 times by 1 test Evaluated by: Self test

3-30

4505

{

-

4506

if (strmatch (pattern, p, FNMATCH_EXTFLAG) != FNM_NOMATCH)

strmatch (patt... 5) : 0)) != 1	Description
TRUE	evaluated 2 times by 1 test Evaluated by: Self test
FALSE	evaluated 28 times by 1 test Evaluated by: Self test

2-28

4507

{

-

4508

c = *p; *p = '\0';

-

4509

ret = savestring (param);

-

4510

*p = c;

-

4511

return (ret);

executed 2 times by 1 test: return (ret);

Executed by:

Self test

2

4512

}

-

4513

}

executed 28 times by 1 test: end of block

Executed by:

Self test

28

4514

break;

executed 3 times by 1 test: break;

Executed by:

Self test

3

4515

}

-

4516

-

4517

return (param); /* no match, return original string */

executed 7 times by 1 test: return (param);

Executed by:

Self test

7

4518

}

-

4519

-

4520

#if defined (HANDLE_MULTIBYTE)

-

4521

/* Returns its first argument if nothing matched; new memory otherwise */

-

4522

static wchar_t *

-

4523

remove_wpattern (wparam, wstrlen, wpattern, op)

-

4524

wchar_t *wparam;

-

4525

size_t wstrlen;

-

4526

wchar_t *wpattern;

-

4527

int op;

-

4528

{

-

4529

wchar_t wc, *ret;

-

4530

int n;

-

4531

-

4532

switch (op)

-

4533

{

-

4534

case RP_LONG_LEFT: /* remove longest match at start */

executed 150 times by 1 test: case 1:

Executed by:

Self test

150

4535

for (n = wstrlen; n >= 0; n--)

n >= 0	Description
TRUE	evaluated 858 times by 1 test Evaluated by: Self test
FALSE	evaluated 24 times by 1 test Evaluated by: Self test

24-858

4536

{

-

4537

wc = wparam[n]; wparam[n] = L'\0';

-

4538

if (wcsmatch (wpattern, wparam, FNMATCH_EXTFLAG) != FNM_NOMATCH)

wcsmatch (wpat... 5) : 0)) != 1	Description
TRUE	evaluated 126 times by 1 test Evaluated by: Self test
FALSE	evaluated 732 times by 1 test Evaluated by: Self test

126-732

4539

{

-

4540

wparam[n] = wc;

-

4541

return (wcsdup (wparam + n));

executed 126 times by 1 test: return (wcsdup (wparam + n));

Executed by:

Self test

126

4542

}

-

4543

wparam[n] = wc;

-

4544

}

executed 732 times by 1 test: end of block

Executed by:

Self test

732

4545

break;

executed 24 times by 1 test: break;

Executed by:

Self test

24

4546

-

4547

case RP_SHORT_LEFT: /* remove shortest match at start */

executed 1158112 times by 1 test: case 2:

Executed by:

Self test

1158112

4548

for (n = 0; n <= wstrlen; n++)

n <= wstrlen	Description
TRUE	evaluated 5568628 times by 1 test Evaluated by: Self test
FALSE	evaluated 873181 times by 1 test Evaluated by: Self test

873181-5568628

4549

{

-

4550

wc = wparam[n]; wparam[n] = L'\0';

-

4551

if (wcsmatch (wpattern, wparam, FNMATCH_EXTFLAG) != FNM_NOMATCH)

wcsmatch (wpat... 5) : 0)) != 1	Description
TRUE	evaluated 284931 times by 1 test Evaluated by: Self test
FALSE	evaluated 5283697 times by 1 test Evaluated by: Self test

284931-5283697

4552

{

-

4553

wparam[n] = wc;

-

4554

return (wcsdup (wparam + n));

executed 284931 times by 1 test: return (wcsdup (wparam + n));

Executed by:

Self test

284931

4555

}

-

4556

wparam[n] = wc;

-

4557

}

executed 5283697 times by 1 test: end of block

Executed by:

Self test

5283697

4558

break;

executed 873181 times by 1 test: break;

Executed by:

Self test

873181

4559

-

4560

case RP_LONG_RIGHT: /* remove longest match at end */

executed 157 times by 1 test: case 3:

Executed by:

Self test

157

4561

for (n = 0; n <= wstrlen; n++)

n <= wstrlen	Description
TRUE	evaluated 510 times by 1 test Evaluated by: Self test
FALSE	evaluated 37 times by 1 test Evaluated by: Self test

37-510

4562

{

-

4563

if (wcsmatch (wpattern, wparam + n, FNMATCH_EXTFLAG) != FNM_NOMATCH)

wcsmatch (wpat... 5) : 0)) != 1	Description
TRUE	evaluated 120 times by 1 test Evaluated by: Self test
FALSE	evaluated 390 times by 1 test Evaluated by: Self test

120-390

4564

{

-

4565

wc = wparam[n]; wparam[n] = L'\0';

-

4566

ret = wcsdup (wparam);

-

4567

wparam[n] = wc;

-

4568

return (ret);

executed 120 times by 1 test: return (ret);

Executed by:

Self test

120

4569

}

-

4570

}

executed 390 times by 1 test: end of block

Executed by:

Self test

390

4571

break;

executed 37 times by 1 test: break;

Executed by:

Self test

37

4572

-

4573

case RP_SHORT_RIGHT: /* remove shortest match at end */

executed 1158080 times by 1 test: case 4:

Executed by:

Self test

1158080

4574

for (n = wstrlen; n >= 0; n--)

n >= 0	Description
TRUE	evaluated 4052978 times by 1 test Evaluated by: Self test
FALSE	evaluated 579257 times by 1 test Evaluated by: Self test

579257-4052978

4575

{

-

4576

if (wcsmatch (wpattern, wparam + n, FNMATCH_EXTFLAG) != FNM_NOMATCH)

wcsmatch (wpat... 5) : 0)) != 1	Description
TRUE	evaluated 578823 times by 1 test Evaluated by: Self test
FALSE	evaluated 3474155 times by 1 test Evaluated by: Self test

578823-3474155

4577

{

-

4578

wc = wparam[n]; wparam[n] = L'\0';

-

4579

ret = wcsdup (wparam);

-

4580

wparam[n] = wc;

-

4581

return (ret);

executed 578823 times by 1 test: return (ret);

Executed by:

Self test

578823

4582

}

-

4583

}

executed 3474155 times by 1 test: end of block

Executed by:

Self test

3474155

4584

break;

executed 579257 times by 1 test: break;

Executed by:

Self test

579257

4585

}

-

4586

-

4587

return (wparam); /* no match, return original string */

executed 1452499 times by 1 test: return (wparam);

Executed by:

Self test

1452499

4588

}

-

4589

#endif /* HANDLE_MULTIBYTE */

-

4590

-

4591

static char *

-

4592

remove_pattern (param, pattern, op)

-

4593

char *param, *pattern;

-

4594

int op;

-

4595

{

-

4596

char *xret;

-

4597

-

4598

if (param == NULL)

param == ((void *)0)	Description
TRUE	never evaluated
FALSE	evaluated 2316560 times by 1 test Evaluated by: Self test

0-2316560

4599

return (param);

never executed: return (param);

0

4600

if (*param == '\0' || pattern == NULL || *pattern == '\0') /* minor optimization */

*param == '\0'	Description
TRUE	evaluated 12 times by 1 test Evaluated by: Self test
FALSE	evaluated 2316548 times by 1 test Evaluated by: Self test

pattern == ((void *)0)	Description
TRUE	evaluated 5 times by 1 test Evaluated by: Self test
FALSE	evaluated 2316543 times by 1 test Evaluated by: Self test

*pattern == '\0'	Description
TRUE	evaluated 16 times by 1 test Evaluated by: Self test
FALSE	evaluated 2316527 times by 1 test Evaluated by: Self test

5-2316548

4601

return (savestring (param));

executed 33 times by 1 test: return ((char *)strcpy (sh_xmalloc((1 + strlen (param)), "subst.c", 4601), (param)));

Executed by:

Self test

33

4602

-

4603

#if defined (HANDLE_MULTIBYTE)

-

4604

if (MB_CUR_MAX > 1)

(__ctype_get_m...ur_max ()) > 1	Description
TRUE	evaluated 2316500 times by 1 test Evaluated by: Self test
FALSE	evaluated 27 times by 1 test Evaluated by: Self test

27-2316500

4605

{

-

4606

wchar_t *ret, *oret;

-

4607

size_t n;

-

4608

wchar_t *wparam, *wpattern;

-

4609

mbstate_t ps;

-

4610

-

4611

/* XXX - could optimize here by checking param and pattern for multibyte

-

4612

chars with mbsmbchar and calling remove_upattern. */

-

4613

-

4614

n = xdupmbstowcs (&wpattern, NULL, pattern);

-

4615

if (n == (size_t)-1)

n == (size_t)-1	Description
TRUE	evaluated 1 time by 1 test Evaluated by: Self test
FALSE	evaluated 2316499 times by 1 test Evaluated by: Self test

1-2316499

4616

{

-

4617

xret = remove_upattern (param, pattern, op);

-

4618

return ((xret == param) ? savestring (param) : xret);

executed 1 time by 1 test: return ((xret == param) ? (char *)strcpy (sh_xmalloc((1 + strlen (param)), "subst.c", 4618), (param)) : xret);

Executed by:

Self test

1

4619

}

-

4620

n = xdupmbstowcs (&wparam, NULL, param);

-

4621

-

4622

if (n == (size_t)-1)

n == (size_t)-1	Description
TRUE	never evaluated
FALSE	evaluated 2316499 times by 1 test Evaluated by: Self test

0-2316499

4623

{

-

4624

free (wpattern);

-

4625

xret = remove_upattern (param, pattern, op);

-

4626

return ((xret == param) ? savestring (param) : xret);

never executed: return ((xret == param) ? (char *)strcpy (sh_xmalloc((1 + strlen (param)), "subst.c", 4626), (param)) : xret);

0

4627

}

-

4628

oret = ret = remove_wpattern (wparam, n, wpattern, op);

-

4629

/* Don't bother to convert wparam back to multibyte string if nothing

-

4630

matched; just return copy of original string */

-

4631

if (ret == wparam)

ret == wparam	Description
TRUE	evaluated 1452499 times by 1 test Evaluated by: Self test
FALSE	evaluated 864000 times by 1 test Evaluated by: Self test

864000-1452499

4632

{

-

4633

free (wparam);

-

4634

free (wpattern);

-

4635

return (savestring (param));

executed 1452499 times by 1 test: return ((char *)strcpy (sh_xmalloc((1 + strlen (param)), "subst.c", 4635), (param)));

Executed by:

Self test

1452499

4636

}

-

4637

-

4638

free (wparam);

-

4639

free (wpattern);

-

4640

-

4641

n = strlen (param);

-

4642

xret = (char *)xmalloc (n + 1);

-

4643

memset (&ps, '\0', sizeof (mbstate_t));

-

4644

n = wcsrtombs (xret, (const wchar_t **)&ret, n, &ps);

-

4645

xret[n] = '\0'; /* just to make sure */

-

4646

free (oret);

-

4647

return xret;

executed 864000 times by 1 test: return xret;

Executed by:

Self test

864000

4648

}

-

4649

else

-

4650

#endif

-

4651

{

-

4652

xret = remove_upattern (param, pattern, op);

-

4653

return ((xret == param) ? savestring (param) : xret);

executed 27 times by 1 test: return ((xret == param) ? (char *)strcpy (sh_xmalloc((1 + strlen (param)), "subst.c", 4653), (param)) : xret);

Executed by:

Self test

27

4654

}

-

4655

}

-

4656

-

4657

/* Match PAT anywhere in STRING and return the match boundaries.

-

4658

This returns 1 in case of a successful match, 0 otherwise. SP

-

4659

and EP are pointers into the string where the match begins and

-

4660

ends, respectively. MTYPE controls what kind of match is attempted.

-

4661

MATCH_BEG and MATCH_END anchor the match at the beginning and end

-

4662

of the string, respectively. The longest match is returned. */

-

4663

static int

-

4664

match_upattern (string, pat, mtype, sp, ep)

-

4665

char *string, *pat;

-

4666

int mtype;

-

4667

char **sp, **ep;

-

4668

{

-

4669

int c, mlen;

-

4670

size_t len;

-

4671

register char *p, *p1, *npat;

-

4672

char *end;

-

4673

-

4674

/* If the pattern doesn't match anywhere in the string, go ahead and

-

4675

short-circuit right away. A minor optimization, saves a bunch of

-

4676

unnecessary calls to strmatch (up to N calls for a string of N

-

4677

characters) if the match is unsuccessful. To preserve the semantics

-

4678

of the substring matches below, we make sure that the pattern has

-

4679

`*' as first and last character, making a new pattern if necessary. */

-

4680

/* XXX - check this later if I ever implement `**' with special meaning,

-

4681

since this will potentially result in `**' at the beginning or end */

-

4682

len = STRLEN (pat);

(pat)[1]	Description
TRUE	evaluated 58547 times by 1 test Evaluated by: Self test
FALSE	evaluated 1624 times by 1 test Evaluated by: Self test

(pat)[2]	Description
TRUE	evaluated 57653 times by 1 test Evaluated by: Self test
FALSE	evaluated 894 times by 1 test Evaluated by: Self test

(pat)	Description
TRUE	evaluated 60171 times by 1 test Evaluated by: Self test
FALSE	never evaluated

(pat)[0]	Description
TRUE	evaluated 60171 times by 1 test Evaluated by: Self test
FALSE	never evaluated

0-60171

4683

if (pat[0] != '*' || (pat[0] == '*' && pat[1] == LPAREN && extended_glob) || pat[len - 1] != '*')

pat[0] != '*'	Description
TRUE	evaluated 59904 times by 1 test Evaluated by: Self test
FALSE	evaluated 267 times by 1 test Evaluated by: Self test

pat[0] == '*'	Description
TRUE	evaluated 267 times by 1 test Evaluated by: Self test
FALSE	never evaluated

pat[1] == '('	Description
TRUE	evaluated 2 times by 1 test Evaluated by: Self test
FALSE	evaluated 265 times by 1 test Evaluated by: Self test

extended_glob	Description
TRUE	evaluated 2 times by 1 test Evaluated by: Self test
FALSE	never evaluated

pat[len - 1] != '*'	Description
TRUE	evaluated 4 times by 1 test Evaluated by: Self test
FALSE	evaluated 261 times by 1 test Evaluated by: Self test

0-59904

4684

{

-

4685

int unescaped_backslash;

-

4686

char *pp;

-

4687

-

4688

p = npat = (char *)xmalloc (len + 3);

-

4689

p1 = pat;

-

4690

if ((mtype != MATCH_BEG) && (*p1 != '*' || (*p1 == '*' && p1[1] == LPAREN && extended_glob)))

(mtype != 0x001)	Description
TRUE	evaluated 59815 times by 1 test Evaluated by: Self test
FALSE	evaluated 95 times by 1 test Evaluated by: Self test

p1 != ''	Description
TRUE	evaluated 59809 times by 1 test Evaluated by: Self test
FALSE	evaluated 6 times by 1 test Evaluated by: Self test

p1 == ''	Description
TRUE	evaluated 6 times by 1 test Evaluated by: Self test
FALSE	never evaluated

p1[1] == '('	Description
TRUE	evaluated 2 times by 1 test Evaluated by: Self test
FALSE	evaluated 4 times by 1 test Evaluated by: Self test

extended_glob	Description
TRUE	evaluated 2 times by 1 test Evaluated by: Self test
FALSE	never evaluated

0-59815

4691

*p++ = '*';

executed 59811 times by 1 test: *p++ = '*';

Executed by:

Self test

59811

4692

while (*p1)

*p1	Description
TRUE	evaluated 372193 times by 1 test Evaluated by: Self test
FALSE	evaluated 59910 times by 1 test Evaluated by: Self test

59910-372193

4693

*p++ = *p1++;

executed 372193 times by 1 test: *p++ = *p1++;

Executed by:

Self test

372193

4694

#if 1

-

4695

/* Need to also handle a pattern that ends with an unescaped backslash.

-

4696

For right now, we ignore it because the pattern matching code will

-

4697

fail the match anyway */

-

4698

/* If the pattern ends with a `*' we leave it alone if it's preceded by

-

4699

an even number of backslashes, but if it's escaped by a backslash

-

4700

we need to add another `*'. */

-

4701

if ((mtype != MATCH_END) && (p1[-1] == '*' && (unescaped_backslash = p1[-2] == '\\')))

(mtype != 0x002)	Description
TRUE	evaluated 59692 times by 1 test Evaluated by: Self test
FALSE	evaluated 218 times by 1 test Evaluated by: Self test

p1[-1] == '*'	Description
TRUE	evaluated 115 times by 1 test Evaluated by: Self test
FALSE	evaluated 59577 times by 1 test Evaluated by: Self test

(unescaped_bac...1[-2] == '\\')	Description
TRUE	evaluated 3 times by 1 test Evaluated by: Self test
FALSE	evaluated 112 times by 1 test Evaluated by: Self test

3-59692

4702

{

-

4703

pp = p1 - 3;

-

4704

while (pp >= pat && *pp-- == '\\')

pp >= pat	Description
TRUE	evaluated 1 time by 1 test Evaluated by: Self test
FALSE	evaluated 3 times by 1 test Evaluated by: Self test

*pp-- == '\\'	Description
TRUE	evaluated 1 time by 1 test Evaluated by: Self test
FALSE	never evaluated

0-3

4705

unescaped_backslash = 1 - unescaped_backslash;

executed 1 time by 1 test: unescaped_backslash = 1 - unescaped_backslash;

Executed by:

Self test

1

4706

if (unescaped_backslash)

unescaped_backslash	Description
TRUE	evaluated 2 times by 1 test Evaluated by: Self test
FALSE	evaluated 1 time by 1 test Evaluated by: Self test

1-2

4707

*p++ = '*';

executed 2 times by 1 test: *p++ = '*';

Executed by:

Self test

2

4708

}

executed 3 times by 1 test: end of block

Executed by:

Self test

3

4709

else if (mtype != MATCH_END && p1[-1] != '*')

mtype != 0x002	Description
TRUE	evaluated 59689 times by 1 test Evaluated by: Self test
FALSE	evaluated 218 times by 1 test Evaluated by: Self test

p1[-1] != '*'	Description
TRUE	evaluated 59577 times by 1 test Evaluated by: Self test
FALSE	evaluated 112 times by 1 test Evaluated by: Self test

112-59689

4710

*p++ = '*';

executed 59577 times by 1 test: *p++ = '*';

Executed by:

Self test

59577

4711

#else

-

4712

if (p1[-1] != '*' || p1[-2] == '\\')

-

4713

*p++ = '*';

-

4714

#endif

-

4715

*p = '\0';

-

4716

}

executed 59910 times by 1 test: end of block

Executed by:

Self test

59910

4717

else

-

4718

npat = pat;

executed 261 times by 1 test: npat = pat;

Executed by:

Self test

261

4719

c = strmatch (npat, string, FNMATCH_EXTFLAG | FNMATCH_IGNCASE);

-

4720

if (npat != pat)

npat != pat	Description
TRUE	evaluated 59910 times by 1 test Evaluated by: Self test
FALSE	evaluated 261 times by 1 test Evaluated by: Self test

261-59910

4721

free (npat);

executed 59910 times by 1 test: sh_xfree((npat), "subst.c", 4721);

Executed by:

Self test

59910

4722

if (c == FNM_NOMATCH)

c == 1	Description
TRUE	evaluated 812 times by 1 test Evaluated by: Self test
FALSE	evaluated 59359 times by 1 test Evaluated by: Self test

812-59359

4723

return (0);

executed 812 times by 1 test: return (0);

Executed by:

Self test

812

4724

-

4725

len = STRLEN (string);

(string)[1]	Description
TRUE	evaluated 59310 times by 1 test Evaluated by: Self test
FALSE	evaluated 31 times by 1 test Evaluated by: Self test

(string)[2]	Description
TRUE	evaluated 58572 times by 1 test Evaluated by: Self test
FALSE	evaluated 738 times by 1 test Evaluated by: Self test

(string)	Description
TRUE	evaluated 59359 times by 1 test Evaluated by: Self test
FALSE	never evaluated

(string)[0]	Description
TRUE	evaluated 59341 times by 1 test Evaluated by: Self test
FALSE	evaluated 18 times by 1 test Evaluated by: Self test

0-59359

4726

end = string + len;

-

4727

-

4728

mlen = umatchlen (pat, len);

-

4729

-

4730

switch (mtype)

-

4731

{

-

4732

case MATCH_ANY:

executed 59010 times by 1 test: case 0x000:

Executed by:

Self test

59010

4733

for (p = string; p <= end; p++)

p <= end	Description
TRUE	evaluated 94052 times by 1 test Evaluated by: Self test
FALSE	never evaluated

0-94052

4734

{

-

4735

if (match_pattern_char (pat, p, FNMATCH_IGNCASE))

match_pattern_...(1 << 4) : 0))	Description
TRUE	evaluated 78870 times by 1 test Evaluated by: Self test
FALSE	evaluated 15182 times by 1 test Evaluated by: Self test

15182-78870

4736

{

-

4737

p1 = (mlen == -1) ? end : p + mlen;

(mlen == -1)	Description
TRUE	evaluated 179 times by 1 test Evaluated by: Self test
FALSE	evaluated 78691 times by 1 test Evaluated by: Self test

179-78691

4738

/* p1 - p = length of portion of string to be considered

-

4739

p = current position in string

-

4740

mlen = number of characters consumed by match (-1 for entire string)

-

4741

end = end of string

-

4742

we want to break immediately if the potential match len

-

4743

is greater than the number of characters remaining in the

-

4744

string

-

4745

*/

-

4746

if (p1 > end)

p1 > end	Description
TRUE	never evaluated
FALSE	evaluated 78870 times by 1 test Evaluated by: Self test

0-78870

4747

break;

never executed: break;

0

4748

for ( ; p1 >= p; p1--)

p1 >= p	Description
TRUE	evaluated 78888 times by 1 test Evaluated by: Self test
FALSE	evaluated 1 time by 1 test Evaluated by: Self test

1-78888

4749

{

-

4750

c = *p1; *p1 = '\0';

-

4751

if (strmatch (pat, p, FNMATCH_EXTFLAG | FNMATCH_IGNCASE) == 0)

strmatch (pat,... 4) : 0)) == 0	Description
TRUE	evaluated 59010 times by 1 test Evaluated by: Self test
FALSE	evaluated 19878 times by 1 test Evaluated by: Self test

19878-59010

4752

{

-

4753

*p1 = c;

-

4754

*sp = p;

-

4755

*ep = p1;

-

4756

return 1;

executed 59010 times by 1 test: return 1;

Executed by:

Self test

59010

4757

}

-

4758

*p1 = c;

-

4759

#if 1

-

4760

/* If MLEN != -1, we have a fixed length pattern. */

-

4761

if (mlen != -1)

mlen != -1	Description
TRUE	evaluated 19859 times by 1 test Evaluated by: Self test
FALSE	evaluated 19 times by 1 test Evaluated by: Self test

19-19859

4762

break;

executed 19859 times by 1 test: break;

Executed by:

Self test

19859

4763

#endif

-

4764

}

executed 19 times by 1 test: end of block

Executed by:

Self test

19

4765

}

executed 19860 times by 1 test: end of block

Executed by:

Self test

19860

4766

}

executed 35042 times by 1 test: end of block

Executed by:

Self test

35042

4767

-

4768

return (0);

never executed: return (0);

0

4769

-

4770

case MATCH_BEG:

executed 140 times by 1 test: case 0x001:

Executed by:

Self test

140

4771

if (match_pattern_char (pat, string, FNMATCH_IGNCASE) == 0)

match_pattern_... 4) : 0)) == 0	Description
TRUE	never evaluated
FALSE	evaluated 140 times by 1 test Evaluated by: Self test

0-140

4772

return (0);

never executed: return (0);

0

4773

-

4774

for (p = (mlen == -1) ? end : string + mlen; p >= string; p--)

p >= string	Description
TRUE	evaluated 140 times by 1 test Evaluated by: Self test
FALSE	never evaluated

0-140

4775

{

-

4776

c = *p; *p = '\0';

-

4777

if (strmatch (pat, string, FNMATCH_EXTFLAG | FNMATCH_IGNCASE) == 0)

strmatch (pat,... 4) : 0)) == 0	Description
TRUE	evaluated 140 times by 1 test Evaluated by: Self test
FALSE	never evaluated

0-140

4778

{

-

4779

*p = c;

-

4780

*sp = string;

-

4781

*ep = p;

-

4782

return 1;

executed 140 times by 1 test: return 1;

Executed by:

Self test

140

4783

}

-

4784

*p = c;

-

4785

/* If MLEN != -1, we have a fixed length pattern. */

-

4786

if (mlen != -1)

mlen != -1	Description
TRUE	never evaluated
FALSE	never evaluated

0

4787

break;

never executed: break;

0

4788

}

never executed: end of block

0

4789

-

4790

return (0);

never executed: return (0);

0

4791

-

4792

case MATCH_END:

executed 209 times by 1 test: case 0x002:

Executed by:

Self test

209

4793

for (p = end - ((mlen == -1) ? len : mlen); p <= end; p++)

p <= end	Description
TRUE	evaluated 236 times by 1 test Evaluated by: Self test
FALSE	never evaluated

0-236

4794

{

-

4795

if (strmatch (pat, p, FNMATCH_EXTFLAG | FNMATCH_IGNCASE) == 0)

strmatch (pat,... 4) : 0)) == 0	Description
TRUE	evaluated 209 times by 1 test Evaluated by: Self test
FALSE	evaluated 27 times by 1 test Evaluated by: Self test

27-209

4796

{

-

4797

*sp = p;

-

4798

*ep = end;

-

4799

return 1;

executed 209 times by 1 test: return 1;

Executed by:

Self test

209

4800

}

-

4801

/* If MLEN != -1, we have a fixed length pattern. */

-

4802

if (mlen != -1)

mlen != -1	Description
TRUE	never evaluated
FALSE	evaluated 27 times by 1 test Evaluated by: Self test

0-27

4803

break;

never executed: break;

0

4804

}

executed 27 times by 1 test: end of block

Executed by:

Self test

27

4805

-

4806

return (0);

never executed: return (0);

0

4807

}

-

4808

-

4809

return (0);

never executed: return (0);

0

4810

}

-

4811

-

4812

#if defined (HANDLE_MULTIBYTE)

-

4813

-

4814

#define WFOLD(c) (match_ignore_case && iswupper (c) ? towlower (c) : (c))

-

4815

-

4816

/* Match WPAT anywhere in WSTRING and return the match boundaries.

-

4817

This returns 1 in case of a successful match, 0 otherwise. Wide

-

4818

character version. */

-

4819

static int

-

4820

match_wpattern (wstring, indices, wstrlen, wpat, mtype, sp, ep)

-

4821

wchar_t *wstring;

-

4822

char **indices;

-

4823

size_t wstrlen;

-

4824

wchar_t *wpat;

-

4825

int mtype;

-

4826

char **sp, **ep;

-

4827

{

-

4828

wchar_t wc, *wp, *nwpat, *wp1;

-

4829

size_t len;

-

4830

int mlen;

-

4831

int n, n1, n2, simple;

-

4832

-

4833

simple = (wpat[0] != L'\\' && wpat[0] != L'*' && wpat[0] != L'?' && wpat[0] != L'[');

wpat[0] != L'\\'	Description
TRUE	evaluated 10 times by 1 test Evaluated by: Self test
FALSE	never evaluated

wpat[0] != L'*'	Description
TRUE	evaluated 10 times by 1 test Evaluated by: Self test
FALSE	never evaluated

wpat[0] != L'?'	Description
TRUE	evaluated 10 times by 1 test Evaluated by: Self test
FALSE	never evaluated

wpat[0] != L'['	Description
TRUE	evaluated 10 times by 1 test Evaluated by: Self test
FALSE	never evaluated

0-10

4834

#if defined (EXTENDED_GLOB)

-

4835

if (extended_glob)

extended_glob	Description
TRUE	never evaluated
FALSE	evaluated 10 times by 1 test Evaluated by: Self test

0-10

4836

simple &= (wpat[1] != L'(' || (wpat[0] != L'*' && wpat[0] != L'?' && wpat[0] != L'+' && wpat[0] != L'!' && wpat[0] != L'@')); /*)*/

never executed:

simple &= (wpat[1] != L'(' || (wpat[0] != L'*' && wpat[0] != L'?' && wpat[0] != L'+' && wpat[0] != L'!' && wpat[0] != L'@'));

wpat[1] != L'('	Description
TRUE	never evaluated
FALSE	never evaluated

wpat[0] != L'*'	Description
TRUE	never evaluated
FALSE	never evaluated

wpat[0] != L'?'	Description
TRUE	never evaluated
FALSE	never evaluated

wpat[0] != L'+'	Description
TRUE	never evaluated
FALSE	never evaluated

wpat[0] != L'!'	Description
TRUE	never evaluated
FALSE	never evaluated

wpat[0] != L'@'	Description
TRUE	never evaluated
FALSE	never evaluated

0

4837

#endif

-

4838

-

4839

/* If the pattern doesn't match anywhere in the string, go ahead and

-

4840

short-circuit right away. A minor optimization, saves a bunch of

-

4841

unnecessary calls to strmatch (up to N calls for a string of N

-

4842

characters) if the match is unsuccessful. To preserve the semantics

-

4843

of the substring matches below, we make sure that the pattern has

-

4844

`*' as first and last character, making a new pattern if necessary. */

-

4845

len = wcslen (wpat);

-

4846

if (wpat[0] != L'*' || (wpat[0] == L'*' && wpat[1] == WLPAREN && extended_glob) || wpat[len - 1] != L'*')

wpat[0] != L'*'	Description
TRUE	evaluated 10 times by 1 test Evaluated by: Self test
FALSE	never evaluated

wpat[0] == L'*'	Description
TRUE	never evaluated
FALSE	never evaluated

wpat[1] == L'('	Description
TRUE	never evaluated
FALSE	never evaluated

extended_glob	Description
TRUE	never evaluated
FALSE	never evaluated

wpat[len - 1] != L'*'	Description
TRUE	never evaluated
FALSE	never evaluated

0-10

4847

{

-

4848

int unescaped_backslash;

-

4849

wchar_t *wpp;

-

4850

-

4851

wp = nwpat = (wchar_t *)xmalloc ((len + 3) * sizeof (wchar_t));

-

4852

wp1 = wpat;

-

4853

if (*wp1 != L'*' || (*wp1 == '*' && wp1[1] == WLPAREN && extended_glob))

wp1 != L''	Description
TRUE	evaluated 10 times by 1 test Evaluated by: Self test
FALSE	never evaluated

wp1 == ''	Description
TRUE	never evaluated
FALSE	never evaluated

wp1[1] == L'('	Description
TRUE	never evaluated
FALSE	never evaluated

extended_glob	Description
TRUE	never evaluated
FALSE	never evaluated

0-10

4854

*wp++ = L'*';

executed 10 times by 1 test: *wp++ = L'*';

Executed by:

Self test

10

4855

while (*wp1 != L'\0')

*wp1 != L'\0'	Description
TRUE	evaluated 20 times by 1 test Evaluated by: Self test
FALSE	evaluated 10 times by 1 test Evaluated by: Self test

10-20

4856

*wp++ = *wp1++;

executed 20 times by 1 test: *wp++ = *wp1++;

Executed by:

Self test

20

4857

#if 1

-

4858

/* See comments above in match_upattern. */

-

4859

if (wp1[-1] == L'*' && (unescaped_backslash = wp1[-2] == L'\\'))

wp1[-1] == L'*'	Description
TRUE	never evaluated
FALSE	evaluated 10 times by 1 test Evaluated by: Self test

(unescaped_bac...[-2] == L'\\')	Description
TRUE	never evaluated
FALSE	never evaluated

0-10

4860

{

-

4861

wpp = wp1 - 3;

-

4862

while (wpp >= wpat && *wpp-- == L'\\')

wpp >= wpat	Description
TRUE	never evaluated
FALSE	never evaluated

*wpp-- == L'\\'	Description
TRUE	never evaluated
FALSE	never evaluated

0

4863

unescaped_backslash = 1 - unescaped_backslash;

never executed: unescaped_backslash = 1 - unescaped_backslash;

0

4864

if (unescaped_backslash)

unescaped_backslash	Description
TRUE	never evaluated
FALSE	never evaluated

0

4865

*wp++ = L'*';

never executed: *wp++ = L'*';

0

4866

}

never executed: end of block

0

4867

else if (wp1[-1] != L'*')

wp1[-1] != L'*'	Description
TRUE	evaluated 10 times by 1 test Evaluated by: Self test
FALSE	never evaluated

0-10

4868

*wp++ = L'*';

executed 10 times by 1 test: *wp++ = L'*';

Executed by:

Self test

10

4869

#else

-

4870

if (wp1[-1] != L'*' || wp1[-2] == L'\\')

-

4871

*wp++ = L'*';

-

4872

#endif

-

4873

*wp = '\0';

-

4874

}

executed 10 times by 1 test: end of block

Executed by:

Self test

10

4875

else

-

4876

nwpat = wpat;

never executed: nwpat = wpat;

0

4877

len = wcsmatch (nwpat, wstring, FNMATCH_EXTFLAG | FNMATCH_IGNCASE);

-

4878

if (nwpat != wpat)

nwpat != wpat	Description
TRUE	evaluated 10 times by 1 test Evaluated by: Self test
FALSE	never evaluated

0-10

4879

free (nwpat);

executed 10 times by 1 test: sh_xfree((nwpat), "subst.c", 4879);

Executed by:

Self test

10

4880

if (len == FNM_NOMATCH)

len == 1	Description
TRUE	evaluated 3 times by 1 test Evaluated by: Self test
FALSE	evaluated 7 times by 1 test Evaluated by: Self test

3-7

4881

return (0);

executed 3 times by 1 test: return (0);

Executed by:

Self test

3

4882

-

4883

mlen = wmatchlen (wpat, wstrlen);

-

4884

-

4885

/* itrace("wmatchlen (%ls) -> %d", wpat, mlen); */

-

4886

switch (mtype)

-

4887

{

-

4888

case MATCH_ANY:

executed 3 times by 1 test: case 0x000:

Executed by:

Self test

3

4889

for (n = 0; n <= wstrlen; n++)

n <= wstrlen	Description
TRUE	evaluated 6 times by 1 test Evaluated by: Self test
FALSE	never evaluated

0-6

4890

{

-

4891

n2 = simple ? (WFOLD(*wpat) == WFOLD(wstring[n])) : match_pattern_wchar (wpat, wstring + n, FNMATCH_IGNCASE);

simple	Description
TRUE	evaluated 6 times by 1 test Evaluated by: Self test
FALSE	never evaluated

match_ignore_case	Description
TRUE	never evaluated
FALSE	evaluated 6 times by 1 test Evaluated by: Self test

iswupper (*wpat)	Description
TRUE	never evaluated
FALSE	never evaluated

match_ignore_case	Description
TRUE	never evaluated
FALSE	evaluated 6 times by 1 test Evaluated by: Self test

iswupper (wstring[n])	Description
TRUE	never evaluated
FALSE	never evaluated

0-6

4892

if (n2)

n2	Description
TRUE	evaluated 3 times by 1 test Evaluated by: Self test
FALSE	evaluated 3 times by 1 test Evaluated by: Self test

3

4893

{

-

4894

n1 = (mlen == -1) ? wstrlen : n + mlen;

(mlen == -1)	Description
TRUE	never evaluated
FALSE	evaluated 3 times by 1 test Evaluated by: Self test

0-3

4895

if (n1 > wstrlen)

n1 > wstrlen	Description
TRUE	never evaluated
FALSE	evaluated 3 times by 1 test Evaluated by: Self test

0-3

4896

break;

never executed: break;

0

4897

-

4898

for ( ; n1 >= n; n1--)

n1 >= n	Description
TRUE	evaluated 3 times by 1 test Evaluated by: Self test
FALSE	never evaluated

0-3

4899

{

-

4900

wc = wstring[n1]; wstring[n1] = L'\0';

-

4901

if (wcsmatch (wpat, wstring + n, FNMATCH_EXTFLAG | FNMATCH_IGNCASE) == 0)

wcsmatch (wpat... 4) : 0)) == 0	Description
TRUE	evaluated 3 times by 1 test Evaluated by: Self test
FALSE	never evaluated

0-3

4902

{

-

4903

wstring[n1] = wc;

-

4904

*sp = indices[n];

-

4905

*ep = indices[n1];

-

4906

return 1;

executed 3 times by 1 test: return 1;

Executed by:

Self test

3

4907

}

-

4908

wstring[n1] = wc;

-

4909

/* If MLEN != -1, we have a fixed length pattern. */

-

4910

if (mlen != -1)

mlen != -1	Description
TRUE	never evaluated
FALSE	never evaluated

0

4911

break;

never executed: break;

0

4912

}

never executed: end of block

0

4913

}

never executed: end of block

0

4914

}

executed 3 times by 1 test: end of block

Executed by:

Self test

3

4915

-

4916

return (0);

never executed: return (0);

0

4917

-

4918

case MATCH_BEG:

executed 2 times by 1 test: case 0x001:

Executed by:

Self test

2

4919

if (match_pattern_wchar (wpat, wstring, FNMATCH_IGNCASE) == 0)

match_pattern_... 4) : 0)) == 0	Description
TRUE	never evaluated
FALSE	evaluated 2 times by 1 test Evaluated by: Self test

0-2

4920

return (0);

never executed: return (0);

0

4921

-

4922

for (n = (mlen == -1) ? wstrlen : mlen; n >= 0; n--)

n >= 0	Description
TRUE	evaluated 2 times by 1 test Evaluated by: Self test
FALSE	never evaluated

0-2

4923

{

-

4924

wc = wstring[n]; wstring[n] = L'\0';

-

4925

if (wcsmatch (wpat, wstring, FNMATCH_EXTFLAG | FNMATCH_IGNCASE) == 0)

wcsmatch (wpat... 4) : 0)) == 0	Description
TRUE	evaluated 2 times by 1 test Evaluated by: Self test
FALSE	never evaluated

0-2

4926

{

-

4927

wstring[n] = wc;

-

4928

*sp = indices[0];

-

4929

*ep = indices[n];

-

4930

return 1;

executed 2 times by 1 test: return 1;

Executed by:

Self test

2

4931

}

-

4932

wstring[n] = wc;

-

4933

/* If MLEN != -1, we have a fixed length pattern. */

-

4934

if (mlen != -1)

mlen != -1	Description
TRUE	never evaluated
FALSE	never evaluated

0

4935

break;

never executed: break;

0

4936

}

never executed: end of block

0

4937

-

4938

return (0);

never executed: return (0);

0

4939

-

4940

case MATCH_END:

executed 2 times by 1 test: case 0x002:

Executed by:

Self test

2

4941

for (n = wstrlen - ((mlen == -1) ? wstrlen : mlen); n <= wstrlen; n++)

n <= wstrlen	Description
TRUE	evaluated 2 times by 1 test Evaluated by: Self test
FALSE	never evaluated

0-2

4942

{

-

4943

if (wcsmatch (wpat, wstring + n, FNMATCH_EXTFLAG | FNMATCH_IGNCASE) == 0)

wcsmatch (wpat... 4) : 0)) == 0	Description
TRUE	evaluated 2 times by 1 test Evaluated by: Self test
FALSE	never evaluated

0-2

4944

{

-

4945

*sp = indices[n];

-

4946

*ep = indices[wstrlen];

-

4947

return 1;

executed 2 times by 1 test: return 1;

Executed by:

Self test

2

4948

}

-

4949

/* If MLEN != -1, we have a fixed length pattern. */

-

4950

if (mlen != -1)

mlen != -1	Description
TRUE	never evaluated
FALSE	never evaluated

0

4951

break;

never executed: break;

0

4952

}

never executed: end of block

0

4953

-

4954

return (0);

never executed: return (0);

0

4955

}

-

4956

-

4957

return (0);

never executed: return (0);

0

4958

}

-

4959

#undef WFOLD

-

4960

#endif /* HANDLE_MULTIBYTE */

-

4961

-

4962

static int

-

4963

match_pattern (string, pat, mtype, sp, ep)

-

4964

char *string, *pat;

-

4965

int mtype;

-

4966

char **sp, **ep;

-

4967

{

-

4968

#if defined (HANDLE_MULTIBYTE)

-

4969

int ret;

-

4970

size_t n;

-

4971

wchar_t *wstring, *wpat;

-

4972

char **indices;

-

4973

#endif

-

4974

-

4975

if (string == 0 || pat == 0 || *pat == 0)

string == 0	Description
TRUE	never evaluated
FALSE	evaluated 60212 times by 1 test Evaluated by: Self test

pat == 0	Description
TRUE	evaluated 31 times by 1 test Evaluated by: Self test
FALSE	evaluated 60181 times by 1 test Evaluated by: Self test

*pat == 0	Description
TRUE	never evaluated
FALSE	evaluated 60181 times by 1 test Evaluated by: Self test

0-60212

4976

return (0);

executed 31 times by 1 test: return (0);

Executed by:

Self test

31

4977

-

4978

#if defined (HANDLE_MULTIBYTE)

-

4979

if (MB_CUR_MAX > 1)

(__ctype_get_m...ur_max ()) > 1	Description
TRUE	evaluated 31459 times by 1 test Evaluated by: Self test
FALSE	evaluated 28722 times by 1 test Evaluated by: Self test

28722-31459

4980

{

-

4981

if (mbsmbchar (string) == 0 && mbsmbchar (pat) == 0)

mbsmbchar (string) == 0	Description
TRUE	evaluated 31449 times by 1 test Evaluated by: Self test
FALSE	evaluated 10 times by 1 test Evaluated by: Self test

mbsmbchar (pat) == 0	Description
TRUE	evaluated 31449 times by 1 test Evaluated by: Self test
FALSE	never evaluated

0-31449

4982

return (match_upattern (string, pat, mtype, sp, ep));

executed 31449 times by 1 test: return (match_upattern (string, pat, mtype, sp, ep));

Executed by:

Self test

31449

4983

-

4984

n = xdupmbstowcs (&wpat, NULL, pat);

-

4985

if (n == (size_t)-1)

n == (size_t)-1	Description
TRUE	never evaluated
FALSE	evaluated 10 times by 1 test Evaluated by: Self test

0-10

4986

return (match_upattern (string, pat, mtype, sp, ep));

never executed: return (match_upattern (string, pat, mtype, sp, ep));

0

4987

n = xdupmbstowcs (&wstring, &indices, string);

-

4988

if (n == (size_t)-1)

n == (size_t)-1	Description
TRUE	never evaluated
FALSE	evaluated 10 times by 1 test Evaluated by: Self test

0-10

4989

{

-

4990

free (wpat);

-

4991

return (match_upattern (string, pat, mtype, sp, ep));

never executed: return (match_upattern (string, pat, mtype, sp, ep));

0

4992

}

-

4993

ret = match_wpattern (wstring, indices, n, wpat, mtype, sp, ep);

-

4994

-

4995

free (wpat);

-

4996

free (wstring);

-

4997

free (indices);

-

4998

-

4999

return (ret);

executed 10 times by 1 test: return (ret);

Executed by:

Self test

10

5000

}

-

5001

else

-

5002

#endif

-

5003

return (match_upattern (string, pat, mtype, sp, ep));

executed 28722 times by 1 test: return (match_upattern (string, pat, mtype, sp, ep));

Executed by:

Self test

28722

5004

}

-

5005

-

5006

static int

-

5007

getpatspec (c, value)

-

5008

int c;

-

5009

char *value;

-

5010

{

-

5011

if (c == '#')

c == '#'	Description
TRUE	evaluated 1157915 times by 1 test Evaluated by: Self test
FALSE	evaluated 1157903 times by 1 test Evaluated by: Self test

1157903-1157915

5012

return ((*value == '#') ? RP_LONG_LEFT : RP_SHORT_LEFT);

executed 1157915 times by 1 test: return ((*value == '#') ? 1 : 2);

Executed by:

Self test

1157915

5013

else /* c == '%' */

-

5014

return ((*value == '%') ? RP_LONG_RIGHT : RP_SHORT_RIGHT);

executed 1157903 times by 1 test: return ((*value == '%') ? 3 : 4);

Executed by:

Self test

1157903

5015

}

-

5016

-

5017

/* Posix.2 says that the WORD should be run through tilde expansion,

-

5018

parameter expansion, command substitution and arithmetic expansion.

-

5019

This leaves the result quoted, so quote_string_for_globbing () has

-

5020

to be called to fix it up for strmatch (). If QUOTED is non-zero,

-

5021

it means that the entire expression was enclosed in double quotes.

-

5022

This means that quoting characters in the pattern do not make any

-

5023

special pattern characters quoted. For example, the `*' in the

-

5024

following retains its special meaning: "${foo#'*'}". */

-

5025

static char *

-

5026

getpattern (value, quoted, expandpat)

-

5027

char *value;

-

5028

int quoted, expandpat;

-

5029

{

-

5030

char *pat, *tword;

-

5031

WORD_LIST *l;

-

5032

#if 0

-

5033

int i;

-

5034

#endif

-

5035

/* There is a problem here: how to handle single or double quotes in the

-

5036

pattern string when the whole expression is between double quotes?

-

5037

POSIX.2 says that enclosing double quotes do not cause the pattern to

-

5038

be quoted, but does that leave us a problem with @ and array[@] and their

-

5039

expansions inside a pattern? */

-

5040

#if 0

-

5041

if (expandpat && (quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)) && *tword)

-

5042

{

-

5043

i = 0;

-

5044

pat = string_extract_double_quoted (tword, &i, SX_STRIPDQ);

-

5045

free (tword);

-

5046

tword = pat;

-

5047

}

-

5048

#endif

-

5049

-

5050

/* expand_string_for_pat () leaves WORD quoted and does not perform

-

5051

word splitting. */

-

5052

l = *value ? expand_string_for_pat (value,

*value	Description
TRUE	evaluated 2316712 times by 1 test Evaluated by: Self test
FALSE	evaluated 47 times by 1 test Evaluated by: Self test

47-2316712

5053

(quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)) ? Q_PATQUOTE : quoted,

-

5054

(int *)NULL, (int *)NULL)

-

5055

: (WORD_LIST *)0;

-

5056

pat = string_list (l);

-

5057

dispose_words (l);

-

5058

if (pat)

pat	Description
TRUE	evaluated 2316689 times by 1 test Evaluated by: Self test
FALSE	evaluated 66 times by 1 test Evaluated by: Self test

66-2316689

5059

{

-

5060

tword = quote_string_for_globbing (pat, QGLOB_CVTNULL);

-

5061

free (pat);

-

5062

pat = tword;

-

5063

}

executed 2316689 times by 1 test: end of block

Executed by:

Self test

2316689

5064

return (pat);

executed 2316755 times by 1 test: return (pat);

Executed by:

Self test

2316755

5065

}

-

5066

-

5067

#if 0

-

5068

/* Handle removing a pattern from a string as a result of ${name%[%]value}

-

5069

or ${name#[#]value}. */

-

5070

static char *

-

5071

variable_remove_pattern (value, pattern, patspec, quoted)

-

5072

char *value, *pattern;

-

5073

int patspec, quoted;

-

5074

{

-

5075

char *tword;

-

5076

-

5077

tword = remove_pattern (value, pattern, patspec);

-

5078

-

5079

return (tword);

-

5080

}

-

5081

#endif

-

5082

-

5083

static char *

-

5084

list_remove_pattern (list, pattern, patspec, itype, quoted)

-

5085

WORD_LIST *list;

-

5086

char *pattern;

-

5087

int patspec, itype, quoted;

-

5088

{

-

5089

WORD_LIST *new, *l;

-

5090

WORD_DESC *w;

-

5091

char *tword;

-

5092

-

5093

for (new = (WORD_LIST *)NULL, l = list; l; l = l->next)

l	Description
TRUE	evaluated 870 times by 1 test Evaluated by: Self test
FALSE	evaluated 128 times by 1 test Evaluated by: Self test

128-870

5094

{

-

5095

tword = remove_pattern (l->word->word, pattern, patspec);

-

5096

w = alloc_word_desc ();

-

5097

w->word = tword ? tword : savestring ("");

tword	Description
TRUE	evaluated 870 times by 1 test Evaluated by: Self test
FALSE	never evaluated

0-870

5098

new = make_word_list (w, new);

-

5099

}

executed 870 times by 1 test: end of block

Executed by:

Self test

870

5100

-

5101

l = REVERSE_LIST (new, WORD_LIST *);

new	Description
TRUE	evaluated 128 times by 1 test Evaluated by: Self test
FALSE	never evaluated

new->next	Description
TRUE	evaluated 119 times by 1 test Evaluated by: Self test
FALSE	evaluated 9 times by 1 test Evaluated by: Self test

0-128

5102

tword = string_list_pos_params (itype, l, quoted);

-

5103

dispose_words (l);

-

5104

-

5105

return (tword);

executed 128 times by 1 test: return (tword);

Executed by:

Self test

128

5106

}

-

5107

-

5108

static char *

-

5109

parameter_list_remove_pattern (itype, pattern, patspec, quoted)

-

5110

int itype;

-

5111

char *pattern;

-

5112

int patspec, quoted;

-

5113

{

-

5114

char *ret;

-

5115

WORD_LIST *list;

-

5116

-

5117

list = list_rest_of_args ();

-

5118

if (list == 0)

list == 0	Description
TRUE	never evaluated
FALSE	evaluated 61 times by 1 test Evaluated by: Self test

0-61

5119

return ((char *)NULL);

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

0

5120

ret = list_remove_pattern (list, pattern, patspec, itype, quoted);

-

5121

dispose_words (list);

-

5122

return (ret);

executed 61 times by 1 test: return (ret);

Executed by:

Self test

61

5123

}

-

5124

-

5125

#if defined (ARRAY_VARS)

-

5126

static char *

-

5127

array_remove_pattern (var, pattern, patspec, varname, quoted)

-

5128

SHELL_VAR *var;

-

5129

char *pattern;

-

5130

int patspec;

-

5131

char *varname; /* so we can figure out how it's indexed */

-

5132

int quoted;

-

5133

{

-

5134

ARRAY *a;

-

5135

HASH_TABLE *h;

-

5136

int itype;

-

5137

char *ret;

-

5138

WORD_LIST *list;

-

5139

SHELL_VAR *v;

-

5140

-

5141

/* compute itype from varname here */

-

5142

v = array_variable_part (varname, 0, &ret, 0);

-

5143

-

5144

/* XXX */

-

5145

if (v && invisible_p (v))

v	Description
TRUE	evaluated 67 times by 1 test Evaluated by: Self test
FALSE	never evaluated

((((v)->attrib... (0x0001000)))	Description
TRUE	never evaluated
FALSE	evaluated 67 times by 1 test Evaluated by: Self test

0-67

5146

return ((char *)NULL);

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

0

5147

-

5148

itype = ret[0];

-

5149

-

5150

a = (v && array_p (v)) ? array_cell (v) : 0;

v	Description
TRUE	evaluated 67 times by 1 test Evaluated by: Self test
FALSE	never evaluated

((((v)->attrib... (0x0000004)))	Description
TRUE	evaluated 57 times by 1 test Evaluated by: Self test
FALSE	evaluated 10 times by 1 test Evaluated by: Self test

0-67

5151

h = (v && assoc_p (v)) ? assoc_cell (v) : 0;

v	Description
TRUE	evaluated 67 times by 1 test Evaluated by: Self test
FALSE	never evaluated

((((v)->attrib... (0x0000040)))	Description
TRUE	evaluated 10 times by 1 test Evaluated by: Self test
FALSE	evaluated 57 times by 1 test Evaluated by: Self test

0-67

5152

-

5153

list = a ? array_to_word_list (a) : (h ? assoc_to_word_list (h) : 0);

a	Description
TRUE	evaluated 57 times by 1 test Evaluated by: Self test
FALSE	evaluated 10 times by 1 test Evaluated by: Self test

h	Description
TRUE	evaluated 10 times by 1 test Evaluated by: Self test
FALSE	never evaluated

0-57

5154

if (list == 0)

list == 0	Description
TRUE	never evaluated
FALSE	evaluated 67 times by 1 test Evaluated by: Self test

0-67

5155

return ((char *)NULL);

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

0

5156

ret = list_remove_pattern (list, pattern, patspec, itype, quoted);

-

5157

dispose_words (list);

-

5158

-

5159

return ret;

executed 67 times by 1 test: return ret;

Executed by:

Self test

67

5160

}

-

5161

#endif /* ARRAY_VARS */

-

5162

-

5163

static char *

-

5164

parameter_brace_remove_pattern (varname, value, ind, patstr, rtype, quoted, flags)

-

5165

char *varname, *value;

-

5166

int ind;

-

5167

char *patstr;

-

5168

int rtype, quoted, flags;

-

5169

{

-

5170

int vtype, patspec, starsub;

-

5171

char *temp1, *val, *pattern, *oname;

-

5172

SHELL_VAR *v;

-

5173

-

5174

if (value == 0)

value == 0	Description
TRUE	never evaluated
FALSE	evaluated 2315818 times by 1 test Evaluated by: Self test

0-2315818

5175

return ((char *)NULL);

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

0

5176

-

5177

oname = this_command_name;

-

5178

this_command_name = varname;

-

5179

-

5180

vtype = get_var_and_type (varname, value, ind, quoted, flags, &v, &val);

-

5181

if (vtype == -1)

vtype == -1	Description
TRUE	never evaluated
FALSE	evaluated 2315818 times by 1 test Evaluated by: Self test

0-2315818

5182

{

-

5183

this_command_name = oname;

-

5184

return ((char *)NULL);

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

0

5185

}

-

5186

-

5187

starsub = vtype & VT_STARSUB;

-

5188

vtype &= ~VT_STARSUB;

-

5189

-

5190

patspec = getpatspec (rtype, patstr);

-

5191

if (patspec == RP_LONG_LEFT || patspec == RP_LONG_RIGHT)

patspec == 1	Description
TRUE	evaluated 111 times by 1 test Evaluated by: Self test
FALSE	evaluated 2315707 times by 1 test Evaluated by: Self test

patspec == 3	Description
TRUE	evaluated 108 times by 1 test Evaluated by: Self test
FALSE	evaluated 2315599 times by 1 test Evaluated by: Self test

108-2315707

5192

patstr++;

executed 219 times by 1 test: patstr++;

Executed by:

Self test

219

5193

-

5194

/* Need to pass getpattern newly-allocated memory in case of expansion --

-

5195

the expansion code will free the passed string on an error. */

-

5196

temp1 = savestring (patstr);

-

5197

pattern = getpattern (temp1, quoted, 1);

-

5198

free (temp1);

-

5199

-

5200

temp1 = (char *)NULL; /* shut up gcc */

-

5201

switch (vtype)

-

5202

{

-

5203

case VT_VARIABLE:

executed 2315641 times by 1 test: case 0:

Executed by:

Self test

2315641

5204

case VT_ARRAYMEMBER:

executed 49 times by 1 test: case 3:

Executed by:

Self test

49

5205

temp1 = remove_pattern (val, pattern, patspec);

-

5206

if (vtype == VT_VARIABLE)

vtype == 0	Description
TRUE	evaluated 2315641 times by 1 test Evaluated by: Self test
FALSE	evaluated 49 times by 1 test Evaluated by: Self test

49-2315641

5207

FREE (val);

executed 2315641 times by 1 test: sh_xfree((val), "subst.c", 5207);

Executed by:

Self test

executed 2315641 times by 1 test: end of block

Executed by:

Self test

val	Description
TRUE	evaluated 2315641 times by 1 test Evaluated by: Self test
FALSE	never evaluated

0-2315641

5208

if (temp1)

temp1	Description
TRUE	evaluated 2315690 times by 1 test Evaluated by: Self test
FALSE	never evaluated

0-2315690

5209

{

-

5210

val = (quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES))

(quoted & (0x002\|0x001))	Description
TRUE	evaluated 140 times by 1 test Evaluated by: Self test
FALSE	evaluated 2315550 times by 1 test Evaluated by: Self test

140-2315550

5211

? quote_string (temp1)

-

5212

: quote_escapes (temp1);

-

5213

free (temp1);

-

5214

temp1 = val;

-

5215

}

executed 2315690 times by 1 test: end of block

Executed by:

Self test

2315690

5216

break;

executed 2315690 times by 1 test: break;

Executed by:

Self test

2315690

5217

#if defined (ARRAY_VARS)

-

5218

case VT_ARRAYVAR:

executed 67 times by 1 test: case 2:

Executed by:

Self test

67

5219

temp1 = array_remove_pattern (v, pattern, patspec, varname, quoted);

-

5220

if (temp1 && ((quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)) == 0))

temp1	Description
TRUE	evaluated 67 times by 1 test Evaluated by: Self test
FALSE	never evaluated

((quoted & (0x...\|0x001)) == 0)	Description
TRUE	evaluated 55 times by 1 test Evaluated by: Self test
FALSE	evaluated 12 times by 1 test Evaluated by: Self test

0-67

5221

{

-

5222

val = quote_escapes (temp1);

-

5223

free (temp1);

-

5224

temp1 = val;

-

5225

}

executed 55 times by 1 test: end of block

Executed by:

Self test

55

5226

break;

executed 67 times by 1 test: break;

Executed by:

Self test

67

5227

#endif

-

5228

case VT_POSPARMS:

executed 61 times by 1 test: case 1:

Executed by:

Self test

61

5229

temp1 = parameter_list_remove_pattern (varname[0], pattern, patspec, quoted);

-

5230

if (temp1 && quoted == 0 && ifs_is_null)

temp1	Description
TRUE	evaluated 61 times by 1 test Evaluated by: Self test
FALSE	never evaluated

quoted == 0	Description
TRUE	evaluated 46 times by 1 test Evaluated by: Self test
FALSE	evaluated 15 times by 1 test Evaluated by: Self test

ifs_is_null	Description
TRUE	evaluated 2 times by 1 test Evaluated by: Self test
FALSE	evaluated 44 times by 1 test Evaluated by: Self test

0-61

5231

{

-

5232

/* Posix interp 888 */

-

5233

}

executed 2 times by 1 test: end of block

Executed by:

Self test

2

5234

else if (temp1 && ((quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)) == 0))

temp1	Description
TRUE	evaluated 59 times by 1 test Evaluated by: Self test
FALSE	never evaluated

((quoted & (0x...\|0x001)) == 0)	Description
TRUE	evaluated 44 times by 1 test Evaluated by: Self test
FALSE	evaluated 15 times by 1 test Evaluated by: Self test

0-59

5235

{

-

5236

val = quote_escapes (temp1);

-

5237

free (temp1);

-

5238

temp1 = val;

-

5239

}

executed 44 times by 1 test: end of block

Executed by:

Self test

44

5240

break;

executed 61 times by 1 test: break;

Executed by:

Self test

61

5241

}

-

5242

-

5243

this_command_name = oname;

-

5244

-

5245

FREE (pattern);

executed 2315815 times by 1 test: sh_xfree((pattern), "subst.c", 5245);

Executed by:

Self test

pattern	Description
TRUE	evaluated 2315815 times by 1 test Evaluated by: Self test
FALSE	evaluated 3 times by 1 test Evaluated by: Self test

3-2315815

5246

return temp1;

executed 2315818 times by 1 test: return temp1;

Executed by:

Self test

2315818

5247

}

-

5248

-

5249

#if defined (PROCESS_SUBSTITUTION)

-

5250

-

5251

/*****************************************************************/

-

5252

/* */

-

5253

/* Hacking Process Substitution */

-

5254

/* */

-

5255

/*****************************************************************/

-

5256

-

5257

#if !defined (HAVE_DEV_FD)

-

5258

/* Named pipes must be removed explicitly with `unlink'. This keeps a list

-

5259

of FIFOs the shell has open. unlink_fifo_list will walk the list and

-

5260

unlink all of them. add_fifo_list adds the name of an open FIFO to the

-

5261

list. NFIFO is a count of the number of FIFOs in the list. */

-

5262

#define FIFO_INCR 20

-

5263

-

5264

/* PROC value of -1 means the process has been reaped and the FIFO needs to

-

5265

be removed. PROC value of 0 means the slot is unused. */

-

5266

struct temp_fifo {

-

5267

char *file;

-

5268

pid_t proc;

-

5269

};

-

5270

-

5271

static struct temp_fifo *fifo_list = (struct temp_fifo *)NULL;

-

5272

static int nfifo;

-

5273

static int fifo_list_size;

-

5274

-

5275

void

-

5276

clear_fifo_list ()

-

5277

{

-

5278

}

-

5279

-

5280

char *

-

5281

copy_fifo_list (sizep)

-

5282

int *sizep;

-

5283

{

-

5284

if (sizep)

-

5285

*sizep = 0;

-

5286

return (char *)NULL;

-

5287

}

-

5288

-

5289

static void

-

5290

add_fifo_list (pathname)

-

5291

char *pathname;

-

5292

{

-

5293

int osize, i;

-

5294

-

5295

if (nfifo >= fifo_list_size - 1)

-

5296

{

-

5297

osize = fifo_list_size;

-

5298

fifo_list_size += FIFO_INCR;

-

5299

fifo_list = (struct temp_fifo *)xrealloc (fifo_list,

-

5300

fifo_list_size * sizeof (struct temp_fifo));

-

5301

for (i = osize; i < fifo_list_size; i++)

-

5302

{

-

5303

fifo_list[i].file = (char *)NULL;

-

5304

fifo_list[i].proc = 0; /* unused */

-

5305

}

-

5306

}

-

5307

-

5308

fifo_list[nfifo].file = savestring (pathname);

-

5309

nfifo++;

-

5310

}

-

5311

-

5312

void

-

5313

unlink_fifo (i)

-

5314

int i;

-

5315

{

-

5316

if ((fifo_list[i].proc == (pid_t)-1) || (fifo_list[i].proc > 0 && (kill(fifo_list[i].proc, 0) == -1)))

-

5317

{

-

5318

unlink (fifo_list[i].file);

-

5319

free (fifo_list[i].file);

-

5320

fifo_list[i].file = (char *)NULL;

-

5321

fifo_list[i].proc = 0;

-

5322

}

-

5323

}

-

5324

-

5325

void

-

5326

unlink_fifo_list ()

-

5327

{

-

5328

int saved, i, j;

-

5329

-

5330

if (nfifo == 0)

-

5331

return;

-

5332

-

5333

for (i = saved = 0; i < nfifo; i++)

-

5334

{

-

5335

if ((fifo_list[i].proc == (pid_t)-1) || (fifo_list[i].proc > 0 && (kill(fifo_list[i].proc, 0) == -1)))

-

5336

{

-

5337

unlink (fifo_list[i].file);

-

5338

free (fifo_list[i].file);

-

5339

fifo_list[i].file = (char *)NULL;

-

5340

fifo_list[i].proc = 0;

-

5341

}

-

5342

else

-

5343

saved++;

-

5344

}

-

5345

-

5346

/* If we didn't remove some of the FIFOs, compact the list. */

-

5347

if (saved)

-

5348

{

-

5349

for (i = j = 0; i < nfifo; i++)

-

5350

if (fifo_list[i].file)

-

5351

{

-

5352

fifo_list[j].file = fifo_list[i].file;

-

5353

fifo_list[j].proc = fifo_list[i].proc;

-

5354

j++;

-

5355

}

-

5356

nfifo = j;

-

5357

}

-

5358

else

-

5359

nfifo = 0;

-

5360

}

-

5361

-

5362

/* Take LIST, which is a bitmap denoting active FIFOs in fifo_list

-

5363

from some point in the past, and close all open FIFOs in fifo_list

-

5364

that are not marked as active in LIST. If LIST is NULL, close

-

5365

everything in fifo_list. LSIZE is the number of elements in LIST, in

-

5366

case it's larger than fifo_list_size (size of fifo_list). */

-

5367

void

-

5368

close_new_fifos (list, lsize)

-

5369

char *list;

-

5370

int lsize;

-

5371

{

-

5372

int i;

-

5373

-

5374

if (list == 0)

-

5375

{

-

5376

unlink_fifo_list ();

-

5377

return;

-

5378

}

-

5379

-

5380

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

-

5381

if (list[i] == 0 && i < fifo_list_size && fifo_list[i].proc != -1)

-

5382

unlink_fifo (i);

-

5383

-

5384

for (i = lsize; i < fifo_list_size; i++)

-

5385

unlink_fifo (i);

-

5386

}

-

5387

-

5388

int

-

5389

find_procsub_child (pid)

-

5390

pid_t pid;

-

5391

{

-

5392

int i;

-

5393

-

5394

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

-

5395

if ((fifo_list[i].proc == pid)

-

5396

return i;

-

5397

return -1;

-

5398

}

-

5399

-

5400

void

-

5401

set_procsub_status (ind, pid, status)

-

5402

int ind;

-

5403

pid_t pid;

-

5404

int status;

-

5405

{

-

5406

if (ind >= 0 && ind < nfifo)

-

5407

fifo_list[ind].proc = (pid_t)-1; /* sentinel */

-

5408

}

-

5409

-

5410

/* If we've marked the process for this procsub as dead, close the

-

5411

associated file descriptor and delete the FIFO. */

-

5412

void

-

5413

reap_procsubs ()

-

5414

{

-

5415

int i;

-

5416

-

5417

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

-

5418

if (fifo_list[i].proc == (pid_t)-1) /* reaped */

-

5419

unlink_fifo (i);

-

5420

}

-

5421

-

5422

void

-

5423

wait_procsubs ()

-

5424

{

-

5425

int i;

-

5426

-

5427

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

-

5428

{

-

5429

if (fifo_list[i].proc != (pid_t)-1 && fifo_list[i].proc > 0)

-

5430

{

-

5431

r = wait_for (fifo_list[i].proc);

-

5432

fifo_list[i].proc = (pid_t)-1;

-

5433

}

-

5434

}

-

5435

}

-

5436

-

5437

int

-

5438

fifos_pending ()

-

5439

{

-

5440

return nfifo;

-

5441

}

-

5442

-

5443

int

-

5444

num_fifos ()

-

5445

{

-

5446

return nfifo;

-

5447

}

-

5448

-

5449

static char *

-

5450

make_named_pipe ()

-

5451

{

-

5452

char *tname;

-

5453

-

5454

tname = sh_mktmpname ("sh-np", MT_USERANDOM|MT_USETMPDIR);

-

5455

if (mkfifo (tname, 0600) < 0)

-

5456

{

-

5457

free (tname);

-

5458

return ((char *)NULL);

-

5459

}

-

5460

-

5461

add_fifo_list (tname);

-

5462

return (tname);

-

5463

}

-

5464

-

5465

#else /* HAVE_DEV_FD */

-

5466

-

5467

/* DEV_FD_LIST is a bitmap of file descriptors attached to pipes the shell

-

5468

has open to children. NFDS is a count of the number of bits currently

-

5469

set in DEV_FD_LIST. TOTFDS is a count of the highest possible number

-

5470

of open files. */

-

5471

/* dev_fd_list[I] value of -1 means the process has been reaped and file

-

5472

descriptor I needs to be closed. Value of 0 means the slot is unused. */

-

5473

-

5474

static pid_t *dev_fd_list = (pid_t *)NULL;

-

5475

static int nfds;

-

5476

static int totfds; /* The highest possible number of open files. */

-

5477

-

5478

void

-

5479

clear_fifo (i)

-

5480

int i;

-

5481

{

-

5482

if (dev_fd_list[i])

dev_fd_list[i]	Description
TRUE	never evaluated
FALSE	never evaluated

0

5483

{

-

5484

dev_fd_list[i] = 0;

-

5485

nfds--;

-

5486

}

never executed: end of block

0

5487

}

never executed: end of block

0

5488

-

5489

void

-

5490

clear_fifo_list ()

-

5491

{

-

5492

register int i;

-

5493

-

5494

if (nfds == 0)

nfds == 0	Description
TRUE	evaluated 15 times by 1 test Evaluated by: Self test
FALSE	never evaluated

0-15

5495

return;

executed 15 times by 1 test: return;

Executed by:

Self test

15

5496

-

5497

for (i = 0; nfds && i < totfds; i++)

nfds	Description
TRUE	never evaluated
FALSE	never evaluated

i < totfds	Description
TRUE	never evaluated
FALSE	never evaluated

0

5498

clear_fifo (i);

never executed: clear_fifo (i);

0

5499

-

5500

nfds = 0;

-

5501

}

never executed: end of block

0

5502

-

5503

char *

-

5504

copy_fifo_list (sizep)

-

5505

int *sizep;

-

5506

{

-

5507

char *ret;

-

5508

-

5509

if (nfds == 0 || totfds == 0)

nfds == 0	Description
TRUE	evaluated 195669801 times by 1 test Evaluated by: Self test
FALSE	evaluated 4001512 times by 1 test Evaluated by: Self test

totfds == 0	Description
TRUE	never evaluated
FALSE	evaluated 4001512 times by 1 test Evaluated by: Self test

0-195669801

5510

{

-

5511

if (sizep)

sizep	Description
TRUE	evaluated 195669801 times by 1 test Evaluated by: Self test
FALSE	never evaluated

0-195669801

5512

*sizep = 0;

executed 195669801 times by 1 test: *sizep = 0;

Executed by:

Self test

195669801

5513

return (char *)NULL;

executed 195669801 times by 1 test: return (char *) ((void *)0) ;

Executed by:

Self test

195669801

5514

}

-

5515

-

5516

if (sizep)

sizep	Description
TRUE	evaluated 4001512 times by 1 test Evaluated by: Self test
FALSE	never evaluated

0-4001512

5517

*sizep = totfds;

executed 4001512 times by 1 test: *sizep = totfds;

Executed by:

Self test

4001512

5518

ret = (char *)xmalloc (totfds * sizeof (pid_t));

-

5519

return (memcpy (ret, dev_fd_list, totfds * sizeof (pid_t)));

executed 4001512 times by 1 test: return (memcpy (ret, dev_fd_list, totfds * sizeof (pid_t)));

Executed by:

Self test

4001512

5520

}

-

5521

-

5522

static void

-

5523

add_fifo_list (fd)

-

5524

int fd;

-

5525

{

-

5526

if (dev_fd_list == 0 || fd >= totfds)

dev_fd_list == 0	Description
TRUE	evaluated 1399 times by 1 test Evaluated by: Self test
FALSE	evaluated 677645 times by 1 test Evaluated by: Self test

fd >= totfds	Description
TRUE	never evaluated
FALSE	evaluated 677645 times by 1 test Evaluated by: Self test

0-677645

5527

{

-

5528

int ofds;

-

5529

-

5530

ofds = totfds;

-

5531

totfds = getdtablesize ();

-

5532

if (totfds < 0 || totfds > 256)

totfds < 0	Description
TRUE	never evaluated
FALSE	evaluated 1399 times by 1 test Evaluated by: Self test

totfds > 256	Description
TRUE	evaluated 1170 times by 1 test Evaluated by: Self test
FALSE	evaluated 229 times by 1 test Evaluated by: Self test

0-1399

5533

totfds = 256;

executed 1170 times by 1 test: totfds = 256;

Executed by:

Self test

1170

5534

if (fd >= totfds)

fd >= totfds	Description
TRUE	never evaluated
FALSE	evaluated 1399 times by 1 test Evaluated by: Self test

0-1399

5535

totfds = fd + 2;

never executed: totfds = fd + 2;

0

5536

-

5537

dev_fd_list = (pid_t *)xrealloc (dev_fd_list, totfds * sizeof (dev_fd_list[0]));

-

5538

/* XXX - might need a loop for this */

-

5539

memset (dev_fd_list + ofds, '\0', (totfds - ofds) * sizeof (pid_t));

-

5540

}

executed 1399 times by 1 test: end of block

Executed by:

Self test

1399

5541

-

5542

dev_fd_list[fd] = 1; /* marker; updated later */

-

5543

nfds++;

-

5544

}

executed 679044 times by 1 test: end of block

Executed by:

Self test

679044

5545

-

5546

int

-

5547

fifos_pending ()

-

5548

{

-

5549

return 0; /* used for cleanup; not needed with /dev/fd */

executed 10 times by 1 test: return 0;

Executed by:

Self test

10

5550

}

-

5551

-

5552

int

-

5553

num_fifos ()

-

5554

{

-

5555

return nfds;

executed 399301301 times by 1 test: return nfds;

Executed by:

Self test

399301301

5556

}

-

5557

-

5558

void

-

5559

unlink_fifo (fd)

-

5560

int fd;

-

5561

{

-

5562

if (dev_fd_list[fd])

dev_fd_list[fd]	Description
TRUE	evaluated 677655 times by 1 test Evaluated by: Self test
FALSE	evaluated 126333184 times by 1 test Evaluated by: Self test

677655-126333184

5563

{

-

5564

close (fd);

-

5565

dev_fd_list[fd] = 0;

-

5566

nfds--;

-

5567

}

executed 677655 times by 1 test: end of block

Executed by:

Self test

677655

5568

}

executed 127010839 times by 1 test: end of block

Executed by:

Self test

127010839

5569

-

5570

void

-

5571

unlink_fifo_list ()

-

5572

{

-

5573

register int i;

-

5574

-

5575

if (nfds == 0)

nfds == 0	Description
TRUE	evaluated 1942537 times by 1 test Evaluated by: Self test
FALSE	evaluated 675388 times by 1 test Evaluated by: Self test

675388-1942537

5576

return;

executed 1942537 times by 1 test: return;

Executed by:

Self test

1942537

5577

-

5578

for (i = totfds-1; nfds && i >= 0; i--)

nfds	Description
TRUE	evaluated 127010842 times by 1 test Evaluated by: Self test
FALSE	evaluated 675384 times by 1 test Evaluated by: Self test

i >= 0	Description
TRUE	evaluated 127010838 times by 1 test Evaluated by: Self test
FALSE	evaluated 4 times by 1 test Evaluated by: Self test

4-127010842

5579

unlink_fifo (i);

executed 127010838 times by 1 test: unlink_fifo (i);

Executed by:

Self test

127010838

5580

-

5581

nfds = 0;

-

5582

}

executed 675388 times by 1 test: end of block

Executed by:

Self test

675388

5583

-

5584

/* Take LIST, which is a snapshot copy of dev_fd_list from some point in

-

5585

the past, and close all open fds in dev_fd_list that are not marked

-

5586

as open in LIST. If LIST is NULL, close everything in dev_fd_list.

-

5587

LSIZE is the number of elements in LIST, in case it's larger than

-

5588

totfds (size of dev_fd_list). */

-

5589

void

-

5590

close_new_fifos (list, lsize)

-

5591

char *list;

-

5592

int lsize;

-

5593

{

-

5594

int i;

-

5595

-

5596

if (list == 0)

list == 0	Description
TRUE	evaluated 660612 times by 1 test Evaluated by: Self test
FALSE	evaluated 1 time by 1 test Evaluated by: Self test

1-660612

5597

{

-

5598

unlink_fifo_list ();

-

5599

return;

executed 660612 times by 1 test: return;

Executed by:

Self test

660612

5600

}

-

5601

-

5602

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

i < lsize	Description
TRUE	evaluated 256 times by 1 test Evaluated by: Self test
FALSE	evaluated 1 time by 1 test Evaluated by: Self test

1-256

5603

if (list[i] == 0 && i < totfds && dev_fd_list[i])

list[i] == 0	Description
TRUE	evaluated 256 times by 1 test Evaluated by: Self test
FALSE	never evaluated

i < totfds	Description
TRUE	evaluated 256 times by 1 test Evaluated by: Self test
FALSE	never evaluated

dev_fd_list[i]	Description
TRUE	evaluated 1 time by 1 test Evaluated by: Self test
FALSE	evaluated 255 times by 1 test Evaluated by: Self test

0-256

5604

unlink_fifo (i);

executed 1 time by 1 test: unlink_fifo (i);

Executed by:

Self test

1

5605

-

5606

for (i = lsize; i < totfds; i++)

i < totfds	Description
TRUE	never evaluated
FALSE	evaluated 1 time by 1 test Evaluated by: Self test

0-1

5607

unlink_fifo (i);

never executed: unlink_fifo (i);

0

5608

}

executed 1 time by 1 test: end of block

Executed by:

Self test

1

5609

-

5610

int

-

5611

find_procsub_child (pid)

-

5612

pid_t pid;

-

5613

{

-

5614

int i;

-

5615

-

5616

if (nfds == 0)

nfds == 0	Description
TRUE	evaluated 3285888 times by 1 test Evaluated by: Self test
FALSE	evaluated 699943 times by 1 test Evaluated by: Self test

699943-3285888

5617

return -1;

executed 3285888 times by 1 test: return -1;

Executed by:

Self test

3285888

5618

-

5619

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

i < totfds	Description
TRUE	evaluated 86753058 times by 1 test Evaluated by: Self test
FALSE	evaluated 223925 times by 1 test Evaluated by: Self test

223925-86753058

5620

if (dev_fd_list[i] == pid)

dev_fd_list[i] == pid	Description
TRUE	evaluated 476018 times by 1 test Evaluated by: Self test
FALSE	evaluated 86277040 times by 1 test Evaluated by: Self test

476018-86277040

5621

return i;

executed 476018 times by 1 test: return i;

Executed by:

Self test

476018

5622

-

5623

return -1;

executed 223925 times by 1 test: return -1;

Executed by:

Self test

223925

5624

}

-

5625

-

5626

void

-

5627

set_procsub_status (ind, pid, status)

-

5628

int ind;

-

5629

pid_t pid;

-

5630

int status;

-

5631

{

-

5632

if (ind >= 0 && ind < totfds)

ind >= 0	Description
TRUE	evaluated 476018 times by 1 test Evaluated by: Self test
FALSE	never evaluated

ind < totfds	Description
TRUE	evaluated 476018 times by 1 test Evaluated by: Self test
FALSE	never evaluated

0-476018

5633

dev_fd_list[ind] = (pid_t)-1; /* sentinel */

executed 476018 times by 1 test: dev_fd_list[ind] = (pid_t)-1;

Executed by:

Self test

476018

5634

}

executed 476018 times by 1 test: end of block

Executed by:

Self test

476018

5635

-

5636

/* If we've marked the process for this procsub as dead, close the

-

5637

associated file descriptor. */

-

5638

void

-

5639

reap_procsubs ()

-

5640

{

-

5641

int i;

-

5642

-

5643

for (i = 0; nfds > 0 && i < totfds; i++)

nfds > 0	Description
TRUE	never evaluated
FALSE	evaluated 138 times by 1 test Evaluated by: Self test

i < totfds	Description
TRUE	never evaluated
FALSE	never evaluated

0-138

5644

if (dev_fd_list[i] == (pid_t)-1)

dev_fd_list[i] == (pid_t)-1	Description
TRUE	never evaluated
FALSE	never evaluated

0

5645

unlink_fifo (i);

never executed: unlink_fifo (i);

0

5646

}

executed 138 times by 1 test: end of block

Executed by:

Self test

138

5647

-

5648

void

-

5649

wait_procsubs ()

-

5650

{

-

5651

int i, r;

-

5652

-

5653

for (i = 0; nfds > 0 && i < totfds; i++)

nfds > 0	Description
TRUE	never evaluated
FALSE	evaluated 138 times by 1 test Evaluated by: Self test

i < totfds	Description
TRUE	never evaluated
FALSE	never evaluated

0-138

5654

{

-

5655

if (dev_fd_list[i] != (pid_t)-1 && dev_fd_list[i] > 0)

dev_fd_list[i] != (pid_t)-1	Description
TRUE	never evaluated
FALSE	never evaluated

dev_fd_list[i] > 0	Description
TRUE	never evaluated
FALSE	never evaluated

0

5656

{

-

5657

r = wait_for (dev_fd_list[i]);

-

5658

dev_fd_list[i] = (pid_t)-1;

-

5659

}

never executed: end of block

0

5660

}

never executed: end of block

0

5661

}

executed 138 times by 1 test: end of block

Executed by:

Self test

138

5662

-

5663

#if defined (NOTDEF)

-

5664

print_dev_fd_list ()

-

5665

{

-

5666

register int i;

-

5667

-

5668

fprintf (stderr, "pid %ld: dev_fd_list:", (long)getpid ());

-

5669

fflush (stderr);

-

5670

-

5671

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

-

5672

{

-

5673

if (dev_fd_list[i])

-

5674

fprintf (stderr, " %d", i);

-

5675

}

-

5676

fprintf (stderr, "\n");

-

5677

}

-

5678

#endif /* NOTDEF */

-

5679

-

5680

static char *

-

5681

make_dev_fd_filename (fd)

-

5682

int fd;

-

5683

{

-

5684

char *ret, intbuf[INT_STRLEN_BOUND (int) + 1], *p;

-

5685

-

5686

ret = (char *)xmalloc (sizeof (DEV_FD_PREFIX) + 8);

-

5687

-

5688

strcpy (ret, DEV_FD_PREFIX);

-

5689

p = inttostr (fd, intbuf, sizeof (intbuf));

-

5690

strcpy (ret + sizeof (DEV_FD_PREFIX) - 1, p);

-

5691

-

5692

add_fifo_list (fd);

-

5693

return (ret);

executed 679044 times by 1 test: return (ret);

Executed by:

Self test

679044

5694

}

-

5695

-

5696

#endif /* HAVE_DEV_FD */

-

5697

-

5698

/* Return a filename that will open a connection to the process defined by

-

5699

executing STRING. HAVE_DEV_FD, if defined, means open a pipe and return

-

5700

a filename in /dev/fd corresponding to a descriptor that is one of the

-

5701

ends of the pipe. If not defined, we use named pipes on systems that have

-

5702

them. Systems without /dev/fd and named pipes are out of luck.

-

5703

-

5704

OPEN_FOR_READ_IN_CHILD, if 1, means open the named pipe for reading or

-

5705

use the read end of the pipe and dup that file descriptor to fd 0 in

-

5706

the child. If OPEN_FOR_READ_IN_CHILD is 0, we open the named pipe for

-

5707

writing or use the write end of the pipe in the child, and dup that

-

5708

file descriptor to fd 1 in the child. The parent does the opposite. */

-

5709

-

5710

static char *

-

5711

process_substitute (string, open_for_read_in_child)

-

5712

char *string;

-

5713

int open_for_read_in_child;

-

5714

{

-

5715

char *pathname;

-

5716

int fd, result;

-

5717

pid_t old_pid, pid;

-

5718

#if defined (HAVE_DEV_FD)

-

5719

int parent_pipe_fd, child_pipe_fd;

-

5720

int fildes[2];

-

5721

#endif /* HAVE_DEV_FD */

-

5722

#if defined (JOB_CONTROL)

-

5723

pid_t old_pipeline_pgrp;

-

5724

#endif

-

5725

-

5726

if (!string || !*string || wordexp_only)

!string	Description
TRUE	never evaluated
FALSE	evaluated 679044 times by 1 test Evaluated by: Self test

!*string	Description
TRUE	never evaluated
FALSE	evaluated 679044 times by 1 test Evaluated by: Self test

wordexp_only	Description
TRUE	never evaluated
FALSE	evaluated 679044 times by 1 test Evaluated by: Self test

0-679044

5727

return ((char *)NULL);

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

0

5728

-

5729

#if !defined (HAVE_DEV_FD)

-

5730

pathname = make_named_pipe ();

-

5731

#else /* HAVE_DEV_FD */

-

5732

if (pipe (fildes) < 0)

pipe (fildes) < 0	Description
TRUE	never evaluated
FALSE	evaluated 679044 times by 1 test Evaluated by: Self test

0-679044

5733

{

-

5734

sys_error ("%s", _("cannot make pipe for process substitution"));

-

5735

return ((char *)NULL);

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

0

5736

}

-

5737

/* If OPEN_FOR_READ_IN_CHILD == 1, we want to use the write end of

-

5738

the pipe in the parent, otherwise the read end. */

-

5739

parent_pipe_fd = fildes[open_for_read_in_child];

-

5740

child_pipe_fd = fildes[1 - open_for_read_in_child];

-

5741

/* Move the parent end of the pipe to some high file descriptor, to

-

5742

avoid clashes with FDs used by the script. */

-

5743

parent_pipe_fd = move_to_high_fd (parent_pipe_fd, 1, 64);

-

5744

-

5745

pathname = make_dev_fd_filename (parent_pipe_fd);

-

5746

#endif /* HAVE_DEV_FD */

-

5747

-

5748

if (pathname == 0)

pathname == 0	Description
TRUE	never evaluated
FALSE	evaluated 679044 times by 1 test Evaluated by: Self test

0-679044

5749

{

-

5750

sys_error ("%s", _("cannot make pipe for process substitution"));

-

5751

return ((char *)NULL);

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

0

5752

}

-

5753

-

5754

old_pid = last_made_pid;

-

5755

-

5756

#if defined (JOB_CONTROL)

-

5757

old_pipeline_pgrp = pipeline_pgrp;

-

5758

if (pipeline_pgrp == 0 || (subshell_environment & (SUBSHELL_PIPE|SUBSHELL_FORK|SUBSHELL_ASYNC)) == 0)

pipeline_pgrp == 0	Description
TRUE	evaluated 679041 times by 1 test Evaluated by: Self test
FALSE	evaluated 3 times by 1 test Evaluated by: Self test

(subshell_envi...08\|0x01)) == 0	Description
TRUE	never evaluated
FALSE	evaluated 3 times by 1 test Evaluated by: Self test

0-679041

5759

pipeline_pgrp = shell_pgrp;

executed 679041 times by 1 test: pipeline_pgrp = shell_pgrp;

Executed by:

Self test

679041

5760

save_pipeline (1);

-

5761

#endif /* JOB_CONTROL */

-

5762

-

5763

pid = make_child ((char *)NULL, 1);

-

5764

if (pid == 0)

pid == 0	Description
TRUE	evaluated 1384 times by 1 test Evaluated by: Self test
FALSE	evaluated 677660 times by 1 test Evaluated by: Self test

1384-677660

5765

{

-

5766

reset_terminating_signals (); /* XXX */

-

5767

free_pushed_string_input ();

-

5768

/* Cancel traps, in trap.c. */

-

5769

restore_original_signals (); /* XXX - what about special builtins? bash-4.2 */

-

5770

QUIT; /* catch any interrupts we got post-fork */

never executed: termsig_handler (terminating_signal);

never executed: throw_to_top_level ();

terminating_signal	Description
TRUE	never evaluated
FALSE	evaluated 1384 times by 1 test Evaluated by: Self test

interrupt_state	Description
TRUE	never evaluated
FALSE	evaluated 1384 times by 1 test Evaluated by: Self test

0-1384

5771

setup_async_signals ();

-

5772

subshell_environment |= SUBSHELL_COMSUB|SUBSHELL_PROCSUB;

-

5773

-

5774

/* We don't inherit the verbose option for command substitutions now, so

-

5775

let's try it for process substitutions. */

-

5776

change_flag ('v', FLAG_OFF);

-

5777

-

5778

/* if we're expanding a redirection, we shouldn't have access to the

-

5779

temporary environment, but commands in the subshell should have

-

5780

access to their own temporary environment. */

-

5781

if (expanding_redir)

expanding_redir	Description
TRUE	evaluated 1362 times by 1 test Evaluated by: Self test
FALSE	evaluated 22 times by 1 test Evaluated by: Self test

22-1362

5782

flush_temporary_env ();

executed 1362 times by 1 test: flush_temporary_env ();

Executed by:

Self test

1362

5783

}

executed 1384 times by 1 test: end of block

Executed by:

Self test

1384

5784

-

5785

#if defined (JOB_CONTROL)

-

5786

set_sigchld_handler ();

-

5787

stop_making_children ();

-

5788

/* XXX - should we only do this in the parent? (as in command subst) */

-

5789

pipeline_pgrp = old_pipeline_pgrp;

-

5790

#else

-

5791

stop_making_children ();

-

5792

#endif /* JOB_CONTROL */

-

5793

-

5794

if (pid < 0)

pid < 0	Description
TRUE	never evaluated
FALSE	evaluated 679044 times by 1 test Evaluated by: Self test

0-679044

5795

{

-

5796

sys_error ("%s", _("cannot make child for process substitution"));

-

5797

free (pathname);

-

5798

#if defined (HAVE_DEV_FD)

-

5799

close (parent_pipe_fd);

-

5800

close (child_pipe_fd);

-

5801

#endif /* HAVE_DEV_FD */

-

5802

#if defined (JOB_CONTROL)

-

5803

restore_pipeline (1);

-

5804

#endif

-

5805

return ((char *)NULL);

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

0

5806

}

-

5807

-

5808

if (pid > 0)

pid > 0	Description
TRUE	evaluated 677660 times by 1 test Evaluated by: Self test
FALSE	evaluated 1384 times by 1 test Evaluated by: Self test

1384-677660

5809

{

-

5810

#if defined (JOB_CONTROL)

-

5811

if (last_procsub_child)

last_procsub_child	Description
TRUE	evaluated 220153 times by 1 test Evaluated by: Self test
FALSE	evaluated 457507 times by 1 test Evaluated by: Self test

220153-457507

5812

discard_last_procsub_child ();

executed 220153 times by 1 test: discard_last_procsub_child ();

Executed by:

Self test

220153

5813

last_procsub_child = restore_pipeline (0);

-

5814

#endif

-

5815

-

5816

#if defined (HAVE_DEV_FD)

-

5817

dev_fd_list[parent_pipe_fd] = pid;

-

5818

#else

-

5819

fifo_list[nfifo-1].proc = pid;

-

5820

#endif

-

5821

-

5822

last_made_pid = old_pid;

-

5823

-

5824

#if defined (JOB_CONTROL) && defined (PGRP_PIPE)

-

5825

close_pgrp_pipe ();

-

5826

#endif /* JOB_CONTROL && PGRP_PIPE */

-

5827

-

5828

#if defined (HAVE_DEV_FD)

-

5829

close (child_pipe_fd);

-

5830

#endif /* HAVE_DEV_FD */

-

5831

-

5832

return (pathname);

executed 677660 times by 1 test: return (pathname);

Executed by:

Self test

677660

5833

}

-

5834

-

5835

set_sigint_handler ();

-

5836

-

5837

#if defined (JOB_CONTROL)

-

5838

set_job_control (0);

-

5839

#endif /* JOB_CONTROL */

-

5840

-

5841

#if !defined (HAVE_DEV_FD)

-

5842

/* Open the named pipe in the child. */

-

5843

fd = open (pathname, open_for_read_in_child ? O_RDONLY : O_WRONLY);

-

5844

if (fd < 0)

-

5845

{

-

5846

/* Two separate strings for ease of translation. */

-

5847

if (open_for_read_in_child)

-

5848

sys_error (_("cannot open named pipe %s for reading"), pathname);

-

5849

else

-

5850

sys_error (_("cannot open named pipe %s for writing"), pathname);

-

5851

-

5852

exit (127);

-

5853

}

-

5854

if (open_for_read_in_child)

-

5855

{

-

5856

if (sh_unset_nodelay_mode (fd) < 0)

-

5857

{

-

5858

sys_error (_("cannot reset nodelay mode for fd %d"), fd);

-

5859

exit (127);

-

5860

}

-

5861

}

-

5862

#else /* HAVE_DEV_FD */

-

5863

fd = child_pipe_fd;

-

5864

#endif /* HAVE_DEV_FD */

-

5865

-

5866

/* Discard buffered stdio output before replacing the underlying file

-

5867

descriptor. */

-

5868

if (open_for_read_in_child == 0)

open_for_read_in_child == 0	Description
TRUE	evaluated 1382 times by 1 test Evaluated by: Self test
FALSE	evaluated 2 times by 1 test Evaluated by: Self test

2-1382

5869

fpurge (stdout);

executed 1382 times by 1 test: fpurge ( stdout );

Executed by:

Self test

1382

5870

-

5871

if (dup2 (fd, open_for_read_in_child ? 0 : 1) < 0)

dup2 (fd, open...d ? 0 : 1) < 0	Description
TRUE	never evaluated
FALSE	evaluated 1384 times by 1 test Evaluated by: Self test

0-1384

5872

{

-

5873

sys_error (_("cannot duplicate named pipe %s as fd %d"), pathname,

-

5874

open_for_read_in_child ? 0 : 1);

-

5875

exit (127);

never executed: exit (127);

0

5876

}

-

5877

-

5878

if (fd != (open_for_read_in_child ? 0 : 1))

fd != (open_fo...child ? 0 : 1)	Description
TRUE	evaluated 1384 times by 1 test Evaluated by: Self test
FALSE	never evaluated

open_for_read_in_child	Description
TRUE	evaluated 2 times by 1 test Evaluated by: Self test
FALSE	evaluated 1382 times by 1 test Evaluated by: Self test

0-1384

5879

close (fd);

executed 1384 times by 1 test: close (fd);

Executed by:

Self test

1384

5880

-

5881

/* Need to close any files that this process has open to pipes inherited

-

5882

from its parent. */

-

5883

if (current_fds_to_close)

current_fds_to_close	Description
TRUE	evaluated 22 times by 1 test Evaluated by: Self test
FALSE	evaluated 1362 times by 1 test Evaluated by: Self test

22-1362

5884

{

-

5885

close_fd_bitmap (current_fds_to_close);

-

5886

current_fds_to_close = (struct fd_bitmap *)NULL;

-

5887

}

executed 22 times by 1 test: end of block

Executed by:

Self test

22

5888

-

5889

#if defined (HAVE_DEV_FD)

-

5890

/* Make sure we close the parent's end of the pipe and clear the slot

-

5891

in the fd list so it is not closed later, if reallocated by, for

-

5892

instance, pipe(2). */

-

5893

close (parent_pipe_fd);

-

5894

dev_fd_list[parent_pipe_fd] = 0;

-

5895

#endif /* HAVE_DEV_FD */

-

5896

-

5897

/* subshells shouldn't have this flag, which controls using the temporary

-

5898

environment for variable lookups. We have already flushed the temporary

-

5899

environment above in the case we're expanding a redirection, so processes

-

5900

executed by this command need to be able to set it independently of their

-

5901

parent. */

-

5902

expanding_redir = 0;

-

5903

-

5904

remove_quoted_escapes (string);

-

5905

-

5906

subshell_level++;

-

5907

result = parse_and_execute (string, "process substitution", (SEVAL_NONINT|SEVAL_NOHIST));

-

5908

/* leave subshell level intact for any exit trap */

-

5909

-

5910

#if !defined (HAVE_DEV_FD)

-

5911

/* Make sure we close the named pipe in the child before we exit. */

-

5912

close (open_for_read_in_child ? 0 : 1);

-

5913

#endif /* !HAVE_DEV_FD */

-

5914

-

5915

last_command_exit_value = result;

-

5916

result = run_exit_trap ();

-

5917

exit (result);

executed 1380 times by 1 test: exit (result);

Executed by:

Self test

1380

5918

/*NOTREACHED*/

-

5919

}

-

5920

#endif /* PROCESS_SUBSTITUTION */

-

5921

-

5922

/***********************************/

-

5923

/* */

-

5924

/* Command Substitution */

-

5925

/* */

-

5926

/***********************************/

-

5927

-

5928

static char *

-

5929

read_comsub (fd, quoted, flags, rflag)

-

5930

int fd, quoted, flags;

-

5931

int *rflag;

-

5932

{

-

5933

char *istring, buf[128], *bufp;

-

5934

int istring_index, c, tflag, skip_ctlesc, skip_ctlnul;

-

5935

size_t istring_size;

-

5936

ssize_t bufn;

-

5937

int nullbyte;

-

5938

-

5939

istring = (char *)NULL;

-

5940

istring_index = istring_size = bufn = tflag = 0;

-

5941

-

5942

skip_ctlesc = ifs_cmap[CTLESC];

-

5943

skip_ctlnul = ifs_cmap[CTLNUL];

-

5944

-

5945

nullbyte = 0;

-

5946

-

5947

/* Read the output of the command through the pipe. This may need to be

-

5948

changed to understand multibyte characters in the future. */

-

5949

while (1)

-

5950

{

-

5951

if (fd < 0)

fd < 0	Description
TRUE	never evaluated
FALSE	evaluated 31091420 times by 1 test Evaluated by: Self test

0-31091420

5952

break;

never executed: break;

0

5953

if (--bufn <= 0)

--bufn <= 0	Description
TRUE	evaluated 6510680 times by 1 test Evaluated by: Self test
FALSE	evaluated 24580740 times by 1 test Evaluated by: Self test

6510680-24580740

5954

{

-

5955

bufn = zread (fd, buf, sizeof (buf));

-

5956

if (bufn <= 0)

bufn <= 0	Description
TRUE	evaluated 3253577 times by 1 test Evaluated by: Self test
FALSE	evaluated 3257103 times by 1 test Evaluated by: Self test

3253577-3257103

5957

break;

executed 3253577 times by 1 test: break;

Executed by:

Self test

3253577

5958

bufp = buf;

-

5959

}

executed 3257103 times by 1 test: end of block

Executed by:

Self test

3257103

5960

c = *bufp++;

-

5961

-

5962

if (c == 0)

c == 0	Description
TRUE	never evaluated
FALSE	evaluated 27837843 times by 1 test Evaluated by: Self test

0-27837843

5963

{

-

5964

#if 1

-

5965

if (nullbyte == 0)

nullbyte == 0	Description
TRUE	never evaluated
FALSE	never evaluated

0

5966

{

-

5967

internal_warning ("%s", _("command substitution: ignored null byte in input"));

-

5968

nullbyte = 1;

-

5969

}

never executed: end of block

0

5970

#endif

-

5971

continue;

never executed: continue;

0

5972

}

-

5973

-

5974

/* Add the character to ISTRING, possibly after resizing it. */

-

5975

RESIZE_MALLOCED_BUFFER (istring, istring_index, 2, istring_size, DEFAULT_ARRAY_SIZE);

executed 3257517 times by 1 test: istring_size += (128);

Executed by:

Self test

executed 3257517 times by 1 test: end of block

Executed by:

Self test

(istring_index...= istring_size	Description
TRUE	evaluated 3257517 times by 1 test Evaluated by: Self test
FALSE	evaluated 24580326 times by 1 test Evaluated by: Self test

(istring_index...= istring_size	Description
TRUE	evaluated 3257517 times by 1 test Evaluated by: Self test
FALSE	evaluated 3257517 times by 1 test Evaluated by: Self test

3257517-24580326

5976

-

5977

/* This is essentially quote_string inline */

-

5978

if ((quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)) /* || c == CTLESC || c == CTLNUL */)

(quoted & (0x002\|0x001))	Description
TRUE	evaluated 104068 times by 1 test Evaluated by: Self test
FALSE	evaluated 27733775 times by 1 test Evaluated by: Self test

104068-27733775

5979

istring[istring_index++] = CTLESC;

executed 104068 times by 1 test: istring[istring_index++] = '\001';

Executed by:

Self test

104068

5980

else if ((flags & PF_ASSIGNRHS) && skip_ctlesc && c == CTLESC)

(flags & 0x08)	Description
TRUE	evaluated 14540 times by 1 test Evaluated by: Self test
FALSE	evaluated 27719235 times by 1 test Evaluated by: Self test

skip_ctlesc	Description
TRUE	never evaluated
FALSE	evaluated 14540 times by 1 test Evaluated by: Self test

c == '\001'	Description
TRUE	never evaluated
FALSE	never evaluated

0-27719235

5981

istring[istring_index++] = CTLESC;

never executed: istring[istring_index++] = '\001';

0

5982

/* Escape CTLESC and CTLNUL in the output to protect those characters

-

5983

from the rest of the word expansions (word splitting and globbing.)

-

5984

This is essentially quote_escapes inline. */

-

5985

else if (skip_ctlesc == 0 && c == CTLESC)

skip_ctlesc == 0	Description
TRUE	evaluated 27733604 times by 1 test Evaluated by: Self test
FALSE	evaluated 171 times by 1 test Evaluated by: Self test

c == '\001'	Description
TRUE	evaluated 237 times by 1 test Evaluated by: Self test
FALSE	evaluated 27733367 times by 1 test Evaluated by: Self test

171-27733604

5986

{

-

5987

tflag |= W_HASCTLESC;

-

5988

istring[istring_index++] = CTLESC;

-

5989

}

executed 237 times by 1 test: end of block

Executed by:

Self test

237

5990

else if ((skip_ctlnul == 0 && c == CTLNUL) || (c == ' ' && (ifs_value && *ifs_value == 0)))

skip_ctlnul == 0	Description
TRUE	evaluated 27733538 times by 1 test Evaluated by: Self test
FALSE	never evaluated

c == '\177'	Description
TRUE	evaluated 253 times by 1 test Evaluated by: Self test
FALSE	evaluated 27733285 times by 1 test Evaluated by: Self test

c == ' '	Description
TRUE	evaluated 2663488 times by 1 test Evaluated by: Self test
FALSE	evaluated 25069797 times by 1 test Evaluated by: Self test

ifs_value	Description
TRUE	evaluated 2663488 times by 1 test Evaluated by: Self test
FALSE	never evaluated

*ifs_value == 0	Description
TRUE	evaluated 6 times by 1 test Evaluated by: Self test
FALSE	evaluated 2663482 times by 1 test Evaluated by: Self test

0-27733538

5991

istring[istring_index++] = CTLESC;

executed 259 times by 1 test: istring[istring_index++] = '\001';

Executed by:

Self test

259

5992

-

5993

istring[istring_index++] = c;

-

5994

-

5995

#if 0

-

5996

#if defined (__CYGWIN__)

-

5997

if (c == '\n' && istring_index > 1 && istring[istring_index - 2] == '\r')

-

5998

{

-

5999

istring_index--;

-

6000

istring[istring_index - 1] = '\n';

-

6001

}

-

6002

#endif

-

6003

#endif

-

6004

}

executed 27837843 times by 1 test: end of block

Executed by:

Self test

27837843

6005

-

6006

if (istring)

istring	Description
TRUE	evaluated 3253379 times by 1 test Evaluated by: Self test
FALSE	evaluated 198 times by 1 test Evaluated by: Self test

198-3253379

6007

istring[istring_index] = '\0';

executed 3253379 times by 1 test: istring[istring_index] = '\0';

Executed by:

Self test

3253379

6008

-

6009

/* If we read no output, just return now and save ourselves some

-

6010

trouble. */

-

6011

if (istring_index == 0)

istring_index == 0	Description
TRUE	evaluated 198 times by 1 test Evaluated by: Self test
FALSE	evaluated 3253379 times by 1 test Evaluated by: Self test

198-3253379

6012

{

-

6013

FREE (istring);

never executed: sh_xfree((istring), "subst.c", 6013);

istring	Description
TRUE	never evaluated
FALSE	evaluated 198 times by 1 test Evaluated by: Self test

0-198

6014

if (rflag)

rflag	Description
TRUE	evaluated 198 times by 1 test Evaluated by: Self test
FALSE	never evaluated

0-198

6015

*rflag = tflag;

executed 198 times by 1 test: *rflag = tflag;

Executed by:

Self test

198

6016

return (char *)NULL;

executed 198 times by 1 test: return (char *) ((void *)0) ;

Executed by:

Self test

198

6017

}

-

6018

-

6019

/* Strip trailing newlines from the output of the command. */

-

6020

if (quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES))

quoted & (0x002\|0x001)	Description
TRUE	evaluated 628 times by 1 test Evaluated by: Self test
FALSE	evaluated 3252751 times by 1 test Evaluated by: Self test

628-3252751

6021

{

-

6022

while (istring_index > 0)

istring_index > 0	Description
TRUE	evaluated 1224 times by 1 test Evaluated by: Self test
FALSE	evaluated 13 times by 1 test Evaluated by: Self test

13-1224

6023

{

-

6024

if (istring[istring_index - 1] == '\n')

istring[istrin...x - 1] == '\n'	Description
TRUE	evaluated 609 times by 1 test Evaluated by: Self test
FALSE	evaluated 615 times by 1 test Evaluated by: Self test

609-615

6025

{

-

6026

--istring_index;

-

6027

-

6028

/* If the newline was quoted, remove the quoting char. */

-

6029

if (istring[istring_index - 1] == CTLESC)

istring[istrin...- 1] == '\001'	Description
TRUE	evaluated 609 times by 1 test Evaluated by: Self test
FALSE	never evaluated

0-609

6030

--istring_index;

executed 609 times by 1 test: --istring_index;

Executed by:

Self test

609

6031

}

executed 609 times by 1 test: end of block

Executed by:

Self test

609

6032

else

-

6033

break;

executed 615 times by 1 test: break;

Executed by:

Self test

615

6034

}

-

6035

istring[istring_index] = '\0';

-

6036

}

executed 628 times by 1 test: end of block

Executed by:

Self test

628

6037

else

-

6038

strip_trailing (istring, istring_index - 1, 1);

executed 3252751 times by 1 test: strip_trailing (istring, istring_index - 1, 1);

Executed by:

Self test

3252751

6039

-

6040

if (rflag)

rflag	Description
TRUE	evaluated 3253379 times by 1 test Evaluated by: Self test
FALSE	never evaluated

0-3253379

6041

*rflag = tflag;

executed 3253379 times by 1 test: *rflag = tflag;

Executed by:

Self test

3253379

6042

return istring;

executed 3253379 times by 1 test: return istring;

Executed by:

Self test

3253379

6043

}

-

6044

-

6045

/* Perform command substitution on STRING. This returns a WORD_DESC * with the

-

6046

contained string possibly quoted. */

-

6047

WORD_DESC *

-

6048

command_substitute (string, quoted, flags)

-

6049

char *string;

-

6050

int quoted;

-

6051

int flags;

-

6052

{

-

6053

pid_t pid, old_pid, old_pipeline_pgrp, old_async_pid;

-

6054

char *istring, *s;

-

6055

int result, fildes[2], function_value, pflags, rc, tflag;

-

6056

WORD_DESC *ret;

-

6057

-

6058

istring = (char *)NULL;

-

6059

-

6060

/* Don't fork () if there is no need to. In the case of no command to

-

6061

run, just return NULL. */

-

6062

#if 1

-

6063

for (s = string; s && *s && (shellblank (*s) || *s == '\n'); s++)

s	Description
TRUE	evaluated 3277452 times by 1 test Evaluated by: Self test
FALSE	never evaluated

*s	Description
TRUE	evaluated 3277305 times by 1 test Evaluated by: Self test
FALSE	evaluated 147 times by 1 test Evaluated by: Self test

(sh_syntaxtab[...*s)] & 0x2000)	Description
TRUE	evaluated 20409 times by 1 test Evaluated by: Self test
FALSE	evaluated 3256896 times by 1 test Evaluated by: Self test

*s == '\n'	Description
TRUE	evaluated 371 times by 1 test Evaluated by: Self test
FALSE	evaluated 3256525 times by 1 test Evaluated by: Self test

0-3277452

6064

;

executed 20780 times by 1 test: ;

Executed by:

Self test

20780

6065

if (s == 0 || *s == 0)

s == 0	Description
TRUE	never evaluated
FALSE	evaluated 3256672 times by 1 test Evaluated by: Self test

*s == 0	Description
TRUE	evaluated 147 times by 1 test Evaluated by: Self test
FALSE	evaluated 3256525 times by 1 test Evaluated by: Self test

0-3256672

6066

return ((WORD_DESC *)NULL);

executed 147 times by 1 test: return ((WORD_DESC *) ((void *)0) );

Executed by:

Self test

147

6067

#else

-

6068

if (!string || !*string || (string[0] == '\n' && !string[1]))

-

6069

return ((WORD_DESC *)NULL);

-

6070

#endif

-

6071

-

6072

if (wordexp_only && read_but_dont_execute)

wordexp_only	Description
TRUE	never evaluated
FALSE	evaluated 3256525 times by 1 test Evaluated by: Self test

read_but_dont_execute	Description
TRUE	never evaluated
FALSE	never evaluated

0-3256525

6073

{

-

6074

last_command_exit_value = EX_WEXPCOMSUB;

-

6075

jump_to_top_level (EXITPROG);

-

6076

}

never executed: end of block

0

6077

-

6078

/* We're making the assumption here that the command substitution will

-

6079

eventually run a command from the file system. Since we'll run

-

6080

maybe_make_export_env in this subshell before executing that command,

-

6081

the parent shell and any other shells it starts will have to remake

-

6082

the environment. If we make it before we fork, other shells won't

-

6083

have to. Don't bother if we have any temporary variable assignments,

-

6084

though, because the export environment will be remade after this

-

6085

command completes anyway, but do it if all the words to be expanded

-

6086

are variable assignments. */

-

6087

if (subst_assign_varlist == 0 || garglist == 0)

subst_assign_varlist == 0	Description
TRUE	evaluated 23321 times by 1 test Evaluated by: Self test
FALSE	evaluated 3233204 times by 1 test Evaluated by: Self test

garglist == 0	Description
TRUE	evaluated 3233195 times by 1 test Evaluated by: Self test
FALSE	evaluated 9 times by 1 test Evaluated by: Self test

9-3233204

6088

maybe_make_export_env (); /* XXX */

executed 3256516 times by 1 test: maybe_make_export_env ();

Executed by:

Self test

3256516

6089

-

6090

/* Flags to pass to parse_and_execute() */

-

6091

pflags = (interactive && sourcelevel == 0) ? SEVAL_RESETLINE : 0;

interactive	Description
TRUE	never evaluated
FALSE	evaluated 3256525 times by 1 test Evaluated by: Self test

sourcelevel == 0	Description
TRUE	never evaluated
FALSE	never evaluated

0-3256525

6092

-

6093

old_pid = last_made_pid;

-

6094

-

6095

/* Pipe the output of executing STRING into the current shell. */

-

6096

if (pipe (fildes) < 0)

pipe (fildes) < 0	Description
TRUE	never evaluated
FALSE	evaluated 3256525 times by 1 test Evaluated by: Self test

0-3256525

6097

{

-

6098

sys_error ("%s", _("cannot make pipe for command substitution"));

-

6099

goto error_exit;

never executed: goto error_exit;

0

6100

}

-

6101

-

6102

#if defined (JOB_CONTROL)

-

6103

old_pipeline_pgrp = pipeline_pgrp;

-

6104

/* Don't reset the pipeline pgrp if we're already a subshell in a pipeline. */

-

6105

if ((subshell_environment & SUBSHELL_PIPE) == 0)

(subshell_envi...t & 0x10) == 0	Description
TRUE	evaluated 3256517 times by 1 test Evaluated by: Self test
FALSE	evaluated 8 times by 1 test Evaluated by: Self test

8-3256517

6106

pipeline_pgrp = shell_pgrp;

executed 3256517 times by 1 test: pipeline_pgrp = shell_pgrp;

Executed by:

Self test

3256517

6107

cleanup_the_pipeline ();

-

6108

#endif /* JOB_CONTROL */

-

6109

-

6110

old_async_pid = last_asynchronous_pid;

-

6111

pid = make_child ((char *)NULL, subshell_environment&SUBSHELL_ASYNC);

-

6112

last_asynchronous_pid = old_async_pid;

-

6113

-

6114

if (pid == 0)

pid == 0	Description
TRUE	evaluated 2948 times by 1 test Evaluated by: Self test
FALSE	evaluated 3253577 times by 1 test Evaluated by: Self test

2948-3253577

6115

{

-

6116

/* Reset the signal handlers in the child, but don't free the

-

6117

trap strings. Set a flag noting that we have to free the

-

6118

trap strings if we run trap to change a signal disposition. */

-

6119

reset_signal_handlers ();

-

6120

if (ISINTERRUPT)

interrupt_state != 0	Description
TRUE	never evaluated
FALSE	evaluated 2948 times by 1 test Evaluated by: Self test

0-2948

6121

{

-

6122

kill (getpid (), SIGINT);

-

6123

CLRINTERRUPT; /* if we're ignoring SIGINT somehow */

-

6124

}

never executed: end of block

0

6125

QUIT; /* catch any interrupts we got post-fork */

never executed: termsig_handler (terminating_signal);

never executed: throw_to_top_level ();

terminating_signal	Description
TRUE	never evaluated
FALSE	evaluated 2948 times by 1 test Evaluated by: Self test

interrupt_state	Description
TRUE	never evaluated
FALSE	evaluated 2948 times by 1 test Evaluated by: Self test

0-2948

6126

subshell_environment |= SUBSHELL_RESETTRAP;

-

6127

}

executed 2948 times by 1 test: end of block

Executed by:

Self test

2948

6128

-

6129

#if defined (JOB_CONTROL)

-

6130

/* XXX DO THIS ONLY IN PARENT ? XXX */

-

6131

set_sigchld_handler ();

-

6132

stop_making_children ();

-

6133

if (pid != 0)

pid != 0	Description
TRUE	evaluated 3253577 times by 1 test Evaluated by: Self test
FALSE	evaluated 2948 times by 1 test Evaluated by: Self test

2948-3253577

6134

pipeline_pgrp = old_pipeline_pgrp;

executed 3253577 times by 1 test: pipeline_pgrp = old_pipeline_pgrp;

Executed by:

Self test

3253577

6135

#else

-

6136

stop_making_children ();

-

6137

#endif /* JOB_CONTROL */

-

6138

-

6139

if (pid < 0)

pid < 0	Description
TRUE	never evaluated
FALSE	evaluated 3256525 times by 1 test Evaluated by: Self test

0-3256525

6140

{

-

6141

sys_error (_("cannot make child for command substitution"));

-

6142

error_exit:

code before this statement never executed: error_exit:

0

6143

-

6144

last_made_pid = old_pid;

-

6145

-

6146

FREE (istring);

never executed: sh_xfree((istring), "subst.c", 6146);

istring	Description
TRUE	never evaluated
FALSE	never evaluated

0

6147

close (fildes[0]);

-

6148

close (fildes[1]);

-

6149

return ((WORD_DESC *)NULL);

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

0

6150

}

-

6151

-

6152

if (pid == 0)

pid == 0	Description
TRUE	evaluated 2948 times by 1 test Evaluated by: Self test
FALSE	evaluated 3253577 times by 1 test Evaluated by: Self test

2948-3253577

6153

{

-

6154

/* The currently executing shell is not interactive. */

-

6155

interactive = 0;

-

6156

-

6157

set_sigint_handler (); /* XXX */

-

6158

-

6159

free_pushed_string_input ();

-

6160

-

6161

/* Discard buffered stdio output before replacing the underlying file

-

6162

descriptor. */

-

6163

fpurge (stdout);

-

6164

-

6165

if (dup2 (fildes[1], 1) < 0)

dup2 (fildes[1], 1) < 0	Description
TRUE	never evaluated
FALSE	evaluated 2948 times by 1 test Evaluated by: Self test

0-2948

6166

{

-

6167

sys_error ("%s", _("command_substitute: cannot duplicate pipe as fd 1"));

-

6168

exit (EXECUTION_FAILURE);

never executed: exit (1);

0

6169

}

-

6170

-

6171

/* If standard output is closed in the parent shell

-

6172

(such as after `exec >&-'), file descriptor 1 will be

-

6173

the lowest available file descriptor, and end up in

-

6174

fildes[0]. This can happen for stdin and stderr as well,

-

6175

but stdout is more important -- it will cause no output

-

6176

to be generated from this command. */

-

6177

if ((fildes[1] != fileno (stdin)) &&

(fildes[1] != ...eno ( stdin ))	Description
TRUE	evaluated 2948 times by 1 test Evaluated by: Self test
FALSE	never evaluated

0-2948

6178

(fildes[1] != fileno (stdout)) &&

(fildes[1] != ...no ( stdout ))	Description
TRUE	evaluated 2948 times by 1 test Evaluated by: Self test
FALSE	never evaluated

0-2948

6179

(fildes[1] != fileno (stderr)))

(fildes[1] != ...no ( stderr ))	Description
TRUE	evaluated 2948 times by 1 test Evaluated by: Self test
FALSE	never evaluated

0-2948

6180

close (fildes[1]);

executed 2948 times by 1 test: close (fildes[1]);

Executed by:

Self test

2948

6181

-

6182

if ((fildes[0] != fileno (stdin)) &&

(fildes[0] != ...eno ( stdin ))	Description
TRUE	evaluated 2948 times by 1 test Evaluated by: Self test
FALSE	never evaluated

0-2948

6183

(fildes[0] != fileno (stdout)) &&

(fildes[0] != ...no ( stdout ))	Description
TRUE	evaluated 2948 times by 1 test Evaluated by: Self test
FALSE	never evaluated

0-2948

6184

(fildes[0] != fileno (stderr)))

(fildes[0] != ...no ( stderr ))	Description
TRUE	evaluated 2938 times by 1 test Evaluated by: Self test
FALSE	evaluated 10 times by 1 test Evaluated by: Self test

10-2938

6185

close (fildes[0]);

executed 2938 times by 1 test: close (fildes[0]);

Executed by:

Self test

2938

6186

-

6187

#ifdef __CYGWIN__

-

6188

/* Let stdio know the fd may have changed from text to binary mode, and

-

6189

make sure to preserve stdout line buffering. */

-

6190

freopen (NULL, "w", stdout);

-

6191

sh_setlinebuf (stdout);

-

6192

#endif /* __CYGWIN__ */

-

6193

-

6194

/* This is a subshell environment. */

-

6195

subshell_environment |= SUBSHELL_COMSUB;

-

6196

-

6197

/* Many shells do not appear to inherit the -v option for command

-

6198

substitutions. */

-

6199

change_flag ('v', FLAG_OFF);

-

6200

-

6201

/* When inherit_errexit option is not enabled, command substitution does

-

6202

not inherit the -e flag. It is enabled when Posix mode is enabled */

-

6203

if (inherit_errexit == 0)

inherit_errexit == 0	Description
TRUE	evaluated 2923 times by 1 test Evaluated by: Self test
FALSE	evaluated 25 times by 1 test Evaluated by: Self test

25-2923

6204

{

-

6205

builtin_ignoring_errexit = 0;

-

6206

change_flag ('e', FLAG_OFF);

-

6207

}

executed 2923 times by 1 test: end of block

Executed by:

Self test

2923

6208

set_shellopts ();

-

6209

-

6210

/* If we are expanding a redirection, we can dispose of any temporary

-

6211

environment we received, since redirections are not supposed to have

-

6212

access to the temporary environment. We will have to see whether this

-

6213

affects temporary environments supplied to `eval', but the temporary

-

6214

environment gets copied to builtin_env at some point. */

-

6215

if (expanding_redir)

expanding_redir	Description
TRUE	evaluated 11 times by 1 test Evaluated by: Self test
FALSE	evaluated 2937 times by 1 test Evaluated by: Self test

11-2937

6216

{

-

6217

flush_temporary_env ();

-

6218

expanding_redir = 0;

-

6219

}

executed 11 times by 1 test: end of block

Executed by:

Self test

11

6220

-

6221

remove_quoted_escapes (string);

-

6222

-

6223

startup_state = 2; /* see if we can avoid a fork */

-

6224

parse_and_execute_level = 0;

-

6225

-

6226

/* Give command substitution a place to jump back to on failure,

-

6227

so we don't go back up to main (). */

-

6228

result = setjmp_nosigs (top_level);

-

6229

-

6230

/* If we're running a command substitution inside a shell function,

-

6231

trap `return' so we don't return from the function in the subshell

-

6232

and go off to never-never land. */

-

6233

if (result == 0 && return_catch_flag)

result == 0	Description
TRUE	evaluated 2948 times by 1 test Evaluated by: Self test
FALSE	evaluated 2 times by 1 test Evaluated by: Self test

return_catch_flag	Description
TRUE	evaluated 2360 times by 1 test Evaluated by: Self test
FALSE	evaluated 588 times by 1 test Evaluated by: Self test

2-2948

6234

function_value = setjmp_nosigs (return_catch);

executed 2360 times by 1 test: function_value = __sigsetjmp ( (return_catch) , 0 ) ;

Executed by:

Self test

2360

6235

else

-

6236

function_value = 0;

executed 590 times by 1 test: function_value = 0;

Executed by:

Self test

590

6237

-

6238

if (result == ERREXIT)

result == 4	Description
TRUE	evaluated 2 times by 1 test Evaluated by: Self test
FALSE	evaluated 2948 times by 1 test Evaluated by: Self test

2-2948

6239

rc = last_command_exit_value;

executed 2 times by 1 test: rc = last_command_exit_value;

Executed by:

Self test

2

6240

else if (result == EXITPROG)

result == 3	Description
TRUE	never evaluated
FALSE	evaluated 2948 times by 1 test Evaluated by: Self test

0-2948

6241

rc = last_command_exit_value;

never executed: rc = last_command_exit_value;

0

6242

else if (result)

result	Description
TRUE	never evaluated
FALSE	evaluated 2948 times by 1 test Evaluated by: Self test

0-2948

6243

rc = EXECUTION_FAILURE;

never executed: rc = 1;

0

6244

else if (function_value)

function_value	Description
TRUE	never evaluated
FALSE	evaluated 2948 times by 1 test Evaluated by: Self test

0-2948

6245

rc = return_catch_value;

never executed: rc = return_catch_value;

0

6246

else

-

6247

{

-

6248

subshell_level++;

-

6249

rc = parse_and_execute (string, "command substitution", pflags|SEVAL_NOHIST);

-

6250

/* leave subshell level intact for any exit trap */

-

6251

}

executed 1348 times by 1 test: end of block

Executed by:

Self test

1348

6252

-

6253

last_command_exit_value = rc;

-

6254

rc = run_exit_trap ();

-

6255

#if defined (PROCESS_SUBSTITUTION)

-

6256

unlink_fifo_list ();

-

6257

#endif

-

6258

exit (rc);

executed 1350 times by 1 test: exit (rc);

Executed by:

Self test

1350

6259

}

-

6260

else

-

6261

{

-

6262

#if defined (JOB_CONTROL) && defined (PGRP_PIPE)

-

6263

close_pgrp_pipe ();

-

6264

#endif /* JOB_CONTROL && PGRP_PIPE */

-

6265

-

6266

close (fildes[1]);

-

6267

-

6268

tflag = 0;

-

6269

istring = read_comsub (fildes[0], quoted, flags, &tflag);

-

6270

-

6271

close (fildes[0]);

-

6272

-

6273

current_command_subst_pid = pid;

-

6274

last_command_exit_value = wait_for (pid);

-

6275

last_command_subst_pid = pid;

-

6276

last_made_pid = old_pid;

-

6277

-

6278

#if defined (JOB_CONTROL)

-

6279

/* If last_command_exit_value > 128, then the substituted command

-

6280

was terminated by a signal. If that signal was SIGINT, then send

-

6281

SIGINT to ourselves. This will break out of loops, for instance. */

-

6282

if (last_command_exit_value == (128 + SIGINT) && last_command_exit_signal == SIGINT)

last_command_e... == (128 + 2 )	Description
TRUE	never evaluated
FALSE	evaluated 3253577 times by 1 test Evaluated by: Self test

last_command_exit_signal == 2	Description
TRUE	never evaluated
FALSE	never evaluated

0-3253577

6283

kill (getpid (), SIGINT);

never executed: kill (getpid (), 2 );

0

6284

-

6285

/* wait_for gives the terminal back to shell_pgrp. If some other

-

6286

process group should have it, give it away to that group here.

-

6287

pipeline_pgrp is non-zero only while we are constructing a

-

6288

pipeline, so what we are concerned about is whether or not that

-

6289

pipeline was started in the background. A pipeline started in

-

6290

the background should never get the tty back here. We duplicate

-

6291

the conditions that wait_for tests to make sure we only give

-

6292

the terminal back to pipeline_pgrp under the conditions that wait_for

-

6293

gave it to shell_pgrp. If wait_for doesn't mess with the terminal

-

6294

pgrp, we should not either. */

-

6295

if (interactive && pipeline_pgrp != (pid_t)0 && running_in_background == 0 &&

interactive	Description
TRUE	never evaluated
FALSE	evaluated 3253577 times by 1 test Evaluated by: Self test

pipeline_pgrp != (pid_t)0	Description
TRUE	never evaluated
FALSE	never evaluated

running_in_background == 0	Description
TRUE	never evaluated
FALSE	never evaluated

0-3253577

6296

(subshell_environment & (SUBSHELL_ASYNC|SUBSHELL_PIPE)) == 0)

(subshell_envi...01\|0x10)) == 0	Description
TRUE	never evaluated
FALSE	never evaluated

0

6297

give_terminal_to (pipeline_pgrp, 0);

never executed: give_terminal_to (pipeline_pgrp, 0);

0

6298

#endif /* JOB_CONTROL */

-

6299

-

6300

ret = alloc_word_desc ();

-

6301

ret->word = istring;

-

6302

ret->flags = tflag;

-

6303

-

6304

return ret;

executed 3253577 times by 1 test: return ret;

Executed by:

Self test

3253577

6305

}

-

6306

}

-

6307

-

6308

/********************************************************

-

6309

* *

-

6310

* Utility functions for parameter expansion *

-

6311

* *

-

6312

********************************************************/

-

6313

-

6314

#if defined (ARRAY_VARS)

-

6315

-

6316

static arrayind_t

-

6317

array_length_reference (s)

-

6318

char *s;

-

6319

{

-

6320

int len;

-

6321

arrayind_t ind;

-

6322

char *akey;

-

6323

char *t, c;

-

6324

ARRAY *array;

-

6325

HASH_TABLE *h;

-

6326

SHELL_VAR *var;

-

6327

-

6328

var = array_variable_part (s, 0, &t, &len);

-

6329

-

6330

/* If unbound variables should generate an error, report one and return

-

6331

failure. */

-

6332

if ((var == 0 || invisible_p (var) || (assoc_p (var) == 0 && array_p (var) == 0)) && unbound_vars_is_error)

var == 0	Description
TRUE	evaluated 2 times by 1 test Evaluated by: Self test
FALSE	evaluated 264 times by 1 test Evaluated by: Self test

((((var)->attr... (0x0001000)))	Description
TRUE	never evaluated
FALSE	evaluated 264 times by 1 test Evaluated by: Self test

((((var)->attr...000040))) == 0	Description
TRUE	evaluated 252 times by 1 test Evaluated by: Self test
FALSE	evaluated 12 times by 1 test Evaluated by: Self test

((((var)->attr...000004))) == 0	Description
TRUE	evaluated 4 times by 1 test Evaluated by: Self test
FALSE	evaluated 248 times by 1 test Evaluated by: Self test

unbound_vars_is_error	Description
TRUE	evaluated 1 time by 1 test Evaluated by: Self test
FALSE	evaluated 5 times by 1 test Evaluated by: Self test

0-264

6333

{

-

6334

c = *--t;

-

6335

*t = '\0';

-

6336

last_command_exit_value = EXECUTION_FAILURE;

-

6337

err_unboundvar (s);

-

6338

*t = c;

-

6339

return (-1);

executed 1 time by 1 test: return (-1);

Executed by:

Self test

1

6340

}

-

6341

else if (var == 0 || invisible_p (var))

var == 0	Description
TRUE	evaluated 1 time by 1 test Evaluated by: Self test
FALSE	evaluated 264 times by 1 test Evaluated by: Self test

((((var)->attr... (0x0001000)))	Description
TRUE	never evaluated
FALSE	evaluated 264 times by 1 test Evaluated by: Self test

0-264

6342

return 0;

executed 1 time by 1 test: return 0;

Executed by:

Self test

1

6343

-

6344

/* We support a couple of expansions for variables that are not arrays.

-

6345

We'll return the length of the value for v[0], and 1 for v[@] or

-

6346

v[*]. Return 0 for everything else. */

-

6347

-

6348

array = array_p (var) ? array_cell (var) : (ARRAY *)NULL;

((((var)->attr... (0x0000004)))	Description
TRUE	evaluated 248 times by 1 test Evaluated by: Self test
FALSE	evaluated 16 times by 1 test Evaluated by: Self test

16-248

6349

h = assoc_p (var) ? assoc_cell (var) : (HASH_TABLE *)NULL;

((((var)->attr... (0x0000040)))	Description
TRUE	evaluated 12 times by 1 test Evaluated by: Self test
FALSE	evaluated 252 times by 1 test Evaluated by: Self test

12-252

6350

-

6351

if (ALL_ELEMENT_SUB (t[0]) && t[1] == RBRACK)

(t[0]) == '@'	Description
TRUE	evaluated 229 times by 1 test Evaluated by: Self test
FALSE	evaluated 35 times by 1 test Evaluated by: Self test

(t[0]) == '*'	Description
TRUE	evaluated 9 times by 1 test Evaluated by: Self test
FALSE	evaluated 26 times by 1 test Evaluated by: Self test

t[1] == ']'	Description
TRUE	evaluated 238 times by 1 test Evaluated by: Self test
FALSE	never evaluated

0-238

6352

{

-

6353

if (assoc_p (var))

((((var)->attr... (0x0000040)))	Description
TRUE	evaluated 10 times by 1 test Evaluated by: Self test
FALSE	evaluated 228 times by 1 test Evaluated by: Self test

10-228

6354

return (h ? assoc_num_elements (h) : 0);

executed 10 times by 1 test: return (h ? ((h)->nentries) : 0);

Executed by:

Self test

10

6355

else if (array_p (var))

((((var)->attr... (0x0000004)))	Description
TRUE	evaluated 226 times by 1 test Evaluated by: Self test
FALSE	evaluated 2 times by 1 test Evaluated by: Self test

2-226

6356

return (array ? array_num_elements (array) : 0);

executed 226 times by 1 test: return (array ? ((array)->num_elements) : 0);

Executed by:

Self test

226

6357

else

-

6358

return (var_isset (var) ? 1 : 0);

executed 2 times by 1 test: return (((var)->value != 0) ? 1 : 0);

Executed by:

Self test

2

6359

}

-

6360

-

6361

if (assoc_p (var))

((((var)->attr... (0x0000040)))	Description
TRUE	evaluated 2 times by 1 test Evaluated by: Self test
FALSE	evaluated 24 times by 1 test Evaluated by: Self test

2-24

6362

{

-

6363

t[len - 1] = '\0';

-

6364

akey = expand_assignment_string_to_string (t, 0); /* [ */

-

6365

t[len - 1] = RBRACK;

-

6366

if (akey == 0 || *akey == 0)

akey == 0	Description
TRUE	never evaluated
FALSE	evaluated 2 times by 1 test Evaluated by: Self test

*akey == 0	Description
TRUE	never evaluated
FALSE	evaluated 2 times by 1 test Evaluated by: Self test

0-2

6367

{

-

6368

err_badarraysub (t);

-

6369

FREE (akey);

never executed: sh_xfree((akey), "subst.c", 6369);

akey	Description
TRUE	never evaluated
FALSE	never evaluated

0

6370

return (-1);

never executed: return (-1);

0

6371

}

-

6372

t = assoc_reference (assoc_cell (var), akey);

-

6373

free (akey);

-

6374

}

executed 2 times by 1 test: end of block

Executed by:

Self test

2

6375

else

-

6376

{

-

6377

ind = array_expand_index (var, t, len, 0);

-

6378

/* negative subscripts to indexed arrays count back from end */

-

6379

if (var && array_p (var) && ind < 0)

var	Description
TRUE	evaluated 24 times by 1 test Evaluated by: Self test
FALSE	never evaluated

((((var)->attr... (0x0000004)))	Description
TRUE	evaluated 22 times by 1 test Evaluated by: Self test
FALSE	evaluated 2 times by 1 test Evaluated by: Self test

ind < 0	Description
TRUE	evaluated 1 time by 1 test Evaluated by: Self test
FALSE	evaluated 21 times by 1 test Evaluated by: Self test

0-24

6380

ind = array_max_index (array_cell (var)) + 1 + ind;

executed 1 time by 1 test: ind = (((ARRAY *)((var)->value))->max_index) + 1 + ind;

Executed by:

Self test

1

6381

if (ind < 0)

ind < 0	Description
TRUE	never evaluated
FALSE	evaluated 24 times by 1 test Evaluated by: Self test

0-24

6382

{

-

6383

err_badarraysub (t);

-

6384

return (-1);

never executed: return (-1);

0

6385

}

-

6386

if (array_p (var))

((((var)->attr... (0x0000004)))	Description
TRUE	evaluated 22 times by 1 test Evaluated by: Self test
FALSE	evaluated 2 times by 1 test Evaluated by: Self test

2-22

6387

t = array_reference (array, ind);

executed 22 times by 1 test: t = array_reference (array, ind);

Executed by:

Self test

22

6388

else

-

6389

t = (ind == 0) ? value_cell (var) : (char *)NULL;

executed 2 times by 1 test: t = (ind == 0) ? ((var)->value) : (char *) ((void *)0) ;

Executed by:

Self test

(ind == 0)	Description
TRUE	evaluated 2 times by 1 test Evaluated by: Self test
FALSE	never evaluated

0-2

6390

}

-

6391

-

6392

len = MB_STRLEN (t);

( (__ctype_get...r_max ()) > 1)	Description
TRUE	evaluated 26 times by 1 test Evaluated by: Self test
FALSE	never evaluated

(t)[1]	Description
TRUE	evaluated 25 times by 1 test Evaluated by: Self test
FALSE	never evaluated

(t)[1]	Description
TRUE	never evaluated
FALSE	never evaluated

(t)[2]	Description
TRUE	never evaluated
FALSE	never evaluated

(t)	Description
TRUE	evaluated 26 times by 1 test Evaluated by: Self test
FALSE	never evaluated

(t)[0]	Description
TRUE	evaluated 25 times by 1 test Evaluated by: Self test
FALSE	evaluated 1 time by 1 test Evaluated by: Self test

(t)	Description
TRUE	never evaluated
FALSE	never evaluated

(t)[0]	Description
TRUE	never evaluated
FALSE	never evaluated

0-26

6393

return (len);

executed 26 times by 1 test: return (len);

Executed by:

Self test

26

6394

}

-

6395

#endif /* ARRAY_VARS */

-

6396

-

6397

static int

-

6398

valid_brace_expansion_word (name, var_is_special)

-

6399

char *name;

-

6400

int var_is_special;

-

6401

{

-

6402

if (DIGIT (*name) && all_digits (name))

(*name) >= '0'	Description
TRUE	evaluated 2369043 times by 1 test Evaluated by: Self test
FALSE	evaluated 414 times by 1 test Evaluated by: Self test

(*name) <= '9'	Description
TRUE	evaluated 14868 times by 1 test Evaluated by: Self test
FALSE	evaluated 2354175 times by 1 test Evaluated by: Self test

all_digits (name)	Description
TRUE	evaluated 14867 times by 1 test Evaluated by: Self test
FALSE	evaluated 1 time by 1 test Evaluated by: Self test

1-2369043

6403

return 1;

executed 14867 times by 1 test: return 1;

Executed by:

Self test

14867

6404

else if (var_is_special)

var_is_special	Description
TRUE	evaluated 797 times by 1 test Evaluated by: Self test
FALSE	evaluated 2353793 times by 1 test Evaluated by: Self test

797-2353793

6405

return 1;

executed 797 times by 1 test: return 1;

Executed by:

Self test

797

6406

#if defined (ARRAY_VARS)

-

6407

else if (valid_array_reference (name, 0))

valid_array_re...ence (name, 0)	Description
TRUE	evaluated 5915 times by 1 test Evaluated by: Self test
FALSE	evaluated 2347878 times by 1 test Evaluated by: Self test

5915-2347878

6408

return 1;

executed 5915 times by 1 test: return 1;

Executed by:

Self test

5915

6409

#endif /* ARRAY_VARS */

-

6410

else if (legal_identifier (name))

legal_identifier (name)	Description
TRUE	evaluated 2347838 times by 1 test Evaluated by: Self test
FALSE	evaluated 40 times by 1 test Evaluated by: Self test

40-2347838

6411

return 1;

executed 2347838 times by 1 test: return 1;

Executed by:

Self test

2347838

6412

else

-

6413

return 0;

executed 40 times by 1 test: return 0;

Executed by:

Self test

40

6414

}

-

6415

-

6416

static int

-

6417

chk_atstar (name, quoted, quoted_dollar_atp, contains_dollar_at)

-

6418

char *name;

-

6419

int quoted;

-

6420

int *quoted_dollar_atp, *contains_dollar_at;

-

6421

{

-

6422

char *temp1;

-

6423

-

6424

if (name == 0)

name == 0	Description
TRUE	evaluated 13 times by 1 test Evaluated by: Self test
FALSE	evaluated 5981 times by 1 test Evaluated by: Self test

13-5981

6425

{

-

6426

if (quoted_dollar_atp)

quoted_dollar_atp	Description
TRUE	evaluated 13 times by 1 test Evaluated by: Self test
FALSE	never evaluated

0-13

6427

*quoted_dollar_atp = 0;

executed 13 times by 1 test: *quoted_dollar_atp = 0;

Executed by:

Self test

13

6428

if (contains_dollar_at)

contains_dollar_at	Description
TRUE	evaluated 13 times by 1 test Evaluated by: Self test
FALSE	never evaluated

0-13

6429

*contains_dollar_at = 0;

executed 13 times by 1 test: *contains_dollar_at = 0;

Executed by:

Self test

13

6430

return 0;

executed 13 times by 1 test: return 0;

Executed by:

Self test

13

6431

}

-

6432

-

6433

/* check for $@ and $* */

-

6434

if (name[0] == '@' && name[1] == 0)

name[0] == '@'	Description
TRUE	evaluated 20 times by 1 test Evaluated by: Self test
FALSE	evaluated 5961 times by 1 test Evaluated by: Self test

name[1] == 0	Description
TRUE	evaluated 20 times by 1 test Evaluated by: Self test
FALSE	never evaluated

0-5961

6435

{

-

6436

if ((quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)) && quoted_dollar_atp)

(quoted & (0x002\|0x001))	Description
TRUE	evaluated 10 times by 1 test Evaluated by: Self test
FALSE	evaluated 10 times by 1 test Evaluated by: Self test

quoted_dollar_atp	Description
TRUE	evaluated 10 times by 1 test Evaluated by: Self test
FALSE	never evaluated

0-10

6437

*quoted_dollar_atp = 1;

executed 10 times by 1 test: *quoted_dollar_atp = 1;

Executed by:

Self test

10

6438

if (contains_dollar_at)

contains_dollar_at	Description
TRUE	evaluated 20 times by 1 test Evaluated by: Self test
FALSE	never evaluated

0-20

6439

*contains_dollar_at = 1;

executed 20 times by 1 test: *contains_dollar_at = 1;

Executed by:

Self test

20

6440

return 1;

executed 20 times by 1 test: return 1;

Executed by:

Self test

20

6441

}

-

6442

else if (name[0] == '*' && name[1] == '\0' && quoted == 0)

name[0] == '*'	Description
TRUE	never evaluated
FALSE	evaluated 5961 times by 1 test Evaluated by: Self test

name[1] == '\0'	Description
TRUE	never evaluated
FALSE	never evaluated

quoted == 0	Description
TRUE	never evaluated
FALSE	never evaluated

0-5961

6443

{

-

6444

if (contains_dollar_at)

contains_dollar_at	Description
TRUE	never evaluated
FALSE	never evaluated

0

6445

*contains_dollar_at = 1;

never executed: *contains_dollar_at = 1;

0

6446

return 1;

never executed: return 1;

0

6447

}

-

6448

-

6449

/* Now check for ${array[@]} and ${array[*]} */

-

6450

#if defined (ARRAY_VARS)

-

6451

else if (valid_array_reference (name, 0))

valid_array_re...ence (name, 0)	Description
TRUE	evaluated 5904 times by 1 test Evaluated by: Self test
FALSE	evaluated 57 times by 1 test Evaluated by: Self test

57-5904

6452

{

-

6453

temp1 = mbschr (name, LBRACK);

-

6454

if (temp1 && temp1[1] == '@' && temp1[2] == RBRACK)

temp1	Description
TRUE	evaluated 5904 times by 1 test Evaluated by: Self test
FALSE	never evaluated

temp1[1] == '@'	Description
TRUE	evaluated 665 times by 1 test Evaluated by: Self test
FALSE	evaluated 5239 times by 1 test Evaluated by: Self test

temp1[2] == ']'	Description
TRUE	evaluated 665 times by 1 test Evaluated by: Self test
FALSE	never evaluated

0-5904

6455

{

-

6456

if ((quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)) && quoted_dollar_atp)

(quoted & (0x002\|0x001))	Description
TRUE	evaluated 234 times by 1 test Evaluated by: Self test
FALSE	evaluated 431 times by 1 test Evaluated by: Self test

quoted_dollar_atp	Description
TRUE	evaluated 234 times by 1 test Evaluated by: Self test
FALSE	never evaluated

0-431

6457

*quoted_dollar_atp = 1;

executed 234 times by 1 test: *quoted_dollar_atp = 1;

Executed by:

Self test

234

6458

if (contains_dollar_at)

contains_dollar_at	Description
TRUE	evaluated 665 times by 1 test Evaluated by: Self test
FALSE	never evaluated

0-665

6459

*contains_dollar_at = 1;

executed 665 times by 1 test: *contains_dollar_at = 1;

Executed by:

Self test

665

6460

return 1;

executed 665 times by 1 test: return 1;

Executed by:

Self test

665

6461

}

-

6462

/* ${array[*]}, when unquoted, should be treated like ${array[@]},

-

6463

which should result in separate words even when IFS is unset. */

-

6464

if (temp1 && temp1[1] == '*' && temp1[2] == RBRACK && quoted == 0)

temp1	Description
TRUE	evaluated 5239 times by 1 test Evaluated by: Self test
FALSE	never evaluated

temp1[1] == '*'	Description
TRUE	evaluated 156 times by 1 test Evaluated by: Self test
FALSE	evaluated 5083 times by 1 test Evaluated by: Self test

temp1[2] == ']'	Description
TRUE	evaluated 156 times by 1 test Evaluated by: Self test
FALSE	never evaluated

quoted == 0	Description
TRUE	evaluated 102 times by 1 test Evaluated by: Self test
FALSE	evaluated 54 times by 1 test Evaluated by: Self test

0-5239

6465

{

-

6466

if (contains_dollar_at)

contains_dollar_at	Description
TRUE	evaluated 102 times by 1 test Evaluated by: Self test
FALSE	never evaluated

0-102

6467

*contains_dollar_at = 1;

executed 102 times by 1 test: *contains_dollar_at = 1;

Executed by:

Self test

102

6468

return 1;

executed 102 times by 1 test: return 1;

Executed by:

Self test

102

6469

}

-

6470

}

executed 5137 times by 1 test: end of block

Executed by:

Self test

5137

6471

#endif

-

6472

return 0;

executed 5194 times by 1 test: return 0;

Executed by:

Self test

5194

6473

}

-

6474

-

6475

/* Parameter expand NAME, and return a new string which is the expansion,

-

6476

or NULL if there was no expansion. NAME is as given in ${NAMEcWORD}.

-

6477

VAR_IS_SPECIAL is non-zero if NAME is one of the special variables in

-

6478

the shell, e.g., "@", "$", "*", etc. QUOTED, if non-zero, means that

-

6479

NAME was found inside of a double-quoted expression. */

-

6480

static WORD_DESC *

-

6481

parameter_brace_expand_word (name, var_is_special, quoted, pflags, indp)

-

6482

char *name;

-

6483

int var_is_special, quoted, pflags;

-

6484

arrayind_t *indp;

-

6485

{

-

6486

WORD_DESC *ret;

-

6487

char *temp, *tt;

-

6488

intmax_t arg_index;

-

6489

SHELL_VAR *var;

-

6490

int atype, rflags;

-

6491

arrayind_t ind;

-

6492

-

6493

ret = 0;

-

6494

temp = 0;

-

6495

rflags = 0;

-

6496

-

6497

if (indp)

indp	Description
TRUE	evaluated 2369206 times by 1 test Evaluated by: Self test
FALSE	evaluated 208 times by 1 test Evaluated by: Self test

208-2369206

6498

*indp = INTMAX_MIN;

executed 2369206 times by 1 test: *indp = (-9223372036854775807L -1) ;

Executed by:

Self test

2369206

6499

-

6500

/* Handle multiple digit arguments, as in ${11}. */

-

6501

if (legal_number (name, &arg_index))

legal_number (...e, &arg_index)	Description
TRUE	evaluated 14867 times by 1 test Evaluated by: Self test
FALSE	evaluated 2354547 times by 1 test Evaluated by: Self test

14867-2354547

6502

{

-

6503

tt = get_dollar_var_value (arg_index);

-

6504

if (tt)

tt	Description
TRUE	evaluated 14627 times by 1 test Evaluated by: Self test
FALSE	evaluated 240 times by 1 test Evaluated by: Self test

240-14627

6505

temp = (*tt && (quoted & (Q_DOUBLE_QUOTES|Q_HERE_DOCUMENT)))

executed 14627 times by 1 test: temp = (*tt && (quoted & (0x001|0x002))) ? quote_string (tt) : quote_escapes (tt);

Executed by:

Self test

*tt	Description
TRUE	evaluated 14609 times by 1 test Evaluated by: Self test
FALSE	evaluated 18 times by 1 test Evaluated by: Self test

(quoted & (0x001\|0x002))	Description
TRUE	evaluated 14244 times by 1 test Evaluated by: Self test
FALSE	evaluated 365 times by 1 test Evaluated by: Self test

18-14627

6506

? quote_string (tt)

executed 14627 times by 1 test: temp = (*tt && (quoted & (0x001|0x002))) ? quote_string (tt) : quote_escapes (tt);

Executed by:

Self test

14627

6507

: quote_escapes (tt);

executed 14627 times by 1 test: temp = (*tt && (quoted & (0x001|0x002))) ? quote_string (tt) : quote_escapes (tt);

Executed by:

Self test

14627

6508

else

-

6509

temp = (char *)NULL;

executed 240 times by 1 test: temp = (char *) ((void *)0) ;

Executed by:

Self test

240

6510

FREE (tt);

executed 14627 times by 1 test: sh_xfree((tt), "subst.c", 6510);

Executed by:

Self test

tt	Description
TRUE	evaluated 14627 times by 1 test Evaluated by: Self test
FALSE	evaluated 240 times by 1 test Evaluated by: Self test

240-14627

6511

}

executed 14867 times by 1 test: end of block

Executed by:

Self test

14867

6512

else if (var_is_special) /* ${@} */

var_is_special	Description
TRUE	evaluated 797 times by 1 test Evaluated by: Self test
FALSE	evaluated 2353750 times by 1 test Evaluated by: Self test

797-2353750

6513

{

-

6514

int sindex;

-

6515

tt = (char *)xmalloc (2 + strlen (name));

-

6516

tt[sindex = 0] = '$';

-

6517

strcpy (tt + 1, name);

-

6518

-

6519

ret = param_expand (tt, &sindex, quoted, (int *)NULL, (int *)NULL,

-

6520

(int *)NULL, (int *)NULL, pflags);

-

6521

free (tt);

-

6522

}

executed 797 times by 1 test: end of block

Executed by:

Self test

797

6523

#if defined (ARRAY_VARS)

-

6524

else if (valid_array_reference (name, 0))

valid_array_re...ence (name, 0)	Description
TRUE	evaluated 5936 times by 1 test Evaluated by: Self test
FALSE	evaluated 2347814 times by 1 test Evaluated by: Self test

5936-2347814

6525

{

-

6526

expand_arrayref:

-

6527

var = array_variable_part (name, 0, &tt, (int *)0);

-

6528

/* These are the cases where word splitting will not be performed */

-

6529

if (pflags & PF_ASSIGNRHS)

pflags & 0x08	Description
TRUE	evaluated 56 times by 1 test Evaluated by: Self test
FALSE	evaluated 5884 times by 1 test Evaluated by: Self test

56-5884

6530

{

-

6531

if (ALL_ELEMENT_SUB (tt[0]) && tt[1] == RBRACK)

(tt[0]) == '@'	Description
TRUE	evaluated 11 times by 1 test Evaluated by: Self test
FALSE	evaluated 45 times by 1 test Evaluated by: Self test

(tt[0]) == '*'	Description
TRUE	evaluated 11 times by 1 test Evaluated by: Self test
FALSE	evaluated 34 times by 1 test Evaluated by: Self test

tt[1] == ']'	Description
TRUE	evaluated 22 times by 1 test Evaluated by: Self test
FALSE	never evaluated

0-45

6532

{

-

6533

/* Only treat as double quoted if array variable */

-

6534

if (var && (array_p (var) || assoc_p (var)))

var	Description
TRUE	evaluated 22 times by 1 test Evaluated by: Self test
FALSE	never evaluated

((((var)->attr... (0x0000004)))	Description
TRUE	evaluated 21 times by 1 test Evaluated by: Self test
FALSE	evaluated 1 time by 1 test Evaluated by: Self test

((((var)->attr... (0x0000040)))	Description
TRUE	never evaluated
FALSE	evaluated 1 time by 1 test Evaluated by: Self test

0-22

6535

/* XXX - bash-4.4/bash-5.0 pass AV_ASSIGNRHS */

-

6536

temp = array_value (name, quoted|Q_DOUBLE_QUOTES, AV_ASSIGNRHS, &atype, &ind);

executed 21 times by 1 test: temp = array_value (name, quoted|0x001, 0x010, &atype, &ind);

Executed by:

Self test

21

6537

else

-

6538

temp = array_value (name, quoted, 0, &atype, &ind);

executed 1 time by 1 test: temp = array_value (name, quoted, 0, &atype, &ind);

Executed by:

Self test

1

6539

}

-

6540

else

-

6541

temp = array_value (name, quoted, 0, &atype, &ind);

executed 34 times by 1 test: temp = array_value (name, quoted, 0, &atype, &ind);

Executed by:

Self test

34

6542

}

-

6543

/* Posix interp 888 */

-

6544

else if (pflags & PF_NOSPLIT2)

pflags & 0x04	Description
TRUE	evaluated 19 times by 1 test Evaluated by: Self test
FALSE	evaluated 5865 times by 1 test Evaluated by: Self test

19-5865

6545

{

-

6546

/* Special cases, then general case, for each of A[@], A[*], A[n] */

-

6547

#if defined (HANDLE_MULTIBYTE)

-

6548

if (tt[0] == '@' && tt[1] == RBRACK && var && quoted == 0 && ifs_is_set && ifs_is_null == 0 && ifs_firstc[0] != ' ')

tt[0] == '@'	Description
TRUE	evaluated 4 times by 1 test Evaluated by: Self test
FALSE	evaluated 15 times by 1 test Evaluated by: Self test

tt[1] == ']'	Description
TRUE	evaluated 4 times by 1 test Evaluated by: Self test
FALSE	never evaluated

var	Description
TRUE	evaluated 4 times by 1 test Evaluated by: Self test
FALSE	never evaluated

quoted == 0	Description
TRUE	evaluated 4 times by 1 test Evaluated by: Self test
FALSE	never evaluated

ifs_is_set	Description
TRUE	evaluated 4 times by 1 test Evaluated by: Self test
FALSE	never evaluated

ifs_is_null == 0	Description
TRUE	evaluated 3 times by 1 test Evaluated by: Self test
FALSE	evaluated 1 time by 1 test Evaluated by: Self test

ifs_firstc[0] != ' '	Description
TRUE	evaluated 1 time by 1 test Evaluated by: Self test
FALSE	evaluated 2 times by 1 test Evaluated by: Self test

0-15

6549

#else

-

6550

if (tt[0] == '@' && tt[1] == RBRACK && var && quoted == 0 && ifs_is_set && ifs_is_null == 0 && ifs_firstc != ' ')

-

6551

#endif

-

6552

temp = array_value (name, Q_DOUBLE_QUOTES, AV_ASSIGNRHS, &atype, &ind);

executed 1 time by 1 test: temp = array_value (name, 0x001, 0x010, &atype, &ind);

Executed by:

Self test

1

6553

else if (tt[0] == '@' && tt[1] == RBRACK)

tt[0] == '@'	Description
TRUE	evaluated 3 times by 1 test Evaluated by: Self test
FALSE	evaluated 15 times by 1 test Evaluated by: Self test

tt[1] == ']'	Description
TRUE	evaluated 3 times by 1 test Evaluated by: Self test
FALSE	never evaluated

0-15

6554

temp = array_value (name, quoted, 0, &atype, &ind);

executed 3 times by 1 test: temp = array_value (name, quoted, 0, &atype, &ind);

Executed by:

Self test

3

6555

else if (tt[0] == '*' && tt[1] == RBRACK && expand_no_split_dollar_star && ifs_is_null)

tt[0] == '*'	Description
TRUE	evaluated 8 times by 1 test Evaluated by: Self test
FALSE	evaluated 7 times by 1 test Evaluated by: Self test

tt[1] == ']'	Description
TRUE	evaluated 8 times by 1 test Evaluated by: Self test
FALSE	never evaluated

expand_no_split_dollar_star	Description
TRUE	evaluated 5 times by 1 test Evaluated by: Self test
FALSE	evaluated 3 times by 1 test Evaluated by: Self test

ifs_is_null	Description
TRUE	evaluated 1 time by 1 test Evaluated by: Self test
FALSE	evaluated 4 times by 1 test Evaluated by: Self test

0-8

6556

temp = array_value (name, Q_DOUBLE_QUOTES|Q_HERE_DOCUMENT, 0, &atype, &ind);

executed 1 time by 1 test: temp = array_value (name, 0x001|0x002, 0, &atype, &ind);

Executed by:

Self test

1

6557

else if (tt[0] == '*' && tt[1] == RBRACK)

tt[0] == '*'	Description
TRUE	evaluated 7 times by 1 test Evaluated by: Self test
FALSE	evaluated 7 times by 1 test Evaluated by: Self test

tt[1] == ']'	Description
TRUE	evaluated 7 times by 1 test Evaluated by: Self test
FALSE	never evaluated

0-7

6558

temp = array_value (name, quoted, 0, &atype, &ind);

executed 7 times by 1 test: temp = array_value (name, quoted, 0, &atype, &ind);

Executed by:

Self test

7

6559

else

-

6560

temp = array_value (name, quoted, 0, &atype, &ind);

executed 7 times by 1 test: temp = array_value (name, quoted, 0, &atype, &ind);

Executed by:

Self test

7

6561

}

-

6562

else if (tt[0] == '*' && tt[1] == RBRACK && expand_no_split_dollar_star && ifs_is_null)

tt[0] == '*'	Description
TRUE	evaluated 137 times by 1 test Evaluated by: Self test
FALSE	evaluated 5728 times by 1 test Evaluated by: Self test

tt[1] == ']'	Description
TRUE	evaluated 137 times by 1 test Evaluated by: Self test
FALSE	never evaluated

expand_no_split_dollar_star	Description
TRUE	evaluated 7 times by 1 test Evaluated by: Self test
FALSE	evaluated 130 times by 1 test Evaluated by: Self test

ifs_is_null	Description
TRUE	evaluated 1 time by 1 test Evaluated by: Self test
FALSE	evaluated 6 times by 1 test Evaluated by: Self test

0-5728

6563

temp = array_value (name, Q_DOUBLE_QUOTES|Q_HERE_DOCUMENT, 0, &atype, &ind);

executed 1 time by 1 test: temp = array_value (name, 0x001|0x002, 0, &atype, &ind);

Executed by:

Self test

1

6564

else

-

6565

temp = array_value (name, quoted, 0, &atype, &ind);

executed 5864 times by 1 test: temp = array_value (name, quoted, 0, &atype, &ind);

Executed by:

Self test

5864

6566

if (atype == 0 && temp)

atype == 0	Description
TRUE	evaluated 5107 times by 1 test Evaluated by: Self test
FALSE	evaluated 821 times by 1 test Evaluated by: Self test

temp	Description
TRUE	evaluated 4634 times by 1 test Evaluated by: Self test
FALSE	evaluated 473 times by 1 test Evaluated by: Self test

473-5107

6567

{

-

6568

temp = (*temp && (quoted & (Q_DOUBLE_QUOTES|Q_HERE_DOCUMENT)))

*temp	Description
TRUE	evaluated 4618 times by 1 test Evaluated by: Self test
FALSE	evaluated 16 times by 1 test Evaluated by: Self test

(quoted & (0x001\|0x002))	Description
TRUE	evaluated 4079 times by 1 test Evaluated by: Self test
FALSE	evaluated 539 times by 1 test Evaluated by: Self test

16-4618

6569

? quote_string (temp)

-

6570

: quote_escapes (temp);

-

6571

rflags |= W_ARRAYIND;

-

6572

if (indp)

indp	Description
TRUE	evaluated 4610 times by 1 test Evaluated by: Self test
FALSE	evaluated 24 times by 1 test Evaluated by: Self test

24-4610

6573

*indp = ind;

executed 4610 times by 1 test: *indp = ind;

Executed by:

Self test

4610

6574

}

executed 4634 times by 1 test: end of block

Executed by:

Self test

4634

6575

else if (atype == 1 && temp && QUOTED_NULL (temp) && (quoted & (Q_DOUBLE_QUOTES|Q_HERE_DOCUMENT)))

atype == 1	Description
TRUE	evaluated 156 times by 1 test Evaluated by: Self test
FALSE	evaluated 1138 times by 1 test Evaluated by: Self test

temp	Description
TRUE	evaluated 156 times by 1 test Evaluated by: Self test
FALSE	never evaluated

(temp)[0] == '\177'	Description
TRUE	evaluated 1 time by 1 test Evaluated by: Self test
FALSE	evaluated 155 times by 1 test Evaluated by: Self test

(temp)[1] == '\0'	Description
TRUE	evaluated 1 time by 1 test Evaluated by: Self test
FALSE	never evaluated

(quoted & (0x001\|0x002))	Description
TRUE	evaluated 1 time by 1 test Evaluated by: Self test
FALSE	never evaluated

0-1138

6576

rflags |= W_HASQUOTEDNULL;

executed 1 time by 1 test: rflags |= 0x040000;

Executed by:

Self test

1

6577

}

executed 5928 times by 1 test: end of block

Executed by:

Self test

5928

6578

#endif

-

6579

else if (var = find_variable (name))

var = find_variable (name)	Description
TRUE	evaluated 2340452 times by 1 test Evaluated by: Self test
FALSE	evaluated 7362 times by 1 test Evaluated by: Self test

7362-2340452

6580

{

-

6581

if (var_isset (var) && invisible_p (var) == 0)

((var)->value != 0)	Description
TRUE	evaluated 2340446 times by 1 test Evaluated by: Self test
FALSE	evaluated 6 times by 1 test Evaluated by: Self test

((((var)->attr...001000))) == 0	Description
TRUE	evaluated 2340408 times by 1 test Evaluated by: Self test
FALSE	evaluated 38 times by 1 test Evaluated by: Self test

6-2340446

6582

{

-

6583

#if defined (ARRAY_VARS)

-

6584

if (assoc_p (var))

((((var)->attr... (0x0000040)))	Description
TRUE	evaluated 6 times by 1 test Evaluated by: Self test
FALSE	evaluated 2340402 times by 1 test Evaluated by: Self test

6-2340402

6585

temp = assoc_reference (assoc_cell (var), "0");

executed 6 times by 1 test: temp = assoc_reference ((HASH_TABLE *)((var)->value), "0");

Executed by:

Self test

6

6586

else if (array_p (var))

((((var)->attr... (0x0000004)))	Description
TRUE	evaluated 125 times by 1 test Evaluated by: Self test
FALSE	evaluated 2340277 times by 1 test Evaluated by: Self test

125-2340277

6587

temp = array_reference (array_cell (var), 0);

executed 125 times by 1 test: temp = array_reference ((ARRAY *)((var)->value), 0);

Executed by:

Self test

125

6588

else

-

6589

temp = value_cell (var);

executed 2340277 times by 1 test: temp = ((var)->value);

Executed by:

Self test

2340277

6590

#else

-

6591

temp = value_cell (var);

-

6592

#endif

-

6593

-

6594

if (temp)

temp	Description
TRUE	evaluated 2340390 times by 1 test Evaluated by: Self test
FALSE	evaluated 18 times by 1 test Evaluated by: Self test

18-2340390

6595

temp = (*temp && (quoted & (Q_DOUBLE_QUOTES|Q_HERE_DOCUMENT)))

executed 2340390 times by 1 test: temp = (*temp && (quoted & (0x001|0x002))) ? quote_string (temp) : quote_escapes (temp);

Executed by:

Self test

*temp	Description
TRUE	evaluated 2334174 times by 1 test Evaluated by: Self test
FALSE	evaluated 6216 times by 1 test Evaluated by: Self test

(quoted & (0x001\|0x002))	Description
TRUE	evaluated 8388 times by 1 test Evaluated by: Self test
FALSE	evaluated 2325786 times by 1 test Evaluated by: Self test

6216-2340390

6596

? quote_string (temp)

executed 2340390 times by 1 test: temp = (*temp && (quoted & (0x001|0x002))) ? quote_string (temp) : quote_escapes (temp);

Executed by:

Self test

2340390

6597

: quote_escapes (temp);

executed 2340390 times by 1 test: temp = (*temp && (quoted & (0x001|0x002))) ? quote_string (temp) : quote_escapes (temp);

Executed by:

Self test

2340390

6598

}

executed 2340408 times by 1 test: end of block

Executed by:

Self test

2340408

6599

else

-

6600

temp = (char *)NULL;

executed 44 times by 1 test: temp = (char *) ((void *)0) ;

Executed by:

Self test

44

6601

}

-

6602

else if (var = find_variable_last_nameref (name, 0))

var = find_var...eref (name, 0)	Description
TRUE	evaluated 6 times by 1 test Evaluated by: Self test
FALSE	evaluated 7356 times by 1 test Evaluated by: Self test

6-7356

6603

{

-

6604

temp = nameref_cell (var);

-

6605

#if defined (ARRAY_VARS)

-

6606

/* Handle expanding nameref whose value is x[n] */

-

6607

if (temp && *temp && valid_array_reference (temp, 0))

temp	Description
TRUE	evaluated 6 times by 1 test Evaluated by: Self test
FALSE	never evaluated

*temp	Description
TRUE	evaluated 6 times by 1 test Evaluated by: Self test
FALSE	never evaluated

valid_array_re...ence (temp, 0)	Description
TRUE	evaluated 4 times by 1 test Evaluated by: Self test
FALSE	evaluated 2 times by 1 test Evaluated by: Self test

0-6

6608

{

-

6609

name = temp;

-

6610

goto expand_arrayref;

executed 4 times by 1 test: goto expand_arrayref;

Executed by:

Self test

4

6611

}

-

6612

else

-

6613

#endif

-

6614

/* y=2 ; typeset -n x=y; echo ${x} is not the same as echo ${2} in ksh */

-

6615

if (temp && *temp && legal_identifier (temp) == 0)

temp	Description
TRUE	evaluated 2 times by 1 test Evaluated by: Self test
FALSE	never evaluated

*temp	Description
TRUE	evaluated 2 times by 1 test Evaluated by: Self test
FALSE	never evaluated

legal_identifier (temp) == 0	Description
TRUE	never evaluated
FALSE	evaluated 2 times by 1 test Evaluated by: Self test

0-2

6616

{

-

6617

last_command_exit_value = EXECUTION_FAILURE;

-

6618

report_error (_("%s: invalid variable name for name reference"), temp);

-

6619

temp = &expand_param_error;

-

6620

}

never executed: end of block

0

6621

else

-

6622

temp = (char *)NULL;

executed 2 times by 1 test: temp = (char *) ((void *)0) ;

Executed by:

Self test

2

6623

}

-

6624

else

-

6625

temp = (char *)NULL;

executed 7356 times by 1 test: temp = (char *) ((void *)0) ;

Executed by:

Self test

7356

6626

-

6627

if (ret == 0)

ret == 0	Description
TRUE	evaluated 2368605 times by 1 test Evaluated by: Self test
FALSE	evaluated 797 times by 1 test Evaluated by: Self test

797-2368605

6628

{

-

6629

ret = alloc_word_desc ();

-

6630

ret->word = temp;

-

6631

ret->flags |= rflags;

-

6632

}

executed 2368605 times by 1 test: end of block

Executed by:

Self test

2368605

6633

return ret;

executed 2369402 times by 1 test: return ret;

Executed by:

Self test

2369402

6634

}

-

6635

-

6636

static char *

-

6637

parameter_brace_find_indir (name, var_is_special, quoted, find_nameref)

-

6638

char *name;

-

6639

int var_is_special, quoted, find_nameref;

-

6640

{

-

6641

char *temp, *t;

-

6642

WORD_DESC *w;

-

6643

SHELL_VAR *v;

-

6644

int pflags, oldex;

-

6645

-

6646

if (find_nameref && var_is_special == 0 && (v = find_variable_last_nameref (name, 0)) &&

find_nameref	Description
TRUE	evaluated 2 times by 1 test Evaluated by: Self test
FALSE	evaluated 104 times by 1 test Evaluated by: Self test

var_is_special == 0	Description
TRUE	evaluated 2 times by 1 test Evaluated by: Self test
FALSE	never evaluated

(v = find_vari...ref (name, 0))	Description
TRUE	evaluated 2 times by 1 test Evaluated by: Self test
FALSE	never evaluated

0-104

6647

nameref_p (v) && (t = nameref_cell (v)) && *t)

((((v)->attrib... (0x0000800)))	Description
TRUE	never evaluated
FALSE	evaluated 2 times by 1 test Evaluated by: Self test

(t = ((v)->value))	Description
TRUE	never evaluated
FALSE	never evaluated

*t	Description
TRUE	never evaluated
FALSE	never evaluated

0-2

6648

return (savestring (t));

never executed: return ((char *)strcpy (sh_xmalloc((1 + strlen (t)), "subst.c", 6648), (t)));

0

6649

-

6650

/* If var_is_special == 0, and name is not an array reference, this does

-

6651

more expansion than necessary. It should really look up the variable's

-

6652

value and not try to expand it. */

-

6653

pflags = PF_IGNUNBOUND;

-

6654

/* Note that we're not going to be doing word splitting here */

-

6655

if (var_is_special)

var_is_special	Description
TRUE	evaluated 12 times by 1 test Evaluated by: Self test
FALSE	evaluated 94 times by 1 test Evaluated by: Self test

12-94

6656

{

-

6657

pflags |= PF_ASSIGNRHS; /* suppresses word splitting */

-

6658

oldex = expand_no_split_dollar_star;

-

6659

expand_no_split_dollar_star = 1;

-

6660

}

executed 12 times by 1 test: end of block

Executed by:

Self test

12

6661

w = parameter_brace_expand_word (name, var_is_special, quoted, pflags, 0);

-

6662

if (var_is_special)

var_is_special	Description
TRUE	evaluated 12 times by 1 test Evaluated by: Self test
FALSE	evaluated 94 times by 1 test Evaluated by: Self test

12-94

6663

expand_no_split_dollar_star = oldex;

executed 12 times by 1 test: expand_no_split_dollar_star = oldex;

Executed by:

Self test

12

6664

-

6665

t = w->word;

-

6666

/* Have to dequote here if necessary */

-

6667

if (t)

t	Description
TRUE	evaluated 93 times by 1 test Evaluated by: Self test
FALSE	evaluated 13 times by 1 test Evaluated by: Self test

13-93

6668

{

-

6669

temp = ((quoted & (Q_DOUBLE_QUOTES|Q_HERE_DOCUMENT)) || var_is_special)

(quoted & (0x001\|0x002))	Description
TRUE	evaluated 22 times by 1 test Evaluated by: Self test
FALSE	evaluated 71 times by 1 test Evaluated by: Self test

var_is_special	Description
TRUE	evaluated 10 times by 1 test Evaluated by: Self test
FALSE	evaluated 61 times by 1 test Evaluated by: Self test

10-71

6670

? dequote_string (t)

-

6671

: dequote_escapes (t);

-

6672

free (t);

-

6673

t = temp;

-

6674

}

executed 93 times by 1 test: end of block

Executed by:

Self test

93

6675

dispose_word_desc (w);

-

6676

-

6677

return t;

executed 106 times by 1 test: return t;

Executed by:

Self test

106

6678

}

-

6679

-

6680

/* Expand an indirect reference to a variable: ${!NAME} expands to the

-

6681

value of the variable whose name is the value of NAME. */

-

6682

static WORD_DESC *

-

6683

parameter_brace_expand_indir (name, var_is_special, quoted, quoted_dollar_atp, contains_dollar_at)

-

6684

char *name;

-

6685

int var_is_special, quoted;

-

6686

int *quoted_dollar_atp, *contains_dollar_at;

-

6687

{

-

6688

char *t;

-

6689

WORD_DESC *w;

-

6690

SHELL_VAR *v;

-

6691

-

6692

/* See if it's a nameref first, behave in ksh93-compatible fashion.

-

6693

There is at least one incompatibility: given ${!foo[0]} where foo=bar,

-

6694

bash performs an indirect lookup on foo[0] and expands the result;

-

6695

ksh93 expands bar[0]. We could do that here -- there are enough usable

-

6696

primitives to do that -- but do not at this point. */

-

6697

if (var_is_special == 0 && (v = find_variable_last_nameref (name, 0)))

var_is_special == 0	Description
TRUE	evaluated 118 times by 1 test Evaluated by: Self test
FALSE	evaluated 12 times by 1 test Evaluated by: Self test

(v = find_vari...ref (name, 0))	Description
TRUE	evaluated 65 times by 1 test Evaluated by: Self test
FALSE	evaluated 53 times by 1 test Evaluated by: Self test

12-118

6698

{

-

6699

if (nameref_p (v) && (t = nameref_cell (v)) && *t)

((((v)->attrib... (0x0000800)))	Description
TRUE	evaluated 20 times by 1 test Evaluated by: Self test
FALSE	evaluated 45 times by 1 test Evaluated by: Self test

(t = ((v)->value))	Description
TRUE	evaluated 20 times by 1 test Evaluated by: Self test
FALSE	never evaluated

*t	Description
TRUE	evaluated 20 times by 1 test Evaluated by: Self test
FALSE	never evaluated

0-45

6700

{

-

6701

w = alloc_word_desc ();

-

6702

w->word = savestring (t);

-

6703

w->flags = 0;

-

6704

return w;

executed 20 times by 1 test: return w;

Executed by:

Self test

20

6705

}

-

6706

}

executed 45 times by 1 test: end of block

Executed by:

Self test

45

6707

-

6708

/* An indirect reference to a positional parameter or a special parameter

-

6709

is ok. Indirect references to array references, as explained above, are

-

6710

ok (currently). Only references to unset variables are errors at this

-

6711

point. */

-

6712

if (legal_identifier (name) && v == 0)

legal_identifier (name)	Description
TRUE	evaluated 51 times by 1 test Evaluated by: Self test
FALSE	evaluated 59 times by 1 test Evaluated by: Self test

v == 0	Description
TRUE	evaluated 6 times by 1 test Evaluated by: Self test
FALSE	evaluated 45 times by 1 test Evaluated by: Self test

6-59

6713

{

-

6714

report_error (_("%s: invalid indirect expansion"), name);

-

6715

w = alloc_word_desc ();

-

6716

w->word = &expand_param_error;

-

6717

w->flags = 0;

-

6718

return (w);

executed 6 times by 1 test: return (w);

Executed by:

Self test

6

6719

}

-

6720

-

6721

t = parameter_brace_find_indir (name, var_is_special, quoted, 0);

-

6722

-

6723

chk_atstar (t, quoted, quoted_dollar_atp, contains_dollar_at);

-

6724

-

6725

#if defined (ARRAY_VARS)

-

6726

/* Array references to unset variables are also an error */

-

6727

if (t == 0 && valid_array_reference (name, 0))

t == 0	Description
TRUE	evaluated 13 times by 1 test Evaluated by: Self test
FALSE	evaluated 91 times by 1 test Evaluated by: Self test

valid_array_re...ence (name, 0)	Description
TRUE	evaluated 1 time by 1 test Evaluated by: Self test
FALSE	evaluated 12 times by 1 test Evaluated by: Self test

1-91

6728

{

-

6729

v = array_variable_part (name, 0, (char **)0, (int *)0);

-

6730

if (v == 0)

v == 0	Description
TRUE	evaluated 1 time by 1 test Evaluated by: Self test
FALSE	never evaluated

0-1

6731

{

-

6732

report_error (_("%s: invalid indirect expansion"), name);

-

6733

w = alloc_word_desc ();

-

6734

w->word = &expand_param_error;

-

6735

w->flags = 0;

-

6736

return (w);

executed 1 time by 1 test: return (w);

Executed by:

Self test

1

6737

}

-

6738

else

-

6739

return (WORD_DESC *)NULL;

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

0

6740

}

-

6741

#endif

-

6742

-

6743

if (t == 0)

t == 0	Description
TRUE	evaluated 12 times by 1 test Evaluated by: Self test
FALSE	evaluated 91 times by 1 test Evaluated by: Self test

12-91

6744

return (WORD_DESC *)NULL;

executed 12 times by 1 test: return (WORD_DESC *) ((void *)0) ;

Executed by:

Self test

12

6745

-

6746

if (valid_brace_expansion_word (t, SPECIAL_VAR (t, 0)) == 0)

valid_brace_ex... '*'))))) == 0	Description
TRUE	evaluated 10 times by 1 test Evaluated by: Self test
FALSE	evaluated 81 times by 1 test Evaluated by: Self test

10-81

6747

{

-

6748

report_error (_("%s: invalid variable name"), t);

-

6749

free (t);

-

6750

w = alloc_word_desc ();

-

6751

w->word = &expand_param_error;

-

6752

w->flags = 0;

-

6753

return (w);

executed 10 times by 1 test: return (w);

Executed by:

Self test

10

6754

}

-

6755

-

6756

w = parameter_brace_expand_word (t, SPECIAL_VAR(t, 0), quoted, 0, 0);

-

6757

free (t);

-

6758

-

6759

return w;

executed 80 times by 1 test: return w;

Executed by:

Self test

80

6760

}

-

6761

-

6762

/* Expand the right side of a parameter expansion of the form ${NAMEcVALUE},

-

6763

depending on the value of C, the separating character. C can be one of

-

6764

"-", "+", or "=". QUOTED is true if the entire brace expression occurs

-

6765

between double quotes. */

-

6766

static WORD_DESC *

-

6767

parameter_brace_expand_rhs (name, value, op, quoted, pflags, qdollaratp, hasdollarat)

-

6768

char *name, *value;

-

6769

int op, quoted, pflags, *qdollaratp, *hasdollarat;

-

6770

{

-

6771

WORD_DESC *w;

-

6772

WORD_LIST *l;

-

6773

char *t, *t1, *temp, *vname;

-

6774

int l_hasdollat, sindex;

-

6775

-

6776

/*itrace("parameter_brace_expand_rhs: %s:%s pflags = %d", name, value, pflags);*/

-

6777

/* If the entire expression is between double quotes, we want to treat

-

6778

the value as a double-quoted string, with the exception that we strip

-

6779

embedded unescaped double quotes (for sh backwards compatibility). */

-

6780

if ((quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)) && *value)

(quoted & (0x002\|0x001))	Description
TRUE	evaluated 2055 times by 1 test Evaluated by: Self test
FALSE	evaluated 8935 times by 1 test Evaluated by: Self test

*value	Description
TRUE	evaluated 2049 times by 1 test Evaluated by: Self test
FALSE	evaluated 6 times by 1 test Evaluated by: Self test

6-8935

6781

{

-

6782

sindex = 0;

-

6783

temp = string_extract_double_quoted (value, &sindex, SX_STRIPDQ);

-

6784

}

executed 2049 times by 1 test: end of block

Executed by:

Self test

2049

6785

else

-

6786

temp = value;

executed 8941 times by 1 test: temp = value;

Executed by:

Self test

8941

6787

-

6788

w = alloc_word_desc ();

-

6789

l_hasdollat = 0;

-

6790

l = *temp ? expand_string_for_rhs (temp, quoted, op, pflags, &l_hasdollat, (int *)NULL)

*temp	Description
TRUE	evaluated 10971 times by 1 test Evaluated by: Self test
FALSE	evaluated 19 times by 1 test Evaluated by: Self test

19-10971

6791

: (WORD_LIST *)0;

-

6792

if (hasdollarat)

hasdollarat	Description
TRUE	evaluated 10975 times by 1 test Evaluated by: Self test
FALSE	never evaluated

0-10975

6793

*hasdollarat = l_hasdollat || (l && l->next);

executed 10975 times by 1 test: *hasdollarat = l_hasdollat || (l && l->next);

Executed by:

Self test

l_hasdollat	Description
TRUE	evaluated 2433 times by 1 test Evaluated by: Self test
FALSE	evaluated 8542 times by 1 test Evaluated by: Self test

l	Description
TRUE	evaluated 8483 times by 1 test Evaluated by: Self test
FALSE	evaluated 59 times by 1 test Evaluated by: Self test

l->next	Description
TRUE	evaluated 14 times by 1 test Evaluated by: Self test
FALSE	evaluated 8469 times by 1 test Evaluated by: Self test

14-10975

6794

if (temp != value)

temp != value	Description
TRUE	evaluated 2044 times by 1 test Evaluated by: Self test
FALSE	evaluated 8931 times by 1 test Evaluated by: Self test

2044-8931

6795

free (temp);

executed 2044 times by 1 test: sh_xfree((temp), "subst.c", 6795);

Executed by:

Self test

2044

6796

if (l)

l	Description
TRUE	evaluated 10880 times by 1 test Evaluated by: Self test
FALSE	evaluated 95 times by 1 test Evaluated by: Self test

95-10880

6797

{

-

6798

/* If l->next is not null, we know that TEMP contained "$@", since that

-

6799

is the only expansion that creates more than one word. */

-

6800

if (qdollaratp && ((l_hasdollat && quoted) || l->next))

qdollaratp	Description
TRUE	evaluated 10880 times by 1 test Evaluated by: Self test
FALSE	never evaluated

l_hasdollat	Description
TRUE	evaluated 2397 times by 1 test Evaluated by: Self test
FALSE	evaluated 8483 times by 1 test Evaluated by: Self test

quoted	Description
TRUE	evaluated 763 times by 1 test Evaluated by: Self test
FALSE	evaluated 1634 times by 1 test Evaluated by: Self test

l->next	Description
TRUE	evaluated 77 times by 1 test Evaluated by: Self test
FALSE	evaluated 10040 times by 1 test Evaluated by: Self test

0-10880

6801

{

-

6802

/*itrace("parameter_brace_expand_rhs: %s:%s: l != NULL, set *qdollaratp", name, value);*/

-

6803

*qdollaratp = 1;

-

6804

}

executed 840 times by 1 test: end of block

Executed by:

Self test

840

6805

-

6806

/* The expansion of TEMP returned something. We need to treat things

-

6807

slightly differently if L_HASDOLLAT is non-zero. If we have "$@",

-

6808

the individual words have already been quoted. We need to turn them

-

6809

into a string with the words separated by the first character of

-

6810

$IFS without any additional quoting, so string_list_dollar_at won't

-

6811

do the right thing. If IFS is null, we want "$@" to split into

-

6812

separate arguments, not be concatenated, so we use string_list_internal

-

6813

and mark the word to be split on spaces later. We use

-

6814

string_list_dollar_star for "$@" otherwise. */

-

6815

if (l->next && ifs_is_null)

l->next	Description
TRUE	evaluated 114 times by 1 test Evaluated by: Self test
FALSE	evaluated 10766 times by 1 test Evaluated by: Self test

ifs_is_null	Description
TRUE	evaluated 21 times by 1 test Evaluated by: Self test
FALSE	evaluated 93 times by 1 test Evaluated by: Self test

21-10766

6816

{

-

6817

temp = string_list_internal (l, " ");

-

6818

w->flags |= W_SPLITSPACE;

-

6819

}

executed 21 times by 1 test: end of block

Executed by:

Self test

21

6820

else

-

6821

temp = (l_hasdollat || l->next) ? string_list_dollar_star (l, quoted, 0) : string_list (l);

executed 10859 times by 1 test: temp = (l_hasdollat || l->next) ? string_list_dollar_star (l, quoted, 0) : string_list (l);

Executed by:

Self test

l_hasdollat	Description
TRUE	evaluated 2379 times by 1 test Evaluated by: Self test
FALSE	evaluated 8480 times by 1 test Evaluated by: Self test

l->next	Description
TRUE	evaluated 11 times by 1 test Evaluated by: Self test
FALSE	evaluated 8469 times by 1 test Evaluated by: Self test

11-10859

6822

-

6823

/* If we have a quoted null result (QUOTED_NULL(temp)) and the word is

-

6824

a quoted null (l->next == 0 && QUOTED_NULL(l->word->word)), the

-

6825

flags indicate it (l->word->flags & W_HASQUOTEDNULL), and the

-

6826

expansion is quoted (quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES))

-

6827

(which is more paranoia than anything else), we need to return the

-

6828

quoted null string and set the flags to indicate it. */

-

6829

if (l->next == 0 && (quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)) && QUOTED_NULL (temp) && QUOTED_NULL (l->word->word) && (l->word->flags & W_HASQUOTEDNULL))

l->next == 0	Description
TRUE	evaluated 10766 times by 1 test Evaluated by: Self test
FALSE	evaluated 114 times by 1 test Evaluated by: Self test

(quoted & (0x002\|0x001))	Description
TRUE	evaluated 1972 times by 1 test Evaluated by: Self test
FALSE	evaluated 8794 times by 1 test Evaluated by: Self test

(temp)[0] == '\177'	Description
TRUE	evaluated 4 times by 1 test Evaluated by: Self test
FALSE	evaluated 1968 times by 1 test Evaluated by: Self test

(temp)[1] == '\0'	Description
TRUE	evaluated 4 times by 1 test Evaluated by: Self test
FALSE	never evaluated

(l->word->word)[0] == '\177'	Description
TRUE	evaluated 4 times by 1 test Evaluated by: Self test
FALSE	never evaluated

(l->word->word)[1] == '\0'	Description
TRUE	evaluated 4 times by 1 test Evaluated by: Self test
FALSE	never evaluated

(l->word->flags & 0x040000)	Description
TRUE	evaluated 4 times by 1 test Evaluated by: Self test
FALSE	never evaluated

0-10766

6830

{

-

6831

w->flags |= W_HASQUOTEDNULL;

-

6832

/*itrace("parameter_brace_expand_rhs (%s:%s): returning quoted null, turning off qdollaratp", name, value);*/

-

6833

/* If we return a quoted null with L_HASDOLLARAT, we either have a

-

6834

construct like "${@-$@}" or "${@-${@-$@}}" with no positional

-

6835

parameters or a quoted expansion of "$@" with $1 == ''. In either

-

6836

case, we don't want to enable special handling of $@. */

-

6837

if (qdollaratp && l_hasdollat)

qdollaratp	Description
TRUE	evaluated 4 times by 1 test Evaluated by: Self test
FALSE	never evaluated

l_hasdollat	Description
TRUE	never evaluated
FALSE	evaluated 4 times by 1 test Evaluated by: Self test

0-4

6838

*qdollaratp = 0;

never executed: *qdollaratp = 0;

0

6839

}

executed 4 times by 1 test: end of block

Executed by:

Self test

4

6840

dispose_words (l);

-

6841

}

executed 10880 times by 1 test: end of block

Executed by:

Self test

10880

6842

else if ((quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)) && l_hasdollat)

(quoted & (0x002\|0x001))	Description
TRUE	evaluated 41 times by 1 test Evaluated by: Self test
FALSE	evaluated 54 times by 1 test Evaluated by: Self test

l_hasdollat	Description
TRUE	evaluated 35 times by 1 test Evaluated by: Self test
FALSE	evaluated 6 times by 1 test Evaluated by: Self test

6-54

6843

{

-

6844

/* Posix interp 221 changed the rules on this. The idea is that

-

6845

something like "$xxx$@" should expand the same as "${foo-$xxx$@}"

-

6846

when foo and xxx are unset. The problem is that it's not in any

-

6847

way backwards compatible and few other shells do it. We're eventually

-

6848

going to try and split the difference (heh) a little bit here. */

-

6849

/* l_hasdollat == 1 means we saw a quoted dollar at. */

-

6850

-

6851

/* The brace expansion occurred between double quotes and there was

-

6852

a $@ in TEMP. It does not matter if the $@ is quoted, as long as

-

6853

it does not expand to anything. In this case, we want to return

-

6854

a quoted empty string. Posix interp 888 */

-

6855

temp = make_quoted_char ('\0');

-

6856

w->flags |= W_HASQUOTEDNULL;

-

6857

/*itrace("parameter_brace_expand_rhs (%s:%s): returning quoted null", name, value);*/

-

6858

}

executed 35 times by 1 test: end of block

Executed by:

Self test

35

6859

else

-

6860

temp = (char *)NULL;

executed 60 times by 1 test: temp = (char *) ((void *)0) ;

Executed by:

Self test

60

6861

-

6862

if (op == '-' || op == '+')

op == '-'	Description
TRUE	evaluated 949 times by 1 test Evaluated by: Self test
FALSE	evaluated 10026 times by 1 test Evaluated by: Self test

op == '+'	Description
TRUE	evaluated 4881 times by 1 test Evaluated by: Self test
FALSE	evaluated 5145 times by 1 test Evaluated by: Self test

949-10026

6863

{

-

6864

w->word = temp;

-

6865

return w;

executed 5830 times by 1 test: return w;

Executed by:

Self test

5830

6866

}

-

6867

-

6868

/* op == '=' */

-

6869

t1 = temp ? dequote_string (temp) : savestring ("");

temp	Description
TRUE	evaluated 5136 times by 1 test Evaluated by: Self test
FALSE	evaluated 9 times by 1 test Evaluated by: Self test

9-5136

6870

free (temp);

-

6871

-

6872

/* bash-4.4/5.0 */

-

6873

vname = name;

-

6874

if (*name == '!' &&

*name == '!'	Description
TRUE	never evaluated
FALSE	evaluated 5145 times by 1 test Evaluated by: Self test

0-5145

6875

(legal_variable_starter ((unsigned char)name[1]) || DIGIT (name[1]) || VALID_INDIR_PARAM (name[1])))

((*__ctype_b_l...int) _ISalpha)	Description
TRUE	never evaluated
FALSE	never evaluated

((unsigned cha...ame[1] == '_')	Description
TRUE	never evaluated
FALSE	never evaluated

(name[1]) >= '0'	Description
TRUE	never evaluated
FALSE	never evaluated

(name[1]) <= '9'	Description
TRUE	never evaluated
FALSE	never evaluated

posixly_correct == 0	Description
TRUE	never evaluated
FALSE	never evaluated

(name[1]) == '#'	Description
TRUE	never evaluated
FALSE	never evaluated

posixly_correct == 0	Description
TRUE	never evaluated
FALSE	never evaluated

(name[1]) == '?'	Description
TRUE	never evaluated
FALSE	never evaluated

(name[1]) == '@'	Description
TRUE	never evaluated
FALSE	never evaluated

(name[1]) == '*'	Description
TRUE	never evaluated
FALSE	never evaluated

0

6876

{

-

6877

vname = parameter_brace_find_indir (name + 1, SPECIAL_VAR (name, 1), quoted, 1);

-

6878

if (vname == 0 || *vname == 0)

vname == 0	Description
TRUE	never evaluated
FALSE	never evaluated

*vname == 0	Description
TRUE	never evaluated
FALSE	never evaluated

0

6879

{

-

6880

report_error (_("%s: invalid indirect expansion"), name);

-

6881

free (vname);

-

6882

dispose_word (w);

-

6883

return &expand_wdesc_error;

never executed: return &expand_wdesc_error;

0

6884

}

-

6885

if (legal_identifier (vname) == 0)

legal_identifier (vname) == 0	Description
TRUE	never evaluated
FALSE	never evaluated

0

6886

{

-

6887

report_error (_("%s: invalid variable name"), vname);

-

6888

free (vname);

-

6889

dispose_word (w);

-

6890

return &expand_wdesc_error;

never executed: return &expand_wdesc_error;

0

6891

}

-

6892

}

never executed: end of block

0

6893

-

6894

#if defined (ARRAY_VARS)

-

6895

if (valid_array_reference (vname, 0))

valid_array_re...nce (vname, 0)	Description
TRUE	evaluated 1 time by 1 test Evaluated by: Self test
FALSE	evaluated 5144 times by 1 test Evaluated by: Self test

1-5144

6896

assign_array_element (vname, t1, 0);

executed 1 time by 1 test: assign_array_element (vname, t1, 0);

Executed by:

Self test

1

6897

else

-

6898

#endif /* ARRAY_VARS */

-

6899

bind_variable (vname, t1, 0);

executed 5144 times by 1 test: bind_variable (vname, t1, 0);

Executed by:

Self test

5144

6900

-

6901

stupidly_hack_special_variables (vname);

-

6902

-

6903

if (vname != name)

vname != name	Description
TRUE	never evaluated
FALSE	evaluated 5145 times by 1 test Evaluated by: Self test

0-5145

6904

free (vname);

never executed: sh_xfree((vname), "subst.c", 6904);

0

6905

-

6906

/* From Posix group discussion Feb-March 2010. Issue 7 0000221 */

-

6907

-

6908

/* If we are double-quoted or if we are not going to be performing word

-

6909

splitting, we want to quote the value we return appropriately, like

-

6910

the other expansions this function handles. */

-

6911

w->word = (quoted & (Q_DOUBLE_QUOTES|Q_HERE_DOCUMENT)) ? quote_string (t1) : quote_escapes (t1);

(quoted & (0x001\|0x002))	Description
TRUE	evaluated 1656 times by 1 test Evaluated by: Self test
FALSE	evaluated 3489 times by 1 test Evaluated by: Self test

1656-3489

6912

free (t1);

-

6913

-

6914

return w;

executed 5145 times by 1 test: return w;

Executed by:

Self test

5145

6915

}

-

6916

-

6917

/* Deal with the right hand side of a ${name:?value} expansion in the case

-

6918

that NAME is null or not set. If VALUE is non-null it is expanded and

-

6919

used as the error message to print, otherwise a standard message is

-

6920

printed. */

-

6921

static void

-

6922

parameter_brace_expand_error (name, value, check_null)

-

6923

char *name, *value;

-

6924

int check_null;

-

6925

{

-

6926

WORD_LIST *l;

-

6927

char *temp;

-

6928

-

6929

last_command_exit_value = EXECUTION_FAILURE; /* ensure it's non-zero */

-

6930

if (value && *value)

value	Description
TRUE	evaluated 14 times by 1 test Evaluated by: Self test
FALSE	never evaluated

*value	Description
TRUE	evaluated 2 times by 1 test Evaluated by: Self test
FALSE	evaluated 12 times by 1 test Evaluated by: Self test

0-14

6931

{

-

6932

l = expand_string (value, 0);

-

6933

temp = string_list (l);

-

6934

report_error ("%s: %s", name, temp ? temp : ""); /* XXX was value not "" */

-

6935

FREE (temp);

executed 2 times by 1 test: sh_xfree((temp), "subst.c", 6935);

Executed by:

Self test

temp	Description
TRUE	evaluated 2 times by 1 test Evaluated by: Self test
FALSE	never evaluated

0-2

6936

dispose_words (l);

-

6937

}

executed 2 times by 1 test: end of block

Executed by:

Self test

2

6938

else if (check_null == 0)

check_null == 0	Description
TRUE	evaluated 7 times by 1 test Evaluated by: Self test
FALSE	evaluated 5 times by 1 test Evaluated by: Self test

5-7

6939

report_error (_("%s: parameter not set"), name);

executed 7 times by 1 test: report_error ( dcgettext (((void *)0), "%s: parameter not set" , 5) , name);

Executed by:

Self test

7

6940

else

-

6941

report_error (_("%s: parameter null or not set"), name);

executed 5 times by 1 test: report_error ( dcgettext (((void *)0), "%s: parameter null or not set" , 5) , name);

Executed by:

Self test

5

6942

-

6943

/* Free the data we have allocated during this expansion, since we

-

6944

are about to longjmp out. */

-

6945

free (name);

-

6946

FREE (value);

executed 14 times by 1 test: sh_xfree((value), "subst.c", 6946);

Executed by:

Self test

value	Description
TRUE	evaluated 14 times by 1 test Evaluated by: Self test
FALSE	never evaluated

0-14

6947

}

executed 14 times by 1 test: end of block

Executed by:

Self test

14

6948

-

6949

/* Return 1 if NAME is something for which parameter_brace_expand_length is

-

6950

OK to do. */

-

6951

static int

-

6952

valid_length_expression (name)

-

6953

char *name;

-

6954

{

-

6955

return (name[1] == '\0' || /* ${#} */

executed 521 times by 1 test:

return (name[1] == '\0' || ((sh_syntaxtab[(unsigned char) name[1]] & 0x0800) && name[2] == '\0') || (((name[1]) >= '0' && (name[1]) <= '9') && all_digits (name + 1)) || valid_array_reference (name + 1, 0) || legal_identifier (name + 1));

Executed by:

Self test

521

6956

((sh_syntaxtab[(unsigned char) name[1]] & CSPECVAR) && name[2] == '\0') || /* special param */

executed 521 times by 1 test:

return (name[1] == '\0' || ((sh_syntaxtab[(unsigned char) name[1]] & 0x0800) && name[2] == '\0') || (((name[1]) >= '0' && (name[1]) <= '9') && all_digits (name + 1)) || valid_array_reference (name + 1, 0) || legal_identifier (name + 1));

Executed by:

Self test

521

6957

(DIGIT (name[1]) && all_digits (name + 1)) || /* ${#11} */

executed 521 times by 1 test:

return (name[1] == '\0' || ((sh_syntaxtab[(unsigned char) name[1]] & 0x0800) && name[2] == '\0') || (((name[1]) >= '0' && (name[1]) <= '9') && all_digits (name + 1)) || valid_array_reference (name + 1, 0) || legal_identifier (name + 1));

Executed by:

Self test

521

6958

#if defined (ARRAY_VARS)

executed 521 times by 1 test:

return (name[1] == '\0' || ((sh_syntaxtab[(unsigned char) name[1]] & 0x0800) && name[2] == '\0') || (((name[1]) >= '0' && (name[1]) <= '9') && all_digits (name + 1)) || valid_array_reference (name + 1, 0) || legal_identifier (name + 1));

Executed by:

Self test

521

6959

valid_array_reference (name + 1, 0) || /* ${#a[7]} */

executed 521 times by 1 test:

return (name[1] == '\0' || ((sh_syntaxtab[(unsigned char) name[1]] & 0x0800) && name[2] == '\0') || (((name[1]) >= '0' && (name[1]) <= '9') && all_digits (name + 1)) || valid_array_reference (name + 1, 0) || legal_identifier (name + 1));

Executed by:

Self test

521

6960

#endif

executed 521 times by 1 test:

return (name[1] == '\0' || ((sh_syntaxtab[(unsigned char) name[1]] & 0x0800) && name[2] == '\0') || (((name[1]) >= '0' && (name[1]) <= '9') && all_digits (name + 1)) || valid_array_reference (name + 1, 0) || legal_identifier (name + 1));

Executed by:

Self test

521

6961

legal_identifier (name + 1)); /* ${#PS1} */

executed 521 times by 1 test:

return (name[1] == '\0' || ((sh_syntaxtab[(unsigned char) name[1]] & 0x0800) && name[2] == '\0') || (((name[1]) >= '0' && (name[1]) <= '9') && all_digits (name + 1)) || valid_array_reference (name + 1, 0) || legal_identifier (name + 1));

Executed by:

Self test

521

6962

}

-

6963

-

6964

/* Handle the parameter brace expansion that requires us to return the

-

6965

length of a parameter. */

-

6966

static intmax_t

-

6967

parameter_brace_expand_length (name)

-

6968

char *name;

-

6969

{

-

6970

char *t, *newname;

-

6971

intmax_t number, arg_index;

-

6972

WORD_LIST *list;

-

6973

#if defined (ARRAY_VARS)

-

6974

SHELL_VAR *var;

-

6975

#endif

-

6976

-

6977

if (name[1] == '\0') /* ${#} */

name[1] == '\0'	Description
TRUE	never evaluated
FALSE	evaluated 518 times by 1 test Evaluated by: Self test

0-518

6978

number = number_of_args ();

never executed: number = number_of_args ();

0

6979

else if (DOLLAR_AT_STAR (name[1]) && name[2] == '\0') /* ${#@}, ${#*} */

(name[1]) == '@'	Description
TRUE	evaluated 7 times by 1 test Evaluated by: Self test
FALSE	evaluated 511 times by 1 test Evaluated by: Self test

(name[1]) == '*'	Description
TRUE	evaluated 5 times by 1 test Evaluated by: Self test
FALSE	evaluated 506 times by 1 test Evaluated by: Self test

name[2] == '\0'	Description
TRUE	evaluated 12 times by 1 test Evaluated by: Self test
FALSE	never evaluated

0-511

6980

number = number_of_args ();

executed 12 times by 1 test: number = number_of_args ();

Executed by:

Self test

12

6981

else if ((sh_syntaxtab[(unsigned char) name[1]] & CSPECVAR) && name[2] == '\0')

(sh_syntaxtab[...[1]] & 0x0800)	Description
TRUE	evaluated 8 times by 1 test Evaluated by: Self test
FALSE	evaluated 498 times by 1 test Evaluated by: Self test

name[2] == '\0'	Description
TRUE	evaluated 8 times by 1 test Evaluated by: Self test
FALSE	never evaluated

0-498

6982

{

-

6983

/* Take the lengths of some of the shell's special parameters. */

-

6984

switch (name[1])

-

6985

{

-

6986

case '-':

executed 1 time by 1 test: case '-':

Executed by:

Self test

1

6987

t = which_set_flags ();

-

6988

break;

executed 1 time by 1 test: break;

Executed by:

Self test

1

6989

case '?':

executed 4 times by 1 test: case '?':

Executed by:

Self test

4

6990

t = itos (last_command_exit_value);

-

6991

break;

executed 4 times by 1 test: break;

Executed by:

Self test

4

6992

case '$':

never executed: case '$':

0

6993

t = itos (dollar_dollar_pid);

-

6994

break;

never executed: break;

0

6995

case '!':

executed 1 time by 1 test: case '!':

Executed by:

Self test

1

6996

if (last_asynchronous_pid == NO_PID)

last_asynchron...d == (pid_t)-1	Description
TRUE	evaluated 1 time by 1 test Evaluated by: Self test
FALSE	never evaluated

0-1

6997

t = (char *)NULL; /* XXX - error if set -u set? */

executed 1 time by 1 test: t = (char *) ((void *)0) ;

Executed by:

Self test

1

6998

else

-

6999

t = itos (last_asynchronous_pid);

never executed: t = itos (last_asynchronous_pid);

0

7000

break;

executed 1 time by 1 test: break;

Executed by:

Self test

1

7001

case '#':

executed 2 times by 1 test: case '#':

Executed by:

Self test

2

7002

t = itos (number_of_args ());

-

7003

break;

executed 2 times by 1 test: break;

Executed by:

Self test

2

7004

}

-

7005

number = STRLEN (t);

(t)[1]	Description
TRUE	evaluated 1 time by 1 test Evaluated by: Self test
FALSE	evaluated 6 times by 1 test Evaluated by: Self test

(t)[2]	Description
TRUE	never evaluated
FALSE	evaluated 1 time by 1 test Evaluated by: Self test

(t)	Description
TRUE	evaluated 7 times by 1 test Evaluated by: Self test
FALSE	evaluated 1 time by 1 test Evaluated by: Self test

(t)[0]	Description
TRUE	evaluated 7 times by 1 test Evaluated by: Self test
FALSE	never evaluated

0-7

7006

FREE (t);

executed 7 times by 1 test: sh_xfree((t), "subst.c", 7006);

Executed by:

Self test

t	Description
TRUE	evaluated 7 times by 1 test Evaluated by: Self test
FALSE	evaluated 1 time by 1 test Evaluated by: Self test

1-7

7007

}

executed 8 times by 1 test: end of block

Executed by:

Self test

8

7008

#if defined (ARRAY_VARS)

-

7009

else if (valid_array_reference (name + 1, 0))

valid_array_re... (name + 1, 0)	Description
TRUE	evaluated 266 times by 1 test Evaluated by: Self test
FALSE	evaluated 232 times by 1 test Evaluated by: Self test

232-266

7010

number = array_length_reference (name + 1);

executed 266 times by 1 test: number = array_length_reference (name + 1);

Executed by:

Self test

266

7011

#endif /* ARRAY_VARS */

-

7012

else

-

7013

{

-

7014

number = 0;

-

7015

-

7016

if (legal_number (name + 1, &arg_index)) /* ${#1} */

legal_number (...1, &arg_index)	Description
TRUE	evaluated 27 times by 1 test Evaluated by: Self test
FALSE	evaluated 205 times by 1 test Evaluated by: Self test

27-205

7017

{

-

7018

t = get_dollar_var_value (arg_index);

-

7019

if (t == 0 && unbound_vars_is_error)

t == 0	Description
TRUE	evaluated 1 time by 1 test Evaluated by: Self test
FALSE	evaluated 26 times by 1 test Evaluated by: Self test

unbound_vars_is_error	Description
TRUE	evaluated 1 time by 1 test Evaluated by: Self test
FALSE	never evaluated

0-26

7020

return INTMAX_MIN;

executed 1 time by 1 test: return (-9223372036854775807L -1) ;

Executed by:

Self test

1

7021

number = MB_STRLEN (t);

( (__ctype_get...r_max ()) > 1)	Description
TRUE	evaluated 26 times by 1 test Evaluated by: Self test
FALSE	never evaluated

(t)[1]	Description
TRUE	evaluated 26 times by 1 test Evaluated by: Self test
FALSE	never evaluated

(t)[1]	Description
TRUE	never evaluated
FALSE	never evaluated

(t)[2]	Description
TRUE	never evaluated
FALSE	never evaluated

(t)	Description
TRUE	evaluated 26 times by 1 test Evaluated by: Self test
FALSE	never evaluated

(t)[0]	Description
TRUE	evaluated 26 times by 1 test Evaluated by: Self test
FALSE	never evaluated

(t)	Description
TRUE	never evaluated
FALSE	never evaluated

(t)[0]	Description
TRUE	never evaluated
FALSE	never evaluated

0-26

7022

FREE (t);

executed 26 times by 1 test: sh_xfree((t), "subst.c", 7022);

Executed by:

Self test

t	Description
TRUE	evaluated 26 times by 1 test Evaluated by: Self test
FALSE	never evaluated

0-26

7023

}

executed 26 times by 1 test: end of block

Executed by:

Self test

26

7024

#if defined (ARRAY_VARS)

-

7025

else if ((var = find_variable (name + 1)) && (invisible_p (var) == 0) && (array_p (var) || assoc_p (var)))

(var = find_va...le (name + 1))	Description
TRUE	evaluated 201 times by 1 test Evaluated by: Self test
FALSE	evaluated 4 times by 1 test Evaluated by: Self test

(((((var)->att...01000))) == 0)	Description
TRUE	evaluated 201 times by 1 test Evaluated by: Self test
FALSE	never evaluated

((((var)->attr... (0x0000004)))	Description
TRUE	evaluated 4 times by 1 test Evaluated by: Self test
FALSE	evaluated 197 times by 1 test Evaluated by: Self test

((((var)->attr... (0x0000040)))	Description
TRUE	evaluated 2 times by 1 test Evaluated by: Self test
FALSE	evaluated 195 times by 1 test Evaluated by: Self test

0-201

7026

{

-

7027

if (assoc_p (var))

((((var)->attr... (0x0000040)))	Description
TRUE	evaluated 2 times by 1 test Evaluated by: Self test
FALSE	evaluated 4 times by 1 test Evaluated by: Self test

2-4

7028

t = assoc_reference (assoc_cell (var), "0");

executed 2 times by 1 test: t = assoc_reference ((HASH_TABLE *)((var)->value), "0");

Executed by:

Self test

2

7029

else

-

7030

t = array_reference (array_cell (var), 0);

executed 4 times by 1 test: t = array_reference ((ARRAY *)((var)->value), 0);

Executed by:

Self test

4

7031

if (t == 0 && unbound_vars_is_error)

t == 0	Description
TRUE	evaluated 1 time by 1 test Evaluated by: Self test
FALSE	evaluated 5 times by 1 test Evaluated by: Self test

unbound_vars_is_error	Description
TRUE	evaluated 1 time by 1 test Evaluated by: Self test
FALSE	never evaluated

0-5

7032

return INTMAX_MIN;

executed 1 time by 1 test: return (-9223372036854775807L -1) ;

Executed by:

Self test

1

7033

number = MB_STRLEN (t);

( (__ctype_get...r_max ()) > 1)	Description
TRUE	evaluated 5 times by 1 test Evaluated by: Self test
FALSE	never evaluated

(t)[1]	Description
TRUE	evaluated 5 times by 1 test Evaluated by: Self test
FALSE	never evaluated

(t)[1]	Description
TRUE	never evaluated
FALSE	never evaluated

(t)[2]	Description
TRUE	never evaluated
FALSE	never evaluated

(t)	Description
TRUE	evaluated 5 times by 1 test Evaluated by: Self test
FALSE	never evaluated

(t)[0]	Description
TRUE	evaluated 5 times by 1 test Evaluated by: Self test
FALSE	never evaluated

(t)	Description
TRUE	never evaluated
FALSE	never evaluated

(t)[0]	Description
TRUE	never evaluated
FALSE	never evaluated

0-5

7034

}

executed 5 times by 1 test: end of block

Executed by:

Self test

5

7035

#endif

-

7036

else /* ${#PS1} */

-

7037

{

-

7038

newname = savestring (name);

-

7039

newname[0] = '$';

-

7040

list = expand_string (newname, Q_DOUBLE_QUOTES);

-

7041

t = list ? string_list (list) : (char *)NULL;

list	Description
TRUE	evaluated 190 times by 1 test Evaluated by: Self test
FALSE	evaluated 6 times by 1 test Evaluated by: Self test

6-190

7042

free (newname);

-

7043

if (list)

list	Description
TRUE	evaluated 190 times by 1 test Evaluated by: Self test
FALSE	evaluated 6 times by 1 test Evaluated by: Self test

6-190

7044

dispose_words (list);

executed 190 times by 1 test: dispose_words (list);

Executed by:

Self test

190

7045

-

7046

number = t ? MB_STRLEN (t) : 0;

t	Description
TRUE	evaluated 190 times by 1 test Evaluated by: Self test
FALSE	evaluated 6 times by 1 test Evaluated by: Self test

( (__ctype_get...r_max ()) > 1)	Description
TRUE	evaluated 186 times by 1 test Evaluated by: Self test
FALSE	evaluated 4 times by 1 test Evaluated by: Self test

(t)[1]	Description
TRUE	evaluated 173 times by 1 test Evaluated by: Self test
FALSE	evaluated 13 times by 1 test Evaluated by: Self test

(t)[1]	Description
TRUE	evaluated 4 times by 1 test Evaluated by: Self test
FALSE	never evaluated

(t)[2]	Description
TRUE	evaluated 4 times by 1 test Evaluated by: Self test
FALSE	never evaluated

(t)	Description
TRUE	evaluated 186 times by 1 test Evaluated by: Self test
FALSE	never evaluated

(t)[0]	Description
TRUE	evaluated 186 times by 1 test Evaluated by: Self test
FALSE	never evaluated

(t)	Description
TRUE	evaluated 4 times by 1 test Evaluated by: Self test
FALSE	never evaluated

(t)[0]	Description
TRUE	evaluated 4 times by 1 test Evaluated by: Self test
FALSE	never evaluated

0-190

7047

FREE (t);

executed 190 times by 1 test: sh_xfree((t), "subst.c", 7047);

Executed by:

Self test

t	Description
TRUE	evaluated 190 times by 1 test Evaluated by: Self test
FALSE	evaluated 6 times by 1 test Evaluated by: Self test

6-190

7048

}

executed 196 times by 1 test: end of block

Executed by:

Self test

196

7049

}

-

7050

-

7051

return (number);

executed 513 times by 1 test: return (number);

Executed by:

Self test

513

7052

}

-

7053

-

7054

/* Skip characters in SUBSTR until DELIM. SUBSTR is an arithmetic expression,

-

7055

so we do some ad-hoc parsing of an arithmetic expression to find

-

7056

the first DELIM, instead of using strchr(3). Two rules:

-

7057

1. If the substring contains a `(', read until closing `)'.

-

7058

2. If the substring contains a `?', read past one `:' for each `?'.

-

7059

The SD_ARITHEXP flag to skip_to_delim takes care of doing this.

-

7060

*/

-

7061

-

7062

static char *

-

7063

skiparith (substr, delim)

-

7064

char *substr;

-

7065

int delim;

-

7066

{

-

7067

int i;

-

7068

char delims[2];

-

7069

-

7070

delims[0] = delim;

-

7071

delims[1] = '\0';

-

7072

-

7073

i = skip_to_delim (substr, 0, delims, SD_ARITHEXP);

-

7074

return (substr + i);

executed 792 times by 1 test: return (substr + i);

Executed by:

Self test

792

7075

}

-

7076

-

7077

/* Verify and limit the start and end of the desired substring. If

-

7078

VTYPE == 0, a regular shell variable is being used; if it is 1,

-

7079

then the positional parameters are being used; if it is 2, then

-

7080

VALUE is really a pointer to an array variable that should be used.

-

7081

Return value is 1 if both values were OK, 0 if there was a problem

-

7082

with an invalid expression, or -1 if the values were out of range. */

-

7083

static int

-

7084

verify_substring_values (v, value, substr, vtype, e1p, e2p)

-

7085

SHELL_VAR *v;

-

7086

char *value, *substr;

-

7087

int vtype;

-

7088

intmax_t *e1p, *e2p;

-

7089

{

-

7090

char *t, *temp1, *temp2;

-

7091

arrayind_t len;

-

7092

int expok;

-

7093

#if defined (ARRAY_VARS)

-

7094

ARRAY *a;

-

7095

HASH_TABLE *h;

-

7096

#endif

-

7097

-

7098

/* duplicate behavior of strchr(3) */

-

7099

t = skiparith (substr, ':');

-

7100

if (*t && *t == ':')

*t	Description
TRUE	evaluated 525 times by 1 test Evaluated by: Self test
FALSE	evaluated 267 times by 1 test Evaluated by: Self test

*t == ':'	Description
TRUE	evaluated 525 times by 1 test Evaluated by: Self test
FALSE	never evaluated

0-525

7101

*t = '\0';

executed 525 times by 1 test: *t = '\0';

Executed by:

Self test

525

7102

else

-

7103

t = (char *)0;

executed 267 times by 1 test: t = (char *)0;

Executed by:

Self test

267

7104

-

7105

temp1 = expand_arith_string (substr, Q_DOUBLE_QUOTES);

-

7106

*e1p = evalexp (temp1, 0, &expok); /* XXX - EXP_EXPANDED? */

-

7107

free (temp1);

-

7108

if (expok == 0)

expok == 0	Description
TRUE	evaluated 18 times by 1 test Evaluated by: Self test
FALSE	evaluated 773 times by 1 test Evaluated by: Self test

18-773

7109

return (0);

executed 18 times by 1 test: return (0);

Executed by:

Self test

18

7110

-

7111

len = -1; /* paranoia */

-

7112

switch (vtype)

-

7113

{

-

7114

case VT_VARIABLE:

executed 439 times by 1 test: case 0:

Executed by:

Self test

439

7115

case VT_ARRAYMEMBER:

executed 30 times by 1 test: case 3:

Executed by:

Self test

30

7116

len = MB_STRLEN (value);

( (__ctype_get...r_max ()) > 1)	Description
TRUE	evaluated 469 times by 1 test Evaluated by: Self test
FALSE	never evaluated

(value)[1]	Description
TRUE	evaluated 421 times by 1 test Evaluated by: Self test
FALSE	evaluated 30 times by 1 test Evaluated by: Self test

(value)[1]	Description
TRUE	never evaluated
FALSE	never evaluated

(value)[2]	Description
TRUE	never evaluated
FALSE	never evaluated

(value)	Description
TRUE	evaluated 469 times by 1 test Evaluated by: Self test
FALSE	never evaluated

(value)[0]	Description
TRUE	evaluated 451 times by 1 test Evaluated by: Self test
FALSE	evaluated 18 times by 1 test Evaluated by: Self test

(value)	Description
TRUE	never evaluated
FALSE	never evaluated

(value)[0]	Description
TRUE	never evaluated
FALSE	never evaluated

0-469

7117

break;

executed 469 times by 1 test: break;

Executed by:

Self test

469

7118

case VT_POSPARMS:

executed 223 times by 1 test: case 1:

Executed by:

Self test

223

7119

len = number_of_args () + 1;

-

7120

if (*e1p == 0)

*e1p == 0	Description
TRUE	evaluated 8 times by 1 test Evaluated by: Self test
FALSE	evaluated 215 times by 1 test Evaluated by: Self test

8-215

7121

len++; /* add one arg if counting from $0 */

executed 8 times by 1 test: len++;

Executed by:

Self test

8

7122

break;

executed 223 times by 1 test: break;

Executed by:

Self test

223

7123

#if defined (ARRAY_VARS)

-

7124

case VT_ARRAYVAR:

executed 81 times by 1 test: case 2:

Executed by:

Self test

81

7125

/* For arrays, the first value deals with array indices. Negative

-

7126

offsets count from one past the array's maximum index. Associative

-

7127

arrays treat the number of elements as the maximum index. */

-

7128

if (assoc_p (v))

((((v)->attrib... (0x0000040)))	Description
TRUE	evaluated 2 times by 1 test Evaluated by: Self test
FALSE	evaluated 79 times by 1 test Evaluated by: Self test

2-79

7129

{

-

7130

h = assoc_cell (v);

-

7131

len = assoc_num_elements (h) + (*e1p < 0);

-

7132

}

executed 2 times by 1 test: end of block

Executed by:

Self test

2

7133

else

-

7134

{

-

7135

a = (ARRAY *)value;

-

7136

len = array_max_index (a) + (*e1p < 0); /* arrays index from 0 to n - 1 */

-

7137

}

executed 79 times by 1 test: end of block

Executed by:

Self test

79

7138

break;

executed 81 times by 1 test: break;

Executed by:

Self test

81

7139

#endif

-

7140

}

-

7141

-

7142

if (len == -1) /* paranoia */

len == -1	Description
TRUE	never evaluated
FALSE	evaluated 773 times by 1 test Evaluated by: Self test

0-773

7143

return -1;

never executed: return -1;

0

7144

-

7145

if (*e1p < 0) /* negative offsets count from end */

*e1p < 0	Description
TRUE	evaluated 31 times by 1 test Evaluated by: Self test
FALSE	evaluated 742 times by 1 test Evaluated by: Self test

31-742

7146

*e1p += len;

executed 31 times by 1 test: *e1p += len;

Executed by:

Self test

31

7147

-

7148

if (*e1p > len || *e1p < 0)

*e1p > len	Description
TRUE	evaluated 26 times by 1 test Evaluated by: Self test
FALSE	evaluated 747 times by 1 test Evaluated by: Self test

*e1p < 0	Description
TRUE	evaluated 2 times by 1 test Evaluated by: Self test
FALSE	evaluated 745 times by 1 test Evaluated by: Self test

2-747

7149

return (-1);

executed 28 times by 1 test: return (-1);

Executed by:

Self test

28

7150

-

7151

#if defined (ARRAY_VARS)

-

7152

/* For arrays, the second offset deals with the number of elements. */

-

7153

if (vtype == VT_ARRAYVAR)

vtype == 2	Description
TRUE	evaluated 77 times by 1 test Evaluated by: Self test
FALSE	evaluated 668 times by 1 test Evaluated by: Self test

77-668

7154

len = assoc_p (v) ? assoc_num_elements (h) : array_num_elements (a);

executed 77 times by 1 test: len = ((((v)->attributes) & (0x0000040))) ? ((h)->nentries) : ((a)->num_elements);

Executed by:

Self test

((((v)->attrib... (0x0000040)))	Description
TRUE	evaluated 2 times by 1 test Evaluated by: Self test
FALSE	evaluated 75 times by 1 test Evaluated by: Self test

2-77

7155

#endif

-

7156

-

7157

if (t)

t	Description
TRUE	evaluated 510 times by 1 test Evaluated by: Self test
FALSE	evaluated 235 times by 1 test Evaluated by: Self test

235-510

7158

{

-

7159

t++;

-

7160

temp2 = savestring (t);

-

7161

temp1 = expand_arith_string (temp2, Q_DOUBLE_QUOTES);

-

7162

free (temp2);

-

7163

t[-1] = ':';

-

7164

*e2p = evalexp (temp1, 0, &expok); /* XXX - EXP_EXPANDED? */

-

7165

free (temp1);

-

7166

if (expok == 0)

expok == 0	Description
TRUE	never evaluated
FALSE	evaluated 510 times by 1 test Evaluated by: Self test

0-510

7167

return (0);

never executed: return (0);

0

7168

-

7169

/* Should we allow positional parameter length < 0 to count backwards

-

7170

from end of positional parameters? */

-

7171

#if 1

-

7172

if ((vtype == VT_ARRAYVAR || vtype == VT_POSPARMS) && *e2p < 0)

vtype == 2	Description
TRUE	evaluated 54 times by 1 test Evaluated by: Self test
FALSE	evaluated 456 times by 1 test Evaluated by: Self test

vtype == 1	Description
TRUE	evaluated 103 times by 1 test Evaluated by: Self test
FALSE	evaluated 353 times by 1 test Evaluated by: Self test

*e2p < 0	Description
TRUE	evaluated 2 times by 1 test Evaluated by: Self test
FALSE	evaluated 155 times by 1 test Evaluated by: Self test

2-456

7173

#else

-

7174

/* XXX - bash-5.0 */

-

7175

if (vtype == VT_ARRAYVAR && *e2p < 0)

-

7176

#endif

-

7177

{

-

7178

internal_error (_("%s: substring expression < 0"), t);

-

7179

return (0);

executed 2 times by 1 test: return (0);

Executed by:

Self test

2

7180

}

-

7181

#if defined (ARRAY_VARS)

-

7182

/* In order to deal with sparse arrays, push the intelligence about how

-

7183

to deal with the number of elements desired down to the array-

-

7184

specific functions. */

-

7185

if (vtype != VT_ARRAYVAR)

vtype != 2	Description
TRUE	evaluated 454 times by 1 test Evaluated by: Self test
FALSE	evaluated 54 times by 1 test Evaluated by: Self test

54-454

7186

#endif

-

7187

{

-

7188

if (*e2p < 0)

*e2p < 0	Description
TRUE	evaluated 9 times by 1 test Evaluated by: Self test
FALSE	evaluated 445 times by 1 test Evaluated by: Self test

9-445

7189

{

-

7190

*e2p += len;

-

7191

if (*e2p < 0 || *e2p < *e1p)

*e2p < 0	Description
TRUE	never evaluated
FALSE	evaluated 9 times by 1 test Evaluated by: Self test

e2p < e1p	Description
TRUE	never evaluated
FALSE	evaluated 9 times by 1 test Evaluated by: Self test

0-9

7192

{

-

7193

internal_error (_("%s: substring expression < 0"), t);

-

7194

return (0);

never executed: return (0);

0

7195

}

-

7196

}

executed 9 times by 1 test: end of block

Executed by:

Self test

9

7197

else

-

7198

*e2p += *e1p; /* want E2 chars starting at E1 */

executed 445 times by 1 test: *e2p += *e1p;

Executed by:

Self test

445

7199

if (*e2p > len)

*e2p > len	Description
TRUE	evaluated 70 times by 1 test Evaluated by: Self test
FALSE	evaluated 384 times by 1 test Evaluated by: Self test

70-384

7200

*e2p = len;

executed 70 times by 1 test: *e2p = len;

Executed by:

Self test

70

7201

}

executed 454 times by 1 test: end of block

Executed by:

Self test

454

7202

}

executed 508 times by 1 test: end of block

Executed by:

Self test

508

7203

else

-

7204

*e2p = len;

executed 235 times by 1 test: *e2p = len;

Executed by:

Self test

235

7205

-

7206

return (1);

executed 743 times by 1 test: return (1);

Executed by:

Self test

743

7207

}

-

7208

-

7209

/* Return the type of variable specified by VARNAME (simple variable,

-

7210

positional param, or array variable). Also return the value specified

-

7211

by VARNAME (value of a variable or a reference to an array element).

-

7212

QUOTED is the standard description of quoting state, using Q_* defines.

-

7213

FLAGS is currently a set of flags to pass to array_value. If IND is

-

7214

non-null and not INTMAX_MIN, and FLAGS includes AV_USEIND, IND is

-

7215

passed to array_value so the array index is not computed again.

-

7216

If this returns VT_VARIABLE, the caller assumes that CTLESC and CTLNUL

-

7217

characters in the value are quoted with CTLESC and takes appropriate

-

7218

steps. For convenience, *VALP is set to the dequoted VALUE. */

-

7219

static int

-

7220

get_var_and_type (varname, value, ind, quoted, flags, varp, valp)

-

7221

char *varname, *value;

-

7222

arrayind_t ind;

-

7223

int quoted, flags;

-

7224

SHELL_VAR **varp;

-

7225

char **valp;

-

7226

{

-

7227

int vtype, want_indir;

-

7228

char *temp, *vname;

-

7229

SHELL_VAR *v;

-

7230

arrayind_t lind;

-

7231

-

7232

want_indir = *varname == '!' &&

*varname == '!'	Description
TRUE	evaluated 2 times by 1 test Evaluated by: Self test
FALSE	evaluated 2317594 times by 1 test Evaluated by: Self test

2-2317594

7233

(legal_variable_starter ((unsigned char)varname[1]) || DIGIT (varname[1])

((*__ctype_b_l...int) _ISalpha)	Description
TRUE	evaluated 2 times by 1 test Evaluated by: Self test
FALSE	never evaluated

((unsigned cha...ame[1] == '_')	Description
TRUE	never evaluated
FALSE	never evaluated

(varname[1]) >= '0'	Description
TRUE	never evaluated
FALSE	never evaluated

(varname[1]) <= '9'	Description
TRUE	never evaluated
FALSE	never evaluated

0-2

7234

|| VALID_INDIR_PARAM (varname[1]));

posixly_correct == 0	Description
TRUE	never evaluated
FALSE	never evaluated

(varname[1]) == '#'	Description
TRUE	never evaluated
FALSE	never evaluated

posixly_correct == 0	Description
TRUE	never evaluated
FALSE	never evaluated

(varname[1]) == '?'	Description
TRUE	never evaluated
FALSE	never evaluated

(varname[1]) == '@'	Description
TRUE	never evaluated
FALSE	never evaluated

(varname[1]) == '*'	Description
TRUE	never evaluated
FALSE	never evaluated

0

7235

if (want_indir)

want_indir	Description
TRUE	evaluated 2 times by 1 test Evaluated by: Self test
FALSE	evaluated 2317594 times by 1 test Evaluated by: Self test

2-2317594

7236

vname = parameter_brace_find_indir (varname+1, SPECIAL_VAR (varname, 1), quoted, 1);

executed 2 times by 1 test:

vname = parameter_brace_find_indir (varname+1, (*varname && ((((*varname) >= '0' && (*varname) <= '9') && all_digits (varname)) || (varname[1] == '\0' && (sh_syntaxtab[(unsigned char)*varname] & 0x0800)) || (1 && varname[2] == '\0' && ((posixly_correct == 0 && (varname[1]) == '#') || (posixly_correct == 0 && (varname[1]) == '?') || (varname[1]) == '@' || (varname[1]) == '*')))), quoted, 1);

Executed by:

Self test

2

7237

/* XXX - what if vname == 0 || *vname == 0 ? */

-

7238

else

-

7239

vname = varname;

executed 2317594 times by 1 test: vname = varname;

Executed by:

Self test

2317594

7240

-

7241

if (vname == 0)

vname == 0	Description
TRUE	never evaluated
FALSE	evaluated 2317596 times by 1 test Evaluated by: Self test

0-2317596

7242

{

-

7243

vtype = VT_VARIABLE;

-

7244

*varp = (SHELL_VAR *)NULL;

-

7245

*valp = (char *)NULL;

-

7246

return (vtype);

never executed: return (vtype);

0

7247

}

-

7248

-

7249

/* This sets vtype to VT_VARIABLE or VT_POSPARMS */

-

7250

vtype = STR_DOLLAR_AT_STAR (vname);

((vname)[0]) == '@'	Description
TRUE	evaluated 258 times by 1 test Evaluated by: Self test
FALSE	evaluated 2317338 times by 1 test Evaluated by: Self test

((vname)[0]) == '*'	Description
TRUE	evaluated 191 times by 1 test Evaluated by: Self test
FALSE	evaluated 2317147 times by 1 test Evaluated by: Self test

(vname)[1] == '\0'	Description
TRUE	evaluated 449 times by 1 test Evaluated by: Self test
FALSE	never evaluated

0-2317338

7251

if (vtype == VT_POSPARMS && vname[0] == '*')

vtype == 1	Description
TRUE	evaluated 449 times by 1 test Evaluated by: Self test
FALSE	evaluated 2317147 times by 1 test Evaluated by: Self test

vname[0] == '*'	Description
TRUE	evaluated 191 times by 1 test Evaluated by: Self test
FALSE	evaluated 258 times by 1 test Evaluated by: Self test

191-2317147

7252

vtype |= VT_STARSUB;

executed 191 times by 1 test: vtype |= 128;

Executed by:

Self test

191

7253

*varp = (SHELL_VAR *)NULL;

-

7254

-

7255

#if defined (ARRAY_VARS)

-

7256

if (valid_array_reference (vname, 0))

valid_array_re...nce (vname, 0)	Description
TRUE	evaluated 488 times by 1 test Evaluated by: Self test
FALSE	evaluated 2317108 times by 1 test Evaluated by: Self test

488-2317108

7257

{

-

7258

v = array_variable_part (vname, 0, &temp, (int *)0);

-

7259

/* If we want to signal array_value to use an already-computed index,

-

7260

set LIND to that index */

-

7261

lind = (ind != INTMAX_MIN && (flags & AV_USEIND)) ? ind : 0;

ind != (-92233...854775807L -1)	Description
TRUE	evaluated 488 times by 1 test Evaluated by: Self test
FALSE	never evaluated

(flags & 0x004)	Description
TRUE	evaluated 149 times by 1 test Evaluated by: Self test
FALSE	evaluated 339 times by 1 test Evaluated by: Self test

0-488

7262

if (v && invisible_p (v))

v	Description
TRUE	evaluated 488 times by 1 test Evaluated by: Self test
FALSE	never evaluated

((((v)->attrib... (0x0001000)))	Description
TRUE	never evaluated
FALSE	evaluated 488 times by 1 test Evaluated by: Self test

0-488

7263

{

-

7264

vtype = VT_ARRAYMEMBER;

-

7265

*varp = (SHELL_VAR *)NULL;

-

7266

*valp = (char *)NULL;

-

7267

}

never executed: end of block

0

7268

if (v && (array_p (v) || assoc_p (v)))

v	Description
TRUE	evaluated 488 times by 1 test Evaluated by: Self test
FALSE	never evaluated

((((v)->attrib... (0x0000004)))	Description
TRUE	evaluated 434 times by 1 test Evaluated by: Self test
FALSE	evaluated 54 times by 1 test Evaluated by: Self test

((((v)->attrib... (0x0000040)))	Description
TRUE	evaluated 42 times by 1 test Evaluated by: Self test
FALSE	evaluated 12 times by 1 test Evaluated by: Self test

0-488

7269

{

-

7270

if (ALL_ELEMENT_SUB (temp[0]) && temp[1] == RBRACK)

(temp[0]) == '@'	Description
TRUE	evaluated 268 times by 1 test Evaluated by: Self test
FALSE	evaluated 208 times by 1 test Evaluated by: Self test

(temp[0]) == '*'	Description
TRUE	evaluated 64 times by 1 test Evaluated by: Self test
FALSE	evaluated 144 times by 1 test Evaluated by: Self test

temp[1] == ']'	Description
TRUE	evaluated 332 times by 1 test Evaluated by: Self test
FALSE	never evaluated

0-332

7271

{

-

7272

/* Callers have to differentiate between indexed and associative */

-

7273

vtype = VT_ARRAYVAR;

-

7274

if (temp[0] == '*')

temp[0] == '*'	Description
TRUE	evaluated 64 times by 1 test Evaluated by: Self test
FALSE	evaluated 268 times by 1 test Evaluated by: Self test

64-268

7275

vtype |= VT_STARSUB;

executed 64 times by 1 test: vtype |= 128;

Executed by:

Self test

64

7276

*valp = array_p (v) ? (char *)array_cell (v) : (char *)assoc_cell (v);

((((v)->attrib... (0x0000004)))	Description
TRUE	evaluated 298 times by 1 test Evaluated by: Self test
FALSE	evaluated 34 times by 1 test Evaluated by: Self test

34-298

7277

}

executed 332 times by 1 test: end of block

Executed by:

Self test

332

7278

else

-

7279

{

-

7280

vtype = VT_ARRAYMEMBER;

-

7281

*valp = array_value (vname, Q_DOUBLE_QUOTES, flags, (int *)NULL, &lind);

-

7282

}

executed 144 times by 1 test: end of block

Executed by:

Self test

144

7283

*varp = v;

-

7284

}

executed 476 times by 1 test: end of block

Executed by:

Self test

476

7285

else if (v && (ALL_ELEMENT_SUB (temp[0]) && temp[1] == RBRACK))

v	Description
TRUE	evaluated 12 times by 1 test Evaluated by: Self test
FALSE	never evaluated

(temp[0]) == '@'	Description
TRUE	evaluated 6 times by 1 test Evaluated by: Self test
FALSE	evaluated 6 times by 1 test Evaluated by: Self test

(temp[0]) == '*'	Description
TRUE	never evaluated
FALSE	evaluated 6 times by 1 test Evaluated by: Self test

temp[1] == ']'	Description
TRUE	evaluated 6 times by 1 test Evaluated by: Self test
FALSE	never evaluated

0-12

7286

{

-

7287

vtype = VT_VARIABLE;

-

7288

*varp = v;

-

7289

if (quoted & (Q_DOUBLE_QUOTES|Q_HERE_DOCUMENT))

quoted & (0x001\|0x002)	Description
TRUE	evaluated 2 times by 1 test Evaluated by: Self test
FALSE	evaluated 4 times by 1 test Evaluated by: Self test

2-4

7290

*valp = dequote_string (value);

executed 2 times by 1 test: *valp = dequote_string (value);

Executed by:

Self test

2

7291

else

-

7292

*valp = dequote_escapes (value);

executed 4 times by 1 test: *valp = dequote_escapes (value);

Executed by:

Self test

4

7293

}

-

7294

else

-

7295

{

-

7296

vtype = VT_ARRAYMEMBER;

-

7297

*varp = v;

-

7298

*valp = array_value (vname, Q_DOUBLE_QUOTES, flags, (int *)NULL, &lind);

-

7299

}

executed 6 times by 1 test: end of block

Executed by:

Self test

6

7300

}

-

7301

else if ((v = find_variable (vname)) && (invisible_p (v) == 0) && (assoc_p (v) || array_p (v)))

(v = find_variable (vname))	Description
TRUE	evaluated 2316546 times by 1 test Evaluated by: Self test
FALSE	evaluated 562 times by 1 test Evaluated by: Self test

(((((v)->attri...01000))) == 0)	Description
TRUE	evaluated 2316546 times by 1 test Evaluated by: Self test
FALSE	never evaluated

((((v)->attrib... (0x0000040)))	Description
TRUE	evaluated 5 times by 1 test Evaluated by: Self test
FALSE	evaluated 2316541 times by 1 test Evaluated by: Self test

((((v)->attrib... (0x0000004)))	Description
TRUE	evaluated 44 times by 1 test Evaluated by: Self test
FALSE	evaluated 2316497 times by 1 test Evaluated by: Self test

0-2316546

7302

{

-

7303

vtype = VT_ARRAYMEMBER;

-

7304

*varp = v;

-

7305

*valp = assoc_p (v) ? assoc_reference (assoc_cell (v), "0") : array_reference (array_cell (v), 0);

((((v)->attrib... (0x0000040)))	Description
TRUE	evaluated 5 times by 1 test Evaluated by: Self test
FALSE	evaluated 44 times by 1 test Evaluated by: Self test

5-44

7306

}

executed 49 times by 1 test: end of block

Executed by:

Self test

49

7307

else

-

7308

#endif

-

7309

{

-

7310

if (value && vtype == VT_VARIABLE)

value	Description
TRUE	evaluated 2317050 times by 1 test Evaluated by: Self test
FALSE	evaluated 9 times by 1 test Evaluated by: Self test

vtype == 0	Description
TRUE	evaluated 2316609 times by 1 test Evaluated by: Self test
FALSE	evaluated 441 times by 1 test Evaluated by: Self test

9-2317050

7311

{

-

7312

*varp = find_variable (vname);

-

7313

if (quoted & (Q_DOUBLE_QUOTES|Q_HERE_DOCUMENT))

quoted & (0x001\|0x002)	Description
TRUE	evaluated 426 times by 1 test Evaluated by: Self test
FALSE	evaluated 2316183 times by 1 test Evaluated by: Self test

426-2316183

7314

*valp = dequote_string (value);

executed 426 times by 1 test: *valp = dequote_string (value);

Executed by:

Self test

426

7315

else

-

7316

*valp = dequote_escapes (value);

executed 2316183 times by 1 test: *valp = dequote_escapes (value);

Executed by:

Self test

2316183

7317

}

-

7318

else

-

7319

*valp = value;

executed 450 times by 1 test: *valp = value;

Executed by:

Self test

450

7320

}

-

7321

-

7322

if (want_indir)

want_indir	Description
TRUE	evaluated 2 times by 1 test Evaluated by: Self test
FALSE	evaluated 2317594 times by 1 test Evaluated by: Self test

2-2317594

7323

free (vname);

executed 2 times by 1 test: sh_xfree((vname), "subst.c", 7323);

Executed by:

Self test

2

7324

-

7325

return vtype;

executed 2317596 times by 1 test: return vtype;

Executed by:

Self test

2317596

7326

}

-

7327

-

7328

/***********************************************************/

-

7329

/* */

-

7330

/* Functions to perform transformations on variable values */

-

7331

/* */

-

7332

/***********************************************************/

-

7333

-

7334

static char *

-

7335

string_var_assignment (v, s)

-

7336

SHELL_VAR *v;

-

7337

char *s;

-

7338

{

-

7339

char flags[MAX_ATTRIBUTES], *ret, *val;

-

7340

int i;

-

7341

-

7342

val = sh_quote_reusable (s, 0);

-

7343

i = var_attribute_string (v, 0, flags);

-

7344

ret = (char *)xmalloc (i + strlen (val) + strlen (v->name) + 16 + MAX_ATTRIBUTES);

-

7345

if (i > 0)

i > 0	Description
TRUE	evaluated 3 times by 1 test Evaluated by: Self test
FALSE	evaluated 1 time by 1 test Evaluated by: Self test

1-3

7346

sprintf (ret, "declare -%s %s=%s", flags, v->name, val);

executed 3 times by 1 test: sprintf (ret, "declare -%s %s=%s", flags, v->name, val);

Executed by:

Self test

3

7347

else

-

7348

sprintf (ret, "%s=%s", v->name, val);

executed 1 time by 1 test: sprintf (ret, "%s=%s", v->name, val);

Executed by:

Self test

1

7349

free (val);

-

7350

return ret;

executed 4 times by 1 test: return ret;

Executed by:

Self test

4

7351

}

-

7352

-

7353

#if defined (ARRAY_VARS)

-

7354

static char *

-

7355

array_var_assignment (v, itype, quoted)

-

7356

SHELL_VAR *v;

-

7357

int itype, quoted;

-

7358

{

-

7359

char *ret, *val, flags[MAX_ATTRIBUTES];

-

7360

int i;

-

7361

-

7362

if (v == 0)

v == 0	Description
TRUE	never evaluated
FALSE	evaluated 6 times by 1 test Evaluated by: Self test

0-6

7363

return (char *)NULL;

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

0

7364

val = array_p (v) ? array_to_assign (array_cell (v), 0)

((((v)->attrib... (0x0000004)))	Description
TRUE	evaluated 4 times by 1 test Evaluated by: Self test
FALSE	evaluated 2 times by 1 test Evaluated by: Self test

2-4

7365

: assoc_to_assign (assoc_cell (v), 0);

-

7366

if (val == 0)

val == 0	Description
TRUE	evaluated 2 times by 1 test Evaluated by: Self test
FALSE	evaluated 4 times by 1 test Evaluated by: Self test

2-4

7367

{

-

7368

val = (char *)xmalloc (3);

-

7369

val[0] = LPAREN;

-

7370

val[1] = RPAREN;

-

7371

val[2] = 0;

-

7372

}

executed 2 times by 1 test: end of block

Executed by:

Self test

2

7373

else

-

7374

{

-

7375

ret = (quoted & (Q_DOUBLE_QUOTES|Q_HERE_DOCUMENT)) ? quote_string (val) : quote_escapes (val);

(quoted & (0x001\|0x002))	Description
TRUE	evaluated 2 times by 1 test Evaluated by: Self test
FALSE	evaluated 2 times by 1 test Evaluated by: Self test

2

7376

free (val);

-

7377

val = ret;

-

7378

}

executed 4 times by 1 test: end of block

Executed by:

Self test

4

7379

i = var_attribute_string (v, 0, flags);

-

7380

ret = (char *)xmalloc (i + strlen (val) + strlen (v->name) + 16);

-

7381

sprintf (ret, "declare -%s %s=%s", flags, v->name, val);

-

7382

free (val);

-

7383

return ret;

executed 6 times by 1 test: return ret;

Executed by:

Self test

6

7384

}

-

7385

#endif

-

7386

-

7387

static char *

-

7388

pos_params_assignment (list, itype, quoted)

-

7389

WORD_LIST *list;

-

7390

int itype;

-

7391

int quoted;

-

7392

{

-

7393

char *temp, *ret;

-

7394

-

7395

/* first, we transform the list to quote each word. */

-

7396

temp = list_transform ('Q', (SHELL_VAR *)0, list, itype, quoted);

-

7397

ret = (char *)xmalloc (strlen (temp) + 8);

-

7398

strcpy (ret, "set -- ");

-

7399

strcpy (ret + 7, temp);

-

7400

free (temp);

-

7401

return ret;

executed 1 time by 1 test: return ret;

Executed by:

Self test

1

7402

}

-

7403

-

7404

static char *

-

7405

string_transform (xc, v, s)

-

7406

int xc;

-

7407

SHELL_VAR *v;

-

7408

char *s;

-

7409

{

-

7410

char *ret, flags[MAX_ATTRIBUTES], *t;

-

7411

int i;

-

7412

-

7413

if (((xc == 'A' || xc == 'a') && v == 0) || (xc != 'a' && s == 0))

xc == 'A'	Description
TRUE	evaluated 5 times by 1 test Evaluated by: Self test
FALSE	evaluated 62 times by 1 test Evaluated by: Self test

xc == 'a'	Description
TRUE	evaluated 4 times by 1 test Evaluated by: Self test
FALSE	evaluated 58 times by 1 test Evaluated by: Self test

v == 0	Description
TRUE	evaluated 1 time by 1 test Evaluated by: Self test
FALSE	evaluated 8 times by 1 test Evaluated by: Self test

xc != 'a'	Description
TRUE	evaluated 62 times by 1 test Evaluated by: Self test
FALSE	evaluated 4 times by 1 test Evaluated by: Self test

s == 0	Description
TRUE	never evaluated
FALSE	evaluated 62 times by 1 test Evaluated by: Self test

0-62

7414

return (char *)NULL;

executed 1 time by 1 test: return (char *) ((void *)0) ;

Executed by:

Self test

1

7415

-

7416

switch (xc)

-

7417

{

-

7418

/* Transformations that interrogate the variable */

-

7419

case 'a':

executed 4 times by 1 test: case 'a':

Executed by:

Self test

4

7420

i = var_attribute_string (v, 0, flags);

-

7421

ret = (i > 0) ? savestring (flags) : (char *)NULL;

(i > 0)	Description
TRUE	evaluated 4 times by 1 test Evaluated by: Self test
FALSE	never evaluated

0-4

7422

break;

executed 4 times by 1 test: break;

Executed by:

Self test

4

7423

case 'A':

executed 4 times by 1 test: case 'A':

Executed by:

Self test

4

7424

ret = string_var_assignment (v, s);

-

7425

break;

executed 4 times by 1 test: break;

Executed by:

Self test

4

7426

/* Transformations that modify the variable's value */

-

7427

case 'E':

executed 11 times by 1 test: case 'E':

Executed by:

Self test

11

7428

t = ansiexpand (s, 0, strlen (s), (int *)0);

-

7429

ret = dequote_escapes (t);

-

7430

free (t);

-

7431

break;

executed 11 times by 1 test: break;

Executed by:

Self test

11

7432

case 'P':

executed 2 times by 1 test: case 'P':

Executed by:

Self test

2

7433

ret = decode_prompt_string (s);

-

7434

break;

executed 2 times by 1 test: break;

Executed by:

Self test

2

7435

case 'Q':

executed 45 times by 1 test: case 'Q':

Executed by:

Self test

45

7436

ret = sh_quote_reusable (s, 0);

-

7437

break;

executed 45 times by 1 test: break;

Executed by:

Self test

45

7438

default:

never executed: default:

0

7439

ret = (char *)NULL;

-

7440

break;

never executed: break;

0

7441

}

-

7442

return ret;

executed 66 times by 1 test: return ret;

Executed by:

Self test

66

7443

}

-

7444

-

7445

static char *

-

7446

list_transform (xc, v, list, itype, quoted)

-

7447

int xc;

-

7448

SHELL_VAR *v;

-

7449

WORD_LIST *list;

-

7450

int itype, quoted;

-

7451

{

-

7452

WORD_LIST *new, *l;

-

7453

WORD_DESC *w;

-

7454

char *tword;

-

7455

int qflags;

-

7456

-

7457

for (new = (WORD_LIST *)NULL, l = list; l; l = l->next)

l	Description
TRUE	evaluated 49 times by 1 test Evaluated by: Self test
FALSE	evaluated 20 times by 1 test Evaluated by: Self test

20-49

7458

{

-

7459

tword = string_transform (xc, v, l->word->word);

-

7460

w = alloc_word_desc ();

-

7461

w->word = tword ? tword : savestring (""); /* XXX */

tword	Description
TRUE	evaluated 49 times by 1 test Evaluated by: Self test
FALSE	never evaluated

0-49

7462

new = make_word_list (w, new);

-

7463

}

executed 49 times by 1 test: end of block

Executed by:

Self test

49

7464

l = REVERSE_LIST (new, WORD_LIST *);

new	Description
TRUE	evaluated 20 times by 1 test Evaluated by: Self test
FALSE	never evaluated

new->next	Description
TRUE	evaluated 15 times by 1 test Evaluated by: Self test
FALSE	evaluated 5 times by 1 test Evaluated by: Self test

0-20

7465

-

7466

qflags = quoted;

-

7467

/* If we are expanding in a context where word splitting will not be

-

7468

performed, treat as quoted. This changes how $* will be expanded. */

-

7469

if (itype == '*' && expand_no_split_dollar_star && ifs_is_null)

itype == '*'	Description
TRUE	evaluated 9 times by 1 test Evaluated by: Self test
FALSE	evaluated 11 times by 1 test Evaluated by: Self test

expand_no_split_dollar_star	Description
TRUE	evaluated 5 times by 1 test Evaluated by: Self test
FALSE	evaluated 4 times by 1 test Evaluated by: Self test

ifs_is_null	Description
TRUE	evaluated 5 times by 1 test Evaluated by: Self test
FALSE	never evaluated

0-11

7470

qflags |= Q_DOUBLE_QUOTES; /* Posix interp 888 */

executed 5 times by 1 test: qflags |= 0x001;

Executed by:

Self test

5

7471

-

7472

tword = string_list_pos_params (itype, l, qflags);

-

7473

dispose_words (l);

-

7474

-

7475

return (tword);

executed 20 times by 1 test: return (tword);

Executed by:

Self test

20

7476

}

-

7477

-

7478

static char *

-

7479

parameter_list_transform (xc, itype, quoted)

-

7480

int xc;

-

7481

int itype;

-

7482

int quoted;

-

7483

{

-

7484

char *ret;

-

7485

WORD_LIST *list;

-

7486

-

7487

list = list_rest_of_args ();

-

7488

if (list == 0)

list == 0	Description
TRUE	never evaluated
FALSE	evaluated 11 times by 1 test Evaluated by: Self test

0-11

7489

return ((char *)NULL);

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

0

7490

if (xc == 'A')

xc == 'A'	Description
TRUE	evaluated 1 time by 1 test Evaluated by: Self test
FALSE	evaluated 10 times by 1 test Evaluated by: Self test

1-10

7491

return (pos_params_assignment (list, itype, quoted));

executed 1 time by 1 test: return (pos_params_assignment (list, itype, quoted));

Executed by:

Self test

1

7492

ret = list_transform (xc, (SHELL_VAR *)0, list, itype, quoted);

-

7493

dispose_words (list);

-

7494

return (ret);

executed 10 times by 1 test: return (ret);

Executed by:

Self test

10

7495

}

-

7496

-

7497

#if defined (ARRAY_VARS)

-

7498

static char *

-

7499

array_transform (xc, var, varname, quoted)

-

7500

int xc;

-

7501

SHELL_VAR *var;

-

7502

char *varname; /* so we can figure out how it's indexed */

-

7503

int quoted;

-

7504

{

-

7505

ARRAY *a;

-

7506

HASH_TABLE *h;

-

7507

int itype;

-

7508

char *ret;

-

7509

WORD_LIST *list;

-

7510

SHELL_VAR *v;

-

7511

-

7512

/* compute itype from varname here */

-

7513

v = array_variable_part (varname, 0, &ret, 0);

-

7514

-

7515

/* XXX */

-

7516

if (v && invisible_p (v))

v	Description
TRUE	evaluated 15 times by 1 test Evaluated by: Self test
FALSE	never evaluated

((((v)->attrib... (0x0001000)))	Description
TRUE	never evaluated
FALSE	evaluated 15 times by 1 test Evaluated by: Self test

0-15

7517

return ((char *)NULL);

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

0

7518

-

7519

itype = ret[0];

-

7520

-

7521

if (xc == 'A')

xc == 'A'	Description
TRUE	evaluated 6 times by 1 test Evaluated by: Self test
FALSE	evaluated 9 times by 1 test Evaluated by: Self test

6-9

7522

return (array_var_assignment (v, itype, quoted));

executed 6 times by 1 test: return (array_var_assignment (v, itype, quoted));

Executed by:

Self test

6

7523

-

7524

a = (v && array_p (v)) ? array_cell (v) : 0;

v	Description
TRUE	evaluated 9 times by 1 test Evaluated by: Self test
FALSE	never evaluated

((((v)->attrib... (0x0000004)))	Description
TRUE	evaluated 9 times by 1 test Evaluated by: Self test
FALSE	never evaluated

0-9

7525

h = (v && assoc_p (v)) ? assoc_cell (v) : 0;

v	Description
TRUE	evaluated 9 times by 1 test Evaluated by: Self test
FALSE	never evaluated

((((v)->attrib... (0x0000040)))	Description
TRUE	never evaluated
FALSE	evaluated 9 times by 1 test Evaluated by: Self test

0-9

7526

-

7527

list = a ? array_to_word_list (a) : (h ? assoc_to_word_list (h) : 0);

a	Description
TRUE	evaluated 9 times by 1 test Evaluated by: Self test
FALSE	never evaluated

h	Description
TRUE	never evaluated
FALSE	never evaluated

0-9

7528

if (list == 0)

list == 0	Description
TRUE	never evaluated
FALSE	evaluated 9 times by 1 test Evaluated by: Self test

0-9

7529

return ((char *)NULL);

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

0

7530

ret = list_transform (xc, v, list, itype, quoted);

-

7531

dispose_words (list);

-

7532

-

7533

return ret;

executed 9 times by 1 test: return ret;

Executed by:

Self test

9

7534

}

-

7535

#endif /* ARRAY_VARS */

-

7536

-

7537

static char *

-

7538

parameter_brace_transform (varname, value, ind, xform, rtype, quoted, pflags, flags)

-

7539

char *varname, *value;

-

7540

int ind;

-

7541

char *xform;

-

7542

int rtype, quoted, pflags, flags;

-

7543

{

-

7544

int vtype, xc;

-

7545

char *temp1, *val, *oname;

-

7546

SHELL_VAR *v;

-

7547

-

7548

xc = xform[0];

-

7549

if (value == 0 && xc != 'A' && xc != 'a')

value == 0	Description
TRUE	evaluated 9 times by 1 test Evaluated by: Self test
FALSE	evaluated 41 times by 1 test Evaluated by: Self test

xc != 'A'	Description
TRUE	evaluated 6 times by 1 test Evaluated by: Self test
FALSE	evaluated 3 times by 1 test Evaluated by: Self test

xc != 'a'	Description
TRUE	evaluated 5 times by 1 test Evaluated by: Self test
FALSE	evaluated 1 time by 1 test Evaluated by: Self test

1-41

7550

return ((char *)NULL);

executed 5 times by 1 test: return ((char *) ((void *)0) );

Executed by:

Self test

5

7551

-

7552

oname = this_command_name;

-

7553

this_command_name = varname;

-

7554

-

7555

vtype = get_var_and_type (varname, value, ind, quoted, flags, &v, &val);

-

7556

if (vtype == -1)

vtype == -1	Description
TRUE	never evaluated
FALSE	evaluated 45 times by 1 test Evaluated by: Self test

0-45

7557

{

-

7558

this_command_name = oname;

-

7559

return ((char *)NULL);

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

0

7560

}

-

7561

-

7562

/* check for valid values of xc */

-

7563

switch (xc)

-

7564

{

-

7565

case 'a': /* expand to a string with just attributes */

executed 4 times by 1 test: case 'a':

Executed by:

Self test

4

7566

case 'A': /* expand as an assignment statement with attributes */

executed 12 times by 1 test: case 'A':

Executed by:

Self test

12

7567

case 'E': /* expand like $'...' */

executed 9 times by 1 test: case 'E':

Executed by:

Self test

9

7568

case 'P': /* expand like prompt string */

executed 2 times by 1 test: case 'P':

Executed by:

Self test

2

7569

case 'Q': /* quote reusably */

executed 17 times by 1 test: case 'Q':

Executed by:

Self test

17

7570

break;

executed 44 times by 1 test: break;

Executed by:

Self test

44

7571

default:

executed 1 time by 1 test: default:

Executed by:

Self test

1

7572

this_command_name = oname;

-

7573

return &expand_param_error;

executed 1 time by 1 test: return &expand_param_error;

Executed by:

Self test

1

7574

}

-

7575

-

7576

temp1 = (char *)NULL; /* shut up gcc */

-

7577

switch (vtype & ~VT_STARSUB)

-

7578

{

-

7579

case VT_VARIABLE:

executed 15 times by 1 test: case 0:

Executed by:

Self test

15

7580

case VT_ARRAYMEMBER:

executed 3 times by 1 test: case 3:

Executed by:

Self test

3

7581

temp1 = string_transform (xc, v, val);

-

7582

if (vtype == VT_VARIABLE)

vtype == 0	Description
TRUE	evaluated 15 times by 1 test Evaluated by: Self test
FALSE	evaluated 3 times by 1 test Evaluated by: Self test

3-15

7583

FREE (val);

executed 14 times by 1 test: sh_xfree((val), "subst.c", 7583);

Executed by:

Self test

executed 15 times by 1 test: end of block

Executed by:

Self test

val	Description
TRUE	evaluated 14 times by 1 test Evaluated by: Self test
FALSE	evaluated 1 time by 1 test Evaluated by: Self test

1-15

7584

if (temp1)

temp1	Description
TRUE	evaluated 17 times by 1 test Evaluated by: Self test
FALSE	evaluated 1 time by 1 test Evaluated by: Self test

1-17

7585

{

-

7586

val = (quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES))

(quoted & (0x002\|0x001))	Description
TRUE	evaluated 12 times by 1 test Evaluated by: Self test
FALSE	evaluated 5 times by 1 test Evaluated by: Self test

5-12

7587

? quote_string (temp1)

-

7588

: quote_escapes (temp1);

-

7589

free (temp1);

-

7590

temp1 = val;

-

7591

}

executed 17 times by 1 test: end of block

Executed by:

Self test

17

7592

break;

executed 18 times by 1 test: break;

Executed by:

Self test

18

7593

#if defined (ARRAY_VARS)

-

7594

case VT_ARRAYVAR:

executed 15 times by 1 test: case 2:

Executed by:

Self test

15

7595

temp1 = array_transform (xc, v, varname, quoted);

-

7596

if (temp1 && quoted == 0 && ifs_is_null)

temp1	Description
TRUE	evaluated 15 times by 1 test Evaluated by: Self test
FALSE	never evaluated

quoted == 0	Description
TRUE	evaluated 9 times by 1 test Evaluated by: Self test
FALSE	evaluated 6 times by 1 test Evaluated by: Self test

ifs_is_null	Description
TRUE	evaluated 4 times by 1 test Evaluated by: Self test
FALSE	evaluated 5 times by 1 test Evaluated by: Self test

0-15

7597

{

-

7598

/* Posix interp 888 */

-

7599

}

executed 4 times by 1 test: end of block

Executed by:

Self test

4

7600

else if (temp1 && ((quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)) == 0))

temp1	Description
TRUE	evaluated 11 times by 1 test Evaluated by: Self test
FALSE	never evaluated

((quoted & (0x...\|0x001)) == 0)	Description
TRUE	evaluated 5 times by 1 test Evaluated by: Self test
FALSE	evaluated 6 times by 1 test Evaluated by: Self test

0-11

7601

{

-

7602

val = quote_escapes (temp1);

-

7603

free (temp1);

-

7604

temp1 = val;

-

7605

}

executed 5 times by 1 test: end of block

Executed by:

Self test

5

7606

break;

executed 15 times by 1 test: break;

Executed by:

Self test

15

7607

#endif

-

7608

case VT_POSPARMS:

executed 11 times by 1 test: case 1:

Executed by:

Self test

11

7609

temp1 = parameter_list_transform (xc, varname[0], quoted);

-

7610

if (temp1 && quoted == 0 && ifs_is_null)

temp1	Description
TRUE	evaluated 11 times by 1 test Evaluated by: Self test
FALSE	never evaluated

quoted == 0	Description
TRUE	evaluated 8 times by 1 test Evaluated by: Self test
FALSE	evaluated 3 times by 1 test Evaluated by: Self test

ifs_is_null	Description
TRUE	evaluated 6 times by 1 test Evaluated by: Self test
FALSE	evaluated 2 times by 1 test Evaluated by: Self test

0-11

7611

{

-

7612

/* Posix interp 888 */

-

7613

}

executed 6 times by 1 test: end of block

Executed by:

Self test

6

7614

else if (temp1 && ((quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)) == 0))

temp1	Description
TRUE	evaluated 5 times by 1 test Evaluated by: Self test
FALSE	never evaluated

((quoted & (0x...\|0x001)) == 0)	Description
TRUE	evaluated 2 times by 1 test Evaluated by: Self test
FALSE	evaluated 3 times by 1 test Evaluated by: Self test

0-5

7615

{

-

7616

val = quote_escapes (temp1);

-

7617

free (temp1);

-

7618

temp1 = val;

-

7619

}

executed 2 times by 1 test: end of block

Executed by:

Self test

2

7620

break;

executed 11 times by 1 test: break;

Executed by:

Self test

11

7621

}

-

7622

-

7623

this_command_name = oname;

-

7624

return temp1;

executed 44 times by 1 test: return temp1;

Executed by:

Self test

44

7625

}

-

7626

-

7627

/******************************************************/

-

7628

/* */

-

7629

/* Functions to extract substrings of variable values */

-

7630

/* */

-

7631

/******************************************************/

-

7632

-

7633

#if defined (HANDLE_MULTIBYTE)

-

7634

/* Character-oriented rather than strictly byte-oriented substrings. S and

-

7635

E, rather being strict indices into STRING, indicate character (possibly

-

7636

multibyte character) positions that require calculation.

-

7637

Used by the ${param:offset[:length]} expansion. */

-

7638

static char *

-

7639

mb_substring (string, s, e)

-

7640

char *string;

-

7641

int s, e;

-

7642

{

-

7643

char *tt;

-

7644

int start, stop, i;

-

7645

size_t slen;

-

7646

DECLARE_MBSTATE;

-

7647

-

7648

start = 0;

-

7649

/* Don't need string length in ADVANCE_CHAR unless multibyte chars possible. */

-

7650

slen = (MB_CUR_MAX > 1) ? STRLEN (string) : 0;

( (__ctype_get...r_max ()) > 1)	Description
TRUE	evaluated 445 times by 1 test Evaluated by: Self test
FALSE	never evaluated

(string)[1]	Description
TRUE	evaluated 399 times by 1 test Evaluated by: Self test
FALSE	evaluated 30 times by 1 test Evaluated by: Self test

(string)[2]	Description
TRUE	evaluated 396 times by 1 test Evaluated by: Self test
FALSE	evaluated 3 times by 1 test Evaluated by: Self test

(string)	Description
TRUE	evaluated 445 times by 1 test Evaluated by: Self test
FALSE	never evaluated

(string)[0]	Description
TRUE	evaluated 429 times by 1 test Evaluated by: Self test
FALSE	evaluated 16 times by 1 test Evaluated by: Self test

0-445

7651

-

7652

i = s;

-

7653

while (string[start] && i--)

string[start]	Description
TRUE	evaluated 1880 times by 1 test Evaluated by: Self test
FALSE	evaluated 28 times by 1 test Evaluated by: Self test

i--	Description
TRUE	evaluated 1463 times by 1 test Evaluated by: Self test
FALSE	evaluated 417 times by 1 test Evaluated by: Self test

28-1880

7654

ADVANCE_CHAR (string, slen, start);

executed 1458 times by 1 test: mblength = 1;

Executed by:

Self test

never executed: mblength = 1;

executed 5 times by 1 test: end of block

Executed by:

Self test

never executed: end of block

never executed: (start)++;

executed 1463 times by 1 test: (start) += mblength;

Executed by:

Self test

never executed: (start)++;

executed 1463 times by 1 test: end of block

Executed by:

Self test

locale_mb_cur_max > 1	Description
TRUE	evaluated 1463 times by 1 test Evaluated by: Self test
FALSE	never evaluated

_f	Description
TRUE	evaluated 1458 times by 1 test Evaluated by: Self test
FALSE	evaluated 5 times by 1 test Evaluated by: Self test

mblength == 0	Description
TRUE	never evaluated
FALSE	evaluated 1463 times by 1 test Evaluated by: Self test

locale_utf8locale	Description
TRUE	evaluated 5 times by 1 test Evaluated by: Self test
FALSE	never evaluated

(((string)[sta... & 0x80) == 0)	Description
TRUE	never evaluated
FALSE	evaluated 5 times by 1 test Evaluated by: Self test

mblength == (size_t)-2	Description
TRUE	never evaluated
FALSE	evaluated 1463 times by 1 test Evaluated by: Self test

mblength == (size_t)-1	Description
TRUE	never evaluated
FALSE	evaluated 1463 times by 1 test Evaluated by: Self test

0-1463

7655

stop = start;

-

7656

i = e - s;

-

7657

while (string[stop] && i--)

string[stop]	Description
TRUE	evaluated 2953 times by 1 test Evaluated by: Self test
FALSE	evaluated 218 times by 1 test Evaluated by: Self test

i--	Description
TRUE	evaluated 2726 times by 1 test Evaluated by: Self test
FALSE	evaluated 227 times by 1 test Evaluated by: Self test

218-2953

7658

ADVANCE_CHAR (string, slen, stop);

executed 2601 times by 1 test: mblength = 1;

Executed by:

Self test

executed 125 times by 1 test: mblength = 1;

Executed by:

Self test

never executed: end of block

never executed: (stop)++;

executed 2726 times by 1 test: (stop) += mblength;

Executed by:

Self test

never executed: (stop)++;

executed 2726 times by 1 test: end of block

Executed by:

Self test

locale_mb_cur_max > 1	Description
TRUE	evaluated 2726 times by 1 test Evaluated by: Self test
FALSE	never evaluated

_f	Description
TRUE	evaluated 2601 times by 1 test Evaluated by: Self test
FALSE	evaluated 125 times by 1 test Evaluated by: Self test

mblength == 0	Description
TRUE	never evaluated
FALSE	evaluated 2726 times by 1 test Evaluated by: Self test

locale_utf8locale	Description
TRUE	evaluated 125 times by 1 test Evaluated by: Self test
FALSE	never evaluated

(((string)[stop] & 0x80) == 0)	Description
TRUE	evaluated 125 times by 1 test Evaluated by: Self test
FALSE	never evaluated

mblength == (size_t)-2	Description
TRUE	never evaluated
FALSE	evaluated 2726 times by 1 test Evaluated by: Self test

mblength == (size_t)-1	Description
TRUE	never evaluated
FALSE	evaluated 2726 times by 1 test Evaluated by: Self test

0-2726

7659

tt = substring (string, start, stop);

-

7660

return tt;

executed 445 times by 1 test: return tt;

Executed by:

Self test

445

7661

}

-

7662

#endif

-

7663

-

7664

/* Process a variable substring expansion: ${name:e1[:e2]}. If VARNAME

-

7665

is `@', use the positional parameters; otherwise, use the value of

-

7666

VARNAME. If VARNAME is an array variable, use the array elements. */

-

7667

-

7668

static char *

-

7669

parameter_brace_substring (varname, value, ind, substr, quoted, pflags, flags)

-

7670

char *varname, *value;

-

7671

int ind;

-

7672

char *substr;

-

7673

int quoted, pflags, flags;

-

7674

{

-

7675

intmax_t e1, e2;

-

7676

int vtype, r, starsub, qflags;

-

7677

char *temp, *val, *tt, *oname;

-

7678

SHELL_VAR *v;

-

7679

-

7680

if (value == 0 && ((varname[0] != '@' && varname[0] != '*') || varname[1]))

value == 0	Description
TRUE	evaluated 10 times by 1 test Evaluated by: Self test
FALSE	evaluated 784 times by 1 test Evaluated by: Self test

varname[0] != '@'	Description
TRUE	evaluated 2 times by 1 test Evaluated by: Self test
FALSE	evaluated 8 times by 1 test Evaluated by: Self test

varname[0] != '*'	Description
TRUE	evaluated 2 times by 1 test Evaluated by: Self test
FALSE	never evaluated

varname[1]	Description
TRUE	never evaluated
FALSE	evaluated 8 times by 1 test Evaluated by: Self test

0-784

7681

return ((char *)NULL);

executed 2 times by 1 test: return ((char *) ((void *)0) );

Executed by:

Self test

2

7682

-

7683

oname = this_command_name;

-

7684

this_command_name = varname;

-

7685

-

7686

vtype = get_var_and_type (varname, value, ind, quoted, flags, &v, &val);

-

7687

if (vtype == -1)

vtype == -1	Description
TRUE	never evaluated
FALSE	evaluated 792 times by 1 test Evaluated by: Self test

0-792

7688

{

-

7689

this_command_name = oname;

-

7690

return ((char *)NULL);

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

0

7691

}

-

7692

-

7693

starsub = vtype & VT_STARSUB;

-

7694

vtype &= ~VT_STARSUB;

-

7695

-

7696

r = verify_substring_values (v, val, substr, vtype, &e1, &e2);

-

7697

this_command_name = oname;

-

7698

if (r <= 0)

r <= 0	Description
TRUE	evaluated 48 times by 1 test Evaluated by: Self test
FALSE	evaluated 743 times by 1 test Evaluated by: Self test

48-743

7699

{

-

7700

if (vtype == VT_VARIABLE)

vtype == 0	Description
TRUE	evaluated 42 times by 1 test Evaluated by: Self test
FALSE	evaluated 6 times by 1 test Evaluated by: Self test

6-42

7701

FREE (val);

executed 42 times by 1 test: sh_xfree((val), "subst.c", 7701);

Executed by:

Self test

executed 42 times by 1 test: end of block

Executed by:

Self test

val	Description
TRUE	evaluated 42 times by 1 test Evaluated by: Self test
FALSE	never evaluated

0-42

7702

return ((r == 0) ? &expand_param_error : (char *)NULL);

executed 48 times by 1 test: return ((r == 0) ? &expand_param_error : (char *) ((void *)0) );

Executed by:

Self test

48

7703

}

-

7704

-

7705

switch (vtype)

-

7706

{

-

7707

case VT_VARIABLE:

executed 415 times by 1 test: case 0:

Executed by:

Self test

415

7708

case VT_ARRAYMEMBER:

executed 30 times by 1 test: case 3:

Executed by:

Self test

30

7709

#if defined (HANDLE_MULTIBYTE)

-

7710

if (MB_CUR_MAX > 1)

(__ctype_get_m...ur_max ()) > 1	Description
TRUE	evaluated 445 times by 1 test Evaluated by: Self test
FALSE	never evaluated

0-445

7711

tt = mb_substring (val, e1, e2);

executed 445 times by 1 test: tt = mb_substring (val, e1, e2);

Executed by:

Self test

445

7712

else

-

7713

#endif

-

7714

tt = substring (val, e1, e2);

never executed: tt = substring (val, e1, e2);

0

7715

-

7716

if (vtype == VT_VARIABLE)

vtype == 0	Description
TRUE	evaluated 415 times by 1 test Evaluated by: Self test
FALSE	evaluated 30 times by 1 test Evaluated by: Self test

30-415

7717

FREE (val);

executed 415 times by 1 test: sh_xfree((val), "subst.c", 7717);

Executed by:

Self test

executed 415 times by 1 test: end of block

Executed by:

Self test

val	Description
TRUE	evaluated 415 times by 1 test Evaluated by: Self test
FALSE	never evaluated

0-415

7718

if (quoted & (Q_DOUBLE_QUOTES|Q_HERE_DOCUMENT))

quoted & (0x001\|0x002)	Description
TRUE	evaluated 126 times by 1 test Evaluated by: Self test
FALSE	evaluated 319 times by 1 test Evaluated by: Self test

126-319

7719

temp = quote_string (tt);

executed 126 times by 1 test: temp = quote_string (tt);

Executed by:

Self test

126

7720

else

-

7721

temp = tt ? quote_escapes (tt) : (char *)NULL;

executed 319 times by 1 test: temp = tt ? quote_escapes (tt) : (char *) ((void *)0) ;

Executed by:

Self test

tt	Description
TRUE	evaluated 319 times by 1 test Evaluated by: Self test
FALSE	never evaluated

0-319

7722

FREE (tt);

executed 445 times by 1 test: sh_xfree((tt), "subst.c", 7722);

Executed by:

Self test

tt	Description
TRUE	evaluated 445 times by 1 test Evaluated by: Self test
FALSE	never evaluated

0-445

7723

break;

executed 445 times by 1 test: break;

Executed by:

Self test

445

7724

case VT_POSPARMS:

executed 221 times by 1 test: case 1:

Executed by:

Self test

221

7725

qflags = quoted;

-

7726

tt = pos_params (varname, e1, e2, qflags);

-

7727

/* string_list_dollar_at will quote the list if ifs_is_null != 0 */

-

7728

/* We want to leave this alone in every case where pos_params/

-

7729

string_list_pos_params quotes the list members */

-

7730

if (tt && quoted == 0 && ifs_is_null)

tt	Description
TRUE	evaluated 215 times by 1 test Evaluated by: Self test
FALSE	evaluated 6 times by 1 test Evaluated by: Self test

quoted == 0	Description
TRUE	evaluated 86 times by 1 test Evaluated by: Self test
FALSE	evaluated 129 times by 1 test Evaluated by: Self test

ifs_is_null	Description
TRUE	evaluated 4 times by 1 test Evaluated by: Self test
FALSE	evaluated 82 times by 1 test Evaluated by: Self test

4-215

7731

{

-

7732

temp = tt; /* Posix interp 888 */

-

7733

}

executed 4 times by 1 test: end of block

Executed by:

Self test

4

7734

else if ((quoted & (Q_DOUBLE_QUOTES|Q_HERE_DOCUMENT)) == 0)

(quoted & (0x001\|0x002)) == 0	Description
TRUE	evaluated 86 times by 1 test Evaluated by: Self test
FALSE	evaluated 131 times by 1 test Evaluated by: Self test

86-131

7735

{

-

7736

temp = tt ? quote_escapes (tt) : (char *)NULL;

tt	Description
TRUE	evaluated 82 times by 1 test Evaluated by: Self test
FALSE	evaluated 4 times by 1 test Evaluated by: Self test

4-82

7737

FREE (tt);

executed 82 times by 1 test: sh_xfree((tt), "subst.c", 7737);

Executed by:

Self test

tt	Description
TRUE	evaluated 82 times by 1 test Evaluated by: Self test
FALSE	evaluated 4 times by 1 test Evaluated by: Self test

4-82

7738

}

executed 86 times by 1 test: end of block

Executed by:

Self test

86

7739

else

-

7740

temp = tt;

executed 131 times by 1 test: temp = tt;

Executed by:

Self test

131

7741

break;

executed 221 times by 1 test: break;

Executed by:

Self test

221

7742

#if defined (ARRAY_VARS)

-

7743

case VT_ARRAYVAR:

executed 77 times by 1 test: case 2:

Executed by:

Self test

77

7744

if (assoc_p (v))

((((v)->attrib... (0x0000040)))	Description
TRUE	evaluated 2 times by 1 test Evaluated by: Self test
FALSE	evaluated 75 times by 1 test Evaluated by: Self test

2-75

7745

/* we convert to list and take first e2 elements starting at e1th

-

7746

element -- officially undefined for now */

-

7747

temp = assoc_subrange (assoc_cell (v), e1, e2, starsub, quoted);

executed 2 times by 1 test: temp = assoc_subrange ((HASH_TABLE *)((v)->value), e1, e2, starsub, quoted);

Executed by:

Self test

2

7748

else

-

7749

/* We want E2 to be the number of elements desired (arrays can be sparse,

-

7750

so verify_substring_values just returns the numbers specified and we

-

7751

rely on array_subrange to understand how to deal with them). */

-

7752

temp = array_subrange (array_cell (v), e1, e2, starsub, quoted);

executed 75 times by 1 test: temp = array_subrange ((ARRAY *)((v)->value), e1, e2, starsub, quoted);

Executed by:

Self test

75

7753

/* array_subrange now calls array_quote_escapes as appropriate, so the

-

7754

caller no longer needs to. */

-

7755

break;

executed 77 times by 1 test: break;

Executed by:

Self test

77

7756

#endif

-

7757

default:

never executed: default:

0

7758

temp = (char *)NULL;

-

7759

}

never executed: end of block

0

7760

-

7761

return temp;

executed 743 times by 1 test: return temp;

Executed by:

Self test

743

7762

}

-

7763

-

7764

/****************************************************************/

-

7765

/* */

-

7766

/* Functions to perform pattern substitution on variable values */

-

7767

/* */

-

7768

/****************************************************************/

-

7769

-

7770

#ifdef INCLUDE_UNUSED

-

7771

static int

-

7772

shouldexp_replacement (s)

-

7773

char *s;

-

7774

{

-

7775

register char *p;

-

7776

-

7777

for (p = s; p && *p; p++)

-

7778

{

-

7779

if (*p == '\\')

-

7780

p++;

-

7781

else if (*p == '&')

-

7782

return 1;

-

7783

}

-

7784

return 0;

-

7785

}

-

7786

#endif

-

7787

-

7788

char *

-

7789

pat_subst (string, pat, rep, mflags)

-

7790

char *string, *pat, *rep;

-

7791

int mflags;

-

7792

{

-

7793

char *ret, *s, *e, *str, *rstr, *mstr;

-

7794

int rptr, mtype, rxpand, mlen;

-

7795

size_t rsize, l, replen, rslen;

-

7796

-

7797

if (string == 0)

string == 0	Description
TRUE	never evaluated
FALSE	evaluated 2176 times by 1 test Evaluated by: Self test

0-2176

7798

return (savestring (""));

never executed: return ((char *)strcpy (sh_xmalloc((1 + strlen ("")), "subst.c", 7798), ("")));

0

7799

-

7800

mtype = mflags & MATCH_TYPEMASK;

-

7801

-

7802

#if 0 /* bash-4.2 ? */

-

7803

rxpand = (rep && *rep) ? shouldexp_replacement (rep) : 0;

-

7804

#else

-

7805

rxpand = 0;

-

7806

#endif

-

7807

-

7808

/* Special cases:

-

7809

* 1. A null pattern with mtype == MATCH_BEG means to prefix STRING

-

7810

* with REP and return the result.

-

7811

* 2. A null pattern with mtype == MATCH_END means to append REP to

-

7812

* STRING and return the result.

-

7813

* 3. A null STRING with a matching pattern means to append REP to

-

7814

* STRING and return the result.

-

7815

* These don't understand or process `&' in the replacement string.

-

7816

*/

-

7817

if ((pat == 0 || *pat == 0) && (mtype == MATCH_BEG || mtype == MATCH_END))

pat == 0	Description
TRUE	evaluated 31 times by 1 test Evaluated by: Self test
FALSE	evaluated 2145 times by 1 test Evaluated by: Self test

*pat == 0	Description
TRUE	evaluated 112 times by 1 test Evaluated by: Self test
FALSE	evaluated 2033 times by 1 test Evaluated by: Self test

mtype == 0x001	Description
TRUE	evaluated 110 times by 1 test Evaluated by: Self test
FALSE	evaluated 33 times by 1 test Evaluated by: Self test

mtype == 0x002	Description
TRUE	evaluated 2 times by 1 test Evaluated by: Self test
FALSE	evaluated 31 times by 1 test Evaluated by: Self test

2-2145

7818

{

-

7819

replen = STRLEN (rep);

(rep)[1]	Description
TRUE	evaluated 80 times by 1 test Evaluated by: Self test
FALSE	evaluated 30 times by 1 test Evaluated by: Self test

(rep)[2]	Description
TRUE	evaluated 78 times by 1 test Evaluated by: Self test
FALSE	evaluated 2 times by 1 test Evaluated by: Self test

(rep)	Description
TRUE	evaluated 110 times by 1 test Evaluated by: Self test
FALSE	evaluated 2 times by 1 test Evaluated by: Self test

(rep)[0]	Description
TRUE	evaluated 110 times by 1 test Evaluated by: Self test
FALSE	never evaluated

0-110

7820

l = STRLEN (string);

(string)[1]	Description
TRUE	evaluated 79 times by 1 test Evaluated by: Self test
FALSE	evaluated 24 times by 1 test Evaluated by: Self test

(string)[2]	Description
TRUE	evaluated 79 times by 1 test Evaluated by: Self test
FALSE	never evaluated

(string)	Description
TRUE	evaluated 112 times by 1 test Evaluated by: Self test
FALSE	never evaluated

(string)[0]	Description
TRUE	evaluated 103 times by 1 test Evaluated by: Self test
FALSE	evaluated 9 times by 1 test Evaluated by: Self test

0-112

7821

ret = (char *)xmalloc (replen + l + 2);

-

7822

if (replen == 0)

replen == 0	Description
TRUE	evaluated 2 times by 1 test Evaluated by: Self test
FALSE	evaluated 110 times by 1 test Evaluated by: Self test

2-110

7823

strcpy (ret, string);

executed 2 times by 1 test: strcpy (ret, string);

Executed by:

Self test

2

7824

else if (mtype == MATCH_BEG)

mtype == 0x001	Description
TRUE	evaluated 109 times by 1 test Evaluated by: Self test
FALSE	evaluated 1 time by 1 test Evaluated by: Self test

1-109

7825

{

-

7826

strcpy (ret, rep);

-

7827

strcpy (ret + replen, string);

-

7828

}

executed 109 times by 1 test: end of block

Executed by:

Self test

109

7829

else

-

7830

{

-

7831

strcpy (ret, string);

-

7832

strcpy (ret + l, rep);

-

7833

}

executed 1 time by 1 test: end of block

Executed by:

Self test

1

7834

return (ret);

executed 112 times by 1 test: return (ret);

Executed by:

Self test

112

7835

}

-

7836

else if (*string == 0 && (match_pattern (string, pat, mtype, &s, &e) != 0))

*string == 0	Description
TRUE	evaluated 32 times by 1 test Evaluated by: Self test
FALSE	evaluated 2032 times by 1 test Evaluated by: Self test

(match_pattern... &s, &e) != 0)	Description
TRUE	evaluated 18 times by 1 test Evaluated by: Self test
FALSE	evaluated 14 times by 1 test Evaluated by: Self test

14-2032

7837

{

-

7838

replen = STRLEN (rep);

(rep)[1]	Description
TRUE	never evaluated
FALSE	evaluated 18 times by 1 test Evaluated by: Self test

(rep)[2]	Description
TRUE	never evaluated
FALSE	never evaluated

(rep)	Description
TRUE	evaluated 18 times by 1 test Evaluated by: Self test
FALSE	never evaluated

(rep)[0]	Description
TRUE	evaluated 18 times by 1 test Evaluated by: Self test
FALSE	never evaluated

0-18

7839

ret = (char *)xmalloc (replen + 1);

-

7840

if (replen == 0)

replen == 0	Description
TRUE	never evaluated
FALSE	evaluated 18 times by 1 test Evaluated by: Self test

0-18

7841

ret[0] = '\0';

never executed: ret[0] = '\0';

0

7842

else

-

7843

strcpy (ret, rep);

executed 18 times by 1 test: strcpy (ret, rep);

Executed by:

Self test

18

7844

return (ret);

executed 18 times by 1 test: return (ret);

Executed by:

Self test

18

7845

}

-

7846

-

7847

ret = (char *)xmalloc (rsize = 64);

-

7848

ret[0] = '\0';

-

7849

-

7850

for (replen = STRLEN (rep), rptr = 0, str = string; *str;)

*str	Description
TRUE	evaluated 60180 times by 1 test Evaluated by: Self test
FALSE	evaluated 174 times by 1 test Evaluated by: Self test

174-60180

7851

{

-

7852

if (match_pattern (str, pat, mtype, &s, &e) == 0)

match_pattern ..., &s, &e) == 0	Description
TRUE	evaluated 832 times by 1 test Evaluated by: Self test
FALSE	evaluated 59348 times by 1 test Evaluated by: Self test

832-59348

7853

break;

executed 832 times by 1 test: break;

Executed by:

Self test

832

7854

l = s - str;

-

7855

-

7856

if (rep && rxpand)

rep	Description
TRUE	evaluated 1185 times by 1 test Evaluated by: Self test
FALSE	evaluated 58163 times by 1 test Evaluated by: Self test

rxpand	Description
TRUE	never evaluated
FALSE	evaluated 1185 times by 1 test Evaluated by: Self test

0-58163

7857

{

-

7858

int x;

-

7859

mlen = e - s;

-

7860

mstr = xmalloc (mlen + 1);

-

7861

for (x = 0; x < mlen; x++)

x < mlen	Description
TRUE	never evaluated
FALSE	never evaluated

0

7862

mstr[x] = s[x];

never executed: mstr[x] = s[x];

0

7863

mstr[mlen] = '\0';

-

7864

rstr = strcreplace (rep, '&', mstr, 0);

-

7865

free (mstr);

-

7866

rslen = strlen (rstr);

-

7867

}

never executed: end of block

0

7868

else

-

7869

{

-

7870

rstr = rep;

-

7871

rslen = replen;

-

7872

}

executed 59348 times by 1 test: end of block

Executed by:

Self test

59348

7873

-

7874

RESIZE_MALLOCED_BUFFER (ret, rptr, (l + rslen), rsize, 64);

executed 826 times by 1 test: rsize += (64);

Executed by:

Self test

executed 520 times by 1 test: end of block

Executed by:

Self test

(rptr) + ((l +...len)) >= rsize	Description
TRUE	evaluated 520 times by 1 test Evaluated by: Self test
FALSE	evaluated 58828 times by 1 test Evaluated by: Self test

(rptr) + ((l +...len)) >= rsize	Description
TRUE	evaluated 826 times by 1 test Evaluated by: Self test
FALSE	evaluated 520 times by 1 test Evaluated by: Self test

520-58828

7875

-

7876

/* OK, now copy the leading unmatched portion of the string (from

-

7877

str to s) to ret starting at rptr (the current offset). Then copy

-

7878

the replacement string at ret + rptr + (s - str). Increment

-

7879

rptr (if necessary) and str and go on. */

-

7880

if (l)

l	Description
TRUE	evaluated 10505 times by 1 test Evaluated by: Self test
FALSE	evaluated 48843 times by 1 test Evaluated by: Self test

10505-48843

7881

{

-

7882

strncpy (ret + rptr, str, l);

-

7883

rptr += l;

-

7884

}

executed 10505 times by 1 test: end of block

Executed by:

Self test

10505

7885

if (replen)

replen	Description
TRUE	evaluated 1185 times by 1 test Evaluated by: Self test
FALSE	evaluated 58163 times by 1 test Evaluated by: Self test

1185-58163

7886

{

-

7887

strncpy (ret + rptr, rstr, rslen);

-

7888

rptr += rslen;

-

7889

}

executed 1185 times by 1 test: end of block

Executed by:

Self test

1185

7890

str = e; /* e == end of match */

-

7891

-

7892

if (rstr != rep)

rstr != rep	Description
TRUE	never evaluated
FALSE	evaluated 59348 times by 1 test Evaluated by: Self test

0-59348

7893

free (rstr);

never executed: sh_xfree((rstr), "subst.c", 7893);

0

7894

-

7895

if (((mflags & MATCH_GLOBREP) == 0) || mtype != MATCH_ANY)

((mflags & 0x010) == 0)	Description
TRUE	evaluated 1040 times by 1 test Evaluated by: Self test
FALSE	evaluated 58308 times by 1 test Evaluated by: Self test

mtype != 0x000	Description
TRUE	never evaluated
FALSE	evaluated 58308 times by 1 test Evaluated by: Self test

0-58308

7896

break;

executed 1040 times by 1 test: break;

Executed by:

Self test

1040

7897

-

7898

if (s == e)

s == e	Description
TRUE	never evaluated
FALSE	evaluated 58308 times by 1 test Evaluated by: Self test

0-58308

7899

{

-

7900

/* On a zero-length match, make sure we copy one character, since

-

7901

we increment one character to avoid infinite recursion. */

-

7902

RESIZE_MALLOCED_BUFFER (ret, rptr, 1, rsize, 64);

never executed: rsize += (64);

never executed: end of block

(rptr) + (1) >= rsize	Description
TRUE	never evaluated
FALSE	never evaluated

(rptr) + (1) >= rsize	Description
TRUE	never evaluated
FALSE	never evaluated

0

7903

ret[rptr++] = *str++;

-

7904

e++; /* avoid infinite recursion on zero-length match */

-

7905

}

never executed: end of block

0

7906

}

executed 58308 times by 1 test: end of block

Executed by:

Self test

58308

7907

-

7908

/* Now copy the unmatched portion of the input string */

-

7909

if (str && *str)

str	Description
TRUE	evaluated 2046 times by 1 test Evaluated by: Self test
FALSE	never evaluated

*str	Description
TRUE	evaluated 1459 times by 1 test Evaluated by: Self test
FALSE	evaluated 587 times by 1 test Evaluated by: Self test

0-2046

7910

{

-

7911

RESIZE_MALLOCED_BUFFER (ret, rptr, STRLEN(str) + 1, rsize, 64);

executed 1241 times by 1 test: rsize += (64);

Executed by:

Self test

executed 17 times by 1 test: end of block

Executed by:

Self test

(rptr) + ((((s... + 1) >= rsize	Description
TRUE	evaluated 17 times by 1 test Evaluated by: Self test
FALSE	evaluated 1442 times by 1 test Evaluated by: Self test

(rptr) + ((((s... + 1) >= rsize	Description
TRUE	evaluated 1241 times by 1 test Evaluated by: Self test
FALSE	evaluated 17 times by 1 test Evaluated by: Self test

(str)[1]	Description
TRUE	evaluated 701 times by 1 test Evaluated by: Self test
FALSE	evaluated 758 times by 1 test Evaluated by: Self test

(str)[2]	Description
TRUE	evaluated 519 times by 1 test Evaluated by: Self test
FALSE	evaluated 182 times by 1 test Evaluated by: Self test

(str)[1]	Description
TRUE	evaluated 1258 times by 1 test Evaluated by: Self test
FALSE	never evaluated

(str)[2]	Description
TRUE	evaluated 1258 times by 1 test Evaluated by: Self test
FALSE	never evaluated

(str)	Description
TRUE	evaluated 1459 times by 1 test Evaluated by: Self test
FALSE	never evaluated

(str)[0]	Description
TRUE	evaluated 1459 times by 1 test Evaluated by: Self test
FALSE	never evaluated

(str)	Description
TRUE	evaluated 1258 times by 1 test Evaluated by: Self test
FALSE	never evaluated

(str)[0]	Description
TRUE	evaluated 1258 times by 1 test Evaluated by: Self test
FALSE	never evaluated

0-1459

7912

strcpy (ret + rptr, str);

-

7913

}

executed 1459 times by 1 test: end of block

Executed by:

Self test

1459

7914

else

-

7915

ret[rptr] = '\0';

executed 587 times by 1 test: ret[rptr] = '\0';

Executed by:

Self test

587

7916

-

7917

return ret;

executed 2046 times by 1 test: return ret;

Executed by:

Self test

2046

7918

}

-

7919

-

7920

/* Do pattern match and replacement on the positional parameters. */

-

7921

static char *

-

7922

pos_params_pat_subst (string, pat, rep, mflags)

-

7923

char *string, *pat, *rep;

-

7924

int mflags;

-

7925

{

-

7926

WORD_LIST *save, *params;

-

7927

WORD_DESC *w;

-

7928

char *ret;

-

7929

int pchar, qflags;

-

7930

-

7931

save = params = list_rest_of_args ();

-

7932

if (save == 0)

save == 0	Description
TRUE	never evaluated
FALSE	evaluated 140 times by 1 test Evaluated by: Self test

0-140

7933

return ((char *)NULL);

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

0

7934

-

7935

for ( ; params; params = params->next)

params	Description
TRUE	evaluated 779 times by 1 test Evaluated by: Self test
FALSE	evaluated 140 times by 1 test Evaluated by: Self test

140-779

7936

{

-

7937

ret = pat_subst (params->word->word, pat, rep, mflags);

-

7938

w = alloc_word_desc ();

-

7939

w->word = ret ? ret : savestring ("");

ret	Description
TRUE	evaluated 779 times by 1 test Evaluated by: Self test
FALSE	never evaluated

0-779

7940

dispose_word (params->word);

-

7941

params->word = w;

-

7942

}

executed 779 times by 1 test: end of block

Executed by:

Self test

779

7943

-

7944

pchar = (mflags & MATCH_STARSUB) == MATCH_STARSUB ? '*' : '@';

(mflags & 0x080) == 0x080	Description
TRUE	evaluated 26 times by 1 test Evaluated by: Self test
FALSE	evaluated 114 times by 1 test Evaluated by: Self test

26-114

7945

qflags = (mflags & MATCH_QUOTED) == MATCH_QUOTED ? Q_DOUBLE_QUOTES : 0;

(mflags & 0x020) == 0x020	Description
TRUE	evaluated 28 times by 1 test Evaluated by: Self test
FALSE	evaluated 112 times by 1 test Evaluated by: Self test

28-112

7946

-

7947

/* If we are expanding in a context where word splitting will not be

-

7948

performed, treat as quoted. This changes how $* will be expanded. */

-

7949

if (pchar == '*' && (mflags & MATCH_ASSIGNRHS) && expand_no_split_dollar_star && ifs_is_null)

pchar == '*'	Description
TRUE	evaluated 26 times by 1 test Evaluated by: Self test
FALSE	evaluated 114 times by 1 test Evaluated by: Self test

(mflags & 0x040)	Description
TRUE	evaluated 6 times by 1 test Evaluated by: Self test
FALSE	evaluated 20 times by 1 test Evaluated by: Self test

expand_no_split_dollar_star	Description
TRUE	evaluated 3 times by 1 test Evaluated by: Self test
FALSE	evaluated 3 times by 1 test Evaluated by: Self test

ifs_is_null	Description
TRUE	evaluated 3 times by 1 test Evaluated by: Self test
FALSE	never evaluated

0-114

7950

qflags |= Q_DOUBLE_QUOTES; /* Posix interp 888 */

executed 3 times by 1 test: qflags |= 0x001;

Executed by:

Self test

3

7951

-

7952

ret = string_list_pos_params (pchar, save, qflags);

-

7953

dispose_words (save);

-

7954

-

7955

return (ret);

executed 140 times by 1 test: return (ret);

Executed by:

Self test

140

7956

}

-

7957

-

7958

/* Perform pattern substitution on VALUE, which is the expansion of

-

7959

VARNAME. PATSUB is an expression supplying the pattern to match

-

7960

and the string to substitute. QUOTED is a flags word containing

-

7961

the type of quoting currently in effect. */

-

7962

static char *

-

7963

parameter_brace_patsub (varname, value, ind, patsub, quoted, pflags, flags)

-

7964

char *varname, *value;

-

7965

int ind;

-

7966

char *patsub;

-

7967

int quoted, pflags, flags;

-

7968

{

-

7969

int vtype, mflags, starsub, delim;

-

7970

char *val, *temp, *pat, *rep, *p, *lpatsub, *tt, *oname;

-

7971

SHELL_VAR *v;

-

7972

-

7973

if (value == 0)

value == 0	Description
TRUE	evaluated 16 times by 1 test Evaluated by: Self test
FALSE	evaluated 861 times by 1 test Evaluated by: Self test

16-861

7974

return ((char *)NULL);

executed 16 times by 1 test: return ((char *) ((void *)0) );

Executed by:

Self test

16

7975

-

7976

oname = this_command_name;

-

7977

this_command_name = varname; /* error messages */

-

7978

-

7979

vtype = get_var_and_type (varname, value, ind, quoted, flags, &v, &val);

-

7980

if (vtype == -1)

vtype == -1	Description
TRUE	never evaluated
FALSE	evaluated 861 times by 1 test Evaluated by: Self test

0-861

7981

{

-

7982

this_command_name = oname;

-

7983

return ((char *)NULL);

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

0

7984

}

-

7985

-

7986

starsub = vtype & VT_STARSUB;

-

7987

vtype &= ~VT_STARSUB;

-

7988

-

7989

mflags = 0;

-

7990

/* PATSUB is never NULL when this is called. */

-

7991

if (*patsub == '/')

*patsub == '/'	Description
TRUE	evaluated 304 times by 1 test Evaluated by: Self test
FALSE	evaluated 557 times by 1 test Evaluated by: Self test

304-557

7992

{

-

7993

mflags |= MATCH_GLOBREP;

-

7994

patsub++;

-

7995

}

executed 304 times by 1 test: end of block

Executed by:

Self test

304

7996

-

7997

/* Malloc this because expand_string_if_necessary or one of the expansion

-

7998

functions in its call chain may free it on a substitution error. */

-

7999

lpatsub = savestring (patsub);

-

8000

-

8001

if (quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES))

quoted & (0x002\|0x001)	Description
TRUE	evaluated 223 times by 1 test Evaluated by: Self test
FALSE	evaluated 638 times by 1 test Evaluated by: Self test

223-638

8002

mflags |= MATCH_QUOTED;

executed 223 times by 1 test: mflags |= 0x020;

Executed by:

Self test

223

8003

-

8004

if (starsub)

starsub	Description
TRUE	evaluated 51 times by 1 test Evaluated by: Self test
FALSE	evaluated 810 times by 1 test Evaluated by: Self test

51-810

8005

mflags |= MATCH_STARSUB;

executed 51 times by 1 test: mflags |= 0x080;

Executed by:

Self test

51

8006

-

8007

if (pflags & PF_ASSIGNRHS)

pflags & 0x08	Description
TRUE	evaluated 12 times by 1 test Evaluated by: Self test
FALSE	evaluated 849 times by 1 test Evaluated by: Self test

12-849

8008

mflags |= MATCH_ASSIGNRHS;

executed 12 times by 1 test: mflags |= 0x040;

Executed by:

Self test

12

8009

-

8010

/* If the pattern starts with a `/', make sure we skip over it when looking

-

8011

for the replacement delimiter. */

-

8012

delim = skip_to_delim (lpatsub, ((*patsub == '/') ? 1 : 0), "/", 0);

-

8013

if (lpatsub[delim] == '/')

lpatsub[delim] == '/'	Description
TRUE	evaluated 745 times by 1 test Evaluated by: Self test
FALSE	evaluated 116 times by 1 test Evaluated by: Self test

116-745

8014

{

-

8015

lpatsub[delim] = 0;

-

8016

rep = lpatsub + delim + 1;

-

8017

}

executed 745 times by 1 test: end of block

Executed by:

Self test

745

8018

else

-

8019

rep = (char *)NULL;

executed 116 times by 1 test: rep = (char *) ((void *)0) ;

Executed by:

Self test

116

8020

-

8021

if (rep && *rep == '\0')

rep	Description
TRUE	evaluated 745 times by 1 test Evaluated by: Self test
FALSE	evaluated 116 times by 1 test Evaluated by: Self test

*rep == '\0'	Description
TRUE	evaluated 154 times by 1 test Evaluated by: Self test
FALSE	evaluated 591 times by 1 test Evaluated by: Self test

116-745

8022

rep = (char *)NULL;

executed 154 times by 1 test: rep = (char *) ((void *)0) ;

Executed by:

Self test

154

8023

-

8024

/* Perform the same expansions on the pattern as performed by the

-

8025

pattern removal expansions. */

-

8026

pat = getpattern (lpatsub, quoted, 1);

-

8027

-

8028

if (rep)

rep	Description
TRUE	evaluated 589 times by 1 test Evaluated by: Self test
FALSE	evaluated 268 times by 1 test Evaluated by: Self test

268-589

8029

{

-

8030

/* We want to perform quote removal on the expanded replacement even if

-

8031

the entire expansion is double-quoted because the parser and string

-

8032

extraction functions treated quotes in the replacement string as

-

8033

special. THIS IS NOT BACKWARDS COMPATIBLE WITH BASH-4.2. */

-

8034

if (shell_compatibility_level > 42)

shell_compatibility_level > 42	Description
TRUE	evaluated 589 times by 1 test Evaluated by: Self test
FALSE	never evaluated

0-589

8035

rep = expand_string_if_necessary (rep, quoted & ~(Q_DOUBLE_QUOTES|Q_HERE_DOCUMENT), expand_string_unsplit);

executed 589 times by 1 test: rep = expand_string_if_necessary (rep, quoted & ~(0x001|0x002), expand_string_unsplit);

Executed by:

Self test

589

8036

/* This is the bash-4.2 code. */

-

8037

else if ((mflags & MATCH_QUOTED) == 0)

(mflags & 0x020) == 0	Description
TRUE	never evaluated
FALSE	never evaluated

0

8038

rep = expand_string_if_necessary (rep, quoted, expand_string_unsplit);

never executed: rep = expand_string_if_necessary (rep, quoted, expand_string_unsplit);

0

8039

else

-

8040

rep = expand_string_to_string_internal (rep, quoted, expand_string_unsplit);

never executed: rep = expand_string_to_string_internal (rep, quoted, expand_string_unsplit);

0

8041

}

-

8042

-

8043

/* ksh93 doesn't allow the match specifier to be a part of the expanded

-

8044

pattern. This is an extension. Make sure we don't anchor the pattern

-

8045

at the beginning or end of the string if we're doing global replacement,

-

8046

though. */

-

8047

p = pat;

-

8048

if (mflags & MATCH_GLOBREP)

mflags & 0x010	Description
TRUE	evaluated 300 times by 1 test Evaluated by: Self test
FALSE	evaluated 557 times by 1 test Evaluated by: Self test

300-557

8049

mflags |= MATCH_ANY;

executed 300 times by 1 test: mflags |= 0x000;

Executed by:

Self test

300

8050

else if (pat && pat[0] == '#')

pat	Description
TRUE	evaluated 541 times by 1 test Evaluated by: Self test
FALSE	evaluated 16 times by 1 test Evaluated by: Self test

pat[0] == '#'	Description
TRUE	evaluated 122 times by 1 test Evaluated by: Self test
FALSE	evaluated 419 times by 1 test Evaluated by: Self test

16-541

8051

{

-

8052

mflags |= MATCH_BEG;

-

8053

p++;

-

8054

}

executed 122 times by 1 test: end of block

Executed by:

Self test

122

8055

else if (pat && pat[0] == '%')

pat	Description
TRUE	evaluated 419 times by 1 test Evaluated by: Self test
FALSE	evaluated 16 times by 1 test Evaluated by: Self test

pat[0] == '%'	Description
TRUE	evaluated 97 times by 1 test Evaluated by: Self test
FALSE	evaluated 322 times by 1 test Evaluated by: Self test

16-419

8056

{

-

8057

mflags |= MATCH_END;

-

8058

p++;

-

8059

}

executed 97 times by 1 test: end of block

Executed by:

Self test

97

8060

else

-

8061

mflags |= MATCH_ANY;

executed 338 times by 1 test: mflags |= 0x000;

Executed by:

Self test

338

8062

-

8063

/* OK, we now want to substitute REP for PAT in VAL. If

-

8064

flags & MATCH_GLOBREP is non-zero, the substitution is done

-

8065

everywhere, otherwise only the first occurrence of PAT is

-

8066

replaced. The pattern matching code doesn't understand

-

8067

CTLESC quoting CTLESC and CTLNUL so we use the dequoted variable

-

8068

values passed in (VT_VARIABLE) so the pattern substitution

-

8069

code works right. We need to requote special chars after

-

8070

we're done for VT_VARIABLE and VT_ARRAYMEMBER, and for the

-

8071

other cases if QUOTED == 0, since the posparams and arrays

-

8072

indexed by * or @ do special things when QUOTED != 0. */

-

8073

-

8074

switch (vtype)

-

8075

{

-

8076

case VT_VARIABLE:

executed 463 times by 1 test: case 0:

Executed by:

Self test

463

8077

case VT_ARRAYMEMBER:

executed 108 times by 1 test: case 3:

Executed by:

Self test

108

8078

temp = pat_subst (val, p, rep, mflags);

-

8079

if (vtype == VT_VARIABLE)

vtype == 0	Description
TRUE	evaluated 463 times by 1 test Evaluated by: Self test
FALSE	evaluated 108 times by 1 test Evaluated by: Self test

108-463

8080

FREE (val);

executed 463 times by 1 test: sh_xfree((val), "subst.c", 8080);

Executed by:

Self test

executed 463 times by 1 test: end of block

Executed by:

Self test

val	Description
TRUE	evaluated 463 times by 1 test Evaluated by: Self test
FALSE	never evaluated

0-463

8081

if (temp)

temp	Description
TRUE	evaluated 571 times by 1 test Evaluated by: Self test
FALSE	never evaluated

0-571

8082

{

-

8083

tt = (mflags & MATCH_QUOTED) ? quote_string (temp) : quote_escapes (temp);

(mflags & 0x020)	Description
TRUE	evaluated 143 times by 1 test Evaluated by: Self test
FALSE	evaluated 428 times by 1 test Evaluated by: Self test

143-428

8084

free (temp);

-

8085

temp = tt;

-

8086

}

executed 571 times by 1 test: end of block

Executed by:

Self test

571

8087

break;

executed 571 times by 1 test: break;

Executed by:

Self test

571

8088

case VT_POSPARMS:

executed 140 times by 1 test: case 1:

Executed by:

Self test

140

8089

/* This does the right thing for the case where we are not performing

-

8090

word splitting. MATCH_STARSUB restricts it to ${* /foo/bar}, and

-

8091

pos_params_pat_subst/string_list_pos_params will do the right thing

-

8092

in turn for the case where ifs_is_null. Posix interp 888 */

-

8093

if ((pflags & PF_NOSPLIT2) && (mflags & MATCH_STARSUB))

(pflags & 0x04)	Description
TRUE	evaluated 3 times by 1 test Evaluated by: Self test
FALSE	evaluated 137 times by 1 test Evaluated by: Self test

(mflags & 0x080)	Description
TRUE	evaluated 3 times by 1 test Evaluated by: Self test
FALSE	never evaluated

0-137

8094

mflags |= MATCH_ASSIGNRHS;

executed 3 times by 1 test: mflags |= 0x040;

Executed by:

Self test

3

8095

temp = pos_params_pat_subst (val, p, rep, mflags);

-

8096

if (temp && quoted == 0 && ifs_is_null)

temp	Description
TRUE	evaluated 140 times by 1 test Evaluated by: Self test
FALSE	never evaluated

quoted == 0	Description
TRUE	evaluated 112 times by 1 test Evaluated by: Self test
FALSE	evaluated 28 times by 1 test Evaluated by: Self test

ifs_is_null	Description
TRUE	evaluated 6 times by 1 test Evaluated by: Self test
FALSE	evaluated 106 times by 1 test Evaluated by: Self test

0-140

8097

{

-

8098

/* Posix interp 888 */

-

8099

}

executed 6 times by 1 test: end of block

Executed by:

Self test

6

8100

else if (temp && (mflags & MATCH_QUOTED) == 0)

temp	Description
TRUE	evaluated 134 times by 1 test Evaluated by: Self test
FALSE	never evaluated

(mflags & 0x020) == 0	Description
TRUE	evaluated 106 times by 1 test Evaluated by: Self test
FALSE	evaluated 28 times by 1 test Evaluated by: Self test

0-134

8101

{

-

8102

tt = quote_escapes (temp);

-

8103

free (temp);

-

8104

temp = tt;

-

8105

}

executed 106 times by 1 test: end of block

Executed by:

Self test

106

8106

break;

executed 140 times by 1 test: break;

Executed by:

Self test

140

8107

#if defined (ARRAY_VARS)

-

8108

case VT_ARRAYVAR:

executed 146 times by 1 test: case 2:

Executed by:

Self test

146

8109

/* If we are expanding in a context where word splitting will not be

-

8110

performed, treat as quoted. This changes how ${A[*]} will be

-

8111

expanded to make it identical to $*. */

-

8112

if ((mflags & MATCH_STARSUB) && (mflags & MATCH_ASSIGNRHS) && ifs_is_null)

(mflags & 0x080)	Description
TRUE	evaluated 25 times by 1 test Evaluated by: Self test
FALSE	evaluated 121 times by 1 test Evaluated by: Self test

(mflags & 0x040)	Description
TRUE	evaluated 1 time by 1 test Evaluated by: Self test
FALSE	evaluated 24 times by 1 test Evaluated by: Self test

ifs_is_null	Description
TRUE	never evaluated
FALSE	evaluated 1 time by 1 test Evaluated by: Self test

0-121

8113

mflags |= MATCH_QUOTED; /* Posix interp 888 */

never executed: mflags |= 0x020;

0

8114

-

8115

temp = assoc_p (v) ? assoc_patsub (assoc_cell (v), p, rep, mflags)

((((v)->attrib... (0x0000040)))	Description
TRUE	evaluated 8 times by 1 test Evaluated by: Self test
FALSE	evaluated 138 times by 1 test Evaluated by: Self test

8-138

8116

: array_patsub (array_cell (v), p, rep, mflags);

-

8117

/* Don't call quote_escapes anymore; array_patsub calls

-

8118

array_quote_escapes as appropriate before adding the

-

8119

space separators; ditto for assoc_patsub. */

-

8120

break;

executed 146 times by 1 test: break;

Executed by:

Self test

146

8121

#endif

-

8122

}

-

8123

-

8124

FREE (pat);

executed 832 times by 1 test: sh_xfree((pat), "subst.c", 8124);

Executed by:

Self test

pat	Description
TRUE	evaluated 832 times by 1 test Evaluated by: Self test
FALSE	evaluated 25 times by 1 test Evaluated by: Self test

25-832

8125

FREE (rep);

executed 588 times by 1 test: sh_xfree((rep), "subst.c", 8125);

Executed by:

Self test

rep	Description
TRUE	evaluated 588 times by 1 test Evaluated by: Self test
FALSE	evaluated 269 times by 1 test Evaluated by: Self test

269-588

8126

free (lpatsub);

-

8127

-

8128

this_command_name = oname;

-

8129

-

8130

return temp;

executed 857 times by 1 test: return temp;

Executed by:

Self test

857

8131

}

-

8132

-

8133

/****************************************************************/

-

8134

/* */

-

8135

/* Functions to perform case modification on variable values */

-

8136

/* */

-

8137

/****************************************************************/

-

8138

-

8139

/* Do case modification on the positional parameters. */

-

8140

-

8141

static char *

-

8142

pos_params_modcase (string, pat, modop, mflags)

-

8143

char *string, *pat;

-

8144

int modop;

-

8145

int mflags;

-

8146

{

-

8147

WORD_LIST *save, *params;

-

8148

WORD_DESC *w;

-

8149

char *ret;

-

8150

int pchar, qflags;

-

8151

-

8152

save = params = list_rest_of_args ();

-

8153

if (save == 0)

save == 0	Description
TRUE	never evaluated
FALSE	evaluated 14 times by 1 test Evaluated by: Self test

0-14

8154

return ((char *)NULL);

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

0

8155

-

8156

for ( ; params; params = params->next)

params	Description
TRUE	evaluated 27 times by 1 test Evaluated by: Self test
FALSE	evaluated 14 times by 1 test Evaluated by: Self test

14-27

8157

{

-

8158

ret = sh_modcase (params->word->word, pat, modop);

-

8159

w = alloc_word_desc ();

-

8160

w->word = ret ? ret : savestring ("");

ret	Description
TRUE	evaluated 27 times by 1 test Evaluated by: Self test
FALSE	never evaluated

0-27

8161

dispose_word (params->word);

-

8162

params->word = w;

-

8163

}

executed 27 times by 1 test: end of block

Executed by:

Self test

27

8164

-

8165

pchar = (mflags & MATCH_STARSUB) == MATCH_STARSUB ? '*' : '@';

(mflags & 0x080) == 0x080	Description
TRUE	evaluated 4 times by 1 test Evaluated by: Self test
FALSE	evaluated 10 times by 1 test Evaluated by: Self test

4-10

8166

qflags = (mflags & MATCH_QUOTED) == MATCH_QUOTED ? Q_DOUBLE_QUOTES : 0;

(mflags & 0x020) == 0x020	Description
TRUE	evaluated 1 time by 1 test Evaluated by: Self test
FALSE	evaluated 13 times by 1 test Evaluated by: Self test

1-13

8167

-

8168

/* If we are expanding in a context where word splitting will not be

-

8169

performed, treat as quoted. This changes how $* will be expanded. */

-

8170

if (pchar == '*' && (mflags & MATCH_ASSIGNRHS) && ifs_is_null)

pchar == '*'	Description
TRUE	evaluated 4 times by 1 test Evaluated by: Self test
FALSE	evaluated 10 times by 1 test Evaluated by: Self test

(mflags & 0x040)	Description
TRUE	evaluated 1 time by 1 test Evaluated by: Self test
FALSE	evaluated 3 times by 1 test Evaluated by: Self test

ifs_is_null	Description
TRUE	evaluated 1 time by 1 test Evaluated by: Self test
FALSE	never evaluated

0-10

8171

qflags |= Q_DOUBLE_QUOTES; /* Posix interp 888 */

executed 1 time by 1 test: qflags |= 0x001;

Executed by:

Self test

1

8172

-

8173

ret = string_list_pos_params (pchar, save, qflags);

-

8174

dispose_words (save);

-

8175

-

8176

return (ret);

executed 14 times by 1 test: return (ret);

Executed by:

Self test

14

8177

}

-

8178

-

8179

/* Perform case modification on VALUE, which is the expansion of

-

8180

VARNAME. MODSPEC is an expression supplying the type of modification

-

8181

to perform. QUOTED is a flags word containing the type of quoting

-

8182

currently in effect. */

-

8183

static char *

-

8184

parameter_brace_casemod (varname, value, ind, modspec, patspec, quoted, pflags, flags)

-

8185

char *varname, *value;

-

8186

int ind, modspec;

-

8187

char *patspec;

-

8188

int quoted, pflags, flags;

-

8189

{

-

8190

int vtype, starsub, modop, mflags, x;

-

8191

char *val, *temp, *pat, *p, *lpat, *tt, *oname;

-

8192

SHELL_VAR *v;

-

8193

-

8194

if (value == 0)

value == 0	Description
TRUE	never evaluated
FALSE	evaluated 80 times by 1 test Evaluated by: Self test

0-80

8195

return ((char *)NULL);

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

0

8196

-

8197

oname = this_command_name;

-

8198

this_command_name = varname;

-

8199

-

8200

vtype = get_var_and_type (varname, value, ind, quoted, flags, &v, &val);

-

8201

if (vtype == -1)

vtype == -1	Description
TRUE	never evaluated
FALSE	evaluated 80 times by 1 test Evaluated by: Self test

0-80

8202

{

-

8203

this_command_name = oname;

-

8204

return ((char *)NULL);

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

0

8205

}

-

8206

-

8207

starsub = vtype & VT_STARSUB;

-

8208

vtype &= ~VT_STARSUB;

-

8209

-

8210

modop = 0;

-

8211

mflags = 0;

-

8212

if (quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES))

quoted & (0x002\|0x001)	Description
TRUE	evaluated 21 times by 1 test Evaluated by: Self test
FALSE	evaluated 59 times by 1 test Evaluated by: Self test

21-59

8213

mflags |= MATCH_QUOTED;

executed 21 times by 1 test: mflags |= 0x020;

Executed by:

Self test

21

8214

if (starsub)

starsub	Description
TRUE	evaluated 8 times by 1 test Evaluated by: Self test
FALSE	evaluated 72 times by 1 test Evaluated by: Self test

8-72

8215

mflags |= MATCH_STARSUB;

executed 8 times by 1 test: mflags |= 0x080;

Executed by:

Self test

8

8216

if (pflags & PF_ASSIGNRHS)

pflags & 0x08	Description
TRUE	evaluated 5 times by 1 test Evaluated by: Self test
FALSE	evaluated 75 times by 1 test Evaluated by: Self test

5-75

8217

mflags |= MATCH_ASSIGNRHS;

executed 5 times by 1 test: mflags |= 0x040;

Executed by:

Self test

5

8218

-

8219

p = patspec;

-

8220

if (modspec == '^')

modspec == '^'	Description
TRUE	evaluated 38 times by 1 test Evaluated by: Self test
FALSE	evaluated 42 times by 1 test Evaluated by: Self test

38-42

8221

{

-

8222

x = p && p[0] == modspec;

p	Description
TRUE	evaluated 38 times by 1 test Evaluated by: Self test
FALSE	never evaluated

p[0] == modspec	Description
TRUE	evaluated 21 times by 1 test Evaluated by: Self test
FALSE	evaluated 17 times by 1 test Evaluated by: Self test

0-38

8223

modop = x ? CASE_UPPER : CASE_UPFIRST;

x	Description
TRUE	evaluated 21 times by 1 test Evaluated by: Self test
FALSE	evaluated 17 times by 1 test Evaluated by: Self test

17-21

8224

p += x;

-

8225

}

executed 38 times by 1 test: end of block

Executed by:

Self test

38

8226

else if (modspec == ',')

modspec == ','	Description
TRUE	evaluated 40 times by 1 test Evaluated by: Self test
FALSE	evaluated 2 times by 1 test Evaluated by: Self test

2-40

8227

{

-

8228

x = p && p[0] == modspec;

p	Description
TRUE	evaluated 40 times by 1 test Evaluated by: Self test
FALSE	never evaluated

p[0] == modspec	Description
TRUE	evaluated 29 times by 1 test Evaluated by: Self test
FALSE	evaluated 11 times by 1 test Evaluated by: Self test

0-40

8229

modop = x ? CASE_LOWER : CASE_LOWFIRST;

x	Description
TRUE	evaluated 29 times by 1 test Evaluated by: Self test
FALSE	evaluated 11 times by 1 test Evaluated by: Self test

11-29

8230

p += x;

-

8231

}

executed 40 times by 1 test: end of block

Executed by:

Self test

40

8232

else if (modspec == '~')

modspec == '~'	Description
TRUE	evaluated 2 times by 1 test Evaluated by: Self test
FALSE	never evaluated

0-2

8233

{

-

8234

x = p && p[0] == modspec;

p	Description
TRUE	evaluated 2 times by 1 test Evaluated by: Self test
FALSE	never evaluated

p[0] == modspec	Description
TRUE	evaluated 1 time by 1 test Evaluated by: Self test
FALSE	evaluated 1 time by 1 test Evaluated by: Self test

0-2

8235

modop = x ? CASE_TOGGLEALL : CASE_TOGGLE;

x	Description
TRUE	evaluated 1 time by 1 test Evaluated by: Self test
FALSE	evaluated 1 time by 1 test Evaluated by: Self test

1

8236

p += x;

-

8237

}

executed 2 times by 1 test: end of block

Executed by:

Self test

2

8238

-

8239

lpat = p ? savestring (p) : 0;

p	Description
TRUE	evaluated 80 times by 1 test Evaluated by: Self test
FALSE	never evaluated

0-80

8240

/* Perform the same expansions on the pattern as performed by the

-

8241

pattern removal expansions. */

-

8242

pat = lpat ? getpattern (lpat, quoted, 1) : 0;

lpat	Description
TRUE	evaluated 80 times by 1 test Evaluated by: Self test
FALSE	never evaluated

0-80

8243

-

8244

/* OK, now we do the case modification. */

-

8245

switch (vtype)

-

8246

{

-

8247

case VT_VARIABLE:

executed 34 times by 1 test: case 0:

Executed by:

Self test

34

8248

case VT_ARRAYMEMBER:

executed 9 times by 1 test: case 3:

Executed by:

Self test

9

8249

temp = sh_modcase (val, pat, modop);

-

8250

if (vtype == VT_VARIABLE)

vtype == 0	Description
TRUE	evaluated 34 times by 1 test Evaluated by: Self test
FALSE	evaluated 9 times by 1 test Evaluated by: Self test

9-34

8251

FREE (val);

executed 34 times by 1 test: sh_xfree((val), "subst.c", 8251);

Executed by:

Self test

executed 34 times by 1 test: end of block

Executed by:

Self test

val	Description
TRUE	evaluated 34 times by 1 test Evaluated by: Self test
FALSE	never evaluated

0-34

8252

if (temp)

temp	Description
TRUE	evaluated 43 times by 1 test Evaluated by: Self test
FALSE	never evaluated

0-43

8253

{

-

8254

tt = (mflags & MATCH_QUOTED) ? quote_string (temp) : quote_escapes (temp);

(mflags & 0x020)	Description
TRUE	evaluated 11 times by 1 test Evaluated by: Self test
FALSE	evaluated 32 times by 1 test Evaluated by: Self test

11-32

8255

free (temp);

-

8256

temp = tt;

-

8257

}

executed 43 times by 1 test: end of block

Executed by:

Self test

43

8258

break;

executed 43 times by 1 test: break;

Executed by:

Self test

43

8259

-

8260

case VT_POSPARMS:

executed 14 times by 1 test: case 1:

Executed by:

Self test

14

8261

temp = pos_params_modcase (val, pat, modop, mflags);

-

8262

if (temp && quoted == 0 && ifs_is_null)

temp	Description
TRUE	evaluated 14 times by 1 test Evaluated by: Self test
FALSE	never evaluated

quoted == 0	Description
TRUE	evaluated 13 times by 1 test Evaluated by: Self test
FALSE	evaluated 1 time by 1 test Evaluated by: Self test

ifs_is_null	Description
TRUE	evaluated 5 times by 1 test Evaluated by: Self test
FALSE	evaluated 8 times by 1 test Evaluated by: Self test

0-14

8263

{

-

8264

/* Posix interp 888 */

-

8265

}

executed 5 times by 1 test: end of block

Executed by:

Self test

5

8266

else if (temp && (mflags & MATCH_QUOTED) == 0)

temp	Description
TRUE	evaluated 9 times by 1 test Evaluated by: Self test
FALSE	never evaluated

(mflags & 0x020) == 0	Description
TRUE	evaluated 8 times by 1 test Evaluated by: Self test
FALSE	evaluated 1 time by 1 test Evaluated by: Self test

0-9

8267

{

-

8268

tt = quote_escapes (temp);

-

8269

free (temp);

-

8270

temp = tt;

-

8271

}

executed 8 times by 1 test: end of block

Executed by:

Self test

8

8272

break;

executed 14 times by 1 test: break;

Executed by:

Self test

14

8273

-

8274

#if defined (ARRAY_VARS)

-

8275

case VT_ARRAYVAR:

executed 23 times by 1 test: case 2:

Executed by:

Self test

23

8276

/* If we are expanding in a context where word splitting will not be

-

8277

performed, treat as quoted. This changes how ${A[*]} will be

-

8278

expanded to make it identical to $*. */

-

8279

if ((mflags & MATCH_STARSUB) && (mflags & MATCH_ASSIGNRHS) && ifs_is_null)

(mflags & 0x080)	Description
TRUE	evaluated 4 times by 1 test Evaluated by: Self test
FALSE	evaluated 19 times by 1 test Evaluated by: Self test

(mflags & 0x040)	Description
TRUE	never evaluated
FALSE	evaluated 4 times by 1 test Evaluated by: Self test

ifs_is_null	Description
TRUE	never evaluated
FALSE	never evaluated

0-19

8280

mflags |= MATCH_QUOTED; /* Posix interp 888 */

never executed: mflags |= 0x020;

0

8281

-

8282

temp = assoc_p (v) ? assoc_modcase (assoc_cell (v), pat, modop, mflags)

((((v)->attrib... (0x0000040)))	Description
TRUE	evaluated 12 times by 1 test Evaluated by: Self test
FALSE	evaluated 11 times by 1 test Evaluated by: Self test

11-12

8283

: array_modcase (array_cell (v), pat, modop, mflags);

-

8284

/* Don't call quote_escapes; array_modcase calls array_quote_escapes

-

8285

as appropriate before adding the space separators; ditto for

-

8286

assoc_modcase. */

-

8287

break;

executed 23 times by 1 test: break;

Executed by:

Self test

23

8288

#endif

-

8289

}

-

8290

-

8291

FREE (pat);

executed 42 times by 1 test: sh_xfree((pat), "subst.c", 8291);

Executed by:

Self test

pat	Description
TRUE	evaluated 42 times by 1 test Evaluated by: Self test
FALSE	evaluated 38 times by 1 test Evaluated by: Self test

38-42

8292

free (lpat);

-

8293

-

8294

this_command_name = oname;

-

8295

-

8296

return temp;

executed 80 times by 1 test: return temp;

Executed by:

Self test

80

8297

}

-

8298

-

8299

/* Check for unbalanced parens in S, which is the contents of $(( ... )). If

-

8300

any occur, this must be a nested command substitution, so return 0.

-

8301

Otherwise, return 1. A valid arithmetic expression must always have a

-

8302

( before a matching ), so any cases where there are more right parens

-

8303

means that this must not be an arithmetic expression, though the parser

-

8304

will not accept it without a balanced total number of parens. */

-

8305

static int

-

8306

chk_arithsub (s, len)

-

8307

const char *s;

-

8308

int len;

-

8309

{

-

8310

int i, count;

-

8311

DECLARE_MBSTATE;

-

8312

-

8313

i = count = 0;

-

8314

while (i < len)

i < len	Description
TRUE	evaluated 36416 times by 1 test Evaluated by: Self test
FALSE	evaluated 6365 times by 1 test Evaluated by: Self test

6365-36416

8315

{

-

8316

if (s[i] == LPAREN)

s[i] == '('	Description
TRUE	evaluated 287 times by 1 test Evaluated by: Self test
FALSE	evaluated 36129 times by 1 test Evaluated by: Self test

287-36129

8317

count++;

executed 287 times by 1 test: count++;

Executed by:

Self test

287

8318

else if (s[i] == RPAREN)

s[i] == ')'	Description
TRUE	evaluated 334 times by 1 test Evaluated by: Self test
FALSE	evaluated 35795 times by 1 test Evaluated by: Self test

334-35795

8319

{

-

8320

count--;

-

8321

if (count < 0)

count < 0	Description
TRUE	evaluated 47 times by 1 test Evaluated by: Self test
FALSE	evaluated 287 times by 1 test Evaluated by: Self test

47-287

8322

return 0;

executed 47 times by 1 test: return 0;

Executed by:

Self test

47

8323

}

executed 287 times by 1 test: end of block

Executed by:

Self test

287

8324

-

8325

switch (s[i])

-

8326

{

-

8327

default:

executed 36340 times by 1 test: default:

Executed by:

Self test

36340

8328

ADVANCE_CHAR (s, len, i);

executed 35571 times by 1 test: mblength = 1;

Executed by:

Self test

executed 668 times by 1 test: mblength = 1;

Executed by:

Self test

never executed: end of block

never executed: (i)++;

executed 36239 times by 1 test: (i) += mblength;

Executed by:

Self test

executed 101 times by 1 test: (i)++;

Executed by:

Self test

locale_mb_cur_max > 1	Description
TRUE