[Demangle] Pass Ret parameter from decodeNumber by reference

[ljmf00]

Summary

Since Ret parameter is never meant to be nullptr, let's pass it by reference instead of a raw pointer.

[dblaikie]

Great, thanks!

llvm/lib/Demangle/DLangDemangle.cpp

private:
   /// \param Mangled string to extract the number.
   /// \param Ret assigned result value.
   ///
   /// \return The remaining string on success or nullptr on failure.
   ///
   /// \note A result larger than UINT_MAX is considered a failure.
   ///
   /// \see https://dlang.org/spec/abi.html#Number .
-  const char *decodeNumber(const char *Mangled, unsigned long *Ret);
+  const char *decodeNumber(const char *Mangled, unsigned long &Ret);
 
   /// Extract the back reference position from a given string.
   ///
   /// \param Mangled string to extract the back reference position.
   /// \param Ret assigned result value.
   ///
   /// \return the remaining string on success or nullptr on failure.
   ///
private:
   /// The string we are demangling.
   const char *Str;
   /// The index of the last back reference.
   int LastBackref;
 };
 
 } // namespace
 
-const char *Demangler::decodeNumber(const char *Mangled, unsigned long *Ret) {
+const char *Demangler::decodeNumber(const char *Mangled, unsigned long &Ret) {
   // Return nullptr if trying to extract something that isn't a digit.
   if (Mangled == nullptr || !std::isdigit(*Mangled))
     return nullptr;
 
   unsigned long Val = 0;
 
   do {
     unsigned long Digit = Mangled[0] - '0';
 
     // Check for overflow.
     if (Val > (std::numeric_limits<unsigned int>::max() - Digit) / 10)
       return nullptr;
 
     Val = Val * 10 + Digit;
     ++Mangled;
   } while (std::isdigit(*Mangled));
 
   if (*Mangled == '\0')
     return nullptr;
 
-  *Ret = Val;
+  Ret = Val;
   return Mangled;
 }
 
 const char *Demangler::decodeBackrefPos(const char *Mangled, long &Ret) {
   // Return nullptr if trying to extract something that isn't a digit
   if (Mangled == nullptr || !std::isalpha(*Mangled))
     return nullptr;
 
const char *Demangler::parseSymbolBackref(OutputBuffer *Demangled,
   //        ^
   const char *Backref;
   unsigned long Len;
 
   // Get position of the back reference
   Mangled = decodeBackref(Mangled, Backref);
 
   // Must point to a simple identifier
-  Backref = decodeNumber(Backref, &Len);
+  Backref = decodeNumber(Backref, Len);
   if (Backref == nullptr || strlen(Backref) < Len)
     return nullptr;
 
   Backref = parseLName(Demangled, Backref, Len);
   if (Backref == nullptr)
     return nullptr;
 
   return Mangled;
const char *Demangler::parseIdentifier(OutputBuffer *Demangled,
   if (Mangled == nullptr || *Mangled == '\0')
     return nullptr;
 
   if (*Mangled == 'Q')
     return parseSymbolBackref(Demangled, Mangled);
 
   // TODO: Parse lengthless template instances.
 
-  const char *Endptr = decodeNumber(Mangled, &Len);
+  const char *Endptr = decodeNumber(Mangled, Len);
 
   if (Endptr == nullptr || Len == 0)
     return nullptr;
 
   if (strlen(Endptr) < Len)
     return nullptr;
 
   Mangled = Endptr;