sync with parent repo.

src/libraries/cryptolib4pascal/ClpConverters.pas

@@ -292,44 +292,64 @@ end;
 class function TConverters.ReadBytesAsUInt32LE(a_in: PByte;
   a_index: Int32): UInt32;
 begin
+{$IFDEF FPC}
 {$IFDEF FPC_REQUIRES_PROPER_ALIGNMENT}
   System.Move(a_in[a_index], result, System.SizeOf(UInt32));
 {$ELSE}
   result := PCardinal(a_in + a_index)^;
 {$ENDIF FPC_REQUIRES_PROPER_ALIGNMENT}
+{$ELSE}
+  // Delphi does not handle unaligned memory access on ARM Devices properly.
+  System.Move(a_in[a_index], result, System.SizeOf(UInt32));
+{$ENDIF FPC}
   result := le2me_32(result);
 end;
 
 class function TConverters.ReadBytesAsUInt32BE(a_in: PByte;
   a_index: Int32): UInt32;
 begin
+{$IFDEF FPC}
 {$IFDEF FPC_REQUIRES_PROPER_ALIGNMENT}
   System.Move(a_in[a_index], result, System.SizeOf(UInt32));
 {$ELSE}
   result := PCardinal(a_in + a_index)^;
 {$ENDIF FPC_REQUIRES_PROPER_ALIGNMENT}
+{$ELSE}
+  // Delphi does not handle unaligned memory access on ARM Devices properly.
+  System.Move(a_in[a_index], result, System.SizeOf(UInt32));
+{$ENDIF FPC}
   result := be2me_32(result);
 end;
 
 class function TConverters.ReadBytesAsUInt64LE(a_in: PByte;
   a_index: Int32): UInt64;
 begin
+{$IFDEF FPC}
 {$IFDEF FPC_REQUIRES_PROPER_ALIGNMENT}
   System.Move(a_in[a_index], result, System.SizeOf(UInt64));
 {$ELSE}
   result := PUInt64(a_in + a_index)^;
 {$ENDIF FPC_REQUIRES_PROPER_ALIGNMENT}
+{$ELSE}
+  // Delphi does not handle unaligned memory access on ARM Devices properly.
+  System.Move(a_in[a_index], result, System.SizeOf(UInt64));
+{$ENDIF FPC}
   result := le2me_64(result);
 end;
 
 class function TConverters.ReadBytesAsUInt64BE(a_in: PByte;
   a_index: Int32): UInt64;
 begin
+{$IFDEF FPC}
 {$IFDEF FPC_REQUIRES_PROPER_ALIGNMENT}
   System.Move(a_in[a_index], result, System.SizeOf(UInt64));
 {$ELSE}
   result := PUInt64(a_in + a_index)^;
 {$ENDIF FPC_REQUIRES_PROPER_ALIGNMENT}
+{$ELSE}
+  // Delphi does not handle unaligned memory access on ARM Devices properly.
+  System.Move(a_in[a_index], result, System.SizeOf(UInt64));
+{$ENDIF FPC}
   result := be2me_64(result);
 end;
 

src/libraries/cryptolib4pascal/ClpOSRandom.pas

@@ -199,7 +199,6 @@ end;
 class function TOSRandom.GenRandomBytesIOSDelphi(len: Int32;
   const data: PByte): Int32;
 begin
-  // UNTESTED !!!, Please Take Note.
   result := SecRandomCopyBytes(kSecRandomDefault, LongWord(len), data);
 end;
 

src/libraries/cryptolib4pascal/CryptoLibHelper.inc

@@ -19,8 +19,8 @@
 {$IFDEF ENDIAN_BIG}
 {$MESSAGE FATAL 'This Library does not support "Big Endian" processors yet.'}
 {$ENDIF}
-// FPC 3.0.0 and Above
+// FPC 3.0.4 and Above
 // Had to Include this here since Delphi does not allow it Compile in "CryptoLib.inc".
-{$IF FPC_FULLVERSION < 30000}
-{$MESSAGE ERROR 'This Library requires FreePascal 3.0.0 or higher.'}
+{$IF FPC_FULLVERSION < 30004}
+{$MESSAGE ERROR 'This Library requires FreePascal 3.0.4 or higher.'}
 {$IFEND}

src/libraries/simplebaselib4pascal/SbpBase16.pas

@@ -92,6 +92,7 @@ begin
   end;
   if ((textLen and 1) <> 0) then
   begin
+    Ltext := '';
     if System.Length(text) > 0 then
     begin
       System.SetString(Ltext, PChar(@text[0]), System.Length(text));

src/libraries/simplebaselib4pascal/SbpBase85.pas

@@ -15,7 +15,7 @@ uses
 resourcestring
   SAlphabetNil = 'Alphabet Instance cannot be Nil "%s"';
   SUnExpectedCharacter =
