~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/rust/macros/helpers.rs

Version: ~ [ linux-6.12-rc7 ] ~ [ linux-6.11.7 ] ~ [ linux-6.10.14 ] ~ [ linux-6.9.12 ] ~ [ linux-6.8.12 ] ~ [ linux-6.7.12 ] ~ [ linux-6.6.60 ] ~ [ linux-6.5.13 ] ~ [ linux-6.4.16 ] ~ [ linux-6.3.13 ] ~ [ linux-6.2.16 ] ~ [ linux-6.1.116 ] ~ [ linux-6.0.19 ] ~ [ linux-5.19.17 ] ~ [ linux-5.18.19 ] ~ [ linux-5.17.15 ] ~ [ linux-5.16.20 ] ~ [ linux-5.15.171 ] ~ [ linux-5.14.21 ] ~ [ linux-5.13.19 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.229 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.285 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.323 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.336 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.337 ] ~ [ linux-4.4.302 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.12 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

Diff markup

Differences between /rust/macros/helpers.rs (Version linux-6.12-rc7) and /rust/macros/helpers.rs (Version linux-5.5.19)


  1 // SPDX-License-Identifier: GPL-2.0               
  2                                                   
  3 use proc_macro::{token_stream, Group, TokenStr    
  4                                                   
  5 pub(crate) fn try_ident(it: &mut token_stream:    
  6     if let Some(TokenTree::Ident(ident)) = it.    
  7         Some(ident.to_string())                   
  8     } else {                                      
  9         None                                      
 10     }                                             
 11 }                                                 
 12                                                   
 13 pub(crate) fn try_literal(it: &mut token_strea    
 14     if let Some(TokenTree::Literal(literal)) =    
 15         Some(literal.to_string())                 
 16     } else {                                      
 17         None                                      
 18     }                                             
 19 }                                                 
 20                                                   
 21 pub(crate) fn try_string(it: &mut token_stream    
 22     try_literal(it).and_then(|string| {           
 23         if string.starts_with('\"') && string.    
 24             let content = &string[1..string.le    
 25             if content.contains('\\') {           
 26                 panic!("Escape sequences in st    
 27             }                                     
 28             Some(content.to_string())             
 29         } else if string.starts_with("r\"") {     
 30             panic!("Raw string literals are no    
 31         } else {                                  
 32             None                                  
 33         }                                         
 34     })                                            
 35 }                                                 
 36                                                   
 37 pub(crate) fn expect_ident(it: &mut token_stre    
 38     try_ident(it).expect("Expected Ident")        
 39 }                                                 
 40                                                   
 41 pub(crate) fn expect_punct(it: &mut token_stre    
 42     if let TokenTree::Punct(punct) = it.next()    
 43         punct.as_char()                           
 44     } else {                                      
 45         panic!("Expected Punct");                 
 46     }                                             
 47 }                                                 
 48                                                   
 49 pub(crate) fn expect_string(it: &mut token_str    
 50     try_string(it).expect("Expected string")      
 51 }                                                 
 52                                                   
 53 pub(crate) fn expect_string_ascii(it: &mut tok    
 54     let string = try_string(it).expect("Expect    
 55     assert!(string.is_ascii(), "Expected ASCII    
 56     string                                        
 57 }                                                 
 58                                                   
 59 pub(crate) fn expect_group(it: &mut token_stre    
 60     if let TokenTree::Group(group) = it.next()    
 61         group                                     
 62     } else {                                      
 63         panic!("Expected Group");                 
 64     }                                             
 65 }                                                 
 66                                                   
 67 pub(crate) fn expect_end(it: &mut token_stream    
 68     if it.next().is_some() {                      
 69         panic!("Expected end");                   
 70     }                                             
 71 }                                                 
 72                                                   
 73 /// Parsed generics.                              
 74 ///                                               
 75 /// See the field documentation for an explana    
 76 ///                                               
 77 /// # Examples                                    
 78 ///                                               
 79 /// ```rust,ignore                                
 80 /// # let input = todo!();                        
 81 /// let (Generics { decl_generics, impl_generi    
 82 /// quote! {                                      
 83 ///     struct Foo<$($decl_generics)*> {          
 84 ///         // ...                                
 85 ///     }                                         
 86 ///                                               
 87 ///     impl<$impl_generics> Foo<$ty_generics>    
 88 ///         fn foo() {                            
 89 ///             // ...                            
 90 ///         }                                     
 91 ///     }                                         
 92 /// }                                             
 93 /// ```                                           
 94 pub(crate) struct Generics {                      
 95     /// The generics with bounds and default v    
 96     ///                                           
 97     /// Use this on type definitions e.g. `str    
 98     pub(crate) decl_generics: Vec<TokenTree>,     
 99     /// The generics with bounds (e.g. `T: Clo    
100     ///                                           
101     /// Use this on `impl` blocks e.g. `impl<$    
102     pub(crate) impl_generics: Vec<TokenTree>,     
103     /// The generics without bounds and withou    
104     ///                                           
105     /// Use this when you use the type that is    
106     /// `Foo<$ty_generics>`.                      
107     pub(crate) ty_generics: Vec<TokenTree>,       
108 }                                                 
109                                                   
110 /// Parses the given `TokenStream` into `Gener    
111 ///                                               
112 /// The generics are not present in the rest,     
113 pub(crate) fn parse_generics(input: TokenStrea    
114     // The generics with bounds and default va    
115     let mut decl_generics = vec![];               
116     // `impl_generics`, the declared generics     
117     let mut impl_generics = vec![];               
118     // Only the names of the generics, without    
119     let mut ty_generics = vec![];                 
120     // Tokens not related to the generics e.g.    
121     let mut rest = vec![];                        
122     // The current level of `<`.                  
123     let mut nesting = 0;                          
124     let mut toks = input.into_iter();             
125     // If we are at the beginning of a generic    
126     let mut at_start = true;                      
127     let mut skip_until_comma = false;             
128     while let Some(tt) = toks.next() {            
129         if nesting == 1 && matches!(&tt, Token    
130             // Found the end of the generics.     
131             break;                                
132         } else if nesting >= 1 {                  
133             decl_generics.push(tt.clone());       
134         }                                         
135         match tt.clone() {                        
136             TokenTree::Punct(p) if p.as_char()    
137                 if nesting >= 1 && !skip_until    
138                     // This is inside of the g    
139                     impl_generics.push(tt);       
140                 }                                 
141                 nesting += 1;                     
142             }                                     
143             TokenTree::Punct(p) if p.as_char()    
144                 // This is a parsing error, so    
145                 if nesting == 0 {                 
146                     break;                        
147                 } else {                          
148                     nesting -= 1;                 
149                     if nesting >= 1 && !skip_u    
150                         // We are still inside    
151                         impl_generics.push(tt)    
152                     }                             
153                 }                                 
154             }                                     
155             TokenTree::Punct(p) if skip_until_    
156                 if nesting == 1 {                 
157                     impl_generics.push(tt.clon    
158                     impl_generics.push(tt);       
159                     skip_until_comma = false;     
160                 }                                 
161             }                                     
162             _ if !skip_until_comma => {           
163                 match nesting {                   
164                     // If we haven't entered t    
165                     0 => rest.push(tt),           
166                     1 => {                        
167                         // Here depending on t    
168                         match tt.clone() {        
169                             TokenTree::Ident(i    
170                                 let Some(name)    
171                                     // Parsing    
172                                     break;        
173                                 };                
174                                 impl_generics.    
175                                 impl_generics.    
176                                 ty_generics.pu    
177                                 decl_generics.    
178                                 at_start = fal    
179                             }                     
180                             TokenTree::Ident(_    
181                                 impl_generics.    
182                                 ty_generics.pu    
183                                 at_start = fal    
184                             }                     
185                             TokenTree::Punct(p    
186                                 impl_generics.    
187                                 ty_generics.pu    
188                                 at_start = tru    
189                             }                     
190                             // Lifetimes begin    
191                             TokenTree::Punct(p    
192                                 impl_generics.    
193                                 ty_generics.pu    
194                             }                     
195                             // Generics can ha    
196                             TokenTree::Punct(p    
197                                 skip_until_com    
198                             }                     
199                             _ => impl_generics    
200                         }                         
201                     }                             
202                     _ => impl_generics.push(tt    
203                 }                                 
204             }                                     
205             _ => {}                               
206         }                                         
207     }                                             
208     rest.extend(toks);                            
209     (                                             
210         Generics {                                
211             impl_generics,                        
212             decl_generics,                        
213             ty_generics,                          
214         },                                        
215         rest,                                     
216     )                                             
217 }                                                 
                                                      

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

sflogo.php