Method _create_unlimit_call_fuzzer_var

src/program/transform.rs:528–584

(
        &mut self,
        arg_ty: &str,
        arg: &Node,
        visitor: &Visitor,
    )

    }

    fn _create_unlimit_call_fuzzer_var(
        &mut self,
        arg_ty: &str,
        arg: &Node,
        visitor: &Visitor,
    ) -> Result<()> {
        let arg = arg.ignore_parenexpr();
        if is_fuzzable_array_ty(arg_ty) {
            if let Clang::StringLiteral(sl) = &arg.kind {
                let value = sl.get_eval_value();
                let ty = get_pointer_inner(arg_ty).expect("array ty should not faild");
                self.create_string_fuzzer_var(value, ty)?;
            } else if let Clang::InitListExpr(ile) = &arg.kind {
                if !ile.is_mutable_list(arg) {
                    return Ok(());
                }
                if is_sized_array_ty(arg_ty) {
                    self.create_list_fuzzer_var(ile, arg)?;
                } else {
                    self.create_unlimit_list_fuzzer_var(ile, arg)?;
                }
            }
        }

        if is_integer_ty(arg_ty) {
            if let Clang::IntegerLiteral(il) = &arg.kind {
                self.create_integer_fuzzer_var(il, arg_ty)?;
                return Ok(());
            } else if let Clang::EnumConstantDecl(ecd) = &arg.kind {
                if let Some(value) = ecd.get_const_value(arg) {
                    self.fuzzer_shim.append_integer_var(value);
                    return Ok(());
                }
            } else if let Clang::UnaryOperator(uo) = &arg.kind {
                // negative value
                if !uo.is_minus() || arg.inner.len() != 1 {
                    return Ok(());
                }
                if let Clang::IntegerLiteral(il) = &arg.inner[0].kind {
                    let mut il = il.clone();
                    if !is_unsigned_integer_ty(arg_ty) {
                        let mut value = il.value.to_string();
                        value.insert(0, '-');
                        il.value = value.into();
                    }
                    self.create_integer_fuzzer_var(&il, arg_ty)?;
                }
                return Ok(());
            }
        }
        if let Clang::DeclRefExpr(dre) = &arg.kind {
            if let Some(init) = dre.get_var_init(visitor) {
                self._create_unlimit_call_fuzzer_var(arg_ty, init, visitor)?;
            }
        }
        Ok(())
    }