-    'Unexpected Character "%s" In The Middle Of a Regular Block';
+    'Unexpected Shortcut Character In The Middle Of a Regular Block';
 
 type
   TBase85 = class sealed(TInterfacedObject, IBase85)
@@ -35,7 +35,7 @@ type
       numBytesToWrite: Int32); static; inline;
 
     class procedure WriteShortcut(var pOutput: PByte; blockIndex: Int32;
-      c: Char; value: Int64); static; inline;
+      value: Int64); static; inline;
 
     class function GetDecodeBufferLength(textLen: Int32;
       usingShortcuts: Boolean): Int32; static; inline;
@@ -57,7 +57,8 @@ type
       : TSimpleBaseLibByteArray; overload;
 
     procedure WriteOutput(var pOutput: PChar; const table: String; input: Int64;
-      stringLength: Int32; hasShortcut: Boolean); inline;
+      stringLength: Int32; usesZeroShortcut, usesSpaceShortcut
+      : Boolean); inline;
 
   public
 
@@ -94,27 +95,27 @@ implementation
 { TBase85 }
 
 procedure TBase85.WriteOutput(var pOutput: PChar; const table: String;
-  input: Int64; stringLength: Int32; hasShortcut: Boolean);
+  input: Int64; stringLength: Int32; usesZeroShortcut, usesSpaceShortcut
+  : Boolean);
 var
   i: Int32;
   result: Int64;
 begin
-  // handle "z" shortcut
-  if (hasShortcut) then
+  // handle shortcuts
+  if (input = 0) and (usesZeroShortcut) then
   begin
-    if (input = 0) then
-    begin
-      pOutput^ := Falphabet.AllZeroShortcut;
-      System.Inc(pOutput);
-      Exit;
-    end;
-    if (input = allSpace) then
-    begin
-      pOutput^ := Falphabet.AllSpaceShortcut;
-      System.Inc(pOutput);
-      Exit;
-    end;
+    pOutput^ := Falphabet.AllZeroShortcut;
+    System.Inc(pOutput);
+    Exit;
   end;
+
+  if (input = allSpace) and (usesSpaceShortcut) then
+  begin
+    pOutput^ := Falphabet.AllSpaceShortcut;
+    System.Inc(pOutput);
+    Exit;
+  end;
+
   // map the 4-byte packet to to 5-byte octets
   i := stringBlockSize - 1;
   while i >= 0 do
@@ -146,12 +147,11 @@ begin
 end;
 
 class procedure TBase85.WriteShortcut(var pOutput: PByte; blockIndex: Int32;
-  c: Char; value: Int64);
+  value: Int64);
 begin
   if (blockIndex <> 0) then
   begin
-    raise EArgumentSimpleBaseLibException.CreateResFmt
-      (@SUnExpectedCharacter, [c]);
+    raise EArgumentSimpleBaseLibException.CreateRes(@SUnExpectedCharacter);
   end;
   WriteDecodedValue(pOutput, value, byteBlockSize);
 end;
@@ -204,8 +204,8 @@ begin
   end;
   allZeroChar := Falphabet.AllZeroShortcut;
   allSpaceChar := Falphabet.AllSpaceShortcut;
-  checkZero := allZeroChar <> TBase85Alphabet.NoShortcut;
-  checkSpace := allSpaceChar <> TBase85Alphabet.NoShortcut;
+  checkZero := allZeroChar <> TBase85Alphabet.NullChar;
+  checkSpace := allSpaceChar <> TBase85Alphabet.NullChar;
   usingShortcuts := checkZero or checkSpace;
   // allocate a larger buffer if we're using shortcuts
 
@@ -234,12 +234,12 @@ begin
     // handle shortcut characters
     if ((checkZero) and (c = allZeroChar)) then
     begin
-      WriteShortcut(pDecodeBuffer, blockIndex, allZeroChar, 0);
+      WriteShortcut(pDecodeBuffer, blockIndex, 0);
       continue;
     end;
     if ((checkSpace) and (c = allSpaceChar)) then
     begin
-      WriteShortcut(pDecodeBuffer, blockIndex, allSpaceChar, allSpace);
+      WriteShortcut(pDecodeBuffer, blockIndex, allSpace);
       continue;
     end;
 
@@ -298,7 +298,7 @@ var
   bytesLen, maxOutputLen, fullLen, remainingBytes, n, outputLen: Int32;
   input: Int64;
   t1, t2, t3, t4: UInt32;
-  hasShortcut: Boolean;
+  usesZeroShortcut, usesSpaceShortcut: Boolean;
   output: TSimpleBaseLibCharArray;
   table: string;
   inputPtr, pInput, pInputEnd: PByte;
@@ -310,7 +310,8 @@ begin
   begin
     Exit;
   end;
-  hasShortcut := Falphabet.hasShortcut;
+  usesZeroShortcut := Falphabet.AllZeroShortcut <> TBase85Alphabet.NullChar;
+  usesSpaceShortcut := Falphabet.AllSpaceShortcut <> TBase85Alphabet.NullChar;
 
   // adjust output length based on prefix and suffix settings
   // we know output length is too large but we will handle it later.
