I don't know if anyone else has started working on this or not, but I'm currently writing a DMD backend to generate the MSIL for a .NET compatible assembly using the D language.

Since the project was just started a couple days ago, there's not yet much to show, but I felt it might be useful to let people know that it's in the works.

While I can by no means guarentee that all of D's functionality will be portable, I still hope that the vast majority of the features that make D stand apart from languages such as C/++/# and Java will be able to be harnessed within the framework of the .NET architecture.

Right now, I have no plans to port Phobos as most, if not all, of the functionality provided by it is already available via .NET

Please feel free to send any feedback to deja@scratch-ware.net or to post as a reply here.

"Deja Augustine" <Deja_member@pathlink.com> wrote in message news:cct8vj$ft9$1@digitaldaemon.com...
> I don't know if anyone else has started working on this or not, but I'm currently writing a DMD backend to generate the MSIL for a .NET compatible assembly using the D language.
>
> Since the project was just started a couple days ago, there's not yet much
to
> show, but I felt it might be useful to let people know that it's in the
works.

There's a book "Compiling for the .NET Common Language Runtime (CLR)" by John Gough that looks like a good resource for this project. Good luck!

Deja Augustine wrote:
> I don't know if anyone else has started working on this or not, but I'm
> currently writing a DMD backend to generate the MSIL for a .NET compatible
> assembly using the D language.
> 
> Since the project was just started a couple days ago, there's not yet much to
> show, but I felt it might be useful to let people know that it's in the works.
> 
> While I can by no means guarentee that all of D's functionality will be
> portable, I still hope that the vast majority of the features that make D stand
> apart from languages such as C/++/# and Java will be able to be harnessed within
> the framework of the .NET architecture.
> 
> Right now, I have no plans to port Phobos as most, if not all, of the
> functionality provided by it is already available via .NET
> 
> Please feel free to send any feedback to deja@scratch-ware.net or to post as a
> reply here.
> 
> 
Have you seen my probject (dcc) on dsource.org? We should talk about it!

Stephan

"Deja Augustine" <Deja_member@pathlink.com> wrote in message news:cct8vj$ft9$1@digitaldaemon.com...
> I don't know if anyone else has started working on this or not, but I'm currently writing a DMD backend to generate the MSIL for a .NET compatible assembly using the D language.

What I'd really like is an IDE whose debugger can understand D structures. Will your DMD back-end be able to "watch" and otherwise debug D structures/classes?

-david

In article <cct8vj$ft9$1@digitaldaemon.com>, Deja Augustine says...
>
>I don't know if anyone else has started working on this or not, but I'm currently writing a DMD backend to generate the MSIL for a .NET compatible assembly using the D language.
>
>Since the project was just started a couple days ago, there's not yet much to show, but I felt it might be useful to let people know that it's in the works.
>
>While I can by no means guarentee that all of D's functionality will be portable, I still hope that the vast majority of the features that make D stand apart from languages such as C/++/# and Java will be able to be harnessed within the framework of the .NET architecture.
>
>Right now, I have no plans to port Phobos as most, if not all, of the functionality provided by it is already available via .NET
>
>Please feel free to send any feedback to deja@scratch-ware.net or to post as a reply here.
>
>

Goodday fellows!
Great Step mr.Deja !
Will D.Net be interoperable with Mono or Portable.Net in future?

Novice Student wrote:
> In article <cct8vj$ft9$1@digitaldaemon.com>, Deja Augustine says...
> 
>>I don't know if anyone else has started working on this or not, but I'm
>>currently writing a DMD backend to generate the MSIL for a .NET compatible
>>assembly using the D language.
>>
>>Right now, I have no plans to port Phobos as most, if not all, of the
>>functionality provided by it is already available via .NET
>>
>>Please feel free to send any feedback to deja@scratch-ware.net or to post as a
>>reply here.
> 
> Goodday fellows!
> Great Step mr.Deja ! Will D.Net be interoperable with Mono or Portable.Net in future?

Due to the nature of the CIL, it would take more effort not to. ;)

The real hat trick (relatively speaking) will be making it interoperate with native D.

 -- andy

In article <cd9n15$npr$1@digitaldaemon.com>, Andy Friesen says...
>
>Novice Student wrote:
>> In article <cct8vj$ft9$1@digitaldaemon.com>, Deja Augustine says...
>> 
>>>I don't know if anyone else has started working on this or not, but I'm currently writing a DMD backend to generate the MSIL for a .NET compatible assembly using the D language.
>>>
>>>Right now, I have no plans to port Phobos as most, if not all, of the functionality provided by it is already available via .NET
>>>
>>>Please feel free to send any feedback to deja@scratch-ware.net or to post as a reply here.
>> 
>> Goodday fellows!
>> Great Step mr.Deja !
>> Will D.Net be interoperable with Mono or Portable.Net in future?
>
>Due to the nature of the CIL, it would take more effort not to. ;)
>
>The real hat trick (relatively speaking) will be making it interoperate with native D.
>
>  -- andy

