c, b made behave like C

Author: zsoltoroszlany82

CHANGELOG.md

@@ -2,6 +2,16 @@
 
 All notable changes to the pyprintf project will be documented in this file.
 
+## [0.0.8] - 2025-04-18
+
+**Character Handling (`%c`):**  
+* Added modulo 256 truncation to align with C's `unsigned char` behavior, ensuring values wrap within 0-255.  
+* Negative inputs now wrap via modulo 256 (e.g., `-1` becomes `255`).  
+
+**Binary Handling (`%b`):**  
+* Negative numbers now use 32-bit two's complement (e.g., `-5` becomes `11111111111111111111111111111011`).  
+* Values are truncated to 32 bits via `& 0xFFFFFFFF` to mimic C's integer overflow.  
+
 ## [0.0.7] - 2025-04-18
 
 * Normalized scientific notation format (`e`, `E`) to align with C++ conventions.

src/pyprintf/core.py

@@ -508,14 +508,20 @@ def sprintf_format(
         # Process argument based on format specifier
         if placeholder.type == "b":  # Binary
             try:
-                arg = bin(int(arg))[2:]  # Remove '0b' prefix
+                num = int(arg)
+                # Truncate to 32 bits (like C's `int`)
+                num = num & 0xFFFFFFFF
+                # Convert to two's complement for negatives
+                if num < 0:
+                    num += 0x100000000
+                arg = bin(num)[2:]
             except (ValueError, TypeError):
                 arg = "0"
 
         elif placeholder.type == "c":  # Character
             try:
-                arg = chr(int(arg))
-            except (ValueError, TypeError, OverflowError):
+                arg = chr(int(arg) % 256) # Wrap to 0-255 like C's unsigned char
+            except (ValueError, TypeError):
                 arg = "\0"
 
         elif placeholder.type in ("d", "i"):  # Integer

tests/test_sprintf.py

@@ -19,11 +19,23 @@ def test_format_a_percentage_sign(self):
         assert sprintf("%%") == "%"
 
     def test_format_a_binary_number(self):
-        assert sprintf("%b", 2) == "10"
+        assert sprintf("%b", 10) == "1010"
+
+    def test_format_a_binary_negative_number(self):
+        assert sprintf("%b", -5) == "11111111111111111111111111111011"
+
+    def test_format_a_binary_number_overflow(self):
+        assert sprintf("%b", 256) == "100000000"
 
     def test_format_a_character(self):
         assert sprintf("%c", 65) == "A"
 
+    def test_format_a_character_overflow(self):
+        assert sprintf("%c", 256) == "\x00"
+
+    def test_format_a_character_negative(self):
+        assert sprintf("%c", -1) == "ÿ"
+
     def test_format_a_decimal_integer(self):
         assert sprintf("%d", 2) == "2"
 
@@ -333,7 +345,7 @@ def test_format_a_large_number_exceeding_32_bits_correctly_as_a_hexadecimal_stri
 
     def test_format_a_binary_number_using_lambda(self):
         cfg = config().allow_computed_value(True)
-        assert cfg.sprintf("%b", lambda: 2) == "10"
+        assert cfg.sprintf("%b", lambda: 10) == "1010"
 
     def test_format_a_character_using_lambda(self):
         cfg = config().allow_computed_value(True)