• Deja Augustine (13/13) Jul 11 2004 I don't know if anyone else has started working on this or not, but I'm
• Walter (6/11) Jul 11 2004 to
• Stephan Wienczny (3/22) Jul 12 2004 Have you seen my probject (dcc) on dsource.org? We should talk about it!
• David Barrett (6/9) Jul 12 2004 What I'd really like is an IDE whose debugger can understand D structure...
• Novice Student (4/17) Jul 16 2004 Goodday fellows!
• Andy Friesen (5/20) Jul 16 2004 Due to the nature of the CIL, it would take more effort not to. ;)
• Deja Augustine (22/42) Jul 17 2004 Indeed, though that is on my to-do list.
• Ivan Senji (16/62) Jul 19 2004 compatible
• Deja Augustine (12/30) Jul 19 2004 Yes, this has already been brought up to me and I realized the ambiguity...

Deja Augustine <Deja_member pathlink.com> writes:

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

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.

"Walter" <newshound digitalmars.com> writes:

"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!

Stephan Wienczny <Stephan Wienczny.de> writes:

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

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

"David Barrett" <dbarrett quinthar.com> writes:

"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

Novice Student <Novice_member pathlink.com> writes:

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

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?

Andy Friesen <andy ikagames.com> writes:

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

Deja Augustine <Deja_member pathlink.com> writes:

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

"Ivan Senji" <ivan.senji public.srce.hr> writes:

"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

Deja Augustine <deja scratch-ware.net> writes:

 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