Christophe de Dinechin wrote:

> Ouch, please don't call LX an "alternative" to D. I would not spend so much time in this forum if I saw things as black and white :-) Choice is good. And just to clarify, LX has been ported to BeOS, and a Windows port is under way (although I did not hear back... Hmmm)
>
> Christophe
>

Sorry for my misunderstanding.

John

Walter wrote:
> Good points. One thought might be to make the front end "open source", not
> gpl. Then, encourage people to make a seperate GPL version, using the open
> source version as a sort of reference manual. I get a lot of flak for making
> implementation ease a priority <g>, but this is one reason why.
> 
> -Walter
...


Here's another alternative:  If you release a GPL version, there's nothing that prevents you from also releasing a version with your license on it.  It only prevents other people from doing that.  You can use whatever other licenses you like.

And then there's the MPL (Mozilla) and the QPL (TrollTech).  True, TrollTech had some problems getting their license accepted, but it was eventually.

Still, gcc may require GPL.  And if so, then it's the dual-license choice that is feasible for the plans that you mention.  If you choose to do this, then you would need to get any contributors to assign their copyrights to you, to enable the licensing of compatible versions both as GPL and as whatever license you choose.

I ran across another solution.

Have D write an intermediate file out in some simple generic language. Write a front end for gcc that compiles the generic language. There's some effort this way already (the C-- project).


Charles Hixson wrote in message <3B817012.3010606@earthlink.net>...
>Walter wrote:
>> Good points. One thought might be to make the front end "open source",
not
>> gpl. Then, encourage people to make a seperate GPL version, using the
open
>> source version as a sort of reference manual. I get a lot of flak for
making
>> implementation ease a priority <g>, but this is one reason why.
>>
>> -Walter
>...
>
>
>Here's another alternative:  If you release a GPL version, there's nothing that prevents you from also releasing a version with your license on it.  It only prevents other people from doing that.  You can use whatever other licenses you like.
>
>And then there's the MPL (Mozilla) and the QPL (TrollTech).  True,
>TrollTech had some problems getting their license accepted, but it was
>eventually.
>
>Still, gcc may require GPL.  And if so, then it's the dual-license choice that is feasible for the plans that you mention.  If you choose to do this, then you would need to get any contributors to assign their copyrights to you, to enable the licensing of compatible versions both as GPL and as whatever license you choose.
>
>

> (the C-- project).

Wooohhaaaaa!!!!
Isn't that M$ Visual C--???

"Walter" <walter@digitalmars.com> wrote:

> I ran across another solution.
>
> Have D write an intermediate file out in some simple generic language.
Write
> a front end for gcc that compiles the generic language. There's some
effort
> this way already (the C-- project).

Doesn't this make source level debugging difficult (or impossible)?

I've had an integrated debugger for as long as I've been programming.  Not having one is a definite dealbreaker for me.

I don't know how those command line people do it, but I know it's not for me.

Angus Graham

> Have D write an intermediate file out in some simple generic language. Write a front end for gcc that compiles the generic language. There's some effort this way already (the C-- project).

Now for simplicity let's call that that intermediate format, "C" :o)))

Well I know that many other systems like word processor have a common sharing format (ie. .rtf), CAD systems have something similar (.dxf) etc.

But to my knowledge there is no generic (as all other generics, ascii based) format for object files/project tree's. Having such would simplify the coders world in odd situation (like this), however making a good format (and integrating it in example in gcc to be read- and writeable) is a nice project for itself.

- Axel

Not impossible. You could add the debug info to the generic language. -Walter

Angus Graham wrote in message <9lsm4a$1j7m$1@digitaldaemon.com>...
>"Walter" <walter@digitalmars.com> wrote:
>
>> I ran across another solution.
>>
>> Have D write an intermediate file out in some simple generic language.
>Write
>> a front end for gcc that compiles the generic language. There's some
>effort
>> this way already (the C-- project).
>
>Doesn't this make source level debugging difficult (or impossible)?
>
>I've had an integrated debugger for as long as I've been programming.  Not having one is a definite dealbreaker for me.
>
>I don't know how those command line people do it, but I know it's not for me.
>
>Angus Graham
>
>

Back when the compiler was multi-pass, that's just what it did.


Axel Kittenberger wrote in message <9lsq2d$1lol$1@digitaldaemon.com>... But to my knowledge there is no generic (as all other generics, ascii based) format for object files/project tree's. Having such would simplify the coders world in odd situation (like this), however making a good format (and integrating it in example in gcc to be read- and writeable) is a nice project for itself.

- Axel

Walter wrote:

> Not impossible. You could add the debug info to the generic language. -Walter

Not even impossible if the intermediate is C. I just say #file and #line :o)

However investigating variables in the debugger will not work, if there is some additional name mangling applied on them :(

> Back when the compiler was multi-pass, that's just what it did.

Huh? I'm confused, gcc? Gcc has an intermediate language (RTL) however it's never written to disk, and according to the docentation it's not even really possibly.

I think a major step forward in computing would be not to let the compilers generate native object code, but some intermediate register language. There linker could be allowed to do far improved optimizations, as it could in example scrap unused functions of the image, or is allowed to realize other cross-file depencies.

However as I realize such a thing is beyond this particular project :o) It would in majority go about a new gcc backend/target, and a complety new linker with integrated post-compiler/final-optimizer that creates final imagines of this intermediate format.

Might be possible that such efforts exists already, however at the GNU I
didn't yet hear about it. However from what I understood this one of the
key features microsofts tries to archieve with their.net efforts.
I just hope the OpenSource world doesn't oversleep this tech.

. Axel