nox-spirv 0.1.0

Compact SPIR-V reflection library written in pure-Rust
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
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124

//! SPIR-V streams.

use crate::{
    core::*,
    ParseResult, ParseError,
    op,
};

/// An iterator over [`instructions`][1] in SPIR-V code.
///
/// [1]: InstructionStream
#[derive(Clone, Copy)]
pub struct Stream<'a> {
    spirv: &'a [u32],
    pos: usize,
}

impl<'a> Stream<'a> {

    #[inline(always)]
    pub fn new(spirv: &'a [u32]) -> Self {
        Self {
            spirv: &spirv[5..],
            pos: 0,
        }
    }

    #[inline(always)]
    pub fn reset(&mut self) {
        self.pos = 0;
    }
}

/// Represents a single SPIR-V instruction.
#[derive(Clone, Copy)]
pub struct InstructionStream<'a> {
    op: op::Code,
    words: &'a [u32],
    pos: usize,
}

impl<'a> InstructionStream<'a> {

    #[inline]
    pub fn code(&self) -> op::Code {
        self.op
    }

    #[inline]
    pub fn is_eos(&self) -> bool {
        self.pos == self.words.len()
    }

    #[inline]
    pub fn reset(&mut self) {
        self.pos = 1;
    }

    #[inline]
    pub fn read(&mut self) -> ParseResult<u32> {
        let len = self.words.len();
        let pos = self.pos;
        if pos == len { Err(ParseError::EndOfStream) }
        else {
            self.pos += 1;
            Ok(self.words[pos])
        }
    }

    #[inline]
    pub fn read_words(&mut self, count: Option<u32>) -> ParseResult<&'a [u32]> {
        let len = self.words.len();
        let pos = self.pos;
        if pos == len { Ok(Default::default()) }
        else {
            let end = count
                .map(|count| pos + count as usize)
                .unwrap_or(len);
            if end > len { Err(ParseError::EndOfStream) }
            else {
                self.pos = end;
                Ok(&self.words[pos..end])
            }
        }
    }

    #[inline]
    pub fn read_string(&mut self) -> ParseResult<CompilerStr<'a>> {
        let pos = self.pos;
        if pos == self.words.len() { Err(ParseError::EndOfStream) }
        else {
            let str = CompilerStr::new(&self.words[pos..]);
            self.pos = pos + str.len().div_ceil(8);
            Ok(str)
        }
    }
}

impl<'a> Iterator for Stream<'a> {

    type Item = InstructionStream<'a>;

    #[inline]
    fn next(&mut self) -> Option<Self::Item> {
        let len = self.spirv.len();
        let pos = self.pos;
        if pos == len { None }
        else {
            let word = self.spirv[pos];
            let (count, op_code) = (word >> 16, word & 0xFFFF);
            let end = pos + count as usize;
            if end > len { None }
            else {
                let instruction = InstructionStream {
                    op: op::Code(op_code as u16),
                    words: &self.spirv[pos..end],
                    pos: 1,
                };
                self.pos = end;
                Some(instruction)
            }
        }
    }
}