Refactor base encodings (#10)

Comprehensive refactoring of all base encoding implementations (Base2, Base8,
Base16, Base32, Base45, Base64, Base85, MoneroBase58, DividingCoder, Multibase).

- Made Base64 TryEncode/TryDecode allocation-free with two-layer architecture
- Added static Internal safe-count methods to Base64, matching other bases
- Replaced shr on signed types with TBitOperations.Asr32/Asr64 for
  cross-platform correctness
- Abstracted reverse lookup access into shared TCodingAlphabet.TryLookup
- Unified decode success path to System.Copy trim pattern across all bases
- Added upfront buffer validation and empty-input guards to all Try* methods
- Deduplicated TBits.PartialBigEndianBytesToUInt64 (MoneroBase58 now uses it)
- Removed redundant Base16Alphabet.MapCounterparts and Multibase helper
- Standardized error messages, exception types, and System-qualified calls
- Various minor fixes: comment typos, bounds guards, empty-result guards

Author: Xor-el

SimpleBaseLib/src/Alphabets/SbpAliasedBase32Alphabet.pas

@@ -9,6 +9,7 @@ interface
   SbpCharMap,
   SbpPaddingPosition,
   SbpCharUtilities,
+  SbpCodingAlphabet,
   SbpIAliasedBase32Alphabet,
   SbpBase32Alphabet;
 
@@ -53,7 +54,9 @@ procedure TAliasedBase32Alphabet.MapAlternate(ASource, ADestination: Char);
 var
   LResult: Int32;
 begin
-  LResult := ReverseLookupTable[Ord(ADestination)] - 1;
+  if not TCodingAlphabet.TryLookup(ReverseLookupTable, ADestination, LResult) then
+    raise EArgumentSimpleBaseLibException.CreateFmt(
+      'Character "%s" is not in the alphabet', [ADestination]);
   Map(ASource, LResult);
   Map(TCharUtilities.ToAsciiLower(ASource), LResult);
 end;

SimpleBaseLib/src/Alphabets/SbpBase16Alphabet.pas

@@ -5,18 +5,14 @@
 interface
 
 uses
-  SysUtils,
   SbpICodingAlphabet,
   SbpIBase16Alphabet,
-  SbpCharUtilities,
   SbpCodingAlphabet;
 
 type
   TBase16Alphabet = class(TCodingAlphabet, IBase16Alphabet)
   strict private
     FCaseSensitive: Boolean;
-
-    procedure MapCounterparts;
   public
     class var FUpperCaseAlphabet: ICodingAlphabet;
     class var FLowerCaseAlphabet: ICodingAlphabet;
@@ -58,36 +54,8 @@ constructor TBase16Alphabet.Create(const AAlphabet: String);
 constructor TBase16Alphabet.Create(const AAlphabet: String;
   const ACaseSensitive: Boolean);
 begin
-  inherited Create(16, AAlphabet, False);
+  inherited Create(16, AAlphabet, not ACaseSensitive);
   FCaseSensitive := ACaseSensitive;
-
-  if not FCaseSensitive then
-  begin
-    MapCounterparts;
-  end;
-end;
-
-procedure TBase16Alphabet.MapCounterparts;
-var
-  LI, LAlphaLen: Int32;
-  LChar: Char;
-begin
-  LAlphaLen := System.Length(Value);
-  for LI := 0 to LAlphaLen - 1 do
-  begin
-    LChar := Value[LI + 1];
-    if TCharUtilities.IsLetter(LChar) then
-    begin
-      if TCharUtilities.IsAsciiUpper(LChar) then
-      begin
-        Map(TCharUtilities.ToAsciiLower(LChar), LI);
-      end
-      else
-      begin
-        Map(TCharUtilities.ToAsciiUpper(LChar), LI);
-      end;
-    end;
-  end;
 end;
 
 class function TBase16Alphabet.GetUpperCase: ICodingAlphabet;

SimpleBaseLib/src/Alphabets/SbpBase32Alphabet.pas

@@ -180,7 +180,7 @@ class function TBase32Alphabet.GetCrockford: IBase32Alphabet;
 begin
   if FCrockfordAlphabet = nil then
   begin
-    SetLength(LMap, 3);
+    System.SetLength(LMap, 3);
     LMap[0] := CMap[0];
     LMap[1] := CMap[1];
     LMap[2] := CMap[2];
@@ -203,7 +203,7 @@ class function TBase32Alphabet.GetBase32H: IBase32Alphabet;
 begin
   if FBase32HAlphabet = nil then
   begin
-    SetLength(LMap, 4);
+    System.SetLength(LMap, 4);
     LMap[0] := CMap[0];
     LMap[1] := CMap[1];
     LMap[2] := CMap[2];

SimpleBaseLib/src/Alphabets/SbpCodingAlphabet.pas

@@ -37,6 +37,9 @@   TCodingAlphabet = class(TInterfacedObject, ICodingAlphabet)
     function ToString: String; override;
     function GetHashCode: {$IFDEF DELPHI}Int32;{$ELSE}PtrInt;{$ENDIF DELPHI}override;
 
+    class function TryLookup(const ATable: TSimpleBaseLibByteArray;
+      AChar: Char; out AValue: Int32): Boolean; static; inline;
+
     property Value: String read GetValue;
     property Length: Int32 read GetLength;
     property ReverseLookupTable: TSimpleBaseLibByteArray read GetReverseLookupTable;
@@ -137,5 +140,18 @@ procedure TCodingAlphabet.Map(AChar: Char; AValue: Int32);
  FReverseLookupTable[Ord(AChar)] := Byte(AValue + 1);
 end;
 
+class function TCodingAlphabet.TryLookup(const ATable: TSimpleBaseLibByteArray;
+  AChar: Char; out AValue: Int32): Boolean;
+begin
+  if Ord(AChar) >= System.Length(ATable) then
+  begin
+    AValue := -1;
+    Result := False;
+    Exit;
+  end;
+  AValue := ATable[Ord(AChar)] - 1;
+  Result := AValue >= 0;
+end;
+
 end.
 

SimpleBaseLib/src/Bases/SbpBase16.pas

@@ -13,6 +13,7 @@ interface
   SbpIBaseStreamCoder,
   SbpINonAllocatingBaseCoder,
   SbpStreamUtilities,
+  SbpCodingAlphabet,
   SbpBase16Alphabet;
 
 type
@@ -41,6 +42,9 @@   TBase16 = class(TInterfacedObject, IBase16, IBaseStreamCoder, INonAllocatingBa
     class procedure InternalEncode(const AInput: TSimpleBaseLibByteArray;
       const AOutput: TSimpleBaseLibCharArray; const AAlphabet: String); static;
 
+    function InternalDecode(const AInput: String;
+      const AOutput: TSimpleBaseLibByteArray; out ABytesWritten: Int32): Boolean;
+
   public
     class constructor Create;
 
@@ -141,23 +145,24 @@ class function TBase16.GetModHex: IBase16;
 
 function TBase16.Decode(const AText: String): TSimpleBaseLibByteArray;
 var
-  LTextLen: Int32;
-  LSafeCount: Int32;
-  LBytesWritten: Int32;
+  LSafeCount, LBytesWritten: Int32;
 begin
-  LTextLen := System.Length(AText);
-  if LTextLen = 0 then
+  if System.Length(AText) = 0 then
   begin
     Result := nil;
     Exit;
   end;
 
   LSafeCount := GetSafeByteCountForDecoding(AText);
-  System.SetLength(Result, LSafeCount);
+  if LSafeCount = 0 then
+  begin
+    raise EArgumentSimpleBaseLibException.Create('Invalid text length');
+  end;
 
-  if not TryDecode(AText, Result, LBytesWritten) then
+  System.SetLength(Result, LSafeCount);
+  if not InternalDecode(AText, Result, LBytesWritten) then
   begin
-    raise EArgumentSimpleBaseLibException.Create('Invalid text');
+    raise EArgumentSimpleBaseLibException.Create('Invalid character in input');
   end;
 end;
 
@@ -193,56 +198,30 @@ function TBase16.TryDecode(const AText: String;
   const AOutput: TSimpleBaseLibByteArray;
   out ABytesWritten: Int32): Boolean;
 var
-  LTextLen, LI, LO, LByte1, LByte2, LOutputLen: Int32;
-  LChar1, LChar2: Char;
+  LTextLen, LOutputLen: Int32;
 begin
+  ABytesWritten := 0;
   LTextLen := System.Length(AText);
   if LTextLen = 0 then
   begin
-    ABytesWritten := 0;
     Result := True;
     Exit;
   end;
 
   if (LTextLen and 1) <> 0 then
   begin
-    ABytesWritten := 0;
     Result := False;
     Exit;
   end;
 
   LOutputLen := LTextLen div 2;
   if System.Length(AOutput) < LOutputLen then
   begin
-    ABytesWritten := 0;
     Result := False;
     Exit;
   end;
 
-  LO := 0;
-  LI := 1;
-  while LI <= LTextLen do
-  begin
-    LChar1 := AText[LI];
-    LChar2 := AText[LI + 1];
-
-    LByte1 := FAlphabet.ReverseLookupTable[Ord(LChar1)] - 1;
-    LByte2 := FAlphabet.ReverseLookupTable[Ord(LChar2)] - 1;
-
-    if (LByte1 < 0) or (LByte2 < 0) then
-    begin
-      ABytesWritten := LO;
-      Result := False;
-      Exit;
-    end;
-
-    AOutput[LO] := Byte((LByte1 * 16) or LByte2);
-    Inc(LO);
-    Inc(LI, 2);
-  end;
-
-  ABytesWritten := LO;
-  Result := True;
+  Result := InternalDecode(AText, AOutput, ABytesWritten);
 end;
 
 function TBase16.Encode(const ABytes: TSimpleBaseLibByteArray): String;
@@ -260,9 +239,9 @@ function TBase16.Encode(const ABytes: TSimpleBaseLibByteArray): String;
 
   LAlphabet := FAlphabet.Value;
   LSafeCount := GetSafeCharCountForEncoding(ABytes);
-  SetLength(LOutput, LSafeCount);
+  System.SetLength(LOutput, LSafeCount);
   InternalEncode(ABytes, LOutput, LAlphabet);
-  SetString(Result, PChar(@LOutput[0]), Length(LOutput));
+  SetString(Result, PChar(@LOutput[0]), System.Length(LOutput));
 end;
 
 function TBase16.TryEncode(const ABytes: TSimpleBaseLibByteArray;
@@ -271,20 +250,18 @@ function TBase16.TryEncode(const ABytes: TSimpleBaseLibByteArray;
   LLen, LOutputLen: Int32;
   LAlphabet: String;
 begin
+  ACharsWritten := 0;
   LLen := System.Length(ABytes);
-  LOutputLen := LLen * 2;
-
-  if System.Length(AOutput) < LOutputLen then
+  if LLen = 0 then
   begin
-    ACharsWritten := 0;
-    Result := False;
+    Result := True;
     Exit;
   end;
 
-  if LOutputLen = 0 then
+  LOutputLen := LLen * 2;
+  if System.Length(AOutput) < LOutputLen then
   begin
-    ACharsWritten := 0;
-    Result := True;
+    Result := False;
     Exit;
   end;
 
@@ -295,6 +272,39 @@ function TBase16.TryEncode(const ABytes: TSimpleBaseLibByteArray;
   Result := True;
 end;
 
+function TBase16.InternalDecode(const AInput: String;
+  const AOutput: TSimpleBaseLibByteArray; out ABytesWritten: Int32): Boolean;
+var
+  LTextLen, LI, LO, LByte1, LByte2: Int32;
+  LChar1, LChar2: Char;
+  LTable: TSimpleBaseLibByteArray;
+begin
+  LTable := FAlphabet.ReverseLookupTable;
+  LTextLen := System.Length(AInput);
+  LO := 0;
+  LI := 1;
+  while LI <= LTextLen do
+  begin
+    LChar1 := AInput[LI];
+    LChar2 := AInput[LI + 1];
+
+    if (not TCodingAlphabet.TryLookup(LTable, LChar1, LByte1)) or
+      (not TCodingAlphabet.TryLookup(LTable, LChar2, LByte2)) then
+    begin
+      ABytesWritten := LO;
+      Result := False;
+      Exit;
+    end;
+
+    AOutput[LO] := Byte((LByte1 * 16) or LByte2);
+    Inc(LO);
+    Inc(LI, 2);
+  end;
+
+  ABytesWritten := LO;
+  Result := True;
+end;
+
 class procedure TBase16.InternalEncode(const AInput: TSimpleBaseLibByteArray;
   const AOutput: TSimpleBaseLibCharArray; const AAlphabet: String);
 var

SimpleBaseLib/src/Bases/SbpBase2.pas

@@ -82,9 +82,15 @@ function TBase2.Decode(const AText: String): TSimpleBaseLibByteArray;
 var
   LOutputLen: Int32;
 begin
+  if System.Length(AText) = 0 then
+  begin
+    Result := nil;
+    Exit;
+  end;
+
   if (System.Length(AText) mod 8) <> 0 then
   begin
-    raise EArgumentSimpleBaseLibException.Create('Input length must be multiply of 8');
+    raise EArgumentSimpleBaseLibException.Create('Input length must be a multiple of 8');
   end;
 
   LOutputLen := System.Length(AText) div 8;
@@ -170,6 +176,12 @@ function TBase2.TryEncode(const ABytes: TSimpleBaseLibByteArray;
   LTargetLen: Int32;
 begin
   ACharsWritten := 0;
+  if System.Length(ABytes) = 0 then
+  begin
+    Result := True;
+    Exit;
+  end;
+
   LTargetLen := System.Length(ABytes) * 8;
   if System.Length(AOutput) < LTargetLen then
   begin