View Issue Details

IDProjectCategoryView StatusLast Update
0033499FPC-public2018-03-25 11:25
ReporterOndrej PokornyAssigned ToMichael Van Canneyt 
PrioritynormalSeverityminorReproducibilityN/A
Status closedResolutionfixed 
Product VersionProduct Build 
Target Version3.2.0Fixed in Version3.1.1 
Summary0033499: Fix CamelCase in identifiers in mathh.inc, systemh.inc and math.pp
DescriptionFix CamelCase in identifiers in mathh.inc, systemh.inc and math.pp
TagsNo tags attached.
Fixed in Revision38619
FPCOldBugId
FPCTarget
Attached Files
  • CamelCase-2.patch (55,996 bytes)
    Index: rtl/inc/mathh.inc
    ===================================================================
    --- rtl/inc/mathh.inc	(revision 38616)
    +++ rtl/inc/mathh.inc	(working copy)
    @@ -102,19 +102,19 @@
       {$endif}
     {$endif}
     
    -    function pi : ValReal;[internproc:fpc_in_pi_real];
    -    function abs(d : ValReal) : ValReal;[internproc:fpc_in_abs_real];
    -    function sqr(d : ValReal) : ValReal;[internproc:fpc_in_sqr_real];
    -    function sqrt(d : ValReal) : ValReal;[internproc:fpc_in_sqrt_real];
    -    function arctan(d : ValReal) : ValReal;[internproc:fpc_in_arctan_real];
    -    function ln(d : ValReal) : ValReal;[internproc:fpc_in_ln_real];
    -    function sin(d : ValReal) : ValReal;[internproc:fpc_in_sin_real];
    -    function cos(d : ValReal) : ValReal;[internproc:fpc_in_cos_real];
    -    function exp(d : ValReal) : ValReal;[internproc:fpc_in_exp_real];
    -    function round(d : ValReal) : int64;[internproc:fpc_in_round_real];
    -    function frac(d : ValReal) : ValReal;[internproc:fpc_in_frac_real];
    -    function int(d : ValReal) : ValReal;[internproc:fpc_in_int_real];
    -    function trunc(d : ValReal) : int64;[internproc:fpc_in_trunc_real];
    +    function Pi : ValReal;[internproc:fpc_in_pi_real];
    +    function Abs(d : ValReal) : ValReal;[internproc:fpc_in_abs_real];
    +    function Sqr(d : ValReal) : ValReal;[internproc:fpc_in_sqr_real];
    +    function Sqrt(d : ValReal) : ValReal;[internproc:fpc_in_sqrt_real];
    +    function ArcTan(d : ValReal) : ValReal;[internproc:fpc_in_arctan_real];
    +    function Ln(d : ValReal) : ValReal;[internproc:fpc_in_ln_real];
    +    function Sin(d : ValReal) : ValReal;[internproc:fpc_in_sin_real];
    +    function Cos(d : ValReal) : ValReal;[internproc:fpc_in_cos_real];
    +    function Exp(d : ValReal) : ValReal;[internproc:fpc_in_exp_real];
    +    function Round(d : ValReal) : int64;[internproc:fpc_in_round_real];
    +    function Frac(d : ValReal) : ValReal;[internproc:fpc_in_frac_real];
    +    function Int(d : ValReal) : ValReal;[internproc:fpc_in_int_real];
    +    function Trunc(d : ValReal) : int64;[internproc:fpc_in_trunc_real];
     
     {$ifdef SUPPORT_EXTENDED}
         function FPower10(val: Extended; Power: Longint): Extended;
    @@ -121,7 +121,7 @@
     {$endif SUPPORT_EXTENDED}
     
         type
    -       real48 = array[0..5] of byte;
    +       Real48 = array[0..5] of byte;
     
     {$ifdef SUPPORT_DOUBLE}
         function Real2Double(r : real48) : double;
    Index: rtl/inc/systemh.inc
    ===================================================================
    --- rtl/inc/systemh.inc	(revision 38616)
    +++ rtl/inc/systemh.inc	(working copy)
    @@ -557,13 +557,13 @@
     
       PNativeInt 	      = ^NativeInt;
       PNativeUInt	      = ^NativeUint;
    -  pInt8   	      = PShortInt;
    -  pInt16  	      = PSmallint;
    -  pInt32  	      = PLongint;
    +  PInt8   	      = PShortInt;
    +  PInt16  	      = PSmallint;
    +  PInt32  	      = PLongint;
       PIntPtr 	      = PPtrInt;
    -  pUInt8  	      = PByte;
    -  pUInt16 	      = PWord;
    -  pUInt32 	      = PDWord;
    +  PUInt8  	      = PByte;
    +  PUInt16 	      = PWord;
    +  PUInt32 	      = PDWord;
       PUintPtr	      = PPtrUInt;
     
       PShortString        = ^ShortString;
    @@ -656,10 +656,10 @@
       MaxUIntValue = High(ValUInt);
     
     { max. values for longint and int}
    -  maxLongint  = $7fffffff;
    -  maxSmallint = 32767;
    +  MaxLongint  = $7fffffff;
    +  MaxSmallint = 32767;
     
    -  maxint   = maxsmallint;
    +  MaxInt   = maxsmallint;
     
     type
     {$ifdef CPU16}
    @@ -698,8 +698,8 @@
     
     { Exit Procedure handling consts and types  }
       ExitProc : codepointer = nil;
    -  Erroraddr: codepointer = nil;
    -  Errorcode: Word    = 0;
    +  ErrorAddr: codepointer = nil;
    +  ErrorCode: Word    = 0;
     
     { file input modes }
       fmClosed = $D7B0;
    @@ -707,7 +707,7 @@
       fmOutput = $D7B2;
       fmInOut  = $D7B3;
       fmAppend = $D7B4;
    -  Filemode : byte = 2;
    +  FileMode : byte = 2;
     (* Value should be changed during system initialization as appropriate. *)
     
       { assume that this program will not spawn other threads, when the
    @@ -754,7 +754,7 @@
     
     {$ifndef HAS_CMDLINE}
     {Value should be changed during system initialization as appropriate.}
    -var cmdline:Pchar=nil;
    +var CmdLine:Pchar=nil;
     {$endif}
     
     {$ifdef FPC_HAS_FEATURE_THREADING}
    @@ -822,7 +822,7 @@
     procedure MoveChar0(const buf1;var buf2;len:SizeInt);
     function  IndexChar0(const buf;len:SizeInt;b:char):SizeInt;
     function  CompareChar0(const buf1,buf2;len:SizeInt):SizeInt;
    -procedure prefetch(const mem);[internproc:fpc_in_prefetch_var];
    +procedure Prefetch(const mem);[internproc:fpc_in_prefetch_var];
     procedure ReadBarrier;
     procedure ReadDependencyBarrier;
     procedure ReadWriteBarrier;
    @@ -836,27 +836,27 @@
                               Math Routines
     ****************************************************************************}
     
    -Function  lo(B: Byte):Byte;{$ifdef SYSTEMINLINE}inline;{$endif}
    -Function  hi(b : Byte) : Byte;{$ifdef SYSTEMINLINE}inline;{$endif}
    -Function  lo(i : Integer) : byte;  [INTERNPROC: fpc_in_lo_Word];
    -Function  lo(w : Word) : byte;     [INTERNPROC: fpc_in_lo_Word];
    -Function  lo(l : Longint) : Word;  [INTERNPROC: fpc_in_lo_long];
    -Function  lo(l : DWord) : Word;    [INTERNPROC: fpc_in_lo_long];
    -Function  lo(i : Int64) : DWord;   [INTERNPROC: fpc_in_lo_qword];
    -Function  lo(q : QWord) : DWord;   [INTERNPROC: fpc_in_lo_qword];
    -Function  hi(i : Integer) : byte;  [INTERNPROC: fpc_in_hi_Word];
    -Function  hi(w : Word) : byte;     [INTERNPROC: fpc_in_hi_Word];
    -Function  hi(l : Longint) : Word;  [INTERNPROC: fpc_in_hi_long];
    -Function  hi(l : DWord) : Word;    [INTERNPROC: fpc_in_hi_long];
    -Function  hi(i : Int64) : DWord;   [INTERNPROC: fpc_in_hi_qword];
    -Function  hi(q : QWord) : DWord;   [INTERNPROC: fpc_in_hi_qword];
    +Function  Lo(B: Byte):Byte;{$ifdef SYSTEMINLINE}inline;{$endif}
    +Function  Hi(b : Byte) : Byte;{$ifdef SYSTEMINLINE}inline;{$endif}
    +Function  Lo(i : Integer) : byte;  [INTERNPROC: fpc_in_lo_Word];
    +Function  Lo(w : Word) : byte;     [INTERNPROC: fpc_in_lo_Word];
    +Function  Lo(l : Longint) : Word;  [INTERNPROC: fpc_in_lo_long];
    +Function  Lo(l : DWord) : Word;    [INTERNPROC: fpc_in_lo_long];
    +Function  Lo(i : Int64) : DWord;   [INTERNPROC: fpc_in_lo_qword];
    +Function  Lo(q : QWord) : DWord;   [INTERNPROC: fpc_in_lo_qword];
    +Function  Hi(i : Integer) : byte;  [INTERNPROC: fpc_in_hi_Word];
    +Function  Hi(w : Word) : byte;     [INTERNPROC: fpc_in_hi_Word];
    +Function  Hi(l : Longint) : Word;  [INTERNPROC: fpc_in_hi_long];
    +Function  Hi(l : DWord) : Word;    [INTERNPROC: fpc_in_hi_long];
    +Function  Hi(i : Int64) : DWord;   [INTERNPROC: fpc_in_hi_qword];
    +Function  Hi(q : QWord) : DWord;   [INTERNPROC: fpc_in_hi_qword];
     
    -Function swap (X : Word) : Word;{$ifdef SYSTEMINLINE}inline;{$endif}[internconst:fpc_in_const_swap_word];
    +Function Swap (X : Word) : Word;{$ifdef SYSTEMINLINE}inline;{$endif}[internconst:fpc_in_const_swap_word];
     Function Swap (X : Integer) : Integer;{$ifdef SYSTEMINLINE}inline;{$endif}[internconst:fpc_in_const_swap_word];
    -Function swap (X : Longint) : Longint;{$ifdef SYSTEMINLINE}inline;{$endif}[internconst:fpc_in_const_swap_long];
    +Function Swap (X : Longint) : Longint;{$ifdef SYSTEMINLINE}inline;{$endif}[internconst:fpc_in_const_swap_long];
     Function Swap (X : Cardinal) : Cardinal;{$ifdef SYSTEMINLINE}inline;{$endif}[internconst:fpc_in_const_swap_long];
     Function Swap (X : QWord) : QWord;{$ifdef SYSTEMINLINE}inline;{$endif}[internconst:fpc_in_const_swap_qword];
    -Function swap (X : Int64) : Int64;{$ifdef SYSTEMINLINE}inline;{$endif}[internconst:fpc_in_const_swap_qword];
    +Function Swap (X : Int64) : Int64;{$ifdef SYSTEMINLINE}inline;{$endif}[internconst:fpc_in_const_swap_qword];
     
     Function Align (Addr : PtrUInt; Alignment : PtrUInt) : PtrUInt;{$ifdef SYSTEMINLINE}inline;{$endif}
     Function Align (Addr : Pointer; Alignment : PtrUInt) : Pointer;{$ifdef SYSTEMINLINE}inline;{$endif}
    @@ -873,52 +873,52 @@
     {$if defined(CPUINT8)}
       {$ifdef FPC_HAS_INTERNAL_ABS_SHORTINT}
       {$define FPC_SYSTEM_HAS_ABS_SHORTINT}
    -  Function abs(l:shortint):shortint;[internproc:fpc_in_abs_long];
    +  Function Abs(l:shortint):shortint;[internproc:fpc_in_abs_long];
       {$else FPC_SYSTEM_HAS_ABS_SHORTINT}
    -  Function abs(l:shortint):shortint;[internconst:fpc_in_const_abs];{$ifdef SYSTEMINLINE}inline;{$endif}
    +  Function Abs(l:shortint):shortint;[internconst:fpc_in_const_abs];{$ifdef SYSTEMINLINE}inline;{$endif}
       {$endif FPC_SYSTEM_HAS_ABS_SHORTINT}
     {$endif CPUINT8}
     {$if defined(CPUINT16) or defined(CPUINT8)}
       {$ifdef FPC_HAS_INTERNAL_ABS_SMALLINT}
       {$define FPC_SYSTEM_HAS_ABS_SMALLINT}
    -  Function abs(l:smallint):smallint;[internproc:fpc_in_abs_long];
    +  Function Abs(l:smallint):smallint;[internproc:fpc_in_abs_long];
       {$else FPC_HAS_INTERNAL_ABS_LONG}
    -  Function abs(l:smallint):smallint;[internconst:fpc_in_const_abs];{$ifdef SYSTEMINLINE}inline;{$endif}
    +  Function Abs(l:smallint):smallint;[internconst:fpc_in_const_abs];{$ifdef SYSTEMINLINE}inline;{$endif}
       {$endif FPC_HAS_INTERNAL_ABS_LONG}
     {$endif CPUINT16 or CPUINT8}
     {$ifdef FPC_HAS_INTERNAL_ABS_LONG}
     {$define FPC_SYSTEM_HAS_ABS_LONGINT}
    -Function abs(l:longint):longint;[internproc:fpc_in_abs_long];
    +Function Abs(l:longint):longint;[internproc:fpc_in_abs_long];
     {$else FPC_HAS_INTERNAL_ABS_LONG}
    -Function abs(l:Longint):Longint;[internconst:fpc_in_const_abs];{$ifdef SYSTEMINLINE}inline;{$endif}
    +Function Abs(l:Longint):Longint;[internconst:fpc_in_const_abs];{$ifdef SYSTEMINLINE}inline;{$endif}
     {$endif FPC_HAS_INTERNAL_ABS_LONG}
     {$ifdef FPC_HAS_INTERNAL_ABS_INT64}
     {$define FPC_SYSTEM_HAS_ABS_INT64}
    -Function abs(l:Int64):Int64;[internproc:fpc_in_abs_long];
    +Function Abs(l:Int64):Int64;[internproc:fpc_in_abs_long];
     {$else FPC_HAS_INTERNAL_ABS_INT64}
    -Function abs(l:Int64):Int64;[internconst:fpc_in_const_abs];{$ifdef SYSTEMINLINE}inline;{$endif}
    +Function Abs(l:Int64):Int64;[internconst:fpc_in_const_abs];{$ifdef SYSTEMINLINE}inline;{$endif}
     {$endif FPC_HAS_INTERNAL_ABS_INT64}
     {$if defined(CPUINT8)}
    -Function sqr(l:shortint):shortint;[internconst:fpc_in_const_sqr];{$ifdef SYSTEMINLINE}inline;{$endif}
    +Function Sqr(l:shortint):shortint;[internconst:fpc_in_const_sqr];{$ifdef SYSTEMINLINE}inline;{$endif}
     {$endif CPUINT8}
     {$if defined(CPUINT16) or defined(CPUINT8)}
    -Function sqr(l:smallint):smallint;[internconst:fpc_in_const_sqr];{$ifdef SYSTEMINLINE}inline;{$endif}
    +Function Sqr(l:smallint):smallint;[internconst:fpc_in_const_sqr];{$ifdef SYSTEMINLINE}inline;{$endif}
     {$endif CPUINT16 or CPUINT8}
    -Function sqr(l:Longint):Longint;[internconst:fpc_in_const_sqr];{$ifdef SYSTEMINLINE}inline;{$endif}
    -Function sqr(l:Int64):Int64;[internconst:fpc_in_const_sqr];{$ifdef SYSTEMINLINE}inline;{$endif}
    -Function sqr(l:QWord):QWord;[internconst:fpc_in_const_sqr];{$ifdef SYSTEMINLINE}inline;{$endif}
    +Function Sqr(l:Longint):Longint;[internconst:fpc_in_const_sqr];{$ifdef SYSTEMINLINE}inline;{$endif}
    +Function Sqr(l:Int64):Int64;[internconst:fpc_in_const_sqr];{$ifdef SYSTEMINLINE}inline;{$endif}
    +Function Sqr(l:QWord):QWord;[internconst:fpc_in_const_sqr];{$ifdef SYSTEMINLINE}inline;{$endif}
     {$if defined(CPUINT8)}
    -Function odd(l:shortint):Boolean;[internconst:fpc_in_const_odd];{$ifdef SYSTEMINLINE}inline;{$endif}
    -Function odd(l:byte):Boolean;[internconst:fpc_in_const_odd];{$ifdef SYSTEMINLINE}inline;{$endif}
    +Function Odd(l:shortint):Boolean;[internconst:fpc_in_const_odd];{$ifdef SYSTEMINLINE}inline;{$endif}
    +Function Odd(l:byte):Boolean;[internconst:fpc_in_const_odd];{$ifdef SYSTEMINLINE}inline;{$endif}
     {$endif CPUINT8}
     {$if defined(CPUINT16) or defined(CPUINT8)}
    -Function odd(l:smallint):Boolean;[internconst:fpc_in_const_odd];{$ifdef SYSTEMINLINE}inline;{$endif}
    -Function odd(l:word):Boolean;[internconst:fpc_in_const_odd];{$ifdef SYSTEMINLINE}inline;{$endif}
    +Function Odd(l:smallint):Boolean;[internconst:fpc_in_const_odd];{$ifdef SYSTEMINLINE}inline;{$endif}
    +Function Odd(l:word):Boolean;[internconst:fpc_in_const_odd];{$ifdef SYSTEMINLINE}inline;{$endif}
     {$endif CPUINT16 or CPUINT8}
    -Function odd(l:Longint):Boolean;[internconst:fpc_in_const_odd];{$ifdef SYSTEMINLINE}inline;{$endif}
    -Function odd(l:Longword):Boolean;[internconst:fpc_in_const_odd];{$ifdef SYSTEMINLINE}inline;{$endif}
    -Function odd(l:Int64):Boolean;[internconst:fpc_in_const_odd];{$ifdef SYSTEMINLINE}inline;{$endif}
    -Function odd(l:QWord):Boolean;[internconst:fpc_in_const_odd];{$ifdef SYSTEMINLINE}inline;{$endif}
    +Function Odd(l:Longint):Boolean;[internconst:fpc_in_const_odd];{$ifdef SYSTEMINLINE}inline;{$endif}
    +Function Odd(l:Longword):Boolean;[internconst:fpc_in_const_odd];{$ifdef SYSTEMINLINE}inline;{$endif}
    +Function Odd(l:Int64):Boolean;[internconst:fpc_in_const_odd];{$ifdef SYSTEMINLINE}inline;{$endif}
    +Function Odd(l:QWord):Boolean;[internconst:fpc_in_const_odd];{$ifdef SYSTEMINLINE}inline;{$endif}
     
     function SwapEndian(const AValue: SmallInt): SmallInt;{$ifdef SYSTEMINLINE}inline;{$endif}
     function SwapEndian(const AValue: Word): Word;{$ifdef SYSTEMINLINE}inline;{$endif}
    @@ -1161,17 +1161,17 @@
                              Addr/Pointer Handling
     ****************************************************************************}
     
    -Function  ptr(sel,off:{$ifdef CPU16}Word{$else}Longint{$endif}):farpointer;[internconst:fpc_in_const_ptr];{$ifdef SYSTEMINLINE}inline;{$endif}
    -Function  Cseg:Word;{$ifdef SYSTEMINLINE}inline;{$endif}
    -Function  Dseg:Word;{$ifdef SYSTEMINLINE}inline;{$endif}
    -Function  Sseg:Word;{$ifdef SYSTEMINLINE}inline;{$endif}
    +Function  Ptr(sel,off:{$ifdef CPU16}Word{$else}Longint{$endif}):farpointer;[internconst:fpc_in_const_ptr];{$ifdef SYSTEMINLINE}inline;{$endif}
    +Function  CSeg:Word;{$ifdef SYSTEMINLINE}inline;{$endif}
    +Function  DSeg:Word;{$ifdef SYSTEMINLINE}inline;{$endif}
    +Function  SSeg:Word;{$ifdef SYSTEMINLINE}inline;{$endif}
     
     {****************************************************************************
                           PChar and String Handling
     ****************************************************************************}
     
    -function strpas(p:pchar):shortstring;{$ifdef SYSTEMINLINE}inline;{$endif}
    -function strlen(p:pchar):sizeint;external name 'FPC_PCHAR_LENGTH';
    +function StrPas(p:pchar):shortstring;{$ifdef SYSTEMINLINE}inline;{$endif}
    +function StrLen(p:pchar):sizeint;external name 'FPC_PCHAR_LENGTH';
     
     { result:
       <0: invalid sequence detected after processing "-result" bytes
    @@ -1202,37 +1202,37 @@
     {$endif FPC_HAS_FEATURE_ANSISTRINGS}
     Procedure {$ifdef FPC_HAS_CPSTRING}fpc_setstring_shortstr{$else}SetString{$endif}(out S : Shortstring; Buf : PChar; Len : SizeInt); {$ifdef FPC_HAS_CPSTRING} compilerproc; {$endif FPC_HAS_CPSTRING}
     function  ShortCompareText(const S1, S2: shortstring): SizeInt;
    -Function  upCase(const s:shortstring):shortstring;
    -Function  lowerCase(const s:shortstring):shortstring; overload;
    +Function  UpCase(const s:shortstring):shortstring;
    +Function  LowerCase(const s:shortstring):shortstring; overload;
     Function  Space(b:byte):shortstring;
    -Function  hexStr(Val:Longint;cnt:byte):shortstring;
    +Function  HexStr(Val:Longint;cnt:byte):shortstring;
     Function  OctStr(Val:Longint;cnt:byte):shortstring;
    -Function  binStr(Val:Longint;cnt:byte):shortstring;
    -Function  hexStr(Val:int64;cnt:byte):shortstring;
    +Function  BinStr(Val:Longint;cnt:byte):shortstring;
    +Function  HexStr(Val:int64;cnt:byte):shortstring;
     Function  OctStr(Val:int64;cnt:byte):shortstring;
    -Function  binStr(Val:int64;cnt:byte):shortstring;
    -Function  hexStr(Val:qword;cnt:byte):shortstring;
    +Function  BinStr(Val:int64;cnt:byte):shortstring;
    +Function  HexStr(Val:qword;cnt:byte):shortstring;
     Function  OctStr(Val:qword;cnt:byte):shortstring;
    -Function  binStr(Val:qword;cnt:byte):shortstring;
    +Function  BinStr(Val:qword;cnt:byte):shortstring;
     {$ifdef CPUI8086}
    -Function  hexStr(Val:NearPointer):shortstring;
    -function  hexStr(Val:NearCsPointer):shortstring;
    -function  hexStr(Val:NearDsPointer):shortstring;
    -function  hexStr(Val:NearEsPointer):shortstring;
    -function  hexStr(Val:NearSsPointer):shortstring;
    -function  hexStr(Val:NearFsPointer):shortstring;
    -function  hexStr(Val:NearGsPointer):shortstring;
    -Function  hexStr(Val:FarPointer):shortstring;
    -Function  hexStr(Val:HugePointer):shortstring;{$ifdef SYSTEMINLINE}inline;{$endif}
    +Function  HexStr(Val:NearPointer):shortstring;
    +function  HexStr(Val:NearCsPointer):shortstring;
    +function  HexStr(Val:NearDsPointer):shortstring;
    +function  HexStr(Val:NearEsPointer):shortstring;
    +function  HexStr(Val:NearSsPointer):shortstring;
    +function  HexStr(Val:NearFsPointer):shortstring;
    +function  HexStr(Val:NearGsPointer):shortstring;
    +Function  HexStr(Val:FarPointer):shortstring;
    +Function  HexStr(Val:HugePointer):shortstring;{$ifdef SYSTEMINLINE}inline;{$endif}
     {$else CPUI8086}
    -Function  hexStr(Val:Pointer):shortstring;
    +Function  HexStr(Val:Pointer):shortstring;
     {$endif CPUI8086}
     
     { Char functions }
    -Function chr(b : byte) : Char;      [INTERNPROC: fpc_in_chr_byte];
    -Function  upCase(c:Char):Char;
    -Function  lowerCase(c:Char):Char; overload;
    -function  pos(const substr : shortstring;c:char; Offset: Sizeint = 1): SizeInt;
    +Function Chr(b : byte) : Char;      [INTERNPROC: fpc_in_chr_byte];
    +Function  UpCase(c:Char):Char;
    +Function  LowerCase(c:Char):Char; overload;
    +function  Pos(const substr : shortstring;c:char; Offset: Sizeint = 1): SizeInt;
     
     
     {****************************************************************************
    @@ -1248,8 +1248,8 @@
     Procedure Delete (var S : RawByteString; Index,Size: SizeInt);{$ifdef FPC_HAS_CPSTRING}rtlproc;{$endif FPC_HAS_CPSTRING}
     {$endif VER3_0}
     Function  StringOfChar(c : Ansichar;l : SizeInt) : AnsiString;
    -function  upcase(const s : ansistring) : ansistring;
    -function  lowercase(const s : ansistring) : ansistring;
    +function  UpCase(const s : ansistring) : ansistring;
    +function  LowerCase(const s : ansistring) : ansistring;
     
     function StringCodePage(const S : RawByteString): TSystemCodePage; overload;
     function StringElementSize(const S : RawByteString): Word; overload;
    @@ -1381,22 +1381,22 @@
     ****************************************************************************}
     
     {$ifdef FPC_HAS_FEATURE_FILEIO}
    -Procedure chdir(const s:shortstring); overload;
    -Procedure mkdir(const s:shortstring); overload;
    -Procedure rmdir(const s:shortstring); overload;
    -Procedure getdir(drivenr:byte;var dir:shortstring);overload;
    +Procedure ChDir(const s:shortstring); overload;
    +Procedure MkDir(const s:shortstring); overload;
    +Procedure RmDir(const s:shortstring); overload;
    +Procedure GetDir(drivenr:byte;var dir:shortstring);overload;
     {$ifdef FPC_HAS_FEATURE_ANSISTRINGS}
    -Procedure chdir(const s:rawbytestring); overload;
    -Procedure mkdir(const s:rawbytestring); overload;
    -Procedure rmdir(const s:rawbytestring); overload;
    +Procedure ChDir(const s:rawbytestring); overload;
    +Procedure MkDir(const s:rawbytestring); overload;
    +Procedure RmDir(const s:rawbytestring); overload;
     // defaultrtlfilesystemcodepage is returned here
    -Procedure getdir(drivenr:byte;var dir: rawbytestring);overload;{$ifdef FPC_HAS_CPSTRING}rtlproc;{$endif FPC_HAS_CPSTRING}
    +Procedure GetDir(drivenr:byte;var dir: rawbytestring);overload;{$ifdef FPC_HAS_CPSTRING}rtlproc;{$endif FPC_HAS_CPSTRING}
     {$endif FPC_HAS_FEATURE_ANSISTRINGS}
     {$ifdef FPC_HAS_FEATURE_WIDESTRINGS}
    -Procedure chdir(const s:unicodestring); overload;
    -Procedure mkdir(const s:unicodestring); overload;
    -Procedure rmdir(const s:unicodestring); overload;
    -Procedure getdir(drivenr:byte;var dir: unicodestring);overload;
    +Procedure ChDir(const s:unicodestring); overload;
    +Procedure MkDir(const s:unicodestring); overload;
    +Procedure RmDir(const s:unicodestring); overload;
    +Procedure GetDir(drivenr:byte;var dir: unicodestring);overload;
     {$endif FPC_HAS_FEATURE_WIDESTRINGS}
     
     {$endif FPC_HAS_FEATURE_FILEIO}
    @@ -1431,7 +1431,7 @@
     procedure get_caller_stackinfo(var framebp : pointer; var addr : codepointer);
     
     Function IOResult:Word;
    -Function Sptr:Pointer;[internconst:fpc_in_const_ptr];
    +Function SPtr:Pointer;[internconst:fpc_in_const_ptr];
     
     {$ifdef FPC_HAS_FEATURE_PROCESSES}
     Function GetProcessID:SizeUInt;
    @@ -1445,22 +1445,22 @@
     {$endif}
     
     {$ifdef cpu16}
    -function InterLockedIncrement (var Target: smallint) : smallint; public name 'FPC_INTERLOCKEDINCREMENT16';
    -function InterLockedDecrement (var Target: smallint) : smallint; public name 'FPC_INTERLOCKEDDECREMENT16';
    -function InterLockedExchange (var Target: smallint;Source : smallint) : smallint; public name 'FPC_INTERLOCKEDEXCHANGE16';
    -function InterLockedExchangeAdd (var Target: smallint;Source : smallint) : smallint; public name 'FPC_INTERLOCKEDEXCHANGEADD16';
    +function InterlockedIncrement (var Target: smallint) : smallint; public name 'FPC_INTERLOCKEDINCREMENT16';
    +function InterlockedDecrement (var Target: smallint) : smallint; public name 'FPC_INTERLOCKEDDECREMENT16';
    +function InterlockedExchange (var Target: smallint;Source : smallint) : smallint; public name 'FPC_INTERLOCKEDEXCHANGE16';
    +function InterlockedExchangeAdd (var Target: smallint;Source : smallint) : smallint; public name 'FPC_INTERLOCKEDEXCHANGEADD16';
     function InterlockedCompareExchange(var Target: smallint; NewValue: smallint; Comperand: smallint): smallint; public name 'FPC_INTERLOCKEDCOMPAREEXCHANGE16';
     {$endif cpu16}
    -function InterLockedIncrement (var Target: longint) : longint; public name 'FPC_INTERLOCKEDINCREMENT';
    -function InterLockedDecrement (var Target: longint) : longint; public name 'FPC_INTERLOCKEDDECREMENT';
    -function InterLockedExchange (var Target: longint;Source : longint) : longint; public name 'FPC_INTERLOCKEDEXCHANGE';
    -function InterLockedExchangeAdd (var Target: longint;Source : longint) : longint; public name 'FPC_INTERLOCKEDEXCHANGEADD';
    +function InterlockedIncrement (var Target: longint) : longint; public name 'FPC_INTERLOCKEDINCREMENT';
    +function InterlockedDecrement (var Target: longint) : longint; public name 'FPC_INTERLOCKEDDECREMENT';
    +function InterlockedExchange (var Target: longint;Source : longint) : longint; public name 'FPC_INTERLOCKEDEXCHANGE';
    +function InterlockedExchangeAdd (var Target: longint;Source : longint) : longint; public name 'FPC_INTERLOCKEDEXCHANGEADD';
     function InterlockedCompareExchange(var Target: longint; NewValue: longint; Comperand: longint): longint; public name 'FPC_INTERLOCKEDCOMPAREEXCHANGE';
     {$ifdef cpu64}
    -function InterLockedIncrement64 (var Target: int64) : int64; public name 'FPC_INTERLOCKEDINCREMENT64';
    -function InterLockedDecrement64 (var Target: int64) : int64; public name 'FPC_INTERLOCKEDDECREMENT64';
    -function InterLockedExchange64 (var Target: int64;Source : int64) : int64; public name 'FPC_INTERLOCKEDEXCHANGE64';
    -function InterLockedExchangeAdd64 (var Target: int64;Source : int64) : int64; public name 'FPC_INTERLOCKEDEXCHANGEADD64';
    +function InterlockedIncrement64 (var Target: int64) : int64; public name 'FPC_INTERLOCKEDINCREMENT64';
    +function InterlockedDecrement64 (var Target: int64) : int64; public name 'FPC_INTERLOCKEDDECREMENT64';
    +function InterlockedExchange64 (var Target: int64;Source : int64) : int64; public name 'FPC_INTERLOCKEDEXCHANGE64';
    +function InterlockedExchangeAdd64 (var Target: int64;Source : int64) : int64; public name 'FPC_INTERLOCKEDEXCHANGEADD64';
     function InterlockedCompareExchange64(var Target: int64; NewValue: int64; Comperand: int64): int64; public name 'FPC_INTERLOCKEDCOMPAREEXCHANGE64';
     {$endif cpu64}
     { Pointer overloads }
    @@ -1467,47 +1467,47 @@
     {$if defined(FPC_HAS_EXPLICIT_INTERLOCKED_POINTER)}
     { Note: define FPC_SYSTEM_HAS_EXPLICIT_INTERLOCKED_POINTER if the target platform defines
             these pointer overloads itself instead of using platform independant inline functions }
    -function InterLockedIncrement (var Target: Pointer) : Pointer; {$ifndef FPC_SYSTEM_HAS_EXPLICIT_INTERLOCKED_POINTER}inline;{$endif}
    -function InterLockedDecrement (var Target: Pointer) : Pointer; {$ifndef FPC_SYSTEM_HAS_EXPLICIT_INTERLOCKED_POINTER}inline;{$endif}
    -function InterLockedExchange (var Target: Pointer;Source : Pointer) : Pointer; {$ifndef FPC_SYSTEM_HAS_EXPLICIT_INTERLOCKED_POINTER}inline;{$endif}
    -function InterLockedExchangeAdd (var Target: Pointer;Source : Pointer) : Pointer; {$ifndef FPC_SYSTEM_HAS_EXPLICIT_INTERLOCKED_POINTER}inline;{$endif}
    -function InterLockedCompareExchange(var Target: Pointer; NewValue: Pointer; Comperand: Pointer): Pointer;  {$ifndef FPC_SYSTEM_HAS_EXPLICIT_INTERLOCKED_POINTER}inline;{$else}public name 'FPC_INTERLOCKEDEXCHANGEPOINTER';{$endif}
    +function InterlockedIncrement (var Target: Pointer) : Pointer; {$ifndef FPC_SYSTEM_HAS_EXPLICIT_INTERLOCKED_POINTER}inline;{$endif}
    +function InterlockedDecrement (var Target: Pointer) : Pointer; {$ifndef FPC_SYSTEM_HAS_EXPLICIT_INTERLOCKED_POINTER}inline;{$endif}
    +function InterlockedExchange (var Target: Pointer;Source : Pointer) : Pointer; {$ifndef FPC_SYSTEM_HAS_EXPLICIT_INTERLOCKED_POINTER}inline;{$endif}
    +function InterlockedExchangeAdd (var Target: Pointer;Source : Pointer) : Pointer; {$ifndef FPC_SYSTEM_HAS_EXPLICIT_INTERLOCKED_POINTER}inline;{$endif}
    +function InterlockedCompareExchange(var Target: Pointer; NewValue: Pointer; Comperand: Pointer): Pointer;  {$ifndef FPC_SYSTEM_HAS_EXPLICIT_INTERLOCKED_POINTER}inline;{$else}public name 'FPC_INTERLOCKEDEXCHANGEPOINTER';{$endif}
     { Note: in case of FPC_SYSTEM_HAS_EXPLICIT_INTERLOCKED_POINTER this is an alias for
    -        InterLockedCompareExchange (this doesn't work with inline however) }
    -function InterLockedCompareExchangePointer(var Target: Pointer; NewValue: Pointer; Comperand: Pointer): Pointer; {$ifndef FPC_INTERLOCKED_POINTER_INLINE}inline;{$else}external name 'FPC_INTERLOCKEDEXCHANGEPOINTER';{$endif}
    +        InterlockedCompareExchange (this doesn't work with inline however) }
    +function InterlockedCompareExchangePointer(var Target: Pointer; NewValue: Pointer; Comperand: Pointer): Pointer; {$ifndef FPC_INTERLOCKED_POINTER_INLINE}inline;{$else}external name 'FPC_INTERLOCKEDEXCHANGEPOINTER';{$endif}
     {$elseif defined(cpu64)}
    -function InterLockedIncrement (var Target: Pointer) : Pointer; external name 'FPC_INTERLOCKEDINCREMENT64';
    -function InterLockedDecrement (var Target: Pointer) : Pointer; external name 'FPC_INTERLOCKEDDECREMENT64';
    -function InterLockedExchange (var Target: Pointer;Source : Pointer) : Pointer; external name 'FPC_INTERLOCKEDEXCHANGE64';
    -function InterLockedExchangeAdd (var Target: Pointer;Source : Pointer) : Pointer; external name 'FPC_INTERLOCKEDEXCHANGEADD64';
    +function InterlockedIncrement (var Target: Pointer) : Pointer; external name 'FPC_INTERLOCKEDINCREMENT64';
    +function InterlockedDecrement (var Target: Pointer) : Pointer; external name 'FPC_INTERLOCKEDDECREMENT64';
    +function InterlockedExchange (var Target: Pointer;Source : Pointer) : Pointer; external name 'FPC_INTERLOCKEDEXCHANGE64';
    +function InterlockedExchangeAdd (var Target: Pointer;Source : Pointer) : Pointer; external name 'FPC_INTERLOCKEDEXCHANGEADD64';
     function InterlockedCompareExchange(var Target: Pointer; NewValue: Pointer; Comperand: Pointer): Pointer; external name 'FPC_INTERLOCKEDCOMPAREEXCHANGE64';
     function InterlockedCompareExchangePointer(var Target: Pointer; NewValue: Pointer; Comperand: Pointer): Pointer; external name 'FPC_INTERLOCKEDCOMPAREEXCHANGE64';
     {$else not FPC_HAS_EXPLICIT_INTERLOCKED_POINTER and not CPU64}
    -function InterLockedIncrement (var Target: Pointer) : Pointer; external name 'FPC_INTERLOCKEDINCREMENT';
    -function InterLockedDecrement (var Target: Pointer) : Pointer; external name 'FPC_INTERLOCKEDDECREMENT';
    -function InterLockedExchange (var Target: Pointer;Source : Pointer) : Pointer; external name 'FPC_INTERLOCKEDEXCHANGE';
    -function InterLockedExchangeAdd (var Target: Pointer;Source : Pointer) : Pointer; external name 'FPC_INTERLOCKEDEXCHANGEADD';
    +function InterlockedIncrement (var Target: Pointer) : Pointer; external name 'FPC_INTERLOCKEDINCREMENT';
    +function InterlockedDecrement (var Target: Pointer) : Pointer; external name 'FPC_INTERLOCKEDDECREMENT';
    +function InterlockedExchange (var Target: Pointer;Source : Pointer) : Pointer; external name 'FPC_INTERLOCKEDEXCHANGE';
    +function InterlockedExchangeAdd (var Target: Pointer;Source : Pointer) : Pointer; external name 'FPC_INTERLOCKEDEXCHANGEADD';
     function InterlockedCompareExchange(var Target: Pointer; NewValue: Pointer; Comperand: Pointer): Pointer; external name 'FPC_INTERLOCKEDCOMPAREEXCHANGE';
     function InterlockedCompareExchangePointer(var Target: Pointer; NewValue: Pointer; Comperand: Pointer): Pointer; external name 'FPC_INTERLOCKEDCOMPAREEXCHANGE';
     {$endif FPC_HAS_EXPLICIT_INTERLOCKED_POINTER / CPU64}
     { unsigned overloads }
     {$ifdef cpu16}
    -function InterLockedIncrement (var Target: word) : word; external name 'FPC_INTERLOCKEDINCREMENT16';
    -function InterLockedDecrement (var Target: word) : word; external name 'FPC_INTERLOCKEDDECREMENT16';
    -function InterLockedExchange (var Target: word;Source : word) : word; external name 'FPC_INTERLOCKEDEXCHANGE16';
    -function InterLockedExchangeAdd (var Target: word;Source : word) : word; external name 'FPC_INTERLOCKEDEXCHANGEADD16';
    +function InterlockedIncrement (var Target: word) : word; external name 'FPC_INTERLOCKEDINCREMENT16';
    +function InterlockedDecrement (var Target: word) : word; external name 'FPC_INTERLOCKEDDECREMENT16';
    +function InterlockedExchange (var Target: word;Source : word) : word; external name 'FPC_INTERLOCKEDEXCHANGE16';
    +function InterlockedExchangeAdd (var Target: word;Source : word) : word; external name 'FPC_INTERLOCKEDEXCHANGEADD16';
     function InterlockedCompareExchange(var Target: word; NewValue: word; Comperand: word): word; external name 'FPC_INTERLOCKEDCOMPAREEXCHANGE16';
     {$endif cpu16}
    -function InterLockedIncrement (var Target: cardinal) : cardinal; external name 'FPC_INTERLOCKEDINCREMENT';
    -function InterLockedDecrement (var Target: cardinal) : cardinal; external name 'FPC_INTERLOCKEDDECREMENT';
    -function InterLockedExchange (var Target: cardinal;Source : cardinal) : cardinal; external name 'FPC_INTERLOCKEDEXCHANGE';
    -function InterLockedExchangeAdd (var Target: cardinal;Source : cardinal) : cardinal; external name 'FPC_INTERLOCKEDEXCHANGEADD';
    +function InterlockedIncrement (var Target: cardinal) : cardinal; external name 'FPC_INTERLOCKEDINCREMENT';
    +function InterlockedDecrement (var Target: cardinal) : cardinal; external name 'FPC_INTERLOCKEDDECREMENT';
    +function InterlockedExchange (var Target: cardinal;Source : cardinal) : cardinal; external name 'FPC_INTERLOCKEDEXCHANGE';
    +function InterlockedExchangeAdd (var Target: cardinal;Source : cardinal) : cardinal; external name 'FPC_INTERLOCKEDEXCHANGEADD';
     function InterlockedCompareExchange(var Target: cardinal; NewValue: cardinal; Comperand: cardinal): cardinal; external name 'FPC_INTERLOCKEDCOMPAREEXCHANGE';
     {$ifdef cpu64}
    -function InterLockedIncrement64 (var Target: qword) : qword; external name 'FPC_INTERLOCKEDINCREMENT64';
    -function InterLockedDecrement64 (var Target: qword) : qword; external name 'FPC_INTERLOCKEDDECREMENT64';
    -function InterLockedExchange64 (var Target: qword;Source : qword) : qword; external name 'FPC_INTERLOCKEDEXCHANGE64';
    -function InterLockedExchangeAdd64 (var Target: qword;Source : qword) : qword; external name 'FPC_INTERLOCKEDEXCHANGEADD64';
    +function InterlockedIncrement64 (var Target: qword) : qword; external name 'FPC_INTERLOCKEDINCREMENT64';
    +function InterlockedDecrement64 (var Target: qword) : qword; external name 'FPC_INTERLOCKEDDECREMENT64';
    +function InterlockedExchange64 (var Target: qword;Source : qword) : qword; external name 'FPC_INTERLOCKEDEXCHANGE64';
    +function InterlockedExchangeAdd64 (var Target: qword;Source : qword) : qword; external name 'FPC_INTERLOCKEDEXCHANGEADD64';
     function InterlockedCompareExchange64(var Target: qword; NewValue: qword; Comperand: qword): int64; external name 'FPC_INTERLOCKEDCOMPAREEXCHANGE64';
     {$endif cpu64}
     
    @@ -1546,16 +1546,16 @@
     Procedure Dump_Stack(var f : text;fp:pointer;addr : codepointer = nil);
     procedure Dump_Stack(var f : text;skipframes : longint);
     {$ifdef FPC_HAS_FEATURE_EXCEPTIONS}
    -procedure DumpExceptionBackTrace(var f:text);
    +procedure DumpExceptionBacktrace(var f:text);
     {$endif FPC_HAS_FEATURE_EXCEPTIONS}
     
     Procedure RunError(w:Word);noreturn;
     Procedure RunError;{$ifdef SYSTEMINLINE}inline;{$endif}noreturn;
    -Procedure halt(errnum:Longint);noreturn;
    +Procedure Halt(errnum:Longint);noreturn;
     {$ifdef FPC_HAS_FEATURE_HEAP}
     Procedure AddExitProc(Proc:TProcedure);
     {$endif FPC_HAS_FEATURE_HEAP}
    -Procedure halt;{$ifdef SYSTEMINLINE}inline;{$endif}noreturn;
    +Procedure Halt;{$ifdef SYSTEMINLINE}inline;{$endif}noreturn;
     
     { Need to be exported for threads unit }
     {$ifdef FPC_HAS_FEATURE_EXCEPTIONS}
    @@ -1587,7 +1587,7 @@
     
     procedure AbstractError;external name 'FPC_ABSTRACTERROR';
     procedure EmptyMethod;external name 'FPC_EMPTYMETHOD';
    -Function  SysBackTraceStr(Addr:CodePointer): ShortString;
    +Function  SysBacktraceStr(Addr:CodePointer): ShortString;
     Procedure SysAssert(const Msg,FName:ShortString;LineNo:Longint;ErrorAddr:Pointer);
     (* Supposed to return address of previous CtrlBreakHandler *)
     (* (may be nil), returned value of pointer (-1) means that *)
    @@ -1596,7 +1596,7 @@
     
     { Error handlers }
     Type
    -  TBackTraceStrFunc = Function (Addr: CodePointer): ShortString;
    +  TBacktraceStrFunc = Function (Addr: CodePointer): ShortString;
       TErrorProc = Procedure (ErrNo : Longint; Address : CodePointer; Frame : Pointer);
       TAbstractErrorProc = Procedure;
       TAssertErrorProc = Procedure(const msg,fname:ShortString;lineno:longint;erroraddr:pointer);
    @@ -1604,7 +1604,7 @@
     
     
     const
    -  BackTraceStrFunc  : TBackTraceStrFunc = @SysBackTraceStr;
    +  BacktraceStrFunc  : TBacktraceStrFunc = @SysBacktraceStr;
       ErrorProc         : TErrorProc = nil;
       AbstractErrorProc : TAbstractErrorProc = nil;
       AssertErrorProc   : TAssertErrorProc = @SysAssert;
    Index: rtl/objpas/math.pp
    ===================================================================
    --- rtl/objpas/math.pp	(revision 38616)
    +++ rtl/objpas/math.pp	(working copy)
    @@ -97,7 +97,7 @@
            { break all assembler code  PM                            }
     {$if defined(FPC_HAS_TYPE_FLOAT128)}
           type
    -         float = float128;
    +         Float = Float128;
     
           const
              MinFloat = MinFloat128;
    @@ -104,7 +104,7 @@
              MaxFloat = MaxFloat128;
     {$elseif defined(FPC_HAS_TYPE_EXTENDED)}
           type
    -         float = extended;
    +         Float = extended;
     
           const
              MinFloat = MinExtended;
    @@ -111,7 +111,7 @@
              MaxFloat = MaxExtended;
     {$elseif defined(FPC_HAS_TYPE_DOUBLE)}
           type
    -         float = double;
    +         Float = double;
     
           const
              MinFloat = MinDouble;
    @@ -118,7 +118,7 @@
              MaxFloat = MaxDouble;
     {$elseif defined(FPC_HAS_TYPE_SINGLE)}
           type
    -         float = single;
    +         Float = single;
     
           const
              MinFloat = MinSingle;
    @@ -131,7 +131,7 @@
            PFloat = ^Float;
            PInteger = ObjPas.PInteger;
     
    -       tpaymenttime = (ptendofperiod,ptstartofperiod);
    +       TPaymentTime = (ptEndOfPeriod,ptStartOfPeriod);
     
            EInvalidArgument = class(ematherror);
     
    @@ -287,15 +287,15 @@
     
     { angle conversion }
     
    -function degtorad(deg : float) : float;inline;
    -function radtodeg(rad : float) : float;inline;
    -function gradtorad(grad : float) : float;inline;
    -function radtograd(rad : float) : float;inline;
    -function degtograd(deg : float) : float;inline;
    -function gradtodeg(grad : float) : float;inline;
    +function DegToRad(deg : float) : float;inline;
    +function RadToDeg(rad : float) : float;inline;
    +function GradToRad(grad : float) : float;inline;
    +function RadToGrad(rad : float) : float;inline;
    +function DegToGrad(deg : float) : float;inline;
    +function GradToDeg(grad : float) : float;inline;
     { one cycle are 2*Pi rad }
    -function cycletorad(cycle : float) : float;inline;
    -function radtocycle(rad : float) : float;inline;
    +function CycleToRad(cycle : float) : float;inline;
    +function RadToCycle(rad : float) : float;inline;
     {$ifdef FPC_HAS_TYPE_SINGLE}
     Function DegNormalize(deg : single) : single; inline;
     {$ENDIF}
    @@ -308,70 +308,70 @@
     
     { trigoniometric functions }
     
    -function tan(x : float) : float;
    -function cotan(x : float) : float;
    -function cot(x : float) : float; inline;
    +function Tan(x : float) : float;
    +function Cotan(x : float) : float;
    +function Cot(x : float) : float; inline;
     {$ifdef FPC_HAS_TYPE_SINGLE}
    -procedure sincos(theta : single;out sinus,cosinus : single);
    +procedure SinCos(theta : single;out sinus,cosinus : single);
     {$endif}
     {$ifdef FPC_HAS_TYPE_DOUBLE}
    -procedure sincos(theta : double;out sinus,cosinus : double);
    +procedure SinCos(theta : double;out sinus,cosinus : double);
     {$endif}
     {$ifdef FPC_HAS_TYPE_EXTENDED}
    -procedure sincos(theta : extended;out sinus,cosinus : extended);
    +procedure SinCos(theta : extended;out sinus,cosinus : extended);
     {$endif}
     
     
    -function secant(x : float) : float; inline;
    -function cosecant(x : float) : float; inline;
    -function sec(x : float) : float; inline;
    -function csc(x : float) : float; inline;
    +function Secant(x : float) : float; inline;
    +function Cosecant(x : float) : float; inline;
    +function Sec(x : float) : float; inline;
    +function Csc(x : float) : float; inline;
     
     { inverse functions }
     
    -function arccos(x : float) : float;
    -function arcsin(x : float) : float;
    +function ArcCos(x : float) : float;
    +function ArcSin(x : float) : float;
     
     { calculates arctan(y/x) and returns an angle in the correct quadrant }
    -function arctan2(y,x : float) : float;
    +function ArcTan2(y,x : float) : float;
     
     { hyperbolic functions }
     
    -function cosh(x : float) : float;
    -function sinh(x : float) : float;
    -function tanh(x : float) : float;
    +function CosH(x : float) : float;
    +function SinH(x : float) : float;
    +function TanH(x : float) : float;
     
     { area functions }
     
     { delphi names: }
    -function arccosh(x : float) : float;inline;
    -function arcsinh(x : float) : float;inline;
    -function arctanh(x : float) : float;inline;
    +function ArcCosH(x : float) : float;inline;
    +function ArcSinH(x : float) : float;inline;
    +function ArcTanH(x : float) : float;inline;
     { IMHO the function should be called as follows (FK) }
    -function arcosh(x : float) : float;
    -function arsinh(x : float) : float;
    -function artanh(x : float) : float;
    +function ArCosH(x : float) : float;
    +function ArSinH(x : float) : float;
    +function ArTanH(x : float) : float;
     
     { triangle functions }
     
     { returns the length of the hypotenuse of a right triangle }
     { if x and y are the other sides                           }
    -function hypot(x,y : float) : float;
    +function Hypot(x,y : float) : float;
     
     { logarithm functions }
     
    -function log10(x : float) : float;
    -function log2(x : float) : float;
    -function logn(n,x : float) : float;
    +function Log10(x : float) : float;
    +function Log2(x : float) : float;
    +function LogN(n,x : float) : float;
     
     { returns natural logarithm of x+1, accurate for x values near zero }
    -function lnxp1(x : float) : float;
    +function LnXP1(x : float) : float;
     
     { exponential functions }
     
    -function power(base,exponent : float) : float;
    +function Power(base,exponent : float) : float;
     { base^exponent }
    -function intpower(base : float;const exponent : Integer) : float;
    +function IntPower(base : float;const exponent : Integer) : float;
     
     operator ** (bas,expo : float) e: float; inline;
     operator ** (bas,expo : int64) i: int64; inline;
    @@ -379,11 +379,11 @@
     { number converting }
     
     { rounds x towards positive infinity }
    -function ceil(x : float) : Integer;
    -function ceil64(x: float): Int64;
    +function Ceil(x : float) : Integer;
    +function Ceil64(x: float): Int64;
     { rounds x towards negative infinity }
    -function floor(x : float) : Integer;
    -function floor64(x: float): Int64;
    +function Floor(x : float) : Integer;
    +function Floor64(x: float): Int64;
     
     { misc. functions }
     
    @@ -390,194 +390,194 @@
     { splits x into mantissa and exponent (to base 2) }
     procedure Frexp(X: float; var Mantissa: float; var Exponent: integer);
     { returns x*(2^p) }
    -function ldexp(x : float; const p : Integer) : float;
    +function Ldexp(x : float; const p : Integer) : float;
     
     { statistical functions }
     
     {$ifdef FPC_HAS_TYPE_SINGLE}
    -function mean(const data : array of Single) : float;
    -function sum(const data : array of Single) : float;inline;
    -function mean(const data : PSingle; Const N : longint) : float;
    -function sum(const data : PSingle; Const N : Longint) : float;
    +function Mean(const data : array of Single) : float;
    +function Sum(const data : array of Single) : float;inline;
    +function Mean(const data : PSingle; Const N : longint) : float;
    +function Sum(const data : PSingle; Const N : Longint) : float;
     {$endif FPC_HAS_TYPE_SINGLE}
     
     {$ifdef FPC_HAS_TYPE_DOUBLE}
    -function mean(const data : array of double) : float;inline;
    -function sum(const data : array of double) : float;inline;
    -function mean(const data : PDouble; Const N : longint) : float;
    -function sum(const data : PDouble; Const N : Longint) : float;
    +function Mean(const data : array of double) : float;inline;
    +function Sum(const data : array of double) : float;inline;
    +function Mean(const data : PDouble; Const N : longint) : float;
    +function Sum(const data : PDouble; Const N : Longint) : float;
     {$endif FPC_HAS_TYPE_DOUBLE}
     
     {$ifdef FPC_HAS_TYPE_EXTENDED}
    -function mean(const data : array of Extended) : float;
    -function sum(const data : array of Extended) : float;inline;
    -function mean(const data : PExtended; Const N : longint) : float;
    -function sum(const data : PExtended; Const N : Longint) : float;
    +function Mean(const data : array of Extended) : float;
    +function Sum(const data : array of Extended) : float;inline;
    +function Mean(const data : PExtended; Const N : longint) : float;
    +function Sum(const data : PExtended; Const N : Longint) : float;
     {$endif FPC_HAS_TYPE_EXTENDED}
     
    -function sumInt(const data : PInt64;Const N : longint) : Int64;
    -function sumInt(const data : array of Int64) : Int64;inline;
    -function mean(const data : PInt64; const N : Longint):Float;
    -function mean(const data: array of Int64):Float;
    -function sumInt(const data : PInteger; Const N : longint) : Int64;
    -function sumInt(const data : array of Integer) : Int64;inline;
    -function mean(const data : PInteger; const N : Longint):Float;
    -function mean(const data: array of Integer):Float;
    +function SumInt(const data : PInt64;Const N : longint) : Int64;
    +function SumInt(const data : array of Int64) : Int64;inline;
    +function Mean(const data : PInt64; const N : Longint):Float;
    +function Mean(const data: array of Int64):Float;
    +function SumInt(const data : PInteger; Const N : longint) : Int64;
    +function SumInt(const data : array of Integer) : Int64;inline;
    +function Mean(const data : PInteger; const N : Longint):Float;
    +function Mean(const data: array of Integer):Float;
     
     
     {$ifdef FPC_HAS_TYPE_SINGLE}
    -function sumofsquares(const data : array of Single) : float;inline;
    -function sumofsquares(const data : PSingle; Const N : Integer) : float;
    +function SumOfSquares(const data : array of Single) : float;inline;
    +function SumOfSquares(const data : PSingle; Const N : Integer) : float;
     { calculates the sum and the sum of squares of data }
    -procedure sumsandsquares(const data : array of Single;
    +procedure SumsAndSquares(const data : array of Single;
       var sum,sumofsquares : float);inline;
    -procedure sumsandsquares(const data : PSingle; Const N : Integer;
    +procedure SumsAndSquares(const data : PSingle; Const N : Integer;
       var sum,sumofsquares : float);
     {$endif FPC_HAS_TYPE_SINGLE}
     
     {$ifdef FPC_HAS_TYPE_DOUBLE}
    -function sumofsquares(const data : array of double) : float;
    -function sumofsquares(const data : PDouble; Const N : Integer) : float;
    +function SumOfSquares(const data : array of double) : float;
    +function SumOfSquares(const data : PDouble; Const N : Integer) : float;
     { calculates the sum and the sum of squares of data }
    -procedure sumsandsquares(const data : array of Double;
    +procedure SumsAndSquares(const data : array of Double;
       var sum,sumofsquares : float);inline;
    -procedure sumsandsquares(const data : PDouble; Const N : Integer;
    +procedure SumsAndSquares(const data : PDouble; Const N : Integer;
       var sum,sumofsquares : float);
     {$endif FPC_HAS_TYPE_DOUBLE}
     
     {$ifdef FPC_HAS_TYPE_EXTENDED}
    -function sumofsquares(const data : array of Extended) : float;inline;
    -function sumofsquares(const data : PExtended; Const N : Integer) : float;
    +function SumOfSquares(const data : array of Extended) : float;inline;
    +function SumOfSquares(const data : PExtended; Const N : Integer) : float;
     { calculates the sum and the sum of squares of data }
    -procedure sumsandsquares(const data : array of Extended;
    +procedure SumsAndSquares(const data : array of Extended;
       var sum,sumofsquares : float);inline;
    -procedure sumsandsquares(const data : PExtended; Const N : Integer;
    +procedure SumsAndSquares(const data : PExtended; Const N : Integer;
       var sum,sumofsquares : float);
     {$endif FPC_HAS_TYPE_EXTENDED}
     
     {$ifdef FPC_HAS_TYPE_SINGLE}
    -function minvalue(const data : array of Single) : Single;inline;
    -function minvalue(const data : PSingle; Const N : Integer) : Single;
    -function maxvalue(const data : array of Single) : Single;inline;
    -function maxvalue(const data : PSingle; Const N : Integer) : Single;
    +function MinValue(const data : array of Single) : Single;inline;
    +function MinValue(const data : PSingle; Const N : Integer) : Single;
    +function MaxValue(const data : array of Single) : Single;inline;
    +function MaxValue(const data : PSingle; Const N : Integer) : Single;
     {$endif FPC_HAS_TYPE_SINGLE}
     
     {$ifdef FPC_HAS_TYPE_DOUBLE}
    -function minvalue(const data : array of Double) : Double;inline;
    -function minvalue(const data : PDouble; Const N : Integer) : Double;
    -function maxvalue(const data : array of Double) : Double;inline;
    -function maxvalue(const data : PDouble; Const N : Integer) : Double;
    +function MinValue(const data : array of Double) : Double;inline;
    +function MinValue(const data : PDouble; Const N : Integer) : Double;
    +function MaxValue(const data : array of Double) : Double;inline;
    +function MaxValue(const data : PDouble; Const N : Integer) : Double;
     {$endif FPC_HAS_TYPE_DOUBLE}
     
     {$ifdef FPC_HAS_TYPE_EXTENDED}
    -function minvalue(const data : array of Extended) : Extended;inline;
    -function minvalue(const data : PExtended; Const N : Integer) : Extended;
    -function maxvalue(const data : array of Extended) : Extended;inline;
    -function maxvalue(const data : PExtended; Const N : Integer) : Extended;
    +function MinValue(const data : array of Extended) : Extended;inline;
    +function MinValue(const data : PExtended; Const N : Integer) : Extended;
    +function MaxValue(const data : array of Extended) : Extended;inline;
    +function MaxValue(const data : PExtended; Const N : Integer) : Extended;
     {$endif FPC_HAS_TYPE_EXTENDED}
     
    -function minvalue(const data : array of integer) : Integer;inline;
    +function MinValue(const data : array of integer) : Integer;inline;
     function MinValue(const Data : PInteger; Const N : Integer): Integer;
     
    -function maxvalue(const data : array of integer) : Integer;inline;
    -function maxvalue(const data : PInteger; Const N : Integer) : Integer;
    +function MaxValue(const data : array of integer) : Integer;inline;
    +function MaxValue(const data : PInteger; Const N : Integer) : Integer;
     
     { returns random values with gaussian distribution }
    -function randg(mean,stddev : float) : float;
    +function RandG(mean,stddev : float) : float;
     function RandomRange(const aFrom, aTo: Integer): Integer;
     function RandomRange(const aFrom, aTo: Int64): Int64;
     
     {$ifdef FPC_HAS_TYPE_SINGLE}
     { calculates the standard deviation }
    -function stddev(const data : array of Single) : float;inline;
    -function stddev(const data : PSingle; Const N : Integer) : float;
    +function StdDev(const data : array of Single) : float;inline;
    +function StdDev(const data : PSingle; Const N : Integer) : float;
     { calculates the mean and stddev }
    -procedure meanandstddev(const data : array of Single;
    +procedure MeanAndStdDev(const data : array of Single;
       var mean,stddev : float);inline;
    -procedure meanandstddev(const data : PSingle;
    +procedure MeanAndStdDev(const data : PSingle;
       Const N : Longint;var mean,stddev : float);
    -function variance(const data : array of Single) : float;inline;
    -function totalvariance(const data : array of Single) : float;inline;
    -function variance(const data : PSingle; Const N : Integer) : float;
    -function totalvariance(const data : PSingle; Const N : Integer) : float;
    +function Variance(const data : array of Single) : float;inline;
    +function TotalVariance(const data : array of Single) : float;inline;
    +function Variance(const data : PSingle; Const N : Integer) : float;
    +function TotalVariance(const data : PSingle; Const N : Integer) : float;
     
     { Population (aka uncorrected) variance and standard deviation }
    -function popnstddev(const data : array of Single) : float;inline;
    -function popnstddev(const data : PSingle; Const N : Integer) : float;
    -function popnvariance(const data : PSingle; Const N : Integer) : float;
    -function popnvariance(const data : array of Single) : float;inline;
    -procedure momentskewkurtosis(const data : array of Single;
    +function PopnStdDev(const data : array of Single) : float;inline;
    +function PopnStdDev(const data : PSingle; Const N : Integer) : float;
    +function PopnVariance(const data : PSingle; Const N : Integer) : float;
    +function PopnVariance(const data : array of Single) : float;inline;
    +procedure MomentSkewKurtosis(const data : array of Single;
       out m1,m2,m3,m4,skew,kurtosis : float);inline;
    -procedure momentskewkurtosis(const data : PSingle; Const N : Integer;
    +procedure MomentSkewKurtosis(const data : PSingle; Const N : Integer;
       out m1,m2,m3,m4,skew,kurtosis : float);
     
     { geometrical function }
     
     { returns the euclidean L2 norm }
    -function norm(const data : array of Single) : float;inline;
    -function norm(const data : PSingle; Const N : Integer) : float;
    +function Norm(const data : array of Single) : float;inline;
    +function Norm(const data : PSingle; Const N : Integer) : float;
     {$endif FPC_HAS_TYPE_SINGLE}
     
     {$ifdef FPC_HAS_TYPE_DOUBLE}
     { calculates the standard deviation }
    -function stddev(const data : array of Double) : float;inline;
    -function stddev(const data : PDouble; Const N : Integer) : float;
    +function StdDev(const data : array of Double) : float;inline;
    +function StdDev(const data : PDouble; Const N : Integer) : float;
     { calculates the mean and stddev }
    -procedure meanandstddev(const data : array of Double;
    +procedure MeanAndStdDev(const data : array of Double;
       var mean,stddev : float);inline;
    -procedure meanandstddev(const data : PDouble;
    +procedure MeanAndStdDev(const data : PDouble;
       Const N : Longint;var mean,stddev : float);
    -function variance(const data : array of Double) : float;inline;
    -function totalvariance(const data : array of Double) : float;inline;
    -function variance(const data : PDouble; Const N : Integer) : float;
    -function totalvariance(const data : PDouble; Const N : Integer) : float;
    +function Variance(const data : array of Double) : float;inline;
    +function TotalVariance(const data : array of Double) : float;inline;
    +function Variance(const data : PDouble; Const N : Integer) : float;
    +function TotalVariance(const data : PDouble; Const N : Integer) : float;
     
     { Population (aka uncorrected) variance and standard deviation }
    -function popnstddev(const data : array of Double) : float;inline;
    -function popnstddev(const data : PDouble; Const N : Integer) : float;
    -function popnvariance(const data : PDouble; Const N : Integer) : float;
    -function popnvariance(const data : array of Double) : float;inline;
    -procedure momentskewkurtosis(const data : array of Double;
    +function PopnStdDev(const data : array of Double) : float;inline;
    +function PopnStdDev(const data : PDouble; Const N : Integer) : float;
    +function PopnVariance(const data : PDouble; Const N : Integer) : float;
    +function PopnVariance(const data : array of Double) : float;inline;
    +procedure MomentSkewKurtosis(const data : array of Double;
       out m1,m2,m3,m4,skew,kurtosis : float);inline;
    -procedure momentskewkurtosis(const data : PDouble; Const N : Integer;
    +procedure MomentSkewKurtosis(const data : PDouble; Const N : Integer;
       out m1,m2,m3,m4,skew,kurtosis : float);
     
     { geometrical function }
     
     { returns the euclidean L2 norm }
    -function norm(const data : array of double) : float;inline;
    -function norm(const data : PDouble; Const N : Integer) : float;
    +function Norm(const data : array of double) : float;inline;
    +function Norm(const data : PDouble; Const N : Integer) : float;
     {$endif FPC_HAS_TYPE_DOUBLE}
     
     {$ifdef FPC_HAS_TYPE_EXTENDED}
     { calculates the standard deviation }
    -function stddev(const data : array of Extended) : float;inline;
    -function stddev(const data : PExtended; Const N : Integer) : float;
    +function StdDev(const data : array of Extended) : float;inline;
    +function StdDev(const data : PExtended; Const N : Integer) : float;
     { calculates the mean and stddev }
    -procedure meanandstddev(const data : array of Extended;
    +procedure MeanAndStdDev(const data : array of Extended;
       var mean,stddev : float);inline;
    -procedure meanandstddev(const data : PExtended;
    +procedure MeanAndStdDev(const data : PExtended;
       Const N : Longint;var mean,stddev : float);
    -function variance(const data : array of Extended) : float;inline;
    -function totalvariance(const data : array of Extended) : float;inline;
    -function variance(const data : PExtended; Const N : Integer) : float;
    -function totalvariance(const data : PExtended; Const N : Integer) : float;
    +function Variance(const data : array of Extended) : float;inline;
    +function TotalVariance(const data : array of Extended) : float;inline;
    +function Variance(const data : PExtended; Const N : Integer) : float;
    +function TotalVariance(const data : PExtended; Const N : Integer) : float;
     
     { Population (aka uncorrected) variance and standard deviation }
    -function popnstddev(const data : array of Extended) : float;inline;
    -function popnstddev(const data : PExtended; Const N : Integer) : float;
    -function popnvariance(const data : PExtended; Const N : Integer) : float;
    -function popnvariance(const data : array of Extended) : float;inline;
    -procedure momentskewkurtosis(const data : array of Extended;
    +function PopnStdDev(const data : array of Extended) : float;inline;
    +function PopnStdDev(const data : PExtended; Const N : Integer) : float;
    +function PopnVariance(const data : PExtended; Const N : Integer) : float;
    +function PopnVariance(const data : array of Extended) : float;inline;
    +procedure MomentSkewKurtosis(const data : array of Extended;
       out m1,m2,m3,m4,skew,kurtosis : float);inline;
    -procedure momentskewkurtosis(const data : PExtended; Const N : Integer;
    +procedure MomentSkewKurtosis(const data : PExtended; Const N : Integer;
       out m1,m2,m3,m4,skew,kurtosis : float);
     
     { geometrical function }
     
     { returns the euclidean L2 norm }
    -function norm(const data : array of Extended) : float;inline;
    -function norm(const data : PExtended; Const N : Integer) : float;
    +function Norm(const data : array of Extended) : float;inline;
    +function Norm(const data : PExtended; Const N : Integer) : float;
     {$endif FPC_HAS_TYPE_EXTENDED}
     
     { Financial functions }
    @@ -599,9 +599,9 @@
     
     { Misc functions }
     
    -function ifthen(val:boolean;const iftrue:integer; const iffalse:integer= 0) :integer; inline; overload;
    -function ifthen(val:boolean;const iftrue:int64  ; const iffalse:int64 = 0)  :int64;   inline; overload;
    -function ifthen(val:boolean;const iftrue:double ; const iffalse:double =0.0):double;  inline; overload;
    +function IfThen(val:boolean;const iftrue:integer; const iffalse:integer= 0) :integer; inline; overload;
    +function IfThen(val:boolean;const iftrue:int64  ; const iffalse:int64 = 0)  :int64;   inline; overload;
    +function IfThen(val:boolean;const iftrue:double ; const iffalse:double =0.0):double;  inline; overload;
     
     function CompareValue ( const A, B  : Integer) : TValueRelationship; inline;
     function CompareValue ( const A, B  : Int64) : TValueRelationship; inline;
    
    CamelCase-2.patch (55,996 bytes)

Activities

Ondrej Pokorny

2018-03-24 10:51

developer  

CamelCase-2.patch (55,996 bytes)
Index: rtl/inc/mathh.inc
===================================================================
--- rtl/inc/mathh.inc	(revision 38616)
+++ rtl/inc/mathh.inc	(working copy)
@@ -102,19 +102,19 @@
   {$endif}
 {$endif}
 
-    function pi : ValReal;[internproc:fpc_in_pi_real];
-    function abs(d : ValReal) : ValReal;[internproc:fpc_in_abs_real];
-    function sqr(d : ValReal) : ValReal;[internproc:fpc_in_sqr_real];
-    function sqrt(d : ValReal) : ValReal;[internproc:fpc_in_sqrt_real];
-    function arctan(d : ValReal) : ValReal;[internproc:fpc_in_arctan_real];
-    function ln(d : ValReal) : ValReal;[internproc:fpc_in_ln_real];
-    function sin(d : ValReal) : ValReal;[internproc:fpc_in_sin_real];
-    function cos(d : ValReal) : ValReal;[internproc:fpc_in_cos_real];
-    function exp(d : ValReal) : ValReal;[internproc:fpc_in_exp_real];
-    function round(d : ValReal) : int64;[internproc:fpc_in_round_real];
-    function frac(d : ValReal) : ValReal;[internproc:fpc_in_frac_real];
-    function int(d : ValReal) : ValReal;[internproc:fpc_in_int_real];
-    function trunc(d : ValReal) : int64;[internproc:fpc_in_trunc_real];
+    function Pi : ValReal;[internproc:fpc_in_pi_real];
+    function Abs(d : ValReal) : ValReal;[internproc:fpc_in_abs_real];
+    function Sqr(d : ValReal) : ValReal;[internproc:fpc_in_sqr_real];
+    function Sqrt(d : ValReal) : ValReal;[internproc:fpc_in_sqrt_real];
+    function ArcTan(d : ValReal) : ValReal;[internproc:fpc_in_arctan_real];
+    function Ln(d : ValReal) : ValReal;[internproc:fpc_in_ln_real];
+    function Sin(d : ValReal) : ValReal;[internproc:fpc_in_sin_real];
+    function Cos(d : ValReal) : ValReal;[internproc:fpc_in_cos_real];
+    function Exp(d : ValReal) : ValReal;[internproc:fpc_in_exp_real];
+    function Round(d : ValReal) : int64;[internproc:fpc_in_round_real];
+    function Frac(d : ValReal) : ValReal;[internproc:fpc_in_frac_real];
+    function Int(d : ValReal) : ValReal;[internproc:fpc_in_int_real];
+    function Trunc(d : ValReal) : int64;[internproc:fpc_in_trunc_real];
 
 {$ifdef SUPPORT_EXTENDED}
     function FPower10(val: Extended; Power: Longint): Extended;
@@ -121,7 +121,7 @@
 {$endif SUPPORT_EXTENDED}
 
     type
-       real48 = array[0..5] of byte;
+       Real48 = array[0..5] of byte;
 
 {$ifdef SUPPORT_DOUBLE}
     function Real2Double(r : real48) : double;
Index: rtl/inc/systemh.inc
===================================================================
--- rtl/inc/systemh.inc	(revision 38616)
+++ rtl/inc/systemh.inc	(working copy)
@@ -557,13 +557,13 @@
 
   PNativeInt 	      = ^NativeInt;
   PNativeUInt	      = ^NativeUint;
-  pInt8   	      = PShortInt;
-  pInt16  	      = PSmallint;
-  pInt32  	      = PLongint;
+  PInt8   	      = PShortInt;
+  PInt16  	      = PSmallint;
+  PInt32  	      = PLongint;
   PIntPtr 	      = PPtrInt;
-  pUInt8  	      = PByte;
-  pUInt16 	      = PWord;
-  pUInt32 	      = PDWord;
+  PUInt8  	      = PByte;
+  PUInt16 	      = PWord;
+  PUInt32 	      = PDWord;
   PUintPtr	      = PPtrUInt;
 
   PShortString        = ^ShortString;
@@ -656,10 +656,10 @@
   MaxUIntValue = High(ValUInt);
 
 { max. values for longint and int}
-  maxLongint  = $7fffffff;
-  maxSmallint = 32767;
+  MaxLongint  = $7fffffff;
+  MaxSmallint = 32767;
 
-  maxint   = maxsmallint;
+  MaxInt   = maxsmallint;
 
 type
 {$ifdef CPU16}
@@ -698,8 +698,8 @@
 
 { Exit Procedure handling consts and types  }
   ExitProc : codepointer = nil;
-  Erroraddr: codepointer = nil;
-  Errorcode: Word    = 0;
+  ErrorAddr: codepointer = nil;
+  ErrorCode: Word    = 0;
 
 { file input modes }
   fmClosed = $D7B0;
@@ -707,7 +707,7 @@
   fmOutput = $D7B2;
   fmInOut  = $D7B3;
   fmAppend = $D7B4;
-  Filemode : byte = 2;
+  FileMode : byte = 2;
 (* Value should be changed during system initialization as appropriate. *)
 
   { assume that this program will not spawn other threads, when the
@@ -754,7 +754,7 @@
 
 {$ifndef HAS_CMDLINE}
 {Value should be changed during system initialization as appropriate.}
-var cmdline:Pchar=nil;
+var CmdLine:Pchar=nil;
 {$endif}
 
 {$ifdef FPC_HAS_FEATURE_THREADING}
@@ -822,7 +822,7 @@
 procedure MoveChar0(const buf1;var buf2;len:SizeInt);
 function  IndexChar0(const buf;len:SizeInt;b:char):SizeInt;
 function  CompareChar0(const buf1,buf2;len:SizeInt):SizeInt;
-procedure prefetch(const mem);[internproc:fpc_in_prefetch_var];
+procedure Prefetch(const mem);[internproc:fpc_in_prefetch_var];
 procedure ReadBarrier;
 procedure ReadDependencyBarrier;
 procedure ReadWriteBarrier;
@@ -836,27 +836,27 @@
                           Math Routines
 ****************************************************************************}
 
-Function  lo(B: Byte):Byte;{$ifdef SYSTEMINLINE}inline;{$endif}
-Function  hi(b : Byte) : Byte;{$ifdef SYSTEMINLINE}inline;{$endif}
-Function  lo(i : Integer) : byte;  [INTERNPROC: fpc_in_lo_Word];
-Function  lo(w : Word) : byte;     [INTERNPROC: fpc_in_lo_Word];
-Function  lo(l : Longint) : Word;  [INTERNPROC: fpc_in_lo_long];
-Function  lo(l : DWord) : Word;    [INTERNPROC: fpc_in_lo_long];
-Function  lo(i : Int64) : DWord;   [INTERNPROC: fpc_in_lo_qword];
-Function  lo(q : QWord) : DWord;   [INTERNPROC: fpc_in_lo_qword];
-Function  hi(i : Integer) : byte;  [INTERNPROC: fpc_in_hi_Word];
-Function  hi(w : Word) : byte;     [INTERNPROC: fpc_in_hi_Word];
-Function  hi(l : Longint) : Word;  [INTERNPROC: fpc_in_hi_long];
-Function  hi(l : DWord) : Word;    [INTERNPROC: fpc_in_hi_long];
-Function  hi(i : Int64) : DWord;   [INTERNPROC: fpc_in_hi_qword];
-Function  hi(q : QWord) : DWord;   [INTERNPROC: fpc_in_hi_qword];
+Function  Lo(B: Byte):Byte;{$ifdef SYSTEMINLINE}inline;{$endif}
+Function  Hi(b : Byte) : Byte;{$ifdef SYSTEMINLINE}inline;{$endif}
+Function  Lo(i : Integer) : byte;  [INTERNPROC: fpc_in_lo_Word];
+Function  Lo(w : Word) : byte;     [INTERNPROC: fpc_in_lo_Word];
+Function  Lo(l : Longint) : Word;  [INTERNPROC: fpc_in_lo_long];
+Function  Lo(l : DWord) : Word;    [INTERNPROC: fpc_in_lo_long];
+Function  Lo(i : Int64) : DWord;   [INTERNPROC: fpc_in_lo_qword];
+Function  Lo(q : QWord) : DWord;   [INTERNPROC: fpc_in_lo_qword];
+Function  Hi(i : Integer) : byte;  [INTERNPROC: fpc_in_hi_Word];
+Function  Hi(w : Word) : byte;     [INTERNPROC: fpc_in_hi_Word];
+Function  Hi(l : Longint) : Word;  [INTERNPROC: fpc_in_hi_long];
+Function  Hi(l : DWord) : Word;    [INTERNPROC: fpc_in_hi_long];
+Function  Hi(i : Int64) : DWord;   [INTERNPROC: fpc_in_hi_qword];
+Function  Hi(q : QWord) : DWord;   [INTERNPROC: fpc_in_hi_qword];
 
-Function swap (X : Word) : Word;{$ifdef SYSTEMINLINE}inline;{$endif}[internconst:fpc_in_const_swap_word];
+Function Swap (X : Word) : Word;{$ifdef SYSTEMINLINE}inline;{$endif}[internconst:fpc_in_const_swap_word];
 Function Swap (X : Integer) : Integer;{$ifdef SYSTEMINLINE}inline;{$endif}[internconst:fpc_in_const_swap_word];
-Function swap (X : Longint) : Longint;{$ifdef SYSTEMINLINE}inline;{$endif}[internconst:fpc_in_const_swap_long];
+Function Swap (X : Longint) : Longint;{$ifdef SYSTEMINLINE}inline;{$endif}[internconst:fpc_in_const_swap_long];
 Function Swap (X : Cardinal) : Cardinal;{$ifdef SYSTEMINLINE}inline;{$endif}[internconst:fpc_in_const_swap_long];
 Function Swap (X : QWord) : QWord;{$ifdef SYSTEMINLINE}inline;{$endif}[internconst:fpc_in_const_swap_qword];
-Function swap (X : Int64) : Int64;{$ifdef SYSTEMINLINE}inline;{$endif}[internconst:fpc_in_const_swap_qword];
+Function Swap (X : Int64) : Int64;{$ifdef SYSTEMINLINE}inline;{$endif}[internconst:fpc_in_const_swap_qword];
 
 Function Align (Addr : PtrUInt; Alignment : PtrUInt) : PtrUInt;{$ifdef SYSTEMINLINE}inline;{$endif}
 Function Align (Addr : Pointer; Alignment : PtrUInt) : Pointer;{$ifdef SYSTEMINLINE}inline;{$endif}
@@ -873,52 +873,52 @@
 {$if defined(CPUINT8)}
   {$ifdef FPC_HAS_INTERNAL_ABS_SHORTINT}
   {$define FPC_SYSTEM_HAS_ABS_SHORTINT}
-  Function abs(l:shortint):shortint;[internproc:fpc_in_abs_long];
+  Function Abs(l:shortint):shortint;[internproc:fpc_in_abs_long];
   {$else FPC_SYSTEM_HAS_ABS_SHORTINT}
-  Function abs(l:shortint):shortint;[internconst:fpc_in_const_abs];{$ifdef SYSTEMINLINE}inline;{$endif}
+  Function Abs(l:shortint):shortint;[internconst:fpc_in_const_abs];{$ifdef SYSTEMINLINE}inline;{$endif}
   {$endif FPC_SYSTEM_HAS_ABS_SHORTINT}
 {$endif CPUINT8}
 {$if defined(CPUINT16) or defined(CPUINT8)}
   {$ifdef FPC_HAS_INTERNAL_ABS_SMALLINT}
   {$define FPC_SYSTEM_HAS_ABS_SMALLINT}
-  Function abs(l:smallint):smallint;[internproc:fpc_in_abs_long];
+  Function Abs(l:smallint):smallint;[internproc:fpc_in_abs_long];
   {$else FPC_HAS_INTERNAL_ABS_LONG}
-  Function abs(l:smallint):smallint;[internconst:fpc_in_const_abs];{$ifdef SYSTEMINLINE}inline;{$endif}
+  Function Abs(l:smallint):smallint;[internconst:fpc_in_const_abs];{$ifdef SYSTEMINLINE}inline;{$endif}
   {$endif FPC_HAS_INTERNAL_ABS_LONG}
 {$endif CPUINT16 or CPUINT8}
 {$ifdef FPC_HAS_INTERNAL_ABS_LONG}
 {$define FPC_SYSTEM_HAS_ABS_LONGINT}
-Function abs(l:longint):longint;[internproc:fpc_in_abs_long];
+Function Abs(l:longint):longint;[internproc:fpc_in_abs_long];
 {$else FPC_HAS_INTERNAL_ABS_LONG}
-Function abs(l:Longint):Longint;[internconst:fpc_in_const_abs];{$ifdef SYSTEMINLINE}inline;{$endif}
+Function Abs(l:Longint):Longint;[internconst:fpc_in_const_abs];{$ifdef SYSTEMINLINE}inline;{$endif}
 {$endif FPC_HAS_INTERNAL_ABS_LONG}
 {$ifdef FPC_HAS_INTERNAL_ABS_INT64}
 {$define FPC_SYSTEM_HAS_ABS_INT64}
-Function abs(l:Int64):Int64;[internproc:fpc_in_abs_long];
+Function Abs(l:Int64):Int64;[internproc:fpc_in_abs_long];
 {$else FPC_HAS_INTERNAL_ABS_INT64}
-Function abs(l:Int64):Int64;[internconst:fpc_in_const_abs];{$ifdef SYSTEMINLINE}inline;{$endif}
+Function Abs(l:Int64):Int64;[internconst:fpc_in_const_abs];{$ifdef SYSTEMINLINE}inline;{$endif}
 {$endif FPC_HAS_INTERNAL_ABS_INT64}
 {$if defined(CPUINT8)}
-Function sqr(l:shortint):shortint;[internconst:fpc_in_const_sqr];{$ifdef SYSTEMINLINE}inline;{$endif}
+Function Sqr(l:shortint):shortint;[internconst:fpc_in_const_sqr];{$ifdef SYSTEMINLINE}inline;{$endif}
 {$endif CPUINT8}
 {$if defined(CPUINT16) or defined(CPUINT8)}
-Function sqr(l:smallint):smallint;[internconst:fpc_in_const_sqr];{$ifdef SYSTEMINLINE}inline;{$endif}
+Function Sqr(l:smallint):smallint;[internconst:fpc_in_const_sqr];{$ifdef SYSTEMINLINE}inline;{$endif}
 {$endif CPUINT16 or CPUINT8}
-Function sqr(l:Longint):Longint;[internconst:fpc_in_const_sqr];{$ifdef SYSTEMINLINE}inline;{$endif}
-Function sqr(l:Int64):Int64;[internconst:fpc_in_const_sqr];{$ifdef SYSTEMINLINE}inline;{$endif}
-Function sqr(l:QWord):QWord;[internconst:fpc_in_const_sqr];{$ifdef SYSTEMINLINE}inline;{$endif}
+Function Sqr(l:Longint):Longint;[internconst:fpc_in_const_sqr];{$ifdef SYSTEMINLINE}inline;{$endif}
+Function Sqr(l:Int64):Int64;[internconst:fpc_in_const_sqr];{$ifdef SYSTEMINLINE}inline;{$endif}
+Function Sqr(l:QWord):QWord;[internconst:fpc_in_const_sqr];{$ifdef SYSTEMINLINE}inline;{$endif}
 {$if defined(CPUINT8)}
-Function odd(l:shortint):Boolean;[internconst:fpc_in_const_odd];{$ifdef SYSTEMINLINE}inline;{$endif}
-Function odd(l:byte):Boolean;[internconst:fpc_in_const_odd];{$ifdef SYSTEMINLINE}inline;{$endif}
+Function Odd(l:shortint):Boolean;[internconst:fpc_in_const_odd];{$ifdef SYSTEMINLINE}inline;{$endif}
+Function Odd(l:byte):Boolean;[internconst:fpc_in_const_odd];{$ifdef SYSTEMINLINE}inline;{$endif}
 {$endif CPUINT8}
 {$if defined(CPUINT16) or defined(CPUINT8)}
-Function odd(l:smallint):Boolean;[internconst:fpc_in_const_odd];{$ifdef SYSTEMINLINE}inline;{$endif}
-Function odd(l:word):Boolean;[internconst:fpc_in_const_odd];{$ifdef SYSTEMINLINE}inline;{$endif}
+Function Odd(l:smallint):Boolean;[internconst:fpc_in_const_odd];{$ifdef SYSTEMINLINE}inline;{$endif}
+Function Odd(l:word):Boolean;[internconst:fpc_in_const_odd];{$ifdef SYSTEMINLINE}inline;{$endif}
 {$endif CPUINT16 or CPUINT8}
-Function odd(l:Longint):Boolean;[internconst:fpc_in_const_odd];{$ifdef SYSTEMINLINE}inline;{$endif}
-Function odd(l:Longword):Boolean;[internconst:fpc_in_const_odd];{$ifdef SYSTEMINLINE}inline;{$endif}
-Function odd(l:Int64):Boolean;[internconst:fpc_in_const_odd];{$ifdef SYSTEMINLINE}inline;{$endif}
-Function odd(l:QWord):Boolean;[internconst:fpc_in_const_odd];{$ifdef SYSTEMINLINE}inline;{$endif}
+Function Odd(l:Longint):Boolean;[internconst:fpc_in_const_odd];{$ifdef SYSTEMINLINE}inline;{$endif}
+Function Odd(l:Longword):Boolean;[internconst:fpc_in_const_odd];{$ifdef SYSTEMINLINE}inline;{$endif}
+Function Odd(l:Int64):Boolean;[internconst:fpc_in_const_odd];{$ifdef SYSTEMINLINE}inline;{$endif}
+Function Odd(l:QWord):Boolean;[internconst:fpc_in_const_odd];{$ifdef SYSTEMINLINE}inline;{$endif}
 
 function SwapEndian(const AValue: SmallInt): SmallInt;{$ifdef SYSTEMINLINE}inline;{$endif}
 function SwapEndian(const AValue: Word): Word;{$ifdef SYSTEMINLINE}inline;{$endif}
@@ -1161,17 +1161,17 @@
                          Addr/Pointer Handling
 ****************************************************************************}
 
-Function  ptr(sel,off:{$ifdef CPU16}Word{$else}Longint{$endif}):farpointer;[internconst:fpc_in_const_ptr];{$ifdef SYSTEMINLINE}inline;{$endif}
-Function  Cseg:Word;{$ifdef SYSTEMINLINE}inline;{$endif}
-Function  Dseg:Word;{$ifdef SYSTEMINLINE}inline;{$endif}
-Function  Sseg:Word;{$ifdef SYSTEMINLINE}inline;{$endif}
+Function  Ptr(sel,off:{$ifdef CPU16}Word{$else}Longint{$endif}):farpointer;[internconst:fpc_in_const_ptr];{$ifdef SYSTEMINLINE}inline;{$endif}
+Function  CSeg:Word;{$ifdef SYSTEMINLINE}inline;{$endif}
+Function  DSeg:Word;{$ifdef SYSTEMINLINE}inline;{$endif}
+Function  SSeg:Word;{$ifdef SYSTEMINLINE}inline;{$endif}
 
 {****************************************************************************
                       PChar and String Handling
 ****************************************************************************}
 
-function strpas(p:pchar):shortstring;{$ifdef SYSTEMINLINE}inline;{$endif}
-function strlen(p:pchar):sizeint;external name 'FPC_PCHAR_LENGTH';
+function StrPas(p:pchar):shortstring;{$ifdef SYSTEMINLINE}inline;{$endif}
+function StrLen(p:pchar):sizeint;external name 'FPC_PCHAR_LENGTH';
 
 { result:
   <0: invalid sequence detected after processing "-result" bytes
@@ -1202,37 +1202,37 @@
 {$endif FPC_HAS_FEATURE_ANSISTRINGS}
 Procedure {$ifdef FPC_HAS_CPSTRING}fpc_setstring_shortstr{$else}SetString{$endif}(out S : Shortstring; Buf : PChar; Len : SizeInt); {$ifdef FPC_HAS_CPSTRING} compilerproc; {$endif FPC_HAS_CPSTRING}
 function  ShortCompareText(const S1, S2: shortstring): SizeInt;
-Function  upCase(const s:shortstring):shortstring;
-Function  lowerCase(const s:shortstring):shortstring; overload;
+Function  UpCase(const s:shortstring):shortstring;
+Function  LowerCase(const s:shortstring):shortstring; overload;
 Function  Space(b:byte):shortstring;
-Function  hexStr(Val:Longint;cnt:byte):shortstring;
+Function  HexStr(Val:Longint;cnt:byte):shortstring;
 Function  OctStr(Val:Longint;cnt:byte):shortstring;
-Function  binStr(Val:Longint;cnt:byte):shortstring;
-Function  hexStr(Val:int64;cnt:byte):shortstring;
+Function  BinStr(Val:Longint;cnt:byte):shortstring;
+Function  HexStr(Val:int64;cnt:byte):shortstring;
 Function  OctStr(Val:int64;cnt:byte):shortstring;
-Function  binStr(Val:int64;cnt:byte):shortstring;
-Function  hexStr(Val:qword;cnt:byte):shortstring;
+Function  BinStr(Val:int64;cnt:byte):shortstring;
+Function  HexStr(Val:qword;cnt:byte):shortstring;
 Function  OctStr(Val:qword;cnt:byte):shortstring;
-Function  binStr(Val:qword;cnt:byte):shortstring;
+Function  BinStr(Val:qword;cnt:byte):shortstring;
 {$ifdef CPUI8086}
-Function  hexStr(Val:NearPointer):shortstring;
-function  hexStr(Val:NearCsPointer):shortstring;
-function  hexStr(Val:NearDsPointer):shortstring;
-function  hexStr(Val:NearEsPointer):shortstring;
-function  hexStr(Val:NearSsPointer):shortstring;
-function  hexStr(Val:NearFsPointer):shortstring;
-function  hexStr(Val:NearGsPointer):shortstring;
-Function  hexStr(Val:FarPointer):shortstring;
-Function  hexStr(Val:HugePointer):shortstring;{$ifdef SYSTEMINLINE}inline;{$endif}
+Function  HexStr(Val:NearPointer):shortstring;
+function  HexStr(Val:NearCsPointer):shortstring;
+function  HexStr(Val:NearDsPointer):shortstring;
+function  HexStr(Val:NearEsPointer):shortstring;
+function  HexStr(Val:NearSsPointer):shortstring;
+function  HexStr(Val:NearFsPointer):shortstring;
+function  HexStr(Val:NearGsPointer):shortstring;
+Function  HexStr(Val:FarPointer):shortstring;
+Function  HexStr(Val:HugePointer):shortstring;{$ifdef SYSTEMINLINE}inline;{$endif}
 {$else CPUI8086}
-Function  hexStr(Val:Pointer):shortstring;
+Function  HexStr(Val:Pointer):shortstring;
 {$endif CPUI8086}
 
 { Char functions }
-Function chr(b : byte) : Char;      [INTERNPROC: fpc_in_chr_byte];
-Function  upCase(c:Char):Char;
-Function  lowerCase(c:Char):Char; overload;
-function  pos(const substr : shortstring;c:char; Offset: Sizeint = 1): SizeInt;
+Function Chr(b : byte) : Char;      [INTERNPROC: fpc_in_chr_byte];
+Function  UpCase(c:Char):Char;
+Function  LowerCase(c:Char):Char; overload;
+function  Pos(const substr : shortstring;c:char; Offset: Sizeint = 1): SizeInt;
 
 
 {****************************************************************************
@@ -1248,8 +1248,8 @@
 Procedure Delete (var S : RawByteString; Index,Size: SizeInt);{$ifdef FPC_HAS_CPSTRING}rtlproc;{$endif FPC_HAS_CPSTRING}
 {$endif VER3_0}
 Function  StringOfChar(c : Ansichar;l : SizeInt) : AnsiString;
-function  upcase(const s : ansistring) : ansistring;
-function  lowercase(const s : ansistring) : ansistring;
+function  UpCase(const s : ansistring) : ansistring;
+function  LowerCase(const s : ansistring) : ansistring;
 
 function StringCodePage(const S : RawByteString): TSystemCodePage; overload;
 function StringElementSize(const S : RawByteString): Word; overload;
@@ -1381,22 +1381,22 @@
 ****************************************************************************}
 
 {$ifdef FPC_HAS_FEATURE_FILEIO}
-Procedure chdir(const s:shortstring); overload;
-Procedure mkdir(const s:shortstring); overload;
-Procedure rmdir(const s:shortstring); overload;
-Procedure getdir(drivenr:byte;var dir:shortstring);overload;
+Procedure ChDir(const s:shortstring); overload;
+Procedure MkDir(const s:shortstring); overload;
+Procedure RmDir(const s:shortstring); overload;
+Procedure GetDir(drivenr:byte;var dir:shortstring);overload;
 {$ifdef FPC_HAS_FEATURE_ANSISTRINGS}
-Procedure chdir(const s:rawbytestring); overload;
-Procedure mkdir(const s:rawbytestring); overload;
-Procedure rmdir(const s:rawbytestring); overload;
+Procedure ChDir(const s:rawbytestring); overload;
+Procedure MkDir(const s:rawbytestring); overload;
+Procedure RmDir(const s:rawbytestring); overload;
 // defaultrtlfilesystemcodepage is returned here
-Procedure getdir(drivenr:byte;var dir: rawbytestring);overload;{$ifdef FPC_HAS_CPSTRING}rtlproc;{$endif FPC_HAS_CPSTRING}
+Procedure GetDir(drivenr:byte;var dir: rawbytestring);overload;{$ifdef FPC_HAS_CPSTRING}rtlproc;{$endif FPC_HAS_CPSTRING}
 {$endif FPC_HAS_FEATURE_ANSISTRINGS}
 {$ifdef FPC_HAS_FEATURE_WIDESTRINGS}
-Procedure chdir(const s:unicodestring); overload;
-Procedure mkdir(const s:unicodestring); overload;
-Procedure rmdir(const s:unicodestring); overload;
-Procedure getdir(drivenr:byte;var dir: unicodestring);overload;
+Procedure ChDir(const s:unicodestring); overload;
+Procedure MkDir(const s:unicodestring); overload;
+Procedure RmDir(const s:unicodestring); overload;
+Procedure GetDir(drivenr:byte;var dir: unicodestring);overload;
 {$endif FPC_HAS_FEATURE_WIDESTRINGS}
 
 {$endif FPC_HAS_FEATURE_FILEIO}
@@ -1431,7 +1431,7 @@
 procedure get_caller_stackinfo(var framebp : pointer; var addr : codepointer);
 
 Function IOResult:Word;
-Function Sptr:Pointer;[internconst:fpc_in_const_ptr];
+Function SPtr:Pointer;[internconst:fpc_in_const_ptr];
 
 {$ifdef FPC_HAS_FEATURE_PROCESSES}
 Function GetProcessID:SizeUInt;
@@ -1445,22 +1445,22 @@
 {$endif}
 
 {$ifdef cpu16}
-function InterLockedIncrement (var Target: smallint) : smallint; public name 'FPC_INTERLOCKEDINCREMENT16';
-function InterLockedDecrement (var Target: smallint) : smallint; public name 'FPC_INTERLOCKEDDECREMENT16';
-function InterLockedExchange (var Target: smallint;Source : smallint) : smallint; public name 'FPC_INTERLOCKEDEXCHANGE16';
-function InterLockedExchangeAdd (var Target: smallint;Source : smallint) : smallint; public name 'FPC_INTERLOCKEDEXCHANGEADD16';
+function InterlockedIncrement (var Target: smallint) : smallint; public name 'FPC_INTERLOCKEDINCREMENT16';
+function InterlockedDecrement (var Target: smallint) : smallint; public name 'FPC_INTERLOCKEDDECREMENT16';
+function InterlockedExchange (var Target: smallint;Source : smallint) : smallint; public name 'FPC_INTERLOCKEDEXCHANGE16';
+function InterlockedExchangeAdd (var Target: smallint;Source : smallint) : smallint; public name 'FPC_INTERLOCKEDEXCHANGEADD16';
 function InterlockedCompareExchange(var Target: smallint; NewValue: smallint; Comperand: smallint): smallint; public name 'FPC_INTERLOCKEDCOMPAREEXCHANGE16';
 {$endif cpu16}
-function InterLockedIncrement (var Target: longint) : longint; public name 'FPC_INTERLOCKEDINCREMENT';
-function InterLockedDecrement (var Target: longint) : longint; public name 'FPC_INTERLOCKEDDECREMENT';
-function InterLockedExchange (var Target: longint;Source : longint) : longint; public name 'FPC_INTERLOCKEDEXCHANGE';
-function InterLockedExchangeAdd (var Target: longint;Source : longint) : longint; public name 'FPC_INTERLOCKEDEXCHANGEADD';
+function InterlockedIncrement (var Target: longint) : longint; public name 'FPC_INTERLOCKEDINCREMENT';
+function InterlockedDecrement (var Target: longint) : longint; public name 'FPC_INTERLOCKEDDECREMENT';
+function InterlockedExchange (var Target: longint;Source : longint) : longint; public name 'FPC_INTERLOCKEDEXCHANGE';
+function InterlockedExchangeAdd (var Target: longint;Source : longint) : longint; public name 'FPC_INTERLOCKEDEXCHANGEADD';
 function InterlockedCompareExchange(var Target: longint; NewValue: longint; Comperand: longint): longint; public name 'FPC_INTERLOCKEDCOMPAREEXCHANGE';
 {$ifdef cpu64}
-function InterLockedIncrement64 (var Target: int64) : int64; public name 'FPC_INTERLOCKEDINCREMENT64';
-function InterLockedDecrement64 (var Target: int64) : int64; public name 'FPC_INTERLOCKEDDECREMENT64';
-function InterLockedExchange64 (var Target: int64;Source : int64) : int64; public name 'FPC_INTERLOCKEDEXCHANGE64';
-function InterLockedExchangeAdd64 (var Target: int64;Source : int64) : int64; public name 'FPC_INTERLOCKEDEXCHANGEADD64';
+function InterlockedIncrement64 (var Target: int64) : int64; public name 'FPC_INTERLOCKEDINCREMENT64';
+function InterlockedDecrement64 (var Target: int64) : int64; public name 'FPC_INTERLOCKEDDECREMENT64';
+function InterlockedExchange64 (var Target: int64;Source : int64) : int64; public name 'FPC_INTERLOCKEDEXCHANGE64';
+function InterlockedExchangeAdd64 (var Target: int64;Source : int64) : int64; public name 'FPC_INTERLOCKEDEXCHANGEADD64';
 function InterlockedCompareExchange64(var Target: int64; NewValue: int64; Comperand: int64): int64; public name 'FPC_INTERLOCKEDCOMPAREEXCHANGE64';
 {$endif cpu64}
 { Pointer overloads }
@@ -1467,47 +1467,47 @@
 {$if defined(FPC_HAS_EXPLICIT_INTERLOCKED_POINTER)}
 { Note: define FPC_SYSTEM_HAS_EXPLICIT_INTERLOCKED_POINTER if the target platform defines
         these pointer overloads itself instead of using platform independant inline functions }
-function InterLockedIncrement (var Target: Pointer) : Pointer; {$ifndef FPC_SYSTEM_HAS_EXPLICIT_INTERLOCKED_POINTER}inline;{$endif}
-function InterLockedDecrement (var Target: Pointer) : Pointer; {$ifndef FPC_SYSTEM_HAS_EXPLICIT_INTERLOCKED_POINTER}inline;{$endif}
-function InterLockedExchange (var Target: Pointer;Source : Pointer) : Pointer; {$ifndef FPC_SYSTEM_HAS_EXPLICIT_INTERLOCKED_POINTER}inline;{$endif}
-function InterLockedExchangeAdd (var Target: Pointer;Source : Pointer) : Pointer; {$ifndef FPC_SYSTEM_HAS_EXPLICIT_INTERLOCKED_POINTER}inline;{$endif}
-function InterLockedCompareExchange(var Target: Pointer; NewValue: Pointer; Comperand: Pointer): Pointer;  {$ifndef FPC_SYSTEM_HAS_EXPLICIT_INTERLOCKED_POINTER}inline;{$else}public name 'FPC_INTERLOCKEDEXCHANGEPOINTER';{$endif}
+function InterlockedIncrement (var Target: Pointer) : Pointer; {$ifndef FPC_SYSTEM_HAS_EXPLICIT_INTERLOCKED_POINTER}inline;{$endif}
+function InterlockedDecrement (var Target: Pointer) : Pointer; {$ifndef FPC_SYSTEM_HAS_EXPLICIT_INTERLOCKED_POINTER}inline;{$endif}
+function InterlockedExchange (var Target: Pointer;Source : Pointer) : Pointer; {$ifndef FPC_SYSTEM_HAS_EXPLICIT_INTERLOCKED_POINTER}inline;{$endif}
+function InterlockedExchangeAdd (var Target: Pointer;Source : Pointer) : Pointer; {$ifndef FPC_SYSTEM_HAS_EXPLICIT_INTERLOCKED_POINTER}inline;{$endif}
+function InterlockedCompareExchange(var Target: Pointer; NewValue: Pointer; Comperand: Pointer): Pointer;  {$ifndef FPC_SYSTEM_HAS_EXPLICIT_INTERLOCKED_POINTER}inline;{$else}public name 'FPC_INTERLOCKEDEXCHANGEPOINTER';{$endif}
 { Note: in case of FPC_SYSTEM_HAS_EXPLICIT_INTERLOCKED_POINTER this is an alias for
-        InterLockedCompareExchange (this doesn't work with inline however) }
-function InterLockedCompareExchangePointer(var Target: Pointer; NewValue: Pointer; Comperand: Pointer): Pointer; {$ifndef FPC_INTERLOCKED_POINTER_INLINE}inline;{$else}external name 'FPC_INTERLOCKEDEXCHANGEPOINTER';{$endif}
+        InterlockedCompareExchange (this doesn't work with inline however) }
+function InterlockedCompareExchangePointer(var Target: Pointer; NewValue: Pointer; Comperand: Pointer): Pointer; {$ifndef FPC_INTERLOCKED_POINTER_INLINE}inline;{$else}external name 'FPC_INTERLOCKEDEXCHANGEPOINTER';{$endif}
 {$elseif defined(cpu64)}
-function InterLockedIncrement (var Target: Pointer) : Pointer; external name 'FPC_INTERLOCKEDINCREMENT64';
-function InterLockedDecrement (var Target: Pointer) : Pointer; external name 'FPC_INTERLOCKEDDECREMENT64';
-function InterLockedExchange (var Target: Pointer;Source : Pointer) : Pointer; external name 'FPC_INTERLOCKEDEXCHANGE64';
-function InterLockedExchangeAdd (var Target: Pointer;Source : Pointer) : Pointer; external name 'FPC_INTERLOCKEDEXCHANGEADD64';
+function InterlockedIncrement (var Target: Pointer) : Pointer; external name 'FPC_INTERLOCKEDINCREMENT64';
+function InterlockedDecrement (var Target: Pointer) : Pointer; external name 'FPC_INTERLOCKEDDECREMENT64';
+function InterlockedExchange (var Target: Pointer;Source : Pointer) : Pointer; external name 'FPC_INTERLOCKEDEXCHANGE64';
+function InterlockedExchangeAdd (var Target: Pointer;Source : Pointer) : Pointer; external name 'FPC_INTERLOCKEDEXCHANGEADD64';
 function InterlockedCompareExchange(var Target: Pointer; NewValue: Pointer; Comperand: Pointer): Pointer; external name 'FPC_INTERLOCKEDCOMPAREEXCHANGE64';
 function InterlockedCompareExchangePointer(var Target: Pointer; NewValue: Pointer; Comperand: Pointer): Pointer; external name 'FPC_INTERLOCKEDCOMPAREEXCHANGE64';
 {$else not FPC_HAS_EXPLICIT_INTERLOCKED_POINTER and not CPU64}
-function InterLockedIncrement (var Target: Pointer) : Pointer; external name 'FPC_INTERLOCKEDINCREMENT';
-function InterLockedDecrement (var Target: Pointer) : Pointer; external name 'FPC_INTERLOCKEDDECREMENT';
-function InterLockedExchange (var Target: Pointer;Source : Pointer) : Pointer; external name 'FPC_INTERLOCKEDEXCHANGE';
-function InterLockedExchangeAdd (var Target: Pointer;Source : Pointer) : Pointer; external name 'FPC_INTERLOCKEDEXCHANGEADD';
+function InterlockedIncrement (var Target: Pointer) : Pointer; external name 'FPC_INTERLOCKEDINCREMENT';
+function InterlockedDecrement (var Target: Pointer) : Pointer; external name 'FPC_INTERLOCKEDDECREMENT';
+function InterlockedExchange (var Target: Pointer;Source : Pointer) : Pointer; external name 'FPC_INTERLOCKEDEXCHANGE';
+function InterlockedExchangeAdd (var Target: Pointer;Source : Pointer) : Pointer; external name 'FPC_INTERLOCKEDEXCHANGEADD';
 function InterlockedCompareExchange(var Target: Pointer; NewValue: Pointer; Comperand: Pointer): Pointer; external name 'FPC_INTERLOCKEDCOMPAREEXCHANGE';
 function InterlockedCompareExchangePointer(var Target: Pointer; NewValue: Pointer; Comperand: Pointer): Pointer; external name 'FPC_INTERLOCKEDCOMPAREEXCHANGE';
 {$endif FPC_HAS_EXPLICIT_INTERLOCKED_POINTER / CPU64}
 { unsigned overloads }
 {$ifdef cpu16}
-function InterLockedIncrement (var Target: word) : word; external name 'FPC_INTERLOCKEDINCREMENT16';
-function InterLockedDecrement (var Target: word) : word; external name 'FPC_INTERLOCKEDDECREMENT16';
-function InterLockedExchange (var Target: word;Source : word) : word; external name 'FPC_INTERLOCKEDEXCHANGE16';
-function InterLockedExchangeAdd (var Target: word;Source : word) : word; external name 'FPC_INTERLOCKEDEXCHANGEADD16';
+function InterlockedIncrement (var Target: word) : word; external name 'FPC_INTERLOCKEDINCREMENT16';
+function InterlockedDecrement (var Target: word) : word; external name 'FPC_INTERLOCKEDDECREMENT16';
+function InterlockedExchange (var Target: word;Source : word) : word; external name 'FPC_INTERLOCKEDEXCHANGE16';
+function InterlockedExchangeAdd (var Target: word;Source : word) : word; external name 'FPC_INTERLOCKEDEXCHANGEADD16';
 function InterlockedCompareExchange(var Target: word; NewValue: word; Comperand: word): word; external name 'FPC_INTERLOCKEDCOMPAREEXCHANGE16';
 {$endif cpu16}
-function InterLockedIncrement (var Target: cardinal) : cardinal; external name 'FPC_INTERLOCKEDINCREMENT';
-function InterLockedDecrement (var Target: cardinal) : cardinal; external name 'FPC_INTERLOCKEDDECREMENT';
-function InterLockedExchange (var Target: cardinal;Source : cardinal) : cardinal; external name 'FPC_INTERLOCKEDEXCHANGE';
-function InterLockedExchangeAdd (var Target: cardinal;Source : cardinal) : cardinal; external name 'FPC_INTERLOCKEDEXCHANGEADD';
+function InterlockedIncrement (var Target: cardinal) : cardinal; external name 'FPC_INTERLOCKEDINCREMENT';
+function InterlockedDecrement (var Target: cardinal) : cardinal; external name 'FPC_INTERLOCKEDDECREMENT';
+function InterlockedExchange (var Target: cardinal;Source : cardinal) : cardinal; external name 'FPC_INTERLOCKEDEXCHANGE';
+function InterlockedExchangeAdd (var Target: cardinal;Source : cardinal) : cardinal; external name 'FPC_INTERLOCKEDEXCHANGEADD';
 function InterlockedCompareExchange(var Target: cardinal; NewValue: cardinal; Comperand: cardinal): cardinal; external name 'FPC_INTERLOCKEDCOMPAREEXCHANGE';
 {$ifdef cpu64}
-function InterLockedIncrement64 (var Target: qword) : qword; external name 'FPC_INTERLOCKEDINCREMENT64';
-function InterLockedDecrement64 (var Target: qword) : qword; external name 'FPC_INTERLOCKEDDECREMENT64';
-function InterLockedExchange64 (var Target: qword;Source : qword) : qword; external name 'FPC_INTERLOCKEDEXCHANGE64';
-function InterLockedExchangeAdd64 (var Target: qword;Source : qword) : qword; external name 'FPC_INTERLOCKEDEXCHANGEADD64';
+function InterlockedIncrement64 (var Target: qword) : qword; external name 'FPC_INTERLOCKEDINCREMENT64';
+function InterlockedDecrement64 (var Target: qword) : qword; external name 'FPC_INTERLOCKEDDECREMENT64';
+function InterlockedExchange64 (var Target: qword;Source : qword) : qword; external name 'FPC_INTERLOCKEDEXCHANGE64';
+function InterlockedExchangeAdd64 (var Target: qword;Source : qword) : qword; external name 'FPC_INTERLOCKEDEXCHANGEADD64';
 function InterlockedCompareExchange64(var Target: qword; NewValue: qword; Comperand: qword): int64; external name 'FPC_INTERLOCKEDCOMPAREEXCHANGE64';
 {$endif cpu64}
 
@@ -1546,16 +1546,16 @@
 Procedure Dump_Stack(var f : text;fp:pointer;addr : codepointer = nil);
 procedure Dump_Stack(var f : text;skipframes : longint);
 {$ifdef FPC_HAS_FEATURE_EXCEPTIONS}
-procedure DumpExceptionBackTrace(var f:text);
+procedure DumpExceptionBacktrace(var f:text);
 {$endif FPC_HAS_FEATURE_EXCEPTIONS}
 
 Procedure RunError(w:Word);noreturn;
 Procedure RunError;{$ifdef SYSTEMINLINE}inline;{$endif}noreturn;
-Procedure halt(errnum:Longint);noreturn;
+Procedure Halt(errnum:Longint);noreturn;
 {$ifdef FPC_HAS_FEATURE_HEAP}
 Procedure AddExitProc(Proc:TProcedure);
 {$endif FPC_HAS_FEATURE_HEAP}
-Procedure halt;{$ifdef SYSTEMINLINE}inline;{$endif}noreturn;
+Procedure Halt;{$ifdef SYSTEMINLINE}inline;{$endif}noreturn;
 
 { Need to be exported for threads unit }
 {$ifdef FPC_HAS_FEATURE_EXCEPTIONS}
@@ -1587,7 +1587,7 @@
 
 procedure AbstractError;external name 'FPC_ABSTRACTERROR';
 procedure EmptyMethod;external name 'FPC_EMPTYMETHOD';
-Function  SysBackTraceStr(Addr:CodePointer): ShortString;
+Function  SysBacktraceStr(Addr:CodePointer): ShortString;
 Procedure SysAssert(const Msg,FName:ShortString;LineNo:Longint;ErrorAddr:Pointer);
 (* Supposed to return address of previous CtrlBreakHandler *)
 (* (may be nil), returned value of pointer (-1) means that *)
@@ -1596,7 +1596,7 @@
 
 { Error handlers }
 Type
-  TBackTraceStrFunc = Function (Addr: CodePointer): ShortString;
+  TBacktraceStrFunc = Function (Addr: CodePointer): ShortString;
   TErrorProc = Procedure (ErrNo : Longint; Address : CodePointer; Frame : Pointer);
   TAbstractErrorProc = Procedure;
   TAssertErrorProc = Procedure(const msg,fname:ShortString;lineno:longint;erroraddr:pointer);
@@ -1604,7 +1604,7 @@
 
 
 const
-  BackTraceStrFunc  : TBackTraceStrFunc = @SysBackTraceStr;
+  BacktraceStrFunc  : TBacktraceStrFunc = @SysBacktraceStr;
   ErrorProc         : TErrorProc = nil;
   AbstractErrorProc : TAbstractErrorProc = nil;
   AssertErrorProc   : TAssertErrorProc = @SysAssert;
Index: rtl/objpas/math.pp
===================================================================
--- rtl/objpas/math.pp	(revision 38616)
+++ rtl/objpas/math.pp	(working copy)
@@ -97,7 +97,7 @@
        { break all assembler code  PM                            }
 {$if defined(FPC_HAS_TYPE_FLOAT128)}
       type
-         float = float128;
+         Float = Float128;
 
       const
          MinFloat = MinFloat128;
@@ -104,7 +104,7 @@
          MaxFloat = MaxFloat128;
 {$elseif defined(FPC_HAS_TYPE_EXTENDED)}
       type
-         float = extended;
+         Float = extended;
 
       const
          MinFloat = MinExtended;
@@ -111,7 +111,7 @@
          MaxFloat = MaxExtended;
 {$elseif defined(FPC_HAS_TYPE_DOUBLE)}
       type
-         float = double;
+         Float = double;
 
       const
          MinFloat = MinDouble;
@@ -118,7 +118,7 @@
          MaxFloat = MaxDouble;
 {$elseif defined(FPC_HAS_TYPE_SINGLE)}
       type
-         float = single;
+         Float = single;
 
       const
          MinFloat = MinSingle;
@@ -131,7 +131,7 @@
        PFloat = ^Float;
        PInteger = ObjPas.PInteger;
 
-       tpaymenttime = (ptendofperiod,ptstartofperiod);
+       TPaymentTime = (ptEndOfPeriod,ptStartOfPeriod);
 
        EInvalidArgument = class(ematherror);
 
@@ -287,15 +287,15 @@
 
 { angle conversion }
 
-function degtorad(deg : float) : float;inline;
-function radtodeg(rad : float) : float;inline;
-function gradtorad(grad : float) : float;inline;
-function radtograd(rad : float) : float;inline;
-function degtograd(deg : float) : float;inline;
-function gradtodeg(grad : float) : float;inline;
+function DegToRad(deg : float) : float;inline;
+function RadToDeg(rad : float) : float;inline;
+function GradToRad(grad : float) : float;inline;
+function RadToGrad(rad : float) : float;inline;
+function DegToGrad(deg : float) : float;inline;
+function GradToDeg(grad : float) : float;inline;
 { one cycle are 2*Pi rad }
-function cycletorad(cycle : float) : float;inline;
-function radtocycle(rad : float) : float;inline;
+function CycleToRad(cycle : float) : float;inline;
+function RadToCycle(rad : float) : float;inline;
 {$ifdef FPC_HAS_TYPE_SINGLE}
 Function DegNormalize(deg : single) : single; inline;
 {$ENDIF}
@@ -308,70 +308,70 @@
 
 { trigoniometric functions }
 
-function tan(x : float) : float;
-function cotan(x : float) : float;
-function cot(x : float) : float; inline;
+function Tan(x : float) : float;
+function Cotan(x : float) : float;
+function Cot(x : float) : float; inline;
 {$ifdef FPC_HAS_TYPE_SINGLE}
-procedure sincos(theta : single;out sinus,cosinus : single);
+procedure SinCos(theta : single;out sinus,cosinus : single);
 {$endif}
 {$ifdef FPC_HAS_TYPE_DOUBLE}
-procedure sincos(theta : double;out sinus,cosinus : double);
+procedure SinCos(theta : double;out sinus,cosinus : double);
 {$endif}
 {$ifdef FPC_HAS_TYPE_EXTENDED}
-procedure sincos(theta : extended;out sinus,cosinus : extended);
+procedure SinCos(theta : extended;out sinus,cosinus : extended);
 {$endif}
 
 
-function secant(x : float) : float; inline;
-function cosecant(x : float) : float; inline;
-function sec(x : float) : float; inline;
-function csc(x : float) : float; inline;
+function Secant(x : float) : float; inline;
+function Cosecant(x : float) : float; inline;
+function Sec(x : float) : float; inline;
+function Csc(x : float) : float; inline;
 
 { inverse functions }
 
-function arccos(x : float) : float;
-function arcsin(x : float) : float;
+function ArcCos(x : float) : float;
+function ArcSin(x : float) : float;
 
 { calculates arctan(y/x) and returns an angle in the correct quadrant }
-function arctan2(y,x : float) : float;
+function ArcTan2(y,x : float) : float;
 
 { hyperbolic functions }
 
-function cosh(x : float) : float;
-function sinh(x : float) : float;
-function tanh(x : float) : float;
+function CosH(x : float) : float;
+function SinH(x : float) : float;
+function TanH(x : float) : float;
 
 { area functions }
 
 { delphi names: }
-function arccosh(x : float) : float;inline;
-function arcsinh(x : float) : float;inline;
-function arctanh(x : float) : float;inline;
+function ArcCosH(x : float) : float;inline;
+function ArcSinH(x : float) : float;inline;
+function ArcTanH(x : float) : float;inline;
 { IMHO the function should be called as follows (FK) }
-function arcosh(x : float) : float;
-function arsinh(x : float) : float;
-function artanh(x : float) : float;
+function ArCosH(x : float) : float;
+function ArSinH(x : float) : float;
+function ArTanH(x : float) : float;
 
 { triangle functions }
 
 { returns the length of the hypotenuse of a right triangle }
 { if x and y are the other sides                           }
-function hypot(x,y : float) : float;
+function Hypot(x,y : float) : float;
 
 { logarithm functions }
 
-function log10(x : float) : float;
-function log2(x : float) : float;
-function logn(n,x : float) : float;
+function Log10(x : float) : float;
+function Log2(x : float) : float;
+function LogN(n,x : float) : float;
 
 { returns natural logarithm of x+1, accurate for x values near zero }
-function lnxp1(x : float) : float;
+function LnXP1(x : float) : float;
 
 { exponential functions }
 
-function power(base,exponent : float) : float;
+function Power(base,exponent : float) : float;
 { base^exponent }
-function intpower(base : float;const exponent : Integer) : float;
+function IntPower(base : float;const exponent : Integer) : float;
 
 operator ** (bas,expo : float) e: float; inline;
 operator ** (bas,expo : int64) i: int64; inline;
@@ -379,11 +379,11 @@
 { number converting }
 
 { rounds x towards positive infinity }
-function ceil(x : float) : Integer;
-function ceil64(x: float): Int64;
+function Ceil(x : float) : Integer;
+function Ceil64(x: float): Int64;
 { rounds x towards negative infinity }
-function floor(x : float) : Integer;
-function floor64(x: float): Int64;
+function Floor(x : float) : Integer;
+function Floor64(x: float): Int64;
 
 { misc. functions }
 
@@ -390,194 +390,194 @@
 { splits x into mantissa and exponent (to base 2) }
 procedure Frexp(X: float; var Mantissa: float; var Exponent: integer);
 { returns x*(2^p) }
-function ldexp(x : float; const p : Integer) : float;
+function Ldexp(x : float; const p : Integer) : float;
 
 { statistical functions }
 
 {$ifdef FPC_HAS_TYPE_SINGLE}
-function mean(const data : array of Single) : float;
-function sum(const data : array of Single) : float;inline;
-function mean(const data : PSingle; Const N : longint) : float;
-function sum(const data : PSingle; Const N : Longint) : float;
+function Mean(const data : array of Single) : float;
+function Sum(const data : array of Single) : float;inline;
+function Mean(const data : PSingle; Const N : longint) : float;
+function Sum(const data : PSingle; Const N : Longint) : float;
 {$endif FPC_HAS_TYPE_SINGLE}
 
 {$ifdef FPC_HAS_TYPE_DOUBLE}
-function mean(const data : array of double) : float;inline;
-function sum(const data : array of double) : float;inline;
-function mean(const data : PDouble; Const N : longint) : float;
-function sum(const data : PDouble; Const N : Longint) : float;
+function Mean(const data : array of double) : float;inline;
+function Sum(const data : array of double) : float;inline;
+function Mean(const data : PDouble; Const N : longint) : float;
+function Sum(const data : PDouble; Const N : Longint) : float;
 {$endif FPC_HAS_TYPE_DOUBLE}
 
 {$ifdef FPC_HAS_TYPE_EXTENDED}
-function mean(const data : array of Extended) : float;
-function sum(const data : array of Extended) : float;inline;
-function mean(const data : PExtended; Const N : longint) : float;
-function sum(const data : PExtended; Const N : Longint) : float;
+function Mean(const data : array of Extended) : float;
+function Sum(const data : array of Extended) : float;inline;
+function Mean(const data : PExtended; Const N : longint) : float;
+function Sum(const data : PExtended; Const N : Longint) : float;
 {$endif FPC_HAS_TYPE_EXTENDED}
 
-function sumInt(const data : PInt64;Const N : longint) : Int64;
-function sumInt(const data : array of Int64) : Int64;inline;
-function mean(const data : PInt64; const N : Longint):Float;
-function mean(const data: array of Int64):Float;
-function sumInt(const data : PInteger; Const N : longint) : Int64;
-function sumInt(const data : array of Integer) : Int64;inline;
-function mean(const data : PInteger; const N : Longint):Float;
-function mean(const data: array of Integer):Float;
+function SumInt(const data : PInt64;Const N : longint) : Int64;
+function SumInt(const data : array of Int64) : Int64;inline;
+function Mean(const data : PInt64; const N : Longint):Float;
+function Mean(const data: array of Int64):Float;
+function SumInt(const data : PInteger; Const N : longint) : Int64;
+function SumInt(const data : array of Integer) : Int64;inline;
+function Mean(const data : PInteger; const N : Longint):Float;
+function Mean(const data: array of Integer):Float;
 
 
 {$ifdef FPC_HAS_TYPE_SINGLE}
-function sumofsquares(const data : array of Single) : float;inline;
-function sumofsquares(const data : PSingle; Const N : Integer) : float;
+function SumOfSquares(const data : array of Single) : float;inline;
+function SumOfSquares(const data : PSingle; Const N : Integer) : float;
 { calculates the sum and the sum of squares of data }
-procedure sumsandsquares(const data : array of Single;
+procedure SumsAndSquares(const data : array of Single;
   var sum,sumofsquares : float);inline;
-procedure sumsandsquares(const data : PSingle; Const N : Integer;
+procedure SumsAndSquares(const data : PSingle; Const N : Integer;
   var sum,sumofsquares : float);
 {$endif FPC_HAS_TYPE_SINGLE}
 
 {$ifdef FPC_HAS_TYPE_DOUBLE}
-function sumofsquares(const data : array of double) : float;
-function sumofsquares(const data : PDouble; Const N : Integer) : float;
+function SumOfSquares(const data : array of double) : float;
+function SumOfSquares(const data : PDouble; Const N : Integer) : float;
 { calculates the sum and the sum of squares of data }
-procedure sumsandsquares(const data : array of Double;
+procedure SumsAndSquares(const data : array of Double;
   var sum,sumofsquares : float);inline;
-procedure sumsandsquares(const data : PDouble; Const N : Integer;
+procedure SumsAndSquares(const data : PDouble; Const N : Integer;
   var sum,sumofsquares : float);
 {$endif FPC_HAS_TYPE_DOUBLE}
 
 {$ifdef FPC_HAS_TYPE_EXTENDED}
-function sumofsquares(const data : array of Extended) : float;inline;
-function sumofsquares(const data : PExtended; Const N : Integer) : float;
+function SumOfSquares(const data : array of Extended) : float;inline;
+function SumOfSquares(const data : PExtended; Const N : Integer) : float;
 { calculates the sum and the sum of squares of data }
-procedure sumsandsquares(const data : array of Extended;
+procedure SumsAndSquares(const data : array of Extended;
   var sum,sumofsquares : float);inline;
-procedure sumsandsquares(const data : PExtended; Const N : Integer;
+procedure SumsAndSquares(const data : PExtended; Const N : Integer;
   var sum,sumofsquares : float);
 {$endif FPC_HAS_TYPE_EXTENDED}
 
 {$ifdef FPC_HAS_TYPE_SINGLE}
-function minvalue(const data : array of Single) : Single;inline;
-function minvalue(const data : PSingle; Const N : Integer) : Single;
-function maxvalue(const data : array of Single) : Single;inline;
-function maxvalue(const data : PSingle; Const N : Integer) : Single;
+function MinValue(const data : array of Single) : Single;inline;
+function MinValue(const data : PSingle; Const N : Integer) : Single;
+function MaxValue(const data : array of Single) : Single;inline;
+function MaxValue(const data : PSingle; Const N : Integer) : Single;
 {$endif FPC_HAS_TYPE_SINGLE}
 
 {$ifdef FPC_HAS_TYPE_DOUBLE}
-function minvalue(const data : array of Double) : Double;inline;
-function minvalue(const data : PDouble; Const N : Integer) : Double;
-function maxvalue(const data : array of Double) : Double;inline;
-function maxvalue(const data : PDouble; Const N : Integer) : Double;
+function MinValue(const data : array of Double) : Double;inline;
+function MinValue(const data : PDouble; Const N : Integer) : Double;
+function MaxValue(const data : array of Double) : Double;inline;
+function MaxValue(const data : PDouble; Const N : Integer) : Double;
 {$endif FPC_HAS_TYPE_DOUBLE}
 
 {$ifdef FPC_HAS_TYPE_EXTENDED}
-function minvalue(const data : array of Extended) : Extended;inline;
-function minvalue(const data : PExtended; Const N : Integer) : Extended;
-function maxvalue(const data : array of Extended) : Extended;inline;
-function maxvalue(const data : PExtended; Const N : Integer) : Extended;
+function MinValue(const data : array of Extended) : Extended;inline;
+function MinValue(const data : PExtended; Const N : Integer) : Extended;
+function MaxValue(const data : array of Extended) : Extended;inline;
+function MaxValue(const data : PExtended; Const N : Integer) : Extended;
 {$endif FPC_HAS_TYPE_EXTENDED}
 
-function minvalue(const data : array of integer) : Integer;inline;
+function MinValue(const data : array of integer) : Integer;inline;
 function MinValue(const Data : PInteger; Const N : Integer): Integer;
 
-function maxvalue(const data : array of integer) : Integer;inline;
-function maxvalue(const data : PInteger; Const N : Integer) : Integer;
+function MaxValue(const data : array of integer) : Integer;inline;
+function MaxValue(const data : PInteger; Const N : Integer) : Integer;
 
 { returns random values with gaussian distribution }
-function randg(mean,stddev : float) : float;
+function RandG(mean,stddev : float) : float;
 function RandomRange(const aFrom, aTo: Integer): Integer;
 function RandomRange(const aFrom, aTo: Int64): Int64;
 
 {$ifdef FPC_HAS_TYPE_SINGLE}
 { calculates the standard deviation }
-function stddev(const data : array of Single) : float;inline;
-function stddev(const data : PSingle; Const N : Integer) : float;
+function StdDev(const data : array of Single) : float;inline;
+function StdDev(const data : PSingle; Const N : Integer) : float;
 { calculates the mean and stddev }
-procedure meanandstddev(const data : array of Single;
+procedure MeanAndStdDev(const data : array of Single;
   var mean,stddev : float);inline;
-procedure meanandstddev(const data : PSingle;
+procedure MeanAndStdDev(const data : PSingle;
   Const N : Longint;var mean,stddev : float);
-function variance(const data : array of Single) : float;inline;
-function totalvariance(const data : array of Single) : float;inline;
-function variance(const data : PSingle; Const N : Integer) : float;
-function totalvariance(const data : PSingle; Const N : Integer) : float;
+function Variance(const data : array of Single) : float;inline;
+function TotalVariance(const data : array of Single) : float;inline;
+function Variance(const data : PSingle; Const N : Integer) : float;
+function TotalVariance(const data : PSingle; Const N : Integer) : float;
 
 { Population (aka uncorrected) variance and standard deviation }
-function popnstddev(const data : array of Single) : float;inline;
-function popnstddev(const data : PSingle; Const N : Integer) : float;
-function popnvariance(const data : PSingle; Const N : Integer) : float;
-function popnvariance(const data : array of Single) : float;inline;
-procedure momentskewkurtosis(const data : array of Single;
+function PopnStdDev(const data : array of Single) : float;inline;
+function PopnStdDev(const data : PSingle; Const N : Integer) : float;
+function PopnVariance(const data : PSingle; Const N : Integer) : float;
+function PopnVariance(const data : array of Single) : float;inline;
+procedure MomentSkewKurtosis(const data : array of Single;
   out m1,m2,m3,m4,skew,kurtosis : float);inline;
-procedure momentskewkurtosis(const data : PSingle; Const N : Integer;
+procedure MomentSkewKurtosis(const data : PSingle; Const N : Integer;
   out m1,m2,m3,m4,skew,kurtosis : float);
 
 { geometrical function }
 
 { returns the euclidean L2 norm }
-function norm(const data : array of Single) : float;inline;
-function norm(const data : PSingle; Const N : Integer) : float;
+function Norm(const data : array of Single) : float;inline;
+function Norm(const data : PSingle; Const N : Integer) : float;
 {$endif FPC_HAS_TYPE_SINGLE}
 
 {$ifdef FPC_HAS_TYPE_DOUBLE}
 { calculates the standard deviation }
-function stddev(const data : array of Double) : float;inline;
-function stddev(const data : PDouble; Const N : Integer) : float;
+function StdDev(const data : array of Double) : float;inline;
+function StdDev(const data : PDouble; Const N : Integer) : float;
 { calculates the mean and stddev }
-procedure meanandstddev(const data : array of Double;
+procedure MeanAndStdDev(const data : array of Double;
   var mean,stddev : float);inline;
-procedure meanandstddev(const data : PDouble;
+procedure MeanAndStdDev(const data : PDouble;
   Const N : Longint;var mean,stddev : float);
-function variance(const data : array of Double) : float;inline;
-function totalvariance(const data : array of Double) : float;inline;
-function variance(const data : PDouble; Const N : Integer) : float;
-function totalvariance(const data : PDouble; Const N : Integer) : float;
+function Variance(const data : array of Double) : float;inline;
+function TotalVariance(const data : array of Double) : float;inline;
+function Variance(const data : PDouble; Const N : Integer) : float;
+function TotalVariance(const data : PDouble; Const N : Integer) : float;
 
 { Population (aka uncorrected) variance and standard deviation }
-function popnstddev(const data : array of Double) : float;inline;
-function popnstddev(const data : PDouble; Const N : Integer) : float;
-function popnvariance(const data : PDouble; Const N : Integer) : float;
-function popnvariance(const data : array of Double) : float;inline;
-procedure momentskewkurtosis(const data : array of Double;
+function PopnStdDev(const data : array of Double) : float;inline;
+function PopnStdDev(const data : PDouble; Const N : Integer) : float;
+function PopnVariance(const data : PDouble; Const N : Integer) : float;
+function PopnVariance(const data : array of Double) : float;inline;
+procedure MomentSkewKurtosis(const data : array of Double;
   out m1,m2,m3,m4,skew,kurtosis : float);inline;
-procedure momentskewkurtosis(const data : PDouble; Const N : Integer;
+procedure MomentSkewKurtosis(const data : PDouble; Const N : Integer;
   out m1,m2,m3,m4,skew,kurtosis : float);
 
 { geometrical function }
 
 { returns the euclidean L2 norm }
-function norm(const data : array of double) : float;inline;
-function norm(const data : PDouble; Const N : Integer) : float;
+function Norm(const data : array of double) : float;inline;
+function Norm(const data : PDouble; Const N : Integer) : float;
 {$endif FPC_HAS_TYPE_DOUBLE}
 
 {$ifdef FPC_HAS_TYPE_EXTENDED}
 { calculates the standard deviation }
-function stddev(const data : array of Extended) : float;inline;
-function stddev(const data : PExtended; Const N : Integer) : float;
+function StdDev(const data : array of Extended) : float;inline;
+function StdDev(const data : PExtended; Const N : Integer) : float;
 { calculates the mean and stddev }
-procedure meanandstddev(const data : array of Extended;
+procedure MeanAndStdDev(const data : array of Extended;
   var mean,stddev : float);inline;
-procedure meanandstddev(const data : PExtended;
+procedure MeanAndStdDev(const data : PExtended;
   Const N : Longint;var mean,stddev : float);
-function variance(const data : array of Extended) : float;inline;
-function totalvariance(const data : array of Extended) : float;inline;
-function variance(const data : PExtended; Const N : Integer) : float;
-function totalvariance(const data : PExtended; Const N : Integer) : float;
+function Variance(const data : array of Extended) : float;inline;
+function TotalVariance(const data : array of Extended) : float;inline;
+function Variance(const data : PExtended; Const N : Integer) : float;
+function TotalVariance(const data : PExtended; Const N : Integer) : float;
 
 { Population (aka uncorrected) variance and standard deviation }
-function popnstddev(const data : array of Extended) : float;inline;
-function popnstddev(const data : PExtended; Const N : Integer) : float;
-function popnvariance(const data : PExtended; Const N : Integer) : float;
-function popnvariance(const data : array of Extended) : float;inline;
-procedure momentskewkurtosis(const data : array of Extended;
+function PopnStdDev(const data : array of Extended) : float;inline;
+function PopnStdDev(const data : PExtended; Const N : Integer) : float;
+function PopnVariance(const data : PExtended; Const N : Integer) : float;
+function PopnVariance(const data : array of Extended) : float;inline;
+procedure MomentSkewKurtosis(const data : array of Extended;
   out m1,m2,m3,m4,skew,kurtosis : float);inline;
-procedure momentskewkurtosis(const data : PExtended; Const N : Integer;
+procedure MomentSkewKurtosis(const data : PExtended; Const N : Integer;
   out m1,m2,m3,m4,skew,kurtosis : float);
 
 { geometrical function }
 
 { returns the euclidean L2 norm }
-function norm(const data : array of Extended) : float;inline;
-function norm(const data : PExtended; Const N : Integer) : float;
+function Norm(const data : array of Extended) : float;inline;
+function Norm(const data : PExtended; Const N : Integer) : float;
 {$endif FPC_HAS_TYPE_EXTENDED}
 
 { Financial functions }
@@ -599,9 +599,9 @@
 
 { Misc functions }
 
-function ifthen(val:boolean;const iftrue:integer; const iffalse:integer= 0) :integer; inline; overload;
-function ifthen(val:boolean;const iftrue:int64  ; const iffalse:int64 = 0)  :int64;   inline; overload;
-function ifthen(val:boolean;const iftrue:double ; const iffalse:double =0.0):double;  inline; overload;
+function IfThen(val:boolean;const iftrue:integer; const iffalse:integer= 0) :integer; inline; overload;
+function IfThen(val:boolean;const iftrue:int64  ; const iffalse:int64 = 0)  :int64;   inline; overload;
+function IfThen(val:boolean;const iftrue:double ; const iffalse:double =0.0):double;  inline; overload;
 
 function CompareValue ( const A, B  : Integer) : TValueRelationship; inline;
 function CompareValue ( const A, B  : Int64) : TValueRelationship; inline;
CamelCase-2.patch (55,996 bytes)

Michael Van Canneyt

2018-03-24 15:40

administrator   ~0107393

Checked and applied, thank you very much !

Ondrej Pokorny

2018-03-25 11:25

developer   ~0107403

Thank you!

Issue History

Date Modified Username Field Change
2018-03-24 10:51 Ondrej Pokorny New Issue
2018-03-24 10:51 Ondrej Pokorny File Added: CamelCase-2.patch
2018-03-24 10:51 Ondrej Pokorny Project Lazarus => FPC
2018-03-24 15:36 Michael Van Canneyt Assigned To => Michael Van Canneyt
2018-03-24 15:36 Michael Van Canneyt Status new => assigned
2018-03-24 15:40 Michael Van Canneyt Fixed in Revision => 38619
2018-03-24 15:40 Michael Van Canneyt Note Added: 0107393
2018-03-24 15:40 Michael Van Canneyt Status assigned => resolved
2018-03-24 15:40 Michael Van Canneyt Fixed in Version => 3.1.1
2018-03-24 15:40 Michael Van Canneyt Resolution open => fixed
2018-03-24 15:40 Michael Van Canneyt Target Version => 3.2.0
2018-03-25 11:25 Ondrej Pokorny Note Added: 0107403
2018-03-25 11:25 Ondrej Pokorny Status resolved => closed