www.digitalmars.com         C & C++   DMDScript  

D - D, so it happend...

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
Apr 06 2009