diff --git a/jcl/source/common/Jcl8087.pas b/jcl/source/common/Jcl8087.pas
index d8c5f1868..c3b8a3a0b 100644
--- a/jcl/source/common/Jcl8087.pas
+++ b/jcl/source/common/Jcl8087.pas
@@ -115,7 +115,7 @@ function Get8087Rounding: T8087Rounding;
   Result := T8087Rounding((Get8087ControlWord and $0C00) shr 10);
 end;
 
-{$IFDEF CPU64}
+{$IFDEF CPUX64}
 function Get8087StatusWord(ClearExceptions: Boolean): Word;
 asm
           TEST    ClearExceptions, ClearExceptions
@@ -138,7 +138,7 @@ function Get8087StatusWord(ClearExceptions: Boolean): Word;
           FNSTSW  Result                    //   get status word (without clearing exceptions)
   end;
 end;
-{$ENDIF CPU64}
+{$ENDIF CPUX64}
 
 function Set8087Infinity(const Infinity: T8087Infinity): T8087Infinity;
 var
diff --git a/jcl/source/common/JclLogic.pas b/jcl/source/common/JclLogic.pas
index 1a3587e5f..5288a9111 100644
--- a/jcl/source/common/JclLogic.pas
+++ b/jcl/source/common/JclLogic.pas
@@ -402,8 +402,23 @@ function OrdToBinary(Value: Int64): string;
 
 // Bit manipulation
 function BitsHighest(X: Cardinal): Integer;
+{$IFDEF PUREPASCAL}
+begin
+  if X = 0 then
+  begin
+    Result := -1;
+    Exit;
+  end;
+  Result := 31;
+  while X and $80000000 = 0 do
+  begin
+    Dec(Result);
+    X := X shl 1
+  end;
+end;
+{$ELSE ~PUREPASCAL}
 asm
-  {$IFDEF CPU32}
+  {$IFDEF CPU386}
   // --> EAX X
   // <-- EAX
   MOV     ECX, EAX
@@ -412,20 +427,26 @@ function BitsHighest(X: Cardinal): Integer;
   JNZ     @@End
   MOV     EAX, -1
 @@End:
-  {$ENDIF CPU32}
-  {$IFDEF CPU64}
+  {$ENDIF CPU386}
+  {$IFDEF CPUX64}
   // --> ECX X
   // <-- RAX
   MOV     EAX, -1
   MOV     R10D, EAX
   BSR     EAX, ECX
   CMOVZ   EAX, R10D
-  {$ENDIF CPU64}
+  {$ENDIF CPUX64}
 end;
+{$ENDIF ~PUREPASCAL}
 
 function BitsHighest(X: Integer): Integer;
+{$IFDEF PUREPASCAL}
+begin
+  Result := BitsHighest(Cardinal(X));
+end;
+{$ELSE ~PUREPASCAL}
 asm
-  {$IFDEF CPU32}
+  {$IFDEF CPU386}
   // --> EAX X
   // <-- EAX
   MOV     ECX, EAX
@@ -434,16 +455,17 @@ function BitsHighest(X: Integer): Integer;
   JNZ     @@End
   MOV     EAX, -1
 @@End:
-  {$ENDIF CPU32}
-  {$IFDEF CPU64}
+  {$ENDIF CPU386}
+  {$IFDEF CPUX64}
   // --> ECX X
   // <-- RAX
   MOV     EAX, -1
   MOV     R10D, EAX
   BSR     EAX, ECX
   CMOVZ   EAX, R10D
-  {$ENDIF CPU64}
+  {$ENDIF CPUX64}
 end;
+{$ENDIF ~PUREPASCAL}
 
 function BitsHighest(X: Byte): Integer;
 begin
@@ -466,15 +488,14 @@ function BitsHighest(X: ShortInt): Integer;
 end;
 
 function BitsHighest(X: Int64): Integer;
-{$IFDEF CPU32}
+{$IFNDEF CPUX64}
 begin
   if TJclULargeInteger(X).HighPart = 0 then
     Result := BitsHighest(TJclULargeInteger(X).LowPart)
   else
     Result := BitsHighest(TJclULargeInteger(X).HighPart) + 32;
 end;
-{$ENDIF CPU32}
-{$IFDEF CPU64}
+{$ELSE CPUX64}
 asm
   // --> RCX X
   // <-- RAX
@@ -487,11 +508,26 @@ function BitsHighest(X: Int64): Integer;
   BSR     RAX, RCX
   CMOVZ   RAX, R10
 end;
-{$ENDIF CPU64}
+{$ENDIF CPUX64}
 
 function BitsLowest(X: Cardinal): Integer;
+{$IFDEF PUREPASCAL}
+begin
+  if X = 0 then
+  begin
+    Result := -1;
+    Exit;
+  end;
+  Result := 0;
+  while X and 1 = 0 do
+  begin
+    Inc(Result);
+    X := X shr 1
+  end;
+end;
+{$ELSE ~PUREPASCAL}
 asm
-  {$IFDEF CPU32}
+  {$IFDEF CPU386}
   // --> EAX X
   // <-- EAX
   MOV     ECX, EAX
@@ -500,20 +536,26 @@ function BitsLowest(X: Cardinal): Integer;
   JNZ     @@End
   MOV     EAX, -1
 @@End:
-  {$ENDIF CPU32}
-  {$IFDEF CPU64}
+  {$ENDIF CPU386}
+  {$IFDEF CPUX64}
   // --> RCX X
   // <-- EAX
   MOV     EAX, -1
   MOV     R10D, EAX
   BSF     EAX, ECX
   CMOVZ   EAX, R10D
-  {$ENDIF CPU64}
+  {$ENDIF CPUX64}
 end;
+{$ENDIF ~PUREPASCAL}
 
 function BitsLowest(X: Integer): Integer;
+{$IFDEF PUREPASCAL}
+begin
+  Result := BitsLowest(Cardinal(X));
+end;
+{$ELSE ~PUREPASCAL}
 asm
-  {$IFDEF CPU32}
+  {$IFDEF CPU386}
   // --> EAX X
   // <-- EAX
   MOV     ECX, EAX
@@ -522,16 +564,17 @@ function BitsLowest(X: Integer): Integer;
   JNZ     @@End
   MOV     EAX, -1
 @@End:
-  {$ENDIF CPU32}
-  {$IFDEF CPU64}
+  {$ENDIF CPU386}
+  {$IFDEF CPUX64}
   // --> RCX X
   // <-- EAX
   MOV     EAX, -1
   MOV     R10D, EAX
   BSF     EAX, ECX
   CMOVZ   EAX, R10D
-  {$ENDIF CPU64}
+  {$ENDIF CPUX64}
 end;
+{$ENDIF ~PUREPASCAL}
 
 function BitsLowest(X: Byte): Integer;
 begin
@@ -554,15 +597,14 @@ function BitsLowest(X: Word): Integer;
 end;
 
 function BitsLowest(X: Int64): Integer;
-{$IFDEF CPU32}
+{$IFNDEF CPUX64}
 begin
   if TJclULargeInteger(X).LowPart = 0 then
     Result := BitsLowest(TJclULargeInteger(X).HighPart) + 32
   else
     Result := BitsLowest(TJclULargeInteger(X).LowPart);
 end;
-{$ENDIF CPU32}
-{$IFDEF CPU64}
+{$ELSE CPUX64}
 asm
   // --> RCX X
   // <-- RAX
@@ -575,9 +617,14 @@ function BitsLowest(X: Int64): Integer;
   BSF     RAX, RCX
   CMOVZ   RAX, R10
 end;
-{$ENDIF CPU64}
+{$ENDIF CPUX64}
 
 function ClearBit(const Value: Byte; const Bit: TBitRange): Byte;
+{$IFDEF PUREPASCAL}
+begin
+  Result := Value and not (Byte(1) shl (Bit and (BitsPerByte - 1)));
+end;
+{$ELSE ~PUREPASCAL}
 asm
   // 32 --> AL Value
   //        DL Bit
@@ -586,13 +633,19 @@ function ClearBit(const Value: Byte; const Bit: TBitRange): Byte;
   //        DL Bit
   //    <-- AL Result
   AND    EDX, BitsPerByte - 1   // modulo BitsPerByte
-  {$IFDEF CPU64}
+  {$IFDEF CPUX64}
   MOVZX  EAX, CL
-  {$ENDIF CPU64}
+  {$ENDIF CPUX64}
   BTR    EAX, EDX
 end;
+{$ENDIF ~PUREPASCAL}
 
 function ClearBit(const Value: Shortint; const Bit: TBitRange): Shortint;
+{$IFDEF PUREPASCAL}
+begin
+  Result := Value and not (Shortint(1) shl (Bit and (BitsPerShortint - 1)));
+end;
+{$ELSE ~PUREPASCAL}
 asm
   // 32 --> AL Value
   //        DL Bit
@@ -601,13 +654,19 @@ function ClearBit(const Value: Shortint; const Bit: TBitRange): Shortint;
   //        DL Bit
   //    <-- AL Result
   AND    EDX, BitsPerShortint - 1   // modulo BitsPerShortint
-  {$IFDEF CPU64}
+  {$IFDEF CPUX64}
   MOVZX  EAX, CL
-  {$ENDIF CPU64}
+  {$ENDIF CPUX64}
   BTR    EAX, EDX
 end;
+{$ENDIF ~PUREPASCAL}
 
 function ClearBit(const Value: Smallint; const Bit: TBitRange): Smallint;
+{$IFDEF PUREPASCAL}
+begin
+  Result := Value and not (Smallint(1) shl (Bit and (BitsPerSmallint - 1)));
+end;
+{$ELSE ~PUREPASCAL}
 asm
   // 32 --> AX Value
   //        DL Bit
@@ -616,13 +675,19 @@ function ClearBit(const Value: Smallint; const Bit: TBitRange): Smallint;
   //        DL Bit
   //    <-- AX Result
   AND    EDX, BitsPerSmallint - 1   // modulo BitsPerSmallint
-  {$IFDEF CPU64}
+  {$IFDEF CPUX64}
   MOVZX  EAX, CX
-  {$ENDIF CPU64}
+  {$ENDIF CPUX64}
   BTR    EAX, EDX
 end;
+{$ENDIF ~PUREPASCAL}
 
 function ClearBit(const Value: Word; const Bit: TBitRange): Word;
+{$IFDEF PUREPASCAL}
+begin
+  Result := Value and not (Word(1) shl (Bit and (BitsPerWord - 1)));
+end;
+{$ELSE ~PUREPASCAL}
 asm
   // 32 --> AX Value
   //        DL Bit
@@ -631,13 +696,19 @@ function ClearBit(const Value: Word; const Bit: TBitRange): Word;
   //        DL Bit
   //    <-- AX Result
   AND    EDX, BitsPerWord - 1   // modulo BitsPerWord
-  {$IFDEF CPU64}
+  {$IFDEF CPUX64}
   MOVZX  EAX, CX
-  {$ENDIF CPU64}
+  {$ENDIF CPUX64}
   BTR    EAX, EDX
 end;
+{$ENDIF ~PUREPASCAL}
 
 function ClearBit(const Value: Cardinal; const Bit: TBitRange): Cardinal;
+{$IFDEF PUREPASCAL}
+begin
+  Result := Value and not (Cardinal(1) shl (Bit and (BitsPerCardinal - 1)));
+end;
+{$ELSE ~PUREPASCAL}
 asm
   // 32 --> EAX Value
   //        DL  Bit
@@ -645,13 +716,19 @@ function ClearBit(const Value: Cardinal; const Bit: TBitRange): Cardinal;
   // 64 --> ECX Value
   //        DL  Bit
   //    <-- EAX Result
-  {$IFDEF CPU64}
+  {$IFDEF CPUX64}
   MOV    EAX, ECX
-  {$ENDIF CPU64}
+  {$ENDIF CPUX64}
   BTR    EAX, EDX
 end;
+{$ENDIF ~PUREPASCAL}
 
 function ClearBit(const Value: Integer; const Bit: TBitRange): Integer;
+{$IFDEF PUREPASCAL}
+begin
+  Result := Value and not (Integer(1) shl (Bit and (BitsPerInteger - 1)));
+end;
+{$ELSE ~PUREPASCAL}
 asm
   // 32 --> EAX Value
   //        DL  Bit
@@ -659,19 +736,19 @@ function ClearBit(const Value: Integer; const Bit: TBitRange): Integer;
   // 64 --> ECX Value
   //        DL  Bit
   //    <-- EAX Result
-  {$IFDEF CPU64}
+  {$IFDEF CPUX64}
   MOV    EAX, ECX
-  {$ENDIF CPU64}
+  {$ENDIF CPUX64}
   BTR    EAX, EDX
 end;
+{$ENDIF ~PUREPASCAL}
 
 function ClearBit(const Value: Int64; const Bit: TBitRange): Int64;
-{$IFDEF CPU32}
+{$IFNDEF CPUX64}
 begin
   Result := Value and not (Int64(1) shl (Bit and (BitsPerInt64 - 1)));
 end;
-{$ENDIF CPU32}
-{$IFDEF CPU64}
+{$ELSE CPUX64}
 asm
   // --> RCX Value
   //     DL  Bit
@@ -679,7 +756,7 @@ function ClearBit(const Value: Int64; const Bit: TBitRange): Int64;
   MOV    RAX, RCX
   BTR    RAX, RDX
 end;
-{$ENDIF CPU64}
+{$ENDIF CPUX64}
 
 procedure ClearBitBuffer(var Value; const Bit: Cardinal);
 {$IFDEF PUREPASCAL}
@@ -849,64 +926,99 @@ function CountBitsCleared(P: Pointer; Count: Cardinal): Cardinal;
 end;
 
 function LRot(const Value: Byte; const Count: TBitRange): Byte;
+{$IFDEF PUREPASCAL}
+var
+  C: TBitRange;
+begin
+  C := Count and (BitsPerByte - 1);
+  Result := Byte(Value shl C) or Byte(Value shr (BitsPerByte - C))
+end;
+{$ELSE ~PUREPASCAL}
 asm
-  {$IFDEF CPU32}
+  {$IFDEF CPU386}
   // --> AL Value
   //     DL Count
   // <-- AL Result
   MOV    CL, DL
   ROL    AL, CL
-  {$ENDIF CPU32}
-  {$IFDEF CPU64}
+  {$ENDIF CPU386}
+  {$IFDEF CPUX64}
   // --> CL Value
   //     DL Count
   // <-- AL Result
   MOV    AL, CL
   MOV    CL, DL
   ROL    AL, CL
-  {$ENDIF CPU64}
+  {$ENDIF CPUX64}
 end;
+{$ENDIF ~PUREPASCAL}
 
 function LRot(const Value: Word; const Count: TBitRange): Word;
+{$IFDEF PUREPASCAL}
+var
+  C: TBitRange;
+begin
+  C := Count and (BitsPerWord - 1);
+  Result := Word(Value shl C) or Word(Value shr (BitsPerWord - C))
+end;
+{$ELSE ~PUREPASCAL}
 asm
-  {$IFDEF CPU32}
+  {$IFDEF CPU386}
   // --> AX Value
   //     DL Count
   // <-- AX Result
   MOV    CL, DL
   ROL    AX, CL
-  {$ENDIF CPU32}
-  {$IFDEF CPU64}
+  {$ENDIF CPU386}
+  {$IFDEF CPUX64}
   // --> CX Value
   //     DL Count
   // <-- AX Result
   MOV    AX, CX
   MOV    CL, DL
   ROL    AX, CL
-  {$ENDIF CPU64}
+  {$ENDIF CPUX64}
 end;
+{$ENDIF ~PUREPASCAL}
 
 function LRot(const Value: Integer; const Count: TBitRange): Integer;
+{$IFDEF PUREPASCAL}
+var
+  C: TBitRange;
+begin
+  C := Count and (BitsPerInteger - 1);
+  Result := Integer(Value shl C) or Integer(Value shr (BitsPerInteger - C))
+end;
+{$ELSE ~PUREPASCAL}
 asm
-  {$IFDEF CPU32}
+  {$IFDEF CPU386}
   // --> EAX Value
   //     DL  Count
   // <-- EAX Result
   MOV    CL,  DL
   ROL    EAX, CL
-  {$ENDIF CPU32}
-  {$IFDEF CPU64}
+  {$ENDIF CPU386}
+  {$IFDEF CPUX64}
   // --> ECX Value
   //     DL  Count
   // <-- EAX Result
   MOV    EAX, ECX
   MOV    CL,  DL
   ROL    EAX, CL
-  {$ENDIF CPU64}
+  {$ENDIF CPUX64}
 end;
+{$ENDIF ~PUREPASCAL}
 
 function LRot(const Value: Int64; const Count: TBitRange): Int64;
-{$IFDEF CPU32}
+{$IFDEF PUREPASCAL}
+var
+  C: TBitRange;
+begin
+  C := Count and (BitsPerInt64 - 1);
+  Result := Int64(Value shl C) or Int64(Value shr (BitsPerInt64 - C))
+end;
+{$ELSE ~PUREPASCAL}
+{$IFDEF CPU386}
 asm
   // --> Value on stack
   //     AL  Count
@@ -954,8 +1066,8 @@ function LRot(const Value: Int64; const Count: TBitRange): Int64;
   POP    EDI
   POP    ESI
 end;
-{$ENDIF CPU32}
-{$IFDEF CPU64}
+{$ENDIF CPU386}
+{$IFDEF CPUX64}
 asm
   // --> RCX Value
   //     DL  Count
@@ -964,15 +1076,15 @@ function LRot(const Value: Int64; const Count: TBitRange): Int64;
   MOV    CL,  DL
   ROL    RAX, CL
 end;
-{$ENDIF CPU64}
+{$ENDIF CPUX64}
+{$ENDIF ~PUREPASCAL}
 
 function RRot(const Value: Int64; const Count: TBitRange): Int64;
-{$IFDEF CPU32}
+{$IFNDEF CPUX64}
 begin
   Result := LRot(Value, 64 - (Count and $3F));
 end;
-{$ENDIF CPU32}
-{$IFDEF CPU64}
+{$ELSE CPUX64}
 asm
   // --> RCX Value
   //     DL  Count
@@ -981,7 +1093,7 @@ function RRot(const Value: Int64; const Count: TBitRange): Int64;
   MOV    CL,  DL
   ROR    RAX, CL
 end;
-{$ENDIF CPU64}
+{$ENDIF CPUX64}
 
 const
   // Lookup table of bit reversed nibbles, used by simple overloads of ReverseBits
@@ -1108,120 +1220,161 @@ function ReverseBits(P: Pointer; Count: Integer): Pointer;
 end;
 
 function RRot(const Value: Byte; const Count: TBitRange): Byte;
+{$IFDEF PUREPASCAL}
+begin
+  Result := LRot(Value, 8 - (Count and $7));
+end;
+{$ELSE ~PUREPASCAL}
 asm
-  {$IFDEF CPU32}
+  {$IFDEF CPU386}
   // --> AL Value
   //     DL Count
   // <-- AL Result
   MOV    CL, DL
   ROR    AL, CL
-  {$ENDIF CPU32}
-  {$IFDEF CPU64}
+  {$ENDIF CPU386}
+  {$IFDEF CPUX64}
   // --> CL Value
   //     DL Count
   // <-- AL Result
   MOV    AL, CL
   MOV    CL, DL
   ROR    AL, CL
