Method match_function

plugins/warp/src/matcher.rs:197–239

(&self, function: &BNFunction)

    }

    pub fn match_function(&self, function: &BNFunction) {
        // Call this the first time you matched on the function.
        let resolve_new_types = |matched: &Function| {
            // We also want to resolve the types here.
            if let TypeClass::Function(c) = matched.ty.class.as_ref() {
                // Recursively go through the function type and resolve referrers
                let view = function.view();
                let arch = function.arch();
                for out_member in &c.out_members {
                    self.add_type_to_view(&view, &arch, &out_member.ty);
                }
                for in_member in &c.in_members {
                    self.add_type_to_view(&view, &arch, &in_member.ty);
                }
            }
        };

        if let Some(matched_function) = cached_function_match(function, || {
            // We have yet to match on this function.
            let function_len = function.highest_address() - function.lowest_address();
            let is_function_trivial = { function_len < self.settings.trivial_function_len };
            let is_function_allowed = {
                function_len > self.settings.minimum_function_len
                    && function_len < self.settings.maximum_function_len.unwrap_or(u64::MAX)
            };
            let warp_func_guid = try_cached_function_guid(function)?;
            match self.functions.get(&warp_func_guid) {
                _ if !is_function_allowed => None,
                Some(matched) if matched.len() == 1 && !is_function_trivial => {
                    resolve_new_types(&matched[0]);
                    Some(matched[0].to_owned())
                }
                Some(matched) => {
                    let matched_on = self.match_function_from_constraints(function, &matched)?;
                    resolve_new_types(matched_on);
                    Some(matched_on.to_owned())
                }
                None => None,
            }
        }) {
            on_matched_function(function, &matched_function);
        }
    }

    pub fn match_function_from_constraints<'a>(
        &self,