To all of you out there waiting with bated breath for D.NET, you may now
breathe a little easier knowing that the project is finally making some
headway. As of this moment, the following code compiles and runs perfectly:
------------------------- main.d -------------------------
pragma(DdotNET_Assembly, "DCorLib");
pragma(DdotNET_Module, "DCorLib");
import test; // an assembly written in C# containing a class,
// TestClass, with two public static methods:
// PrintInt(Int32 i)
// PrintString(string s)
void main()
{
int i = 50;
TestClass.PrintInt(i);
i += 25;
TestClass.PrintInt(i);
i = i / 3;
TestClass.PrintInt(i);
System.String s;
s = "test string";
TestClass.PrintString(s);
System.Console.WriteLine("Internal: {0}",
cast(System.Object)(s));
return;
}
-------------------------- end --------------------------
Rest assured, the pragma names will be changed to something a little
less verbose later on, and the System.Object cast will shortly become
implicit (as will boxing, I hope)
A few things to note:
1. Since the .NET CLR supports global variables and functions, it's not
necessary to wrap everything in classes ala C#
2. The import statement has been modified so that if it doesn't find a D
module, it looks for assemblies.
3. The compiler automatically imports mscorlib, and all classes
automatically derive from [mscorlib]System.Object
While this is promising, it's far from being very useful and there's
still a long way to go before I can even offer an alpha release, but I
just wanted to let the community know that the foundation is there and
the rest should progress much more quickly.
-Deja

Sounds like you're progressing well.
I wonder, down the line, how well we may be able to map DTL containers to .NET
ones. But that's a chat months away. :-)
Keep up the good work.
"Deja Augustine" <deja scratch-ware.net> wrote in message
news:cehhj8$1iiv$1 digitaldaemon.com...

To all of you out there waiting with bated breath for D.NET, you may now
breathe a little easier knowing that the project is finally making some
headway. As of this moment, the following code compiles and runs perfectly:
------------------------- main.d -------------------------
pragma(DdotNET_Assembly, "DCorLib");
pragma(DdotNET_Module, "DCorLib");
import test; // an assembly written in C# containing a class,
// TestClass, with two public static methods:
// PrintInt(Int32 i)
// PrintString(string s)
void main()
{
int i = 50;
TestClass.PrintInt(i);
i += 25;
TestClass.PrintInt(i);
i = i / 3;
TestClass.PrintInt(i);
System.String s;
s = "test string";
TestClass.PrintString(s);
System.Console.WriteLine("Internal: {0}",
cast(System.Object)(s));
return;
}
-------------------------- end --------------------------
Rest assured, the pragma names will be changed to something a little
less verbose later on, and the System.Object cast will shortly become
implicit (as will boxing, I hope)
A few things to note:
1. Since the .NET CLR supports global variables and functions, it's not
necessary to wrap everything in classes ala C#
2. The import statement has been modified so that if it doesn't find a D
module, it looks for assemblies.
3. The compiler automatically imports mscorlib, and all classes
automatically derive from [mscorlib]System.Object
While this is promising, it's far from being very useful and there's
still a long way to go before I can even offer an alpha release, but I
just wanted to let the community know that the foundation is there and
the rest should progress much more quickly.
-Deja

This is Great! When this is done, C# users won't have an excuse not to
use D ;)
Deja Augustine wrote:

To all of you out there waiting with bated breath for D.NET, you may
now breathe a little easier knowing that the project is finally making
some headway. As of this moment, the following code compiles and runs
perfectly:
------------------------- main.d -------------------------
pragma(DdotNET_Assembly, "DCorLib");
pragma(DdotNET_Module, "DCorLib");
import test; // an assembly written in C# containing a class,
// TestClass, with two public static methods:
// PrintInt(Int32 i)
// PrintString(string s)
void main()
{
int i = 50;
TestClass.PrintInt(i);
i += 25;
TestClass.PrintInt(i);
i = i / 3;
TestClass.PrintInt(i);
System.String s;
s = "test string";
TestClass.PrintString(s);
System.Console.WriteLine("Internal: {0}",
cast(System.Object)(s));
return;
}
-------------------------- end --------------------------
Rest assured, the pragma names will be changed to something a little
less verbose later on, and the System.Object cast will shortly become
implicit (as will boxing, I hope)
A few things to note:
1. Since the .NET CLR supports global variables and functions, it's
not necessary to wrap everything in classes ala C#
2. The import statement has been modified so that if it doesn't find a
D module, it looks for assemblies.
3. The compiler automatically imports mscorlib, and all classes
automatically derive from [mscorlib]System.Object
While this is promising, it's far from being very useful and there's
still a long way to go before I can even offer an alpha release, but I
just wanted to let the community know that the foundation is there and
the rest should progress much more quickly.
-Deja