-  {$ENDIF CPU64}
+  {$ENDIF CPUX64}
 end;
+{$ENDIF ~PUREPASCAL}
 
 function RRot(const Value: Word; const Count: TBitRange): Word;
+{$IFDEF PUREPASCAL}
+begin
+  Result := LRot(Value, 16 - (Count and $F));
+end;
+{$ELSE ~PUREPASCAL}
 asm
-  {$IFDEF CPU32}
+  {$IFDEF CPU386}
   // --> AX Value
   //     DL Count
   // <-- AX Result
   MOV    CL, DL
   ROR    AX, CL
-  {$ENDIF CPU32}
-  {$IFDEF CPU64}
+  {$ENDIF CPU386}
+  {$IFDEF CPUX64}
   // --> CX Value
   //     DL Count
   // <-- AX Result
   MOV    AX, CX
   MOV    CL, DL
   ROR    AX, CL
-  {$ENDIF CPU64}
+  {$ENDIF CPUX64}
 end;
+{$ENDIF ~PUREPASCAL}
 
 function RRot(const Value: Integer; const Count: TBitRange): Integer;
+{$IFDEF PUREPASCAL}
+begin
+  Result := LRot(Value, 32 - (Count and $1F));
+end;
+{$ELSE ~PUREPASCAL}
 asm
-  {$IFDEF CPU32}
+  {$IFDEF CPU386}
   // --> EAX Value
   //     DL  Count
   // <-- EAX Result
   MOV    CL,  DL
   ROR    EAX, CL
-  {$ENDIF CPU32}
-  {$IFDEF CPU64}
+  {$ENDIF CPU386}
+  {$IFDEF CPUX64}
   // --> ECX Value
   //     DL  Count
   // <-- EAX Result
   MOV    EAX, ECX
   MOV    CL,  DL
   ROR    EAX, CL
-  {$ENDIF CPU64}
+  {$ENDIF CPUX64}
 end;
+{$ENDIF ~PUREPASCAL}
 
 function Sar(const Value: Shortint; const Count: TBitRange): Shortint;
+{$IFDEF PUREPASCAL}
+begin
+  Result := ShortInt(Smallint(Value) shr Count);
+end;
+{$ELSE ~PUREPASCAL}
 asm
-  {$IFDEF CPU32}
+  {$IFDEF CPU386}
   // --> AL Value
   //     DL Count
   // <-- AL Result
   MOV    CL, DL
   SAR    AL, CL
-  {$ENDIF CPU32}
-  {$IFDEF CPU64}
+  {$ENDIF CPU386}
+  {$IFDEF CPUX64}
   // --> CL Value
   //     DL Count
   // <-- AL Result
   MOV    AL, CL
   MOV    CL, DL
   SAR    AL, CL
-  {$ENDIF CPU64}
+  {$ENDIF CPUX64}
 end;
+{$ENDIF ~PUREPASCAL}
 
 function Sar(const Value: Smallint; const Count: TBitRange): Smallint;
+{$IFDEF PUREPASCAL}
+begin
+  Result := Smallint(Integer(Value) shr Count);
+end;
+{$ELSE ~PUREPASCAL}
 asm
-  {$IFDEF CPU32}
+  {$IFDEF CPU386}
   // --> AX Value
   //     DL Count
   // <-- AX Result
   MOV    CL, DL
   SAR    AX, CL
-  {$ENDIF CPU32}
-  {$IFDEF CPU64}
+  {$ENDIF CPU386}
+  {$IFDEF CPUX64}
   // --> CX Value
   //     DL Count
   // <-- AX Result
   MOV    AX, CX
   MOV    CL, DL
   SAR    AX, CL
-  {$ENDIF CPU64}
+  {$ENDIF CPUX64}
 end;
+{$ENDIF ~PUREPASCAL}
 
 function Sar(const Value: Integer; const Count: TBitRange): Integer;
+{$IFDEF PUREPASCAL}
+begin
+  Result := Integer(Int64(Value) shr Count);
+end;
+{$ELSE ~PUREPASCAL}
 asm
-  {$IFDEF CPU32}
+  {$IFDEF CPU386}
   // --> EAX Value
   //     DL  Count
   // <-- EAX Result
   MOV    CL, DL
   SAR    EAX, CL
-  {$ENDIF CPU32}
-  {$IFDEF CPU64}
+  {$ENDIF CPU386}
+  {$IFDEF CPUX64}
   // --> ECX Value
   //     DL  Count
   // <-- EAX Result
   MOV    EAX, ECX
   MOV    CL,  DL
   SAR    EAX, CL
-  {$ENDIF CPU64}
+  {$ENDIF CPUX64}
 end;
+{$ENDIF ~PUREPASCAL}
 
 function SetBit(const Value: Byte; const Bit: TBitRange): Byte;
+{$IFDEF PUREPASCAL}
+begin
+  Result := Value or (Byte(1) shl (Bit and (BitsPerByte - 1)));
+end;
+{$ELSE ~PUREPASCAL}
 asm
   // 32 --> AL Value
   //        DL Bit
@@ -1230,13 +1383,19 @@ function SetBit(const Value: Byte; const Bit: TBitRange): Byte;
   //        DL Bit
   //    <-- AL Result
   AND    EDX, BitsPerByte - 1   // modulo BitsPerByte
-  {$IFDEF CPU64}
+  {$IFDEF CPUX64}
   MOVZX  EAX, CL
-  {$ENDIF CPU64}
+  {$ENDIF CPUX64}
   BTS    EAX, EDX
 end;
+{$ENDIF ~PUREPASCAL}
 
 function SetBit(const Value: Shortint; const Bit: TBitRange): Shortint;
+{$IFDEF PUREPASCAL}
+begin
+  Result := Value or (Shortint(1) shl (Bit and (BitsPerShortint - 1)));
+end;
+{$ELSE ~PUREPASCAL}
 asm
   // 32 --> AL Value
   //        DL Bit
@@ -1245,13 +1404,19 @@ function SetBit(const Value: Shortint; const Bit: TBitRange): Shortint;
   //        DL Bit
   //    <-- AL Result
   AND    EDX, BitsPerShortInt - 1   // modulo BitsPerShortInt
-  {$IFDEF CPU64}
+  {$IFDEF CPUX64}
   MOVZX  EAX, CL
-  {$ENDIF CPU64}
+  {$ENDIF CPUX64}
   BTS    EAX, EDX
 end;
+{$ENDIF ~PUREPASCAL}
 
 function SetBit(const Value: Smallint; const Bit: TBitRange): Smallint;
+{$IFDEF PUREPASCAL}
+begin
+  Result := Value or (Smallint(1) shl (Bit and (BitsPerSmallint - 1)));
+end;
+{$ELSE ~PUREPASCAL}
 asm
   // 32 --> AX Value
   //        DL Bit
@@ -1260,13 +1425,19 @@ function SetBit(const Value: Smallint; const Bit: TBitRange): Smallint;
   //        DL Bit
   //    <-- AX Result
   AND    EDX, BitsPerSmallInt - 1   // modulo BitsPerSmallInt
-  {$IFDEF CPU64}
+  {$IFDEF CPUX64}
   MOVZX  EAX, CX
-  {$ENDIF CPU64}
+  {$ENDIF CPUX64}
   BTS    EAX, EDX
 end;
+{$ENDIF ~PUREPASCAL}
 
 function SetBit(const Value: Word; const Bit: TBitRange): Word;
+{$IFDEF PUREPASCAL}
+begin
+  Result := Value or (Word(1) shl (Bit and (BitsPerWord - 1)));
+end;
+{$ELSE ~PUREPASCAL}
 asm
   // 32 --> AX Value
   //        DL Bit
@@ -1275,13 +1446,19 @@ function SetBit(const Value: Word; const Bit: TBitRange): Word;
   //        DL Bit
   //    <-- AX Result
   AND    EDX, BitsPerWord - 1   // modulo BitsPerWord
-  {$IFDEF CPU64}
+  {$IFDEF CPUX64}
   MOVZX  EAX, CX
-  {$ENDIF CPU64}
+  {$ENDIF CPUX64}
   BTS    EAX, EDX
 end;
+{$ENDIF ~PUREPASCAL}
 
 function SetBit(const Value: Cardinal; const Bit: TBitRange): Cardinal;
+{$IFDEF PUREPASCAL}
+begin
+  Result := Value or (Cardinal(1) shl (Bit and (BitsPerCardinal - 1)));
+end;
+{$ELSE ~PUREPASCAL}
 asm
   // 32 --> EAX Value
   //        DL  Bit
@@ -1289,13 +1466,19 @@ function SetBit(const Value: Cardinal; const Bit: TBitRange): Cardinal;
   // 64 --> ECX Value
   //        DL  Bit
   //    <-- EAX Result
-  {$IFDEF CPU64}
+  {$IFDEF CPUX64}
   MOV    EAX, ECX
-  {$ENDIF CPU64}
+  {$ENDIF CPUX64}
   BTS    EAX, EDX
 end;
+{$ENDIF ~PUREPASCAL}
 
 function SetBit(const Value: Integer; const Bit: TBitRange): Integer;
+{$IFDEF PUREPASCAL}
+begin
+  Result := Value or (Integer(1) shl (Bit and (BitsPerInteger - 1)));
+end;
+{$ELSE ~PUREPASCAL}
 asm
   // 32 --> EAX Value
   //        DL  Bit
@@ -1303,19 +1486,19 @@ function SetBit(const Value: Integer; const Bit: TBitRange): Integer;
   // 64 --> ECX Value
   //        DL  Bit
   //    <-- EAX Result
-  {$IFDEF CPU64}
+  {$IFDEF CPUX64}
   MOV    EAX, ECX
-  {$ENDIF CPU64}
+  {$ENDIF CPUX64}
   BTS    EAX, EDX
 end;
+{$ENDIF ~PUREPASCAL}
 
 function SetBit(const Value: Int64; const Bit: TBitRange): Int64;
-{$IFDEF CPU32}
+{$IFNDEF CPUX64}
 begin
   Result := Value or (Int64(1) shl (Bit and (BitsPerInt64 - 1)));
 end;
-{$ENDIF CPU32}
-{$IFDEF CPU64}
+{$ELSE CPUX64}
 asm
   // --> RCX Value
   //     DL  Bit
@@ -1323,7 +1506,7 @@ function SetBit(const Value: Int64; const Bit: TBitRange): Int64;
   MOV    RAX, RCX
   BTS    RAX, RDX
 end;
-{$ENDIF CPU64}
+{$ENDIF CPUX64}
 
 procedure SetBitBuffer(var Value; const Bit: Cardinal);
 {$IFDEF PUREPASCAL}
@@ -1375,9 +1558,9 @@ function TestBit(const Value: Byte; const Bit: TBitRange): Boolean;
   //        DL Bit
   //    <-- AL Result
   AND    EDX, BitsPerByte - 1   // modulo BitsPerByte
-  {$IFDEF CPU64}
+  {$IFDEF CPUX64}
   MOVZX  EAX, CL
-  {$ENDIF CPU64}
+  {$ENDIF CPUX64}
   BT     EAX, EDX
   SETC   AL
 end;
@@ -1397,9 +1580,9 @@ function TestBit(const Value: Shortint; const Bit: TBitRange): Boolean;
   //        DL Bit
   //    <-- AL Result
   AND    EDX, BitsPerShortInt - 1   // modulo BitsPerShortInt
-  {$IFDEF CPU64}
+  {$IFDEF CPUX64}
   MOVZX  EAX, CL
-  {$ENDIF CPU64}
+  {$ENDIF CPUX64}
   BT     EAX, EDX
   SETC   AL
 end;
@@ -1419,9 +1602,9 @@ function TestBit(const Value: Smallint; const Bit: TBitRange): Boolean;
   //        DL Bit
   //    <-- AX Result
   AND    EDX, BitsPerSmallInt - 1   // modulo BitsPerSmallInt
-  {$IFDEF CPU64}
+  {$IFDEF CPUX64}
   MOVZX  EAX, CX
-  {$ENDIF CPU64}
+  {$ENDIF CPUX64}
   BT     EAX, EDX
   SETC   AL
 end;
@@ -1441,9 +1624,9 @@ function TestBit(const Value: Word; const Bit: TBitRange): Boolean;
   //        DL Bit
   //    <-- AX Result
   AND    EDX, BitsPerWord - 1   // modulo BitsPerWord
-  {$IFDEF CPU64}
+  {$IFDEF CPUX64}
   MOVZX  EAX, CX
-  {$ENDIF CPU64}
+  {$ENDIF CPUX64}
   BT     EAX, EDX
   SETC   AL
 end;
@@ -1462,9 +1645,9 @@ function TestBit(const Value: Cardinal; const Bit: TBitRange): Boolean;
   // 64 --> ECX Value
   //        DL  Bit
   //    <-- EAX Result
-  {$IFDEF CPU64}
+  {$IFDEF CPUX64}
   MOV    EAX, ECX
-  {$ENDIF CPU64}
+  {$ENDIF CPUX64}
   BT     EAX, EDX
   SETC   AL
 end;
@@ -1483,21 +1666,20 @@ function TestBit(const Value: Integer; const Bit: TBitRange): Boolean;
   // 64 --> ECX Value
   //        DL  Bit
   //    <-- EAX Result
-  {$IFDEF CPU64}
+  {$IFDEF CPUX64}
   MOV    EAX, ECX
-  {$ENDIF CPU64}
+  {$ENDIF CPUX64}
   BT     EAX, EDX
   SETC   AL
 end;
 {$ENDIF ~PUREPASCAL}
 
 function TestBit(const Value: Int64; const Bit: TBitRange): Boolean;
-{$IFDEF CPU32}
+{$IFNDEF CPUX64}
 begin
   Result := (Value shr (Bit and (BitsPerInt64 - 1))) and 1 <> 0;
 end;
-{$ENDIF CPU32}
-{$IFDEF CPU64}
+{$ELSE CPUX64}
 asm
   // --> RCX Value
   //     DL  Bit
@@ -1506,7 +1688,7 @@ function TestBit(const Value: Int64; const Bit: TBitRange): Boolean;
   BT     RAX, RDX
   SETC   AL
 end;
-{$ENDIF ~PUREPASCAL}
+{$ENDIF CPUX64}
 
 function TestBitBuffer(const Value; const Bit: Cardinal): Boolean;
 {$IFDEF PUREPASCAL}
@@ -1595,9 +1777,9 @@ function ToggleBit(const Value: Byte; const Bit: TBitRange): Byte;
   //        DL Bit
   //    <-- AL Result
   AND    EDX, BitsPerByte - 1   // modulo BitsPerByte
-  {$IFDEF CPU64}
+  {$IFDEF CPUX64}
   MOVZX  EAX, CL
-  {$ENDIF CPU64}
+  {$ENDIF CPUX64}
   BTC    EAX, EDX
 end;
 {$ENDIF ~PUREPASCAL}
@@ -1616,9 +1798,9 @@ function ToggleBit(const Value: Shortint; const Bit: TBitRange): Shortint;
   //        DL Bit
   //    <-- AL Result
   AND    EDX, BitsPerShortInt - 1   // modulo BitsPerShortInt
-  {$IFDEF CPU64}
+  {$IFDEF CPUX64}
   MOVZX  EAX, CL
-  {$ENDIF CPU64}
+  {$ENDIF CPUX64}
   BTC    EAX, EDX
 end;
 {$ENDIF ~PUREPASCAL}
@@ -1637,9 +1819,9 @@ function ToggleBit(const Value: Smallint; const Bit: TBitRange): Smallint;
   //        DL Bit
   //    <-- AX Result
   AND    EDX, BitsPerSmallInt - 1   // modulo BitsPerSmallInt
-  {$IFDEF CPU64}
+  {$IFDEF CPUX64}
   MOVZX  EAX, CX
-  {$ENDIF CPU64}
+  {$ENDIF CPUX64}
   BTC    EAX, EDX
 end;
 {$ENDIF ~PUREPASCAL}
@@ -1658,9 +1840,9 @@ function ToggleBit(const Value: Word; const Bit: TBitRange): Word;
   //        DL Bit
   //    <-- AX Result
   AND    EDX, BitsPerWord - 1   // modulo BitsPerWord
-  {$IFDEF CPU64}
+  {$IFDEF CPUX64}
   MOVZX  EAX, CX
-  {$ENDIF CPU64}
+  {$ENDIF CPUX64}
   BTC    EAX, EDX
 end;
 {$ENDIF ~PUREPASCAL}
@@ -1678,9 +1860,9 @@ function ToggleBit(const Value: Cardinal; const Bit: TBitRange): Cardinal;
   // 64 --> ECX Value
   //        DL  Bit
   //    <-- EAX Result
-  {$IFDEF CPU64}
+  {$IFDEF CPUX64}
   MOV    EAX, ECX
-  {$ENDIF CPU64}
+  {$ENDIF CPUX64}
   BTC    EAX, EDX
 end;
 {$ENDIF ~PUREPASCAL}
@@ -1698,20 +1880,19 @@ function ToggleBit(const Value: Integer; const Bit: TBitRange): Integer;
   // 64 --> ECX Value
   //        DL  Bit
   //    <-- EAX Result
-  {$IFDEF CPU64}
+  {$IFDEF CPUX64}
   MOV    EAX, ECX
-  {$ENDIF CPU64}
+  {$ENDIF CPUX64}
   BTC    EAX, EDX
 end;
 {$ENDIF ~PUREPASCAL}
 
 function ToggleBit(const Value: Int64; const Bit: TBitRange): Int64;
-{$IFDEF CPU32}
+{$IFNDEF CPUX64}
 begin
   Result := Value xor (Int64(1) shl (Bit and (BitsPerInt64 - 1)));
 end;
-{$ENDIF CPU32}
-{$IFDEF CPU64}
+{$ELSE CPUX64}
 asm
   // --> RCX Value
   //     DL  Bit
@@ -1719,7 +1900,7 @@ function ToggleBit(const Value: Int64; const Bit: TBitRange): Int64;
   MOV    RAX, RCX
   BTC    RAX, RDX
 end;
-{$ENDIF CPU64}
+{$ENDIF CPUX64}
 
 procedure ToggleBitBuffer(var Value; const Bit: Cardinal);
 {$IFDEF PUREPASCAL}
@@ -1896,38 +2077,38 @@ function ReverseBytes(Value: Word): Word;
 end;
 {$ELSE ~PUREPASCAL}
 asm
-  {$IFDEF CPU32}
+  {$IFDEF CPU386}
   // --> AX Value
   // <-- AX Value
   XCHG   AL, AH
-  {$ENDIF CPU32}
-  {$IFDEF CPU64}
+  {$ENDIF CPU386}
+  {$IFDEF CPUX64}
   // --> CX Value
   // <-- AX Value
   MOV    AH, CL
   MOV    AL, CH
-  {$ENDIF CPU64}
+  {$ENDIF CPUX64}
 end;
 {$ENDIF ~PUREPASCAL}
 
 function ReverseBytes(Value: Smallint): Smallint;
 {$IFDEF PUREPASCAL}
-asm
-  XCHG    AL, AH
+begin
+  Result := Smallint((Word(Value) shr 8) or (Word(Value) shl 8));
 end;
 {$ELSE ~PUREPASCAL}
 asm
-  {$IFDEF CPU32}
+  {$IFDEF CPU386}
   // --> AX Value
   // <-- AX Value
   XCHG   AL, AH
