RustPython
diff --git a/‎vm/src/builtins/pystr.rs
Copy file name to clipboardExpand all lines: vm/src/builtins/pystr.rs
+21Lines changed: 21 additions & 0 deletions b/‎vm/src/builtins/pystr.rs
Copy file name to clipboardExpand all lines: vm/src/builtins/pystr.rs
+21Lines changed: 21 additions & 0 deletions
@@ -41,6 +41,7 @@ use unicode_casing::CharExt;
 pub(crate) enum PyStrKind {
     Ascii,
     Utf8,
+    U32,
 }
 
 impl std::ops::BitOr for PyStrKind {
@@ -58,6 +59,7 @@ impl PyStrKind {
         match self {
             PyStrKind::Ascii => PyStrKindData::Ascii,
             PyStrKind::Utf8 => PyStrKindData::Utf8(Radium::new(usize::MAX)),
+            PyStrKind::U32 => PyStrKindData::U32,
         }
     }
 }
@@ -67,13 +69,15 @@ enum PyStrKindData {
     Ascii,
     // uses usize::MAX as a sentinel for "uncomputed"
     Utf8(PyAtomic<usize>),
+    U32,
 }
 
 impl PyStrKindData {
     fn kind(&self) -> PyStrKind {
         match self {
             PyStrKindData::Ascii => PyStrKind::Ascii,
             PyStrKindData::Utf8(_) => PyStrKind::Utf8,
+            PyStrKindData::U32 => PyStrKind::U32,
         }
     }
 }
@@ -361,13 +365,23 @@ impl PyStr {
         }
     }
 
+    fn as_u32_slice(&self) -> &[u32] {
+        assert_eq!(self.kind.kind(), PyStrKind::U32);
+        assert_eq!(self.bytes.len() % 4, 0);
+        let (prefix, reslice, suffix) = unsafe { self.bytes.as_slice().align_to::<u32>() };
+        assert_eq!(prefix.len(), 0);
+        assert_eq!(suffix.len(), 0);
+        reslice
+    }
+
     fn char_all<F>(&self, test: F) -> bool
     where
         F: Fn(char) -> bool,
     {
         match self.kind.kind() {
             PyStrKind::Ascii => self.bytes.iter().all(|&x| test(char::from(x))),
             PyStrKind::Utf8 => self.as_str().chars().all(test),
+            PyStrKind::U32 => unimplemented!(),
         }
     }
 }
@@ -466,6 +480,7 @@ impl PyStr {
                 usize::MAX => self._compute_char_len(),
                 len => len,
             },
+            PyStrKindData::U32 => self.bytes.len() / 4,
         }
     }
     #[cold]
@@ -490,6 +505,7 @@ impl PyStr {
         match self.kind {
             PyStrKindData::Ascii => true,
             PyStrKindData::Utf8(_) => false,
+            PyStrKindData::U32 => false,
         }
     }
 
@@ -531,6 +547,7 @@ impl PyStr {
         match self.kind.kind() {
             PyStrKind::Ascii => self.as_str().to_ascii_lowercase(),
             PyStrKind::Utf8 => self.as_str().to_lowercase(),
+            PyStrKind::U32 => unimplemented!(),
         }
     }
 
@@ -545,6 +562,7 @@ impl PyStr {
         match self.kind.kind() {
             PyStrKind::Ascii => self.as_str().to_ascii_uppercase(),
             PyStrKind::Utf8 => self.as_str().to_uppercase(),
+            PyStrKind::U32 => unimplemented!(),
         }
     }
 
@@ -597,6 +615,7 @@ impl PyStr {
                 |v, s, n, vm| v.splitn(n, s).map(|s| vm.ctx.new_str(s).into()).collect(),
                 |v, n, vm| v.py_split_whitespace(n, |s| vm.ctx.new_str(s).into()),
             ),
+            PyStrKind::U32 => unimplemented!(),
         }?;
         Ok(elements)
     }
@@ -880,6 +899,7 @@ impl PyStr {
             PyStrKind::Utf8 => self
                 .as_str()
                 .py_iscase(char::is_lowercase, char::is_uppercase),
+            PyStrKind::U32 => unimplemented!(),
         }
     }
 
@@ -891,6 +911,7 @@ impl PyStr {
             PyStrKind::Utf8 => self
                 .as_str()
                 .py_iscase(char::is_uppercase, char::is_lowercase),
+            PyStrKind::U32 => unimplemented!(),
         }
     }
Original file line number	Diff line number	Diff line change
`@@ -41,6 +41,7 @@ use unicode_casing::CharExt;`
`41`	`41`	`pub(crate) enum PyStrKind {`
`42`	`42`	`Ascii,`
`43`	`43`	`Utf8,`
	`44`	`+ U32,`
`44`	`45`	`}`
`45`	`46`
`46`	`47`	`impl std::ops::BitOr for PyStrKind {`
`@@ -58,6 +59,7 @@ impl PyStrKind {`
`58`	`59`	`match self {`
`59`	`60`	`PyStrKind::Ascii => PyStrKindData::Ascii,`
`60`	`61`	`PyStrKind::Utf8 => PyStrKindData::Utf8(Radium::new(usize::MAX)),`
	`62`	`+ PyStrKind::U32 => PyStrKindData::U32,`
