In the past 10 motnhs, I completly rewrote the D Compiler in C#!

Motivations:
- LOVE THE D LANGUAGE!!
- To be fully able to develop in a VS.NET like environment using D, with no limmitations.

Cons:
- Requires Windows platforms (XP and above).
- Requires P4+ CPU.
- 2-4 times slower compiler (still need to be optimized).
- No "_Identifier" allowed! (I hate that _ s##t!)
- Removed "auto" types.
- Removed some data types.
- No documentation available :(

Pros:
- Faster overall application execution speed.
   - Tested against existing benchmarks.
- Implemented full debug functionality.
   - No more creapy asm stuff.
   - View/Modify ALL datatypes without any limitations or hassles.
- Complete 128 bit ints/reals
   - Added Custom 256 bit ints/reals. (...who's gonna use it anyway?)
- Dynamic keywords:
   - For example:
      - Can rename "else if" to ElseIf etc.
      - Can rename "{}" code block indicators to Begin/End etc.
   - Remain compatible with any older/newer "keyword set".
   - Can basically change keywords to adopt your style.
- Includes "event handler" functionality
- Includes dynamic binary modules (.ddbm)
   - Can automaticaly optimize itself on a target environment.
      - Can restructure its own code pattern (32/64/Multi-CPU)
      - Can physically relocate itself.
      - Can defrag itself in memory/disk.
   - Magnitudes faster then normal DLLs.
   - Can bind/execute across networks.
   - Can be initiated from a remote machine.
   - Includes full security features.
- Includes pre-set configuration templates:
   - Custom Mode
   - Console Mode (exe)
   - Windows Mode (exe)
   - GL Mode (exe)
   - Library Mode (dll)
   - Dynamic Binary Module Mode (ddbm)
   - Windows Service Mode (exe)
   - Device Driver Mode (drv/sys)
- Includes Code Convertion Utility (from C# to D).

Tech info:
- Parse the code into XML using Regular Expressions.
   - More code optimization is now possible.
- Replaced the backend with HLA.
   - Code > HLA > OBJ > EXE/DLL
- Removed GC, ...don't need it.
   - Variables allocate/deallocate themselfs.
   - Manual allocation/deallocation still possible.
- Package/Module now require code block indicators
   - package somepackage.somewhere
     {
        module somemodule
        {
           ....
           module deep.beneath
           {
              ....
           }
           ....
        }

        module another.module
        {
           ....
        }
     }
   - More than one module per file is now possible.
- Added inline HLA
   - Can now use asm{} or hla{}
- Changed property syntax (similar to C#)
   - int something
     {
        get { return somevariable; }
        set { somevariable = value; }
     }
- Renamed "mixin" to "macro"
- Removed "imaginary" and "complex" types.
- Changed/Added Types
   * ubyte > byte
   * byte > sbyte
   * char > compiler options determine which type to use (1/2/4 bytes)
   * short > short/int16
   * ushort > ushort/uint16
   * int > int/int32
   * uint > uint/uint32
   * long > long/int63
   * ulong > ulong/uint64
   * float > float/single/real32
   * double > double/real64
   + int128/decimal
   + uint128/udecimal
   + int256
   + uint256
   + real128
   + real256
   + string > compiler options determine which type to use (1/2 bytes)
   + date/time/datetime

In Progress:
- "native" .NET framework.

Plan for the Future:
- "VS.NET-like" IDE.
- "true" Generic functionality.

Sorry...
NO CODE OR BINARIES INCLUDED WITH THIS MESSAGE! (yet)

Baas

Any plans for release?

It looks like you made many language changes according to personal style preferences...

Baas Wrote:

> In the past 10 motnhs, I completly rewrote the D Compiler in C#!
> 
> Motivations:
> - LOVE THE D LANGUAGE!!
> - To be fully able to develop in a VS.NET like environment using D, with no limmitations.
> 
> Cons:
> - Requires Windows platforms (XP and above).
> - Requires P4+ CPU.
> - 2-4 times slower compiler (still need to be optimized).
> - No "_Identifier" allowed! (I hate that _ s##t!)
> - Removed "auto" types.
> - Removed some data types.
> - No documentation available :(
> 
> Pros:
> - Faster overall application execution speed.
>    - Tested against existing benchmarks.
> - Implemented full debug functionality.
>    - No more creapy asm stuff.
>    - View/Modify ALL datatypes without any limitations or hassles.
> - Complete 128 bit ints/reals
>    - Added Custom 256 bit ints/reals. (...who's gonna use it anyway?)
> - Dynamic keywords:
>    - For example:
>       - Can rename "else if" to ElseIf etc.
>       - Can rename "{}" code block indicators to Begin/End etc.
>    - Remain compatible with any older/newer "keyword set".
>    - Can basically change keywords to adopt your style.
> - Includes "event handler" functionality
> - Includes dynamic binary modules (.ddbm)
>    - Can automaticaly optimize itself on a target environment.
>       - Can restructure its own code pattern (32/64/Multi-CPU)
>       - Can physically relocate itself.
>       - Can defrag itself in memory/disk.
>    - Magnitudes faster then normal DLLs.
>    - Can bind/execute across networks.
>    - Can be initiated from a remote machine.
>    - Includes full security features.
> - Includes pre-set configuration templates:
>    - Custom Mode
>    - Console Mode (exe)
>    - Windows Mode (exe)
>    - GL Mode (exe)
>    - Library Mode (dll)
>    - Dynamic Binary Module Mode (ddbm)
>    - Windows Service Mode (exe)
>    - Device Driver Mode (drv/sys)
> - Includes Code Convertion Utility (from C# to D).
> 
> Tech info:
> - Parse the code into XML using Regular Expressions.
>    - More code optimization is now possible.
> - Replaced the backend with HLA.
>    - Code > HLA > OBJ > EXE/DLL
> - Removed GC, ...don't need it.
>    - Variables allocate/deallocate themselfs.
>    - Manual allocation/deallocation still possible.
> - Package/Module now require code block indicators
>    - package somepackage.somewhere
>      {
>         module somemodule
>         {
>            ....
>            module deep.beneath
>            {
>               ....
>            }
>            ....
>         }
> 
>         module another.module
>         {
>            ....
>         }
>      }
>    - More than one module per file is now possible.
> - Added inline HLA
>    - Can now use asm{} or hla{}
> - Changed property syntax (similar to C#)
>    - int something
>      {
>         get { return somevariable; }
>         set { somevariable = value; }
>      }
> - Renamed "mixin" to "macro"
> - Removed "imaginary" and "complex" types.
> - Changed/Added Types
>    * ubyte > byte
>    * byte > sbyte
>    * char > compiler options determine which type to use (1/2/4 bytes)
>    * short > short/int16
>    * ushort > ushort/uint16
>    * int > int/int32
>    * uint > uint/uint32
>    * long > long/int63
>    * ulong > ulong/uint64
>    * float > float/single/real32
>    * double > double/real64
>    + int128/decimal
>    + uint128/udecimal
>    + int256
>    + uint256
>    + real128
>    + real256
>    + string > compiler options determine which type to use (1/2 bytes)
>    + date/time/datetime
> 
> In Progress:
> - "native" .NET framework.
> 
> Plan for the Future:
> - "VS.NET-like" IDE.
> - "true" Generic functionality.
> 
> Sorry...
> NO CODE OR BINARIES INCLUDED WITH THIS MESSAGE! (yet)
> 
> Baas
> 

On Mon, Apr 6, 2009 at 10:29 AM, Baas <hacker@webmail.co.za> wrote:
> In the past 10 motnhs, I completly rewrote the D Compiler in C#!
>
> Sorry...
> NO CODE OR BINARIES INCLUDED WITH THIS MESSAGE! (yet)

Why, because it's complete vaporware?

Why would someone rewrite the D compiler in C# - and change the language to something completely different in the process - and never mention it until now?

Baas wrote:
> Tech info:
> - Parse the code into XML using Regular Expressions.

*double take*

Ellery Newcomer wrote:
> Baas wrote:
>> Tech info:
>> - Parse the code into XML using Regular Expressions.
> 
> *double take*

It's all about the better optimizations that are now possible!

Jarrett Billingsley:
> Why would someone rewrite the D compiler in C# -

For fun, I guess :-) Or maybe as a programming exercise, etc. So there are already four D compilers, (and no one of them is "high quality").

>- Faster overall application execution speed. - Tested against existing benchmarks.<

I'd like to know what benchmarks are used, and against what compiler, etc.

Bye,
bearophile

How is compilar formed? How is compilar formed? How executable get maked?

Tom S Wrote:

> How is compilar formed? How is compilar formed? How executable get maked?

Well, it (the D code) is simply converted to HLA (High Level Assembler) files.
HLA take it from there and compile it into .obj files.
From there you can bassically choose your favourite linker to create exe etc.

downs Wrote:

> Ellery Newcomer wrote:
> > Baas wrote:
> >> Tech info:
> >> - Parse the code into XML using Regular Expressions.
> > 
> > *double take*
> 
> It's all about the better optimizations that are now possible!

I've only provide a brief description upfront.
It basically is now more "dynamic" to do optimization since you're working with straight XML content, which is easier to analyze, manipulate, etc.

Jarrett Billingsley Wrote:

> On Mon, Apr 6, 2009 at 10:29 AM, Baas <hacker@webmail.co.za> wrote:
> > In the past 10 motnhs, I completly rewrote the D Compiler in C#!
> >
> > Sorry...
> > NO CODE OR BINARIES INCLUDED WITH THIS MESSAGE! (yet)
> 
> Why, because it's complete vaporware?
> 
> Why would someone rewrite the D compiler in C# - and change the language to something completely different in the process - and never mention it until now?

...cause it wasn't worth mentioning until now...
have a great day!