Method parse_internal

crates/kernel_cmdline/src/bytes.rs:486–520

Parse a parameter from a byte slice that contains exactly one parameter. This is an internal method that assumes the input has already been split into a single parameter (e.g., by CmdlineIterBytes).

(input: &'a [u8])

    /// This is an internal method that assumes the input has already been
    /// split into a single parameter (e.g., by CmdlineIterBytes).
    fn parse_internal(input: &'a [u8]) -> Option<Self> {
        // *Only* the first and last double quotes are stripped
        let dequoted_input = input.strip_prefix(b"\"").unwrap_or(input);
        let dequoted_input = dequoted_input.strip_suffix(b"\"").unwrap_or(dequoted_input);

        let equals = dequoted_input.iter().position(|b| *b == b'=');

        match equals {
            None => Some(Self {
                parameter: input,
                key: ParameterKey(dequoted_input),
                value: None,
            }),
            Some(i) => {
                let (key, mut value) = dequoted_input.split_at(i);
                let key = ParameterKey(key);

                // skip `=`, we know it's the first byte because we
                // found it above
                value = &value[1..];

                // If there is a quote after the equals, skip it.  If
                // there was a closing quote at the end of the value,
                // we would have already removed it in
                // `dequoted_input` above
                value = value.strip_prefix(b"\"").unwrap_or(value);

                Some(Self {
                    parameter: input,
                    key,
                    value: Some(value),
                })
            }
        }
    }

    /// Returns the key part of the parameter
    pub fn key(&self) -> ParameterKey<'a> {