-  {$ENDIF CPU32}
-  {$IFDEF CPU64}
+  {$ENDIF CPU386}
+  {$IFDEF CPUX64}
   // --> CX Value
   // <-- AX Value
   MOV    AH, CL
   MOV    AL, CH
-  {$ENDIF CPU64}
+  {$ENDIF CPUX64}
 end;
 {$ENDIF ~PUREPASCAL}
 
@@ -1938,17 +2119,17 @@ function ReverseBytes(Value: Integer): Integer;
 end;
 {$ELSE ~PUREPASCAL}
 asm
-  {$IFDEF CPU32}
+  {$IFDEF CPU386}
   // --> EAX Value
   // <-- EAX Value
   BSWAP  EAX
-  {$ENDIF CPU32}
-  {$IFDEF CPU64}
+  {$ENDIF CPU386}
+  {$IFDEF CPUX64}
   // --> ECX Value
   // <-- EAX Value
   MOV    EAX, ECX
   BSWAP  EAX
-  {$ENDIF CPU64}
+  {$ENDIF CPUX64}
 end;
 {$ENDIF ~PUREPASCAL}
 
@@ -1959,22 +2140,22 @@ function ReverseBytes(Value: Cardinal): Cardinal;
 end;
 {$ELSE ~PUREPASCAL}
 asm
-  {$IFDEF CPU32}
+  {$IFDEF CPU386}
   // --> EAX Value
   // <-- EAX Value
   BSWAP  EAX
-  {$ENDIF CPU32}
-  {$IFDEF CPU64}
+  {$ENDIF CPU386}
+  {$IFDEF CPUX64}
   // --> ECX Value
   // <-- EAX Value
   MOV    EAX, ECX
   BSWAP  EAX
-  {$ENDIF CPU64}
+  {$ENDIF CPUX64}
 end;
 {$ENDIF ~PUREPASCAL}
 
 function ReverseBytes(Value: Int64): Int64;
-{$IFDEF CPU32}
+{$IFNDEF CPUX64}
 var
   Lo, Hi: Cardinal;
 begin
@@ -1984,15 +2165,14 @@ function ReverseBytes(Value: Int64): Int64;
   TJclULargeInteger(Result).HighPart := (Hi shr 24) or (Hi shl 24) or ((Hi and $00FF0000) shr 8) or ((Hi and $0000FF00) shl 8);
   TJclULargeInteger(Result).LowPart := (Lo shr 24) or (Lo shl 24) or ((Lo and $00FF0000) shr 8) or ((Lo and $0000FF00) shl 8);
 end;
-{$ENDIF CPU32}
-{$IFDEF CPU64}
+{$ELSE CPUX64}
 asm
   // --> RCX Value
   // <-- RAX Result
   MOV    RAX, RCX
   BSWAP  RAX
 end;
-{$ENDIF CPU64}
+{$ENDIF CPUX64}
 
 function ReverseBytes(P: Pointer; Count: Integer): Pointer;
 var
