#[macro_export]
macro_rules! rreil2_binop {
( $names:tt # $segs:tt # $op:ident # ( $a:expr ), ( $b:expr ) , ( $c:expr ) ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::$op(rreil_val!($names # ( $b )),rreil_val!($names # ( $c ))),
result: rreil_var!($names # ( $a ))
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $op:ident # ( $a:expr ), ( $b:expr ) , ( $c:expr ) : $c_w:tt ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::$op(rreil_val!($names # ( $b )),rreil_val!($names # ( $c ) : $c_w)),
result: rreil_var!($names # ( $a ))
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $op:ident # ( $a:expr ), ( $b:expr ) , $c:tt : $c_w:tt ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::$op(rreil_val!($names # ( $b )),rreil_val!($names # $c : $c_w)),
result: rreil_var!($names # ( $a ))
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $op:ident # ( $a:expr ), ( $b:expr ) , [ $c:tt ] : $c_w:tt ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::$op(rreil_val!($names # ( $b )),rreil_val!($names # [ $c ] : $c_w)),
result: rreil_var!($names # ( $a ))
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $op:ident # ( $a:expr ), ( $b:expr ) , ? ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::$op(rreil_val!($names # ( $b )),rreil_val!($names # ?)),
result: rreil_var!($names # ( $a ))
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $op:ident # ( $a:expr ), ( $b:expr ) : $b_w:tt , ( $c:expr ) ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::$op(rreil_val!($names # ( $b ) : $b_w),rreil_val!($names # ( $c ))),
result: rreil_var!($names # ( $a ))
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $op:ident # ( $a:expr ), ( $b:expr ) : $b_w:tt , ( $c:expr ) : $c_w:tt ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::$op(rreil_val!($names # ( $b ) : $b_w),rreil_val!($names # ( $c ) : $c_w)),
result: rreil_var!($names # ( $a ))
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $op:ident # ( $a:expr ), ( $b:expr ) : $b_w:tt , $c:tt : $c_w:tt ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::$op(rreil_val!($names # ( $b ) : $b_w),rreil_val!($names # $c : $c_w)),
result: rreil_var!($names # ( $a ))
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $op:ident # ( $a:expr ), ( $b:expr ) : $b_w:tt , [ $c:tt ] : $c_w:tt ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::$op(rreil_val!($names # ( $b ) : $b_w),rreil_val!($names # [ $c ] : $c_w)),
result: rreil_var!($names # ( $a ))
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $op:ident # ( $a:expr ), ( $b:expr ) : $b_w:tt , ? ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::$op(rreil_val!($names # ( $b ) : $b_w),rreil_val!($names # ?)),
result: rreil_var!($names # ( $a ))
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $op:ident # ( $a:expr ), $b:tt : $b_w:tt , ( $c:expr ) ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::$op(rreil_val!($names # $b : $b_w),rreil_val!($names # ( $c ))),
result: rreil_var!($names # ( $a ))
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $op:ident # ( $a:expr ), $b:tt : $b_w:tt , ( $c:expr ) : $c_w:tt ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::$op(rreil_val!($names # $b : $b_w),rreil_val!($names # ( $c ) : $c_w)),
result: rreil_var!($names # ( $a ))
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $op:ident # ( $a:expr ), $b:tt : $b_w:tt , $c:tt : $c_w:tt ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::$op(rreil_val!($names # $b : $b_w),rreil_val!($names # $c : $c_w)),
result: rreil_var!($names # ( $a ))
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $op:ident # ( $a:expr ), $b:tt : $b_w:tt , [ $c:tt ] : $c_w:tt ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::$op(rreil_val!($names # $b : $b_w),rreil_val!($names # [ $c ] : $c_w)),
result: rreil_var!($names # ( $a ))
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $op:ident # ( $a:expr ), $b:tt : $b_w:tt , ? ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::$op(rreil_val!($names # $b : $b_w),rreil_val!($names # ?)),
result: rreil_var!($names # ( $a ))
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $op:ident # ( $a:expr ), [ $b:tt ] : $b_w:tt , ( $c:expr ) ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::$op(rreil_val!($names # [ $b ] : $b_w),rreil_val!($names # ( $c ))),
result: rreil_var!($names # ( $a ))
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $op:ident # ( $a:expr ), [ $b:tt ] : $b_w:tt , ( $c:expr ) : $c_w:tt ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::$op(rreil_val!($names # [ $b ] : $b_w),rreil_val!($names # ( $c ) : $c_w)),
result: rreil_var!($names # ( $a ))
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $op:ident # ( $a:expr ), [ $b:tt ] : $b_w:tt , $c:tt : $c_w:tt ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::$op(rreil_val!($names # [ $b ] : $b_w),rreil_val!($names # $c : $c_w)),
result: rreil_var!($names # ( $a ))
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $op:ident # ( $a:expr ), [ $b:tt ] : $b_w:tt , [ $c:tt ] : $c_w:tt ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::$op(rreil_val!($names # [ $b ] : $b_w),rreil_val!($names # [ $c ] : $c_w)),
result: rreil_var!($names # ( $a ))
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $op:ident # ( $a:expr ), [ $b:tt ] : $b_w:tt , ? ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::$op(rreil_val!($names # [ $b ] : $b_w),rreil_val!($names # ?)),
result: rreil_var!($names # ( $a ))
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $op:ident # ( $a:expr ), ? , ( $c:expr ) ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::$op(rreil_val!($names # ?),rreil_val!($names # ( $c ))),
result: rreil_var!($names # ( $a ))
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $op:ident # ( $a:expr ), ? , ( $c:expr ) : $c_w:tt ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::$op(rreil_val!($names # ?),rreil_val!($names # ( $c ) : $c_w)),
result: rreil_var!($names # ( $a ))
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $op:ident # ( $a:expr ), ? , $c:tt : $c_w:tt ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::$op(rreil_val!($names # ?),rreil_val!($names # $c : $c_w)),
result: rreil_var!($names # ( $a ))
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $op:ident # ( $a:expr ), ? , [ $c:tt ] : $c_w:tt ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::$op(rreil_val!($names # ?),rreil_val!($names # [ $c ] : $c_w)),
result: rreil_var!($names # ( $a ))
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $op:ident # ( $a:expr ), ? , ? ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::$op(rreil_val!($names # ?),rreil_val!($names # ?)),
result: rreil_var!($names # ( $a ))
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $op:ident # ( $a:expr ) : $a_w:tt, ( $b:expr ) , ( $c:expr ) ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::$op(rreil_val!($names # ( $b )),rreil_val!($names # ( $c ))),
result: rreil_var!($names # ( $a ) : $a_w)
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $op:ident # ( $a:expr ) : $a_w:tt, ( $b:expr ) , ( $c:expr ) : $c_w:tt ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::$op(rreil_val!($names # ( $b )),rreil_val!($names # ( $c ) : $c_w)),
result: rreil_var!($names # ( $a ) : $a_w)
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $op:ident # ( $a:expr ) : $a_w:tt, ( $b:expr ) , $c:tt : $c_w:tt ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::$op(rreil_val!($names # ( $b )),rreil_val!($names # $c : $c_w)),
result: rreil_var!($names # ( $a ) : $a_w)
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $op:ident # ( $a:expr ) : $a_w:tt, ( $b:expr ) , [ $c:tt ] : $c_w:tt ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::$op(rreil_val!($names # ( $b )),rreil_val!($names # [ $c ] : $c_w)),
result: rreil_var!($names # ( $a ) : $a_w)
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $op:ident # ( $a:expr ) : $a_w:tt, ( $b:expr ) , ? ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::$op(rreil_val!($names # ( $b )),rreil_val!($names # ?)),
result: rreil_var!($names # ( $a ) : $a_w)
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $op:ident # ( $a:expr ) : $a_w:tt, ( $b:expr ) : $b_w:tt , ( $c:expr ) ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::$op(rreil_val!($names # ( $b ) : $b_w),rreil_val!($names # ( $c ))),
result: rreil_var!($names # ( $a ) : $a_w)
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $op:ident # ( $a:expr ) : $a_w:tt, ( $b:expr ) : $b_w:tt , ( $c:expr ) : $c_w:tt ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::$op(rreil_val!($names # ( $b ) : $b_w),rreil_val!($names # ( $c ) : $c_w)),
result: rreil_var!($names # ( $a ) : $a_w)
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $op:ident # ( $a:expr ) : $a_w:tt, ( $b:expr ) : $b_w:tt , $c:tt : $c_w:tt ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::$op(rreil_val!($names # ( $b ) : $b_w),rreil_val!($names # $c : $c_w)),
result: rreil_var!($names # ( $a ) : $a_w)
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $op:ident # ( $a:expr ) : $a_w:tt, ( $b:expr ) : $b_w:tt , [ $c:tt ] : $c_w:tt ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::$op(rreil_val!($names # ( $b ) : $b_w),rreil_val!($names # [ $c ] : $c_w)),
result: rreil_var!($names # ( $a ) : $a_w)
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $op:ident # ( $a:expr ) : $a_w:tt, ( $b:expr ) : $b_w:tt , ? ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::$op(rreil_val!($names # ( $b ) : $b_w),rreil_val!($names # ?)),
result: rreil_var!($names # ( $a ) : $a_w)
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $op:ident # ( $a:expr ) : $a_w:tt, $b:tt : $b_w:tt , ( $c:expr ) ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::$op(rreil_val!($names # $b : $b_w),rreil_val!($names # ( $c ))),
result: rreil_var!($names # ( $a ) : $a_w)
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $op:ident # ( $a:expr ) : $a_w:tt, $b:tt : $b_w:tt , ( $c:expr ) : $c_w:tt ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::$op(rreil_val!($names # $b : $b_w),rreil_val!($names # ( $c ) : $c_w)),
result: rreil_var!($names # ( $a ) : $a_w)
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $op:ident # ( $a:expr ) : $a_w:tt, $b:tt : $b_w:tt , $c:tt : $c_w:tt ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::$op(rreil_val!($names # $b : $b_w),rreil_val!($names # $c : $c_w)),
result: rreil_var!($names # ( $a ) : $a_w)
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $op:ident # ( $a:expr ) : $a_w:tt, $b:tt : $b_w:tt , [ $c:tt ] : $c_w:tt ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::$op(rreil_val!($names # $b : $b_w),rreil_val!($names # [ $c ] : $c_w)),
result: rreil_var!($names # ( $a ) : $a_w)
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $op:ident # ( $a:expr ) : $a_w:tt, $b:tt : $b_w:tt , ? ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::$op(rreil_val!($names # $b : $b_w),rreil_val!($names # ?)),
result: rreil_var!($names # ( $a ) : $a_w)
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $op:ident # ( $a:expr ) : $a_w:tt, [ $b:tt ] : $b_w:tt , ( $c:expr ) ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::$op(rreil_val!($names # [ $b ] : $b_w),rreil_val!($names # ( $c ))),
result: rreil_var!($names # ( $a ) : $a_w)
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $op:ident # ( $a:expr ) : $a_w:tt, [ $b:tt ] : $b_w:tt , ( $c:expr ) : $c_w:tt ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::$op(rreil_val!($names # [ $b ] : $b_w),rreil_val!($names # ( $c ) : $c_w)),
result: rreil_var!($names # ( $a ) : $a_w)
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $op:ident # ( $a:expr ) : $a_w:tt, [ $b:tt ] : $b_w:tt , $c:tt : $c_w:tt ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::$op(rreil_val!($names # [ $b ] : $b_w),rreil_val!($names # $c : $c_w)),
result: rreil_var!($names # ( $a ) : $a_w)
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $op:ident # ( $a:expr ) : $a_w:tt, [ $b:tt ] : $b_w:tt , [ $c:tt ] : $c_w:tt ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::$op(rreil_val!($names # [ $b ] : $b_w),rreil_val!($names # [ $c ] : $c_w)),
result: rreil_var!($names # ( $a ) : $a_w)
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $op:ident # ( $a:expr ) : $a_w:tt, [ $b:tt ] : $b_w:tt , ? ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::$op(rreil_val!($names # [ $b ] : $b_w),rreil_val!($names # ?)),
result: rreil_var!($names # ( $a ) : $a_w)
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $op:ident # ( $a:expr ) : $a_w:tt, ? , ( $c:expr ) ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::$op(rreil_val!($names # ?),rreil_val!($names # ( $c ))),
result: rreil_var!($names # ( $a ) : $a_w)
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $op:ident # ( $a:expr ) : $a_w:tt, ? , ( $c:expr ) : $c_w:tt ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::$op(rreil_val!($names # ?),rreil_val!($names # ( $c ) : $c_w)),
result: rreil_var!($names # ( $a ) : $a_w)
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $op:ident # ( $a:expr ) : $a_w:tt, ? , $c:tt : $c_w:tt ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::$op(rreil_val!($names # ?),rreil_val!($names # $c : $c_w)),
result: rreil_var!($names # ( $a ) : $a_w)
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $op:ident # ( $a:expr ) : $a_w:tt, ? , [ $c:tt ] : $c_w:tt ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::$op(rreil_val!($names # ?),rreil_val!($names # [ $c ] : $c_w)),
result: rreil_var!($names # ( $a ) : $a_w)
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $op:ident # ( $a:expr ) : $a_w:tt, ? , ? ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::$op(rreil_val!($names # ?),rreil_val!($names # ?)),
result: rreil_var!($names # ( $a ) : $a_w)
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $op:ident # $a:tt : $a_w:tt, ( $b:expr ) , ( $c:expr ) ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::$op(rreil_val!($names # ( $b )),rreil_val!($names # ( $c ))),
result: rreil_var!($names # $a : $a_w)
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $op:ident # $a:tt : $a_w:tt, ( $b:expr ) , ( $c:expr ) : $c_w:tt ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::$op(rreil_val!($names # ( $b )),rreil_val!($names # ( $c ) : $c_w)),
result: rreil_var!($names # $a : $a_w)
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $op:ident # $a:tt : $a_w:tt, ( $b:expr ) , $c:tt : $c_w:tt ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::$op(rreil_val!($names # ( $b )),rreil_val!($names # $c : $c_w)),
result: rreil_var!($names # $a : $a_w)
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $op:ident # $a:tt : $a_w:tt, ( $b:expr ) , [ $c:tt ] : $c_w:tt ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::$op(rreil_val!($names # ( $b )),rreil_val!($names # [ $c ] : $c_w)),
result: rreil_var!($names # $a : $a_w)
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $op:ident # $a:tt : $a_w:tt, ( $b:expr ) , ? ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::$op(rreil_val!($names # ( $b )),rreil_val!($names # ?)),
result: rreil_var!($names # $a : $a_w)
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $op:ident # $a:tt : $a_w:tt, ( $b:expr ) : $b_w:tt , ( $c:expr ) ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::$op(rreil_val!($names # ( $b ) : $b_w),rreil_val!($names # ( $c ))),
result: rreil_var!($names # $a : $a_w)
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $op:ident # $a:tt : $a_w:tt, ( $b:expr ) : $b_w:tt , ( $c:expr ) : $c_w:tt ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::$op(rreil_val!($names # ( $b ) : $b_w),rreil_val!($names # ( $c ) : $c_w)),
result: rreil_var!($names # $a : $a_w)
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $op:ident # $a:tt : $a_w:tt, ( $b:expr ) : $b_w:tt , $c:tt : $c_w:tt ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::$op(rreil_val!($names # ( $b ) : $b_w),rreil_val!($names # $c : $c_w)),
result: rreil_var!($names # $a : $a_w)
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $op:ident # $a:tt : $a_w:tt, ( $b:expr ) : $b_w:tt , [ $c:tt ] : $c_w:tt ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::$op(rreil_val!($names # ( $b ) : $b_w),rreil_val!($names # [ $c ] : $c_w)),
result: rreil_var!($names # $a : $a_w)
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $op:ident # $a:tt : $a_w:tt, ( $b:expr ) : $b_w:tt , ? ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::$op(rreil_val!($names # ( $b ) : $b_w),rreil_val!($names # ?)),
result: rreil_var!($names # $a : $a_w)
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $op:ident # $a:tt : $a_w:tt, $b:tt : $b_w:tt , ( $c:expr ) ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::$op(rreil_val!($names # $b : $b_w),rreil_val!($names # ( $c ))),
result: rreil_var!($names # $a : $a_w)
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $op:ident # $a:tt : $a_w:tt, $b:tt : $b_w:tt , ( $c:expr ) : $c_w:tt ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::$op(rreil_val!($names # $b : $b_w),rreil_val!($names # ( $c ) : $c_w)),
result: rreil_var!($names # $a : $a_w)
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $op:ident # $a:tt : $a_w:tt, $b:tt : $b_w:tt , $c:tt : $c_w:tt ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::$op(rreil_val!($names # $b : $b_w),rreil_val!($names # $c : $c_w)),
result: rreil_var!($names # $a : $a_w)
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $op:ident # $a:tt : $a_w:tt, $b:tt : $b_w:tt , [ $c:tt ] : $c_w:tt ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::$op(rreil_val!($names # $b : $b_w),rreil_val!($names # [ $c ] : $c_w)),
result: rreil_var!($names # $a : $a_w)
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $op:ident # $a:tt : $a_w:tt, $b:tt : $b_w:tt , ? ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::$op(rreil_val!($names # $b : $b_w),rreil_val!($names # ?)),
result: rreil_var!($names # $a : $a_w)
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $op:ident # $a:tt : $a_w:tt, [ $b:tt ] : $b_w:tt , ( $c:expr ) ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::$op(rreil_val!($names # [ $b ] : $b_w),rreil_val!($names # ( $c ))),
result: rreil_var!($names # $a : $a_w)
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $op:ident # $a:tt : $a_w:tt, [ $b:tt ] : $b_w:tt , ( $c:expr ) : $c_w:tt ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::$op(rreil_val!($names # [ $b ] : $b_w),rreil_val!($names # ( $c ) : $c_w)),
result: rreil_var!($names # $a : $a_w)
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $op:ident # $a:tt : $a_w:tt, [ $b:tt ] : $b_w:tt , $c:tt : $c_w:tt ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::$op(rreil_val!($names # [ $b ] : $b_w),rreil_val!($names # $c : $c_w)),
result: rreil_var!($names # $a : $a_w)
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $op:ident # $a:tt : $a_w:tt, [ $b:tt ] : $b_w:tt , [ $c:tt ] : $c_w:tt ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::$op(rreil_val!($names # [ $b ] : $b_w),rreil_val!($names # [ $c ] : $c_w)),
result: rreil_var!($names # $a : $a_w)
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $op:ident # $a:tt : $a_w:tt, [ $b:tt ] : $b_w:tt , ? ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::$op(rreil_val!($names # [ $b ] : $b_w),rreil_val!($names # ?)),
result: rreil_var!($names # $a : $a_w)
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $op:ident # $a:tt : $a_w:tt, ? , ( $c:expr ) ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::$op(rreil_val!($names # ?),rreil_val!($names # ( $c ))),
result: rreil_var!($names # $a : $a_w)
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $op:ident # $a:tt : $a_w:tt, ? , ( $c:expr ) : $c_w:tt ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::$op(rreil_val!($names # ?),rreil_val!($names # ( $c ) : $c_w)),
result: rreil_var!($names # $a : $a_w)
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $op:ident # $a:tt : $a_w:tt, ? , $c:tt : $c_w:tt ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::$op(rreil_val!($names # ?),rreil_val!($names # $c : $c_w)),
result: rreil_var!($names # $a : $a_w)
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $op:ident # $a:tt : $a_w:tt, ? , [ $c:tt ] : $c_w:tt ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::$op(rreil_val!($names # ?),rreil_val!($names # [ $c ] : $c_w)),
result: rreil_var!($names # $a : $a_w)
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $op:ident # $a:tt : $a_w:tt, ? , ? ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::$op(rreil_val!($names # ?),rreil_val!($names # ?)),
result: rreil_var!($names # $a : $a_w)
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
}
#[macro_export]
macro_rules! rreil2_unop {
( $names:tt # $segs:tt # $op:ident # ( $a:expr ), ( $b:expr ) ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::$op(rreil_val!($names # ( $b ))),
result: rreil_var!($names # ( $a ))
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $op:ident # ( $a:expr ), ( $b:expr ) : $b_w:tt ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::$op(rreil_val!($names # ( $b ) : $b_w)),
result: rreil_var!($names # ( $a ))
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $op:ident # ( $a:expr ), $b:tt : $b_w:tt ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::$op(rreil_val!($names # $b : $b_w)),
result: rreil_var!($names # ( $a ))
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $op:ident # ( $a:expr ), [ $b:tt ] : $b_w:tt ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::$op(rreil_val!($names # [ $b ] : $b_w)),
result: rreil_var!($names # ( $a ))
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $op:ident # ( $a:expr ), ? ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::$op(rreil_val!($names # ?)),
result: rreil_var!($names # ( $a ))
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $op:ident # ( $a:expr ) : $a_w:tt, ( $b:expr ) ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::$op(rreil_val!($names # ( $b ))),
result: rreil_var!($names # ( $a ) : $a_w)
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $op:ident # ( $a:expr ) : $a_w:tt, ( $b:expr ) : $b_w:tt ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::$op(rreil_val!($names # ( $b ) : $b_w)),
result: rreil_var!($names # ( $a ) : $a_w)
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $op:ident # ( $a:expr ) : $a_w:tt, $b:tt : $b_w:tt ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::$op(rreil_val!($names # $b : $b_w)),
result: rreil_var!($names # ( $a ) : $a_w)
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $op:ident # ( $a:expr ) : $a_w:tt, [ $b:tt ] : $b_w:tt ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::$op(rreil_val!($names # [ $b ] : $b_w)),
result: rreil_var!($names # ( $a ) : $a_w)
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $op:ident # ( $a:expr ) : $a_w:tt, ? ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::$op(rreil_val!($names # ?)),
result: rreil_var!($names # ( $a ) : $a_w)
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $op:ident # $a:tt : $a_w:tt, ( $b:expr ) ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::$op(rreil_val!($names # ( $b ))),
result: rreil_var!($names # $a : $a_w)
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $op:ident # $a:tt : $a_w:tt, ( $b:expr ) : $b_w:tt ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::$op(rreil_val!($names # ( $b ) : $b_w)),
result: rreil_var!($names # $a : $a_w)
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $op:ident # $a:tt : $a_w:tt, $b:tt : $b_w:tt ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::$op(rreil_val!($names # $b : $b_w)),
result: rreil_var!($names # $a : $a_w)
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $op:ident # $a:tt : $a_w:tt, [ $b:tt ] : $b_w:tt ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::$op(rreil_val!($names # [ $b ] : $b_w)),
result: rreil_var!($names # $a : $a_w)
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $op:ident # $a:tt : $a_w:tt, ? ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::$op(rreil_val!($names # ?)),
result: rreil_var!($names # $a : $a_w)
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
}
#[macro_export]
macro_rules! rreil_store {
( $names:tt # $segs:tt # $bank:ident # le # $sz:tt # ( $addr:expr ) , ( $val:expr ) ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Memory{
op: $crate::MemoryOperation::Store{
segment: $crate::Segment{
name: $segs.insert(&$crate::Name::new(stringify!($bank).into(),None)),
},
endianess: $crate::Endianess::Little,
bytes: rreil_imm!($sz),
address: rreil_val!($names # ( $addr )),
value: rreil_val!($names # ( $val )),
},
result: $crate::Segment{
name: $segs.insert(&$crate::Name::new(stringify!($bank).into(),None)),
},
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $bank:ident # be # $sz:tt # ( $addr:expr ) , ( $val:expr ) ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Memory{
op: $crate::MemoryOperation::Store{
segment: $crate::Segment{
name: $segs.insert(&$crate::Name::new(stringify!($bank).into(),None)),
},
endianess: $crate::Endianess::Big,
bytes: rreil_imm!($sz),
address: rreil_val!($names # ( $addr )),
value: rreil_val!($names # ( $val )),
},
result: $crate::Segment{
name: $segs.insert(&$crate::Name::new(stringify!($bank).into(),None)),
},
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $bank:ident # le # $sz:tt # ( $addr:expr ) , ( $val:expr ) : $val_w:tt ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Memory{
op: $crate::MemoryOperation::Store{
segment: $crate::Segment{
name: $segs.insert(&$crate::Name::new(stringify!($bank).into(),None)),
},
endianess: $crate::Endianess::Little,
bytes: rreil_imm!($sz),
address: rreil_val!($names # ( $addr )),
value: rreil_val!($names # ( $val ) : $val_w),
},
result: $crate::Segment{
name: $segs.insert(&$crate::Name::new(stringify!($bank).into(),None)),
},
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $bank:ident # be # $sz:tt # ( $addr:expr ) , ( $val:expr ) : $val_w:tt ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Memory{
op: $crate::MemoryOperation::Store{
segment: $crate::Segment{
name: $segs.insert(&$crate::Name::new(stringify!($bank).into(),None)),
},
endianess: $crate::Endianess::Big,
bytes: rreil_imm!($sz),
address: rreil_val!($names # ( $addr )),
value: rreil_val!($names # ( $val ) : $val_w),
},
result: $crate::Segment{
name: $segs.insert(&$crate::Name::new(stringify!($bank).into(),None)),
},
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $bank:ident # le # $sz:tt # ( $addr:expr ) , $val:tt : $val_w:tt ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Memory{
op: $crate::MemoryOperation::Store{
segment: $crate::Segment{
name: $segs.insert(&$crate::Name::new(stringify!($bank).into(),None)),
},
endianess: $crate::Endianess::Little,
bytes: rreil_imm!($sz),
address: rreil_val!($names # ( $addr )),
value: rreil_val!($names # $val : $val_w),
},
result: $crate::Segment{
name: $segs.insert(&$crate::Name::new(stringify!($bank).into(),None)),
},
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $bank:ident # be # $sz:tt # ( $addr:expr ) , $val:tt : $val_w:tt ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Memory{
op: $crate::MemoryOperation::Store{
segment: $crate::Segment{
name: $segs.insert(&$crate::Name::new(stringify!($bank).into(),None)),
},
endianess: $crate::Endianess::Big,
bytes: rreil_imm!($sz),
address: rreil_val!($names # ( $addr )),
value: rreil_val!($names # $val : $val_w),
},
result: $crate::Segment{
name: $segs.insert(&$crate::Name::new(stringify!($bank).into(),None)),
},
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $bank:ident # le # $sz:tt # ( $addr:expr ) , [ $val:tt ] : $val_w:tt ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Memory{
op: $crate::MemoryOperation::Store{
segment: $crate::Segment{
name: $segs.insert(&$crate::Name::new(stringify!($bank).into(),None)),
},
endianess: $crate::Endianess::Little,
bytes: rreil_imm!($sz),
address: rreil_val!($names # ( $addr )),
value: rreil_val!($names # [ $val ] : $val_w),
},
result: $crate::Segment{
name: $segs.insert(&$crate::Name::new(stringify!($bank).into(),None)),
},
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $bank:ident # be # $sz:tt # ( $addr:expr ) , [ $val:tt ] : $val_w:tt ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Memory{
op: $crate::MemoryOperation::Store{
segment: $crate::Segment{
name: $segs.insert(&$crate::Name::new(stringify!($bank).into(),None)),
},
endianess: $crate::Endianess::Big,
bytes: rreil_imm!($sz),
address: rreil_val!($names # ( $addr )),
value: rreil_val!($names # [ $val ] : $val_w),
},
result: $crate::Segment{
name: $segs.insert(&$crate::Name::new(stringify!($bank).into(),None)),
},
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $bank:ident # le # $sz:tt # ( $addr:expr ) , ? ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Memory{
op: $crate::MemoryOperation::Store{
segment: $crate::Segment{
name: $segs.insert(&$crate::Name::new(stringify!($bank).into(),None)),
},
endianess: $crate::Endianess::Little,
bytes: rreil_imm!($sz),
address: rreil_val!($names # ( $addr )),
value: rreil_val!($names # ?),
},
result: $crate::Segment{
name: $segs.insert(&$crate::Name::new(stringify!($bank).into(),None)),
},
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $bank:ident # be # $sz:tt # ( $addr:expr ) , ? ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Memory{
op: $crate::MemoryOperation::Store{
segment: $crate::Segment{
name: $segs.insert(&$crate::Name::new(stringify!($bank).into(),None)),
},
endianess: $crate::Endianess::Big,
bytes: rreil_imm!($sz),
address: rreil_val!($names # ( $addr )),
value: rreil_val!($names # ?),
},
result: $crate::Segment{
name: $segs.insert(&$crate::Name::new(stringify!($bank).into(),None)),
},
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $bank:ident # le # $sz:tt # ( $addr:expr ) : $addr_w:tt , ( $val:expr ) ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Memory{
op: $crate::MemoryOperation::Store{
segment: $crate::Segment{
name: $segs.insert(&$crate::Name::new(stringify!($bank).into(),None)),
},
endianess: $crate::Endianess::Little,
bytes: rreil_imm!($sz),
address: rreil_val!($names # ( $addr ) : $addr_w),
value: rreil_val!($names # ( $val )),
},
result: $crate::Segment{
name: $segs.insert(&$crate::Name::new(stringify!($bank).into(),None)),
},
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $bank:ident # be # $sz:tt # ( $addr:expr ) : $addr_w:tt , ( $val:expr ) ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Memory{
op: $crate::MemoryOperation::Store{
segment: $crate::Segment{
name: $segs.insert(&$crate::Name::new(stringify!($bank).into(),None)),
},
endianess: $crate::Endianess::Big,
bytes: rreil_imm!($sz),
address: rreil_val!($names # ( $addr ) : $addr_w),
value: rreil_val!($names # ( $val )),
},
result: $crate::Segment{
name: $segs.insert(&$crate::Name::new(stringify!($bank).into(),None)),
},
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $bank:ident # le # $sz:tt # ( $addr:expr ) : $addr_w:tt , ( $val:expr ) : $val_w:tt ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Memory{
op: $crate::MemoryOperation::Store{
segment: $crate::Segment{
name: $segs.insert(&$crate::Name::new(stringify!($bank).into(),None)),
},
endianess: $crate::Endianess::Little,
bytes: rreil_imm!($sz),
address: rreil_val!($names # ( $addr ) : $addr_w),
value: rreil_val!($names # ( $val ) : $val_w),
},
result: $crate::Segment{
name: $segs.insert(&$crate::Name::new(stringify!($bank).into(),None)),
},
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $bank:ident # be # $sz:tt # ( $addr:expr ) : $addr_w:tt , ( $val:expr ) : $val_w:tt ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Memory{
op: $crate::MemoryOperation::Store{
segment: $crate::Segment{
name: $segs.insert(&$crate::Name::new(stringify!($bank).into(),None)),
},
endianess: $crate::Endianess::Big,
bytes: rreil_imm!($sz),
address: rreil_val!($names # ( $addr ) : $addr_w),
value: rreil_val!($names # ( $val ) : $val_w),
},
result: $crate::Segment{
name: $segs.insert(&$crate::Name::new(stringify!($bank).into(),None)),
},
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $bank:ident # le # $sz:tt # ( $addr:expr ) : $addr_w:tt , $val:tt : $val_w:tt ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Memory{
op: $crate::MemoryOperation::Store{
segment: $crate::Segment{
name: $segs.insert(&$crate::Name::new(stringify!($bank).into(),None)),
},
endianess: $crate::Endianess::Little,
bytes: rreil_imm!($sz),
address: rreil_val!($names # ( $addr ) : $addr_w),
value: rreil_val!($names # $val : $val_w),
},
result: $crate::Segment{
name: $segs.insert(&$crate::Name::new(stringify!($bank).into(),None)),
},
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $bank:ident # be # $sz:tt # ( $addr:expr ) : $addr_w:tt , $val:tt : $val_w:tt ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Memory{
op: $crate::MemoryOperation::Store{
segment: $crate::Segment{
name: $segs.insert(&$crate::Name::new(stringify!($bank).into(),None)),
},
endianess: $crate::Endianess::Big,
bytes: rreil_imm!($sz),
address: rreil_val!($names # ( $addr ) : $addr_w),
value: rreil_val!($names # $val : $val_w),
},
result: $crate::Segment{
name: $segs.insert(&$crate::Name::new(stringify!($bank).into(),None)),
},
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $bank:ident # le # $sz:tt # ( $addr:expr ) : $addr_w:tt , [ $val:tt ] : $val_w:tt ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Memory{
op: $crate::MemoryOperation::Store{
segment: $crate::Segment{
name: $segs.insert(&$crate::Name::new(stringify!($bank).into(),None)),
},
endianess: $crate::Endianess::Little,
bytes: rreil_imm!($sz),
address: rreil_val!($names # ( $addr ) : $addr_w),
value: rreil_val!($names # [ $val ] : $val_w),
},
result: $crate::Segment{
name: $segs.insert(&$crate::Name::new(stringify!($bank).into(),None)),
},
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $bank:ident # be # $sz:tt # ( $addr:expr ) : $addr_w:tt , [ $val:tt ] : $val_w:tt ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Memory{
op: $crate::MemoryOperation::Store{
segment: $crate::Segment{
name: $segs.insert(&$crate::Name::new(stringify!($bank).into(),None)),
},
endianess: $crate::Endianess::Big,
bytes: rreil_imm!($sz),
address: rreil_val!($names # ( $addr ) : $addr_w),
value: rreil_val!($names # [ $val ] : $val_w),
},
result: $crate::Segment{
name: $segs.insert(&$crate::Name::new(stringify!($bank).into(),None)),
},
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $bank:ident # le # $sz:tt # ( $addr:expr ) : $addr_w:tt , ? ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Memory{
op: $crate::MemoryOperation::Store{
segment: $crate::Segment{
name: $segs.insert(&$crate::Name::new(stringify!($bank).into(),None)),
},
endianess: $crate::Endianess::Little,
bytes: rreil_imm!($sz),
address: rreil_val!($names # ( $addr ) : $addr_w),
value: rreil_val!($names # ?),
},
result: $crate::Segment{
name: $segs.insert(&$crate::Name::new(stringify!($bank).into(),None)),
},
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $bank:ident # be # $sz:tt # ( $addr:expr ) : $addr_w:tt , ? ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Memory{
op: $crate::MemoryOperation::Store{
segment: $crate::Segment{
name: $segs.insert(&$crate::Name::new(stringify!($bank).into(),None)),
},
endianess: $crate::Endianess::Big,
bytes: rreil_imm!($sz),
address: rreil_val!($names # ( $addr ) : $addr_w),
value: rreil_val!($names # ?),
},
result: $crate::Segment{
name: $segs.insert(&$crate::Name::new(stringify!($bank).into(),None)),
},
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $bank:ident # le # $sz:tt # $addr:tt : $addr_w:tt , ( $val:expr ) ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Memory{
op: $crate::MemoryOperation::Store{
segment: $crate::Segment{
name: $segs.insert(&$crate::Name::new(stringify!($bank).into(),None)),
},
endianess: $crate::Endianess::Little,
bytes: rreil_imm!($sz),
address: rreil_val!($names # $addr : $addr_w),
value: rreil_val!($names # ( $val )),
},
result: $crate::Segment{
name: $segs.insert(&$crate::Name::new(stringify!($bank).into(),None)),
},
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $bank:ident # be # $sz:tt # $addr:tt : $addr_w:tt , ( $val:expr ) ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Memory{
op: $crate::MemoryOperation::Store{
segment: $crate::Segment{
name: $segs.insert(&$crate::Name::new(stringify!($bank).into(),None)),
},
endianess: $crate::Endianess::Big,
bytes: rreil_imm!($sz),
address: rreil_val!($names # $addr : $addr_w),
value: rreil_val!($names # ( $val )),
},
result: $crate::Segment{
name: $segs.insert(&$crate::Name::new(stringify!($bank).into(),None)),
},
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $bank:ident # le # $sz:tt # $addr:tt : $addr_w:tt , ( $val:expr ) : $val_w:tt ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Memory{
op: $crate::MemoryOperation::Store{
segment: $crate::Segment{
name: $segs.insert(&$crate::Name::new(stringify!($bank).into(),None)),
},
endianess: $crate::Endianess::Little,
bytes: rreil_imm!($sz),
address: rreil_val!($names # $addr : $addr_w),
value: rreil_val!($names # ( $val ) : $val_w),
},
result: $crate::Segment{
name: $segs.insert(&$crate::Name::new(stringify!($bank).into(),None)),
},
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $bank:ident # be # $sz:tt # $addr:tt : $addr_w:tt , ( $val:expr ) : $val_w:tt ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Memory{
op: $crate::MemoryOperation::Store{
segment: $crate::Segment{
name: $segs.insert(&$crate::Name::new(stringify!($bank).into(),None)),
},
endianess: $crate::Endianess::Big,
bytes: rreil_imm!($sz),
address: rreil_val!($names # $addr : $addr_w),
value: rreil_val!($names # ( $val ) : $val_w),
},
result: $crate::Segment{
name: $segs.insert(&$crate::Name::new(stringify!($bank).into(),None)),
},
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $bank:ident # le # $sz:tt # $addr:tt : $addr_w:tt , $val:tt : $val_w:tt ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Memory{
op: $crate::MemoryOperation::Store{
segment: $crate::Segment{
name: $segs.insert(&$crate::Name::new(stringify!($bank).into(),None)),
},
endianess: $crate::Endianess::Little,
bytes: rreil_imm!($sz),
address: rreil_val!($names # $addr : $addr_w),
value: rreil_val!($names # $val : $val_w),
},
result: $crate::Segment{
name: $segs.insert(&$crate::Name::new(stringify!($bank).into(),None)),
},
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $bank:ident # be # $sz:tt # $addr:tt : $addr_w:tt , $val:tt : $val_w:tt ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Memory{
op: $crate::MemoryOperation::Store{
segment: $crate::Segment{
name: $segs.insert(&$crate::Name::new(stringify!($bank).into(),None)),
},
endianess: $crate::Endianess::Big,
bytes: rreil_imm!($sz),
address: rreil_val!($names # $addr : $addr_w),
value: rreil_val!($names # $val : $val_w),
},
result: $crate::Segment{
name: $segs.insert(&$crate::Name::new(stringify!($bank).into(),None)),
},
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $bank:ident # le # $sz:tt # $addr:tt : $addr_w:tt , [ $val:tt ] : $val_w:tt ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Memory{
op: $crate::MemoryOperation::Store{
segment: $crate::Segment{
name: $segs.insert(&$crate::Name::new(stringify!($bank).into(),None)),
},
endianess: $crate::Endianess::Little,
bytes: rreil_imm!($sz),
address: rreil_val!($names # $addr : $addr_w),
value: rreil_val!($names # [ $val ] : $val_w),
},
result: $crate::Segment{
name: $segs.insert(&$crate::Name::new(stringify!($bank).into(),None)),
},
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $bank:ident # be # $sz:tt # $addr:tt : $addr_w:tt , [ $val:tt ] : $val_w:tt ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Memory{
op: $crate::MemoryOperation::Store{
segment: $crate::Segment{
name: $segs.insert(&$crate::Name::new(stringify!($bank).into(),None)),
},
endianess: $crate::Endianess::Big,
bytes: rreil_imm!($sz),
address: rreil_val!($names # $addr : $addr_w),
value: rreil_val!($names # [ $val ] : $val_w),
},
result: $crate::Segment{
name: $segs.insert(&$crate::Name::new(stringify!($bank).into(),None)),
},
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $bank:ident # le # $sz:tt # $addr:tt : $addr_w:tt , ? ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Memory{
op: $crate::MemoryOperation::Store{
segment: $crate::Segment{
name: $segs.insert(&$crate::Name::new(stringify!($bank).into(),None)),
},
endianess: $crate::Endianess::Little,
bytes: rreil_imm!($sz),
address: rreil_val!($names # $addr : $addr_w),
value: rreil_val!($names # ?),
},
result: $crate::Segment{
name: $segs.insert(&$crate::Name::new(stringify!($bank).into(),None)),
},
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $bank:ident # be # $sz:tt # $addr:tt : $addr_w:tt , ? ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Memory{
op: $crate::MemoryOperation::Store{
segment: $crate::Segment{
name: $segs.insert(&$crate::Name::new(stringify!($bank).into(),None)),
},
endianess: $crate::Endianess::Big,
bytes: rreil_imm!($sz),
address: rreil_val!($names # $addr : $addr_w),
value: rreil_val!($names # ?),
},
result: $crate::Segment{
name: $segs.insert(&$crate::Name::new(stringify!($bank).into(),None)),
},
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $bank:ident # le # $sz:tt # [ $addr:tt ] : $addr_w:tt , ( $val:expr ) ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Memory{
op: $crate::MemoryOperation::Store{
segment: $crate::Segment{
name: $segs.insert(&$crate::Name::new(stringify!($bank).into(),None)),
},
endianess: $crate::Endianess::Little,
bytes: rreil_imm!($sz),
address: rreil_val!($names # [ $addr ] : $addr_w),
value: rreil_val!($names # ( $val )),
},
result: $crate::Segment{
name: $segs.insert(&$crate::Name::new(stringify!($bank).into(),None)),
},
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $bank:ident # be # $sz:tt # [ $addr:tt ] : $addr_w:tt , ( $val:expr ) ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Memory{
op: $crate::MemoryOperation::Store{
segment: $crate::Segment{
name: $segs.insert(&$crate::Name::new(stringify!($bank).into(),None)),
},
endianess: $crate::Endianess::Big,
bytes: rreil_imm!($sz),
address: rreil_val!($names # [ $addr ] : $addr_w),
value: rreil_val!($names # ( $val )),
},
result: $crate::Segment{
name: $segs.insert(&$crate::Name::new(stringify!($bank).into(),None)),
},
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $bank:ident # le # $sz:tt # [ $addr:tt ] : $addr_w:tt , ( $val:expr ) : $val_w:tt ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Memory{
op: $crate::MemoryOperation::Store{
segment: $crate::Segment{
name: $segs.insert(&$crate::Name::new(stringify!($bank).into(),None)),
},
endianess: $crate::Endianess::Little,
bytes: rreil_imm!($sz),
address: rreil_val!($names # [ $addr ] : $addr_w),
value: rreil_val!($names # ( $val ) : $val_w),
},
result: $crate::Segment{
name: $segs.insert(&$crate::Name::new(stringify!($bank).into(),None)),
},
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $bank:ident # be # $sz:tt # [ $addr:tt ] : $addr_w:tt , ( $val:expr ) : $val_w:tt ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Memory{
op: $crate::MemoryOperation::Store{
segment: $crate::Segment{
name: $segs.insert(&$crate::Name::new(stringify!($bank).into(),None)),
},
endianess: $crate::Endianess::Big,
bytes: rreil_imm!($sz),
address: rreil_val!($names # [ $addr ] : $addr_w),
value: rreil_val!($names # ( $val ) : $val_w),
},
result: $crate::Segment{
name: $segs.insert(&$crate::Name::new(stringify!($bank).into(),None)),
},
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $bank:ident # le # $sz:tt # [ $addr:tt ] : $addr_w:tt , $val:tt : $val_w:tt ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Memory{
op: $crate::MemoryOperation::Store{
segment: $crate::Segment{
name: $segs.insert(&$crate::Name::new(stringify!($bank).into(),None)),
},
endianess: $crate::Endianess::Little,
bytes: rreil_imm!($sz),
address: rreil_val!($names # [ $addr ] : $addr_w),
value: rreil_val!($names # $val : $val_w),
},
result: $crate::Segment{
name: $segs.insert(&$crate::Name::new(stringify!($bank).into(),None)),
},
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $bank:ident # be # $sz:tt # [ $addr:tt ] : $addr_w:tt , $val:tt : $val_w:tt ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Memory{
op: $crate::MemoryOperation::Store{
segment: $crate::Segment{
name: $segs.insert(&$crate::Name::new(stringify!($bank).into(),None)),
},
endianess: $crate::Endianess::Big,
bytes: rreil_imm!($sz),
address: rreil_val!($names # [ $addr ] : $addr_w),
value: rreil_val!($names # $val : $val_w),
},
result: $crate::Segment{
name: $segs.insert(&$crate::Name::new(stringify!($bank).into(),None)),
},
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $bank:ident # le # $sz:tt # [ $addr:tt ] : $addr_w:tt , [ $val:tt ] : $val_w:tt ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Memory{
op: $crate::MemoryOperation::Store{
segment: $crate::Segment{
name: $segs.insert(&$crate::Name::new(stringify!($bank).into(),None)),
},
endianess: $crate::Endianess::Little,
bytes: rreil_imm!($sz),
address: rreil_val!($names # [ $addr ] : $addr_w),
value: rreil_val!($names # [ $val ] : $val_w),
},
result: $crate::Segment{
name: $segs.insert(&$crate::Name::new(stringify!($bank).into(),None)),
},
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $bank:ident # be # $sz:tt # [ $addr:tt ] : $addr_w:tt , [ $val:tt ] : $val_w:tt ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Memory{
op: $crate::MemoryOperation::Store{
segment: $crate::Segment{
name: $segs.insert(&$crate::Name::new(stringify!($bank).into(),None)),
},
endianess: $crate::Endianess::Big,
bytes: rreil_imm!($sz),
address: rreil_val!($names # [ $addr ] : $addr_w),
value: rreil_val!($names # [ $val ] : $val_w),
},
result: $crate::Segment{
name: $segs.insert(&$crate::Name::new(stringify!($bank).into(),None)),
},
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $bank:ident # le # $sz:tt # [ $addr:tt ] : $addr_w:tt , ? ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Memory{
op: $crate::MemoryOperation::Store{
segment: $crate::Segment{
name: $segs.insert(&$crate::Name::new(stringify!($bank).into(),None)),
},
endianess: $crate::Endianess::Little,
bytes: rreil_imm!($sz),
address: rreil_val!($names # [ $addr ] : $addr_w),
value: rreil_val!($names # ?),
},
result: $crate::Segment{
name: $segs.insert(&$crate::Name::new(stringify!($bank).into(),None)),
},
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $bank:ident # be # $sz:tt # [ $addr:tt ] : $addr_w:tt , ? ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Memory{
op: $crate::MemoryOperation::Store{
segment: $crate::Segment{
name: $segs.insert(&$crate::Name::new(stringify!($bank).into(),None)),
},
endianess: $crate::Endianess::Big,
bytes: rreil_imm!($sz),
address: rreil_val!($names # [ $addr ] : $addr_w),
value: rreil_val!($names # ?),
},
result: $crate::Segment{
name: $segs.insert(&$crate::Name::new(stringify!($bank).into(),None)),
},
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $bank:ident # le # $sz:tt # ? , ( $val:expr ) ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Memory{
op: $crate::MemoryOperation::Store{
segment: $crate::Segment{
name: $segs.insert(&$crate::Name::new(stringify!($bank).into(),None)),
},
endianess: $crate::Endianess::Little,
bytes: rreil_imm!($sz),
address: rreil_val!($names # ?),
value: rreil_val!($names # ( $val )),
},
result: $crate::Segment{
name: $segs.insert(&$crate::Name::new(stringify!($bank).into(),None)),
},
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $bank:ident # be # $sz:tt # ? , ( $val:expr ) ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Memory{
op: $crate::MemoryOperation::Store{
segment: $crate::Segment{
name: $segs.insert(&$crate::Name::new(stringify!($bank).into(),None)),
},
endianess: $crate::Endianess::Big,
bytes: rreil_imm!($sz),
address: rreil_val!($names # ?),
value: rreil_val!($names # ( $val )),
},
result: $crate::Segment{
name: $segs.insert(&$crate::Name::new(stringify!($bank).into(),None)),
},
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $bank:ident # le # $sz:tt # ? , ( $val:expr ) : $val_w:tt ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Memory{
op: $crate::MemoryOperation::Store{
segment: $crate::Segment{
name: $segs.insert(&$crate::Name::new(stringify!($bank).into(),None)),
},
endianess: $crate::Endianess::Little,
bytes: rreil_imm!($sz),
address: rreil_val!($names # ?),
value: rreil_val!($names # ( $val ) : $val_w),
},
result: $crate::Segment{
name: $segs.insert(&$crate::Name::new(stringify!($bank).into(),None)),
},
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $bank:ident # be # $sz:tt # ? , ( $val:expr ) : $val_w:tt ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Memory{
op: $crate::MemoryOperation::Store{
segment: $crate::Segment{
name: $segs.insert(&$crate::Name::new(stringify!($bank).into(),None)),
},
endianess: $crate::Endianess::Big,
bytes: rreil_imm!($sz),
address: rreil_val!($names # ?),
value: rreil_val!($names # ( $val ) : $val_w),
},
result: $crate::Segment{
name: $segs.insert(&$crate::Name::new(stringify!($bank).into(),None)),
},
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $bank:ident # le # $sz:tt # ? , $val:tt : $val_w:tt ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Memory{
op: $crate::MemoryOperation::Store{
segment: $crate::Segment{
name: $segs.insert(&$crate::Name::new(stringify!($bank).into(),None)),
},
endianess: $crate::Endianess::Little,
bytes: rreil_imm!($sz),
address: rreil_val!($names # ?),
value: rreil_val!($names # $val : $val_w),
},
result: $crate::Segment{
name: $segs.insert(&$crate::Name::new(stringify!($bank).into(),None)),
},
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $bank:ident # be # $sz:tt # ? , $val:tt : $val_w:tt ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Memory{
op: $crate::MemoryOperation::Store{
segment: $crate::Segment{
name: $segs.insert(&$crate::Name::new(stringify!($bank).into(),None)),
},
endianess: $crate::Endianess::Big,
bytes: rreil_imm!($sz),
address: rreil_val!($names # ?),
value: rreil_val!($names # $val : $val_w),
},
result: $crate::Segment{
name: $segs.insert(&$crate::Name::new(stringify!($bank).into(),None)),
},
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $bank:ident # le # $sz:tt # ? , [ $val:tt ] : $val_w:tt ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Memory{
op: $crate::MemoryOperation::Store{
segment: $crate::Segment{
name: $segs.insert(&$crate::Name::new(stringify!($bank).into(),None)),
},
endianess: $crate::Endianess::Little,
bytes: rreil_imm!($sz),
address: rreil_val!($names # ?),
value: rreil_val!($names # [ $val ] : $val_w),
},
result: $crate::Segment{
name: $segs.insert(&$crate::Name::new(stringify!($bank).into(),None)),
},
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $bank:ident # be # $sz:tt # ? , [ $val:tt ] : $val_w:tt ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Memory{
op: $crate::MemoryOperation::Store{
segment: $crate::Segment{
name: $segs.insert(&$crate::Name::new(stringify!($bank).into(),None)),
},
endianess: $crate::Endianess::Big,
bytes: rreil_imm!($sz),
address: rreil_val!($names # ?),
value: rreil_val!($names # [ $val ] : $val_w),
},
result: $crate::Segment{
name: $segs.insert(&$crate::Name::new(stringify!($bank).into(),None)),
},
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $bank:ident # le # $sz:tt # ? , ? ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Memory{
op: $crate::MemoryOperation::Store{
segment: $crate::Segment{
name: $segs.insert(&$crate::Name::new(stringify!($bank).into(),None)),
},
endianess: $crate::Endianess::Little,
bytes: rreil_imm!($sz),
address: rreil_val!($names # ?),
value: rreil_val!($names # ?),
},
result: $crate::Segment{
name: $segs.insert(&$crate::Name::new(stringify!($bank).into(),None)),
},
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $bank:ident # be # $sz:tt # ? , ? ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Memory{
op: $crate::MemoryOperation::Store{
segment: $crate::Segment{
name: $segs.insert(&$crate::Name::new(stringify!($bank).into(),None)),
},
endianess: $crate::Endianess::Big,
bytes: rreil_imm!($sz),
address: rreil_val!($names # ?),
value: rreil_val!($names # ?),
},
result: $crate::Segment{
name: $segs.insert(&$crate::Name::new(stringify!($bank).into(),None)),
},
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
}
#[macro_export]
macro_rules! rreil_load {
( $names:tt # $segs:tt # $bank:ident # le # $sz:tt # ( $res:expr ) , ( $addr:expr ) ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::Load(
$crate::Segment{
name: $segs.insert(&$crate::Name::new(stringify!($bank).into(),None)),
},
$crate::Endianess::Little,
rreil_imm!($sz),
rreil_val!($names # ( $addr ))
),
result: rreil_var!($names # ( $res )),
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $bank:ident # be # $sz:tt # ( $res:expr ) , ( $addr:expr ) ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::Load(
$crate::Segment{
name: $segs.insert(&$crate::Name::new(stringify!($bank).into(),None)),
},
$crate::Endianess::Big,
rreil_imm!($sz),
rreil_val!($names # ( $addr ))
),
result: rreil_var!($names # ( $res )),
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $bank:ident # le # $sz:tt # ( $res:expr ) , ( $addr:expr ) : $addr_w:tt ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::Load(
$crate::Segment{
name: $segs.insert(&$crate::Name::new(stringify!($bank).into(),None)),
},
$crate::Endianess::Little,
rreil_imm!($sz),
rreil_val!($names # ( $addr ) : $addr_w)
),
result: rreil_var!($names # ( $res )),
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $bank:ident # be # $sz:tt # ( $res:expr ) , ( $addr:expr ) : $addr_w:tt ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::Load(
$crate::Segment{
name: $segs.insert(&$crate::Name::new(stringify!($bank).into(),None)),
},
$crate::Endianess::Big,
rreil_imm!($sz),
rreil_val!($names # ( $addr ) : $addr_w)
),
result: rreil_var!($names # ( $res )),
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $bank:ident # le # $sz:tt # ( $res:expr ) , $addr:tt : $addr_w:tt ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::Load(
$crate::Segment{
name: $segs.insert(&$crate::Name::new(stringify!($bank).into(),None)),
},
$crate::Endianess::Little,
rreil_imm!($sz),
rreil_val!($names # $addr : $addr_w)
),
result: rreil_var!($names # ( $res )),
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $bank:ident # be # $sz:tt # ( $res:expr ) , $addr:tt : $addr_w:tt ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::Load(
$crate::Segment{
name: $segs.insert(&$crate::Name::new(stringify!($bank).into(),None)),
},
$crate::Endianess::Big,
rreil_imm!($sz),
rreil_val!($names # $addr : $addr_w)
),
result: rreil_var!($names # ( $res )),
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $bank:ident # le # $sz:tt # ( $res:expr ) , [ $addr:tt ] : $addr_w:tt ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::Load(
$crate::Segment{
name: $segs.insert(&$crate::Name::new(stringify!($bank).into(),None)),
},
$crate::Endianess::Little,
rreil_imm!($sz),
rreil_val!($names # [ $addr ] : $addr_w)
),
result: rreil_var!($names # ( $res )),
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $bank:ident # be # $sz:tt # ( $res:expr ) , [ $addr:tt ] : $addr_w:tt ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::Load(
$crate::Segment{
name: $segs.insert(&$crate::Name::new(stringify!($bank).into(),None)),
},
$crate::Endianess::Big,
rreil_imm!($sz),
rreil_val!($names # [ $addr ] : $addr_w)
),
result: rreil_var!($names # ( $res )),
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $bank:ident # le # $sz:tt # ( $res:expr ) , ? ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::Load(
$crate::Segment{
name: $segs.insert(&$crate::Name::new(stringify!($bank).into(),None)),
},
$crate::Endianess::Little,
rreil_imm!($sz),
rreil_val!($names # ?)
),
result: rreil_var!($names # ( $res )),
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $bank:ident # be # $sz:tt # ( $res:expr ) , ? ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::Load(
$crate::Segment{
name: $segs.insert(&$crate::Name::new(stringify!($bank).into(),None)),
},
$crate::Endianess::Big,
rreil_imm!($sz),
rreil_val!($names # ?)
),
result: rreil_var!($names # ( $res )),
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $bank:ident # le # $sz:tt # ( $res:expr ) : $res_w:tt , ( $addr:expr ) ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::Load(
$crate::Segment{
name: $segs.insert(&$crate::Name::new(stringify!($bank).into(),None)),
},
$crate::Endianess::Little,
rreil_imm!($sz),
rreil_val!($names # ( $addr ))
),
result: rreil_var!($names # ( $res ) : $res_w),
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $bank:ident # be # $sz:tt # ( $res:expr ) : $res_w:tt , ( $addr:expr ) ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::Load(
$crate::Segment{
name: $segs.insert(&$crate::Name::new(stringify!($bank).into(),None)),
},
$crate::Endianess::Big,
rreil_imm!($sz),
rreil_val!($names # ( $addr ))
),
result: rreil_var!($names # ( $res ) : $res_w),
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $bank:ident # le # $sz:tt # ( $res:expr ) : $res_w:tt , ( $addr:expr ) : $addr_w:tt ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::Load(
$crate::Segment{
name: $segs.insert(&$crate::Name::new(stringify!($bank).into(),None)),
},
$crate::Endianess::Little,
rreil_imm!($sz),
rreil_val!($names # ( $addr ) : $addr_w)
),
result: rreil_var!($names # ( $res ) : $res_w),
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $bank:ident # be # $sz:tt # ( $res:expr ) : $res_w:tt , ( $addr:expr ) : $addr_w:tt ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::Load(
$crate::Segment{
name: $segs.insert(&$crate::Name::new(stringify!($bank).into(),None)),
},
$crate::Endianess::Big,
rreil_imm!($sz),
rreil_val!($names # ( $addr ) : $addr_w)
),
result: rreil_var!($names # ( $res ) : $res_w),
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $bank:ident # le # $sz:tt # ( $res:expr ) : $res_w:tt , $addr:tt : $addr_w:tt ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::Load(
$crate::Segment{
name: $segs.insert(&$crate::Name::new(stringify!($bank).into(),None)),
},
$crate::Endianess::Little,
rreil_imm!($sz),
rreil_val!($names # $addr : $addr_w)
),
result: rreil_var!($names # ( $res ) : $res_w),
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $bank:ident # be # $sz:tt # ( $res:expr ) : $res_w:tt , $addr:tt : $addr_w:tt ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::Load(
$crate::Segment{
name: $segs.insert(&$crate::Name::new(stringify!($bank).into(),None)),
},
$crate::Endianess::Big,
rreil_imm!($sz),
rreil_val!($names # $addr : $addr_w)
),
result: rreil_var!($names # ( $res ) : $res_w),
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $bank:ident # le # $sz:tt # ( $res:expr ) : $res_w:tt , [ $addr:tt ] : $addr_w:tt ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::Load(
$crate::Segment{
name: $segs.insert(&$crate::Name::new(stringify!($bank).into(),None)),
},
$crate::Endianess::Little,
rreil_imm!($sz),
rreil_val!($names # [ $addr ] : $addr_w)
),
result: rreil_var!($names # ( $res ) : $res_w),
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $bank:ident # be # $sz:tt # ( $res:expr ) : $res_w:tt , [ $addr:tt ] : $addr_w:tt ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::Load(
$crate::Segment{
name: $segs.insert(&$crate::Name::new(stringify!($bank).into(),None)),
},
$crate::Endianess::Big,
rreil_imm!($sz),
rreil_val!($names # [ $addr ] : $addr_w)
),
result: rreil_var!($names # ( $res ) : $res_w),
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $bank:ident # le # $sz:tt # ( $res:expr ) : $res_w:tt , ? ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::Load(
$crate::Segment{
name: $segs.insert(&$crate::Name::new(stringify!($bank).into(),None)),
},
$crate::Endianess::Little,
rreil_imm!($sz),
rreil_val!($names # ?)
),
result: rreil_var!($names # ( $res ) : $res_w),
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $bank:ident # be # $sz:tt # ( $res:expr ) : $res_w:tt , ? ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::Load(
$crate::Segment{
name: $segs.insert(&$crate::Name::new(stringify!($bank).into(),None)),
},
$crate::Endianess::Big,
rreil_imm!($sz),
rreil_val!($names # ?)
),
result: rreil_var!($names # ( $res ) : $res_w),
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $bank:ident # le # $sz:tt # $res:tt : $res_w:tt , ( $addr:expr ) ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::Load(
$crate::Segment{
name: $segs.insert(&$crate::Name::new(stringify!($bank).into(),None)),
},
$crate::Endianess::Little,
rreil_imm!($sz),
rreil_val!($names # ( $addr ))
),
result: rreil_var!($names # $res : $res_w),
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $bank:ident # be # $sz:tt # $res:tt : $res_w:tt , ( $addr:expr ) ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::Load(
$crate::Segment{
name: $segs.insert(&$crate::Name::new(stringify!($bank).into(),None)),
},
$crate::Endianess::Big,
rreil_imm!($sz),
rreil_val!($names # ( $addr ))
),
result: rreil_var!($names # $res : $res_w),
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $bank:ident # le # $sz:tt # $res:tt : $res_w:tt , ( $addr:expr ) : $addr_w:tt ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::Load(
$crate::Segment{
name: $segs.insert(&$crate::Name::new(stringify!($bank).into(),None)),
},
$crate::Endianess::Little,
rreil_imm!($sz),
rreil_val!($names # ( $addr ) : $addr_w)
),
result: rreil_var!($names # $res : $res_w),
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $bank:ident # be # $sz:tt # $res:tt : $res_w:tt , ( $addr:expr ) : $addr_w:tt ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::Load(
$crate::Segment{
name: $segs.insert(&$crate::Name::new(stringify!($bank).into(),None)),
},
$crate::Endianess::Big,
rreil_imm!($sz),
rreil_val!($names # ( $addr ) : $addr_w)
),
result: rreil_var!($names # $res : $res_w),
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $bank:ident # le # $sz:tt # $res:tt : $res_w:tt , $addr:tt : $addr_w:tt ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::Load(
$crate::Segment{
name: $segs.insert(&$crate::Name::new(stringify!($bank).into(),None)),
},
$crate::Endianess::Little,
rreil_imm!($sz),
rreil_val!($names # $addr : $addr_w)
),
result: rreil_var!($names # $res : $res_w),
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $bank:ident # be # $sz:tt # $res:tt : $res_w:tt , $addr:tt : $addr_w:tt ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::Load(
$crate::Segment{
name: $segs.insert(&$crate::Name::new(stringify!($bank).into(),None)),
},
$crate::Endianess::Big,
rreil_imm!($sz),
rreil_val!($names # $addr : $addr_w)
),
result: rreil_var!($names # $res : $res_w),
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $bank:ident # le # $sz:tt # $res:tt : $res_w:tt , [ $addr:tt ] : $addr_w:tt ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::Load(
$crate::Segment{
name: $segs.insert(&$crate::Name::new(stringify!($bank).into(),None)),
},
$crate::Endianess::Little,
rreil_imm!($sz),
rreil_val!($names # [ $addr ] : $addr_w)
),
result: rreil_var!($names # $res : $res_w),
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $bank:ident # be # $sz:tt # $res:tt : $res_w:tt , [ $addr:tt ] : $addr_w:tt ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::Load(
$crate::Segment{
name: $segs.insert(&$crate::Name::new(stringify!($bank).into(),None)),
},
$crate::Endianess::Big,
rreil_imm!($sz),
rreil_val!($names # [ $addr ] : $addr_w)
),
result: rreil_var!($names # $res : $res_w),
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $bank:ident # le # $sz:tt # $res:tt : $res_w:tt , ? ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::Load(
$crate::Segment{
name: $segs.insert(&$crate::Name::new(stringify!($bank).into(),None)),
},
$crate::Endianess::Little,
rreil_imm!($sz),
rreil_val!($names # ?)
),
result: rreil_var!($names # $res : $res_w),
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $bank:ident # be # $sz:tt # $res:tt : $res_w:tt , ? ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::Load(
$crate::Segment{
name: $segs.insert(&$crate::Name::new(stringify!($bank).into(),None)),
},
$crate::Endianess::Big,
rreil_imm!($sz),
rreil_val!($names # ?)
),
result: rreil_var!($names # $res : $res_w),
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
}
#[macro_export]
macro_rules! rreil2_retop {
( $names:tt # $segs:tt # ; $($cdr:tt)* ) => {{
let mut stmt = vec![$crate::Statement::Flow{
op: $crate::FlowOperation::Return,
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
}
#[macro_export]
macro_rules! rreil2_callop {
( $names:tt # $segs:tt # ( $a:expr ) ; $($cdr:tt)* ) => {{
let mut stmt = vec![$crate::Statement::Flow{
op: $crate::FlowOperation::IndirectCall{
target: rreil_var!($names # ( $a ))
}
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # ( $a:expr ) : $a_w:tt ; $($cdr:tt)* ) => {{
let mut stmt = vec![$crate::Statement::Flow{
op: $crate::FlowOperation::IndirectCall{
target: rreil_var!($names # ( $a ) : $a_w)
}
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $a:tt : $a_w:tt ; $($cdr:tt)* ) => {{
let mut stmt = vec![$crate::Statement::Flow{
op: $crate::FlowOperation::IndirectCall{
target: rreil_var!($names # $a : $a_w)
}
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # [ $a:tt ] : $a_w:tt ; $($cdr:tt)* ) => {{
let mut stmt = vec![$crate::Statement::Flow{
op: $crate::FlowOperation::IndirectCall{
target: rreil_var!($names # [ $a ] : $a_w)
}
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # ? ; $($cdr:tt)* ) => {{
let mut stmt = vec![$crate::Statement::Flow{
op: $crate::FlowOperation::IndirectCall{
target: rreil_var!($names # ?)
}
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
}
#[macro_export]
macro_rules! rreil2_extop {
( $names:tt # $segs:tt # $op:ident # $sz:tt # ( $a:expr ), ( $b:expr ) ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::$op(rreil_imm!($sz),rreil_val!($names # ( $b ))),
result: rreil_var!($names # ( $a ))
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $op:ident # $sz:tt # ( $a:expr ), ( $b:expr ) : $b_w:tt ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::$op(rreil_imm!($sz),rreil_val!($names # ( $b ) : $b_w)),
result: rreil_var!($names # ( $a ))
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $op:ident # $sz:tt # ( $a:expr ), $b:tt : $b_w:tt ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::$op(rreil_imm!($sz),rreil_val!($names # $b : $b_w)),
result: rreil_var!($names # ( $a ))
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $op:ident # $sz:tt # ( $a:expr ), [ $b:tt ] : $b_w:tt ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::$op(rreil_imm!($sz),rreil_val!($names # [ $b ] : $b_w)),
result: rreil_var!($names # ( $a ))
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $op:ident # $sz:tt # ( $a:expr ), ? ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::$op(rreil_imm!($sz),rreil_val!($names # ?)),
result: rreil_var!($names # ( $a ))
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $op:ident # $sz:tt # ( $a:expr ) : $a_w:tt, ( $b:expr ) ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::$op(rreil_imm!($sz),rreil_val!($names # ( $b ))),
result: rreil_var!($names # ( $a ) : $a_w)
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $op:ident # $sz:tt # ( $a:expr ) : $a_w:tt, ( $b:expr ) : $b_w:tt ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::$op(rreil_imm!($sz),rreil_val!($names # ( $b ) : $b_w)),
result: rreil_var!($names # ( $a ) : $a_w)
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $op:ident # $sz:tt # ( $a:expr ) : $a_w:tt, $b:tt : $b_w:tt ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::$op(rreil_imm!($sz),rreil_val!($names # $b : $b_w)),
result: rreil_var!($names # ( $a ) : $a_w)
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $op:ident # $sz:tt # ( $a:expr ) : $a_w:tt, [ $b:tt ] : $b_w:tt ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::$op(rreil_imm!($sz),rreil_val!($names # [ $b ] : $b_w)),
result: rreil_var!($names # ( $a ) : $a_w)
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $op:ident # $sz:tt # ( $a:expr ) : $a_w:tt, ? ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::$op(rreil_imm!($sz),rreil_val!($names # ?)),
result: rreil_var!($names # ( $a ) : $a_w)
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $op:ident # $sz:tt # $a:tt : $a_w:tt, ( $b:expr ) ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::$op(rreil_imm!($sz),rreil_val!($names # ( $b ))),
result: rreil_var!($names # $a : $a_w)
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $op:ident # $sz:tt # $a:tt : $a_w:tt, ( $b:expr ) : $b_w:tt ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::$op(rreil_imm!($sz),rreil_val!($names # ( $b ) : $b_w)),
result: rreil_var!($names # $a : $a_w)
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $op:ident # $sz:tt # $a:tt : $a_w:tt, $b:tt : $b_w:tt ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::$op(rreil_imm!($sz),rreil_val!($names # $b : $b_w)),
result: rreil_var!($names # $a : $a_w)
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $op:ident # $sz:tt # $a:tt : $a_w:tt, [ $b:tt ] : $b_w:tt ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::$op(rreil_imm!($sz),rreil_val!($names # [ $b ] : $b_w)),
result: rreil_var!($names # $a : $a_w)
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $op:ident # $sz:tt # $a:tt : $a_w:tt, ? ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::$op(rreil_imm!($sz),rreil_val!($names # ?)),
result: rreil_var!($names # $a : $a_w)
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
}
#[macro_export]
macro_rules! rreil2_selop {
( $names:tt # $segs:tt # $op:ident # $off:tt # $sz:tt # ( $a:expr ), ( $b:expr ) ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::$op(rreil_imm!($off),rreil_imm!($sz),rreil_val!($names # ( $b ))),
result: rreil_var!($names # ( $a ))
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $op:ident # $off:tt # $sz:tt # ( $a:expr ), ( $b:expr ) : $b_w:tt ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::$op(rreil_imm!($off),rreil_imm!($sz),rreil_val!($names # ( $b ) : $b_w)),
result: rreil_var!($names # ( $a ))
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $op:ident # $off:tt # $sz:tt # ( $a:expr ), $b:tt : $b_w:tt ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::$op(rreil_imm!($off),rreil_imm!($sz),rreil_val!($names # $b : $b_w)),
result: rreil_var!($names # ( $a ))
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $op:ident # $off:tt # $sz:tt # ( $a:expr ), [ $b:tt ] : $b_w:tt ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::$op(rreil_imm!($off),rreil_imm!($sz),rreil_val!($names # [ $b ] : $b_w)),
result: rreil_var!($names # ( $a ))
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $op:ident # $off:tt # $sz:tt # ( $a:expr ), ? ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::$op(rreil_imm!($off),rreil_imm!($sz),rreil_val!($names # ?)),
result: rreil_var!($names # ( $a ))
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $op:ident # $off:tt # $sz:tt # ( $a:expr ) : $a_w:tt, ( $b:expr ) ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::$op(rreil_imm!($off),rreil_imm!($sz),rreil_val!($names # ( $b ))),
result: rreil_var!($names # ( $a ) : $a_w)
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $op:ident # $off:tt # $sz:tt # ( $a:expr ) : $a_w:tt, ( $b:expr ) : $b_w:tt ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::$op(rreil_imm!($off),rreil_imm!($sz),rreil_val!($names # ( $b ) : $b_w)),
result: rreil_var!($names # ( $a ) : $a_w)
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $op:ident # $off:tt # $sz:tt # ( $a:expr ) : $a_w:tt, $b:tt : $b_w:tt ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::$op(rreil_imm!($off),rreil_imm!($sz),rreil_val!($names # $b : $b_w)),
result: rreil_var!($names # ( $a ) : $a_w)
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $op:ident # $off:tt # $sz:tt # ( $a:expr ) : $a_w:tt, [ $b:tt ] : $b_w:tt ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::$op(rreil_imm!($off),rreil_imm!($sz),rreil_val!($names # [ $b ] : $b_w)),
result: rreil_var!($names # ( $a ) : $a_w)
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $op:ident # $off:tt # $sz:tt # ( $a:expr ) : $a_w:tt, ? ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::$op(rreil_imm!($off),rreil_imm!($sz),rreil_val!($names # ?)),
result: rreil_var!($names # ( $a ) : $a_w)
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $op:ident # $off:tt # $sz:tt # $a:tt : $a_w:tt, ( $b:expr ) ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::$op(rreil_imm!($off),rreil_imm!($sz),rreil_val!($names # ( $b ))),
result: rreil_var!($names # $a : $a_w)
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $op:ident # $off:tt # $sz:tt # $a:tt : $a_w:tt, ( $b:expr ) : $b_w:tt ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::$op(rreil_imm!($off),rreil_imm!($sz),rreil_val!($names # ( $b ) : $b_w)),
result: rreil_var!($names # $a : $a_w)
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $op:ident # $off:tt # $sz:tt # $a:tt : $a_w:tt, $b:tt : $b_w:tt ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::$op(rreil_imm!($off),rreil_imm!($sz),rreil_val!($names # $b : $b_w)),
result: rreil_var!($names # $a : $a_w)
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $op:ident # $off:tt # $sz:tt # $a:tt : $a_w:tt, [ $b:tt ] : $b_w:tt ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::$op(rreil_imm!($off),rreil_imm!($sz),rreil_val!($names # [ $b ] : $b_w)),
result: rreil_var!($names # $a : $a_w)
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
( $names:tt # $segs:tt # $op:ident # $off:tt # $sz:tt # $a:tt : $a_w:tt, ? ; $($cdr:tt)*) => {{
let mut stmt = vec![$crate::Statement::Expression{
op: $crate::Operation::$op(rreil_imm!($off),rreil_imm!($sz),rreil_val!($names # ?)),
result: rreil_var!($names # $a : $a_w)
}];
let ret: $crate::Result<Vec<$crate::Statement>> = match stmt[0].sanity_check() {
Ok(()) => {
{let _ = &$segs;}
{let _ = &$names;}
let mut tail: $crate::Result<Vec<$crate::Statement>> = { rreil2!( ($names,$segs) { $($cdr)* } ) };
match tail {
Ok(ref mut other) => {
stmt.extend(other.drain(..));
Ok(stmt)
}
Err(e) => Err(e),
}
}
Err(e) => Err(e).into(),
};
ret
}};
}