ptx_parser/type/
variable.rs

1use crate::r#type::common::{AddressSpace, AttributeDirective, DataLinkage, DataType};
2use crate::parser::Span;
3
4/// Module-level declarations that reserve storage in a specific address space.
5#[derive(Debug, Clone, PartialEq, Eq)]
6pub enum ModuleVariableDirective {
7    Tex { directive: VariableDirective, span: Span },
8    Shared { directive: VariableDirective, span: Span },
9    Global { directive: VariableDirective, span: Span },
10    Const { directive: VariableDirective, span: Span },
11}
12
13impl ModuleVariableDirective {
14    pub fn span(&self) -> Span {
15        match self {
16            ModuleVariableDirective::Tex { span, .. } => span.clone(),
17            ModuleVariableDirective::Shared { span, .. } => span.clone(),
18            ModuleVariableDirective::Global { span, .. } => span.clone(),
19            ModuleVariableDirective::Const { span, .. } => span.clone(),
20        }
21    }
22}
23
24/// Module-scoped variable declaration shared by `.tex`, `.shared`, `.global`, and `.const`.
25#[derive(Debug, Clone, PartialEq, Eq)]
26pub struct VariableDirective {
27    pub address_space: Option<AddressSpace>,
28    pub attributes: Vec<AttributeDirective>,
29    pub ty: Option<DataType>,
30    pub modifiers: Vec<VariableModifier>,
31    pub name: String,
32    pub array: Vec<Option<u64>>,
33    pub initializer: Option<GlobalInitializer>,
34    pub span: Span,
35}
36
37impl VariableDirective {
38    pub fn with_span(mut self, span: Span) -> Self {
39        self.span = span;
40        self
41    }
42}
43
44/// Qualifiers left on module variable declarations (e.g. `.v4`).
45#[derive(Debug, Clone, PartialEq, Eq)]
46pub enum VariableModifier {
47    Vector { value: u32, span: Span },
48    Alignment { value: u32, span: Span },
49    Linkage { linkage: DataLinkage, span: Span },
50    Ptr { span: Span },
51}
52
53impl VariableModifier {
54    pub fn span(&self) -> Span {
55        match self {
56            VariableModifier::Vector { span, .. } => span.clone(),
57            VariableModifier::Alignment { span, .. } => span.clone(),
58            VariableModifier::Linkage { span, .. } => span.clone(),
59            VariableModifier::Ptr { span } => span.clone(),
60        }
61    }
62}
63
64//// Numeric literal kinds allowed inside initialisers.
65#[derive(Debug, Clone, PartialEq, Eq)]
66pub enum NumericLiteral {
67    Signed { value: i64, span: Span },
68    Unsigned { value: u64, span: Span },
69    Float64 { value: u64, span: Span },
70    Float32 { value: u32, span: Span },
71}
72
73impl NumericLiteral {
74    pub fn span(&self) -> Span {
75        match self {
76            NumericLiteral::Signed { span, .. } => span.clone(),
77            NumericLiteral::Unsigned { span, .. } => span.clone(),
78            NumericLiteral::Float64 { span, .. } => span.clone(),
79            NumericLiteral::Float32 { span, .. } => span.clone(),
80        }
81    }
82}
83
84// Values that can appear in global initialiser lists.
85#[derive(Debug, Clone, PartialEq, Eq)]
86pub enum InitializerValue {
87    Numeric { value: NumericLiteral, span: Span },
88    Symbol { name: String, span: Span },
89    StringLiteral { value: String, span: Span },
90}
91
92impl InitializerValue {
93    pub fn span(&self) -> Span {
94        match self {
95            InitializerValue::Numeric { span, .. } => span.clone(),
96            InitializerValue::Symbol { span, .. } => span.clone(),
97            InitializerValue::StringLiteral { span, .. } => span.clone(),
98        }
99    }
100}
101
102/// Structured representation of a global variable initialiser.
103#[derive(Debug, Clone, PartialEq, Eq)]
104pub enum GlobalInitializer {
105    Scalar { value: InitializerValue, span: Span },
106    Aggregate { values: Vec<GlobalInitializer>, span: Span },
107}
108
109impl GlobalInitializer {
110    pub fn span(&self) -> Span {
111        match self {
112            GlobalInitializer::Scalar { span, .. } => span.clone(),
113            GlobalInitializer::Aggregate { span, .. } => span.clone(),
114        }
115    }
116}