`61`	`63`	`}`
`62`	`64`	`}`
`63`	`65`	`}`
`@@ -67,13 +69,15 @@ enum PyStrKindData {`
`67`	`69`	`Ascii,`
`68`	`70`	`// uses usize::MAX as a sentinel for "uncomputed"`
`69`	`71`	`Utf8(PyAtomic<usize>),`
	`72`	`+ U32,`
`70`	`73`	`}`
`71`	`74`
`72`	`75`	`impl PyStrKindData {`
`73`	`76`	`fn kind(&self) -> PyStrKind {`
`74`	`77`	`match self {`
`75`	`78`	`PyStrKindData::Ascii => PyStrKind::Ascii,`
`76`	`79`	`PyStrKindData::Utf8(_) => PyStrKind::Utf8,`
	`80`	`+ PyStrKindData::U32 => PyStrKind::U32,`
`77`	`81`	`}`
`78`	`82`	`}`
`79`	`83`	`}`
`@@ -361,13 +365,23 @@ impl PyStr {`
`361`	`365`	`}`
`362`	`366`	`}`
`363`	`367`
	`368`	`+ fn as_u32_slice(&self) -> &[u32] {`
	`369`	`+ assert_eq!(self.kind.kind(), PyStrKind::U32);`
	`370`	`+ assert_eq!(self.bytes.len() % 4, 0);`
	`371`	`+ let (prefix, reslice, suffix) = unsafe { self.bytes.as_slice().align_to::<u32>() };`
	`372`	`+ assert_eq!(prefix.len(), 0);`
	`373`	`+ assert_eq!(suffix.len(), 0);`
	`374`	`+ reslice`
	`375`	`+ }`
	`376`	`+`
`364`	`377`	`fn char_all<F>(&self, test: F) -> bool`
`365`	`378`	`where`
`366`	`379`	`F: Fn(char) -> bool,`
`367`	`380`	`{`
`368`	`381`	`match self.kind.kind() {`
`369`	`382`	`PyStrKind::Ascii => self.bytes.iter().all(\|&x\| test(char::from(x))),`
`370`	`383`	`PyStrKind::Utf8 => self.as_str().chars().all(test),`
	`384`	`+ PyStrKind::U32 => unimplemented!(),`
`371`	`385`	`}`
`372`	`386`	`}`
`373`	`387`	`}`
`@@ -466,6 +480,7 @@ impl PyStr {`
`466`	`480`	`usize::MAX => self._compute_char_len(),`
`467`	`481`	`len => len,`
`468`	`482`	`},`
	`483`	`+ PyStrKindData::U32 => self.bytes.len() / 4,`
`469`	`484`	`}`
`470`	`485`	`}`
`471`	`486`	`#[cold]`
`@@ -490,6 +505,7 @@ impl PyStr {`
`490`	`505`	`match self.kind {`
`491`	`506`	`PyStrKindData::Ascii => true,`
`492`	`507`	`PyStrKindData::Utf8(_) => false,`
	`508`	`+ PyStrKindData::U32 => false,`
`493`	`509`	`}`
`494`	`510`	`}`
`495`	`511`
`@@ -531,6 +547,7 @@ impl PyStr {`
`531`	`547`	`match self.kind.kind() {`
`532`	`548`	`PyStrKind::Ascii => self.as_str().to_ascii_lowercase(),`
`533`	`549`	`PyStrKind::Utf8 => self.as_str().to_lowercase(),`
	`550`	`+ PyStrKind::U32 => unimplemented!(),`
`534`	`551`	`}`
`535`	`552`	`}`
`536`	`553`
`@@ -545,6 +562,7 @@ impl PyStr {`
`545`	`562`	`match self.kind.kind() {`
`546`	`563`	`PyStrKind::Ascii => self.as_str().to_ascii_uppercase(),`
`547`	`564`	`PyStrKind::Utf8 => self.as_str().to_uppercase(),`
	`565`	`+ PyStrKind::U32 => unimplemented!(),`
`548`	`566`	`}`
`549`	`567`	`}`
`550`	`568`
`@@ -597,6 +615,7 @@ impl PyStr {`
`597`	`615`	`\|v, s, n, vm\| v.splitn(n, s).map(\|s\| vm.ctx.new_str(s).into()).collect(),`
`598`	`616`	`\|v, n, vm\| v.py_split_whitespace(n, \|s\| vm.ctx.new_str(s).into()),`
`599`	`617`	`),`
	`618`	`+ PyStrKind::U32 => unimplemented!(),`
`600`	`619`	`}?;`
`601`	`620`	`Ok(elements)`
`602`	`621`	`}`
`@@ -880,6 +899,7 @@ impl PyStr {`
`880`	`899`	`PyStrKind::Utf8 => self`
`881`	`900`	`.as_str()`
`882`	`901`	`.py_iscase(char::is_lowercase, char::is_uppercase),`
	`902`	`+ PyStrKind::U32 => unimplemented!(),`
`883`	`903`	`}`
`884`	`904`	`}`
`885`	`905`
`@@ -891,6 +911,7 @@ impl PyStr {`
`891`	`911`	`PyStrKind::Utf8 => self`
`892`	`912`	`.as_str()`
`893`	`913`	`.py_iscase(char::is_uppercase, char::is_lowercase),`
	`914`	`+ PyStrKind::U32 => unimplemented!(),`
`894`	`915`	`}`
`895`	`916`	`}`
`896`	`917`