diff --git a/jcl/source/common/JclMath.pas b/jcl/source/common/JclMath.pas
index f66a3a550..529080087 100644
--- a/jcl/source/common/JclMath.pas
+++ b/jcl/source/common/JclMath.pas
@@ -158,7 +158,9 @@ function DegToRad(const Value: Extended): Extended; overload; {$IFDEF SUPPORTS_I
 {$ENDIF SUPPORTS_EXTENDED}
 function DegToRad(const Value: Double): Double; overload; {$IFDEF SUPPORTS_INLINE}inline;{$ENDIF}
 function DegToRad(const Value: Single): Single; overload; {$IFDEF SUPPORTS_INLINE}inline;{$ENDIF}
+{$IFDEF CPUINTEL}
 procedure FastDegToRad;
+{$ENDIF CPUINTEL}
 
 // Converts radians to degrees.
 {$IFDEF SUPPORTS_EXTENDED}
@@ -166,7 +168,9 @@ function RadToDeg(const Value: Extended): Extended; overload; {$IFDEF SUPPORTS_I
 {$ENDIF SUPPORTS_EXTENDED}
 function RadToDeg(const Value: Double): Double; overload; {$IFDEF SUPPORTS_INLINE}inline;{$ENDIF}
 function RadToDeg(const Value: Single): Single; overload; {$IFDEF SUPPORTS_INLINE}inline;{$ENDIF}
+{$IFDEF CPUINTEL}
 procedure FastRadToDeg;
+{$ENDIF CPUINTEL}
 
 // Converts grads to radians.
 {$IFDEF SUPPORTS_EXTENDED}
@@ -174,7 +178,9 @@ function GradToRad(const Value: Extended): Extended; overload; {$IFDEF SUPPORTS_
 {$ENDIF SUPPORTS_EXTENDED}
 function GradToRad(const Value: Double): Double; overload; {$IFDEF SUPPORTS_INLINE}inline;{$ENDIF}
 function GradToRad(const Value: Single): Single; overload; {$IFDEF SUPPORTS_INLINE}inline;{$ENDIF}
+{$IFDEF CPUINTEL}
 procedure FastGradToRad;
+{$ENDIF CPUINTEL}
 
 // Converts radians to grads.
 {$IFDEF SUPPORTS_EXTENDED}
@@ -182,7 +188,9 @@ function RadToGrad(const Value: Extended): Extended; overload; {$IFDEF SUPPORTS_
 {$ENDIF SUPPORTS_EXTENDED}
 function RadToGrad(const Value: Double): Double; overload; {$IFDEF SUPPORTS_INLINE}inline;{$ENDIF}
 function RadToGrad(const Value: Single): Single; overload; {$IFDEF SUPPORTS_INLINE}inline;{$ENDIF}
+{$IFDEF CPUINTEL}
 procedure FastRadToGrad;
+{$ENDIF CPUINTEL}
 
 // Converts degrees to grads.
 {$IFDEF SUPPORTS_EXTENDED}
@@ -190,7 +198,9 @@ function DegToGrad(const Value: Extended): Extended; overload; {$IFDEF SUPPORTS_
 {$ENDIF SUPPORTS_EXTENDED}
 function DegToGrad(const Value: Double): Double; overload; {$IFDEF SUPPORTS_INLINE}inline;{$ENDIF}
 function DegToGrad(const Value: Single): Single; overload; {$IFDEF SUPPORTS_INLINE}inline;{$ENDIF}
+{$IFDEF CPUINTEL}
 procedure FastDegToGrad;
+{$ENDIF CPUINTEL}
 
 // Converts grads to degrees.
 {$IFDEF SUPPORTS_EXTENDED}
@@ -198,7 +208,9 @@ function GradToDeg(const Value: Extended): Extended; overload; {$IFDEF SUPPORTS_
 {$ENDIF SUPPORTS_EXTENDED}
 function GradToDeg(const Value: Double): Double; overload; {$IFDEF SUPPORTS_INLINE}inline;{$ENDIF}
 function GradToDeg(const Value: Single): Single; overload; {$IFDEF SUPPORTS_INLINE}inline;{$ENDIF}
+{$IFDEF CPUINTEL}
 procedure FastGradToDeg;
+{$ENDIF CPUINTEL}
 
 { Logarithmic }
 
@@ -910,7 +922,9 @@ implementation
   {$IFDEF USE_MATH_UNIT}
   System.Math,
   {$ENDIF USE_MATH_UNIT}
+  {$IFDEF CPUINTEL}
   Jcl8087,
+  {$ENDIF CPUINTEL}
   JclResources,
   JclSynch;
 
@@ -1002,6 +1016,7 @@ function DegToRad(const Value: Single): Single;
 
 // Expects degrees in ST(0), leaves radians in ST(0)
 // ST(0) := ST(0) * PI / 180
+{$IFDEF CPUINTEL}
 procedure FastDegToRad; assembler;
 asm
         {$IFDEF PIC}
@@ -1018,6 +1033,7 @@ procedure FastDegToRad; assembler;
         FMULP
         FWAIT
 end;
+{$ENDIF CPUINTEL}
 
 // Converts radians to degrees.
 
@@ -1040,6 +1056,7 @@ function RadToDeg(const Value: Single): Single;
 
 // Expects radians in ST(0), leaves degrees in ST(0)
 // ST(0) := ST(0) * (180 / PI);
+{$IFDEF CPUINTEL}
 procedure FastRadToDeg; assembler;
 asm
         {$IFDEF PIC}
@@ -1056,6 +1073,7 @@ procedure FastRadToDeg; assembler;
         FMULP
         FWAIT
 end;
+{$ENDIF CPUINTEL}
 
 // Converts grads to radians.
 
@@ -1078,6 +1096,7 @@ function GradToRad(const Value: Single): Single;
 
 // Expects grads in ST(0), leaves radians in ST(0)
 // ST(0) := ST(0) * PI / 200
+{$IFDEF CPUINTEL}
 procedure FastGradToRad; assembler;
 asm
         {$IFDEF PIC}
@@ -1094,6 +1113,7 @@ procedure FastGradToRad; assembler;
         FMULP
         FWAIT
 end;
+{$ENDIF CPUINTEL}
 
 // Converts radians to grads.
 
@@ -1116,6 +1136,7 @@ function RadToGrad(const Value: Single): Single;
 
 // Expects radians in ST(0), leaves grads in ST(0)
 // ST(0) := ST(0) * (200 / PI);
+{$IFDEF CPUINTEL}
 procedure FastRadToGrad; assembler;
 asm
         {$IFDEF PIC}
@@ -1132,6 +1153,7 @@ procedure FastRadToGrad; assembler;
         FMULP
         FWAIT
 end;
+{$ENDIF CPUINTEL}
 
 // Converts degrees to grads.
 
@@ -1154,6 +1176,7 @@ function DegToGrad(const Value: Single): Single;
 
 // Expects Degrees in ST(0), leaves grads in ST(0)
 // ST(0) := ST(0) * (200 / 180);
+{$IFDEF CPUINTEL}
 procedure FastDegToGrad; assembler;
 asm
         {$IFDEF PIC}
@@ -1170,6 +1193,7 @@ procedure FastDegToGrad; assembler;
         FMULP
         FWAIT
 end;
+{$ENDIF CPUINTEL}
 
 // Converts grads to degrees.
 
@@ -1192,6 +1216,7 @@ function GradToDeg(const Value: Single): Single;
 
 // Expects grads in ST(0), leaves radians in ST(0)
 // ST(0) := ST(0) * PI / 200
+{$IFDEF CPUINTEL}
 procedure FastGradToDeg; assembler;
 asm
         {$IFDEF PIC}
@@ -1208,6 +1233,7 @@ procedure FastGradToDeg; assembler;
         FMULP
         FWAIT
 end;
+{$ENDIF CPUINTEL}
 
 procedure DomainCheck(Err: Boolean);
 begin
diff --git a/jcl/source/common/JclRTTI.pas b/jcl/source/common/JclRTTI.pas
index 9fa98f8be..30af1b800 100644
--- a/jcl/source/common/JclRTTI.pas
+++ b/jcl/source/common/JclRTTI.pas
@@ -2827,7 +2827,7 @@ function JclGenerateSetType(BaseType: PTypeInfo;
 
 function JclIsClass(const AnObj: TObject; const AClass: TClass): Boolean;
 asm
-        {$IFDEF CPU32}
+        {$IFDEF CPU386}
         // 32 --> EAX AnObj
         //        EDX AClass
         //    <-- AL  Result
@@ -2839,8 +2839,8 @@ function JclIsClass(const AnObj: TObject; const AClass: TClass): Boolean;
         JE      @@success
         MOV     EAX,[EAX].vmtParent
         TEST    EAX,EAX
-        {$ENDIF CPU32}
-        {$IFDEF CPU64}
+        {$ENDIF CPU386}
+        {$IFDEF CPUX64}
         // 64 --> RCX AnObj
         //        RDX AClass
         //    <-- AL  Result
@@ -2853,7 +2853,7 @@ function JclIsClass(const AnObj: TObject; const AClass: TClass): Boolean;
         JE      @@success
         MOV     RAX,[RAX].vmtParent
         TEST    RAX,RAX
-        {$ENDIF CPU64}
+        {$ENDIF CPUX64}
         JNE     @@loop
         JMP     @@exit
 @@success:
diff --git a/jcl/source/common/JclStringConversions.pas b/jcl/source/common/JclStringConversions.pas
index 8efe87750..468fd4bb2 100644
--- a/jcl/source/common/JclStringConversions.pas
+++ b/jcl/source/common/JclStringConversions.pas
@@ -342,8 +342,17 @@ function StreamWriteWord(S: TStream; W: Word): Boolean; {$IFDEF SUPPORTS_INLINE}
 // EAX contains Source, EDX contains Target, ECX contains Count
 
 procedure ExpandASCIIString(const Source: PAnsiChar; Target: PWideChar; Count: SizeInt);
+{$IFDEF PUREPASCAL}
+begin
+  while Count > 0 do
+  begin
+    Dec(Count);
+    Target[Count] := WideChar(Source[Count]);
+  end;
+end;
+{$ELSE ~PUREPASCAL}
 asm
-       {$IFDEF CPU32}
+       {$IFDEF CPU386}
        // --> EAX Source
        //     EDX Target
        //     ECX Count
@@ -359,8 +368,8 @@ procedure ExpandASCIIString(const Source: PAnsiChar; Target: PWideChar; Count: S
        DEC     ECX
        JNZ     @@1
        POP     ESI
-       {$ENDIF CPU32}
-       {$IFDEF CPU64}
+       {$ENDIF CPU386}
+       {$IFDEF CPUX64}
        // --> RCX Source
        //     RDX Target
        //     R8  Count
@@ -375,9 +384,10 @@ procedure ExpandASCIIString(const Source: PAnsiChar; Target: PWideChar; Count: S
 @@2:
        DEC     R8
        JNS     @@1
-       {$ENDIF CPU64}
+       {$ENDIF CPUX64}
 @@Finish:
 end;
+{$ENDIF ~PUREPASCAL}
 
 const
   HalfShift: Integer = 10;
diff --git a/jcl/source/common/JclStrings.pas b/jcl/source/common/JclStrings.pas
index 44fcb2549..1195a5d28 100644
--- a/jcl/source/common/JclStrings.pas
+++ b/jcl/source/common/JclStrings.pas
@@ -2282,6 +2282,18 @@ function StrCompareRange(const S1, S2: string; Index, Count: SizeInt; CaseSensit
 
 procedure StrFillChar(var S; Count: SizeInt; C: Char);
 {$IFDEF SUPPORTS_UNICODE}
+{$IFDEF PUREPASCAL}
+var
+  P: PWideChar;
+begin
+  P := Pointer(@S);
+  while Count > 0 do
+  begin
+    Dec(Count);
+    P[Count] := C;
+  end;
+end;
+{$ELSE ~PUREPASCAL}
 asm
         // 32 --> EAX S
         //        EDX Count
@@ -2289,7 +2301,7 @@ procedure StrFillChar(var S; Count: SizeInt; C: Char);
         // 64 --> RCX S
         //        RDX Count
         //        R8W C
-        {$IFDEF CPU32}
+        {$IFDEF CPU386}
         DEC     EDX
         JS      @@Leave
 @@Loop:
@@ -2297,8 +2309,8 @@ procedure StrFillChar(var S; Count: SizeInt; C: Char);
         ADD     EAX, 2
         DEC     EDX
         JNS     @@Loop
-        {$ENDIF CPU32}
-        {$IFDEF CPU64}
+        {$ENDIF CPU386}
+        {$IFDEF CPUX64}
         DEC     RDX
         JS      @@Leave
 @@Loop:
@@ -2306,9 +2318,10 @@ procedure StrFillChar(var S; Count: SizeInt; C: Char);
         ADD     RCX, 2
         DEC     RDX
         JNS     @@Loop
-        {$ENDIF CPU64}
+        {$ENDIF CPUX64}
 @@Leave:
 end;
+{$ENDIF ~PUREPASCAL}
 {$ELSE ~SUPPORTS_UNICODE}
 begin
   if Count > 0 then
@@ -4396,11 +4409,12 @@ function TJclStringBuilder.Insert(Index: SizeInt; Obj: TObject): TJclStringBuild
 
 function TJclStringBuilder.Remove(StartIndex, Length: SizeInt): TJclStringBuilder;
 begin
-  if (StartIndex < 0) or (Length < 0) or (StartIndex + Length >= FLength) then
+  if (StartIndex < 0) or (Length < 0) or (StartIndex + Length > FLength) then
     raise ArgumentOutOfRangeException.CreateRes(@RsArgumentOutOfRange);
   if Length > 0 then
   begin
-    MoveChar(FChars[StartIndex + Length], FChars[StartIndex], FLength - (StartIndex + Length));
+    if FLength > (StartIndex + Length) then
+      MoveChar(FChars[StartIndex + Length], FChars[StartIndex], FLength - (StartIndex + Length));
     Dec(FLength, Length);
   end;
   Result := Self;
diff --git a/jcl/source/common/JclSynch.pas b/jcl/source/common/JclSynch.pas
index 4d1768b0b..fcfa2890b 100644
--- a/jcl/source/common/JclSynch.pas
+++ b/jcl/source/common/JclSynch.pas
@@ -373,8 +373,13 @@ implementation
 
 // Locked Integer manipulation
 function LockedAdd(var Target: Integer; Value: Integer): Integer;
+{$IFDEF PUREPASCAL}
+begin
+  Result := InterlockedAdd(Target, Value);
+end;
+{$ELSE ~PUREPASCAL}
 asm
-        {$IFDEF CPU32}
+        {$IFDEF CPU386}
         // --> EAX Target
         //     EDX Value
         // <-- EAX Result
@@ -382,20 +387,26 @@ function LockedAdd(var Target: Integer; Value: Integer): Integer;
         MOV     EAX, EDX
         LOCK XADD [ECX], EAX
         ADD     EAX, EDX
-        {$ENDIF CPU32}
-        {$IFDEF CPU64}
+        {$ENDIF CPU386}
+        {$IFDEF CPUX64}
         // --> RCX Target
         //     EDX Value
         // <-- EAX Result
         MOV     EAX, EDX
         LOCK XADD [RCX], EAX
         ADD     EAX, EDX
-        {$ENDIF CPU64}
+        {$ENDIF CPUX64}
 end;
+{$ENDIF}
 
 function LockedCompareExchange(var Target: Integer; Exch, Comp: Integer): Integer;
+{$IFDEF PUREPASCAL}
+begin
+  Result := InterlockedCompareExchange(Target, Exch, Comp);
+end;
+{$ELSE ~PUREPASCAL}
 asm
-        {$IFDEF CPU32}
+        {$IFDEF CPU386}
         // --> EAX Target
         //     EDX Exch
         //     ECX Comp
@@ -405,8 +416,8 @@ function LockedCompareExchange(var Target: Integer; Exch, Comp: Integer): Intege
         //     EDX Exch
         //     ECX Target
         LOCK CMPXCHG [ECX], EDX
-        {$ENDIF CPU32}
-        {$IFDEF CPU64}
+        {$ENDIF CPU386}
+        {$IFDEF CPUX64}
         // --> RCX Target
         //     EDX Exch
         //     R8  Comp
@@ -416,12 +427,18 @@ function LockedCompareExchange(var Target: Integer; Exch, Comp: Integer): Intege
         //     EDX Exch
         //     RAX Comp
         LOCK CMPXCHG [RCX], EDX
-        {$ENDIF CPU64}
+        {$ENDIF CPUX64}
 end;
+{$ENDIF}
 
 function LockedCompareExchange(var Target: Pointer; Exch, Comp: Pointer): Pointer;
+{$IFDEF PUREPASCAL}
+begin
+  Result := InterlockedCompareExchangePointer(Target, Exch, Comp)
+end;
+{$ELSE ~PUREPASCAL}
 asm
-        {$IFDEF CPU32}
+        {$IFDEF CPU386}
         // --> EAX Target
         //     EDX Exch
         //     ECX Comp
@@ -431,8 +448,8 @@ function LockedCompareExchange(var Target: Pointer; Exch, Comp: Pointer): Pointe
         //     EDX Exch
         //     ECX Target
         LOCK CMPXCHG [ECX], EDX
-        {$ENDIF CPU32}
-        {$IFDEF CPU64}
+        {$ENDIF CPU386}
+        {$IFDEF CPUX64}
         // --> RCX Target
         //     RDX Exch
         //     R8  Comp
@@ -442,12 +459,19 @@ function LockedCompareExchange(var Target: Pointer; Exch, Comp: Pointer): Pointe
         //     RDX Exch
         //     RAX Comp
         LOCK CMPXCHG [RCX], RDX
-        {$ENDIF CPU64}
+        {$ENDIF CPUX64}
 end;
+{$ENDIF ~PUREPASCAL}
 
 function LockedCompareExchange(var Target: TObject; Exch, Comp: TObject): TObject;
+{$IFDEF PUREPASCAL}
+begin
+  Result := TObject(InterlockedCompareExchangePointer(Pointer(Target),
+    Pointer(Exch), Pointer(Comp)));
+end;
+{$ELSE ~PUREPASCAL}
 asm
-        {$IFDEF CPU32}
+        {$IFDEF CPU386}
         // --> EAX Target
         //     EDX Exch
         //     ECX Comp
@@ -457,8 +481,8 @@ function LockedCompareExchange(var Target: TObject; Exch, Comp: TObject): TObjec
         //     EDX Exch
         //     ECX Target
         LOCK CMPXCHG [ECX], EDX
-        {$ENDIF CPU32}
-        {$IFDEF CPU64}
+        {$ENDIF CPU386}
+        {$IFDEF CPUX64}
         // --> RCX Target
         //     RDX Exch
         //     R8  Comp
@@ -468,31 +492,43 @@ function LockedCompareExchange(var Target: TObject; Exch, Comp: TObject): TObjec
         //     RDX Exch
         //     RAX Comp
         LOCK CMPXCHG [RCX], RDX
-        {$ENDIF CPU64}
+        {$ENDIF CPUX64}
 end;
+{$ENDIF ~PUREPASCAL}
 
 function LockedDec(var Target: Integer): Integer;
+{$IFDEF PUREPASCAL}
+begin
+  Result := InterlockedDecrement(Target);
+end;
+{$ELSE ~PUREPASCAL}
 asm
-        {$IFDEF CPU32}
+        {$IFDEF CPU386}
         // --> EAX Target
         // <-- EAX Result
         MOV     ECX, EAX
         MOV     EAX, -1
         LOCK XADD [ECX], EAX
         DEC     EAX
-        {$ENDIF CPU32}
-        {$IFDEF CPU64}
+        {$ENDIF CPU386}
+        {$IFDEF CPUX64}
         // --> RCX Target
         // <-- EAX Result
         MOV     EAX, -1
         LOCK XADD [RCX], EAX
         DEC     EAX
-        {$ENDIF CPU64}
+        {$ENDIF CPUX64}
 end;
+{$ENDIF ~PUREPASCAL}
 
 function LockedExchange(var Target: Integer; Value: Integer): Integer;
+{$IFDEF PUREPASCAL}
+begin
+  Result := InterlockedExchange(Target, Value);
+end;
+{$ELSE ~PUREPASCAL}
 asm
-        {$IFDEF CPU32}
+        {$IFDEF CPU386}
         // --> EAX Target
         //     EDX Value
         // <-- EAX Result
@@ -501,8 +537,8 @@ function LockedExchange(var Target: Integer; Value: Integer): Integer;
         //     ECX Target
         //     EAX Value
         LOCK XCHG [ECX], EAX
-        {$ENDIF CPU32}
-        {$IFDEF CPU64}
+        {$ENDIF CPU386}
+        {$IFDEF CPUX64}
         // --> RCX Target
         //     EDX Value
         // <-- EAX Result
@@ -510,12 +546,18 @@ function LockedExchange(var Target: Integer; Value: Integer): Integer;
         //     RCX Target
         //     EAX Value
         LOCK XCHG [RCX], EAX
-        {$ENDIF CPU64}
+        {$ENDIF CPUX64}
 end;
+{$ENDIF ~PUREPASCAL}
 
 function LockedExchangeAdd(var Target: Integer; Value: Integer): Integer;
+{$IFDEF PUREPASCAL}
+begin
+  Result := InterlockedExchangeAdd(Target, Value);
+end;
+{$ELSE ~PUREPASCAL}
 asm
-        {$IFDEF CPU32}
+        {$IFDEF CPU386}
         // --> EAX Target
         //     EDX Value
         // <-- EAX Result
@@ -524,8 +566,8 @@ function LockedExchangeAdd(var Target: Integer; Value: Integer): Integer;
         //     ECX Target
         //     EAX Value
         LOCK XADD [ECX], EAX
-        {$ENDIF CPU32}
-        {$IFDEF CPU64}
+        {$ENDIF CPU386}
+        {$IFDEF CPUX64}
         // --> RCX Target
         //     EDX Value
         // <-- EAX Result
@@ -533,46 +575,64 @@ function LockedExchangeAdd(var Target: Integer; Value: Integer): Integer;
         //     RCX Target
         //     EAX Value
         LOCK XADD [RCX], EAX
-        {$ENDIF CPU64}
+        {$ENDIF CPUX64}
 end;
+{$ENDIF ~PUREPASCAL}
 
 function LockedExchangeDec(var Target: Integer): Integer;
+{$IFDEF PUREPASCAL}
+begin
+  Result := InterlockedExchangeSubtract(Target, 1);
+end;
+{$ELSE ~PUREPASCAL}
 asm
-        {$IFDEF CPU32}
+        {$IFDEF CPU386}
         // --> EAX Target
         // <-- EAX Result
         MOV     ECX, EAX
         MOV     EAX, -1
         LOCK XADD [ECX], EAX
-        {$ENDIF CPU32}
-        {$IFDEF CPU64}
+        {$ENDIF CPU386}
+        {$IFDEF CPUX64}
         // --> RCX Target
         // <-- EAX Result
         MOV     EAX, -1
         LOCK XADD [RCX], EAX
-        {$ENDIF CPU64}
+        {$ENDIF CPUX64}
 end;
+{$ENDIF ~PUREPASCAL}
 
 function LockedExchangeInc(var Target: Integer): Integer;
+{$IFDEF PUREPASCAL}
+begin
+  Result := InterlockedExchangeAdd(Target, 1);
+end;
+{$ELSE ~PUREPASCAL}
 asm
-        {$IFDEF CPU32}
+        {$IFDEF CPU386}
         // --> EAX Target
         // <-- EAX Result
         MOV     ECX, EAX
         MOV     EAX, 1
         LOCK XADD [ECX], EAX
-        {$ENDIF CPU32}
-        {$IFDEF CPU64}
+        {$ENDIF CPU386}
+        {$IFDEF CPUX64}
         // --> RCX Target
         // <-- EAX Result
         MOV     EAX, 1
         LOCK XADD [RCX], EAX
-        {$ENDIF CPU64}
+        {$ENDIF CPUX64}
 end;
+{$ENDIF}
 
 function LockedExchangeSub(var Target: Integer; Value: Integer): Integer;
+{$IFDEF PUREPASCAL}
+begin
+  Result := InterlockedExchangeSubtract(Target, Value);
+end;
+{$ELSE ~PUREPASCAL}
 asm
-        {$IFDEF CPU32}
+        {$IFDEF CPU386}
         // --> EAX Target
         //     EDX Value
         // <-- EAX Result
@@ -582,8 +642,8 @@ function LockedExchangeSub(var Target: Integer; Value: Integer): Integer;
         //     ECX Target
         //     EAX -Value
         LOCK XADD [ECX], EAX
-        {$ENDIF CPU32}
-        {$IFDEF CPU64}
+        {$ENDIF CPU386}
+        {$IFDEF CPUX64}
         // --> RCX Target
         //     EDX Value
         // <-- EAX Result
@@ -592,31 +652,43 @@ function LockedExchangeSub(var Target: Integer; Value: Integer): Integer;
         //     RCX Target
         //     EAX -Value
         LOCK XADD [RCX], EAX
-        {$ENDIF CPU64}
+        {$ENDIF CPUX64}
 end;
+{$ENDIF ~PUREPASCAL}
 
 function LockedInc(var Target: Integer): Integer;
+{$IFDEF PUREPASCAL}
+begin
+  Result := InterlockedIncrement(Target);
+end;
+{$ELSE ~PUREPASCAL}
 asm
-        {$IFDEF CPU32}
+        {$IFDEF CPU386}
         // --> EAX Target
         // <-- EAX Result
         MOV     ECX, EAX
         MOV     EAX, 1
         LOCK XADD [ECX], EAX
         INC     EAX
-        {$ENDIF CPU32}
-        {$IFDEF CPU64}
+        {$ENDIF CPU386}
+        {$IFDEF CPUX64}
         // --> RCX Target
         // <-- EAX Result
         MOV     EAX, 1
         LOCK XADD [RCX], EAX
         INC     EAX
-        {$ENDIF CPU64}
+        {$ENDIF CPUX64}
 end;
+{$ENDIF ~PUREPASCAL}
 
 function LockedSub(var Target: Integer; Value: Integer): Integer;
+{$IFDEF PUREPASCAL}
+begin
+  Result := InterlockedAdd(Target, -Value);
+end;
+{$ELSE ~PUREPASCAL}
 asm
-        {$IFDEF CPU32}
+        {$IFDEF CPU386}
         // --> EAX Target
         //     EDX Value
         // <-- EAX Result
@@ -625,8 +697,8 @@ function LockedSub(var Target: Integer; Value: Integer): Integer;
         MOV     EAX, EDX
         LOCK XADD [ECX], EAX
         ADD     EAX, EDX
-        {$ENDIF CPU32}
-        {$IFDEF CPU64}
+        {$ENDIF CPU386}
+        {$IFDEF CPUX64}
         // --> RCX Target
         //     EDX Value
         // <-- EAX Result
@@ -634,13 +706,19 @@ function LockedSub(var Target: Integer; Value: Integer): Integer;
         MOV     EAX, EDX
         LOCK XADD [RCX], EAX
         ADD     EAX, EDX
-        {$ENDIF CPU64}
+        {$ENDIF CPUX64}
 end;
+{$ENDIF}
 
 {$IFDEF CPU64}
 
 // Locked Int64 manipulation
 function LockedAdd(var Target: Int64; Value: Int64): Int64;
+{$IFDEF PUREPASCAL}
+begin
+  Result := InterlockedAdd64(Target, Value);
+end;
+{$ELSE ~PUREPASCAL}
 asm
         // --> RCX Target
         //     RDX Value
@@ -649,8 +727,14 @@ function LockedAdd(var Target: Int64; Value: Int64): Int64;
         LOCK XADD [RCX], RAX
         ADD     RAX, RDX
 end;
+{$ENDIF ~PUREPASCAL}
 
 function LockedCompareExchange(var Target: Int64; Exch, Comp: Int64): Int64;
+{$IFDEF PUREPASCAL}
+begin
+  Result := InterlockedCompareExchange64(Target, Exch, Comp);
+end;
+{$ELSE ~PUREPASCAL}
 asm
         // --> RCX Target
         //     RDX Exch
@@ -659,8 +743,14 @@ function LockedCompareExchange(var Target: Int64; Exch, Comp: Int64): Int64;
         MOV     RAX, R8
         LOCK CMPXCHG [RCX], RDX
 end;
+{$ENDIF ~PUREPASCAL}
 
 function LockedDec(var Target: Int64): Int64;
+{$IFDEF PUREPASCAL}
+begin
+  Result := InterlockedDecrement64(Target);
+end;
+{$ELSE}
 asm
         // --> RCX Target
         // <-- RAX Result
@@ -668,8 +758,14 @@ function LockedDec(var Target: Int64): Int64;
         LOCK XADD [RCX], RAX
         DEC     RAX
 end;
+{$ENDIF ~PUREPASCAL}
 
 function LockedExchange(var Target: Int64; Value: Int64): Int64;
+{$IFDEF PUREPASCAL}
+begin
+  Result := InterlockedExchange64(Target, Value);
+end;
+{$ELSE ~PUREPASCAL}
 asm
         // --> RCX Target
         //     RDX Value
@@ -677,8 +773,14 @@ function LockedExchange(var Target: Int64; Value: Int64): Int64;
         MOV     RAX, RDX
         LOCK XCHG [RCX], RAX
 end;
+{$ENDIF ~PUREPASCAL}
 
 function LockedExchangeAdd(var Target: Int64; Value: Int64): Int64;
+{$IFDEF PUREPASCAL}
+begin
+  Result := InterlockedExchangeAdd64(Target, Value);
+end;
+{$ELSE ~PUREPASCAL}
 asm
         // --> RCX Target
         //     RDX Value
@@ -686,24 +788,42 @@ function LockedExchangeAdd(var Target: Int64; Value: Int64): Int64;
         MOV     RAX, RDX
         LOCK XADD [RCX], RAX
 end;
+{$ENDIF ~PUREPASCAL}
 
 function LockedExchangeDec(var Target: Int64): Int64;
+{$IFDEF PUREPASCAL}
+begin
+  Result := InterlockedExchangeAdd64(Target, -1);
+end;
+{$ELSE ~PUREPASCAL}
 asm
         // --> RCX Target
         // <-- RAX Result
         MOV     RAX, -1
         LOCK XADD [RCX], RAX
 end;
+{$ENDIF ~PUREPASCAL}
 
 function LockedExchangeInc(var Target: Int64): Int64;
+{$IFDEF PUREPASCAL}
+begin
+  Result := InterlockedExchangeAdd64(Target, 1);
+end;
+{$ELSE ~PUREPASCAL}
 asm
         // --> RCX Target
         // <-- RAX Result
         MOV     RAX, 1
         LOCK XADD [RCX], RAX
 end;
+{$ENDIF ~PUREPASCAL}
 
 function LockedExchangeSub(var Target: Int64; Value: Int64): Int64;
+{$IFDEF PUREPASCAL}
+begin
+  Result := InterlockedExchangeAdd64(Target, -Value);
+end;
+{$ELSE ~PUREPASCAL}
 asm
         // --> RCX Target
         //     RDX Value
@@ -712,8 +832,14 @@ function LockedExchangeSub(var Target: Int64; Value: Int64): Int64;
         MOV     RAX, RDX
         LOCK XADD [RCX], RAX
 end;
+{$ENDIF ~PUREPASCAL}
 
 function LockedInc(var Target: Int64): Int64;
+{$IFDEF PUREPASCAL}
+begin
+  Result := InterlockedIncrement64(Target);
+end;
+{$ELSE ~PUREPASCAL}
 asm
         // --> RCX Target
         // <-- RAX Result
@@ -721,8 +847,14 @@ function LockedInc(var Target: Int64): Int64;
         LOCK XADD [RCX], RAX
         INC     RAX
 end;
+{$ENDIF ~PUREPASCAL}
 
 function LockedSub(var Target: Int64; Value: Int64): Int64;
+{$IFDEF PUREPASCAL}
+begin
+  Result := InterlockedAdd64(Target, -Value);
+end;
+{$ELSE ~PUREPASCAL}
 asm
         // --> RCX Target
         //     RDX Value
@@ -732,6 +864,7 @@ function LockedSub(var Target: Int64; Value: Int64): Int64;
         LOCK XADD [RCX], RAX
         ADD     RAX, RDX
 end;
+{$ENDIF ~PUREPASCAL}
 
 {$IFDEF BORLAND}
 
diff --git a/jcl/source/common/JclSysInfo.pas b/jcl/source/common/JclSysInfo.pas
index b86c6de2f..ff0037bd2 100644
--- a/jcl/source/common/JclSysInfo.pas
+++ b/jcl/source/common/JclSysInfo.pas
@@ -377,6 +377,7 @@ function GetOSVersionString: string;
 {$IFDEF MSWINDOWS}
 function GetMacAddresses(const Machine: string; const Addresses: TStrings): Integer;
 {$ENDIF MSWINDOWS}
+{$IFDEF CPUINTEL}
 function ReadTimeStampCounter: Int64;
 {$IFDEF WIN64}
 {$EXTERNALSYM ReadTimeStampCounter}
@@ -1370,6 +1371,7 @@ function GetOSEnabledFeatures: TOSEnabledFeatures;
 {$ENDIF MSWINDOWS}
 function CPUID: TCpuInfo;
 function TestFDIVInstruction: Boolean;
+{$ENDIF CPUINTEL}
 
 // Memory Information
 {$IFDEF MSWINDOWS}
@@ -1476,7 +1478,10 @@ implementation
   JclRegistry, JclWin32,
   {$ENDIF MSWINDOWS}
   {$ENDIF ~HAS_UNITSCOPE}
-  Jcl8087, JclIniFiles,
+  {$IFDEF CPUINTEL}
+  Jcl8087,
+  {$ENDIF CPUINTEL}
+  JclIniFiles,
   JclSysUtils, JclFileUtils, JclAnsiStrings, JclStrings;
 
 {$IFDEF FPC}
@@ -4594,7 +4599,9 @@ function GetOpenGLVersion(const Win: THandle; out Version, Vendor: AnsiString):
   glErr: Cardinal;
   bError: Boolean;
   sOpenGLVersion, sOpenGLVendor: AnsiString;
+  {$IFDEF CPUINTEL}
   Save8087CW: Word;
+  {$ENDIF}
 
   procedure FunctionFailedError(Name: string);
   begin
@@ -4640,9 +4647,13 @@ function GetOpenGLVersion(const Win: THandle; out Version, Vendor: AnsiString):
 
     { To call for the version information string we must first have an active
       context established for use.  We can, of course, close this after use }
+    {$IFDEF CPUINTEL}
     Save8087CW := Get8087ControlWord;
+    {$ENDIF CPUINTEL}
     try
+      {$IFDEF CPUINTEL}
       Set8087CW($133F);
+      {$ENDIF CPUINTEL}
       hGLContext := 0;
       Result := False;
       bError := False;
@@ -4731,7 +4742,9 @@ function GetOpenGLVersion(const Win: THandle; out Version, Vendor: AnsiString):
           wglDeleteContextFunc(hGLContext);
       end;
     finally
+      {$IFDEF CPUINTEL}
       Set8087CW(Save8087CW);
+      {$ENDIF CPUINTEL}
     end;
   finally
     if (OpenGlLib <> 0) then
@@ -5048,15 +5061,16 @@ function GetMacAddresses(const Machine: string; const Addresses: TStrings): Inte
 end;
 {$ENDIF MSWINDOWS}
 
+{$IFDEF CPUINTEL}
 function ReadTimeStampCounter: Int64; assembler;
 asm
         DW      $310F
         // TSC in EDX:EAX
-        {$IFDEF CPU64}
+        {$IFDEF CPUX64}
         SHL     RDX, 32
         OR      RAX, RDX
         // Result in RAX
-        {$ENDIF CPU64}
+        {$ENDIF CPUX64}
 end;
 
 function GetIntelCacheDescription(const D: Byte): string;
@@ -5275,7 +5289,7 @@ function CPUID: TCpuInfo;
   begin
   {$ENDIF ~DELPHI64_TEMPORARY}
     asm
-      {$IFDEF CPU32}
+      {$IFDEF CPU386}
       PUSHFD
       POP     EAX
       MOV     ECX, EAX
@@ -5288,8 +5302,8 @@ function CPUID: TCpuInfo;
       AND     EAX, ID_FLAG
       XOR     EAX, ECX
       SETNZ   Result
-      {$ENDIF CPU32}
-      {$IFDEF CPU64}
+      {$ENDIF CPU386}
+      {$IFDEF CPUX64}
       {$IFDEF FPC}
         {$DEFINE DELPHI64_TEMPORARY}
       {$ENDIF FPC}
@@ -5320,7 +5334,7 @@ function CPUID: TCpuInfo;
       {$IFDEF FPC}
         {$UNDEF DELPHI64_TEMPORARY}
       {$ENDIF FPC}
-      {$ENDIF CPU64}
+      {$ENDIF CPUX64}
     end;
   {$IFNDEF DELPHI64_TEMPORARY}
   end;
@@ -5331,7 +5345,7 @@ function CPUID: TCpuInfo;
   begin
   {$ENDIF ~DELPHI64_TEMPORARY}
     asm
-      {$IFDEF CPU32}
+      {$IFDEF CPU386}
       // save context
       PUSH    EDI
       PUSH    EBX
@@ -5353,8 +5367,8 @@ function CPUID: TCpuInfo;
       // restore context
       POP  EBX
       POP  EDI
-      {$ENDIF CPU32}
-      {$IFDEF CPU64}
+      {$ENDIF CPU386}
+      {$IFDEF CPUX64}
       // save context
       PUSH    RBX
       // init parameters
@@ -5373,7 +5387,7 @@ function CPUID: TCpuInfo;
       MOV     Cardinal PTR [R11], EDX
       // restore context
       POP     RBX
-      {$ENDIF CPU64}
+      {$ENDIF CPUX64}
     end;
   {$IFNDEF DELPHI64_TEMPORARY}
   end;
@@ -6022,7 +6036,7 @@ function CPUID: TCpuInfo;
 end;
 
 function TestFDIVInstruction: Boolean;
-{$IFDEF CPU32}
+{$IFDEF CPU386}
 var
   TopNum: Double;
   BottomNum: Double;
@@ -6050,12 +6064,13 @@ function TestFDIVInstruction: Boolean;
   end;
   Result := ISOK;
 end;
-{$ENDIF CPU32}
-{$IFDEF CPU64}
+{$ENDIF CPU386}
+{$IFDEF CPUX64}
 begin
   Result := True;
 end;
-{$ENDIF CPU64}
+{$ENDIF CPUX64}
+{$ENDIF CPUINTEL}
 
 //=== Alloc granularity ======================================================
 
diff --git a/jcl/source/common/JclSysUtils.pas b/jcl/source/common/JclSysUtils.pas
index 1bcd25ff9..91b580c21 100644
--- a/jcl/source/common/JclSysUtils.pas
+++ b/jcl/source/common/JclSysUtils.pas
@@ -338,6 +338,7 @@ procedure SetVirtualMethod(AClass: TClass; const Index: Integer; const Method: P
   TDynamicAddressList = array [0..MaxInt div 16] of Pointer;
   PDynamicAddressList = ^TDynamicAddressList;
 
+{$IFDEF CPUINTEL}
 function GetDynamicMethodCount(AClass: TClass): Integer;
 function GetDynamicIndexList(AClass: TClass): PDynamicIndexList;
 function GetDynamicAddressList(AClass: TClass): PDynamicAddressList;
@@ -375,6 +376,7 @@ function GetInitTable(AClass: TClass): PTypeInfo;
   end;
 
 function GetFieldTable(AClass: TClass): PFieldTable;
+{$ENDIF CPUINTEL}
 
 { method table }
 
@@ -393,7 +395,9 @@ function GetFieldTable(AClass: TClass): PFieldTable;
    {Entries: array [1..65534] of TMethodEntry;}
   end;
 
+{$IFDEF CPUINTEL}
 function GetMethodTable(AClass: TClass): PMethodTable;
+{$ENDIF CPUINTEL}
 function GetMethodEntry(MethodTable: PMethodTable; Index: Integer): PMethodEntry;
 
 // Function to compare if two methods/event handlers are equal
@@ -402,11 +406,15 @@ function NotifyEventEquals(aMethod1, aMethod2: TNotifyEvent): boolean;
 
 // Class Parent
 procedure SetClassParent(AClass: TClass; NewClassParent: TClass);
+{$IFDEF CPUINTEL}
 function GetClassParent(AClass: TClass): TClass;
+{$ENDIF CPUINTEL}
 
 {$IFNDEF FPC}
+{$IFDEF CPUINTEL}
 function IsClass(Address: Pointer): Boolean;
 function IsObject(Address: Pointer): Boolean;
+{$ENDIF CPUINTEL}
 {$ENDIF ~FPC}
 
 function InheritsFromByName(AClass: TClass; const AClassName: string): Boolean;
@@ -1996,46 +2004,47 @@ procedure SetVirtualMethod(AClass: TClass; const Index: Integer; const Method: P
   SetVMTPointer(AClass, Index * SizeOf(Pointer), Method);
 end;
 
+{$IFDEF CPUINTEL}
 function GetDynamicMethodCount(AClass: TClass): Integer; assembler;
 asm
-        {$IFDEF CPU32}
+        {$IFDEF CPU386}
         // --> RAX AClass
         // <-- EAX Result
         MOV     EAX, [EAX].vmtDynamicTable
         TEST    EAX, EAX
         JE      @@Exit
         MOVZX   EAX, WORD PTR [EAX]
-        {$ENDIF CPU32}
-        {$IFDEF CPU64}
+        {$ENDIF CPU386}
+        {$IFDEF CPUX64}
         // --> RCX AClass
         // <-- EAX Result
         MOV     RAX, [RCX].vmtDynamicTable
         TEST    RAX, RAX
         JE      @@Exit
         MOVZX   RAX, WORD PTR [RAX]
-        {$ENDIF CPU64}
+        {$ENDIF CPUX64}
 @@Exit:
 end;
 
 function GetDynamicIndexList(AClass: TClass): PDynamicIndexList; assembler;
 asm
-        {$IFDEF CPU32}
+        {$IFDEF CPU386}
         // --> EAX AClass
         // <-- EAX Result
         MOV     EAX, [EAX].vmtDynamicTable
         ADD     EAX, 2
-        {$ENDIF CPU32}
-        {$IFDEF CPU64}
+        {$ENDIF CPU386}
+        {$IFDEF CPUX64}
         // --> RCX AClass
         // <-- RAX Result
         MOV     RAX, [RCX].vmtDynamicTable
         ADD     RAX, 2
-        {$ENDIF CPU64}
+        {$ENDIF CPUX64}
 end;
 
 function GetDynamicAddressList(AClass: TClass): PDynamicAddressList; assembler;
 asm
-        {$IFDEF CPU32}
+        {$IFDEF CPU386}
         // --> EAX AClass
         // <-- EAX Result
         MOV     EAX, [EAX].vmtDynamicTable
@@ -2043,8 +2052,8 @@ function GetDynamicAddressList(AClass: TClass): PDynamicAddressList; assembler;
         ADD     EAX, EDX
         ADD     EAX, EDX
         ADD     EAX, 2
-        {$ENDIF CPU32}
-        {$IFDEF CPU64}
+        {$ENDIF CPU386}
+        {$IFDEF CPUX64}
         // --> RCX AClass
         // <-- RAX Result
         MOV     RAX, [RCX].vmtDynamicTable
@@ -2052,13 +2061,13 @@ function GetDynamicAddressList(AClass: TClass): PDynamicAddressList; assembler;
         ADD     RAX, RDX
         ADD     RAX, RDX
         ADD     RAX, 2
-        {$ENDIF CPU64}
+        {$ENDIF CPUX64}
 end;
 
 function HasDynamicMethod(AClass: TClass; Index: Integer): Boolean; assembler;
 // Mainly copied from System.GetDynaMethod
 asm
-        {$IFDEF CPU32}
+        {$IFDEF CPU386}
         // --> EAX AClass
         //     EDX Index
         // <-- AL  Result
@@ -2088,8 +2097,8 @@ function HasDynamicMethod(AClass: TClass; Index: Integer): Boolean; assembler;
         MOV     EAX, 1
 @@Exit:
         POP     EDI
-        {$ENDIF CPU32}
-        {$IFDEF CPU64}
+        {$ENDIF CPU386}
+        {$IFDEF CPUX64}
         // --> RCX AClass
         //     EDX Index
         // <-- AL  Result
@@ -2118,7 +2127,7 @@ function HasDynamicMethod(AClass: TClass; Index: Integer): Boolean; assembler;
         POP     RAX
         MOV     RAX, 1
 @@Exit:
-        {$ENDIF CPU64}
+        {$ENDIF CPUX64}
 end;
 
 {$IFNDEF FPC}
@@ -2132,45 +2141,46 @@ function GetDynamicMethod(AClass: TClass; Index: Integer): Pointer; assembler;
 
 function GetInitTable(AClass: TClass): PTypeInfo; assembler;
 asm
-        {$IFDEF CPU32}
+        {$IFDEF CPU386}
         // --> EAX AClass
         // <-- EAX Result
         MOV     EAX, [EAX].vmtInitTable
-        {$ENDIF CPU32}
-        {$IFDEF CPU64}
+        {$ENDIF CPU386}
+        {$IFDEF CPUX64}
         // --> RCX AClass
         // <-- RAX Result
         MOV     RAX, [RCX].vmtInitTable
-        {$ENDIF CPU64}
+        {$ENDIF CPUX64}
 end;
 
 function GetFieldTable(AClass: TClass): PFieldTable; assembler;
 asm
-        {$IFDEF CPU32}
+        {$IFDEF CPU386}
         // --> EAX AClass
         // <-- EAX Result
         MOV     EAX, [EAX].vmtFieldTable
-        {$ENDIF CPU32}
-        {$IFDEF CPU64}
+        {$ENDIF CPU386}
+        {$IFDEF CPUX64}
         // --> RCX AClass
         // <-- RAX Result
         MOV     RAX, [RCX].vmtFieldTable
-        {$ENDIF CPU64}
+        {$ENDIF CPUX64}
 end;
 
 function GetMethodTable(AClass: TClass): PMethodTable; assembler;
 asm
-        {$IFDEF CPU32}
+        {$IFDEF CPU386}
         // --> EAX AClass
         // <-- EAX Result
         MOV     EAX, [EAX].vmtMethodTable
-        {$ENDIF CPU32}
-        {$IFDEF CPU64}
+        {$ENDIF CPU386}
+        {$IFDEF CPUX64}
         // --> RCX AClass
         // <-- RAX Result
         MOV     RAX, [RCX].vmtMethodTable
-        {$ENDIF CPU64}
+        {$ENDIF CPUX64}
 end;
+{$ENDIF CPUINTEL}
 
 function GetMethodEntry(MethodTable: PMethodTable; Index: Integer): PMethodEntry;
 begin
@@ -2211,24 +2221,25 @@ procedure SetClassParent(AClass: TClass; NewClassParent: TClass);
   // FlushInstructionCache{$IFDEF MSWINDOWS}(GetCurrentProcess, PatchAddress, SizeOf(Pointer)){$ENDIF};
 end;
 
+{$IFDEF CPUINTEL}
 function GetClassParent(AClass: TClass): TClass; assembler;
 asm
-        {$IFDEF CPU32}
+        {$IFDEF CPU386}
         // --> EAX AClass
         // <-- EAX Result
         MOV     EAX, [EAX].vmtParent
         TEST    EAX, EAX
         JE      @@Exit
         MOV     EAX, [EAX]
-        {$ENDIF CPU32}
-        {$IFDEF CPU64}
+        {$ENDIF CPU386}
+        {$IFDEF CPUX64}
         // --> RCX AClass
         // <-- RAX Result
         MOV     RAX, [RCX].vmtParent
         TEST    RAX, RAX
         JE      @@Exit
         MOV     RAX, [RAX]
-        {$ENDIF CPU64}
+        {$ENDIF CPUX64}
 @@Exit:
 end;
 
@@ -2259,6 +2270,7 @@ function IsObject(Address: Pointer): Boolean; assembler;
 @Exit:
 end;
 {$ENDIF BORLAND}
+{$ENDIF CPUINTEL}
 
 function InheritsFromByName(AClass: TClass; const AClassName: string): Boolean;
 begin
diff --git a/jcl/source/common/JclUnicode.pas b/jcl/source/common/JclUnicode.pas
index c6e07a94f..b5c90bfa2 100644
--- a/jcl/source/common/JclUnicode.pas
+++ b/jcl/source/common/JclUnicode.pas
@@ -5569,21 +5569,22 @@ function TWideStrings.Equals(Strings: TWideStrings): Boolean;
 end;
 
 procedure TWideStrings.Error(const Msg: string; Data: Integer);
-
+  {$IFDEF CPUINTEL}
   function ReturnAddr: Pointer;
   asm
-          {$IFDEF CPU32}
+          {$IFDEF CPU386}
           MOV     EAX, EBP
           MOV     EAX, [EAX + 4]
-          {$ENDIF CPU32}
-          {$IFDEF CPU64}
+          {$ENDIF CPU386}
+          {$IFDEF CPUX64}
           MOV     RAX, RBP
           MOV     RAX, [RAX + 8]
-          {$ENDIF CPU64}
+          {$ENDIF CPUX64}
   end;
+  {$ENDIF CPUINTEL}
 
 begin
-  raise EStringListError.CreateFmt(Msg, [Data]) at ReturnAddr;
+  raise EStringListError.CreateFmt(Msg, [Data]) {$IFDEF CPUINTEL}at ReturnAddr{$ENDIF CPUINTEL};
 end;
 
 procedure TWideStrings.Exchange(Index1, Index2: Integer);
diff --git a/jcl/source/common/JclWideStrings.pas b/jcl/source/common/JclWideStrings.pas
index 89b95774a..78a07acec 100644
--- a/jcl/source/common/JclWideStrings.pas
+++ b/jcl/source/common/JclWideStrings.pas
@@ -822,8 +822,17 @@ function StrRScanW(const Str: PWideChar; Chr: WideChar): PWideChar;
 // stop at the first #0 character
 
 procedure StrSwapByteOrder(Str: PWideChar);
+{$IFDEF PUREPASCAL}
+begin
+  while Str^ <> #0 do
+  begin
+    Str^ := WideChar((Word(Str^) shr 8) or (Word(Str^) shl 8));
+    Inc(Str);
+  end;
+end;
+{$ELSE ~PUREPASCAL}
 asm
-       {$IFDEF CPU32}
+       {$IFDEF CPU386}
        // --> EAX Str
        PUSH    ESI
        PUSH    EDI
@@ -840,8 +849,8 @@ procedure StrSwapByteOrder(Str: PWideChar);
 @@2:
        POP     EDI
        POP     ESI
-       {$ENDIF CPU32}
-       {$IFDEF CPU64}
+       {$ENDIF CPU386}
+       {$IFDEF CPUX64}
        // --> RCX Str
        XOR     RAX, RAX // clear high order byte to be able to use 64bit operand below
 @@1:
@@ -853,8 +862,9 @@ procedure StrSwapByteOrder(Str: PWideChar);
        ADD     ECX, 2
        JMP     @@1
 @@2:
-       {$ENDIF CPU64}
+       {$ENDIF CPUX64}
 end;
+{$ENDIF ~PUREPASCAL}
 
 function StrNScanW(const Str1, Str2: PWideChar): SizeInt;
 // Determines where (in Str1) the first time one of the characters of Str2 appear.
diff --git a/jcl/source/common/bzip2.pas b/jcl/source/common/bzip2.pas
index cc2870e96..e46992490 100644
--- a/jcl/source/common/bzip2.pas
+++ b/jcl/source/common/bzip2.pas
@@ -406,7 +406,7 @@ function _BZ2_indexIntoF: Pointer;
 function BZ2_indexIntoF: Pointer; external;
 {$ENDIF CPU64}
 
-{$IFDEF CPU32}
+{$IFDEF CPU386}
 {$LINK ..\windows\obj\bzip2\win32\bzlib.obj}
 {$LINK ..\windows\obj\bzip2\win32\randtable.obj}
 {$LINK ..\windows\obj\bzip2\win32\crctable.obj}
@@ -414,8 +414,8 @@ function BZ2_indexIntoF: Pointer; external;
 {$LINK ..\windows\obj\bzip2\win32\decompress.obj}
 {$LINK ..\windows\obj\bzip2\win32\huffman.obj}
 {$LINK ..\windows\obj\bzip2\win32\blocksort.obj}
-{$ENDIF CPU32}
-{$IFDEF CPU64}
+{$ENDIF CPU386}
+{$IFDEF CPUX64}
 {$LINK ..\windows\obj\bzip2\win64\bzlib.obj}
 {$LINK ..\windows\obj\bzip2\win64\randtable.obj}
 {$LINK ..\windows\obj\bzip2\win64\crctable.obj}
@@ -423,7 +423,7 @@ function BZ2_indexIntoF: Pointer; external;
 {$LINK ..\windows\obj\bzip2\win64\decompress.obj}
 {$LINK ..\windows\obj\bzip2\win64\huffman.obj}
 {$LINK ..\windows\obj\bzip2\win64\blocksort.obj}
-{$ENDIF CPU64}
+{$ENDIF CPUX64}
 
 {$IFDEF CPU32}
 function _malloc(size: Longint): Pointer; cdecl;
diff --git a/jcl/source/common/pcre.pas b/jcl/source/common/pcre.pas
index 730964cec..bfd74702b 100644
--- a/jcl/source/common/pcre.pas
+++ b/jcl/source/common/pcre.pas
@@ -1724,7 +1724,7 @@ procedure _pcre16_jit_compile; external;
 procedure _pcre16_jit_free; external;
 {$ENDIF PCRE_16}
 
-{$IFDEF CPU32}
+{$IFDEF CPU386}
 
 {$IFDEF PCRE_8}
 
@@ -1772,8 +1772,8 @@ procedure _pcre16_jit_free; external;
 {$LINK ..\windows\obj\pcre\win32\pcre16_string_utils.obj}
 {$ENDIF PCRE_16}
 
-{$ENDIF CPU32}
-{$IFDEF CPU64}
+{$ENDIF CPU386}
+{$IFDEF CPUX64}
 
 {$IFDEF PCRE_8}
 
@@ -1822,7 +1822,7 @@ procedure _pcre16_jit_free; external;
 
 {$ENDIF PCRE_16}
 
-{$ENDIF CPU64}
+{$ENDIF CPUX64}
 
 // user's defined callbacks
 var
diff --git a/jcl/source/common/zlibh.pas b/jcl/source/common/zlibh.pas
index 2032b98d2..baea930c4 100644
--- a/jcl/source/common/zlibh.pas
+++ b/jcl/source/common/zlibh.pas
@@ -2206,7 +2206,7 @@ function inflateBackInit(var strm: TZStreamRec; windowBits: Integer; window: PBy
 
 {$IFDEF ZLIB_STATICLINK}
 
-{$IFDEF CPU32}
+{$IFDEF CPU386}
 {$LINK ..\windows\obj\zlib\win32\adler32.obj} // OS: CHECKTHIS - Unix version may need forward slashes?
 {$LINK ..\windows\obj\zlib\win32\compress.obj}
 {$LINK ..\windows\obj\zlib\win32\crc32.obj}
@@ -2218,8 +2218,8 @@ function inflateBackInit(var strm: TZStreamRec; windowBits: Integer; window: PBy
 {$LINK ..\windows\obj\zlib\win32\trees.obj}
 {$LINK ..\windows\obj\zlib\win32\uncompr.obj}
 {$LINK ..\windows\obj\zlib\win32\zutil.obj}
-{$ENDIF CPU32}
-{$IFDEF CPU64}
+{$ENDIF CPU386}
+{$IFDEF CPUX64}
 {$LINK ..\windows\obj\zlib\win64\adler32.obj}
 {$LINK ..\windows\obj\zlib\win64\compress.obj}
 {$LINK ..\windows\obj\zlib\win64\crc32.obj}
@@ -2231,7 +2231,7 @@ function inflateBackInit(var strm: TZStreamRec; windowBits: Integer; window: PBy
 {$LINK ..\windows\obj\zlib\win64\trees.obj}
 {$LINK ..\windows\obj\zlib\win64\uncompr.obj}
 {$LINK ..\windows\obj\zlib\win64\zutil.obj}
-{$ENDIF CPU64}
+{$ENDIF CPUX64}
 
 // Core functions
 function zlibVersion;          external;
diff --git a/jcl/source/include/jcl.inc b/jcl/source/include/jcl.inc
index afd4c2497..a289b2b64 100644
--- a/jcl/source/include/jcl.inc
+++ b/jcl/source/include/jcl.inc
@@ -599,7 +599,11 @@ ALERT_jedi_inc_incompatible
 {$IFNDEF BZIP2_STATICLINK}
   {$IFNDEF BZIP2_LINKDLL}
     {$IFNDEF BZIP2_LINKONREQUEST}
-      {$DEFINE BZIP2_STATICLINK}
+      {$IFDEF CPUINTEL}
+        {$DEFINE BZIP2_STATICLINK}
+      {$ELSE}
+        {$DEFINE BZIP2_LINKONREQUEST}
+      {$ENDIF CPUINTEL}
     {$ENDIF ~BZIP2_LINKONREQUEST}
   {$ENDIF ~BZIP2_LINKDLL}
 {$ENDIF ~BZIP2_STATICLINK}
@@ -635,7 +639,11 @@ ALERT_jedi_inc_incompatible
   {$IFNDEF ZLIB_LINKDLL}
     {$IFNDEF ZLIB_LINKONREQUEST}
       {$IFNDEF ZLIB_RTL}
-        {$DEFINE ZLIB_STATICLINK}
+        {$IFDEF CPUINTEL}
+          {$DEFINE ZLIB_STATICLINK}
+        {$ELSE ~CPUINTEL}
+          {$DEFINE ZLIB_RTL}
+        {$ENDIF ~CPUINTEL}
       {$ENDIF ~ZLIB_RTL}
     {$ENDIF ~ZLIB_LINKONREQUEST}
   {$ENDIF ~ZLIB_LINKDLL}
diff --git a/jcl/source/prototypes/JclGraphUtils.pas b/jcl/source/prototypes/JclGraphUtils.pas
index c517888a3..2752a40a1 100644
--- a/jcl/source/prototypes/JclGraphUtils.pas
+++ b/jcl/source/prototypes/JclGraphUtils.pas
@@ -479,7 +479,7 @@ procedure _BlendLine(Src, Dst: PColor32; Count: Integer);
 {$ELSE ~DELPHI64_TEMPORARY}
 procedure _BlendLine(Src, Dst: PColor32; Count: Integer); assembler;
 asm
-  {$IFDEF CPU32}
+  {$IFDEF CPU386}
   // EAX <- Src
   // EDX <- Dst
   // ECX <- Count
@@ -558,10 +558,10 @@ procedure _BlendLine(Src, Dst: PColor32; Count: Integer); assembler;
         POP     EBX
 
 @4:     RET
-  {$ENDIF CPU32}
-  {$IFDEF CPU64}
+  {$ENDIF CPU386}
+  {$IFDEF CPUX64}
   TODO
-  {$ENDIF CPU64}
+  {$ENDIF CPUX64}
 end;
 {$ENDIF ~DELPHI64_TEMPORARY}
 
@@ -626,7 +626,7 @@ procedure EMMS;
 
 function M_CombineReg(X, Y, W: TColor32): TColor32; assembler;
 asm
-  {$IFDEF CPU32}
+  {$IFDEF CPU386}
   // EAX - Color X
   // EDX - Color Y
   // ECX - Weight of X [0..255]
@@ -648,8 +648,8 @@ function M_CombineReg(X, Y, W: TColor32): TColor32; assembler;
         db $0F, $71, $D1, $08      // PSRLW     MM1, 8
         db $0F, $67, $C8           // PACKUSWB  MM1, MM0
         db $0F, $7E, $C8           // MOVD      EAX, MM1
-  {$ENDIF CPU32}
-  {$IFDEF CPU64}
+  {$ENDIF CPU386}
+  {$IFDEF CPUX64}
         PXOR      MM0, MM0
         MOVD      MM1, EAX
         SHL       RCX, 3
@@ -666,7 +666,7 @@ function M_CombineReg(X, Y, W: TColor32): TColor32; assembler;
         PSRLW     MM1, 8
         PACKUSWB  MM1, MM0
         MOVD      EAX, MM1
-  {$ENDIF CPU64}
+  {$ENDIF CPUX64}
 end;
 
 procedure M_CombineMem(F: TColor32; var B: TColor32; W: TColor32);
@@ -676,7 +676,7 @@ procedure M_CombineMem(F: TColor32; var B: TColor32; W: TColor32);
 
 function M_BlendReg(F, B: TColor32): TColor32; assembler;
 asm
-  {$IFDEF CPU32}
+  {$IFDEF CPU386}
   // blend foreground color (F) to a background color (B),
   // using alpha channel value of F
   // EAX <- F
@@ -699,8 +699,8 @@ function M_BlendReg(F, B: TColor32): TColor32; assembler;
         db $0F, $71, $D2, $08      // PSRLW     MM2, 8
         db $0F, $67, $D3           // PACKUSWB  MM2, MM3
         db $0F, $7E, $D0           // MOVD      EAX, MM2
-  {$ENDIF CPU32}
-  {$IFDEF CPU64}
+  {$ENDIF CPU386}
+  {$IFDEF CPUX64}
         PXOR      MM3, MM3
         MOVD      MM0, EAX
         MOVD      MM2, EDX
@@ -718,7 +718,7 @@ function M_BlendReg(F, B: TColor32): TColor32; assembler;
         PSRLW     MM2, 8
         PACKUSWB  MM2, MM3
         MOVD      EAX, MM2
-  {$ENDIF CPU64}
+  {$ENDIF CPUX64}
 end;
 
 procedure M_BlendMem(F: TColor32; var B: TColor32);
@@ -728,7 +728,7 @@ procedure M_BlendMem(F: TColor32; var B: TColor32);
 
 function M_BlendRegEx(F, B, M: TColor32): TColor32; assembler;
 asm
-  {$IFDEF CPU32}
+  {$IFDEF CPU386}
   // blend foreground color (F) to a background color (B),
   // using alpha channel value of F
   // EAX <- F
@@ -761,8 +761,8 @@ function M_BlendRegEx(F, B, M: TColor32): TColor32; assembler;
 
 @1:     MOV       EAX, EDX
         POP       EBX
-  {$ENDIF CPU32}
-  {$IFDEF CPU64}
+  {$ENDIF CPU386}
+  {$IFDEF CPUX64}
         PUSH      RBX
         MOV       RBX, RAX
         SHR       RBX, 24
@@ -789,7 +789,7 @@ function M_BlendRegEx(F, B, M: TColor32): TColor32; assembler;
 
 @1:     MOV       RAX, RDX
         POP       RBX
-  {$ENDIF CPU64}
+  {$ENDIF CPUX64}
 end;
 
 procedure M_BlendMemEx(F: TColor32; var B: TColor32; M: TColor32);
@@ -805,7 +805,7 @@ procedure M_BlendLine(Src, Dst: PColor32; Count: Integer);
 {$ELSE ~DELPHI64_TEMPORARY}
 procedure M_BlendLine(Src, Dst: PColor32; Count: Integer); assembler;
 asm
-  {$IFDEF CPU32}
+  {$IFDEF CPU386}
   // EAX <- Src
   // EDX <- Dst
   // ECX <- Count
@@ -859,10 +859,10 @@ procedure M_BlendLine(Src, Dst: PColor32; Count: Integer); assembler;
         POP       ESI
 
 @4:     RET
-  {$ENDIF CPU32}
-  {$IFDEF CPU64}
+  {$ENDIF CPU386}
+  {$IFDEF CPUX64}
   TODO
-  {$ENDIF CPU64}
+  {$ENDIF CPUX64}
 end;
 {$ENDIF ~DELPHI64_TEMPORARY}
 
@@ -874,7 +874,7 @@ procedure M_BlendLineEx(Src, Dst: PColor32; Count: Integer; M: TColor32);
 {$ELSE ~DELPHI64_TEMPORARY}
 procedure M_BlendLineEx(Src, Dst: PColor32; Count: Integer; M: TColor32); assembler;
 asm
-  {$IFDEF CPU32}
+  {$IFDEF CPU386}
   // EAX <- Src
   // EDX <- Dst
   // ECX <- Count
@@ -932,10 +932,10 @@ procedure M_BlendLineEx(Src, Dst: PColor32; Count: Integer; M: TColor32); assemb
         POP       EDI
         POP       ESI
 @4:
-  {$ENDIF CPU32}
-  {$IFDEF CPU64}
+  {$ENDIF CPU386}
+  {$IFDEF CPUX64}
   TODO
-  {$ENDIF CPU64}
+  {$ENDIF CPUX64}
 end;
 {$ENDIF ~DELPHI64_TEMPORARY}
 
diff --git a/jcl/source/vcl/JclGraphUtils.pas b/jcl/source/vcl/JclGraphUtils.pas
index efd0e7460..71309d199 100644
--- a/jcl/source/vcl/JclGraphUtils.pas
+++ b/jcl/source/vcl/JclGraphUtils.pas
@@ -461,7 +461,7 @@ procedure _BlendMemEx(F: TColor32; var B: TColor32; M: TColor32);
 
 procedure _BlendLine(Src, Dst: PColor32; Count: Integer); assembler;
 asm
-  {$IFDEF CPU32}
+  {$IFDEF CPU386}
   // EAX <- Src
   // EDX <- Dst
   // ECX <- Count
@@ -540,8 +540,8 @@ procedure _BlendLine(Src, Dst: PColor32; Count: Integer); assembler;
         POP     EBX
 
 @4:     RET
-  {$ENDIF CPU32}
-  {$IFDEF CPU64}
+  {$ENDIF CPU386}
+  {$IFDEF CPUX64}
   // RCX <- Src      EAX
   // RDX <- Dst      EDX
   // R8  <- Count    ECX
@@ -613,7 +613,7 @@ procedure _BlendLine(Src, Dst: PColor32; Count: Integer); assembler;
 
 
 @4:     RET
-  {$ENDIF CPU64}
+  {$ENDIF CPUX64}
 end;
 
 procedure _BlendLineEx(Src, Dst: PColor32; Count: Integer; M: TColor32);
@@ -666,7 +666,7 @@ procedure FreeAlphaTable;
 function SSE2_CombineReg(X, Y, W: TColor32): TColor32; assembler;
 asm
   // Result := W * (X - Y) + Y
- {$IFDEF CPU32}
+ {$IFDEF CPU386}
   // EAX - Color X
   // EDX - Color Y
   // ECX - Weight of X [0..255]
@@ -687,8 +687,8 @@ function SSE2_CombineReg(X, Y, W: TColor32): TColor32; assembler;
         PSRLW     XMM1, 8
         PACKUSWB  XMM1, XMM0
         MOVD      EAX, XMM1
-  {$ENDIF CPU32}
-  {$IFDEF CPU64}
+  {$ENDIF CPU386}
+  {$IFDEF CPUX64}
   // RCX - Color X
   // RDX - Color Y
   // R8  - Weight of X [0..255]
@@ -709,7 +709,7 @@ function SSE2_CombineReg(X, Y, W: TColor32): TColor32; assembler;
         PSRLW     XMM1, 8
         PACKUSWB  XMM1, XMM0
         MOVD      EAX, XMM1
-  {$ENDIF CPU64}
+  {$ENDIF CPUX64}
 end;
 
 procedure SSE2_CombineMem(F: TColor32; var B: TColor32; W: TColor32);
@@ -722,7 +722,7 @@ function SSE2_BlendReg(F, B: TColor32): TColor32; assembler;
   // blend foreground color (F) to a background color (B),
   // using alpha channel value of F
   // Result := Fa * (Frgb - Brgb) + Brgb
-  {$IFDEF CPU32}
+  {$IFDEF CPU386}
   // EAX <- F
   // EDX <- B
         PXOR      XMM3, XMM3
@@ -746,8 +746,8 @@ function SSE2_BlendReg(F, B: TColor32): TColor32; assembler;
         PSRLW     XMM2, 8
         PACKUSWB  XMM2, XMM3
         MOVD      EAX, XMM2
-  {$ENDIF CPU32}
-  {$IFDEF CPU64}
+  {$ENDIF CPU386}
+  {$IFDEF CPUX64}
   // RCX <- F
   // RDX <- B
         PXOR      XMM3, XMM3
@@ -771,7 +771,7 @@ function SSE2_BlendReg(F, B: TColor32): TColor32; assembler;
         PSRLW     XMM2, 8
         PACKUSWB  XMM2, XMM3
         MOVD      EAX, XMM2
-  {$ENDIF CPU64}
+  {$ENDIF CPUX64}
 end;
 
 procedure SSE2_BlendMem(F: TColor32; var B: TColor32);
@@ -784,7 +784,7 @@ function SSE2_BlendRegEx(F, B, M: TColor32): TColor32; assembler;
   // blend foreground color (F) to a background color (B),
   // using alpha channel value of F
   // Result := M * Fa * (Frgb - Brgb) + Brgb
-  {$IFDEF CPU32}
+  {$IFDEF CPU386}
   // EAX <- F
   // EDX <- B
   // ECX <- M
@@ -816,8 +816,8 @@ function SSE2_BlendRegEx(F, B, M: TColor32): TColor32; assembler;
         RET
 @1:     MOV       EAX, EDX
         POP       EBX
-  {$ENDIF CPU32}
-  {$IFDEF CPU64}
+  {$ENDIF CPU386}
+  {$IFDEF CPUX64}
   // RCX <- F
   // EDX <- B
   // R8 <- M
@@ -846,7 +846,7 @@ function SSE2_BlendRegEx(F, B, M: TColor32): TColor32; assembler;
         RET
 
 @1:     MOV       RAX, RDX
-  {$ENDIF CPU64}
+  {$ENDIF CPUX64}
 end;
 
 procedure SSE2_BlendMemEx(F: TColor32; var B: TColor32; M: TColor32);
@@ -856,7 +856,7 @@ procedure SSE2_BlendMemEx(F: TColor32; var B: TColor32; M: TColor32);
 
 procedure SSE2_BlendLine(Src, Dst: PColor32; Count: Integer); assembler;
 asm
-  {$IFDEF CPU32}
+  {$IFDEF CPU386}
   // EAX <- Src
   // EDX <- Dst
   // ECX <- Count
@@ -914,8 +914,8 @@ procedure SSE2_BlendLine(Src, Dst: PColor32; Count: Integer); assembler;
         POP       ESI
 
 @4:     RET
-  {$ENDIF CPU32}
-  {$IFDEF CPU64}
+  {$ENDIF CPU386}
+  {$IFDEF CPUX64}
   // RCX <- Src
   // RDX <- Dst
   // R8  <- Count
@@ -967,12 +967,12 @@ procedure SSE2_BlendLine(Src, Dst: PColor32; Count: Integer); assembler;
         JNZ       @1
 
 @4:     RET
-  {$ENDIF CPU64}
+  {$ENDIF CPUX64}
 end;
 
 procedure SSE2_BlendLineEx(Src, Dst: PColor32; Count: Integer; M: TColor32); assembler;
 asm
-  {$IFDEF CPU32}
+  {$IFDEF CPU386}
   // EAX <- Src
   // EDX <- Dst
   // ECX <- Count
@@ -1030,8 +1030,8 @@ procedure SSE2_BlendLineEx(Src, Dst: PColor32; Count: Integer; M: TColor32); ass
         POP       EDI
         POP       ESI
 @4:
-  {$ENDIF CPU32}
-  {$IFDEF CPU64}
+  {$ENDIF CPU386}
+  {$IFDEF CPUX64}
   // RCX <- Src
   // RDX <- Dst
   // R8  <- Count
@@ -1082,7 +1082,7 @@ procedure SSE2_BlendLineEx(Src, Dst: PColor32; Count: Integer; M: TColor32); ass
         DEC       R8
         JNZ       @1
 @4:
-  {$ENDIF CPU64}
+  {$ENDIF CPUX64}
 end;
 
 { MMX Detection and linking }
diff --git a/jcl/source/windows/JclNTFS.pas b/jcl/source/windows/JclNTFS.pas
index fe9a4d439..31b4ecff1 100644
--- a/jcl/source/windows/JclNTFS.pas
+++ b/jcl/source/windows/JclNTFS.pas
@@ -619,14 +619,14 @@   EJclInvalidArgument = class(EJclError);
 
 function CallersCallerAddress: Pointer;
 asm
-        {$IFDEF CPU32}
+        {$IFDEF CPU386}
         MOV     EAX, [EBP]
         MOV     EAX, TStackFrame([EAX]).CallerAddress
-        {$ENDIF CPU32}
-        {$IFDEF CPU64}
+        {$ENDIF CPU386}
+        {$IFDEF CPUX64}
         MOV     RAX, [RBP]
         MOV     RAX, TStackFrame([RAX]).CallerAddress
-        {$ENDIF CPU64}
+        {$ENDIF CPUX64}
 end;
 
 {$STACKFRAMES ON}
diff --git a/jcl/source/windows/JclRegistry.pas b/jcl/source/windows/JclRegistry.pas
index 6d8dca3ea..6337118b5 100644
--- a/jcl/source/windows/JclRegistry.pas
+++ b/jcl/source/windows/JclRegistry.pas
@@ -62,7 +62,7 @@ interface
   JclBase, JclStrings;
 
 type
-  DelphiHKEY = {$IFDEF CPUX64}type Winapi.Windows.HKEY{$ELSE}Longword{$ENDIF CPUX64};
+  DelphiHKEY = {$IFDEF CPU64}type Winapi.Windows.HKEY{$ELSE}Longword{$ENDIF CPU64};
   {$HPPEMIT '// BCB users must typecast the HKEY values to DelphiHKEY or use the HK-values below.'}
 
   TExecKind = (ekMachineRun, ekMachineRunOnce, ekUserRun, ekUserRunOnce,
diff --git a/qa/automated/dunit/JclTests.dpr b/qa/automated/dunit/JclTests.dpr
index 4f1f69f86..d8505ae3c 100644
--- a/qa/automated/dunit/JclTests.dpr
+++ b/qa/automated/dunit/JclTests.dpr
@@ -27,7 +27,8 @@ uses
   TestJclContainer in 'units\TestJclContainer.pas',
   TestJclNotify in 'units\TestJclNotify.pas',
   TestJclExprEval in 'units\TestJclExprEval.pas',
-  TestJclDebug in 'units\TestJclDebug.pas';
+  TestJclDebug in 'units\TestJclDebug.pas',
+  TestJclLogic in 'units\TestJclLogic.pas';
 
 
 {$R *.res}
diff --git a/qa/automated/dunit/units/TestJcl8087.pas b/qa/automated/dunit/units/TestJcl8087.pas
index 897e3b33d..6f3893aec 100644
--- a/qa/automated/dunit/units/TestJcl8087.pas
+++ b/qa/automated/dunit/units/TestJcl8087.pas
@@ -18,7 +18,10 @@
 
 unit TestJcl8087;
 
+{$I jcl.inc}
+
 interface
+{$IFDEF CPUINTEL}
 uses
   TestFramework,
   SysUtils,
@@ -39,9 +42,11 @@   TJcl8087Test = class (TTestCase)
     procedure Rounding;
     procedure Exceptions;
   end;
+{$ENDIF CPUINTEL}
 
 implementation
 
+{$IFDEF CPUINTEL}
 //==================================================================================================
 // TJcl8087Test
 //==================================================================================================
@@ -208,14 +213,5 @@ procedure TJcl8087Test.Exceptions;
 initialization
   RegisterTest('JCL8087', TJcl8087Test.Suite);
 
-
+{$ENDIF CPUINTEL}
 end.
-
-
-
-
-
-
-
-
-
diff --git a/qa/automated/dunit/units/TestJclDebug.pas b/qa/automated/dunit/units/TestJclDebug.pas
index 8435ebb80..a8fa02c5d 100644
--- a/qa/automated/dunit/units/TestJclDebug.pas
+++ b/qa/automated/dunit/units/TestJclDebug.pas
@@ -18,8 +18,10 @@
 
 unit TestJclDebug;
 
-interface
+{$I jcl.inc}
 
+interface
+{$IFDEF CPUINTEL}
 uses
   Windows, SysUtils, Classes, TestFramework, JclDebug;
 
@@ -28,9 +30,11 @@   TJclMapScannerTest = class(TTestCase)
   published
     procedure ScanCPP4096;
   end;
+{$ENDIF CPUINTEL}
 
 implementation
 
+{$IFDEF CPUINTEL}
 {$R TestJclDebug.res}
 
 //==================================================================================================
@@ -83,4 +87,5 @@ procedure TJclMapScannerTest.ScanCPP4096;
 initialization
   RegisterTest('JclDebug', TJclMapScannerTest.Suite);
 
+{$ENDIF CPUINTEL}
 end.
diff --git a/qa/automated/dunit/units/TestJclLogic.pas b/qa/automated/dunit/units/TestJclLogic.pas
new file mode 100644
index 000000000..bebfde81a
--- /dev/null
+++ b/qa/automated/dunit/units/TestJclLogic.pas
@@ -0,0 +1,367 @@
+{**************************************************************************************************}
+{                                                                                                  }
+{ Project JEDI Code Library (JCL)                                                                  }
+{ DUnit Test                                                                                       }
+{                                                                                                  }
+{ The contents of this file are subject to the Mozilla Public License Version 1.1 (the "License"); }
+{ you may not use this file except in compliance with the License. You may obtain a copy of the    }
+{ License at http://www.mozilla.org/MPL/                                                           }
+{                                                                                                  }
+{ Software distributed under the License is distributed on an "AS IS" basis, WITHOUT WARRANTY OF   }
+{ ANY KIND, either express or implied. See the License for the specific language governing rights  }
+{ and limitations under the License.                                                               }
+{                                                                                                  }
+{**************************************************************************************************}
+
+unit TestJclLogic;
+
+interface
+uses
+  TestFramework,
+  JclLogic;
+
+type
+  TJclLogicClearBitSetBitTest = class(TTestCase)
+  published
+	procedure _Byte;
+	procedure _Cardinal;
+	procedure _Integer;
+	procedure _Shortint;
+	procedure _Smallint;
+	procedure _Word;
+  end;
+
+  TJclLogicMiscTest = class(TTestCase)
+  published
+	procedure _BitsHighest;
+	procedure _BitsLowest;
+	procedure _ReverseBytes;
+  end;
+
+  TJclLogicRotateTest = class(TTestCase)
+  published
+	procedure _LRotByte;
+	procedure _LRotInteger;
+	procedure _LRotInt64;
+	procedure _LRotWord;
+	procedure _RRotByte;
+	procedure _RRotInteger;
+	procedure _RRotWord;
+	procedure _SarShortint;
+	procedure _SarSmallint;
+	procedure _SarInteger;
+  end;
+
+implementation
+
+//==================================================================================================
+// ClearBit/SetBit
+//==================================================================================================
+
+procedure TJclLogicClearBitSetBitTest._Byte;
+// 0..255
+begin
+  // ClearBit
+  CheckEquals(0, ClearBit(Byte(0), 1));
+  CheckEquals(0, ClearBit(Byte(1), 0));
+  CheckEquals(2, ClearBit(Byte(6), 2));
+  CheckEquals(128, ClearBit(Byte(192), 6));
+  CheckEquals(127, ClearBit(Byte(255), 7));
+  // SetBit
+  CheckEquals(1, SetBit(Byte(0), 0));
+  CheckEquals(2, SetBit(Byte(0), 1));
+  CheckEquals(128, SetBit(Byte(0), 7));
+  CheckEquals(192, SetBit(Byte(128), 6));
+  CheckEquals($FF, SetBit(Byte($FF), 5));
+  // Mod by bit length
+  CheckEquals($FB, ClearBit(Byte($FF), 10));
+  CheckEquals(4, SetBit(Byte(0), 10));
+end;
+
+//--------------------------------------------------------------------------------------------------
+
+procedure TJclLogicClearBitSetBitTest._Cardinal;
+begin
+  // ClearBit
+  CheckEquals(0, ClearBit(Cardinal(0), 1));
+  CheckEquals(0, ClearBit(Cardinal(1), 0));
+  CheckEquals(2, ClearBit(Cardinal(6), 2));
+  CheckEquals($1010, ClearBit(Cardinal($1011), 0));
+  CheckEquals($FEFF, ClearBit(Cardinal($FFFF), 8));
+  CheckEquals($10101010, ClearBit(Cardinal($10111010), 16));
+  CheckEquals($7FFFFFFF, ClearBit(Cardinal($FFFFFFFF), 31));
+  // SetBit
+  CheckEquals(1, SetBit(Cardinal(0), 0));
+  CheckEquals(2, SetBit(Cardinal(0), 1));
+  CheckEquals($C0, SetBit(Cardinal($80), 6));
+  CheckEquals($100, SetBit(Cardinal(0), 8));
+  CheckEquals($1101, SetBit(Cardinal($1001), 8));
+  CheckEquals($FFFF, SetBit(Cardinal($FFFF), 5));
+  CheckEquals($10111010, SetBit(Cardinal($10101010), 16));
+  CheckEquals($FFFFFFFF, SetBit(Cardinal($7FFFFFFF), 31));
+  // Mod by bit length
+  CheckEquals($FFFFFFFB, ClearBit(Cardinal($FFFFFFFF), 34));
+  CheckEquals(4, SetBit(Cardinal(0), 34));
+end;
+
+//--------------------------------------------------------------------------------------------------
+
+procedure TJclLogicClearBitSetBitTest._Integer;
+begin
+  // ClearBit
+  CheckEquals(0, ClearBit(Integer(0), 1));
+  CheckEquals(0, ClearBit(Integer(1), 0));
+  CheckEquals(2, ClearBit(Integer(6), 2));
+  CheckEquals($1010, ClearBit(Integer($1011), 0));
+  CheckEquals(0, ClearBit(Low(Integer), 31));
+  CheckEquals(High(Integer), ClearBit(Integer(-1), 31));
+  // SetBit
+  CheckEquals(1, SetBit(Integer(0), 0));
+  CheckEquals(2, SetBit(Integer(0), 1));
+  CheckEquals(96, SetBit(Integer(32), 6));
+  CheckEquals(Low(Integer), SetBit(Integer(0), 31));
+  CheckEquals(-1073741824, SetBit(Low(Integer), 30));
+  CheckEquals(-1, SetBit(High(Integer), 31));
+  CheckEquals(-1, SetBit(Integer(-1), 5));
+  // Mod by bit length
+  CheckEquals(-5, ClearBit(Integer(-1), 34));
+  CheckEquals(4, SetBit(Integer(0), 34));
+end;
+
+//--------------------------------------------------------------------------------------------------
+
+procedure TJclLogicClearBitSetBitTest._Shortint;
+// -128..127
+begin
+  // ClearBit
+  CheckEquals(0, ClearBit(Shortint(0), 1));
+  CheckEquals(0, ClearBit(Shortint(1), 0));
+  CheckEquals(2, ClearBit(Shortint(6), 2));
+  CheckEquals(0, ClearBit(Shortint(-128), 7));
+  CheckEquals(127, ClearBit(Shortint(-1), 7));
+  // SetBit
+  CheckEquals(1, SetBit(Shortint(0), 0));
+  CheckEquals(2, SetBit(Shortint(0), 1));
+  CheckEquals(96, SetBit(Shortint(32), 6));
+  CheckEquals(-128, SetBit(Shortint(0), 7));
+  CheckEquals(-96, SetBit(Shortint(-128), 5));
+  CheckEquals(-1, SetBit(Shortint(127), 7));
+  CheckEquals(-1, SetBit(Shortint(-1), 5));
+  // Mod by bit length
+  CheckEquals(-5, ClearBit(Shortint(-1), 10));
+  CheckEquals(4, SetBit(Shortint(0), 10));
+end;
+
+//--------------------------------------------------------------------------------------------------
+
+procedure TJclLogicClearBitSetBitTest._Smallint;
+// -32768..32767
+begin
+  // ClearBit
+  CheckEquals(0, ClearBit(Smallint(0), 1));
+  CheckEquals(0, ClearBit(Smallint(1), 0));
+  CheckEquals(2, ClearBit(Smallint(6), 2));
+  CheckEquals($1010, ClearBit(Smallint($1011), 0));
+  CheckEquals(0, ClearBit(Smallint(-32768), 15));
+  CheckEquals(32767, ClearBit(Smallint(-1), 15));
+  // SetBit
+  CheckEquals(1, SetBit(Smallint(0), 0));
+  CheckEquals(2, SetBit(Smallint(0), 1));
+  CheckEquals(96, SetBit(Smallint(32), 6));
+  CheckEquals(-32768, SetBit(Smallint(0), 15));
+  CheckEquals(-16384, SetBit(Smallint(-32768), 14));
+  CheckEquals(-1, SetBit(Smallint(32767), 15));
+  CheckEquals(-1, SetBit(Smallint(-1), 5));
+  // Mod by bit length
+  CheckEquals(-5, ClearBit(Smallint(-1), 18));
+  CheckEquals(4, SetBit(Smallint(0), 18));
+end;
+
+//--------------------------------------------------------------------------------------------------
+
+procedure TJclLogicClearBitSetBitTest._Word;
+// 0..65535
+begin
+  // ClearBit
+  CheckEquals(0, ClearBit(Word(0), 1));
+  CheckEquals(0, ClearBit(Word(1), 0));
+  CheckEquals(2, ClearBit(Word(6), 2));
+  CheckEquals($1010, ClearBit(Word($1011), 0));
+  CheckEquals($FEFF, ClearBit(Word($FFFF), 8));
+  // SetBit
+  CheckEquals(1, SetBit(Word(0), 0));
+  CheckEquals(2, SetBit(Word(0), 1));
+  CheckEquals($C0, SetBit(Word($80), 6));
+  CheckEquals($100, SetBit(Word(0), 8));
+  CheckEquals($1101, SetBit(Word($1001), 8));
+  CheckEquals($FFFF, SetBit(Word($FFFF), 5));
+  // Mod by bit length
+  CheckEquals($FFFB, ClearBit(Word($FFFF), 18));
+  CheckEquals(4, SetBit(Word(0), 18));
+end;
+
+
+//==================================================================================================
+// Misc Bit Manipulation
+//==================================================================================================
+
+procedure TJclLogicMiscTest._BitsHighest;
+begin
+  CheckEquals(-1, BitsHighest(Cardinal(0)));
+  CheckEquals(0, BitsHighest(Cardinal(1)));
+  CheckEquals(16, BitsHighest(Cardinal($1FFFF)));
+  CheckEquals(31, BitsHighest(High(Cardinal)));
+end;
+
+//--------------------------------------------------------------------------------------------------
+
+procedure TJclLogicMiscTest._BitsLowest;
+begin
+  CheckEquals(-1, BitsLowest(Cardinal(0)));
+  CheckEquals(0, BitsLowest(Cardinal(1)));
+  CheckEquals(16, BitsLowest(Cardinal($FFF10000)));
+  CheckEquals(31, BitsLowest(Cardinal($80000000)));
+end;
+
+//--------------------------------------------------------------------------------------------------
+
+procedure TJclLogicMiscTest._ReverseBytes;
+begin
+  CheckEquals(Smallint($0001), ReverseBytes(Smallint($0100)));
+  CheckEquals(Smallint($CDAB), ReverseBytes(Smallint($ABCD)));
+  CheckEquals(Smallint($00FF), ReverseBytes(Smallint($FF00)));
+  CheckEquals(Smallint($FF00), ReverseBytes(Smallint($00FF)));
+end;
+
+
+//==================================================================================================
+// Bit Rotation
+//==================================================================================================
+
+procedure TJclLogicRotateTest._LRotByte;
+begin
+  CheckEquals(0, LRot(Byte(0), 1));
+  CheckEquals(2, LRot(Byte(1), 1));
+  CheckEquals(2, LRot(Byte($80), 2));
+  CheckEquals($F0, LRot(Byte($0F), 4));
+  CheckEquals($0F, LRot(Byte($F0), 4));
+  CheckEquals(2, LRot(Byte($80), 10));
+end;
+
+//--------------------------------------------------------------------------------------------------
+
+procedure TJclLogicRotateTest._LRotInt64;
+begin
+  CheckEquals(0, LRot(Int64(0), 1));
+  CheckEquals(2, LRot(Int64(1), 1));
+  CheckEquals(2, LRot(Low(Int64), 2));
+  CheckEquals(Low(Int64), LRot(Int64($80000000), 32));
+  CheckEquals($80000000, LRot(Low(Int64), 32));
+  CheckEquals(2, LRot(Int64(1), 65));
+end;
+
+//--------------------------------------------------------------------------------------------------
+
+procedure TJclLogicRotateTest._LRotInteger;
+begin
+  CheckEquals(0, LRot(Integer(0), 1));
+  CheckEquals(2, LRot(Integer(1), 1));
+  CheckEquals(2, LRot(Low(Integer), 2));
+  CheckEquals(Low(Integer), LRot(Integer($8000), 16));
+  CheckEquals($8000, LRot(Low(Integer), 16));
+  CheckEquals(2, LRot(Integer(1), 33));
+end;
+
+//--------------------------------------------------------------------------------------------------
+
+procedure TJclLogicRotateTest._LRotWord;
+begin
+  CheckEquals(0, LRot(Word(0), 1));
+  CheckEquals(2, LRot(Word(1), 1));
+  CheckEquals(2, LRot(Word($8000), 2));
+  CheckEquals($8000, LRot(Word($80), 8));
+  CheckEquals($80, LRot(Word($8000), 8));
+  CheckEquals(2, LRot(Word(1), 17));
+end;
+
+//--------------------------------------------------------------------------------------------------
+
+procedure TJclLogicRotateTest._RRotByte;
+begin
+  CheckEquals(0, RRot(Byte(0), 1));
+  CheckEquals(1, RRot(Byte(2), 1));
+  CheckEquals($80, RRot(Byte(2), 2));
+  CheckEquals($0F, RRot(Byte($F0), 4));
+  CheckEquals($F0, RRot(Byte($0F), 4));
+  CheckEquals($80, RRot(Byte(2), 10));
+end;
+
+//--------------------------------------------------------------------------------------------------
+
+procedure TJclLogicRotateTest._RRotInteger;
+begin
+  CheckEquals(0, RRot(Integer(0), 1));
+  CheckEquals(1, RRot(Integer(2), 1));
+  CheckEquals(Low(Integer), RRot(Integer(2), 2));
+  CheckEquals(Integer($8000), RRot(Low(Integer), 16));
+  CheckEquals(Low(Integer), RRot(Integer($8000), 16));
+  CheckEquals(1, RRot(Integer(2), 33));
+end;
+
+//--------------------------------------------------------------------------------------------------
+
+procedure TJclLogicRotateTest._RRotWord;
+begin
+  CheckEquals(0, RRot(Word(0), 1));
+  CheckEquals(1, RRot(Word(2), 1));
+  CheckEquals($8000, RRot(Word(2), 2));
+  CheckEquals($80, RRot(Word($8000), 8));
+  CheckEquals($8000, RRot(Word($80), 8));
+  CheckEquals(1, RRot(Word(2), 17));
+end;
+
+//--------------------------------------------------------------------------------------------------
+
+procedure TJclLogicRotateTest._SarInteger;
+const
+  arr: array[0..10] of Integer = (Low(Integer), Low(Integer) + 1, -5, -2, -1, 0, 1, 2, 5, High(Integer) - 1, High(Integer));
+var
+  i, shift: Byte;
+begin
+  for i := Low(arr) to High(arr) do
+	for shift := 0 to 11 do
+	  CheckEquals(Integer(Int64(arr[i]) shr shift), Sar(arr[i], shift));
+end;
+
+//--------------------------------------------------------------------------------------------------
+
+procedure TJclLogicRotateTest._SarShortint;
+const
+  arr: array[0..9] of Shortint = (-128, -127, -5, -2, -1, 0, 1, 2, 5, 127);
+var
+  i, shift: Byte;
+begin
+  for i := Low(arr) to High(arr) do
+	for shift := 0 to 11 do
+	  CheckEquals(Shortint(Smallint(arr[i]) shr shift), Sar(arr[i], shift));
+end;
+
+//--------------------------------------------------------------------------------------------------
+
+procedure TJclLogicRotateTest._SarSmallint;
+const
+  arr: array[0..9] of Smallint = (-32768, -32767, -5, -2, -1, 0, 1, 2, 5, 32767);
+var
+  i, shift: Byte;
+begin
+  for i := Low(arr) to High(arr) do
+	for shift := 0 to 11 do
+	  CheckEquals(Smallint(Integer(arr[i]) shr shift), Sar(arr[i], shift));
+end;
+
+initialization
+  RegisterTest('JCLLogic', TJclLogicClearBitSetBitTest.Suite);
+  RegisterTest('JCLLogic', TJclLogicMiscTest.Suite);
+  RegisterTest('JCLLogic', TJclLogicRotateTest.Suite);
+
+end.
diff --git a/qa/automated/dunit/units/TestJclMath.pas b/qa/automated/dunit/units/TestJclMath.pas
index 8295b10a9..4c45e2a72 100644
--- a/qa/automated/dunit/units/TestJclMath.pas
+++ b/qa/automated/dunit/units/TestJclMath.pas
@@ -140,6 +140,7 @@   TMathPrimeTest = class(TTestCase)
     procedure _IsRelativePrime;
   end;
 
+{$IFDEF CPU32}
 type
   TMathInfNanSupportTest = class(TTestCase)
   private
@@ -154,6 +155,7 @@   TMathInfNanSupportTest = class(TTestCase)
      procedure _MakeQuietNaN;
      procedure _GetNaNTag;
   end;
+{$ENDIF CPU32}
 
 type
   TSetCrack = class(TJclASet);
@@ -1131,7 +1133,7 @@ procedure TMathExponentialTest._Power;
     Base := Random(10);
     Exponent := Random(10);
 
-    CheckEquals(Math.Power(Base, Exponent),JclMath.Power(Base, Exponent), PrecisionTolerance);
+    CheckEquals(Math.Power(Base, Exponent),JclMath.Power(Base, Exponent), PrecisionTolerance * 10);
   end;
 
 end;
@@ -1319,7 +1321,7 @@ procedure TMathPrimeTest._IsRelativePrime;
 //==================================================================================================
 // NaN and Inf support
 //==================================================================================================
-
+{$IFDEF CPU32}
 procedure TMathInfNanSupportTest._IsInfinite;
 begin
   s := Infinity;
@@ -1462,7 +1464,7 @@ procedure TMathInfNanSupportTest._GetNaNTag;
     CheckEquals(i, GetNaNTag(e));
   end;
 end;
-
+{$ENDIF CPU32}
 //--------------------------------------------------------------------------------------------------
 
 { TMathHexConversionTest }
@@ -1624,5 +1626,7 @@ initialization
   RegisterTest('JCLMath', TMathExponentialTest.Suite);
   RegisterTest('JCLMath', TMathFlatSetTest.Suite);
   RegisterTest('JCLMath', TMathPrimeTest.Suite);
+  {$IFDEF CPU32}
   RegisterTest('JCLMath', TMathInfNanSupportTest.Suite);
+  {$ENDIF}
 end.
diff --git a/qa/automated/dunit/units/TestJclStrings.pas b/qa/automated/dunit/units/TestJclStrings.pas
index c33c69d99..cc1176413 100644
--- a/qa/automated/dunit/units/TestJclStrings.pas
+++ b/qa/automated/dunit/units/TestJclStrings.pas
@@ -30,14 +30,15 @@ interface
   {$ENDIF}
   Classes,
   SysUtils,
-  JclSysUtils,
-  JclStrings;
+  JclBase, JclSysUtils,
+  JclAnsiStrings, JclStrings;
 
 { TJclStringCharacterTestRoutines }
 
 type
   TJclStringCharacterTestRoutines = class(TTestCase)
   private
+    function ToChar(C: AnsiChar): Char;
   published
     procedure _CharEqualNoCase;
     procedure _CharIsAlpha;
@@ -186,6 +187,11 @@   TJclStringTabSet = class(TTestCase)
   { TJclStringManagment }
 
   TAnsiStringListTest = class (TTestCase)
+  {$IFDEF UNICODE}
+  protected
+    procedure CheckEquals(const expected: string; const actual: AnsiString; msg: string = ''); overload;
+    procedure CheckEquals(const expected: AnsiString; const actual: string; msg: string = ''); overload;
+  {$ENDIF UNICODE}
   published
     procedure _SetCommaTextCount;
     procedure _GetCommaTextCount;
@@ -210,13 +216,13 @@ implementation
 uses
   LibC;
 {$ENDIF LINUX}
-{$IFDEF WIN32}
+{$IFDEF MSWINDOWS}
 const
-  LibC = 'msvcrt40.dll';
+  LibC = {$IFDEF CPUINTEL}'msvcrt.dll'{$ELSE}'ucrtbase.dll'{$ENDIF ~CPUINTEL};
 
 function isalnum(C: Integer): LongBool; cdecl; external LibC;
 function isalpha(C: Integer): LongBool; cdecl; external LibC;
-{$ENDIF WIN32}
+{$ENDIF MSWINDOWS}
 
 //-----------------------------------------------------------------------------------------------
 // Generators
@@ -882,7 +888,11 @@ procedure TJclStringTransformation._StrQuote;
 
 function RemoveValidator(const C: Char): Boolean;
 begin
+  {$IFDEF UNICODE}
+  Result := CharInSet(C, removeset);
+  {$ELSE ~UNICODE}
   Result := C in removeset;
+  {$ENDIF ~UNICODE}
 end;
 
 procedure TJclStringTransformation._StrRemoveChars;
@@ -908,7 +918,7 @@ procedure TJclStringTransformation._StrRemoveChars;
 
     for t := 1 to Length(sn) do
     begin
-      if not (sn[t] in removeset) then
+      if not RemoveValidator(sn[t]) then
         removeset := removeset + [Char(sn[t])];
 
       v := Pos(sn[t], s3);
@@ -931,7 +941,11 @@ procedure TJclStringTransformation._StrRemoveChars;
 
 function KeepValidator(const C: Char): Boolean;
 begin
+  {$IFDEF UNICODE}
+  Result := CharInSet(C, keepset);
+  {$ELSE ~UNICODE}
   Result := C in keepset;
+  {$ENDIF ~UNICODE}
 end;
 
 procedure TJclStringTransformation._StrKeepChars;
@@ -958,13 +972,13 @@ procedure TJclStringTransformation._StrKeepChars;
 
     for t := 1 to length(sn) do
     begin
-      if not (sn[t] in keepset) then
+      if not KeepValidator(sn[t]) then
         keepset := keepset + [Char(sn[t])];
     end;
 
     for t := 1 to length(s) do
     begin
-      if s[t] in keepset then
+      if KeepValidator(s[t]) then
         s3 := s3 + s[t];
     end;
 
@@ -1170,19 +1184,20 @@ procedure TJclStringTransformation._StrStripNonNumberChars;
 
 procedure TJclStringTransformation._StrToHex;
 var
-  s, sn: string;
+  s: AnsiString;
+  sn: string;
 
 begin
   CheckEquals(StrToHex(''),'','StrToHex');
 
   SN := '262A32543B';
   SetLength(S,20);
-  HexToBin(PChar(SN),PChar(S),20);
-  CheckEquals(StrToHex(SN),Copy(S,1,Length(SN) div 2),'StrToHex');
+  HexToBin(PChar(SN),PAnsiChar(S),20);
+  CheckEquals(StrToHex(SN),string(Copy(S,1,Length(SN) div 2)),'StrToHex');
 
   SN := 'FF2A2B2C2D1A2F';
-  HexToBin(PChar(SN),PChar(S),20);
-  CheckEquals(StrToHex(SN),Copy(S,1,Length(SN) div 2),'StrToHex');
+  HexToBin(PChar(SN),PAnsiChar(S),20);
+  CheckEquals(StrToHex(SN),string(Copy(S,1,Length(SN) div 2)),'StrToHex');
 end;
 
 //--------------------------------------------------------------------------------------------------
@@ -1844,27 +1859,38 @@ procedure TJclStringSearchandReplace._StrSearch;
 
 //--------------------------------------------------------------------------------------------------
 
+function TJclStringCharacterTestRoutines.ToChar(C: AnsiChar): Char;
+begin
+  {$IFDEF UNICODE}
+  Result := string(AnsiString(C))[1] // Encoding conversion instead of flat cast
+  {$ELSE ~UNICODE}
+  Result := C
+  {$ENDIF ~UNICODE}
+end;
+
+//--------------------------------------------------------------------------------------------------
+
 procedure TJclStringCharacterTestRoutines._CharEqualNoCase;
 var
-  c1, c2: char;
+  c1, c2: AnsiChar;
 
 begin
   for c1 := #0 to #255 do
   for c2 := #0 to #255 do
-    Check(CharEqualNoCase(c1,c2) = (AnsiUpperCase(C1) = AnsiUpperCase(C2)),Format('CharEqualNoCase: C1: %s C2: %s',[c1,c2]));
+    Check(CharEqualNoCase(ToChar(c1),ToChar(c2)) = (AnsiUpperCase(ToChar(C1)) = AnsiUpperCase(ToChar(C2))),Format('CharEqualNoCase: C1: %s C2: %s',[c1,c2]));
 end;
 
 //--------------------------------------------------------------------------------------------------
 
 procedure TJclStringCharacterTestRoutines._CharIsAlpha;
 var
-  C: char;
+  C: AnsiChar;
 begin
   for C := #0 to #255 do
     CheckEquals(
       isalpha(Ord(C)) or (C in [#131, #138, #140, #142, #154, #156, #158, #159, #170, #181, #186, #192 .. #214,
                                 #216 .. #246, #248 .. #255]),
-      CharIsAlpha(C),
+      CharIsAlpha(ToChar(C)),
       'CharIsAlpha #' + IntToStr(Ord(C)));
 end;
 
@@ -1872,13 +1898,13 @@ procedure TJclStringCharacterTestRoutines._CharIsAlpha;
 
 procedure TJclStringCharacterTestRoutines._CharIsAlphaNum;
 var
-  C: char;
+  C: AnsiChar;
 begin
   for C := #0 to #255 do
     CheckEquals(
       isalnum(Ord(C)) or (C in [#131, #138, #140, #142, #154, #156, #158, #159, #170, #178, #179, #181, #185, #186,
                                 #192 .. #214, #216 .. #246, #248 .. #255]),
-      CharIsAlphaNum(C) ,
+      CharIsAlphaNum(ToChar(C)) ,
       'CharIsAlphaNum #' + IntToStr(Ord(C)));
 end;
 
@@ -1886,13 +1912,13 @@ procedure TJclStringCharacterTestRoutines._CharIsAlphaNum;
 
 procedure TJclStringCharacterTestRoutines._CharIsBlank;
 var
-  c1: char;
+  c1: AnsiChar;
 
 begin
   for c1 := #0 to #255 do
     CheckEquals(
       (c1 in [#9, ' ', #160]),
-      CharIsBlank(c1),
+      CharIsBlank(ToChar(c1)),
       'CharIsBlank #' + IntToStr(Ord(c1)));
 end;
 
@@ -1900,13 +1926,13 @@ procedure TJclStringCharacterTestRoutines._CharIsBlank;
 
 procedure TJclStringCharacterTestRoutines._CharIsControl;
 var
-  c1: char;
+  c1: AnsiChar;
 
 begin
   for c1 := #0 to #255 do
     CheckEquals(
-      (c1 in [#0 .. #31, #127, #129, #141, #143, #144, #157]),
-      CharIsControl(c1),
+      (c1 in [#0 .. #31, #127, #129, #141, #143, #144, #157, #173]),
+      CharIsControl(ToChar(c1)),
       'CharIsControl #' + IntToStr(Ord(c1)));
 end;
 
@@ -1914,24 +1940,24 @@ procedure TJclStringCharacterTestRoutines._CharIsControl;
 
 procedure TJclStringCharacterTestRoutines._CharIsDelete;
 var
-  c1: char;
+  c1: AnsiChar;
 
 begin
   for c1 := #0 to #255 do
-    CheckEquals((ord(c1) = 8), CharIsDelete(c1), 'CharIsDelete #' + IntToStr(Ord(c1)));
+    CheckEquals((ord(c1) = 8), CharIsDelete(ToChar(c1)), 'CharIsDelete #' + IntToStr(Ord(c1)));
 end;
 
 //--------------------------------------------------------------------------------------------------
 
 procedure TJclStringCharacterTestRoutines._CharIsDigit;
 var
-  c1: char;
+  c1: AnsiChar;
 
 begin
   for c1 := #0 to #255 do
     CheckEquals(
       (c1 in ['0'..'9', #178 { power of 2 }, #179 {power of 3}, #185 {power of 1}]),
-      CharIsDigit(c1),
+      CharIsDigit(ToChar(c1)),
       'CharIsDigit #' + IntToStr(Ord(c1)));
 end;
 
@@ -1939,13 +1965,13 @@ procedure TJclStringCharacterTestRoutines._CharIsDigit;
 
 procedure TJclStringCharacterTestRoutines._CharIsNumberChar;
 var
-  c1: char;
+  c1: AnsiChar;
 
 begin
   for c1 := #0 to #255 do
     CheckEquals(
       (c1 in ['0'..'9', '+', '-', {$IFDEF RTL220_UP}FormatSettings.{$ENDIF}DecimalSeparator, #178 { power of 2 }, #179 {power of 3}, #185 {power of 1}]),
-      CharIsNumberChar(c1),
+      CharIsNumberChar(ToChar(c1)),
       'CharIsNumberChar #' + IntToStr(Ord(c1)));
 end;
 
@@ -1953,13 +1979,13 @@ procedure TJclStringCharacterTestRoutines._CharIsNumberChar;
 
 procedure TJclStringCharacterTestRoutines._CharIsPrintable;
 var
-  c1: char;
+  c1: AnsiChar;
 
 begin
   for c1 := #0 to #255 do
     CheckEquals(
-      not (c1 in [#0 .. #31, #127, #129, #141, #143, #144, #157]),
-      CharIsPrintable(c1),
+      not (c1 in [#0 .. #31, #127, #129, #141, #143, #144, #157, #173]),
+      CharIsPrintable(ToChar(c1)),
       'CharIsPrintable #' + IntToStr(Ord(c1)));
 end;
 
@@ -1967,13 +1993,13 @@ procedure TJclStringCharacterTestRoutines._CharIsPrintable;
 
 procedure TJclStringCharacterTestRoutines._CharIsPunctuation;
 var
-  c1: char;
+  c1: AnsiChar;
 begin
   for c1 := #0 to #255 do
     CheckEquals(
       (c1 in [#123..#126, #130, #132 .. #135, #137, #139, #145 .. #151, #155, #161 .. #191, #215, #247,
               #91..#96, #38..#47, '@', #60..#63, '#','$','%','"','.',',','!',':','=',';']),
-      CharIsPunctuation(c1),
+      CharIsPunctuation(ToChar(c1)),
       'CharIsPunctuation #' + IntToStr(Ord(c1)));
 end;
 
@@ -1981,22 +2007,22 @@ procedure TJclStringCharacterTestRoutines._CharIsPunctuation;
 
 procedure TJclStringCharacterTestRoutines._CharIsReturn;
 var
-  c1: char;
+  c1: AnsiChar;
 begin
   for c1 := #0 to #255 do
-    CheckEquals(((c1 = #13) or (c1 = #10)), CharIsReturn(c1), 'CharIsReturn #' + IntToStr(Ord(c1)));
+    CheckEquals(((c1 = #13) or (c1 = #10)), CharIsReturn(ToChar(c1)), 'CharIsReturn #' + IntToStr(Ord(c1)));
 end;
 
 //--------------------------------------------------------------------------------------------------
 
 procedure TJclStringCharacterTestRoutines._CharIsSpace;
 var
-  c1: char;
+  c1: AnsiChar;
 begin
   for c1 := #0 to #255 do
     CheckEquals(
       c1 in [#9, #10, #11, #12, #13, ' ', #160],
-      CharIsSpace(c1),
+      CharIsSpace(ToChar(c1)),
       'CharIsSpace #' + IntToStr(Ord(c1)));
 end;
 
@@ -2004,12 +2030,12 @@ procedure TJclStringCharacterTestRoutines._CharIsSpace;
 
 procedure TJclStringCharacterTestRoutines._CharIsWhiteSpace;
 var
-  c1: char;
+  c1: AnsiChar;
 begin
   for c1 := #0 to #255 do
     CheckEquals(
       (c1 in [NativeTab, NativeLineFeed, NativeVerticalTab, NativeFormFeed, NativeCarriageReturn, NativeSpace]),
-      CharIsWhiteSpace(c1),
+      CharIsWhiteSpace(ToChar(c1)),
       'CharIsWhiteSpace #' + IntToStr(Ord(c1))
     );
 end;
@@ -2018,12 +2044,12 @@ procedure TJclStringCharacterTestRoutines._CharIsWhiteSpace;
 
 procedure TJclStringCharacterTestRoutines._CharIsUpper;
 var
-  c1: char;
+  c1: AnsiChar;
 begin
   for c1 := #0 to #255 do
     CheckEquals(
       (c1 in ['A'..'Z', #138, #140, #142, #159, #192 .. #214, #216 .. #222]),
-      CharIsUpper(c1),
+      CharIsUpper(ToChar(c1)),
       'CharIsUpper #' + IntToStr(Ord(c1)));
 end;
 
@@ -2031,12 +2057,12 @@ procedure TJclStringCharacterTestRoutines._CharIsUpper;
 
 procedure TJclStringCharacterTestRoutines._CharIsLower;
 var
-  c1: char;
+  c1: AnsiChar;
 begin
   for c1 := #0 to #255 do
     CheckEquals(
       (c1 in ['a' .. 'z', #131, #154, #156, #158, #170, #181, #186, #223 .. #246, #248 .. #255]),
-      CharIsLower(c1),
+      CharIsLower(ToChar(c1)),
       'CharIsLower #' + IntToStr(Ord(c1)));
 end;
 
@@ -2614,8 +2640,8 @@ procedure TJclStringTabSet._NilSet;
 procedure TJclStringTabSet._OptimalFill;
 var
   tabs: TJclTabSet;
-  tabCount: Integer;
-  spaceCount: Integer;
+  tabCount: SizeInt;
+  spaceCount: SizeInt;
 begin
   tabs := TJclTabSet.Create([17, 22, 32], False, 4);
   try
@@ -2846,9 +2872,13 @@ procedure TJclStringTabSet._ToString;
 var
   tabs: TJclTabSet;
 begin
-  tabs := nil;
-  CheckEquals('0 [] +2', tabs.ToString, 'nil-set, full');
-  CheckEquals('0', tabs.ToString(TabSetFormatting_Default), 'nil-set, default');
+  tabs := TJclTabSet.Create;
+  try
+    CheckEquals('0 [] +2', tabs.ToString, 'nil-set, full');
+    CheckEquals('0', tabs.ToString(TabSetFormatting_Default), 'nil-set, default');
+  finally
+    tabs.Free;
+  end;
 
   tabs := TJclTabSet.Create([15, 17, 20, 30], True, 4);
   try
@@ -2867,8 +2897,8 @@ procedure TJclStringTabSet._ToString;
 procedure TJclStringTabSet._UpdatePosition;
 var
   tabs: TJclTabSet;
-  column: Integer;
-  line: Integer;
+  column: SizeInt;
+  line: SizeInt;
 begin
   tabs := TJclTabSet.Create([17, 22, 32], False, 4);
   try
@@ -2941,6 +2971,20 @@ procedure TJclStringTabSet._ZeroBased;
 
 { TAnsiStringListTest }
 
+{$IFDEF UNICODE}
+procedure TAnsiStringListTest.CheckEquals(const expected: string;
+  const actual: AnsiString; msg: string = '');
+begin
+  CheckEquals(expected, string(actual), msg);
+end;
+
+procedure TAnsiStringListTest.CheckEquals(const expected: AnsiString;
+  const actual: string; msg: string = '');
+begin
+  CheckEquals(string(expected), actual, msg);
+end;
+{$ENDIF UNICODE}
+
 procedure TAnsiStringListTest._GetCommaTextCount;
 var slJCL: TAnsiStringList;
     slRTL: TStringList;