DMD 1.005 release

[Yauheni Akhotnikau]

On Thu, 08 Feb 2007 10:08:29 +0300, Walter Bright  
<newshound at digitalmars.com> wrote:

> Yauheni Akhotnikau wrote:
>> I'm use Ruby a lot and much metaprogramming things done via creating  
>> strings with Ruby code and evaluating it by various 'eval' methods. It  
>> is very simple method -- easy in writting, debugging and testing. And  
>> there isn't two different Ruby -- only one language.
>
> That's possible because Ruby is interpreted - its compilation  
> environment is also the execution environment.
>
> But D is a statically compiled language, so there's a distinction  
> between a compile time variable, and a runtime variable.

Yes, I undertand that. But that is my point: in Ruby there are three steps:
1) use ordinal Ruby code to produce string with another ordinal Ruby code;
2) translation of string with ordinal Ruby code into bytecode;
3) run of bytecode.

In D we now have steps 2) and 3) implemented: step 2) is a compilation  
phase. The question is: how to perform step 1)?

If it is necessary to use special constructs to build strings with ordinal  
D code then I will prefer to use pre-compile-time generation with help of  
external tools.

For example, in last four years I have used home-made serialization  
framework for C++. It requires special description of serializable type in  
special Data Definition Language, like this:

{type {extensible}	handshake_t
   {attr	m_version {of oess_1::uint_t}}
   {attr	m_client_id {of std::string}}

   {extension
     {attr  m_signature
        {of signature_setup_t}
        {default {c++ signature_setup_t()}}
     }
     {attr  m_compression
        {of compression_setup_t}
        {default {c++ compression_setup_t()}}
     }

     {extension
        {attr m_traits
           {stl-map {key oess_1::int_t}}
           {of handshake_trait_shptr_t}
           {default {c++ std::map< int, handshake_trait_shptr_t >()}
               {present_if {c++ m_traits.size()}}
           }
        }
     }
   }
}

The library for parsing such s-expression is about 7K lines in C++ and  
2.5K lines in Ruby. Comparable size it will have in D. But, if I want to  
use such DDL as DSL in mixin expression I must write two version of  
s-expression parsing -- for run-time and compile-time :(

But if I can use ordinal D code at compile time then the situation is much  
better.

-- 
Regards,
Yauheni Akhotnikau