         'name': 'keyword.other.special.d'
       ]
     }
-    #
-    # Parameters
-    #
+
+
+
+    #
+    # Expressions
+    #
+    # We cheat a bit here, since highlighting expressions is overkill, and in
+    # any case we want lexical entities like strings and numbers to be
+    # clearly visible.  So we group expressions into a meta class for the
+    # purposes of other entities.  Expression entities themselves just highlight
+    # lexical elements as well as the base expression operators, and a few
+    # others.
+    #
+    'expression': {
+      'patterns': [
+          { 'include': '#operator' },
+          {
+            'match': ',',
+            'name': 'keyword.operator.comma.d'
+          }
+          { 'include': '#lexical' },
+      ]
+    },
+    'conditional-expression': {
+      'patterns': [
+        {
+          # ternary
+          'match': '\\?|:',
+          'name': 'keyword.operator.ternary.d'
+        },
+        {
+          # logical
+          'match': '!<>=|!<=|!>=|<>=|!<>|<=|>=|<>|!>|!<|==|!=|&&|\\|\\||<|>',
+          'name': 'keyword.operator.logical.d'
+        },
+        { 'include': '#lexical' }
+      ]
+    }
+    'operator': {
+      'patterns': [
+        {
+          # assign
+          'match': '=|\\+=|-=|\\*=|/=|%=|&=|\\|=|\\^=|~=|<<=|>>=|>>>=|^^=',
+          'name': 'keyword.operator.assign.d'
+        },
+        {
+          # ternary
+          'match': '\\?|:',
+          'name': 'keyword.operator.ternary.d'
+        },
+        {
+          # logical
+          'match': '!<>=|!<=|!>=|<>=|!<>|<=|>=|<>|!>|!<|==|!=|&&|\\|\\||<|>',
+          'name': 'keyword.operator.logical.d'
+        },
+        {
+          # bitwise
+          'match': '\\||\\^|&|<<|>>|>>>',
+          'name': 'keyword.operator.bitwise.d'
+        },
+        {
+          # arithmetic
+          'match': '\\+|-|\\*|/|%',
+          'name': 'keyword.operator.arithmetic.d'
+        },
+        {
+          # unary
+          'match': '[=~]\s*(&|\\+\\+|\\--|\\*|-|\\+|!)',
+          'name': 'keyword.operator.unary.d'
+        },
+        {
+          # misc
+          'match': '~|(\\s+!in\\s+)|(\\s+in\\s+)',
+          'name': 'keyword.operator.misc.d'
+        },
+        {
+          # primary expressions
+          'match': 'this|super|null|true|false|$',
+          'name': 'constant.language.primary.d'
+        }
+
+      ]
+    },
+    'assign-operator': {
+      'patterns': [
+        {
+          'match': '=|\\+=|-=|\\*=|/=|%=|&=|\\|=|\\^=|~=|<<=|>>=|>>>=|^^=',
+          'name': 'keyword.operator.assign.d'
+        },
+        { 'include': '#expression' },
+      ]
+    },
+    'ternary-operator': {
+      'patterns:': [
+        {
+          'match': '(\\?|:)',
+          'name': 'keyword.operator.ternary.d'
+        },
+        {
+          'include': '#expression',
+        }
+      ]
+    },
+    #
+    # Template
+    #
+
+
+
+
+
+    #
+    # Declarations
+    #
+    'declaration': {
+      'patterns': [
+        { 'include': '#alias-declaration' },
+        { 'include': '#aggregate-declaration' },
+        { 'include': '#enum-declaration' },
+        { 'include': '#import-declaration' },
+        { 'include': '#decl' }
+      ]
+    },
+    'alias-declaration': {
+      'patterns': [
+        {
+          'match': 'alias',
+          'name': 'keyword.alias.d'
+        },
+        { 'include': '#storage-class' },
+        { 'include': '#basic-type' },
+        { 'include': '#declarator' },
+        { 'include': '#alias-declaration-x' }
+      ]
+    },
+    #
+    # Initializers
+    #
+    'initializer': {
+      'patterns': [
+        { 'include': '#void-initializer' },
+        { 'include': '#non-void-initializer' }
+      ]
+    },
+    'void-initializer': {
+      'patterns': [
+        'match': 'void',
+        'name': 'support.type.void.d'
+      ]
+    },
+    'non-void-initializer': {
+      'patterns': [
+        { 'include': '#exp-initializer' },
+        { 'include': '#array-initializer' },
+        { 'include': '#struct-initializer' }
+      ]
+    },
+    'exp-initializer': {
+      'patterns': [
+        { 'include': '#expression' }
+      ]
+    },
+    'array-initializer': {
+      'patterns': [
+        'begin': '\\[',
+        'beginCaptures': { '0': { 'name': 'support.type.array.initializer.begin.d' } },
+        'end': '\\]',
+        'endCaptures': {'0': { 'name': 'support.type.array.initializer.end.d' } },
+        'patterns': [
+          {
+            'match': ',',
+            'name': 'keyword.operator.comma.d'
+          },
+          { 'include': '#array-member-initialization' },
+        ]
+      ]
+    },
+    'array-member-initializations': {
+      'patterns': [
+        {
+          'match': ',',
+          'name': 'keyword.operator.comma.d'
+        },
+        { 'include': '#array-member-initialization' },
+      ]
+    },
+    'array-member-initialization': {
+      'patterns': [
+        { 'include': '#non-void-initializer' },
+        { 'include': '#expression' },
+        {
+          'match': ':',
+          'name': 'support.type.tag.d'
+        }
+      ]
+    },
+    'struct-initializer': {
+      'patterns': [
+        'begin': '\\{',
+        'beginCaptures': { '0': { 'name': 'support.type.struct.initializer.begin.d' } },
+        'end': '\\}',
+        'endCaptures': { '0': { 'name': 'support.type.struct.initializer.end.d' } },
+        'patterns': [
+          { 'include': '#struct-member-initializers' }
+        ]
+      ]
+    }
+    'struct-member-initializers': {
+      'patterns': [
+        {
+          'match': ',',
+          'name': 'keyword.operator.comma.d'
+        },
+        { 'include': '#struct-member-initializer' },
+      ]
+    },
+    'struct-member-initializer': {
+      'patterns': [
+        { 'include': '#non-void-initializer' },
+        { 'include': '#identifier' },
+        {
+          'match': ':',
+          'name': 'support.type.tag.d'
+        },
+      ]
+    },
+
+    #
+    # Assembly (Iasm)
+    #
+
+
+    ###########################################################################
+    # Type
+    ###########################################################################
+
+
+
+    ###########################################################################
+    # Expression
+    ###########################################################################
+
+    ###########################################################################
+    # Statement
+    ###########################################################################
+
+
+
+
+    ###########################################################################
+    # Iasm
+    ###########################################################################
+
+    'asm-statement': {
+      'patterns': [
+        'begin': 'asm\\s*\\{',
+        'end': '\\}',
+        'beginCaptures': { '0': { 'name': 'keyword.control.asm.begin.d' } },
+        'endCaptures': { '0': { 'name': 'keyword.control.asm.end.d' } },
+        'patterns': [
+          { 'include': '#asm-instruction' },
+        ],
+      ]
+    },
+    'asm-instruction': {
+      'patterns': [
+        {
+          'match': 'align|even|naked|db|ds|di|dl|df|dd|de|:',
+          'name': 'keyword.asm-instruction.d',
+        },
+        { 'include': '#operands' },
+        { 'include': '#integer-expression' }
+      ]
+    },
+    'operands': {
+      'patterns': [
+        {
+          'match': ',',
+          'name': 'keyword.operator.comma.assembly.d'
+        }
+        { 'include': '#asm-exp' },
+      ]
+    },
+    'asm-exp': {
+      'patterns': [
+        {
+          'match': '\\?|:',
+          'name': 'keyword.operator.ternary.assembly.d',
+        },
+        {
+          'match': '\\]|\\[',
+          'name': 'keyword.operator.bracket.assembly.d',
+        },
+        {
+          'match': '>>>|\\|\\||&&|==|!=|<=|>=|<<|>>|\\||\\^|&|<|>|\\+|-|\\*|/|%|~|!',
+          'name': 'keyword.operator.assembly.d'
+        },
+        { 'include': '#asm-una-exp' },
+      ]
+    }
+    'integer-expression': {
+      'patterns': [
+        { 'include': '#integer-literal' },
+        { 'include': '#identifier' },
+      ]
+    },
+    'asm-una-exp': {
+      'patterns': [
+        { 'include': '#asm-type-prefix' },
+        {
+          'match': 'offsetof|seg',
+          'name': 'support.type.assembly.d'
+        },
+        { 'include': '#asm-primary-expression' },
+      ]
+    },
+    'asm-primary-expression': {
+      'patterns': [
+        { 'include': '#integer-literal' },
+        { 'include': '#float-literal' },
+        {
+          'match': '__LOCAL_SIZE',
+          'name': 'constant.language.assembly.d'
+        },
+        { 'include': '#register' },
+        { 'include': '#register-64' },
+        { 'include': '#identifier' }
+      ]
+    },
+    'asm-type-prefix': {
+      'patterns': [
+        'match': '(near\\s+ptr)|(far\\s+ptr)|(byte\\s+ptr)|(short\\s+ptr)|(int\\s+ptr)|(word\\s+ptr)|(dword\\s+ptr)|(qword\\s+ptr)|(float\\s+ptr)|(double\\s+ptr)|(real\\s+ptr)',
+        'name': 'support.type.asm-type-prefix.d',
+      ]
+    },
+    'register': {
+      'patterns': [
+        'match': 'XMM0|XMM1|XMM2|XMM3|XMM4|XMM5|XMM6|XMM7|MM0|MM1|MM2|MM3|MM4|MM5|MM6|MM7|ST\\(0\\)|ST\\(1\\)|ST\\(2\\)|ST\\(3\\)|ST\\(4\\)|ST\\(5\\)|ST\\(6\\)|ST\\(7\\)|ST|TR1|TR2|TR3|TR4|TR5|TR6|TR7|DR0|DR1|DR2|DR3|DR4|DR5|DR6|DR7|CR0|CR2|CR3|CR4|EAX|EBX|ECX|EDX|EBP|ESP|EDI|ESI|AL|AH|AX|BL|BH|BX|CL|CH|CX|DL|DH|DX|BP|SP|DI|SI|ES|CS|SS|DS|GS|FS',
+        'name': 'storage.type.assembly.register.d',
+      ]
+    },
+    'register-64': {
+      'patterns': [
+        'match': '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',
+        'name': 'storage.type.assembly.register-64.d'
+      ]
+    },
+    ###########################################################################
+    # Declaration
+    ###########################################################################
+
+
+
+
+    ###########################################################################
+    # Function
+    ###########################################################################
     'parameters': {
       'patterns': [
         {

        { 'include': '#type-ctor' }
      ]
    }

    #
    # Expressions
    #
    # We cheat a bit here, since highlighting expressions is overkill, and in
    # any case we want lexical entities like strings and numbers to be
    # clearly visible.  So we group expressions into a meta class for the
    # purposes of other entities.  Expression entities themselves just highlight
    # lexical elements as well as the base expression operators, and a few
    # others.
    #
    'expression': {
      'patterns': [
          { 'include': '#operator' },
          {
            'match': ',',
            'name': 'keyword.operator.comma.d'
          }
          { 'include': '#lexical' },
      ]
    },
    'conditional-expression': {
      'patterns': [
        {
          # ternary
          'match': '\\?|:',
          'name': 'keyword.operator.ternary.d'
        },
        {
          # logical
          'match': '!<>=|!<=|!>=|<>=|!<>|<=|>=|<>|!>|!<|==|!=|&&|\\|\\||<|>',
          'name': 'keyword.operator.logical.d'
        },
        { 'include': '#lexical' }
      ]
    }
    'operator': {
      'patterns': [
        {
          # assign
          'match': '=|\\+=|-=|\\*=|/=|%=|&=|\\|=|\\^=|~=|<<=|>>=|>>>=|^^=',
          'name': 'keyword.operator.assign.d'
        },
        {
          # ternary
          'match': '\\?|:',
          'name': 'keyword.operator.ternary.d'
        },
        {
          # logical
          'match': '!<>=|!<=|!>=|<>=|!<>|<=|>=|<>|!>|!<|==|!=|&&|\\|\\||<|>',
          'name': 'keyword.operator.logical.d'
        },
        {
          # bitwise
          'match': '\\||\\^|&|<<|>>|>>>',
          'name': 'keyword.operator.bitwise.d'
        },
        {
          # arithmetic
          'match': '\\+|-|\\*|/|%',
          'name': 'keyword.operator.arithmetic.d'
        },
        {
          # unary
          'match': '[=~]\s*(&|\\+\\+|\\--|\\*|-|\\+|!)',
          'name': 'keyword.operator.unary.d'
        },
        {
          # misc
          'match': '~|(\\s+!in\\s+)|(\\s+in\\s+)',
          'name': 'keyword.operator.misc.d'
        },
        {
          # primary expressions
          'match': 'this|super|null|true|false|$',
          'name': 'constant.language.primary.d'
        }

      ]
    },
    'assign-operator': {
      'patterns': [
        {
          'match': '=|\\+=|-=|\\*=|/=|%=|&=|\\|=|\\^=|~=|<<=|>>=|>>>=|^^=',
          'name': 'keyword.operator.assign.d'
        },
        { 'include': '#expression' },
      ]
    },
    'ternary-operator': {
      'patterns:': [
        {
          'match': '(\\?|:)',
          'name': 'keyword.operator.ternary.d'
        },
        {
          'include': '#expression',
        }
      ]
    },
    #
    # Template
    #





    #
    # Declarations
    #
    'declaration': {
      'patterns': [
        { 'include': '#alias-declaration' },
        { 'include': '#aggregate-declaration' },
        { 'include': '#enum-declaration' },
        { 'include': '#import-declaration' },
        { 'include': '#decl' }
      ]
    },
    'alias-declaration': {
      'patterns': [
        {
          'match': 'alias',
          'name': 'keyword.alias.d'
        },
        { 'include': '#storage-class' },
        { 'include': '#basic-type' },
        { 'include': '#declarator' },
        { 'include': '#alias-declaration-x' }
      ]
    },
    #
    # Initializers
    #
    'initializer': {
      'patterns': [
        { 'include': '#void-initializer' },
        { 'include': '#non-void-initializer' }
      ]
    },
    'void-initializer': {
      'patterns': [
        'match': 'void',
        'name': 'support.type.void.d'
      ]
    },
    'non-void-initializer': {
      'patterns': [
        { 'include': '#exp-initializer' },
        { 'include': '#array-initializer' },
        { 'include': '#struct-initializer' }
      ]
    },
    'exp-initializer': {
      'patterns': [
        { 'include': '#expression' }
      ]
    },
    'array-initializer': {
      'patterns': [
        'begin': '\\[',
        'beginCaptures': { '0': { 'name': 'support.type.array.initializer.begin.d' } },
        'end': '\\]',
        'endCaptures': {'0': { 'name': 'support.type.array.initializer.end.d' } },
        'patterns': [
          {
            'match': ',',
            'name': 'keyword.operator.comma.d'
          },
          { 'include': '#array-member-initialization' },
        ]
      ]
    },
    'array-member-initializations': {
      'patterns': [
        {
          'match': ',',
          'name': 'keyword.operator.comma.d'
        },
        { 'include': '#array-member-initialization' },
      ]
    },
    'array-member-initialization': {
      'patterns': [
        { 'include': '#non-void-initializer' },
        { 'include': '#expression' },
        {
          'match': ':',
          'name': 'support.type.tag.d'
        }
      ]
    },
    'struct-initializer': {
      'patterns': [
        'begin': '\\{',
        'beginCaptures': { '0': { 'name': 'support.type.struct.initializer.begin.d' } },
        'end': '\\}',
        'endCaptures': { '0': { 'name': 'support.type.struct.initializer.end.d' } },
        'patterns': [
          { 'include': '#struct-member-initializers' }
        ]
      ]
    }
    'struct-member-initializers': {
      'patterns': [
        {
          'match': ',',
          'name': 'keyword.operator.comma.d'
        },
        { 'include': '#struct-member-initializer' },
      ]
    },
    'struct-member-initializer': {
      'patterns': [
        { 'include': '#non-void-initializer' },
        { 'include': '#identifier' },
        {
          'match': ':',
          'name': 'support.type.tag.d'
        },
      ]
    },
    'default-initializer-expression': {

    },
    'in-out': {
      'patterns': [
        { 'include': '#in-out-x' }
      ]
    },
    'in-out-x': {
      'patterns': [
        {
          'match': 'auto|final|in|out|lazy|ref|scope',
          'name': 'storage.type.modifier.inout.d'
