diff options
Diffstat (limited to 'rust/qemu-api-macros/src/bits.rs')
| -rw-r--r-- | rust/qemu-api-macros/src/bits.rs | 213 |
1 files changed, 0 insertions, 213 deletions
diff --git a/rust/qemu-api-macros/src/bits.rs b/rust/qemu-api-macros/src/bits.rs deleted file mode 100644 index a80a3b9fee..0000000000 --- a/rust/qemu-api-macros/src/bits.rs +++ /dev/null @@ -1,213 +0,0 @@ -// SPDX-License-Identifier: MIT or Apache-2.0 or GPL-2.0-or-later - -// shadowing is useful together with "if let" -#![allow(clippy::shadow_unrelated)] - -use proc_macro2::{ - Delimiter, Group, Ident, Punct, Spacing, Span, TokenStream, TokenTree, TokenTree as TT, -}; -use syn::Error; - -pub struct BitsConstInternal { - typ: TokenTree, -} - -fn paren(ts: TokenStream) -> TokenTree { - TT::Group(Group::new(Delimiter::Parenthesis, ts)) -} - -fn ident(s: &'static str) -> TokenTree { - TT::Ident(Ident::new(s, Span::call_site())) -} - -fn punct(ch: char) -> TokenTree { - TT::Punct(Punct::new(ch, Spacing::Alone)) -} - -/// Implements a recursive-descent parser that translates Boolean expressions on -/// bitmasks to invocations of `const` functions defined by the `bits!` macro. -impl BitsConstInternal { - // primary ::= '(' or ')' - // | ident - // | '!' ident - fn parse_primary( - &self, - tok: TokenTree, - it: &mut dyn Iterator<Item = TokenTree>, - out: &mut TokenStream, - ) -> Result<Option<TokenTree>, Error> { - let next = match tok { - TT::Group(ref g) => { - if g.delimiter() != Delimiter::Parenthesis && g.delimiter() != Delimiter::None { - return Err(Error::new(g.span(), "expected parenthesis")); - } - let mut stream = g.stream().into_iter(); - let Some(first_tok) = stream.next() else { - return Err(Error::new(g.span(), "expected operand, found ')'")); - }; - let mut output = TokenStream::new(); - // start from the lowest precedence - let next = self.parse_or(first_tok, &mut stream, &mut output)?; - if let Some(tok) = next { - return Err(Error::new(tok.span(), format!("unexpected token {tok}"))); - } - out.extend(Some(paren(output))); - it.next() - } - TT::Ident(_) => { - let mut output = TokenStream::new(); - output.extend([ - self.typ.clone(), - TT::Punct(Punct::new(':', Spacing::Joint)), - TT::Punct(Punct::new(':', Spacing::Joint)), - tok, - ]); - out.extend(Some(paren(output))); - it.next() - } - TT::Punct(ref p) => { - if p.as_char() != '!' { - return Err(Error::new(p.span(), "expected operand")); - } - let Some(rhs_tok) = it.next() else { - return Err(Error::new(p.span(), "expected operand at end of input")); - }; - let next = self.parse_primary(rhs_tok, it, out)?; - out.extend([punct('.'), ident("invert"), paren(TokenStream::new())]); - next - } - _ => { - return Err(Error::new(tok.span(), "unexpected literal")); - } - }; - Ok(next) - } - - fn parse_binop< - F: Fn( - &Self, - TokenTree, - &mut dyn Iterator<Item = TokenTree>, - &mut TokenStream, - ) -> Result<Option<TokenTree>, Error>, - >( - &self, - tok: TokenTree, - it: &mut dyn Iterator<Item = TokenTree>, - out: &mut TokenStream, - ch: char, - f: F, - method: &'static str, - ) -> Result<Option<TokenTree>, Error> { - let mut next = f(self, tok, it, out)?; - while next.is_some() { - let op = next.as_ref().unwrap(); - let TT::Punct(ref p) = op else { break }; - if p.as_char() != ch { - break; - } - - let Some(rhs_tok) = it.next() else { - return Err(Error::new(p.span(), "expected operand at end of input")); - }; - let mut rhs = TokenStream::new(); - next = f(self, rhs_tok, it, &mut rhs)?; - out.extend([punct('.'), ident(method), paren(rhs)]); - } - Ok(next) - } - - // sub ::= primary ('-' primary)* - pub fn parse_sub( - &self, - tok: TokenTree, - it: &mut dyn Iterator<Item = TokenTree>, - out: &mut TokenStream, - ) -> Result<Option<TokenTree>, Error> { - self.parse_binop(tok, it, out, '-', Self::parse_primary, "difference") - } - - // and ::= sub ('&' sub)* - fn parse_and( - &self, - tok: TokenTree, - it: &mut dyn Iterator<Item = TokenTree>, - out: &mut TokenStream, - ) -> Result<Option<TokenTree>, Error> { - self.parse_binop(tok, it, out, '&', Self::parse_sub, "intersection") - } - - // xor ::= and ('&' and)* - fn parse_xor( - &self, - tok: TokenTree, - it: &mut dyn Iterator<Item = TokenTree>, - out: &mut TokenStream, - ) -> Result<Option<TokenTree>, Error> { - self.parse_binop(tok, it, out, '^', Self::parse_and, "symmetric_difference") - } - - // or ::= xor ('|' xor)* - pub fn parse_or( - &self, - tok: TokenTree, - it: &mut dyn Iterator<Item = TokenTree>, - out: &mut TokenStream, - ) -> Result<Option<TokenTree>, Error> { - self.parse_binop(tok, it, out, '|', Self::parse_xor, "union") - } - - pub fn parse( - it: &mut dyn Iterator<Item = TokenTree>, - ) -> Result<proc_macro2::TokenStream, Error> { - let mut pos = Span::call_site(); - let mut typ = proc_macro2::TokenStream::new(); - - // Gobble everything up to an `@` sign, which is followed by a - // parenthesized expression; that is, all token trees except the - // last two form the type. - let next = loop { - let tok = it.next(); - if let Some(ref t) = tok { - pos = t.span(); - } - match tok { - None => break None, - Some(TT::Punct(ref p)) if p.as_char() == '@' => { - let tok = it.next(); - if let Some(ref t) = tok { - pos = t.span(); - } - break tok; - } - Some(x) => typ.extend(Some(x)), - } - }; - - let Some(tok) = next else { - return Err(Error::new( - pos, - "expected expression, do not call this macro directly", - )); - }; - let TT::Group(ref _group) = tok else { - return Err(Error::new( - tok.span(), - "expected parenthesis, do not call this macro directly", - )); - }; - let mut out = TokenStream::new(); - let state = Self { - typ: TT::Group(Group::new(Delimiter::None, typ)), - }; - - let next = state.parse_primary(tok, it, &mut out)?; - - // A parenthesized expression is a single production of the grammar, - // so the input must have reached the last token. - if let Some(tok) = next { - return Err(Error::new(tok.span(), format!("unexpected token {tok}"))); - } - Ok(out) - } -} |