@@ -339,10 +340,11 @@ begin
     t4 := (UInt32(pInput^));
     System.Inc(pInput);
     input := t1 or t2 or t3 or t4;
-    WriteOutput(pOutput, table, input, stringBlockSize, hasShortcut);
+    WriteOutput(pOutput, table, input, stringBlockSize, usesZeroShortcut,
+      usesSpaceShortcut);
   end;
 
-  // remaining part?
+  // check if a part is remaining
   remainingBytes := bytesLen - fullLen;
   if (remainingBytes > 0) then
   begin
@@ -355,7 +357,8 @@ begin
       System.Inc(n);
     end;
 
-    WriteOutput(pOutput, table, input, remainingBytes + 1, hasShortcut);
+    WriteOutput(pOutput, table, input, remainingBytes + 1, usesZeroShortcut,
+      usesSpaceShortcut);
   end;
 
   outputLen := Int32(pOutput - outputPtr);

src/libraries/simplebaselib4pascal/SbpBase85Alphabet.pas

@@ -15,7 +15,7 @@ type
   strict private
 
   const
-    No_Shortcut = Char($FFFF);
+    Null_Char = Char(0);
 
   var
     FAllZeroShortcut, FAllSpaceShortcut: Char;
@@ -28,7 +28,8 @@ type
     function GetAllSpaceShortcut: Char; inline;
     function GetAllZeroShortcut: Char; inline;
 
-    class function GetNoShortcut: Char; static; inline;
+    class function GetNullChar: Char; static; inline;
+
     class function GetZ85: IBase85Alphabet; static; inline;
     class function GetAscii85: IBase85Alphabet; static; inline;
 
@@ -36,26 +37,37 @@ type
 
   public
 
+    /// <summary>
+    /// Gets a value indicating whether the alphabet uses one of shortcut characters for all spaces
+    /// or all zeros.
+    /// </summary>
     property HasShortcut: Boolean read GetHasShortcut;
+
+    /// <summary>
+    /// Gets the character to be used for "all zeros"
+    /// </summary>
+
     property AllZeroShortcut: Char read GetAllZeroShortcut;
+    /// <summary>
+    /// Gets the character to be used for "all spaces"
+    /// </summary>
     property AllSpaceShortcut: Char read GetAllSpaceShortcut;
 
-    class property NoShortcut: Char read GetNoShortcut;
-
     /// <summary>
-    /// ZeroMQ Z85 Alphabet
+    /// Gets ZeroMQ Z85 Alphabet
     /// </summary>
     class property Z85: IBase85Alphabet read GetZ85;
 
     /// <summary>
-    /// Adobe Ascii85 Alphabet (each character is directly produced by raw
+    /// Get Adobe Ascii85 Alphabet (each character is directly produced by raw
     /// value + 33)
     /// </summary>
     class property Ascii85: IBase85Alphabet read GetAscii85;
 
+    class property NullChar: Char read GetNullChar;
+
     constructor Create(const alphabet: String;
-      AllZeroShortcut: Char = No_Shortcut;
-      AllSpaceShortcut: Char = No_Shortcut);
+      AllZeroShortcut: Char = Null_Char; AllSpaceShortcut: Char = Null_Char);
     destructor Destroy; override;
   end;
 
@@ -95,14 +107,14 @@ begin
   Result := FAllZeroShortcut;
 end;
 
-class function TBase85Alphabet.GetNoShortcut: Char;
+class function TBase85Alphabet.GetNullChar: Char;
 begin
-  Result := No_Shortcut;
+  Result := Null_Char;
 end;
 
 function TBase85Alphabet.GetHasShortcut: Boolean;
 begin
-  Result := (AllSpaceShortcut <> NoShortcut) or (AllZeroShortcut <> NoShortcut);
+  Result := (AllSpaceShortcut <> NullChar) or (AllZeroShortcut <> NullChar);
 end;
 
 class function TBase85Alphabet.GetZ85: IBase85Alphabet;

src/libraries/simplebaselib4pascal/SbpIBase85Alphabet.pas

@@ -15,8 +15,20 @@ type
     function GetAllSpaceShortcut: Char;
     function GetAllZeroShortcut: Char;
 
+    /// <summary>
+    /// Gets a value indicating whether the alphabet uses one of shortcut characters for all spaces
+    /// or all zeros.
+    /// </summary>
     property HasShortcut: Boolean read GetHasShortcut;
+
+    /// <summary>
+    /// Gets the character to be used for "all zeros"
+    /// </summary>
+
     property AllZeroShortcut: Char read GetAllZeroShortcut;
+    /// <summary>
+    /// Gets the character to be used for "all spaces"
+    /// </summary>
     property AllSpaceShortcut: Char read GetAllSpaceShortcut;
 
   end;