d

Documentation

Index

• Variables

Variables

var D = internal.Register(MustNewLazyLexer(
	&Config{
		Name:      "D",
		Aliases:   []string{"d"},
		Filenames: []string{"*.d", "*.di"},
		MimeTypes: []string{"text/x-d"},
		EnsureNL:  true,
	},
	dRules,
))

D lexer. https://dlang.org/spec/lex.html

var Dart = internal.Register(MustNewLazyLexer(
	&Config{
		Name:      "Dart",
		Aliases:   []string{"dart"},
		Filenames: []string{"*.dart"},
		MimeTypes: []string{"text/x-dart"},
		DotAll:    true,
	},
	dartRules,
))

Dart lexer.

var Diff = internal.Register(MustNewLazyLexer(
	&Config{
		Name:      "Diff",
		Aliases:   []string{"diff", "udiff"},
		EnsureNL:  true,
		Filenames: []string{"*.diff", "*.patch"},
		MimeTypes: []string{"text/x-diff", "text/x-patch"},
	},
	diffRules,
))

Diff lexer.

var DjangoJinja = internal.Register(MustNewLazyLexer(
	&Config{
		Name:      "Django/Jinja",
		Aliases:   []string{"django", "jinja"},
		Filenames: []string{},
		MimeTypes: []string{"application/x-django-templating", "application/x-jinja"},
		DotAll:    true,
	},
	djangoJinjaRules,
))

Django/Jinja lexer.

var Docker = internal.Register(MustNewLazyLexer(
	&Config{
		Name:            "Docker",
		Aliases:         []string{"docker", "dockerfile"},
		Filenames:       []string{"Dockerfile", "*.docker"},
		MimeTypes:       []string{"text/x-dockerfile-config"},
		CaseInsensitive: true,
	},
	dockerRules,
))

Docker lexer.

var Dtd = internal.Register(MustNewLazyLexer(
	&Config{
		Name:      "DTD",
		Aliases:   []string{"dtd"},
		Filenames: []string{"*.dtd"},
		MimeTypes: []string{"application/xml-dtd"},
		DotAll:    true,
	},
	dtdRules,
))

Dtd lexer.

var Dylan = internal.Register(MustNewLexer(
	&Config{
		Name:            "Dylan",
		Aliases:         []string{"dylan"},
		Filenames:       []string{"*.dylan", "*.dyl", "*.intr"},
		MimeTypes:       []string{"text/x-dylan"},
		CaseInsensitive: true,
	},
	Rules{
		"root": {
			{`\s+`, Whitespace, nil},
			{`//.*?\n`, CommentSingle, nil},
			{`([a-z0-9-]+:)([ \t]*)(.*(?:\n[ \t].+)*)`, ByGroups(NameAttribute, Whitespace, LiteralString), nil},
			Default(Push("code")),
		},
		"code": {
			{`\s+`, Whitespace, nil},
			{`//.*?\n`, CommentSingle, nil},
			{`/\*`, CommentMultiline, Push("comment")},
			{`"`, LiteralString, Push("string")},
			{`'(\\.|\\[0-7]{1,3}|\\x[a-f0-9]{1,2}|[^\\\'\n])'`, LiteralStringChar, nil},
			{`#b[01]+`, LiteralNumberBin, nil},
			{`#o[0-7]+`, LiteralNumberOct, nil},
			{`[-+]?(\d*\.\d+([ed][-+]?\d+)?|\d+(\.\d*)?e[-+]?\d+)`, LiteralNumberFloat, nil},
			{`[-+]?\d+`, LiteralNumberInteger, nil},
			{`#x[0-9a-f]+`, LiteralNumberHex, nil},

			{`(\?\\?)([\w!&*<>|^$%@+~?/=-]+)(:)(token|name|variable|expression|body|case-body|\*)`,
				ByGroups(Operator, NameVariable, Operator, NameBuiltin), nil},
			{`(\?)(:)(token|name|variable|expression|body|case-body|\*)`,
				ByGroups(Operator, Operator, NameVariable), nil},
			{`(\?\\?)([\w!&*<>|^$%@+~?/=-]+)`, ByGroups(Operator, NameVariable), nil},

			{`(=>|::|#\(|#\[|##|\?\?|\?=|\?|[(){}\[\],.;])`, Punctuation, nil},
			{`:=`, Operator, nil},
			{`#[tf]`, Literal, nil},
			{`#"`, LiteralStringSymbol, Push("symbol")},
			{`#[a-z0-9-]+`, Keyword, nil},
			{`#(all-keys|include|key|next|rest)`, Keyword, nil},
			{`[\w!&*<>|^$%@+~?/=-]+:`, KeywordConstant, nil},
			{`<[\w!&*<>|^$%@+~?/=-]+>`, NameClass, nil},
			{`\*[\w!&*<>|^$%@+~?/=-]+\*`, NameVariableGlobal, nil},
			{`\$[\w!&*<>|^$%@+~?/=-]+`, NameConstant, nil},
			{`(let|method|function)([ \t]+)([\w!&*<>|^$%@+~?/=-]+)`, ByGroups(NameBuiltin, Whitespace, NameVariable), nil},
			{`(error|signal|return|break)`, NameException, nil},
			{`(\\?)([\w!&*<>|^$%@+~?/=-]+)`, ByGroups(Operator, Name), nil},
		},
		"comment": {
			{`[^*/]`, CommentMultiline, nil},
			{`/\*`, CommentMultiline, Push()},
			{`\*/`, CommentMultiline, Pop(1)},
			{`[*/]`, CommentMultiline, nil},
		},
		"symbol": {
			{`"`, LiteralStringSymbol, Pop(1)},
			{`[^\\"]+`, LiteralStringSymbol, nil},
		},
		"string": {
			{`"`, LiteralString, Pop(1)},
			{`\\([\\abfnrtv"\']|x[a-f0-9]{2,4}|[0-7]{1,3})`, LiteralStringEscape, nil},
			{`[^\\"\n]+`, LiteralString, nil},
			{`\\\n`, LiteralString, nil},
			{`\\`, LiteralString, nil},
		},
	},
))

Dylan lexer.