@@ -256,7 +256,7 @@ pub enum Name<'a> {
256256 Template ( Box < Name < ' a > > , Params < ' a > ) ,
257257 Discriminator ( i32 ) ,
258258 ParsedName ( Box < ParseResult < ' a > > ) ,
259- AnonymousNamespace ,
259+ AnonymousNamespace ( Option < String > ) ,
260260}
261261
262262impl < ' a > fmt:: Debug for Name < ' a > {
@@ -272,7 +272,9 @@ impl<'a> fmt::Debug for Name<'a> {
272272 }
273273 Name :: Discriminator ( i) => f. debug_tuple ( "Discriminator" ) . field ( & i) . finish ( ) ,
274274 Name :: ParsedName ( ref res) => f. debug_tuple ( "ParsedName" ) . field ( res) . finish ( ) ,
275- Name :: AnonymousNamespace => f. debug_tuple ( "AnonymousNamespace" ) . finish ( ) ,
275+ Name :: AnonymousNamespace ( ref name) => {
276+ f. debug_tuple ( "AnonymousNamespace" ) . field ( name) . finish ( )
277+ }
276278 }
277279 }
278280}
@@ -489,13 +491,13 @@ impl<'a> ParserState<'a> {
489491 if self . consume ( b"$" ) {
490492 if self . consume ( b"TSS" ) {
491493 let mut guard_num: i32 = i32:: from (
492- self . consume_digit ( )
494+ self . read_digit ( )
493495 . ok_or_else ( || self . fail ( "missing digit" ) ) ?,
494496 ) ;
495497 while !self . consume ( b"@" ) {
496498 guard_num = guard_num * 10
497499 + i32:: from (
498- self . consume_digit ( )
500+ self . read_digit ( )
499501 . ok_or_else ( || self . fail ( "missing digit" ) ) ?,
500502 ) ;
501503 }
@@ -690,7 +692,7 @@ impl<'a> ParserState<'a> {
690692 }
691693 }
692694
693- fn consume_digit ( & mut self ) -> Option < u8 > {
695+ fn read_digit ( & mut self ) -> Option < u8 > {
694696 match self . peek ( ) {
695697 Some ( first) => {
696698 if char:: from ( first) . is_digit ( 10 ) {
@@ -704,17 +706,17 @@ impl<'a> ParserState<'a> {
704706 }
705707 }
706708
707- fn consume_hex_digit ( & mut self ) -> bool {
709+ fn read_hex_digit ( & mut self ) -> Option < char > {
708710 match self . peek ( ) {
709711 Some ( first) => {
710712 if char:: from ( first) . is_digit ( 16 ) {
711713 self . advance ( 1 ) ;
712- true
714+ Some ( first as char )
713715 } else {
714- false
716+ None
715717 }
716718 }
717- None => false ,
719+ None => None ,
718720 }
719721 }
720722
@@ -779,7 +781,7 @@ impl<'a> ParserState<'a> {
779781 fn read_number ( & mut self ) -> Result < i32 > {
780782 let neg = self . consume ( b"?" ) ;
781783
782- if let Some ( digit) = self . consume_digit ( ) {
784+ if let Some ( digit) = self . read_digit ( ) {
783785 let ret = digit + 1 ;
784786 return Ok ( if neg { -i32:: from ( ret) } else { i32:: from ( ret) } ) ;
785787 }
@@ -852,7 +854,7 @@ impl<'a> ParserState<'a> {
852854 }
853855
854856 fn read_nested_name ( & mut self ) -> Result < Name < ' a > > {
855- let name = if let Some ( i) = self . consume_digit ( ) {
857+ let name = if let Some ( i) = self . read_digit ( ) {
856858 let i = i as usize ;
857859 if i >= self . memorized_names . len ( ) {
858860 return Err ( self . fail ( "name reference too large" ) ) ;
@@ -867,12 +869,22 @@ impl<'a> ParserState<'a> {
867869 self . memorize_name ( & name) ;
868870 name
869871 } else if self . consume ( b"A" ) {
870- // A__cdecl *instanc'onymous namespace.
871- if self . consume ( b"0x" ) {
872- while self . consume_hex_digit ( ) { }
873- }
872+ let id = if self . consume ( b"0x" ) {
873+ let mut name = String :: from ( "0x" ) ;
874+ while let Some ( c) = self . read_hex_digit ( ) {
875+ name. push ( c) ;
876+ }
877+ Some ( name)
878+ } else {
879+ None
880+ } ;
874881 self . expect ( b"@" ) ?;
875- Name :: AnonymousNamespace
882+ let memorize = id. is_some ( ) ;
883+ let name = Name :: AnonymousNamespace ( id) ;
884+ if memorize {
885+ self . memorize_name ( & name) ;
886+ }
887+ name
876888 } else {
877889 let discriminator = self . read_number ( ) ?;
878890 Name :: Discriminator ( discriminator)
@@ -890,7 +902,7 @@ impl<'a> ParserState<'a> {
890902 }
891903
892904 fn read_unqualified_name ( & mut self , function : bool ) -> Result < Name < ' a > > {
893- let name = if let Some ( i) = self . consume_digit ( ) {
905+ let name = if let Some ( i) = self . read_digit ( ) {
894906 let i = i as usize ;
895907 if i >= self . memorized_names . len ( ) {
896908 return Err ( self . fail ( "name reference too large" ) ) ;
@@ -1286,7 +1298,7 @@ impl<'a> ParserState<'a> {
12861298 return Ok ( Type :: TemplateParameterWithIndex ( -n) ) ;
12871299 }
12881300
1289- if let Some ( n) = self . consume_digit ( ) {
1301+ if let Some ( n) = self . read_digit ( ) {
12901302 if n as usize >= self . memorized_types . len ( ) {
12911303 return Err ( self . fail_args ( format_args ! ( "invalid backreference: {}" , n) ) ) ;
12921304 }
@@ -1393,7 +1405,7 @@ impl<'a> ParserState<'a> {
13931405 && !self . remaining . starts_with ( b"Z" )
13941406 && !self . remaining . is_empty ( )
13951407 {
1396- if let Some ( n) = self . consume_digit ( ) {
1408+ if let Some ( n) = self . read_digit ( ) {
13971409 if n as usize >= self . memorized_types . len ( ) {
13981410 return Err ( self . fail_args ( format_args ! ( "invalid backreference: {}" , n) ) ) ;
13991411 }
@@ -2103,7 +2115,7 @@ impl<'a> Serializer<'a> {
21032115 Name :: ParsedName ( ref val) => {
21042116 write ! ( self . w, "`{}'" , serialize( val, self . flags) ?) ?;
21052117 }
2106- Name :: AnonymousNamespace => {
2118+ Name :: AnonymousNamespace ( _ ) => {
21072119 write ! ( self . w, "`anonymous namespace'" ) ?;
21082120 }
21092121 }
@@ -2200,7 +2212,7 @@ impl<'a> Serializer<'a> {
22002212 Name :: ParsedName ( ref val) => {
22012213 write ! ( self . w, "{}" , serialize( val, self . flags) ?) ?;
22022214 }
2203- Name :: AnonymousNamespace => {
2215+ Name :: AnonymousNamespace ( _ ) => {
22042216 // this should never happen as they are handled elsewhere
22052217 debug_assert ! ( false , "not supposed to be here" ) ;
22062218 }
0 commit comments