powerpc-asm 0.4.1

PowerPC assembler
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93

use crate::Arguments;
use thiserror::Error;

#[derive(Error, Debug)]
pub enum ArgumentError {
    #[error(
        "argument index {index} is out of range: {value} (expected between {start} and {end})"
    )]
    ArgOutOfRangeUnsigned { index: usize, value: u32, start: u32, end: u32 },
    #[error(
        "argument index {index} is out of range: {value} (expected between {start} and {end})"
    )]
    ArgOutOfRangeSigned { index: usize, value: i32, start: i32, end: i32 },
    #[error("unexpected number of arguments: {value} (expected at most {expected})")]
    ArgCount { value: usize, expected: usize },
    #[error("unknown instruction mnemonic")]
    UnknownMnemonic,
}

#[derive(Debug, Default, Clone, Copy, Eq, PartialEq)]
pub enum Argument {
    #[default]
    None,
    Unsigned(u32),
    Signed(i32),
}

pub const fn parse_unsigned(
    args: &Arguments,
    index: usize,
    start: u32,
    end: u32,
) -> Result<u32, ArgumentError> {
    match args[index] {
        Argument::Unsigned(value) => {
            if value >= start && value <= end {
                Ok(value)
            } else {
                Err(ArgumentError::ArgOutOfRangeUnsigned { index, value, start, end })
            }
        }
        Argument::Signed(value) => {
            if value >= start as i32 && value <= end as i32 {
                Ok(value as u32)
            } else {
                Err(ArgumentError::ArgOutOfRangeUnsigned { index, value: value as u32, start, end })
            }
        }
        Argument::None => Err(ArgumentError::ArgCount { value: index, expected: index + 1 }),
    }
}

pub const fn parse_signed(
    args: &Arguments,
    index: usize,
    start: i32,
    end: i32,
) -> Result<i32, ArgumentError> {
    match args[index] {
        Argument::Unsigned(value) => {
            if (start < 0 || value >= start as u32) && value <= end as u32 {
                Ok(value as i32)
            } else {
                Err(ArgumentError::ArgOutOfRangeSigned { index, value: value as i32, start, end })
            }
        }
        Argument::Signed(value) => {
            if value >= start && value <= end {
                Ok(value)
            } else {
                Err(ArgumentError::ArgOutOfRangeSigned { index, value, start, end })
            }
        }
        Argument::None => Err(ArgumentError::ArgCount { value: index, expected: index + 1 }),
    }
}

pub const fn arg_count(args: &Arguments) -> usize {
    let mut i = 0;
    while i < args.len() && !matches!(args[i], Argument::None) {
        i += 1;
    }
    i
}

pub const fn check_arg_count(args: &Arguments, expected: usize) -> Result<(), ArgumentError> {
    let value = arg_count(args);
    if value == expected {
        Ok(())
    } else {
        Err(ArgumentError::ArgCount { value, expected })
    }
}