# D

To use this language, use the class "language-d".

## Comments

    // Single line comment
    /* Multi-line
    	comment */
    /+ Mutli-line
    	/+ nestable +/
    	comment +/

## Numbers

    0 .. 2_147_483_647
    2_147_483_648 .. 9_223_372_036_854_775_807
    0L .. 9_223_372_036_854_775_807L
    0U .. 4_294_967_296U
    4_294_967_296U .. 18_446_744_073_709_551_615U
    0UL .. 18_446_744_073_709_551_615UL
    0x0 .. 0x7FFF_FFFF
    0x8000_0000 .. 0xFFFF_FFFF
    0x1_0000_0000 .. 0x7FFF_FFFF_FFFF_FFFF
    0x8000_0000_0000_0000 .. 0xFFFF_FFFF_FFFF_FFFF
    0x0L .. 0x7FFF_FFFF_FFFF_FFFFL
    0x8000_0000_0000_0000L .. 0xFFFF_FFFF_FFFF_FFFFL
    0x0U .. 0xFFFF_FFFFU
    0x1_0000_0000U .. 0xFFFF_FFFF_FFFF_FFFFU
    0x0UL .. 0xFFFF_FFFF_FFFF_FFFFUL

    123_456.567_8          // 123456.5678
    1_2_3_4_5_6_.5_6_7_8   // 123456.5678
    1_2_3_4_5_6_.5e-6_     // 123456.5e-6
    0x1.FFFFFFFFFFFFFp1023 // double.max
    0x1p-52                // double.epsilon
    1.175494351e-38F       // float.min
    6.3i                   // idouble 6.3
    6.3fi                  // ifloat 6.3
    6.3Li                  // ireal 6.3
    4.5 + 6.2i             // complex number (phased out)

## Strings

    // WYSIWYG strings
    r"hello"
    r"c:\root\foo.exe"
    r"ab\n"
    `hello`
    `c:\root\foo.exe`
    `ab\n`

    // Double-quoted strings
    "hello"
    "c:\\root\\foo.exe"
    "ab\n"
    "ab
    "

    // Hex strings
    x"0A"
    x"00 FBCD 32FD 0A"

    // String postfix characters
    "hello"c  // string
    "hello"w  // wstring
    "hello"d  // dstring

    // Delimited strings
    q"(foo(xxx))"
    q"[foo{]"
    q"EOS
    This
    is a multi-line
    heredoc string
    EOS"
    q"/foo]/"

    // Token strings
    q{foo}
    q{/*}*/ }
    q{ foo(q{hello}); }
    q{ __TIME__ }

    // Character literals
    'a'
    '\u000A'

## Iasm registers

    AL AH AX EAX
    BL BH BX EBX
    CL CH CX ECX
    DL DH DX EDX
    BP EBP
    SP ESP
    DI EDI
    SI ESI
    ES CS SS DS GS FS
    CR0 CR2 CR3 CR4
    DR0 DR1 DR2 DR3 DR6 DR7
    TR3 TR4 TR5 TR6 TR7
    ST
    ST(0) ST(1) ST(2) ST(3) ST(4) ST(5) ST(6) ST(7)
    MM0  MM1  MM2  MM3  MM4  MM5  MM6  MM7
    XMM0 XMM1 XMM2 XMM3 XMM4 XMM5 XMM6 XMM7

    RAX  RBX  RCX  RDX
    BPL  RBP
    SPL  RSP
    DIL  RDI
    SIL  RSI
    R8B  R8W  R8D  R8
    R9B  R9W  R9D  R9
    R10B R10W R10D R10
    R11B R11W R11D R11
    R12B R12W R12D R12
    R13B R13W R13D R13
    R14B R14W R14D R14
    R15B R15W R15D R15
    XMM8 XMM9 XMM10 XMM11 XMM12 XMM13 XMM14 XMM15
    YMM0 YMM1 YMM2  YMM3  YMM4  YMM5  YMM6  YMM7
    YMM8 YMM9 YMM10 YMM11 YMM12 YMM13 YMM14 YMM15

