xidl_parser/hir/
types.rs

1use serde::{Deserialize, Serialize};
2
3use super::*;
4
5#[derive(Clone, Debug, Serialize, Deserialize)]
6#[allow(clippy::large_enum_variant)]
7pub enum TypeSpec {
8    IntegerType(IntegerType),
9    FloatingPtType,
10    CharType,
11    WideCharType,
12    Boolean,
13    AnyType,
14    ObjectType,
15    ValueBaseType,
16    ScopedName(ScopedName),
17    SequenceType(SequenceType),
18    StringType(StringType),
19    WideStringType(WideStringType),
20    FixedPtType(FixedPtType),
21    MapType(MapType),
22    TemplateType(TemplateType),
23}
24
25#[derive(Clone, Debug, Serialize, Deserialize)]
26pub struct SequenceType {
27    pub ty: Box<TypeSpec>,
28    pub len: Option<PositiveIntConst>,
29}
30
31#[derive(Clone, Debug, Serialize, Deserialize)]
32pub struct MapType {
33    pub key: Box<TypeSpec>,
34    pub value: Box<TypeSpec>,
35    pub len: Option<PositiveIntConst>,
36}
37
38#[derive(Clone, Debug, Serialize, Deserialize)]
39pub struct TemplateType {
40    pub ident: String,
41    pub args: Vec<TypeSpec>,
42}
43
44#[derive(Clone, Debug, Serialize, Deserialize)]
45pub struct StringType {
46    pub bound: Option<PositiveIntConst>,
47}
48
49#[derive(Clone, Debug, Serialize, Deserialize)]
50pub struct WideStringType {
51    pub bound: Option<PositiveIntConst>,
52}
53
54#[derive(Clone, Debug, Serialize, Deserialize)]
55pub struct FixedPtType {
56    pub integer: PositiveIntConst,
57    pub fraction: PositiveIntConst,
58}
59
60#[derive(Clone, Debug, Serialize, Deserialize)]
61pub enum IntegerType {
62    Char,
63    UChar,
64    U8,
65    U16,
66    U32,
67    U64,
68    I8,
69    I16,
70    I32,
71    I64,
72}
73
74impl From<crate::typed_ast::TypeSpec> for TypeSpec {
75    fn from(value: crate::typed_ast::TypeSpec) -> Self {
76        match value {
77            crate::typed_ast::TypeSpec::SimpleTypeSpec(simple_type_spec) => simple_type_spec.into(),
78            crate::typed_ast::TypeSpec::TemplateTypeSpec(template_type_spec) => {
79                template_type_spec.into()
80            }
81        }
82    }
83}
84
85impl From<crate::typed_ast::SimpleTypeSpec> for TypeSpec {
86    fn from(ty: crate::typed_ast::SimpleTypeSpec) -> Self {
87        match ty {
88            crate::typed_ast::SimpleTypeSpec::BaseTypeSpec(base_type_spec) => {
89                match base_type_spec {
90                    crate::typed_ast::BaseTypeSpec::IntegerType(integer_type) => {
91                        TypeSpec::IntegerType(integer_type.into())
92                    }
93                    crate::typed_ast::BaseTypeSpec::FloatingPtType(_) => TypeSpec::FloatingPtType,
94                    crate::typed_ast::BaseTypeSpec::CharType(_) => TypeSpec::CharType,
95                    crate::typed_ast::BaseTypeSpec::WideCharType(_) => TypeSpec::WideCharType,
96                    crate::typed_ast::BaseTypeSpec::BooleanType(_) => TypeSpec::Boolean,
97                    crate::typed_ast::BaseTypeSpec::OctetType(_) => {
98                        TypeSpec::IntegerType(IntegerType::U8)
99                    }
100                    crate::typed_ast::BaseTypeSpec::AnyType(_) => TypeSpec::AnyType,
101                    crate::typed_ast::BaseTypeSpec::ObjectType(_) => TypeSpec::ObjectType,
102                    crate::typed_ast::BaseTypeSpec::ValueBaseType(_) => TypeSpec::ValueBaseType,
103                }
104            }
105            crate::typed_ast::SimpleTypeSpec::ScopedName(scoped_name) => {
106                TypeSpec::ScopedName(scoped_name.into())
107            }
108        }
109    }
110}
111
112impl From<crate::typed_ast::IntegerType> for IntegerType {
113    fn from(value: crate::typed_ast::IntegerType) -> Self {
114        match value {
115            crate::typed_ast::IntegerType::SignedInt(signed_int) => match signed_int {
116                crate::typed_ast::SignedInt::SignedShortInt(_) => Self::I16,
117                crate::typed_ast::SignedInt::SignedLongInt(_) => Self::I32,
118                crate::typed_ast::SignedInt::SignedLongLongInt(_) => Self::I64,
119                crate::typed_ast::SignedInt::SignedTinyInt(_) => Self::I8,
120            },
121            crate::typed_ast::IntegerType::UnsignedInt(unsigned_int) => match unsigned_int {
122                crate::typed_ast::UnsignedInt::UnsignedShortInt(_) => Self::U16,
123                crate::typed_ast::UnsignedInt::UnsignedLongInt(_) => Self::U32,
124                crate::typed_ast::UnsignedInt::UnsignedLongLongInt(_) => Self::U64,
125                crate::typed_ast::UnsignedInt::UnsignedTinyInt(_) => Self::U8,
126            },
127        }
128    }
129}
130
131impl From<crate::typed_ast::TemplateTypeSpec> for TypeSpec {
132    fn from(value: crate::typed_ast::TemplateTypeSpec) -> Self {
133        match value {
134            crate::typed_ast::TemplateTypeSpec::SequenceType(sequence_type) => {
135                TypeSpec::SequenceType(sequence_type.into())
136            }
137            crate::typed_ast::TemplateTypeSpec::StringType(string_type) => {
138                TypeSpec::StringType(string_type.into())
139            }
140            crate::typed_ast::TemplateTypeSpec::WideStringType(wide_string_type) => {
141                TypeSpec::WideStringType(wide_string_type.into())
142            }
143            crate::typed_ast::TemplateTypeSpec::FixedPtType(fixed_pt_type) => {
144                TypeSpec::FixedPtType(fixed_pt_type.into())
145            }
146            crate::typed_ast::TemplateTypeSpec::MapType(map_type) => {
147                TypeSpec::MapType(map_type.into())
148            }
149            crate::typed_ast::TemplateTypeSpec::TemplateType(template_type) => {
150                TypeSpec::TemplateType(template_type.into())
151            }
152        }
153    }
154}
155
156impl From<crate::typed_ast::SequenceType> for SequenceType {
157    fn from(value: crate::typed_ast::SequenceType) -> Self {
158        Self {
159            ty: Box::new((*value.ty).into()),
160            len: value.len.map(Into::into),
161        }
162    }
163}
164
165impl From<crate::typed_ast::MapType> for MapType {
166    fn from(value: crate::typed_ast::MapType) -> Self {
167        Self {
168            key: Box::new((*value.key).into()),
169            value: Box::new((*value.value).into()),
170            len: value.len.map(Into::into),
171        }
172    }
173}
174
175impl From<crate::typed_ast::TemplateType> for TemplateType {
176    fn from(value: crate::typed_ast::TemplateType) -> Self {
177        Self {
178            ident: value.ident.0,
179            args: value.args.into_iter().map(Into::into).collect(),
180        }
181    }
182}
183
184impl From<crate::typed_ast::StringType> for StringType {
185    fn from(value: crate::typed_ast::StringType) -> Self {
186        Self {
187            bound: value.bound.map(Into::into),
188        }
189    }
190}
191
192impl From<crate::typed_ast::WideStringType> for WideStringType {
193    fn from(value: crate::typed_ast::WideStringType) -> Self {
194        Self {
195            bound: value.bound.map(Into::into),
196        }
197    }
198}
199
200impl From<crate::typed_ast::FixedPtType> for FixedPtType {
201    fn from(value: crate::typed_ast::FixedPtType) -> Self {
202        Self {
203            integer: value.integer.into(),
204            fraction: value.fraction.into(),
205        }
206    }
207}
xidl_parser/hir/types.rs

xidl_parser/hir/
types.rs
