On 03/04/2021 11:01 PM, DLearner wrote:
> 'Testmain' imports module 'testmod'.
> Both are shown below.
> I expected 1,1,2,2.
> I got 1,0,2,1 - which speaks to scope/extern misunderstanding
> 
> Any ideas?
> Best regards
> 
> Testmain:
> 
> int xvar;

TLS variable with D mangling, not a c global.

> import testmod;
> void main() {
>    import std.stdio;
> 
>    writeln("Entering: main");
>    xvar = 1;
>    writeln("xvar=", xvar);
>    testsub();
>    writeln("xvar=", xvar);
> 
>    writeln("Leaving: main");
> }
> 
> Testmod:
> 
> void testsub() {
> 
>    extern(D) int xvar;

That is a regular variable.
Setting the calling convention/mangling like that doesn't make any sense and shouldn't be allowed in context.

>    import std.stdio;
> 
>    writeln("Entering: testsub");
>    writeln("xvar=", xvar);
>    xvar = 2;
>    writeln("xvar=", xvar);
>    writeln("Leaving: testsub");
> }
> 

On Saturday, 3 April 2021 at 10:05:45 UTC, rikki cattermole wrote:
> On 03/04/2021 11:01 PM, DLearner wrote:
>> [...]
>
> TLS variable with D mangling, not a c global.
>
>>  [...]
>
> That is a regular variable.
> Setting the calling convention/mangling like that doesn't make any sense and shouldn't be allowed in context.
>
>> [...]

> TLS variable with D mangling, not a c global.
Does this mean D has no equivalent of C globals?
What is the D way of doing this?

On 03/04/2021 11:17 PM, DLearner wrote:
> On Saturday, 3 April 2021 at 10:05:45 UTC, rikki cattermole wrote:
>> On 03/04/2021 11:01 PM, DLearner wrote:
>>> [...]
>>
>> TLS variable with D mangling, not a c global.
>>
>>>  [...]
>>
>> That is a regular variable.
>> Setting the calling convention/mangling like that doesn't make any sense and shouldn't be allowed in context.
>>
>>> [...]
> 
>> TLS variable with D mangling, not a c global.
> Does this mean D has no equivalent of C globals?
> What is the D way of doing this?

https://dlang.org/spec/attribute.html#gshared

However, you should be using the module system for accessing globals, rather than redeclaring them.

Tried the following, same result (1,0,2,1):
testmain:
__gshared int xvar;
import testmod;

void main() {
   import std.stdio;

   writeln("Entering: main");
   xvar = 1;
   writeln("xvar=", xvar);
   testsub();
   writeln("xvar=", xvar);

   writeln("Leaving: main");
}

testmod:
void testsub() {
   __gshared int xvar;

   import std.stdio;

   writeln("Entering: testsub");
   writeln("xvar=", xvar);
   xvar = 2;
   writeln("xvar=", xvar);
   writeln("Leaving: testsub");
}

> https://dlang.org/spec/attribute.html#gshared
>
> However, you should be using the module system for accessing globals, rather than redeclaring them.

If the module system is dumped, and evrything put into one file, works perfectly.
With or without __gshared in from of 'int xvar'.

int xvar;
void main() {
   import std.stdio;

   writeln("Entering: main");
   xvar = 1;
   writeln("xvar=", xvar);
   testsub();
   writeln("xvar=", xvar);

   writeln("Leaving: main");
}

void testsub() {
   import std.stdio;

   writeln("Entering: testsub");
   writeln("xvar=", xvar);
   xvar = 2;
   writeln("xvar=", xvar);
   writeln("Leaving: testsub");
}

--- main.d
module main;

extern(C) __gshared int foo;

import std;
void main()
{
    import foo : func;
    func;

    writeln(foo);
}

--- foo.d
module foo;
extern extern(C) __gshared int foo;

void func() {
    foo++;
}

The __gshared is irrelevant to it working between modules, but it is relevant if you want C compatibility between threads (NOTE: extern(C) sets mangling, otherwise the module would be encoded in its name).

> The __gshared is irrelevant to it working between modules, but it is relevant if you want C compatibility between threads (NOTE: extern(C) sets mangling, otherwise the module would be encoded in its name).
Solved:
The following produces the expected result.
However, changing extern(C) to extern(D) causes linker failures.
To me, that is bizarre.
Testmain:
extern(C) int xvar;
import testmod;
void main() {
   import std.stdio;

   writeln("Entering: main");
   xvar = 1;
   writeln("xvar=", xvar);
   testsub();
   writeln("xvar=", xvar);

   writeln("Leaving: main");
}

Testmod:
extern extern(C) int xvar;
void testsub() {

   import std.stdio;

   writeln("Entering: testsub");
   writeln("xvar=", xvar);
   xvar = 2;
   writeln("xvar=", xvar);
   writeln("Leaving: testsub");
}