Indeed, though that is on my to-do list.

A current update for all interested parties:

I have a basic MSIL generator backend written that so far is able to basic constructs such as methods, members, standard operators, typecasting, etc.

It currently can generate MSIL for relatively simple classes, though I have yet to try anything very complex.

Classes derive from [mscorlib]System.Object now instead of Phobos's Object class, but that is merely to maintain IL compatibility.  What I may eventually do, in order to provide proper D<->.NET communication is to port the requisite parts of Phobos over to .NET

Right now, the assembly manifest information is generated through a set of pragma statements, the two most important ones being DdotNET_Assembly and DdotNET_Module to define the assembly and module names.

While a lot of progress has been made, there's still a long way to go, but I was pleased to find that the majority of types ported directly over, the only restriction being that any types that are more than 8-bytes in size are cast down to 64-bit precision.  Also, char[] are converted directly to the IL string type.

I hope that by my next progress report, I'll at least have something to play with.

-Deja

"Deja Augustine" <Deja_member@pathlink.com> wrote in message news:cdcrti$1uaa$1@digitaldaemon.com...
> In article <cd9n15$npr$1@digitaldaemon.com>, Andy Friesen says...
> >
> >Novice Student wrote:
> >> In article <cct8vj$ft9$1@digitaldaemon.com>, Deja Augustine says...
> >>
> >>>I don't know if anyone else has started working on this or not, but I'm currently writing a DMD backend to generate the MSIL for a .NET
compatible
> >>>assembly using the D language.
> >>>
> >>>Right now, I have no plans to port Phobos as most, if not all, of the functionality provided by it is already available via .NET
> >>>
> >>>Please feel free to send any feedback to deja@scratch-ware.net or to
post as a
> >>>reply here.
> >>
> >> Goodday fellows!
> >> Great Step mr.Deja !
> >> Will D.Net be interoperable with Mono or Portable.Net in future?
> >
> >Due to the nature of the CIL, it would take more effort not to. ;)
> >
> >The real hat trick (relatively speaking) will be making it interoperate
> >with native D.
> >
> >  -- andy
>
> Indeed, though that is on my to-do list.
>
> A current update for all interested parties:
>
> I have a basic MSIL generator backend written that so far is able to basic constructs such as methods, members, standard operators, typecasting, etc.
>
> It currently can generate MSIL for relatively simple classes, though I
have yet
> to try anything very complex.
>
> Classes derive from [mscorlib]System.Object now instead of Phobos's Object class, but that is merely to maintain IL compatibility.  What I may
eventually
> do, in order to provide proper D<->.NET communication is to port the
requisite
> parts of Phobos over to .NET
>
> Right now, the assembly manifest information is generated through a set of pragma statements, the two most important ones being DdotNET_Assembly and DdotNET_Module to define the assembly and module names.
>
> While a lot of progress has been made, there's still a long way to go, but
I was
> pleased to find that the majority of types ported directly over, the only restriction being that any types that are more than 8-bytes in size are
cast
> down to 64-bit precision.  Also, char[] are converted directly to the IL
string
> type.

Are you sure about that? Aren't .NET strings imutable? In D you can
slice a string and then assign to that slice, will things like that be
possible?
And what about wchar[] and dchar[]?

> I hope that by my next progress report, I'll at least have something to
play
> with.

Looking forward to that!

> -Deja
>
>

> I was
> 
>>pleased to find that the majority of types ported directly over, the only
>>restriction being that any types that are more than 8-bytes in size are
> 
> cast
> 
>>down to 64-bit precision.  Also, char[] are converted directly to the IL
> 
> string
> 
>>type.
> 
> 
> Are you sure about that? Aren't .NET strings imutable? In D you can
> slice a string and then assign to that slice, will things like that be
> possible?
> And what about wchar[] and dchar[]?

Yes, this has already been brought up to me and I realized the ambiguity in my statement.  .NET only supports, to my knowledge, wchar and char. dchar will be cast down to wchar, and all such castings will be well documented when the program is released.  As far as the char[] to System::String bit, character arrays are treated as arrays but are implicitly converted, by the compiler, to System::Strings as needed.

I'm currently working on importing .NET assemblies into the symbol table   for the compiler so that you will be able to declare System::Strings explicitly as well.

I'm not quite sure how it'll all work out, yet, but I should know within a couple weeks.

-Deja