wild 0.1.0

Glob (wildcard) expanded command-line arguments on Windows
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107


#[derive(Debug)]
enum State {
    BetweenArgs,
    InArg(bool),
    OnQuote,
    Backslashes(usize, bool),
}

/// Given UCS2/potentially-broken-UTF-16 string parses one argument, following
/// the absolutely bizarre quoting rules of `CommandLineToArgvW`, and returns
/// parsed argument as well as a slice of the remaining arguments.
///
/// Calling this repeatedly until rest is empty will parse all arguments.
///
/// `arg` is an empty pre-allocated argument to be returned, and the callback adds a new code unit to it.
/// The last callback argument is whether the unit was quoted or not.
///
/// This parses u16 code units, rather than code points.
/// This allows supporting unpaired surrogates and ensures they won't "eat" any control characters.
pub fn next_arg<AddC, ArgVec>(line: &[u16], mut arg: ArgVec, push: AddC) -> (Option<ArgVec>, &[u16])
where
    AddC: Fn(&mut ArgVec, u16, bool),
{
    use self::State::*;
    let mut state = BetweenArgs;
    for (i, &cu) in line.iter().enumerate() {
        state = match state {
            BetweenArgs => match cu {
                c if c == u16::from(b' ') => BetweenArgs,
                c if c == u16::from(b'"') => InArg(true),
                c if c == u16::from(b'\\') => Backslashes(1, false),
                c => {
                    push(&mut arg, c, false);
                    InArg(false)
                },
            },
            InArg(quoted) => match cu {
                c if c == u16::from(b'\\') => Backslashes(1, quoted),
                c if quoted && c == u16::from(b'"') => OnQuote,
                c if !quoted && c == u16::from(b'"') => InArg(true),
                c if !quoted && c == u16::from(b' ') => {
                    return (Some(arg), &line[i+1..]);
                },
                c => {
                    push(&mut arg, c, quoted);
                    InArg(quoted)
                },
            },
            OnQuote => match cu {
                c if c == u16::from(b'"') => {
                    // In quoted arg "" means literal quote and the end of the quoted string (but not arg)
                    push(&mut arg, u16::from(b'"'), true);
                    InArg(false)
                },
                c if c == u16::from(b' ') => {
                    return (Some(arg), &line[i+1..]);
                },
                c => {
                    push(&mut arg, c, false);
                    InArg(false)
                },
            },
            Backslashes(count, quoted) => match cu {
                c if c == u16::from(b'\\') => Backslashes(count + 1, quoted),
                c if c == u16::from(b'"') => {
                    // backslashes followed by a quotation mark are treated as pairs of protected backslashes
                    for _ in 0..count/2 {
                        push(&mut arg, u16::from(b'\\'), quoted);
                    }

                    if count & 1 != 0 {
                        // An odd number of backslashes is treated as followed by a protected quotation mark.
                        push(&mut arg, u16::from(b'"'), quoted);
                        InArg(quoted)
                    } else if quoted {
                        // An even number of backslashes is treated as followed by a word terminator.
                        return (Some(arg), &line[i+1..]);
                    } else {
                        InArg(quoted)
                    }
                },
                c => {
                    // A string of backslashes not followed by a quotation mark has no special meaning.
                    for _ in 0..count {
                        push(&mut arg, u16::from(b'\\'), quoted);
                    }
                    push(&mut arg, c, quoted);
                    InArg(quoted)
                },
            },
        }
    }
    let arg = match state {
        BetweenArgs => None,
        OnQuote | InArg(..) => Some(arg),
        Backslashes(count, quoted) => {
            // A string of backslashes not followed by a quotation mark has no special meaning.
            for _ in 0..count {
                push(&mut arg, u16::from(b'\\'), quoted);
            }

            Some(arg)
        },
    };
    (arg, &line[..0])
}