## Full example

    #!/usr/bin/dmd -run
    /* sh style script syntax is supported! */
    /* Hello World in D
       To compile:
         dmd hello.d
       or to optimize:
         dmd -O -inline -release hello.d
       or to get generated documentation:
         dmd hello.d -D
      */
    import std.stdio;  // References to  commonly used I/O routines.
    void main(char[][] args)   // 'void' here means return 0 by default.
    {
        // Write-Formatted-Line
         writefln("Hello World, "   // automatic concatenation of string literals
                  "Reloaded");
         // Strings are denoted as a dynamic array of chars 'char[]'
         // auto type inference and built-in foreach
         foreach(argc, argv; args)
        {
            // OOP is supported, of course! And automatic type inference.
             auto cl = new CmdLin(argc, argv);

            // 'writefln' is the improved 'printf' !!
             // user-defined class properties.
             writefln(cl.argnum, cl.suffix, " arg: %s", cl.argv);
            // Garbage Collection or explicit memory management - your choice!!!
             delete cl;
        }
         // Nested structs, classes and functions!
         struct specs
        {
            // all vars. automatically initialized
             int count, allocated;
        }

        // Note that declarations read right-to-left.
        // So that 'char[][]' reads as an array of an array of chars.

        specs argspecs(char[][] args)
        // Optional (built-in) function contracts.
         in{
            assert (args.length > 0); // assert built in
         }
        out(result){
            assert(result.count == CmdLin.total);
            assert(result.allocated > 0);
        }
        body{
            specs* s = new specs;
            // no need for '->'
             s.count = args.length;  // The 'length' property is number of elements.
             s.allocated = typeof(args).sizeof; // built-in properties for native types
             foreach(argv; args)
                s.allocated += argv.length * typeof(argv[0]).sizeof;
            return *s;
        }

        // built-in string and common string operations, e.g. '~' is concatenate.
         char[] argcmsg  = "argc = %d";
        char[] allocmsg = "allocated = %d";
        writefln(argcmsg ~ ", " ~ allocmsg,
             argspecs(args).count,argspecs(args).allocated);
    }
    /**
       Stores a single command line argument.
     */
     class CmdLin
    {
        private {
         int _argc;
         char[] _argv;
         static uint _totalc;
        }

     public:
    /************
          Object constructor.
          params:
            argc = ordinal count of this argument.
            argv = text of the parameter
      *********/
         this(int argc, char[] argv)
        {
            _argc = argc + 1;
            _argv = argv;
            _totalc++;
        }

        ~this() /// Object destructor
         {
            // Doesn't actually do anything for this example.
         }

         int argnum() /// A property that returns arg number
         {
            return _argc;
        }
         char[] argv() /// A property  that returns arg text
         {
            return _argv;
        }
         wchar[] suffix() /// A property  that returns ordinal suffix
         {
            wchar[] suffix;  // Built in  Unicode strings (utf8,utf16, utf32)
             switch(_argc)
            {
            case 1:
                suffix = "st";
                break;
            case 2:
                suffix = "nd";
                break;
            case 3:
                suffix = "rd";
                break;
            default:  // 'default' is mandatory with "-w" compile switch.
                 suffix = "th";
            }
            return suffix;
        }

    /* **************
          * A property of the whole class, not just an instance.
          * returns: The total number of commandline args added.
          *************/
         static typeof(_totalc) total()
        {
            return _totalc;
        }
         // Class invariant, things that must be true after any method is run.
         invariant
         {
             assert(_argc > 0);
             assert(_totalc >= _argc);
         }
    }

## Known failures

There are certain edge cases where Prism will fail. There are always such cases in every regex-based syntax highlighter. However, Prism dares to be open and honest about them. If a failure is listed here, it doesn’t mean it will never be fixed. This is more of a “known bugs” list, just with a certain type of bug.

### Comments only support one level of nesting

    /+ /+ /+ this does not work +/ +/ +/

### Token strings only support one level of nesting

    q{ q{ q{ this does not work } } }

### Token strings inside comments are highlighted

    // This q{is} wrong

### Multi-line comment ends single-line comment

    // This /* is a */ comment