mcxa_pac/mau0/
res_status.rs

1#[doc = "Register `RES_STATUS` reader"]
2pub type R = crate::R<ResStatusSpec>;
3#[doc = "Register `RES_STATUS` writer"]
4pub type W = crate::W<ResStatusSpec>;
5#[doc = "RES0 IEEE Inexact Flag\n\nValue on reset: 0"]
6#[cfg_attr(feature = "defmt", derive(defmt::Format))]
7#[derive(Clone, Copy, Debug, PartialEq, Eq)]
8pub enum Res0Nx {
9    #[doc = "0: The result is not rounded."]
10    Res0NxNo = 0,
11    #[doc = "1: The result is rounded, and as a result some digits lost."]
12    Res0NxYes = 1,
13}
14impl From<Res0Nx> for bool {
15    #[inline(always)]
16    fn from(variant: Res0Nx) -> Self {
17        variant as u8 != 0
18    }
19}
20#[doc = "Field `RES0_NX` reader - RES0 IEEE Inexact Flag"]
21pub type Res0NxR = crate::BitReader<Res0Nx>;
22impl Res0NxR {
23    #[doc = "Get enumerated values variant"]
24    #[inline(always)]
25    pub const fn variant(&self) -> Res0Nx {
26        match self.bits {
27            false => Res0Nx::Res0NxNo,
28            true => Res0Nx::Res0NxYes,
29        }
30    }
31    #[doc = "The result is not rounded."]
32    #[inline(always)]
33    pub fn is_res0_nx_no(&self) -> bool {
34        *self == Res0Nx::Res0NxNo
35    }
36    #[doc = "The result is rounded, and as a result some digits lost."]
37    #[inline(always)]
38    pub fn is_res0_nx_yes(&self) -> bool {
39        *self == Res0Nx::Res0NxYes
40    }
41}
42#[doc = "Field `RES0_NX` writer - RES0 IEEE Inexact Flag"]
43pub type Res0NxW<'a, REG> = crate::BitWriter<'a, REG, Res0Nx>;
44impl<'a, REG> Res0NxW<'a, REG>
45where
46    REG: crate::Writable + crate::RegisterSpec,
47{
48    #[doc = "The result is not rounded."]
49    #[inline(always)]
50    pub fn res0_nx_no(self) -> &'a mut crate::W<REG> {
51        self.variant(Res0Nx::Res0NxNo)
52    }
53    #[doc = "The result is rounded, and as a result some digits lost."]
54    #[inline(always)]
55    pub fn res0_nx_yes(self) -> &'a mut crate::W<REG> {
56        self.variant(Res0Nx::Res0NxYes)
57    }
58}
59#[doc = "RES0 IEEE Underflow Flag\n\nValue on reset: 0"]
60#[cfg_attr(feature = "defmt", derive(defmt::Format))]
61#[derive(Clone, Copy, Debug, PartialEq, Eq)]
62pub enum Res0Uf {
63    #[doc = "0: No tiny non-zero result is detected."]
64    Res0UfNo = 0,
65    #[doc = "1: A tiny non-zero result is detected."]
66    Res0UfYes = 1,
67}
68impl From<Res0Uf> for bool {
69    #[inline(always)]
70    fn from(variant: Res0Uf) -> Self {
71        variant as u8 != 0
72    }
73}
74#[doc = "Field `RES0_UF` reader - RES0 IEEE Underflow Flag"]
75pub type Res0UfR = crate::BitReader<Res0Uf>;
76impl Res0UfR {
77    #[doc = "Get enumerated values variant"]
78    #[inline(always)]
79    pub const fn variant(&self) -> Res0Uf {
80        match self.bits {
81            false => Res0Uf::Res0UfNo,
82            true => Res0Uf::Res0UfYes,
83        }
84    }
85    #[doc = "No tiny non-zero result is detected."]
86    #[inline(always)]
87    pub fn is_res0_uf_no(&self) -> bool {
88        *self == Res0Uf::Res0UfNo
89    }
90    #[doc = "A tiny non-zero result is detected."]
91    #[inline(always)]
92    pub fn is_res0_uf_yes(&self) -> bool {
93        *self == Res0Uf::Res0UfYes
94    }
95}
96#[doc = "Field `RES0_UF` writer - RES0 IEEE Underflow Flag"]
97pub type Res0UfW<'a, REG> = crate::BitWriter<'a, REG, Res0Uf>;
98impl<'a, REG> Res0UfW<'a, REG>
99where
100    REG: crate::Writable + crate::RegisterSpec,
101{
102    #[doc = "No tiny non-zero result is detected."]
103    #[inline(always)]
104    pub fn res0_uf_no(self) -> &'a mut crate::W<REG> {
105        self.variant(Res0Uf::Res0UfNo)
106    }
107    #[doc = "A tiny non-zero result is detected."]
108    #[inline(always)]
109    pub fn res0_uf_yes(self) -> &'a mut crate::W<REG> {
110        self.variant(Res0Uf::Res0UfYes)
111    }
112}
113#[doc = "RES0 IEEE Overflow Flag\n\nValue on reset: 0"]
114#[cfg_attr(feature = "defmt", derive(defmt::Format))]
115#[derive(Clone, Copy, Debug, PartialEq, Eq)]
116pub enum Res0Of {
117    #[doc = "0: The result format's largest finite number is not exceeded."]
118    Res0OfNo = 0,
119    #[doc = "1: The result format's largest finite number is exceeded."]
120    Res0OfYes = 1,
121}
122impl From<Res0Of> for bool {
123    #[inline(always)]
124    fn from(variant: Res0Of) -> Self {
125        variant as u8 != 0
126    }
127}
128#[doc = "Field `RES0_OF` reader - RES0 IEEE Overflow Flag"]
129pub type Res0OfR = crate::BitReader<Res0Of>;
130impl Res0OfR {
131    #[doc = "Get enumerated values variant"]
132    #[inline(always)]
133    pub const fn variant(&self) -> Res0Of {
134        match self.bits {
135            false => Res0Of::Res0OfNo,
136            true => Res0Of::Res0OfYes,
137        }
138    }
139    #[doc = "The result format's largest finite number is not exceeded."]
140    #[inline(always)]
141    pub fn is_res0_of_no(&self) -> bool {
142        *self == Res0Of::Res0OfNo
143    }
144    #[doc = "The result format's largest finite number is exceeded."]
145    #[inline(always)]
146    pub fn is_res0_of_yes(&self) -> bool {
147        *self == Res0Of::Res0OfYes
148    }
149}
150#[doc = "Field `RES0_OF` writer - RES0 IEEE Overflow Flag"]
151pub type Res0OfW<'a, REG> = crate::BitWriter<'a, REG, Res0Of>;
152impl<'a, REG> Res0OfW<'a, REG>
153where
154    REG: crate::Writable + crate::RegisterSpec,
155{
156    #[doc = "The result format's largest finite number is not exceeded."]
157    #[inline(always)]
158    pub fn res0_of_no(self) -> &'a mut crate::W<REG> {
159        self.variant(Res0Of::Res0OfNo)
160    }
161    #[doc = "The result format's largest finite number is exceeded."]
162    #[inline(always)]
163    pub fn res0_of_yes(self) -> &'a mut crate::W<REG> {
164        self.variant(Res0Of::Res0OfYes)
165    }
166}
167#[doc = "RES0 IEEE Divide by Zero Flag\n\nValue on reset: 0"]
168#[cfg_attr(feature = "defmt", derive(defmt::Format))]
169#[derive(Clone, Copy, Debug, PartialEq, Eq)]
170pub enum Res0Dz {
171    #[doc = "0: No exact infinite result is defined for an operation on finite operands."]
172    Res0DzNo = 0,
173    #[doc = "1: An exact infinite result is defined for an operation on finite operands."]
174    Res0DzYes = 1,
175}
176impl From<Res0Dz> for bool {
177    #[inline(always)]
178    fn from(variant: Res0Dz) -> Self {
179        variant as u8 != 0
180    }
181}
182#[doc = "Field `RES0_DZ` reader - RES0 IEEE Divide by Zero Flag"]
183pub type Res0DzR = crate::BitReader<Res0Dz>;
184impl Res0DzR {
185    #[doc = "Get enumerated values variant"]
186    #[inline(always)]
187    pub const fn variant(&self) -> Res0Dz {
188        match self.bits {
189            false => Res0Dz::Res0DzNo,
190            true => Res0Dz::Res0DzYes,
191        }
192    }
193    #[doc = "No exact infinite result is defined for an operation on finite operands."]
194    #[inline(always)]
195    pub fn is_res0_dz_no(&self) -> bool {
196        *self == Res0Dz::Res0DzNo
197    }
198    #[doc = "An exact infinite result is defined for an operation on finite operands."]
199    #[inline(always)]
200    pub fn is_res0_dz_yes(&self) -> bool {
201        *self == Res0Dz::Res0DzYes
202    }
203}
204#[doc = "Field `RES0_DZ` writer - RES0 IEEE Divide by Zero Flag"]
205pub type Res0DzW<'a, REG> = crate::BitWriter<'a, REG, Res0Dz>;
206impl<'a, REG> Res0DzW<'a, REG>
207where
208    REG: crate::Writable + crate::RegisterSpec,
209{
210    #[doc = "No exact infinite result is defined for an operation on finite operands."]
211    #[inline(always)]
212    pub fn res0_dz_no(self) -> &'a mut crate::W<REG> {
213        self.variant(Res0Dz::Res0DzNo)
214    }
215    #[doc = "An exact infinite result is defined for an operation on finite operands."]
216    #[inline(always)]
217    pub fn res0_dz_yes(self) -> &'a mut crate::W<REG> {
218        self.variant(Res0Dz::Res0DzYes)
219    }
220}
221#[doc = "RES0 IEEE Invalid Flag\n\nValue on reset: 0"]
222#[cfg_attr(feature = "defmt", derive(defmt::Format))]
223#[derive(Clone, Copy, Debug, PartialEq, Eq)]
224pub enum Res0Nv {
225    #[doc = "0: There is usefully definable result."]
226    Res0NvNo = 0,
227    #[doc = "1: There is no usefully definable result."]
228    Res0NvYes = 1,
229}
230impl From<Res0Nv> for bool {
231    #[inline(always)]
232    fn from(variant: Res0Nv) -> Self {
233        variant as u8 != 0
234    }
235}
236#[doc = "Field `RES0_NV` reader - RES0 IEEE Invalid Flag"]
237pub type Res0NvR = crate::BitReader<Res0Nv>;
238impl Res0NvR {
239    #[doc = "Get enumerated values variant"]
240    #[inline(always)]
241    pub const fn variant(&self) -> Res0Nv {
242        match self.bits {
243            false => Res0Nv::Res0NvNo,
244            true => Res0Nv::Res0NvYes,
245        }
246    }
247    #[doc = "There is usefully definable result."]
248    #[inline(always)]
249    pub fn is_res0_nv_no(&self) -> bool {
250        *self == Res0Nv::Res0NvNo
251    }
252    #[doc = "There is no usefully definable result."]
253    #[inline(always)]
254    pub fn is_res0_nv_yes(&self) -> bool {
255        *self == Res0Nv::Res0NvYes
256    }
257}
258#[doc = "Field `RES0_NV` writer - RES0 IEEE Invalid Flag"]
259pub type Res0NvW<'a, REG> = crate::BitWriter<'a, REG, Res0Nv>;
260impl<'a, REG> Res0NvW<'a, REG>
261where
262    REG: crate::Writable + crate::RegisterSpec,
263{
264    #[doc = "There is usefully definable result."]
265    #[inline(always)]
266    pub fn res0_nv_no(self) -> &'a mut crate::W<REG> {
267        self.variant(Res0Nv::Res0NvNo)
268    }
269    #[doc = "There is no usefully definable result."]
270    #[inline(always)]
271    pub fn res0_nv_yes(self) -> &'a mut crate::W<REG> {
272        self.variant(Res0Nv::Res0NvYes)
273    }
274}
275#[doc = "RES0 Indirect Operation Error Flag\n\nValue on reset: 0"]
276#[cfg_attr(feature = "defmt", derive(defmt::Format))]
277#[derive(Clone, Copy, Debug, PartialEq, Eq)]
278pub enum Res0Err {
279    #[doc = "0: No invalid indirect operation is detected."]
280    Res0ErrNo = 0,
281    #[doc = "1: An invalid indirect operation error is detected."]
282    Res0ErrYes = 1,
283}
284impl From<Res0Err> for bool {
285    #[inline(always)]
286    fn from(variant: Res0Err) -> Self {
287        variant as u8 != 0
288    }
289}
290#[doc = "Field `RES0_ERR` reader - RES0 Indirect Operation Error Flag"]
291pub type Res0ErrR = crate::BitReader<Res0Err>;
292impl Res0ErrR {
293    #[doc = "Get enumerated values variant"]
294    #[inline(always)]
295    pub const fn variant(&self) -> Res0Err {
296        match self.bits {
297            false => Res0Err::Res0ErrNo,
298            true => Res0Err::Res0ErrYes,
299        }
300    }
301    #[doc = "No invalid indirect operation is detected."]
302    #[inline(always)]
303    pub fn is_res0_err_no(&self) -> bool {
304        *self == Res0Err::Res0ErrNo
305    }
306    #[doc = "An invalid indirect operation error is detected."]
307    #[inline(always)]
308    pub fn is_res0_err_yes(&self) -> bool {
309        *self == Res0Err::Res0ErrYes
310    }
311}
312#[doc = "Field `RES0_ERR` writer - RES0 Indirect Operation Error Flag"]
313pub type Res0ErrW<'a, REG> = crate::BitWriter<'a, REG, Res0Err>;
314impl<'a, REG> Res0ErrW<'a, REG>
315where
316    REG: crate::Writable + crate::RegisterSpec,
317{
318    #[doc = "No invalid indirect operation is detected."]
319    #[inline(always)]
320    pub fn res0_err_no(self) -> &'a mut crate::W<REG> {
321        self.variant(Res0Err::Res0ErrNo)
322    }
323    #[doc = "An invalid indirect operation error is detected."]
324    #[inline(always)]
325    pub fn res0_err_yes(self) -> &'a mut crate::W<REG> {
326        self.variant(Res0Err::Res0ErrYes)
327    }
328}
329#[doc = "RES0 Overwrite Flag\n\nValue on reset: 0"]
330#[cfg_attr(feature = "defmt", derive(defmt::Format))]
331#[derive(Clone, Copy, Debug, PartialEq, Eq)]
332pub enum Res0Ovwr {
333    #[doc = "0: The value of RES0 has been read."]
334    Res0OvwrNo = 0,
335    #[doc = "1: The value of RES0 has not been read yet and is overwritten by a new MAUWRAP result."]
336    Res0OvwrYes = 1,
337}
338impl From<Res0Ovwr> for bool {
339    #[inline(always)]
340    fn from(variant: Res0Ovwr) -> Self {
341        variant as u8 != 0
342    }
343}
344#[doc = "Field `RES0_OVWR` reader - RES0 Overwrite Flag"]
345pub type Res0OvwrR = crate::BitReader<Res0Ovwr>;
346impl Res0OvwrR {
347    #[doc = "Get enumerated values variant"]
348    #[inline(always)]
349    pub const fn variant(&self) -> Res0Ovwr {
350        match self.bits {
351            false => Res0Ovwr::Res0OvwrNo,
352            true => Res0Ovwr::Res0OvwrYes,
353        }
354    }
355    #[doc = "The value of RES0 has been read."]
356    #[inline(always)]
357    pub fn is_res0_ovwr_no(&self) -> bool {
358        *self == Res0Ovwr::Res0OvwrNo
359    }
360    #[doc = "The value of RES0 has not been read yet and is overwritten by a new MAUWRAP result."]
361    #[inline(always)]
362    pub fn is_res0_ovwr_yes(&self) -> bool {
363        *self == Res0Ovwr::Res0OvwrYes
364    }
365}
366#[doc = "Field `RES0_OVWR` writer - RES0 Overwrite Flag"]
367pub type Res0OvwrW<'a, REG> = crate::BitWriter<'a, REG, Res0Ovwr>;
368impl<'a, REG> Res0OvwrW<'a, REG>
369where
370    REG: crate::Writable + crate::RegisterSpec,
371{
372    #[doc = "The value of RES0 has been read."]
373    #[inline(always)]
374    pub fn res0_ovwr_no(self) -> &'a mut crate::W<REG> {
375        self.variant(Res0Ovwr::Res0OvwrNo)
376    }
377    #[doc = "The value of RES0 has not been read yet and is overwritten by a new MAUWRAP result."]
378    #[inline(always)]
379    pub fn res0_ovwr_yes(self) -> &'a mut crate::W<REG> {
380        self.variant(Res0Ovwr::Res0OvwrYes)
381    }
382}
383#[doc = "RES0 Full Flag\n\nValue on reset: 0"]
384#[cfg_attr(feature = "defmt", derive(defmt::Format))]
385#[derive(Clone, Copy, Debug, PartialEq, Eq)]
386pub enum Res0Full {
387    #[doc = "0: RES0 has not updated and cannot be read."]
388    Res0FullNo = 0,
389    #[doc = "1: RES0 has updated and can be read."]
390    Res0FullYes = 1,
391}
392impl From<Res0Full> for bool {
393    #[inline(always)]
394    fn from(variant: Res0Full) -> Self {
395        variant as u8 != 0
396    }
397}
398#[doc = "Field `RES0_FULL` reader - RES0 Full Flag"]
399pub type Res0FullR = crate::BitReader<Res0Full>;
400impl Res0FullR {
401    #[doc = "Get enumerated values variant"]
402    #[inline(always)]
403    pub const fn variant(&self) -> Res0Full {
404        match self.bits {
405            false => Res0Full::Res0FullNo,
406            true => Res0Full::Res0FullYes,
407        }
408    }
409    #[doc = "RES0 has not updated and cannot be read."]
410    #[inline(always)]
411    pub fn is_res0_full_no(&self) -> bool {
412        *self == Res0Full::Res0FullNo
413    }
414    #[doc = "RES0 has updated and can be read."]
415    #[inline(always)]
416    pub fn is_res0_full_yes(&self) -> bool {
417        *self == Res0Full::Res0FullYes
418    }
419}
420#[doc = "Field `RES0_FULL` writer - RES0 Full Flag"]
421pub type Res0FullW<'a, REG> = crate::BitWriter<'a, REG, Res0Full>;
422impl<'a, REG> Res0FullW<'a, REG>
423where
424    REG: crate::Writable + crate::RegisterSpec,
425{
426    #[doc = "RES0 has not updated and cannot be read."]
427    #[inline(always)]
428    pub fn res0_full_no(self) -> &'a mut crate::W<REG> {
429        self.variant(Res0Full::Res0FullNo)
430    }
431    #[doc = "RES0 has updated and can be read."]
432    #[inline(always)]
433    pub fn res0_full_yes(self) -> &'a mut crate::W<REG> {
434        self.variant(Res0Full::Res0FullYes)
435    }
436}
437#[doc = "RES1 IEEE Inexact Flag\n\nValue on reset: 0"]
438#[cfg_attr(feature = "defmt", derive(defmt::Format))]
439#[derive(Clone, Copy, Debug, PartialEq, Eq)]
440pub enum Res1Nx {
441    #[doc = "0: The result is not rounded."]
442    Res1NxNo = 0,
443    #[doc = "1: The result is rounded, and as a result some digits lost."]
444    Res1NxYes = 1,
445}
446impl From<Res1Nx> for bool {
447    #[inline(always)]
448    fn from(variant: Res1Nx) -> Self {
449        variant as u8 != 0
450    }
451}
452#[doc = "Field `RES1_NX` reader - RES1 IEEE Inexact Flag"]
453pub type Res1NxR = crate::BitReader<Res1Nx>;
454impl Res1NxR {
455    #[doc = "Get enumerated values variant"]
456    #[inline(always)]
457    pub const fn variant(&self) -> Res1Nx {
458        match self.bits {
459            false => Res1Nx::Res1NxNo,
460            true => Res1Nx::Res1NxYes,
461        }
462    }
463    #[doc = "The result is not rounded."]
464    #[inline(always)]
465    pub fn is_res1_nx_no(&self) -> bool {
466        *self == Res1Nx::Res1NxNo
467    }
468    #[doc = "The result is rounded, and as a result some digits lost."]
469    #[inline(always)]
470    pub fn is_res1_nx_yes(&self) -> bool {
471        *self == Res1Nx::Res1NxYes
472    }
473}
474#[doc = "Field `RES1_NX` writer - RES1 IEEE Inexact Flag"]
475pub type Res1NxW<'a, REG> = crate::BitWriter<'a, REG, Res1Nx>;
476impl<'a, REG> Res1NxW<'a, REG>
477where
478    REG: crate::Writable + crate::RegisterSpec,
479{
480    #[doc = "The result is not rounded."]
481    #[inline(always)]
482    pub fn res1_nx_no(self) -> &'a mut crate::W<REG> {
483        self.variant(Res1Nx::Res1NxNo)
484    }
485    #[doc = "The result is rounded, and as a result some digits lost."]
486    #[inline(always)]
487    pub fn res1_nx_yes(self) -> &'a mut crate::W<REG> {
488        self.variant(Res1Nx::Res1NxYes)
489    }
490}
491#[doc = "RES1 IEEE Underflow Flag\n\nValue on reset: 0"]
492#[cfg_attr(feature = "defmt", derive(defmt::Format))]
493#[derive(Clone, Copy, Debug, PartialEq, Eq)]
494pub enum Res1Uf {
495    #[doc = "0: No tiny non-zero result is detected."]
496    Res1UfNo = 0,
497    #[doc = "1: A tiny non-zero result is detected."]
498    Res1UfYes = 1,
499}
500impl From<Res1Uf> for bool {
501    #[inline(always)]
502    fn from(variant: Res1Uf) -> Self {
503        variant as u8 != 0
504    }
505}
506#[doc = "Field `RES1_UF` reader - RES1 IEEE Underflow Flag"]
507pub type Res1UfR = crate::BitReader<Res1Uf>;
508impl Res1UfR {
509    #[doc = "Get enumerated values variant"]
510    #[inline(always)]
511    pub const fn variant(&self) -> Res1Uf {
512        match self.bits {
513            false => Res1Uf::Res1UfNo,
514            true => Res1Uf::Res1UfYes,
515        }
516    }
517    #[doc = "No tiny non-zero result is detected."]
518    #[inline(always)]
519    pub fn is_res1_uf_no(&self) -> bool {
520        *self == Res1Uf::Res1UfNo
521    }
522    #[doc = "A tiny non-zero result is detected."]
523    #[inline(always)]
524    pub fn is_res1_uf_yes(&self) -> bool {
525        *self == Res1Uf::Res1UfYes
526    }
527}
528#[doc = "Field `RES1_UF` writer - RES1 IEEE Underflow Flag"]
529pub type Res1UfW<'a, REG> = crate::BitWriter<'a, REG, Res1Uf>;
530impl<'a, REG> Res1UfW<'a, REG>
531where
532    REG: crate::Writable + crate::RegisterSpec,
533{
534    #[doc = "No tiny non-zero result is detected."]
535    #[inline(always)]
536    pub fn res1_uf_no(self) -> &'a mut crate::W<REG> {
537        self.variant(Res1Uf::Res1UfNo)
538    }
539    #[doc = "A tiny non-zero result is detected."]
540    #[inline(always)]
541    pub fn res1_uf_yes(self) -> &'a mut crate::W<REG> {
542        self.variant(Res1Uf::Res1UfYes)
543    }
544}
545#[doc = "RES1 IEEE Overflow Flag\n\nValue on reset: 0"]
546#[cfg_attr(feature = "defmt", derive(defmt::Format))]
547#[derive(Clone, Copy, Debug, PartialEq, Eq)]
548pub enum Res1Of {
549    #[doc = "0: The result format's largest finite number is not exceeded."]
550    Res1OfNo = 0,
551    #[doc = "1: The result format's largest finite number is exceeded."]
552    Res1OfYes = 1,
553}
554impl From<Res1Of> for bool {
555    #[inline(always)]
556    fn from(variant: Res1Of) -> Self {
557        variant as u8 != 0
558    }
559}
560#[doc = "Field `RES1_OF` reader - RES1 IEEE Overflow Flag"]
561pub type Res1OfR = crate::BitReader<Res1Of>;
562impl Res1OfR {
563    #[doc = "Get enumerated values variant"]
564    #[inline(always)]
565    pub const fn variant(&self) -> Res1Of {
566        match self.bits {
567            false => Res1Of::Res1OfNo,
568            true => Res1Of::Res1OfYes,
569        }
570    }
571    #[doc = "The result format's largest finite number is not exceeded."]
572    #[inline(always)]
573    pub fn is_res1_of_no(&self) -> bool {
574        *self == Res1Of::Res1OfNo
575    }
576    #[doc = "The result format's largest finite number is exceeded."]
577    #[inline(always)]
578    pub fn is_res1_of_yes(&self) -> bool {
579        *self == Res1Of::Res1OfYes
580    }
581}
582#[doc = "Field `RES1_OF` writer - RES1 IEEE Overflow Flag"]
583pub type Res1OfW<'a, REG> = crate::BitWriter<'a, REG, Res1Of>;
584impl<'a, REG> Res1OfW<'a, REG>
585where
586    REG: crate::Writable + crate::RegisterSpec,
587{
588    #[doc = "The result format's largest finite number is not exceeded."]
589    #[inline(always)]
590    pub fn res1_of_no(self) -> &'a mut crate::W<REG> {
591        self.variant(Res1Of::Res1OfNo)
592    }
593    #[doc = "The result format's largest finite number is exceeded."]
594    #[inline(always)]
595    pub fn res1_of_yes(self) -> &'a mut crate::W<REG> {
596        self.variant(Res1Of::Res1OfYes)
597    }
598}
599#[doc = "RES1 IEEE Divide by Zero Flag\n\nValue on reset: 0"]
600#[cfg_attr(feature = "defmt", derive(defmt::Format))]
601#[derive(Clone, Copy, Debug, PartialEq, Eq)]
602pub enum Res1Dz {
603    #[doc = "0: No exact infinite result is defined for an operation on finite operands."]
604    Res1DzNo = 0,
605    #[doc = "1: An exact infinite result is defined for an operation on finite operands."]
606    Res1DzYes = 1,
607}
608impl From<Res1Dz> for bool {
609    #[inline(always)]
610    fn from(variant: Res1Dz) -> Self {
611        variant as u8 != 0
612    }
613}
614#[doc = "Field `RES1_DZ` reader - RES1 IEEE Divide by Zero Flag"]
615pub type Res1DzR = crate::BitReader<Res1Dz>;
616impl Res1DzR {
617    #[doc = "Get enumerated values variant"]
618    #[inline(always)]
619    pub const fn variant(&self) -> Res1Dz {
620        match self.bits {
621            false => Res1Dz::Res1DzNo,
622            true => Res1Dz::Res1DzYes,
623        }
624    }
625    #[doc = "No exact infinite result is defined for an operation on finite operands."]
626    #[inline(always)]
627    pub fn is_res1_dz_no(&self) -> bool {
628        *self == Res1Dz::Res1DzNo
629    }
630    #[doc = "An exact infinite result is defined for an operation on finite operands."]
631    #[inline(always)]
632    pub fn is_res1_dz_yes(&self) -> bool {
633        *self == Res1Dz::Res1DzYes
634    }
635}
636#[doc = "Field `RES1_DZ` writer - RES1 IEEE Divide by Zero Flag"]
637pub type Res1DzW<'a, REG> = crate::BitWriter<'a, REG, Res1Dz>;
638impl<'a, REG> Res1DzW<'a, REG>
639where
640    REG: crate::Writable + crate::RegisterSpec,
641{
642    #[doc = "No exact infinite result is defined for an operation on finite operands."]
643    #[inline(always)]
644    pub fn res1_dz_no(self) -> &'a mut crate::W<REG> {
645        self.variant(Res1Dz::Res1DzNo)
646    }
647    #[doc = "An exact infinite result is defined for an operation on finite operands."]
648    #[inline(always)]
649    pub fn res1_dz_yes(self) -> &'a mut crate::W<REG> {
650        self.variant(Res1Dz::Res1DzYes)
651    }
652}
653#[doc = "RES1 IEEE Invalid Flag\n\nValue on reset: 0"]
654#[cfg_attr(feature = "defmt", derive(defmt::Format))]
655#[derive(Clone, Copy, Debug, PartialEq, Eq)]
656pub enum Res1Nv {
657    #[doc = "0: There is usefully definable result."]
658    Res1NvNo = 0,
659    #[doc = "1: There is no usefully definable result."]
660    Res1NvYes = 1,
661}
662impl From<Res1Nv> for bool {
663    #[inline(always)]
664    fn from(variant: Res1Nv) -> Self {
665        variant as u8 != 0
666    }
667}
668#[doc = "Field `RES1_NV` reader - RES1 IEEE Invalid Flag"]
669pub type Res1NvR = crate::BitReader<Res1Nv>;
670impl Res1NvR {
671    #[doc = "Get enumerated values variant"]
672    #[inline(always)]
673    pub const fn variant(&self) -> Res1Nv {
674        match self.bits {
675            false => Res1Nv::Res1NvNo,
676            true => Res1Nv::Res1NvYes,
677        }
678    }
679    #[doc = "There is usefully definable result."]
680    #[inline(always)]
681    pub fn is_res1_nv_no(&self) -> bool {
682        *self == Res1Nv::Res1NvNo
683    }
684    #[doc = "There is no usefully definable result."]
685    #[inline(always)]
686    pub fn is_res1_nv_yes(&self) -> bool {
687        *self == Res1Nv::Res1NvYes
688    }
689}
690#[doc = "Field `RES1_NV` writer - RES1 IEEE Invalid Flag"]
691pub type Res1NvW<'a, REG> = crate::BitWriter<'a, REG, Res1Nv>;
692impl<'a, REG> Res1NvW<'a, REG>
693where
694    REG: crate::Writable + crate::RegisterSpec,
695{
696    #[doc = "There is usefully definable result."]
697    #[inline(always)]
698    pub fn res1_nv_no(self) -> &'a mut crate::W<REG> {
699        self.variant(Res1Nv::Res1NvNo)
700    }
701    #[doc = "There is no usefully definable result."]
702    #[inline(always)]
703    pub fn res1_nv_yes(self) -> &'a mut crate::W<REG> {
704        self.variant(Res1Nv::Res1NvYes)
705    }
706}
707#[doc = "RES1 Indirect Operation Error Flag\n\nValue on reset: 0"]
708#[cfg_attr(feature = "defmt", derive(defmt::Format))]
709#[derive(Clone, Copy, Debug, PartialEq, Eq)]
710pub enum Res1Err {
711    #[doc = "0: No invalid indirect operation is detected."]
712    Res1ErrNo = 0,
713    #[doc = "1: An invalid indirect operation error is detected."]
714    Res1ErrYes = 1,
715}
716impl From<Res1Err> for bool {
717    #[inline(always)]
718    fn from(variant: Res1Err) -> Self {
719        variant as u8 != 0
720    }
721}
722#[doc = "Field `RES1_ERR` reader - RES1 Indirect Operation Error Flag"]
723pub type Res1ErrR = crate::BitReader<Res1Err>;
724impl Res1ErrR {
725    #[doc = "Get enumerated values variant"]
726    #[inline(always)]
727    pub const fn variant(&self) -> Res1Err {
728        match self.bits {
729            false => Res1Err::Res1ErrNo,
730            true => Res1Err::Res1ErrYes,
731        }
732    }
733    #[doc = "No invalid indirect operation is detected."]
734    #[inline(always)]
735    pub fn is_res1_err_no(&self) -> bool {
736        *self == Res1Err::Res1ErrNo
737    }
738    #[doc = "An invalid indirect operation error is detected."]
739    #[inline(always)]
740    pub fn is_res1_err_yes(&self) -> bool {
741        *self == Res1Err::Res1ErrYes
742    }
743}
744#[doc = "Field `RES1_ERR` writer - RES1 Indirect Operation Error Flag"]
745pub type Res1ErrW<'a, REG> = crate::BitWriter<'a, REG, Res1Err>;
746impl<'a, REG> Res1ErrW<'a, REG>
747where
748    REG: crate::Writable + crate::RegisterSpec,
749{
750    #[doc = "No invalid indirect operation is detected."]
751    #[inline(always)]
752    pub fn res1_err_no(self) -> &'a mut crate::W<REG> {
753        self.variant(Res1Err::Res1ErrNo)
754    }
755    #[doc = "An invalid indirect operation error is detected."]
756    #[inline(always)]
757    pub fn res1_err_yes(self) -> &'a mut crate::W<REG> {
758        self.variant(Res1Err::Res1ErrYes)
759    }
760}
761#[doc = "RES1 Overwrite Flag\n\nValue on reset: 0"]
762#[cfg_attr(feature = "defmt", derive(defmt::Format))]
763#[derive(Clone, Copy, Debug, PartialEq, Eq)]
764pub enum Res1Ovwr {
765    #[doc = "0: The value of RES1 has been read."]
766    Res1OvwrNo = 0,
767    #[doc = "1: The value of RES1 has not been read yet and is overwritten by a new MAUWRAP result."]
768    Res1OvwrYes = 1,
769}
770impl From<Res1Ovwr> for bool {
771    #[inline(always)]
772    fn from(variant: Res1Ovwr) -> Self {
773        variant as u8 != 0
774    }
775}
776#[doc = "Field `RES1_OVWR` reader - RES1 Overwrite Flag"]
777pub type Res1OvwrR = crate::BitReader<Res1Ovwr>;
778impl Res1OvwrR {
779    #[doc = "Get enumerated values variant"]
780    #[inline(always)]
781    pub const fn variant(&self) -> Res1Ovwr {
782        match self.bits {
783            false => Res1Ovwr::Res1OvwrNo,
784            true => Res1Ovwr::Res1OvwrYes,
785        }
786    }
787    #[doc = "The value of RES1 has been read."]
788    #[inline(always)]
789    pub fn is_res1_ovwr_no(&self) -> bool {
790        *self == Res1Ovwr::Res1OvwrNo
791    }
792    #[doc = "The value of RES1 has not been read yet and is overwritten by a new MAUWRAP result."]
793    #[inline(always)]
794    pub fn is_res1_ovwr_yes(&self) -> bool {
795        *self == Res1Ovwr::Res1OvwrYes
796    }
797}
798#[doc = "Field `RES1_OVWR` writer - RES1 Overwrite Flag"]
799pub type Res1OvwrW<'a, REG> = crate::BitWriter<'a, REG, Res1Ovwr>;
800impl<'a, REG> Res1OvwrW<'a, REG>
801where
802    REG: crate::Writable + crate::RegisterSpec,
803{
804    #[doc = "The value of RES1 has been read."]
805    #[inline(always)]
806    pub fn res1_ovwr_no(self) -> &'a mut crate::W<REG> {
807        self.variant(Res1Ovwr::Res1OvwrNo)
808    }
809    #[doc = "The value of RES1 has not been read yet and is overwritten by a new MAUWRAP result."]
810    #[inline(always)]
811    pub fn res1_ovwr_yes(self) -> &'a mut crate::W<REG> {
812        self.variant(Res1Ovwr::Res1OvwrYes)
813    }
814}
815#[doc = "RES1 Full Flag\n\nValue on reset: 0"]
816#[cfg_attr(feature = "defmt", derive(defmt::Format))]
817#[derive(Clone, Copy, Debug, PartialEq, Eq)]
818pub enum Res1Full {
819    #[doc = "0: RES1 has not updated and cannot be read."]
820    Res1FullNo = 0,
821    #[doc = "1: RES1 has updated and can be read."]
822    Res1FullYes = 1,
823}
824impl From<Res1Full> for bool {
825    #[inline(always)]
826    fn from(variant: Res1Full) -> Self {
827        variant as u8 != 0
828    }
829}
830#[doc = "Field `RES1_FULL` reader - RES1 Full Flag"]
831pub type Res1FullR = crate::BitReader<Res1Full>;
832impl Res1FullR {
833    #[doc = "Get enumerated values variant"]
834    #[inline(always)]
835    pub const fn variant(&self) -> Res1Full {
836        match self.bits {
837            false => Res1Full::Res1FullNo,
838            true => Res1Full::Res1FullYes,
839        }
840    }
841    #[doc = "RES1 has not updated and cannot be read."]
842    #[inline(always)]
843    pub fn is_res1_full_no(&self) -> bool {
844        *self == Res1Full::Res1FullNo
845    }
846    #[doc = "RES1 has updated and can be read."]
847    #[inline(always)]
848    pub fn is_res1_full_yes(&self) -> bool {
849        *self == Res1Full::Res1FullYes
850    }
851}
852#[doc = "Field `RES1_FULL` writer - RES1 Full Flag"]
853pub type Res1FullW<'a, REG> = crate::BitWriter<'a, REG, Res1Full>;
854impl<'a, REG> Res1FullW<'a, REG>
855where
856    REG: crate::Writable + crate::RegisterSpec,
857{
858    #[doc = "RES1 has not updated and cannot be read."]
859    #[inline(always)]
860    pub fn res1_full_no(self) -> &'a mut crate::W<REG> {
861        self.variant(Res1Full::Res1FullNo)
862    }
863    #[doc = "RES1 has updated and can be read."]
864    #[inline(always)]
865    pub fn res1_full_yes(self) -> &'a mut crate::W<REG> {
866        self.variant(Res1Full::Res1FullYes)
867    }
868}
869#[doc = "RES2 IEEE Inexact Flag\n\nValue on reset: 0"]
870#[cfg_attr(feature = "defmt", derive(defmt::Format))]
871#[derive(Clone, Copy, Debug, PartialEq, Eq)]
872pub enum Res2Nx {
873    #[doc = "0: The result is not rounded."]
874    Res2NxNo = 0,
875    #[doc = "1: The result is rounded, and as a result some digits lost."]
876    Res2NxYes = 1,
877}
878impl From<Res2Nx> for bool {
879    #[inline(always)]
880    fn from(variant: Res2Nx) -> Self {
881        variant as u8 != 0
882    }
883}
884#[doc = "Field `RES2_NX` reader - RES2 IEEE Inexact Flag"]
885pub type Res2NxR = crate::BitReader<Res2Nx>;
886impl Res2NxR {
887    #[doc = "Get enumerated values variant"]
888    #[inline(always)]
889    pub const fn variant(&self) -> Res2Nx {
890        match self.bits {
891            false => Res2Nx::Res2NxNo,
892            true => Res2Nx::Res2NxYes,
893        }
894    }
895    #[doc = "The result is not rounded."]
896    #[inline(always)]
897    pub fn is_res2_nx_no(&self) -> bool {
898        *self == Res2Nx::Res2NxNo
899    }
900    #[doc = "The result is rounded, and as a result some digits lost."]
901    #[inline(always)]
902    pub fn is_res2_nx_yes(&self) -> bool {
903        *self == Res2Nx::Res2NxYes
904    }
905}
906#[doc = "Field `RES2_NX` writer - RES2 IEEE Inexact Flag"]
907pub type Res2NxW<'a, REG> = crate::BitWriter<'a, REG, Res2Nx>;
908impl<'a, REG> Res2NxW<'a, REG>
909where
910    REG: crate::Writable + crate::RegisterSpec,
911{
912    #[doc = "The result is not rounded."]
913    #[inline(always)]
914    pub fn res2_nx_no(self) -> &'a mut crate::W<REG> {
915        self.variant(Res2Nx::Res2NxNo)
916    }
917    #[doc = "The result is rounded, and as a result some digits lost."]
918    #[inline(always)]
919    pub fn res2_nx_yes(self) -> &'a mut crate::W<REG> {
920        self.variant(Res2Nx::Res2NxYes)
921    }
922}
923#[doc = "RES2 IEEE Underflow Flag\n\nValue on reset: 0"]
924#[cfg_attr(feature = "defmt", derive(defmt::Format))]
925#[derive(Clone, Copy, Debug, PartialEq, Eq)]
926pub enum Res2Uf {
927    #[doc = "0: No tiny non-zero result is detected."]
928    Res2UfNo = 0,
929    #[doc = "1: A tiny non-zero result is detected."]
930    Res2UfYes = 1,
931}
932impl From<Res2Uf> for bool {
933    #[inline(always)]
934    fn from(variant: Res2Uf) -> Self {
935        variant as u8 != 0
936    }
937}
938#[doc = "Field `RES2_UF` reader - RES2 IEEE Underflow Flag"]
939pub type Res2UfR = crate::BitReader<Res2Uf>;
940impl Res2UfR {
941    #[doc = "Get enumerated values variant"]
942    #[inline(always)]
943    pub const fn variant(&self) -> Res2Uf {
944        match self.bits {
945            false => Res2Uf::Res2UfNo,
946            true => Res2Uf::Res2UfYes,
947        }
948    }
949    #[doc = "No tiny non-zero result is detected."]
950    #[inline(always)]
951    pub fn is_res2_uf_no(&self) -> bool {
952        *self == Res2Uf::Res2UfNo
953    }
954    #[doc = "A tiny non-zero result is detected."]
955    #[inline(always)]
956    pub fn is_res2_uf_yes(&self) -> bool {
957        *self == Res2Uf::Res2UfYes
958    }
959}
960#[doc = "Field `RES2_UF` writer - RES2 IEEE Underflow Flag"]
961pub type Res2UfW<'a, REG> = crate::BitWriter<'a, REG, Res2Uf>;
962impl<'a, REG> Res2UfW<'a, REG>
963where
964    REG: crate::Writable + crate::RegisterSpec,
965{
966    #[doc = "No tiny non-zero result is detected."]
967    #[inline(always)]
968    pub fn res2_uf_no(self) -> &'a mut crate::W<REG> {
969        self.variant(Res2Uf::Res2UfNo)
970    }
971    #[doc = "A tiny non-zero result is detected."]
972    #[inline(always)]
973    pub fn res2_uf_yes(self) -> &'a mut crate::W<REG> {
974        self.variant(Res2Uf::Res2UfYes)
975    }
976}
977#[doc = "RES2 IEEE Overflow Flag\n\nValue on reset: 0"]
978#[cfg_attr(feature = "defmt", derive(defmt::Format))]
979#[derive(Clone, Copy, Debug, PartialEq, Eq)]
980pub enum Res2Of {
981    #[doc = "0: The result format's largest finite number is not exceeded."]
982    Res2OfNo = 0,
983    #[doc = "1: The result format's largest finite number is exceeded."]
984    Res2OfYes = 1,
985}
986impl From<Res2Of> for bool {
987    #[inline(always)]
988    fn from(variant: Res2Of) -> Self {
989        variant as u8 != 0
990    }
991}
992#[doc = "Field `RES2_OF` reader - RES2 IEEE Overflow Flag"]
993pub type Res2OfR = crate::BitReader<Res2Of>;
994impl Res2OfR {
995    #[doc = "Get enumerated values variant"]
996    #[inline(always)]
997    pub const fn variant(&self) -> Res2Of {
998        match self.bits {
999            false => Res2Of::Res2OfNo,
1000            true => Res2Of::Res2OfYes,
1001        }
1002    }
1003    #[doc = "The result format's largest finite number is not exceeded."]
1004    #[inline(always)]
1005    pub fn is_res2_of_no(&self) -> bool {
1006        *self == Res2Of::Res2OfNo
1007    }
1008    #[doc = "The result format's largest finite number is exceeded."]
1009    #[inline(always)]
1010    pub fn is_res2_of_yes(&self) -> bool {
1011        *self == Res2Of::Res2OfYes
1012    }
1013}
1014#[doc = "Field `RES2_OF` writer - RES2 IEEE Overflow Flag"]
1015pub type Res2OfW<'a, REG> = crate::BitWriter<'a, REG, Res2Of>;
1016impl<'a, REG> Res2OfW<'a, REG>
1017where
1018    REG: crate::Writable + crate::RegisterSpec,
1019{
1020    #[doc = "The result format's largest finite number is not exceeded."]
1021    #[inline(always)]
1022    pub fn res2_of_no(self) -> &'a mut crate::W<REG> {
1023        self.variant(Res2Of::Res2OfNo)
1024    }
1025    #[doc = "The result format's largest finite number is exceeded."]
1026    #[inline(always)]
1027    pub fn res2_of_yes(self) -> &'a mut crate::W<REG> {
1028        self.variant(Res2Of::Res2OfYes)
1029    }
1030}
1031#[doc = "RES2 IEEE Divide by Zero Flag\n\nValue on reset: 0"]
1032#[cfg_attr(feature = "defmt", derive(defmt::Format))]
1033#[derive(Clone, Copy, Debug, PartialEq, Eq)]
1034pub enum Res2Dz {
1035    #[doc = "0: No exact infinite result is defined for an operation on finite operands."]
1036    Res2DzNo = 0,
1037    #[doc = "1: An exact infinite result is defined for an operation on finite operands."]
1038    Res2DzYes = 1,
1039}
1040impl From<Res2Dz> for bool {
1041    #[inline(always)]
1042    fn from(variant: Res2Dz) -> Self {
1043        variant as u8 != 0
1044    }
1045}
1046#[doc = "Field `RES2_DZ` reader - RES2 IEEE Divide by Zero Flag"]
1047pub type Res2DzR = crate::BitReader<Res2Dz>;
1048impl Res2DzR {
1049    #[doc = "Get enumerated values variant"]
1050    #[inline(always)]
1051    pub const fn variant(&self) -> Res2Dz {
1052        match self.bits {
1053            false => Res2Dz::Res2DzNo,
1054            true => Res2Dz::Res2DzYes,
1055        }
1056    }
1057    #[doc = "No exact infinite result is defined for an operation on finite operands."]
1058    #[inline(always)]
1059    pub fn is_res2_dz_no(&self) -> bool {
1060        *self == Res2Dz::Res2DzNo
1061    }
1062    #[doc = "An exact infinite result is defined for an operation on finite operands."]
1063    #[inline(always)]
1064    pub fn is_res2_dz_yes(&self) -> bool {
1065        *self == Res2Dz::Res2DzYes
1066    }
1067}
1068#[doc = "Field `RES2_DZ` writer - RES2 IEEE Divide by Zero Flag"]
1069pub type Res2DzW<'a, REG> = crate::BitWriter<'a, REG, Res2Dz>;
1070impl<'a, REG> Res2DzW<'a, REG>
1071where
1072    REG: crate::Writable + crate::RegisterSpec,
1073{
1074    #[doc = "No exact infinite result is defined for an operation on finite operands."]
1075    #[inline(always)]
1076    pub fn res2_dz_no(self) -> &'a mut crate::W<REG> {
1077        self.variant(Res2Dz::Res2DzNo)
1078    }
1079    #[doc = "An exact infinite result is defined for an operation on finite operands."]
1080    #[inline(always)]
1081    pub fn res2_dz_yes(self) -> &'a mut crate::W<REG> {
1082        self.variant(Res2Dz::Res2DzYes)
1083    }
1084}
1085#[doc = "RES2 IEEE Invalid Flag\n\nValue on reset: 0"]
1086#[cfg_attr(feature = "defmt", derive(defmt::Format))]
1087#[derive(Clone, Copy, Debug, PartialEq, Eq)]
1088pub enum Res2Nv {
1089    #[doc = "0: There is usefully definable result."]
1090    Res2NvNo = 0,
1091    #[doc = "1: There is no usefully definable result."]
1092    Res2NvYes = 1,
1093}
1094impl From<Res2Nv> for bool {
1095    #[inline(always)]
1096    fn from(variant: Res2Nv) -> Self {
1097        variant as u8 != 0
1098    }
1099}
1100#[doc = "Field `RES2_NV` reader - RES2 IEEE Invalid Flag"]
1101pub type Res2NvR = crate::BitReader<Res2Nv>;
1102impl Res2NvR {
1103    #[doc = "Get enumerated values variant"]
1104    #[inline(always)]
1105    pub const fn variant(&self) -> Res2Nv {
1106        match self.bits {
1107            false => Res2Nv::Res2NvNo,
1108            true => Res2Nv::Res2NvYes,
1109        }
1110    }
1111    #[doc = "There is usefully definable result."]
1112    #[inline(always)]
1113    pub fn is_res2_nv_no(&self) -> bool {
1114        *self == Res2Nv::Res2NvNo
1115    }
1116    #[doc = "There is no usefully definable result."]
1117    #[inline(always)]
1118    pub fn is_res2_nv_yes(&self) -> bool {
1119        *self == Res2Nv::Res2NvYes
1120    }
1121}
1122#[doc = "Field `RES2_NV` writer - RES2 IEEE Invalid Flag"]
1123pub type Res2NvW<'a, REG> = crate::BitWriter<'a, REG, Res2Nv>;
1124impl<'a, REG> Res2NvW<'a, REG>
1125where
1126    REG: crate::Writable + crate::RegisterSpec,
1127{
1128    #[doc = "There is usefully definable result."]
1129    #[inline(always)]
1130    pub fn res2_nv_no(self) -> &'a mut crate::W<REG> {
1131        self.variant(Res2Nv::Res2NvNo)
1132    }
1133    #[doc = "There is no usefully definable result."]
1134    #[inline(always)]
1135    pub fn res2_nv_yes(self) -> &'a mut crate::W<REG> {
1136        self.variant(Res2Nv::Res2NvYes)
1137    }
1138}
1139#[doc = "RES2 Indirect Operation Error Flag\n\nValue on reset: 0"]
1140#[cfg_attr(feature = "defmt", derive(defmt::Format))]
1141#[derive(Clone, Copy, Debug, PartialEq, Eq)]
1142pub enum Res2Err {
1143    #[doc = "0: No invalid indirect operation is detected."]
1144    Res2ErrNo = 0,
1145    #[doc = "1: An invalid indirect operation error is detected."]
1146    Res2ErrYes = 1,
1147}
1148impl From<Res2Err> for bool {
1149    #[inline(always)]
1150    fn from(variant: Res2Err) -> Self {
1151        variant as u8 != 0
1152    }
1153}
1154#[doc = "Field `RES2_ERR` reader - RES2 Indirect Operation Error Flag"]
1155pub type Res2ErrR = crate::BitReader<Res2Err>;
1156impl Res2ErrR {
1157    #[doc = "Get enumerated values variant"]
1158    #[inline(always)]
1159    pub const fn variant(&self) -> Res2Err {
1160        match self.bits {
1161            false => Res2Err::Res2ErrNo,
1162            true => Res2Err::Res2ErrYes,
1163        }
1164    }
1165    #[doc = "No invalid indirect operation is detected."]
1166    #[inline(always)]
1167    pub fn is_res2_err_no(&self) -> bool {
1168        *self == Res2Err::Res2ErrNo
1169    }
1170    #[doc = "An invalid indirect operation error is detected."]
1171    #[inline(always)]
1172    pub fn is_res2_err_yes(&self) -> bool {
1173        *self == Res2Err::Res2ErrYes
1174    }
1175}
1176#[doc = "Field `RES2_ERR` writer - RES2 Indirect Operation Error Flag"]
1177pub type Res2ErrW<'a, REG> = crate::BitWriter<'a, REG, Res2Err>;
1178impl<'a, REG> Res2ErrW<'a, REG>
1179where
1180    REG: crate::Writable + crate::RegisterSpec,
1181{
1182    #[doc = "No invalid indirect operation is detected."]
1183    #[inline(always)]
1184    pub fn res2_err_no(self) -> &'a mut crate::W<REG> {
1185        self.variant(Res2Err::Res2ErrNo)
1186    }
1187    #[doc = "An invalid indirect operation error is detected."]
1188    #[inline(always)]
1189    pub fn res2_err_yes(self) -> &'a mut crate::W<REG> {
1190        self.variant(Res2Err::Res2ErrYes)
1191    }
1192}
1193#[doc = "RES2 Overwrite Flag\n\nValue on reset: 0"]
1194#[cfg_attr(feature = "defmt", derive(defmt::Format))]
1195#[derive(Clone, Copy, Debug, PartialEq, Eq)]
1196pub enum Res2Ovwr {
1197    #[doc = "0: The value of RES2 has been read."]
1198    Res2OvwrNo = 0,
1199    #[doc = "1: The value of RES2 has not been read yet and is overwritten by a new MAUWRAP result."]
1200    Res2OvwrYes = 1,
1201}
1202impl From<Res2Ovwr> for bool {
1203    #[inline(always)]
1204    fn from(variant: Res2Ovwr) -> Self {
1205        variant as u8 != 0
1206    }
1207}
1208#[doc = "Field `RES2_OVWR` reader - RES2 Overwrite Flag"]
1209pub type Res2OvwrR = crate::BitReader<Res2Ovwr>;
1210impl Res2OvwrR {
1211    #[doc = "Get enumerated values variant"]
1212    #[inline(always)]
1213    pub const fn variant(&self) -> Res2Ovwr {
1214        match self.bits {
1215            false => Res2Ovwr::Res2OvwrNo,
1216            true => Res2Ovwr::Res2OvwrYes,
1217        }
1218    }
1219    #[doc = "The value of RES2 has been read."]
1220    #[inline(always)]
1221    pub fn is_res2_ovwr_no(&self) -> bool {
1222        *self == Res2Ovwr::Res2OvwrNo
1223    }
1224    #[doc = "The value of RES2 has not been read yet and is overwritten by a new MAUWRAP result."]
1225    #[inline(always)]
1226    pub fn is_res2_ovwr_yes(&self) -> bool {
1227        *self == Res2Ovwr::Res2OvwrYes
1228    }
1229}
1230#[doc = "Field `RES2_OVWR` writer - RES2 Overwrite Flag"]
1231pub type Res2OvwrW<'a, REG> = crate::BitWriter<'a, REG, Res2Ovwr>;
1232impl<'a, REG> Res2OvwrW<'a, REG>
1233where
1234    REG: crate::Writable + crate::RegisterSpec,
1235{
1236    #[doc = "The value of RES2 has been read."]
1237    #[inline(always)]
1238    pub fn res2_ovwr_no(self) -> &'a mut crate::W<REG> {
1239        self.variant(Res2Ovwr::Res2OvwrNo)
1240    }
1241    #[doc = "The value of RES2 has not been read yet and is overwritten by a new MAUWRAP result."]
1242    #[inline(always)]
1243    pub fn res2_ovwr_yes(self) -> &'a mut crate::W<REG> {
1244        self.variant(Res2Ovwr::Res2OvwrYes)
1245    }
1246}
1247#[doc = "RES2 Full Flag\n\nValue on reset: 0"]
1248#[cfg_attr(feature = "defmt", derive(defmt::Format))]
1249#[derive(Clone, Copy, Debug, PartialEq, Eq)]
1250pub enum Res2Full {
1251    #[doc = "0: RES2 has not updated and cannot be read."]
1252    Res2FullNo = 0,
1253    #[doc = "1: RES2 has updated and can be read."]
1254    Res2FullYes = 1,
1255}
1256impl From<Res2Full> for bool {
1257    #[inline(always)]
1258    fn from(variant: Res2Full) -> Self {
1259        variant as u8 != 0
1260    }
1261}
1262#[doc = "Field `RES2_FULL` reader - RES2 Full Flag"]
1263pub type Res2FullR = crate::BitReader<Res2Full>;
1264impl Res2FullR {
1265    #[doc = "Get enumerated values variant"]
1266    #[inline(always)]
1267    pub const fn variant(&self) -> Res2Full {
1268        match self.bits {
1269            false => Res2Full::Res2FullNo,
1270            true => Res2Full::Res2FullYes,
1271        }
1272    }
1273    #[doc = "RES2 has not updated and cannot be read."]
1274    #[inline(always)]
1275    pub fn is_res2_full_no(&self) -> bool {
1276        *self == Res2Full::Res2FullNo
1277    }
1278    #[doc = "RES2 has updated and can be read."]
1279    #[inline(always)]
1280    pub fn is_res2_full_yes(&self) -> bool {
1281        *self == Res2Full::Res2FullYes
1282    }
1283}
1284#[doc = "Field `RES2_FULL` writer - RES2 Full Flag"]
1285pub type Res2FullW<'a, REG> = crate::BitWriter<'a, REG, Res2Full>;
1286impl<'a, REG> Res2FullW<'a, REG>
1287where
1288    REG: crate::Writable + crate::RegisterSpec,
1289{
1290    #[doc = "RES2 has not updated and cannot be read."]
1291    #[inline(always)]
1292    pub fn res2_full_no(self) -> &'a mut crate::W<REG> {
1293        self.variant(Res2Full::Res2FullNo)
1294    }
1295    #[doc = "RES2 has updated and can be read."]
1296    #[inline(always)]
1297    pub fn res2_full_yes(self) -> &'a mut crate::W<REG> {
1298        self.variant(Res2Full::Res2FullYes)
1299    }
1300}
1301#[doc = "RES3 IEEE Inexact Flag\n\nValue on reset: 0"]
1302#[cfg_attr(feature = "defmt", derive(defmt::Format))]
1303#[derive(Clone, Copy, Debug, PartialEq, Eq)]
1304pub enum Res3Nx {
1305    #[doc = "0: The result is not rounded."]
1306    Res3NxNo = 0,
1307    #[doc = "1: The result is rounded, and as a result some digits lost."]
1308    Res3NxYes = 1,
1309}
1310impl From<Res3Nx> for bool {
1311    #[inline(always)]
1312    fn from(variant: Res3Nx) -> Self {
1313        variant as u8 != 0
1314    }
1315}
1316#[doc = "Field `RES3_NX` reader - RES3 IEEE Inexact Flag"]
1317pub type Res3NxR = crate::BitReader<Res3Nx>;
1318impl Res3NxR {
1319    #[doc = "Get enumerated values variant"]
1320    #[inline(always)]
1321    pub const fn variant(&self) -> Res3Nx {
1322        match self.bits {
1323            false => Res3Nx::Res3NxNo,
1324            true => Res3Nx::Res3NxYes,
1325        }
1326    }
1327    #[doc = "The result is not rounded."]
1328    #[inline(always)]
1329    pub fn is_res3_nx_no(&self) -> bool {
1330        *self == Res3Nx::Res3NxNo
1331    }
1332    #[doc = "The result is rounded, and as a result some digits lost."]
1333    #[inline(always)]
1334    pub fn is_res3_nx_yes(&self) -> bool {
1335        *self == Res3Nx::Res3NxYes
1336    }
1337}
1338#[doc = "Field `RES3_NX` writer - RES3 IEEE Inexact Flag"]
1339pub type Res3NxW<'a, REG> = crate::BitWriter<'a, REG, Res3Nx>;
1340impl<'a, REG> Res3NxW<'a, REG>
1341where
1342    REG: crate::Writable + crate::RegisterSpec,
1343{
1344    #[doc = "The result is not rounded."]
1345    #[inline(always)]
1346    pub fn res3_nx_no(self) -> &'a mut crate::W<REG> {
1347        self.variant(Res3Nx::Res3NxNo)
1348    }
1349    #[doc = "The result is rounded, and as a result some digits lost."]
1350    #[inline(always)]
1351    pub fn res3_nx_yes(self) -> &'a mut crate::W<REG> {
1352        self.variant(Res3Nx::Res3NxYes)
1353    }
1354}
1355#[doc = "RES3 IEEE Underflow Flag\n\nValue on reset: 0"]
1356#[cfg_attr(feature = "defmt", derive(defmt::Format))]
1357#[derive(Clone, Copy, Debug, PartialEq, Eq)]
1358pub enum Res3Uf {
1359    #[doc = "0: No tiny non-zero result is detected."]
1360    Res3UfNo = 0,
1361    #[doc = "1: A tiny non-zero result is detected."]
1362    Res3UfYes = 1,
1363}
1364impl From<Res3Uf> for bool {
1365    #[inline(always)]
1366    fn from(variant: Res3Uf) -> Self {
1367        variant as u8 != 0
1368    }
1369}
1370#[doc = "Field `RES3_UF` reader - RES3 IEEE Underflow Flag"]
1371pub type Res3UfR = crate::BitReader<Res3Uf>;
1372impl Res3UfR {
1373    #[doc = "Get enumerated values variant"]
1374    #[inline(always)]
1375    pub const fn variant(&self) -> Res3Uf {
1376        match self.bits {
1377            false => Res3Uf::Res3UfNo,
1378            true => Res3Uf::Res3UfYes,
1379        }
1380    }
1381    #[doc = "No tiny non-zero result is detected."]
1382    #[inline(always)]
1383    pub fn is_res3_uf_no(&self) -> bool {
1384        *self == Res3Uf::Res3UfNo
1385    }
1386    #[doc = "A tiny non-zero result is detected."]
1387    #[inline(always)]
1388    pub fn is_res3_uf_yes(&self) -> bool {
1389        *self == Res3Uf::Res3UfYes
1390    }
1391}
1392#[doc = "Field `RES3_UF` writer - RES3 IEEE Underflow Flag"]
1393pub type Res3UfW<'a, REG> = crate::BitWriter<'a, REG, Res3Uf>;
1394impl<'a, REG> Res3UfW<'a, REG>
1395where
1396    REG: crate::Writable + crate::RegisterSpec,
1397{
1398    #[doc = "No tiny non-zero result is detected."]
1399    #[inline(always)]
1400    pub fn res3_uf_no(self) -> &'a mut crate::W<REG> {
1401        self.variant(Res3Uf::Res3UfNo)
1402    }
1403    #[doc = "A tiny non-zero result is detected."]
1404    #[inline(always)]
1405    pub fn res3_uf_yes(self) -> &'a mut crate::W<REG> {
1406        self.variant(Res3Uf::Res3UfYes)
1407    }
1408}
1409#[doc = "RES3 IEEE Overflow Flag\n\nValue on reset: 0"]
1410#[cfg_attr(feature = "defmt", derive(defmt::Format))]
1411#[derive(Clone, Copy, Debug, PartialEq, Eq)]
1412pub enum Res3Of {
1413    #[doc = "0: The result format's largest finite number is not exceeded."]
1414    Res3OfNo = 0,
1415    #[doc = "1: The result format's largest finite number is exceeded."]
1416    Res3OfYes = 1,
1417}
1418impl From<Res3Of> for bool {
1419    #[inline(always)]
1420    fn from(variant: Res3Of) -> Self {
1421        variant as u8 != 0
1422    }
1423}
1424#[doc = "Field `RES3_OF` reader - RES3 IEEE Overflow Flag"]
1425pub type Res3OfR = crate::BitReader<Res3Of>;
1426impl Res3OfR {
1427    #[doc = "Get enumerated values variant"]
1428    #[inline(always)]
1429    pub const fn variant(&self) -> Res3Of {
1430        match self.bits {
1431            false => Res3Of::Res3OfNo,
1432            true => Res3Of::Res3OfYes,
1433        }
1434    }
1435    #[doc = "The result format's largest finite number is not exceeded."]
1436    #[inline(always)]
1437    pub fn is_res3_of_no(&self) -> bool {
1438        *self == Res3Of::Res3OfNo
1439    }
1440    #[doc = "The result format's largest finite number is exceeded."]
1441    #[inline(always)]
1442    pub fn is_res3_of_yes(&self) -> bool {
1443        *self == Res3Of::Res3OfYes
1444    }
1445}
1446#[doc = "Field `RES3_OF` writer - RES3 IEEE Overflow Flag"]
1447pub type Res3OfW<'a, REG> = crate::BitWriter<'a, REG, Res3Of>;
1448impl<'a, REG> Res3OfW<'a, REG>
1449where
1450    REG: crate::Writable + crate::RegisterSpec,
1451{
1452    #[doc = "The result format's largest finite number is not exceeded."]
1453    #[inline(always)]
1454    pub fn res3_of_no(self) -> &'a mut crate::W<REG> {
1455        self.variant(Res3Of::Res3OfNo)
1456    }
1457    #[doc = "The result format's largest finite number is exceeded."]
1458    #[inline(always)]
1459    pub fn res3_of_yes(self) -> &'a mut crate::W<REG> {
1460        self.variant(Res3Of::Res3OfYes)
1461    }
1462}
1463#[doc = "RES3 IEEE Divide by Zero Flag\n\nValue on reset: 0"]
1464#[cfg_attr(feature = "defmt", derive(defmt::Format))]
1465#[derive(Clone, Copy, Debug, PartialEq, Eq)]
1466pub enum Res3Dz {
1467    #[doc = "0: No exact infinite result is defined for an operation on finite operands."]
1468    Res3DzNo = 0,
1469    #[doc = "1: An exact infinite result is defined for an operation on finite operands."]
1470    Res3DzYes = 1,
1471}
1472impl From<Res3Dz> for bool {
1473    #[inline(always)]
1474    fn from(variant: Res3Dz) -> Self {
1475        variant as u8 != 0
1476    }
1477}
1478#[doc = "Field `RES3_DZ` reader - RES3 IEEE Divide by Zero Flag"]
1479pub type Res3DzR = crate::BitReader<Res3Dz>;
1480impl Res3DzR {
1481    #[doc = "Get enumerated values variant"]
1482    #[inline(always)]
1483    pub const fn variant(&self) -> Res3Dz {
1484        match self.bits {
1485            false => Res3Dz::Res3DzNo,
1486            true => Res3Dz::Res3DzYes,
1487        }
1488    }
1489    #[doc = "No exact infinite result is defined for an operation on finite operands."]
1490    #[inline(always)]
1491    pub fn is_res3_dz_no(&self) -> bool {
1492        *self == Res3Dz::Res3DzNo
1493    }
1494    #[doc = "An exact infinite result is defined for an operation on finite operands."]
1495    #[inline(always)]
1496    pub fn is_res3_dz_yes(&self) -> bool {
1497        *self == Res3Dz::Res3DzYes
1498    }
1499}
1500#[doc = "Field `RES3_DZ` writer - RES3 IEEE Divide by Zero Flag"]
1501pub type Res3DzW<'a, REG> = crate::BitWriter<'a, REG, Res3Dz>;
1502impl<'a, REG> Res3DzW<'a, REG>
1503where
1504    REG: crate::Writable + crate::RegisterSpec,
1505{
1506    #[doc = "No exact infinite result is defined for an operation on finite operands."]
1507    #[inline(always)]
1508    pub fn res3_dz_no(self) -> &'a mut crate::W<REG> {
1509        self.variant(Res3Dz::Res3DzNo)
1510    }
1511    #[doc = "An exact infinite result is defined for an operation on finite operands."]
1512    #[inline(always)]
1513    pub fn res3_dz_yes(self) -> &'a mut crate::W<REG> {
1514        self.variant(Res3Dz::Res3DzYes)
1515    }
1516}
1517#[doc = "RES3 IEEE Invalid Flag\n\nValue on reset: 0"]
1518#[cfg_attr(feature = "defmt", derive(defmt::Format))]
1519#[derive(Clone, Copy, Debug, PartialEq, Eq)]
1520pub enum Res3Nv {
1521    #[doc = "0: There is usefully definable result."]
1522    Res3NvNo = 0,
1523    #[doc = "1: There is no usefully definable result."]
1524    Res3NvYes = 1,
1525}
1526impl From<Res3Nv> for bool {
1527    #[inline(always)]
1528    fn from(variant: Res3Nv) -> Self {
1529        variant as u8 != 0
1530    }
1531}
1532#[doc = "Field `RES3_NV` reader - RES3 IEEE Invalid Flag"]
1533pub type Res3NvR = crate::BitReader<Res3Nv>;
1534impl Res3NvR {
1535    #[doc = "Get enumerated values variant"]
1536    #[inline(always)]
1537    pub const fn variant(&self) -> Res3Nv {
1538        match self.bits {
1539            false => Res3Nv::Res3NvNo,
1540            true => Res3Nv::Res3NvYes,
1541        }
1542    }
1543    #[doc = "There is usefully definable result."]
1544    #[inline(always)]
1545    pub fn is_res3_nv_no(&self) -> bool {
1546        *self == Res3Nv::Res3NvNo
1547    }
1548    #[doc = "There is no usefully definable result."]
1549    #[inline(always)]
1550    pub fn is_res3_nv_yes(&self) -> bool {
1551        *self == Res3Nv::Res3NvYes
1552    }
1553}
1554#[doc = "Field `RES3_NV` writer - RES3 IEEE Invalid Flag"]
1555pub type Res3NvW<'a, REG> = crate::BitWriter<'a, REG, Res3Nv>;
1556impl<'a, REG> Res3NvW<'a, REG>
1557where
1558    REG: crate::Writable + crate::RegisterSpec,
1559{
1560    #[doc = "There is usefully definable result."]
1561    #[inline(always)]
1562    pub fn res3_nv_no(self) -> &'a mut crate::W<REG> {
1563        self.variant(Res3Nv::Res3NvNo)
1564    }
1565    #[doc = "There is no usefully definable result."]
1566    #[inline(always)]
1567    pub fn res3_nv_yes(self) -> &'a mut crate::W<REG> {
1568        self.variant(Res3Nv::Res3NvYes)
1569    }
1570}
1571#[doc = "RES3 Indirect Operation Error Flag\n\nValue on reset: 0"]
1572#[cfg_attr(feature = "defmt", derive(defmt::Format))]
1573#[derive(Clone, Copy, Debug, PartialEq, Eq)]
1574pub enum Res3Err {
1575    #[doc = "0: No invalid indirect operation is detected."]
1576    Res3ErrNo = 0,
1577    #[doc = "1: An invalid indirect operation error is detected."]
1578    Res3ErrYes = 1,
1579}
1580impl From<Res3Err> for bool {
1581    #[inline(always)]
1582    fn from(variant: Res3Err) -> Self {
1583        variant as u8 != 0
1584    }
1585}
1586#[doc = "Field `RES3_ERR` reader - RES3 Indirect Operation Error Flag"]
1587pub type Res3ErrR = crate::BitReader<Res3Err>;
1588impl Res3ErrR {
1589    #[doc = "Get enumerated values variant"]
1590    #[inline(always)]
1591    pub const fn variant(&self) -> Res3Err {
1592        match self.bits {
1593            false => Res3Err::Res3ErrNo,
1594            true => Res3Err::Res3ErrYes,
1595        }
1596    }
1597    #[doc = "No invalid indirect operation is detected."]
1598    #[inline(always)]
1599    pub fn is_res3_err_no(&self) -> bool {
1600        *self == Res3Err::Res3ErrNo
1601    }
1602    #[doc = "An invalid indirect operation error is detected."]
1603    #[inline(always)]
1604    pub fn is_res3_err_yes(&self) -> bool {
1605        *self == Res3Err::Res3ErrYes
1606    }
1607}
1608#[doc = "Field `RES3_ERR` writer - RES3 Indirect Operation Error Flag"]
1609pub type Res3ErrW<'a, REG> = crate::BitWriter<'a, REG, Res3Err>;
1610impl<'a, REG> Res3ErrW<'a, REG>
1611where
1612    REG: crate::Writable + crate::RegisterSpec,
1613{
1614    #[doc = "No invalid indirect operation is detected."]
1615    #[inline(always)]
1616    pub fn res3_err_no(self) -> &'a mut crate::W<REG> {
1617        self.variant(Res3Err::Res3ErrNo)
1618    }
1619    #[doc = "An invalid indirect operation error is detected."]
1620    #[inline(always)]
1621    pub fn res3_err_yes(self) -> &'a mut crate::W<REG> {
1622        self.variant(Res3Err::Res3ErrYes)
1623    }
1624}
1625#[doc = "RES3 Overwrite Flag\n\nValue on reset: 0"]
1626#[cfg_attr(feature = "defmt", derive(defmt::Format))]
1627#[derive(Clone, Copy, Debug, PartialEq, Eq)]
1628pub enum Res3Ovwr {
1629    #[doc = "0: The value of RES3 has been read."]
1630    Res3OvwrNo = 0,
1631    #[doc = "1: The value of RES3 has not been read yet and is overwritten by a new MAUWRAP result."]
1632    Res3OvwrYes = 1,
1633}
1634impl From<Res3Ovwr> for bool {
1635    #[inline(always)]
1636    fn from(variant: Res3Ovwr) -> Self {
1637        variant as u8 != 0
1638    }
1639}
1640#[doc = "Field `RES3_OVWR` reader - RES3 Overwrite Flag"]
1641pub type Res3OvwrR = crate::BitReader<Res3Ovwr>;
1642impl Res3OvwrR {
1643    #[doc = "Get enumerated values variant"]
1644    #[inline(always)]
1645    pub const fn variant(&self) -> Res3Ovwr {
1646        match self.bits {
1647            false => Res3Ovwr::Res3OvwrNo,
1648            true => Res3Ovwr::Res3OvwrYes,
1649        }
1650    }
1651    #[doc = "The value of RES3 has been read."]
1652    #[inline(always)]
1653    pub fn is_res3_ovwr_no(&self) -> bool {
1654        *self == Res3Ovwr::Res3OvwrNo
1655    }
1656    #[doc = "The value of RES3 has not been read yet and is overwritten by a new MAUWRAP result."]
1657    #[inline(always)]
1658    pub fn is_res3_ovwr_yes(&self) -> bool {
1659        *self == Res3Ovwr::Res3OvwrYes
1660    }
1661}
1662#[doc = "Field `RES3_OVWR` writer - RES3 Overwrite Flag"]
1663pub type Res3OvwrW<'a, REG> = crate::BitWriter<'a, REG, Res3Ovwr>;
1664impl<'a, REG> Res3OvwrW<'a, REG>
1665where
1666    REG: crate::Writable + crate::RegisterSpec,
1667{
1668    #[doc = "The value of RES3 has been read."]
1669    #[inline(always)]
1670    pub fn res3_ovwr_no(self) -> &'a mut crate::W<REG> {
1671        self.variant(Res3Ovwr::Res3OvwrNo)
1672    }
1673    #[doc = "The value of RES3 has not been read yet and is overwritten by a new MAUWRAP result."]
1674    #[inline(always)]
1675    pub fn res3_ovwr_yes(self) -> &'a mut crate::W<REG> {
1676        self.variant(Res3Ovwr::Res3OvwrYes)
1677    }
1678}
1679#[doc = "RES3 Full Flag\n\nValue on reset: 0"]
1680#[cfg_attr(feature = "defmt", derive(defmt::Format))]
1681#[derive(Clone, Copy, Debug, PartialEq, Eq)]
1682pub enum Res3Full {
1683    #[doc = "0: RES3 has not updated and cannot be read."]
1684    Res3FullNo = 0,
1685    #[doc = "1: RES3 has updated and can be read."]
1686    Res3FullYes = 1,
1687}
1688impl From<Res3Full> for bool {
1689    #[inline(always)]
1690    fn from(variant: Res3Full) -> Self {
1691        variant as u8 != 0
1692    }
1693}
1694#[doc = "Field `RES3_FULL` reader - RES3 Full Flag"]
1695pub type Res3FullR = crate::BitReader<Res3Full>;
1696impl Res3FullR {
1697    #[doc = "Get enumerated values variant"]
1698    #[inline(always)]
1699    pub const fn variant(&self) -> Res3Full {
1700        match self.bits {
1701            false => Res3Full::Res3FullNo,
1702            true => Res3Full::Res3FullYes,
1703        }
1704    }
1705    #[doc = "RES3 has not updated and cannot be read."]
1706    #[inline(always)]
1707    pub fn is_res3_full_no(&self) -> bool {
1708        *self == Res3Full::Res3FullNo
1709    }
1710    #[doc = "RES3 has updated and can be read."]
1711    #[inline(always)]
1712    pub fn is_res3_full_yes(&self) -> bool {
1713        *self == Res3Full::Res3FullYes
1714    }
1715}
1716#[doc = "Field `RES3_FULL` writer - RES3 Full Flag"]
1717pub type Res3FullW<'a, REG> = crate::BitWriter<'a, REG, Res3Full>;
1718impl<'a, REG> Res3FullW<'a, REG>
1719where
1720    REG: crate::Writable + crate::RegisterSpec,
1721{
1722    #[doc = "RES3 has not updated and cannot be read."]
1723    #[inline(always)]
1724    pub fn res3_full_no(self) -> &'a mut crate::W<REG> {
1725        self.variant(Res3Full::Res3FullNo)
1726    }
1727    #[doc = "RES3 has updated and can be read."]
1728    #[inline(always)]
1729    pub fn res3_full_yes(self) -> &'a mut crate::W<REG> {
1730        self.variant(Res3Full::Res3FullYes)
1731    }
1732}
1733impl R {
1734    #[doc = "Bit 0 - RES0 IEEE Inexact Flag"]
1735    #[inline(always)]
1736    pub fn res0_nx(&self) -> Res0NxR {
1737        Res0NxR::new((self.bits & 1) != 0)
1738    }
1739    #[doc = "Bit 1 - RES0 IEEE Underflow Flag"]
1740    #[inline(always)]
1741    pub fn res0_uf(&self) -> Res0UfR {
1742        Res0UfR::new(((self.bits >> 1) & 1) != 0)
1743    }
1744    #[doc = "Bit 2 - RES0 IEEE Overflow Flag"]
1745    #[inline(always)]
1746    pub fn res0_of(&self) -> Res0OfR {
1747        Res0OfR::new(((self.bits >> 2) & 1) != 0)
1748    }
1749    #[doc = "Bit 3 - RES0 IEEE Divide by Zero Flag"]
1750    #[inline(always)]
1751    pub fn res0_dz(&self) -> Res0DzR {
1752        Res0DzR::new(((self.bits >> 3) & 1) != 0)
1753    }
1754    #[doc = "Bit 4 - RES0 IEEE Invalid Flag"]
1755    #[inline(always)]
1756    pub fn res0_nv(&self) -> Res0NvR {
1757        Res0NvR::new(((self.bits >> 4) & 1) != 0)
1758    }
1759    #[doc = "Bit 5 - RES0 Indirect Operation Error Flag"]
1760    #[inline(always)]
1761    pub fn res0_err(&self) -> Res0ErrR {
1762        Res0ErrR::new(((self.bits >> 5) & 1) != 0)
1763    }
1764    #[doc = "Bit 6 - RES0 Overwrite Flag"]
1765    #[inline(always)]
1766    pub fn res0_ovwr(&self) -> Res0OvwrR {
1767        Res0OvwrR::new(((self.bits >> 6) & 1) != 0)
1768    }
1769    #[doc = "Bit 7 - RES0 Full Flag"]
1770    #[inline(always)]
1771    pub fn res0_full(&self) -> Res0FullR {
1772        Res0FullR::new(((self.bits >> 7) & 1) != 0)
1773    }
1774    #[doc = "Bit 8 - RES1 IEEE Inexact Flag"]
1775    #[inline(always)]
1776    pub fn res1_nx(&self) -> Res1NxR {
1777        Res1NxR::new(((self.bits >> 8) & 1) != 0)
1778    }
1779    #[doc = "Bit 9 - RES1 IEEE Underflow Flag"]
1780    #[inline(always)]
1781    pub fn res1_uf(&self) -> Res1UfR {
1782        Res1UfR::new(((self.bits >> 9) & 1) != 0)
1783    }
1784    #[doc = "Bit 10 - RES1 IEEE Overflow Flag"]
1785    #[inline(always)]
1786    pub fn res1_of(&self) -> Res1OfR {
1787        Res1OfR::new(((self.bits >> 10) & 1) != 0)
1788    }
1789    #[doc = "Bit 11 - RES1 IEEE Divide by Zero Flag"]
1790    #[inline(always)]
1791    pub fn res1_dz(&self) -> Res1DzR {
1792        Res1DzR::new(((self.bits >> 11) & 1) != 0)
1793    }
1794    #[doc = "Bit 12 - RES1 IEEE Invalid Flag"]
1795    #[inline(always)]
1796    pub fn res1_nv(&self) -> Res1NvR {
1797        Res1NvR::new(((self.bits >> 12) & 1) != 0)
1798    }
1799    #[doc = "Bit 13 - RES1 Indirect Operation Error Flag"]
1800    #[inline(always)]
1801    pub fn res1_err(&self) -> Res1ErrR {
1802        Res1ErrR::new(((self.bits >> 13) & 1) != 0)
1803    }
1804    #[doc = "Bit 14 - RES1 Overwrite Flag"]
1805    #[inline(always)]
1806    pub fn res1_ovwr(&self) -> Res1OvwrR {
1807        Res1OvwrR::new(((self.bits >> 14) & 1) != 0)
1808    }
1809    #[doc = "Bit 15 - RES1 Full Flag"]
1810    #[inline(always)]
1811    pub fn res1_full(&self) -> Res1FullR {
1812        Res1FullR::new(((self.bits >> 15) & 1) != 0)
1813    }
1814    #[doc = "Bit 16 - RES2 IEEE Inexact Flag"]
1815    #[inline(always)]
1816    pub fn res2_nx(&self) -> Res2NxR {
1817        Res2NxR::new(((self.bits >> 16) & 1) != 0)
1818    }
1819    #[doc = "Bit 17 - RES2 IEEE Underflow Flag"]
1820    #[inline(always)]
1821    pub fn res2_uf(&self) -> Res2UfR {
1822        Res2UfR::new(((self.bits >> 17) & 1) != 0)
1823    }
1824    #[doc = "Bit 18 - RES2 IEEE Overflow Flag"]
1825    #[inline(always)]
1826    pub fn res2_of(&self) -> Res2OfR {
1827        Res2OfR::new(((self.bits >> 18) & 1) != 0)
1828    }
1829    #[doc = "Bit 19 - RES2 IEEE Divide by Zero Flag"]
1830    #[inline(always)]
1831    pub fn res2_dz(&self) -> Res2DzR {
1832        Res2DzR::new(((self.bits >> 19) & 1) != 0)
1833    }
1834    #[doc = "Bit 20 - RES2 IEEE Invalid Flag"]
1835    #[inline(always)]
1836    pub fn res2_nv(&self) -> Res2NvR {
1837        Res2NvR::new(((self.bits >> 20) & 1) != 0)
1838    }
1839    #[doc = "Bit 21 - RES2 Indirect Operation Error Flag"]
1840    #[inline(always)]
1841    pub fn res2_err(&self) -> Res2ErrR {
1842        Res2ErrR::new(((self.bits >> 21) & 1) != 0)
1843    }
1844    #[doc = "Bit 22 - RES2 Overwrite Flag"]
1845    #[inline(always)]
1846    pub fn res2_ovwr(&self) -> Res2OvwrR {
1847        Res2OvwrR::new(((self.bits >> 22) & 1) != 0)
1848    }
1849    #[doc = "Bit 23 - RES2 Full Flag"]
1850    #[inline(always)]
1851    pub fn res2_full(&self) -> Res2FullR {
1852        Res2FullR::new(((self.bits >> 23) & 1) != 0)
1853    }
1854    #[doc = "Bit 24 - RES3 IEEE Inexact Flag"]
1855    #[inline(always)]
1856    pub fn res3_nx(&self) -> Res3NxR {
1857        Res3NxR::new(((self.bits >> 24) & 1) != 0)
1858    }
1859    #[doc = "Bit 25 - RES3 IEEE Underflow Flag"]
1860    #[inline(always)]
1861    pub fn res3_uf(&self) -> Res3UfR {
1862        Res3UfR::new(((self.bits >> 25) & 1) != 0)
1863    }
1864    #[doc = "Bit 26 - RES3 IEEE Overflow Flag"]
1865    #[inline(always)]
1866    pub fn res3_of(&self) -> Res3OfR {
1867        Res3OfR::new(((self.bits >> 26) & 1) != 0)
1868    }
1869    #[doc = "Bit 27 - RES3 IEEE Divide by Zero Flag"]
1870    #[inline(always)]
1871    pub fn res3_dz(&self) -> Res3DzR {
1872        Res3DzR::new(((self.bits >> 27) & 1) != 0)
1873    }
1874    #[doc = "Bit 28 - RES3 IEEE Invalid Flag"]
1875    #[inline(always)]
1876    pub fn res3_nv(&self) -> Res3NvR {
1877        Res3NvR::new(((self.bits >> 28) & 1) != 0)
1878    }
1879    #[doc = "Bit 29 - RES3 Indirect Operation Error Flag"]
1880    #[inline(always)]
1881    pub fn res3_err(&self) -> Res3ErrR {
1882        Res3ErrR::new(((self.bits >> 29) & 1) != 0)
1883    }
1884    #[doc = "Bit 30 - RES3 Overwrite Flag"]
1885    #[inline(always)]
1886    pub fn res3_ovwr(&self) -> Res3OvwrR {
1887        Res3OvwrR::new(((self.bits >> 30) & 1) != 0)
1888    }
1889    #[doc = "Bit 31 - RES3 Full Flag"]
1890    #[inline(always)]
1891    pub fn res3_full(&self) -> Res3FullR {
1892        Res3FullR::new(((self.bits >> 31) & 1) != 0)
1893    }
1894}
1895#[cfg(feature = "debug")]
1896impl core::fmt::Debug for R {
1897    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1898        f.debug_struct("RES_STATUS")
1899            .field("res0_nx", &self.res0_nx())
1900            .field("res0_uf", &self.res0_uf())
1901            .field("res0_of", &self.res0_of())
1902            .field("res0_dz", &self.res0_dz())
1903            .field("res0_nv", &self.res0_nv())
1904            .field("res0_err", &self.res0_err())
1905            .field("res0_ovwr", &self.res0_ovwr())
1906            .field("res0_full", &self.res0_full())
1907            .field("res1_nx", &self.res1_nx())
1908            .field("res1_uf", &self.res1_uf())
1909            .field("res1_of", &self.res1_of())
1910            .field("res1_dz", &self.res1_dz())
1911            .field("res1_nv", &self.res1_nv())
1912            .field("res1_err", &self.res1_err())
1913            .field("res1_ovwr", &self.res1_ovwr())
1914            .field("res1_full", &self.res1_full())
1915            .field("res2_nx", &self.res2_nx())
1916            .field("res2_uf", &self.res2_uf())
1917            .field("res2_of", &self.res2_of())
1918            .field("res2_dz", &self.res2_dz())
1919            .field("res2_nv", &self.res2_nv())
1920            .field("res2_err", &self.res2_err())
1921            .field("res2_ovwr", &self.res2_ovwr())
1922            .field("res2_full", &self.res2_full())
1923            .field("res3_nx", &self.res3_nx())
1924            .field("res3_uf", &self.res3_uf())
1925            .field("res3_of", &self.res3_of())
1926            .field("res3_dz", &self.res3_dz())
1927            .field("res3_nv", &self.res3_nv())
1928            .field("res3_err", &self.res3_err())
1929            .field("res3_ovwr", &self.res3_ovwr())
1930            .field("res3_full", &self.res3_full())
1931            .finish()
1932    }
1933}
1934impl W {
1935    #[doc = "Bit 0 - RES0 IEEE Inexact Flag"]
1936    #[inline(always)]
1937    pub fn res0_nx(&mut self) -> Res0NxW<'_, ResStatusSpec> {
1938        Res0NxW::new(self, 0)
1939    }
1940    #[doc = "Bit 1 - RES0 IEEE Underflow Flag"]
1941    #[inline(always)]
1942    pub fn res0_uf(&mut self) -> Res0UfW<'_, ResStatusSpec> {
1943        Res0UfW::new(self, 1)
1944    }
1945    #[doc = "Bit 2 - RES0 IEEE Overflow Flag"]
1946    #[inline(always)]
1947    pub fn res0_of(&mut self) -> Res0OfW<'_, ResStatusSpec> {
1948        Res0OfW::new(self, 2)
1949    }
1950    #[doc = "Bit 3 - RES0 IEEE Divide by Zero Flag"]
1951    #[inline(always)]
1952    pub fn res0_dz(&mut self) -> Res0DzW<'_, ResStatusSpec> {
1953        Res0DzW::new(self, 3)
1954    }
1955    #[doc = "Bit 4 - RES0 IEEE Invalid Flag"]
1956    #[inline(always)]
1957    pub fn res0_nv(&mut self) -> Res0NvW<'_, ResStatusSpec> {
1958        Res0NvW::new(self, 4)
1959    }
1960    #[doc = "Bit 5 - RES0 Indirect Operation Error Flag"]
1961    #[inline(always)]
1962    pub fn res0_err(&mut self) -> Res0ErrW<'_, ResStatusSpec> {
1963        Res0ErrW::new(self, 5)
1964    }
1965    #[doc = "Bit 6 - RES0 Overwrite Flag"]
1966    #[inline(always)]
1967    pub fn res0_ovwr(&mut self) -> Res0OvwrW<'_, ResStatusSpec> {
1968        Res0OvwrW::new(self, 6)
1969    }
1970    #[doc = "Bit 7 - RES0 Full Flag"]
1971    #[inline(always)]
1972    pub fn res0_full(&mut self) -> Res0FullW<'_, ResStatusSpec> {
1973        Res0FullW::new(self, 7)
1974    }
1975    #[doc = "Bit 8 - RES1 IEEE Inexact Flag"]
1976    #[inline(always)]
1977    pub fn res1_nx(&mut self) -> Res1NxW<'_, ResStatusSpec> {
1978        Res1NxW::new(self, 8)
1979    }
1980    #[doc = "Bit 9 - RES1 IEEE Underflow Flag"]
1981    #[inline(always)]
1982    pub fn res1_uf(&mut self) -> Res1UfW<'_, ResStatusSpec> {
1983        Res1UfW::new(self, 9)
1984    }
1985    #[doc = "Bit 10 - RES1 IEEE Overflow Flag"]
1986    #[inline(always)]
1987    pub fn res1_of(&mut self) -> Res1OfW<'_, ResStatusSpec> {
1988        Res1OfW::new(self, 10)
1989    }
1990    #[doc = "Bit 11 - RES1 IEEE Divide by Zero Flag"]
1991    #[inline(always)]
1992    pub fn res1_dz(&mut self) -> Res1DzW<'_, ResStatusSpec> {
1993        Res1DzW::new(self, 11)
1994    }
1995    #[doc = "Bit 12 - RES1 IEEE Invalid Flag"]
1996    #[inline(always)]
1997    pub fn res1_nv(&mut self) -> Res1NvW<'_, ResStatusSpec> {
1998        Res1NvW::new(self, 12)
1999    }
2000    #[doc = "Bit 13 - RES1 Indirect Operation Error Flag"]
2001    #[inline(always)]
2002    pub fn res1_err(&mut self) -> Res1ErrW<'_, ResStatusSpec> {
2003        Res1ErrW::new(self, 13)
2004    }
2005    #[doc = "Bit 14 - RES1 Overwrite Flag"]
2006    #[inline(always)]
2007    pub fn res1_ovwr(&mut self) -> Res1OvwrW<'_, ResStatusSpec> {
2008        Res1OvwrW::new(self, 14)
2009    }
2010    #[doc = "Bit 15 - RES1 Full Flag"]
2011    #[inline(always)]
2012    pub fn res1_full(&mut self) -> Res1FullW<'_, ResStatusSpec> {
2013        Res1FullW::new(self, 15)
2014    }
2015    #[doc = "Bit 16 - RES2 IEEE Inexact Flag"]
2016    #[inline(always)]
2017    pub fn res2_nx(&mut self) -> Res2NxW<'_, ResStatusSpec> {
2018        Res2NxW::new(self, 16)
2019    }
2020    #[doc = "Bit 17 - RES2 IEEE Underflow Flag"]
2021    #[inline(always)]
2022    pub fn res2_uf(&mut self) -> Res2UfW<'_, ResStatusSpec> {
2023        Res2UfW::new(self, 17)
2024    }
2025    #[doc = "Bit 18 - RES2 IEEE Overflow Flag"]
2026    #[inline(always)]
2027    pub fn res2_of(&mut self) -> Res2OfW<'_, ResStatusSpec> {
2028        Res2OfW::new(self, 18)
2029    }
2030    #[doc = "Bit 19 - RES2 IEEE Divide by Zero Flag"]
2031    #[inline(always)]
2032    pub fn res2_dz(&mut self) -> Res2DzW<'_, ResStatusSpec> {
2033        Res2DzW::new(self, 19)
2034    }
2035    #[doc = "Bit 20 - RES2 IEEE Invalid Flag"]
2036    #[inline(always)]
2037    pub fn res2_nv(&mut self) -> Res2NvW<'_, ResStatusSpec> {
2038        Res2NvW::new(self, 20)
2039    }
2040    #[doc = "Bit 21 - RES2 Indirect Operation Error Flag"]
2041    #[inline(always)]
2042    pub fn res2_err(&mut self) -> Res2ErrW<'_, ResStatusSpec> {
2043        Res2ErrW::new(self, 21)
2044    }
2045    #[doc = "Bit 22 - RES2 Overwrite Flag"]
2046    #[inline(always)]
2047    pub fn res2_ovwr(&mut self) -> Res2OvwrW<'_, ResStatusSpec> {
2048        Res2OvwrW::new(self, 22)
2049    }
2050    #[doc = "Bit 23 - RES2 Full Flag"]
2051    #[inline(always)]
2052    pub fn res2_full(&mut self) -> Res2FullW<'_, ResStatusSpec> {
2053        Res2FullW::new(self, 23)
2054    }
2055    #[doc = "Bit 24 - RES3 IEEE Inexact Flag"]
2056    #[inline(always)]
2057    pub fn res3_nx(&mut self) -> Res3NxW<'_, ResStatusSpec> {
2058        Res3NxW::new(self, 24)
2059    }
2060    #[doc = "Bit 25 - RES3 IEEE Underflow Flag"]
2061    #[inline(always)]
2062    pub fn res3_uf(&mut self) -> Res3UfW<'_, ResStatusSpec> {
2063        Res3UfW::new(self, 25)
2064    }
2065    #[doc = "Bit 26 - RES3 IEEE Overflow Flag"]
2066    #[inline(always)]
2067    pub fn res3_of(&mut self) -> Res3OfW<'_, ResStatusSpec> {
2068        Res3OfW::new(self, 26)
2069    }
2070    #[doc = "Bit 27 - RES3 IEEE Divide by Zero Flag"]
2071    #[inline(always)]
2072    pub fn res3_dz(&mut self) -> Res3DzW<'_, ResStatusSpec> {
2073        Res3DzW::new(self, 27)
2074    }
2075    #[doc = "Bit 28 - RES3 IEEE Invalid Flag"]
2076    #[inline(always)]
2077    pub fn res3_nv(&mut self) -> Res3NvW<'_, ResStatusSpec> {
2078        Res3NvW::new(self, 28)
2079    }
2080    #[doc = "Bit 29 - RES3 Indirect Operation Error Flag"]
2081    #[inline(always)]
2082    pub fn res3_err(&mut self) -> Res3ErrW<'_, ResStatusSpec> {
2083        Res3ErrW::new(self, 29)
2084    }
2085    #[doc = "Bit 30 - RES3 Overwrite Flag"]
2086    #[inline(always)]
2087    pub fn res3_ovwr(&mut self) -> Res3OvwrW<'_, ResStatusSpec> {
2088        Res3OvwrW::new(self, 30)
2089    }
2090    #[doc = "Bit 31 - RES3 Full Flag"]
2091    #[inline(always)]
2092    pub fn res3_full(&mut self) -> Res3FullW<'_, ResStatusSpec> {
2093        Res3FullW::new(self, 31)
2094    }
2095}
2096#[doc = "Result Status\n\nYou can [`read`](crate::Reg::read) this register and get [`res_status::R`](R). You can [`reset`](crate::Reg::reset), [`write`](crate::Reg::write), [`write_with_zero`](crate::Reg::write_with_zero) this register using [`res_status::W`](W). You can also [`modify`](crate::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
2097pub struct ResStatusSpec;
2098impl crate::RegisterSpec for ResStatusSpec {
2099    type Ux = u32;
2100}
2101#[doc = "`read()` method returns [`res_status::R`](R) reader structure"]
2102impl crate::Readable for ResStatusSpec {}
2103#[doc = "`write(|w| ..)` method takes [`res_status::W`](W) writer structure"]
2104impl crate::Writable for ResStatusSpec {
2105    type Safety = crate::Unsafe;
2106}
2107#[doc = "`reset()` method sets RES_STATUS to value 0"]
2108impl crate::Resettable for ResStatusSpec {}
mcxa_pac/mau0/res_status.rs

mcxa_pac/mau0/
res_status.rs
