Function get_method_param_info

src/native.rs:601–681

(method: jmethodID)

}

unsafe fn get_method_param_info(method: jmethodID) -> Result<MethodInfo, String> {
    let mut ret = MethodInfo {
        mods: get_method_modifiers(method)?,
        params: Vec::new(),
    };
    let is_static = ret.mods & 0x00000008 != 0;
    let mut sig: *mut c_char = 0 as *mut c_char;
    let name_res = (**JVMTI_ENV).GetMethodName.unwrap()(JVMTI_ENV, method, ptr::null_mut(), &mut sig, ptr::null_mut());
    util::unit_or_jvmti_err(name_res)?;
    // Parse the sig
    let sig_str = CStr::from_ptr(sig).to_str().map_err(|_| "Error parsing method sig")?;
    let mut sig_chars = sig_str.chars();
    if sig_chars.next() != Some('(') { return Result::Err(format!("Str {} missing opening param", sig_str)); }
    let mut working_str = "".to_string();
    let mut in_obj = false;
    let mut slot_counter = 0;
    if !is_static {
        ret.params.push(Param {
            name: "this".to_string(),
            typ: get_class_signature(get_method_declaring_class(method)?)?,
            slot: slot_counter,
            val: None,
        });
        slot_counter += 1;
    }
    let mut param_counter = 0;
    loop {
        match sig_chars.next() {
            None => {
                let _ = dealloc(sig as *mut c_char);
                return Result::Err("Unexpected end of desc".to_string());
            },
            Some(c) => match c {
                ')' => {
                    dealloc(sig)?;
                    return Result::Ok(ret);
                },
                ';' if in_obj => {
                    working_str.push(';');
                    ret.params.push(Param {
                        name: format!("arg{}", param_counter),
                        typ: working_str.clone(),
                        slot: slot_counter,
                        val: None,
                    });
                    param_counter += 1;
                    slot_counter += 1;
                    in_obj = false;
                    working_str.clear();
                },
                _ if in_obj => working_str.push(c),
                'L' => {
                    in_obj = true;
                    working_str.push('L');
                }
                '[' => working_str.push('['),
                'B' | 'C' | 'D' | 'F' | 'I' | 'J' | 'S' | 'Z' => {
                    working_str.push(c);