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
Technically cool, but I'm not sure it can be considered 'D' if you won't
be able to compile D 1.0 code with it. Sounds like a language fork.
