Delphi compatibility

[Janusz]

Hi,
I wrote a program in CodeTyphon (based on Free Pascal). Now I need to use Delphi instruction AtomicIncrement.
Is there possiblity to use Free Pascal function named AtomicIncrement.
I know there is something like this :

{ delphi compatibility aliases }
function AtomicIncrement (var Target: Int64) : Int64; overload; external name

maybe is is dll ?

I know that is not fair to ask about it but it impossible for me to change CodeTyphon to Lazarus 😥
Janusz

[marcov]

This is not known to us. Codetyphon is very in-transparent, and we don't know if it is possible to upgrade FPC there yourself.

You could ask on their forum and/or if they plan to release a version with updated trunk

[Fibonacci]

https://www.freepascal.org/daily/doc/rtl/system/interlockedincrement.html

[Janusz]

Hi,
Thank you for an answer.
I need to simulate function with UInt64 argument, too.

I got and information that  there is unit (?) in FP written for compatibility with Delphi :
Here is example :

$IFDEF FPC}
{ delphi compatibility aliases }
function AtomicIncrement (var Target: Int64) : Int64; overload; external name 'FPC_INTERLOCKEDINCREMENT';
function AtomicIncrement (var Target: Int64; Value: Int64) : Int64; overload; external name 'FPC_INTERLOCKEDINCREMENT'; 

Where I can find this ?
Maybe it is dll ?

Janusz
                         

[cdbc]

Hi
"AtomicIncrement()" is a builtin in FPC.
I can just type this in a form's eventhandler "Result:= AtomicIncrement(someQWord);"
edit: Sorry, my bad, the aliases / overloads are implemented in fpc 3.3.1 and I just checked fpc 3.2.2, where they're not   :'(
edit2: just put this:

Code: Pascal  [Select][+][-]

1. { delphi compatibility aliases }
2. function AtomicIncrement (var Target: int64): int64; external name 'FPC_INTERLOCKEDINCREMENT';
3. function AtomicIncrement (var Target: QWord): QWord; external name 'FPC_INTERLOCKEDINCREMENT';

in the top of your unit, then it works in fpc 3.2.2 too
These aliases are courtesey of @Thaddy, I directly lifted them from GitLab
Regards Benny

[Thaddy]

Although that is possible, these are also already exposed in the system unit as:
InterlockedIncrement, InterlockedIncrement64 and InterlockedDecrement, InterlockedDecrement64.
See:
https://www.freepascal.org/docs-html/rtl/system/interlockedincrement.html
and family.
But indeed, that also needs an alias to be declared. And the way you do it should work too.

[marcov]

But CodeTyphon afaik uses trunk

[Thaddy]

Indeed these atomic aliases are added in trunk.

[cdbc]

Hi
@Thaddy: Yup, in 2021 by you Thaddy 
If you read the 2 edits in my post above, youl'll see, that I directly lifted them from your discussion with @PascalDragon in GitLab... 
Regards Benny

[Thaddy]

Forgot. 
It did not make it to 3.2.2, but maybe it is in 3.2.3 fixes.
(After all it is a fix for Delphi compatibility and as patches go, very trivial.)

[paule32]

is in the new version operator overloading supported in Delphi mode ?

[Thaddy]

Yes:

Code: Pascal  [Select][+][-]

1. {$mode delphi}{$macro on}
2. { delphi compatibility aliases }
3. {$if fpc_fullversion < 30301}
4. function AtomicIncrement (var Target: integer): integer;overload; external name 'FPC_INTERLOCKEDINCREMENT';
5. function AtomicIncrement (var Target: int64): int64;overload; external name 'FPC_INTERLOCKEDINCREMENT';
6. function AtomicIncrement (var Target: QWord): QWord;overload; external name 'FPC_INTERLOCKEDINCREMENT';
7. // a lot more
8. {$ifend}
9. var
10.  i:integer = 0;
11. begin
12.   AtomicIncrement(i);
13.   writeln(i);
14. end.

[paule32]

sorry for misunderstanding.
I mean:
operator + (const LValue: Integer; const RValue: Integer): Integer;

[Thaddy]

yes, freestanding operators like that are supported in {$mode Delphi}, but note that Delphi itself does not have that feature. It is FreePascal specific. You put your operators in a separate unit, compile that in {$mode objfpc}. You can then use that unit in a program or other unit in {$mode delphi}
However, your example will not work and fail with "impossible overload" because there is already a compiler intrinsic with the same signature.
Quick example that will work:

Code: Pascal  [Select][+][-]

1. unit ops;
2. {$mode objfpc}{$H+}
3. // this unit must be compiled in objfpc mode
4. interface
5. operator +(const left:string ; const right:integer):string;
6.  
7. implementation
8. operator +(const left:string ;  const right:integer):string;
9. begin
10.    writestr(Result, left,right);
11. end;
12. end.

You can subsequently use it in delphi mode like so:

Code: Pascal  [Select][+][-]

1. {$mode delphi}{$H+}
2. uses ops;
3. var
4.   a:string = 'test';
5.   b:integer = 0;
6. begin
7.   writeln(a+b);// prints 'test0'
8. end.

Maybe there is a {$Modeswitch xxx}to add it to {$mode delphi} but I either forgot or there isn't any..

[PascalDragon]

sorry for misunderstanding.
I mean:
operator + (const LValue: Integer; const RValue: Integer): Integer;

It is not allowed to overload operators that have a built-in implementation.