transpile: Factor out function for getting bytes of a literal

Author: Rua

c2rust-transpile/src/translator/literals.rs

@@ -151,31 +151,42 @@ impl<'c> Translation<'c> {
                 Ok(WithStmts::new_val(val))
             }
 
-            CLiteral::String(ref val, width) => {
-                let mut val = val.to_owned();
-                let num_elems = match self.ast_context.resolve_type(ty.ctype).kind {
-                    CTypeKind::ConstantArray(_elem_ty, num_elems) => num_elems,
-                    ref kind => {
-                        panic!("String literal with unknown size: {val:?}, kind = {kind:?}")
-                    }
-                };
-
-                // Match the literal size to the expected size padding with zeros as needed
-                let size = num_elems * (width as usize);
-                val.resize(size, 0);
+            CLiteral::String(ref bytes, element_size) => {
+                let bytes_padded = self.string_literal_bytes(ty.ctype, bytes, element_size);
 
                 // std::mem::transmute::<[u8; size], ctype>(*b"xxxx")
-                let u8_ty = mk().path_ty(vec!["u8"]);
-                let width_lit = mk().lit_expr(mk().int_unsuffixed_lit(val.len() as u128));
-                Ok(WithStmts::new_unsafe_val(transmute_expr(
-                    mk().array_ty(u8_ty, width_lit),
+                let array_ty = mk().array_ty(
+                    mk().ident_ty("u8"),
+                    mk().lit_expr(bytes_padded.len() as u128),
+                );
+                let val = transmute_expr(
+                    array_ty,
                     self.convert_type(ty.ctype)?,
-                    mk().unary_expr(UnOp::Deref(Default::default()), mk().lit_expr(val)),
-                )))
+                    mk().unary_expr(UnOp::Deref(Default::default()), mk().lit_expr(bytes_padded)),
+                );
+                Ok(WithStmts::new_unsafe_val(val))
             }
         }
     }
 
+    /// Returns the bytes of a string literal, including any additional zero bytes to pad the
+    /// literal to the expected size.
+    pub fn string_literal_bytes(&self, ctype: CTypeId, bytes: &[u8], element_size: u8) -> Vec<u8> {
+        let num_elems = match self.ast_context.resolve_type(ctype).kind {
+            CTypeKind::ConstantArray(_, num_elems) => num_elems,
+            ref kind => {
+                panic!("String literal with unknown size: {bytes:?}, kind = {kind:?}")
+            }
+        };
+
+        let size = num_elems * (element_size as usize);
+        let mut bytes_padded = Vec::with_capacity(size);
+        bytes_padded.extend(bytes);
+        bytes_padded.resize(size, 0);
+
+        bytes_padded
+    }
+
     /// Convert an initialization list into an expression. These initialization lists can be
     /// used as array literals, struct literals, and union literals in code.
     pub fn convert_init_list(

c2rust-transpile/src/translator/mod.rs

@@ -4729,16 +4729,20 @@ impl<'c> Translation<'c> {
                     })
                     .unwrap_or(false);
                 match expr_kind {
-                    Some(&CExprKind::Literal(_, CLiteral::String(ref bytes, 1)))
-                        if is_const && !translate_as_macro =>
-                    {
+                    Some(&CExprKind::Literal(
+                        literal_cqual_type,
+                        CLiteral::String(ref bytes, element_size @ 1),
+                    )) if is_const && !translate_as_macro => {
                         let target_ty = self.convert_type(target_cty.ctype)?;
 
-                        let mut bytes = bytes.to_owned();
-                        bytes.push(0);
-                        let byte_literal = mk().lit_expr(bytes);
-                        let val =
-                            mk().cast_expr(byte_literal, mk().ptr_ty(mk().path_ty(vec!["u8"])));
+                        let bytes_padded = self.string_literal_bytes(
+                            literal_cqual_type.ctype,
+                            bytes,
+                            element_size,
+                        );
+                        let element_ty = mk().ident_ty("u8");
+                        let bytes_literal = mk().lit_expr(bytes_padded);
+                        let val = mk().cast_expr(bytes_literal, mk().ptr_ty(element_ty));
                         let val = mk().cast_expr(val, target_ty);
                         Ok(WithStmts::new_val(val))
                     }

c2rust-transpile/src/translator/operators.rs

@@ -968,21 +968,11 @@ impl<'c> Translation<'c> {
                         false,
                     ) = (expr_kind, translate_as_macro)
                     {
-                        let num_elems =
-                            match self.ast_context.resolve_type(literal_cqual_type.ctype).kind {
-                                CTypeKind::ConstantArray(_, num_elems) => num_elems,
-                                ref kind => {
-                                    panic!(
-                                    "String literal with unknown size: {bytes:?}, kind = {kind:?}"
-                                )
-                                }
-                            };
-
-                        // Match the literal size to the expected size padding with zeros as needed
-                        let size = num_elems * (element_size as usize);
-                        let mut bytes_padded = Vec::with_capacity(size);
-                        bytes_padded.extend(bytes);
-                        bytes_padded.resize(size, 0);
+                        let bytes_padded = self.string_literal_bytes(
+                            literal_cqual_type.ctype,
+                            bytes,
+                            element_size,
+                        );
 
                         let array_ty = mk().array_ty(
                             mk().ident_ty("u8"),