flag_ok

src/durandal/err.rs

@@ -13,6 +13,15 @@ macro_rules! ok {
    };
 }
 
+macro_rules! flag_ok {
+   ($t:ident, $v:expr) => {
+      match $t::from_bits($v) {
+         Some(v) => Ok(v),
+         None => Err(err_msg(concat!("bad ", stringify!($t)))),
+      }
+   };
+}
+
 macro_rules! bail {
    ($e:expr) => {
       return Err(err_msg($e));

src/marathon/map.rs

@@ -16,9 +16,9 @@ pub fn read_minf(b: &[u8]) -> ResultS<Minf>
       ent_flag = u32[84];
    }
 
-   let msn_flag = ok!(MsnFlags::from_bits(msn_flag), "bad MsnFlags")?;
-   let env_flag = ok!(EnvFlags::from_bits(env_flag), "bad EnvFlags")?;
-   let ent_flag = ok!(EntFlags::from_bits(ent_flag), "bad EntFlags")?;
+   let msn_flag = flag_ok!(MsnFlags, msn_flag)?;
+   let env_flag = flag_ok!(EnvFlags, env_flag)?;
+   let ent_flag = flag_ok!(EntFlags, ent_flag)?;
    Ok(Minf{env_code, physi_id, music_id, msn_flag, env_flag, ent_flag,
            levelnam})
 }
@@ -89,7 +89,7 @@ pub fn read_lins(b: &[u8]) -> ResultS<(Line, usize)>
       poly_bk = OptShort[18];
    }
 
-   let flags   = ok!(LineFlags::from_bits(flags), "bad LineFlags")?;
+   let flags = flag_ok!(LineFlags, flags)?;
 
    Ok((Line{flags, pnt_beg, pnt_end, side_fr, side_bk, poly_fr, poly_bk}, 32))
 }
@@ -111,7 +111,7 @@ pub fn read_sids(b: &[u8]) -> ResultS<(Side, usize)>
       shade    = Fixed[48];
    }
 
-   let flags    = ok!(SideFlags::from_bits(flags), "bad SideFlags")?;
+   let flags    = flag_ok!(SideFlags, flags)?;
    let xfer_pri = TransferMode::from_repr(xfer_pri)?;
    let xfer_sec = TransferMode::from_repr(xfer_sec)?;
    let xfer_tra = TransferMode::from_repr(xfer_tra)?;
@@ -169,7 +169,7 @@ pub fn read_lite(b: &[u8]) -> ResultS<(Light, usize)>
       tag     = u16[90];
    }
 
-   let flags = ok!(LightFlags::from_bits(flags), "bad LightFlags")?;
+   let flags = flag_ok!(LightFlags, flags)?;
    let ltype = LightType::from_repr(ltype)?;
 
    Ok((Light{ltype, flags, phase, act_pri, act_sec, act_mid, ina_pri, ina_sec,
@@ -193,7 +193,7 @@ pub fn read_objs(b: &[u8]) -> ResultS<(Object, usize)>
    let bias  = flags & 0xF0_00;
    let flags = flags & 0x0F_FF;
    let bias  = bias >> 12;
-   let flags = ok!(ObjectFlags::from_bits(flags), "bad ObjectFlags")?;
+   let flags = flag_ok!(ObjectFlags, flags)?;
 
    Ok((Object{group, index, angle, poly, pos_x, pos_y, pos_z, flags, bias}, 16))
 }

src/marathon/phy.rs

@@ -52,7 +52,7 @@ pub fn read_fxpx(b: &[u8]) -> ResultS<(Effect, usize)>
       delay_snd  = OptShort[12];
    }
 
-   let flags = ok!(EffectFlags::from_bits(flags), "bad EffectFlags")?;
+   let flags = flag_ok!(EffectFlags, flags)?;
 
    Ok((Effect{collection, shape, pitch, flags, delay, delay_snd}, 14))
 }

src/marathon/shp.rs

@@ -62,7 +62,7 @@ fn bitmap(b: &[u8]) -> ResultS<Bitmap>
    }
 
    let compr = compr == u16::max_value();
-   let flags = ok!(BmpFlags::from_bits(flags), "bad BmpFlags")?;
+   let flags = flag_ok!(BmpFlags, flags)?;
    let alpha = flags.contains(BmpFlags::Transparent);
    let cmajr = flags.contains(BmpFlags::ColumnMajor);
 
@@ -131,7 +131,7 @@ fn frame(b: &[u8]) -> ResultS<Frame>
       wrl_y   = Unit[26];
    }
 
-   let flags = ok!(FrameFlags::from_bits(flags), "bad flag")?;
+   let flags = flag_ok!(FrameFlags, flags)?;
 
    Ok(Frame{flags, min_lt, bmp_ind, wrl_l, wrl_r, wrl_t, wrl_b, wrl_x, wrl_y})
 }
@@ -153,9 +153,9 @@ fn sequence(b: &[u8]) -> ResultS<Sequence>
       loop_f  = u16[58];
    }
 
-   let name    = mac_roman_conv(ok!(pascal_str(name), "bad string")?);
-   let xfer    = TransferMode::from_repr(xfer)?;
-   let v_type  = ViewType::from_repr(v_type)?;
+   let name   = mac_roman_conv(ok!(pascal_str(name), "bad string")?);
+   let xfer   = TransferMode::from_repr(xfer)?;
+   let v_type = ViewType::from_repr(v_type)?;
 
    Ok(Sequence{name, v_type, frames, ticks, key, xfer, xfer_pd, snd_beg,
                snd_key, snd_end, loop_f})

src/marathon/snd.rs

@@ -58,7 +58,7 @@ fn sound_def(b: &[u8]) -> ResultS<Option<(Vec<usize>, u16, SoundDef)>>
       grp_ofs  = u32[20] as usize;
    }
 
-   let flags  = ok!(SoundFlags::from_bits(flags), "bad SoundFlags")?;
+   let flags  = flag_ok!(SoundFlags, flags)?;
    let volume = Volume::from_repr(volume)?;
 
    if index == u16::max_value() {

src/marathon/trm.rs

@@ -16,7 +16,7 @@ fn read_group(b: &[u8], text: &[u8]) -> ResultS<Group>
    }
 
    let text  = mac_roman_conv(&text[start..start + size]);
-   let flags = ok!(GroupFlags::from_bits(flags), "bad GroupFlags")?;
+   let flags = flag_ok!(GroupFlags, flags)?;
    let ttype = GroupType::from_repr(ttype)?;
 
    Ok(Group{flags, ttype, pdata, lines, text})