Support '*' for width and precsision for printf-style formatting

Author: michelhe

vm/src/cformat.rs

@@ -1,4 +1,4 @@
-use crate::format::{parse_number, parse_precision};
+use crate::format::get_num_digits;
 /// Implementation of Printf-Style string formatting
 /// [https://docs.python.org/3/library/stdtypes.html#printf-style-string-formatting]
 use num_bigint::{BigInt, Sign};
@@ -70,12 +70,18 @@ bitflags! {
     }
 }
 
+#[derive(Debug, PartialEq)]
+pub enum CFormatQuantity {
+    Amount(usize),
+    FromValuesTuple,
+}
+
 #[derive(Debug, PartialEq)]
 pub struct CFormatSpec {
     pub mapping_key: Option<String>,
     pub flags: CConversionFlags,
-    pub min_field_width: Option<usize>,
-    pub precision: Option<usize>,
+    pub min_field_width: Option<CFormatQuantity>,
+    pub precision: Option<CFormatQuantity>,
     pub format_type: CFormatType,
     pub format_char: char,
     chars_consumed: usize,
@@ -101,8 +107,8 @@ impl CFormatSpec {
         let num_chars = num_chars;
 
         let width = match self.min_field_width {
-            Some(width) => cmp::max(width, num_chars),
-            None => num_chars,
+            Some(CFormatQuantity::Amount(width)) => cmp::max(width, num_chars),
+            _ => num_chars,
         };
         let fill_chars_needed = width - num_chars;
         let fill_string = CFormatSpec::compute_fill_string(fill_char, fill_chars_needed);
@@ -121,7 +127,7 @@ impl CFormatSpec {
     pub fn format_string(&self, string: String) -> String {
         let mut string = string;
         // truncate if needed
-        if let Some(precision) = self.precision {
+        if let Some(CFormatQuantity::Amount(precision)) = self.precision {
             if string.len() > precision {
                 string.truncate(precision);
             }
@@ -242,6 +248,32 @@ impl FromStr for CFormatString {
     }
 }
 
+fn parse_quantity(text: &str) -> (Option<CFormatQuantity>, &str) {
+    let num_digits: usize = get_num_digits(text);
+    if num_digits == 0 {
+        let mut chars = text.chars();
+        return match chars.next() {
+            Some('*') => (Some(CFormatQuantity::FromValuesTuple), chars.as_str()),
+            _ => (None, text),
+        };
+    }
+    // This should never fail
+    (
+        Some(CFormatQuantity::Amount(
+            text[..num_digits].parse::<usize>().unwrap(),
+        )),
+        &text[num_digits..],
+    )
+}
+
+fn parse_precision(text: &str) -> (Option<CFormatQuantity>, &str) {
+    let mut chars = text.chars();
+    match chars.next() {
+        Some('.') => parse_quantity(&chars.as_str()),
+        _ => (None, text),
+    }
+}
+
 fn parse_literal_single(text: &str) -> Result<(char, &str), CFormatErrorType> {
     let mut chars = text.chars();
     // TODO get rid of the unwrap
@@ -445,7 +477,7 @@ impl FromStr for CFormatSpec {
         let (mapping_key, after_mapping_key) =
             parse_spec_mapping_key(chars.as_str()).map_err(|err| (err, consumed))?;
         let (flags, after_flags) = parse_flags(after_mapping_key);
-        let (width, after_width) = parse_number(after_flags);
+        let (width, after_width) = parse_quantity(after_flags);
         let (precision, after_precision) = parse_precision(after_width);
         // A length modifier (h, l, or L) may be present,
         // but is ignored as it is not necessary for Python – so e.g. %ld is identical to %d.
@@ -459,7 +491,7 @@ impl FromStr for CFormatSpec {
         let precision = match precision {
             Some(precision) => Some(precision),
             None => match format_type {
-                CFormatType::Float(_) => Some(6),
+                CFormatType::Float(_) => Some(CFormatQuantity::Amount(6)),
                 _ => None,
             },
         };
@@ -575,7 +607,7 @@ mod tests {
             format_type: CFormatType::Number(CNumberType::Decimal),
             format_char: 'd',
             chars_consumed: 17,
-            min_field_width: Some(10),
+            min_field_width: Some(CFormatQuantity::Amount(10)),
             precision: None,
             mapping_key: None,
             flags: CConversionFlags::all(),

vm/src/format.rs

@@ -110,7 +110,7 @@ pub struct FormatSpec {
     format_type: Option<FormatType>,
 }
 
-fn get_num_digits(text: &str) -> usize {
+pub fn get_num_digits(text: &str) -> usize {
     for (index, character) in text.char_indices() {
         if !character.is_digit(10) {
             return index;
@@ -151,7 +151,7 @@ fn parse_fill_and_align(text: &str) -> (Option<char>, Option<FormatAlign>, &str)
     }
 }
 
-pub fn parse_number(text: &str) -> (Option<usize>, &str) {
+fn parse_number(text: &str) -> (Option<usize>, &str) {
     let num_digits: usize = get_num_digits(text);
     if num_digits == 0 {
         return (None, text);
@@ -189,7 +189,7 @@ fn parse_zero(text: &str) -> &str {
     }
 }
 
-pub fn parse_precision(text: &str) -> (Option<usize>, &str) {
+fn parse_precision(text: &str) -> (Option<usize>, &str) {
     let mut chars = text.chars();
     match chars.next() {
         Some('.') => {

vm/src/obj/objstr.rs

@@ -12,8 +12,8 @@ use unicode_segmentation::UnicodeSegmentation;
 use unicode_xid::UnicodeXID;
 
 use crate::cformat::{
-    CFormatErrorType, CFormatPart, CFormatPreconversor, CFormatSpec, CFormatString, CFormatType,
-    CNumberType,
+    CFormatErrorType, CFormatPart, CFormatPreconversor, CFormatQuantity, CFormatSpec,
+    CFormatString, CFormatType, CNumberType,
 };
 use crate::format::{FormatParseError, FormatPart, FormatPreconversor, FormatString};
 use crate::function::{single_or_tuple_any, OptionalArg, PyFuncArgs};
@@ -1146,7 +1146,7 @@ fn do_cformat_specifier(
 
 fn do_cformat(
     vm: &VirtualMachine,
-    format_string: CFormatString,
+    mut format_string: CFormatString,
     values_obj: PyObjectRef,
 ) -> PyResult {
     let mut final_string = String::new();
@@ -1169,7 +1169,7 @@ fn do_cformat(
         if !objtype::isinstance(&values_obj, &vm.ctx.dict_type()) {
             return Err(vm.new_type_error("format requires a mapping".to_string()));
         }
-        values_obj
+        values_obj.clone()
     } else {
         // check for only literal parts, in which case only empty tuple is allowed
         if 0 == num_specifiers
@@ -1190,7 +1190,7 @@ fn do_cformat(
     };
 
     let mut auto_index: usize = 0;
-    for (_, part) in &format_string.format_parts {
+    for (_, part) in &mut format_string.format_parts {
         let result_string: String = match part {
             CFormatPart::Spec(format_spec) => {
                 // try to get the object
@@ -1200,8 +1200,42 @@ fn do_cformat(
                         call_getitem(vm, &values_obj, &vm.ctx.new_str(key.to_string()))?
                     }
                     None => {
-                        let elements = objtuple::get_value(&values_obj);
-                        let obj = match elements.into_iter().nth(auto_index) {
+                        let mut elements = objtuple::get_value(&values_obj)
+                            .into_iter()
+                            .skip(auto_index);
+
+                        let mut try_quantity_from_tuple = |q: &mut Option<CFormatQuantity>| {
+                            match q {
+                                Some(CFormatQuantity::FromValuesTuple) => {
+                                    match elements.next() {
+                                        Some(width_obj) => {
+                                            auto_index += 1;
+                                            if !objtype::isinstance(&width_obj, &vm.ctx.int_type())
+                                            {
+                                                Err(vm.new_type_error("* wants int".to_string()))
+                                            } else {
+                                                // TODO: handle errors when truncating BigInt to usize
+                                                *q = Some(CFormatQuantity::Amount(
+                                                    objint::get_value(&width_obj)
+                                                        .to_usize()
+                                                        .unwrap(),
+                                                ));
+                                                Ok(())
+                                            }
+                                        }
+                                        None => Err(vm.new_type_error(
+                                            "not enough arguments for format string".to_string(),
+                                        )),
+                                    }
+                                }
+                                _ => Ok(()),
+                            }
+                        };
+
+                        try_quantity_from_tuple(&mut format_spec.min_field_width)?;
+                        try_quantity_from_tuple(&mut format_spec.precision)?;
+
+                        let obj = match elements.next() {
                             Some(obj) => Ok(obj),
                             None => Err(vm.new_type_error(
                                 "not enough arguments for format string".to_string(),