Function bodies 22 total

panic function · rust · L17-L19 (3 LOC)

test_wasm/src/lib.rs

fn panic(_info: &PanicInfo) -> ! {
    loop {}
}

add function · rust · L27-L29 (3 LOC)

test_wasm/src/lib.rs

pub extern "C" fn add(a: i32, b: i32) -> i32 {
    a.wrapping_add(b)
}

multiply function · rust · L33-L35 (3 LOC)

test_wasm/src/lib.rs

pub extern "C" fn multiply(a: i32, b: i32) -> i32 {
    a.wrapping_mul(b)
}

factorial function · rust · L39-L45 (7 LOC)

test_wasm/src/lib.rs

pub extern "C" fn factorial(n: i32) -> i64 {
    if n <= 1 {
        1
    } else {
        (n as i64).wrapping_mul(factorial(n - 1))
    }
}

spin function · rust · L53-L59 (7 LOC)

test_wasm/src/lib.rs

pub extern "C" fn spin(iterations: i32) -> i32 {
    let mut acc: i32 = 0;
    for i in 0..iterations {
        acc = acc.wrapping_add(i);
    }
    acc
}

infinite_loop function · rust · L63-L68 (6 LOC)

test_wasm/src/lib.rs

pub extern "C" fn infinite_loop() -> i32 {
    let mut x: i32 = 0;
    loop {
        x = x.wrapping_add(1);
    }
}

nested_loops function · rust · L72-L80 (9 LOC)

test_wasm/src/lib.rs

pub extern "C" fn nested_loops(n: i32) -> i32 {
    let mut acc: i32 = 0;
    for i in 0..n {
        for j in 0..n {
            acc = acc.wrapping_add(i.wrapping_mul(j));
        }
    }
    acc
}

About: code-quality intelligence by Repobility · https://repobility.com

write_pattern function · rust · L91-L99 (9 LOC)

test_wasm/src/lib.rs

pub extern "C" fn write_pattern(pattern: u8, length: i32) -> i32 {
    let len = length.min(1024) as usize;
    unsafe {
        for i in 0..len {
            BUFFER[i] = pattern;
        }
    }
    len as i32
}

read_buffer function · rust · L103-L109 (7 LOC)

test_wasm/src/lib.rs

pub extern "C" fn read_buffer(index: i32) -> i32 {
    if index >= 0 && index < 1024 {
        unsafe { BUFFER[index as usize] as i32 }
    } else {
        -1
    }
}

scan_for_pattern function · rust · L113-L122 (10 LOC)

test_wasm/src/lib.rs

pub extern "C" fn scan_for_pattern(pattern: u8) -> i32 {
    unsafe {
        for i in 0..1024 {
            if BUFFER[i] == pattern {
                return i as i32;
            }
        }
    }
    -1
}

fill_incrementing function · rust · L126-L133 (8 LOC)

test_wasm/src/lib.rs

pub extern "C" fn fill_incrementing() -> i32 {
    unsafe {
        for i in 0..1024 {
            BUFFER[i] = (i % 256) as u8;
        }
    }
    1024
}

trap_out_of_bounds function · rust · L141-L146 (6 LOC)

test_wasm/src/lib.rs

pub extern "C" fn trap_out_of_bounds() -> i32 {
    unsafe {
        let ptr = 0xFFFF_FFFF as *const i32;
        *ptr
    }
}

trap_unreachable function · rust · L150-L152 (3 LOC)

test_wasm/src/lib.rs

pub extern "C" fn trap_unreachable() -> i32 {
    core::arch::wasm32::unreachable()
}

trap_div_zero function · rust · L156-L158 (3 LOC)

test_wasm/src/lib.rs

pub extern "C" fn trap_div_zero(a: i32) -> i32 {
    a / 0
}

stateful_increment function · rust · L175-L184 (10 LOC)

test_wasm/src/lib.rs

pub extern "C" fn stateful_increment() -> i32 {
    unsafe {
        STATE = STATE.wrapping_add(1);
        if HISTORY_INDEX < 100 {
            HISTORY[HISTORY_INDEX] = STATE;
            HISTORY_INDEX += 1;
        }
        STATE
    }
}

Repobility — same analyzer, your code, free for public repos · /scan/

get_state function · rust · L188-L190 (3 LOC)

test_wasm/src/lib.rs

pub extern "C" fn get_state() -> i32 {
    unsafe { STATE }
}

reset_state function · rust · L194-L203 (10 LOC)

test_wasm/src/lib.rs

pub extern "C" fn reset_state() -> i32 {
    unsafe {
        STATE = 0;
        HISTORY_INDEX = 0;
        for i in 0..100 {
            HISTORY[i] = 0;
        }
    }
    0
}

crash_after_n function · rust · L210-L222 (13 LOC)

test_wasm/src/lib.rs

pub extern "C" fn crash_after_n(n: i32) -> i32 {
    unsafe {
        for _ in 0..n {
            STATE = STATE.wrapping_add(1);
            if HISTORY_INDEX < 100 {
                HISTORY[HISTORY_INDEX] = STATE;
                HISTORY_INDEX += 1;
            }
        }
        // Now crash - forensics should show STATE = n
        core::arch::wasm32::unreachable()
    }
}

increment_until_exhausted function · rust · L228-L238 (11 LOC)

test_wasm/src/lib.rs

pub extern "C" fn increment_until_exhausted() -> i32 {
    unsafe {
        loop {
            STATE = STATE.wrapping_add(1);
            if HISTORY_INDEX < 100 {
                HISTORY[HISTORY_INDEX] = STATE;
                HISTORY_INDEX += 1;
            }
        }
    }
}

fib function · rust · L246-L252 (7 LOC)

test_wasm/src/lib.rs

pub extern "C" fn fib(n: i32) -> i64 {
    if n <= 1 {
        n as i64
    } else {
        fib(n - 1).wrapping_add(fib(n - 2))
    }
}

is_prime function · rust · L256-L274 (19 LOC)

test_wasm/src/lib.rs

pub extern "C" fn is_prime(n: i32) -> i32 {
    if n <= 1 {
        return 0;
    }
    if n <= 3 {
        return 1;
    }
    if n % 2 == 0 || n % 3 == 0 {
        return 0;
    }
    let mut i = 5;
    while i * i <= n {
        if n % i == 0 || n % (i + 2) == 0 {
            return 0;
        }
        i += 6;
    }
    1
}

count_primes function · rust · L278-L286 (9 LOC)

test_wasm/src/lib.rs

pub extern "C" fn count_primes(n: i32) -> i32 {
    let mut count = 0;
    for i in 2..=n {
        if is_prime(i) == 1 {
            count += 1;
        }
    }
    count
}