Wow nice!

How do you generate the compile-time view?

Saaa wrote:
> How do you generate the compile-time view? 

Since Descent has a Java port of the DMD frontend inside, it probably just runs the semantics passes on the AST and prints it back out...

Reply to Ary,

> Ary Borenszweig wrote:
> 
>> The Descent plugin for Eclipse provides an IDE for writing, launching
>> and debugging code in D.
>> 
>> Explanations on how to get it from within Eclipse are here:
>> 
>> http://www.dsource.org/projects/descent
>> 
>> New features:
>> - Compile-time view (Window -> Show View -> Other -> D ->
>> Compile-time
>> View): allows you to see things from the compiler point of view,
>> which
>
> Here's the video!
> 
> http://www.youtube.com/watch?v=oAhrFQVnsrY
> 


Oh Goody! Oh Goody! Oh Goody! Oh Goody! 

I can't wait to try it with dparse:  http://www.dsource.org/projects/scrapple/browser/trunk/dparser

OTOH last I checked I couldn't even edit it without that kind of stuff.

On Wed, Jan 28, 2009 at 12:46 AM, Ary Borenszweig <ary@esperanto.org.ar> wrote:
>
> Here's the video!
>
> http://www.youtube.com/watch?v=oAhrFQVnsrY
>
> :-)
>

The compile-time view looks quite useful!
I also really like the autocomplete code snippet for the opApply.  I
always dread having to write those.

--bb

Jarrett Billingsley wrote:
> On Tue, Jan 27, 2009 at 10:46 AM, Ary Borenszweig <ary@esperanto.org.ar> wrote:
>> Here's the video!
>>
>> http://www.youtube.com/watch?v=oAhrFQVnsrY
> 
> I kind of just exploded a little watching that.  Some of my brain is coming out.

loool!!

And here's the winner phrase for my MSN status of the day. :-)

Daniel Keep wrote:
[snip]
>
> I've never been big on IDEs; I never felt that they had enough
> advantages over a plain text editor to make up for the slowness and
> restrictions.
>
> But this is just so freaking awesome, I'm seriously considering moving
> over to Descent for my D development.  It's just a pity I can't have my
> Vim editing commands, too :P
>
>   -- Daniel

who said you can't? here's how you can have both:

eclipse (descnet is a plugin of it) has three default key mappings that can be used:
 - the default eclipse key bindings
 - emacs key-bindings
 - vim key bindings

besides that there's also a plugin that implements vim for eclipse, which I forgot it's name. you can google for it, I guess. the plugin integrates vim's text editing capabilities into an eclipse editor.
I didn't try the plugin with D code, but for C/C++ it works great.

Which kind of optimizations are located in the front-end? Not the -O ones, right?

> Saaa wrote:
>> How do you generate the compile-time view?
>
> Since Descent has a Java port of the DMD frontend inside, it probably just runs the semantics passes on the AST and prints it back out...

Saaa wrote:
> Which kind of optimizations are located in the front-end?
> Not the -O ones, right?

Which ones are the -O ones? You can see which optimizations are applied in the front end in optimize.c

For example this:

---
int foo(int x) {
  return x * 2 * 2;
}

int bar(int x) {
  return 2 * 2 * x;
}
---

is transformed to this:

---
int foo(int x) {
  return x * 2 * 2;
}

int bar(int x) {
  return 4 * x;
}
---

So it seems the optimize.c code just optimizes left subexpressions. I wonder if -O does more that. Because if not, there's still a lof of room for optimization in the compiler.

Where can I find a version of obj2asm for Windows to see what's going on in those cases?

> 
>> Saaa wrote:
>>> How do you generate the compile-time view?
>> Since Descent has a Java port of the DMD frontend inside, it probably just runs the semantics passes on the AST and prints it back out... 
> 
> 

> Which ones are the -O ones?
Erm, the ones I invoke with -O :)
I thought they were seperate from the semantic pass van Bommel mentioned

> You can see which optimizations are applied in the front end in optimize.c
Thanks!

>
> For example this:
>
> ---
> int foo(int x) {
>   return x * 2 * 2;
> }
>
> int bar(int x) {
>   return 2 * 2 * x;
> }
> ---
>
> is transformed to this:
>
> ---
> int foo(int x) {
>   return x * 2 * 2;
> }
>
> int bar(int x) {
>   return 4 * x;
> }
> ---
>
> So it seems the optimize.c code just optimizes left subexpressions. I wonder if -O does more that. Because if not, there's still a lof of room for optimization in the compiler.
wow...

>
> Where can I find a version of obj2asm for Windows to see what's going on in those cases?
I think it is in here:
http://www.digitalmars.com/eup.html
When is your birthday? :D

The code is compatible to both. Currently trying with D1. The function becomes this:

public static char[] mixinLuaRegisterFunction(char[] lua_state, char[] name,
		char[] lua_library_dot_name)
{
	return ("mixin (mixinLuaRegisterFunctionAtLine (\"" ~ lua_state ~ "\", \"" ~ name ~ "\", \"" ~ lua_library_dot_name ~ "\", __LINE__));");
}

Furthermore the function is defined in another module and imported. mixin is used in the main module.