[mycpp/runtime] Move hex/octal functions from mylib -> mops

So they can support mops::BigInt, which is 64 bits, and used in printf.

Author: Andy C

builtin/printf_osh.py

@@ -31,6 +31,7 @@
 from frontend import lexer
 from frontend import match
 from frontend import reader
+from mycpp import mops
 from mycpp import mylib
 from mycpp.mylib import log
 from osh import sh_expr_eval
@@ -378,14 +379,15 @@ def _Percent(self, pr, part, varargs, locs):
                         "Can't format negative number %d with %%%s" % (d, typ),
                         part.type)
 
+                big_d = mops.IntWiden(d)
                 if typ == 'o':
-                    s = mylib.octal(d)
+                    s = mops.ToOctal(big_d)
                 elif typ == 'x':
-                    s = mylib.hex_lower(d)
+                    s = mops.ToHexLower(big_d)
                 elif typ == 'X':
-                    s = mylib.hex_upper(d)
+                    s = mops.ToHexUpper(big_d)
                 else:  # diu
-                    s = str(d)  # without spaces like ' -42 '
+                    s = mops.ToStr(big_d)  # without spaces like ' -42 '
 
                 # There are TWO different ways to ZERO PAD, and they differ on
                 # the negative sign!  See spec/builtin-printf

mycpp/gc_mops.cc

@@ -1,6 +1,7 @@
 #include "mycpp/gc_mops.h"
 
 #include <errno.h>
+#include <inttypes.h>  // PRIo64, PRIx64
 #include <stdio.h>
 
 #include "mycpp/gc_alloc.h"
@@ -15,12 +16,32 @@ const BigInt MINUS_ONE = BigInt{-1};
 
 static const int kInt64BufSize = 32;  // more than twice as big as kIntBufSize
 
-// Copied from gc_builtins - str(int i)
+// Note: Could also use OverAllocatedStr, but most strings are small?
+
+// Similar to str(int i) in gc_builtins.cc
+
 BigStr* ToStr(BigInt b) {
-  BigStr* s = OverAllocatedStr(kInt64BufSize);
-  int length = snprintf(s->data(), kInt64BufSize, "%ld", b);
-  s->MaybeShrink(length);
-  return s;
+  char buf[kInt64BufSize];
+  int len = snprintf(buf, kInt64BufSize, "%" PRId64, b);
+  return ::StrFromC(buf, len);
+}
+
+BigStr* ToOctal(BigInt b) {
+  char buf[kInt64BufSize];
+  int len = snprintf(buf, kInt64BufSize, "%" PRIo64, b);
+  return ::StrFromC(buf, len);
+}
+
+BigStr* ToHexUpper(BigInt b) {
+  char buf[kInt64BufSize];
+  int len = snprintf(buf, kInt64BufSize, "%" PRIX64, b);
+  return ::StrFromC(buf, len);
+}
+
+BigStr* ToHexLower(BigInt b) {
+  char buf[kInt64BufSize];
+  int len = snprintf(buf, kInt64BufSize, "%" PRIx64, b);
+  return ::StrFromC(buf, len);
 }
 
 // Copied from gc_builtins - to_int()

mycpp/gc_mops.h

@@ -23,6 +23,10 @@ extern const BigInt ONE;
 extern const BigInt MINUS_ONE;
 
 BigStr* ToStr(BigInt b);
+BigStr* ToOctal(BigInt b);
+BigStr* ToHexUpper(BigInt b);
+BigStr* ToHexLower(BigInt b);
+
 BigInt FromStr(BigStr* s, int base = 10);
 
 inline int BigTruncate(BigInt b) {

mycpp/gc_mops_test.cc

@@ -53,6 +53,38 @@ TEST static_cast_test() {
   PASS();
 }
 
+TEST conversion_test() {
+  mops::BigInt int_min{INT64_MIN};
+  mops::BigInt int_max{INT64_MAX};
+  BigStr* int_str;
+
+  int_str = mops::ToStr(15);
+  ASSERT(str_equals0("15", int_str));
+  print(mops::ToStr(int_min));
+  print(mops::ToStr(int_max));
+  print(kEmptyString);
+
+  int_str = mops::ToOctal(15);
+  ASSERT(str_equals0("17", int_str));
+  print(mops::ToOctal(int_min));
+  print(mops::ToOctal(int_max));
+  print(kEmptyString);
+
+  int_str = mops::ToHexLower(15);
+  ASSERT(str_equals0("f", int_str));
+  print(mops::ToHexLower(int_min));
+  print(mops::ToHexLower(int_max));
+  print(kEmptyString);
+
+  int_str = mops::ToHexUpper(15);
+  ASSERT(str_equals0("F", int_str));
+  print(mops::ToHexUpper(int_min));
+  print(mops::ToHexUpper(int_max));
+  print(kEmptyString);
+
+  PASS();
+}
+
 GREATEST_MAIN_DEFS();
 
 int main(int argc, char** argv) {
@@ -62,6 +94,7 @@ int main(int argc, char** argv) {
 
   RUN_TEST(bigint_test);
   RUN_TEST(static_cast_test);
+  RUN_TEST(conversion_test);
 
   gHeap.CleanProcessExit();
 

mycpp/gc_mylib.h

@@ -121,26 +121,13 @@ void dict_erase(Dict<K, V>* haystack, K needle) {
   DCHECK(haystack->len_ < haystack->capacity_);
 }
 
-// NOTE: Can use OverAllocatedStr for all of these, rather than copying
-
 inline BigStr* hex_lower(int i) {
+  // Note: Could also use OverAllocatedStr, but most strings are small?
   char buf[kIntBufSize];
   int len = snprintf(buf, kIntBufSize, "%x", i);
   return ::StrFromC(buf, len);
 }
 
-inline BigStr* hex_upper(int i) {
-  char buf[kIntBufSize];
-  int len = snprintf(buf, kIntBufSize, "%X", i);
-  return ::StrFromC(buf, len);
-}
-
-inline BigStr* octal(int i) {
-  char buf[kIntBufSize];
-  int len = snprintf(buf, kIntBufSize, "%o", i);
-  return ::StrFromC(buf, len);
-}
-
 // Abstract type: Union of LineReader and Writer
 class File {
  public:

mycpp/gc_mylib_test.cc

@@ -55,14 +55,6 @@ TEST int_to_str_test() {
   print(int_str);
   print(mylib::hex_lower(int_min));
 
-  int_str = mylib::hex_upper(15);
-  ASSERT(str_equals0("F", int_str));
-  print(mylib::hex_upper(int_min));
-
-  int_str = mylib::octal(15);
-  ASSERT(str_equals0("17", int_str));
-  print(mylib::octal(int_min));
-
   PASS();
 }
 

mycpp/mops.py

@@ -56,6 +56,21 @@ def ToStr(b):
     return str(b.i)
 
 
+def ToOctal(b):
+    # type: (BigInt) -> str
+    return '%o' % b.i
+
+
+def ToHexUpper(b):
+    # type: (BigInt) -> str
+    return '%X' % b.i
+
+
+def ToHexLower(b):
+    # type: (BigInt) -> str
+    return '%x' % b.i
+
+
 def FromStr(s, base=10):
     # type: (str, int) -> BigInt
     return BigInt(int(s, base))

mycpp/mylib.py

@@ -374,16 +374,6 @@ def hex_lower(i):
     return '%x' % i
 
 
-def hex_upper(i):
-    # type: (int) -> str
-    return '%X' % i
-
-
-def octal(i):
-    # type: (int) -> str
-    return '%o' % i
-
-
 def dict_erase(d, key):
     # type: (Dict[Any, Any], Any) -> None
     """