▽

Package g

Variables

GDScript lexer.

var GDScript = internal.Register(MustNewLazyLexer(
    &Config{
        Name:      "GDScript",
        Aliases:   []string{"gdscript", "gd"},
        Filenames: []string{"*.gd"},
        MimeTypes: []string{"text/x-gdscript", "application/x-gdscript"},
    },
    gdscriptRules,
))

GLSL lexer.

var GLSL = internal.Register(MustNewLazyLexer(
    &Config{
        Name:      "GLSL",
        Aliases:   []string{"glsl"},
        Filenames: []string{"*.vert", "*.frag", "*.geo"},
        MimeTypes: []string{"text/x-glslsrc"},
    },
    glslRules,
))

Gas lexer.

var Gas = internal.Register(MustNewLazyLexer(
    &Config{
        Name:      "GAS",
        Aliases:   []string{"gas", "asm"},
        Filenames: []string{"*.s", "*.S"},
        MimeTypes: []string{"text/x-gas"},
    },
    gasRules,
))

Genshi lexer.

var Genshi = internal.Register(MustNewLazyLexer(
    &Config{
        Name:         "Genshi",
        Aliases:      []string{"genshi", "kid", "xml+genshi", "xml+kid"},
        Filenames:    []string{"*.kid"},
        MimeTypes:    []string{"application/x-genshi", "application/x-kid"},
        NotMultiline: true,
        DotAll:       true,
    },
    genshiMarkupRules,
))

Html+Genshi lexer.

var GenshiHTMLTemplate = internal.Register(MustNewLazyLexer(
    &Config{
        Name:         "Genshi HTML",
        Aliases:      []string{"html+genshi", "html+kid"},
        Filenames:    []string{},
        MimeTypes:    []string{"text/html+genshi"},
        NotMultiline: true,
        DotAll:       true,
    },
    genshiMarkupRules,
))

Genshi Text lexer.

var GenshiText = internal.Register(MustNewLazyLexer(
    &Config{
        Name:      "Genshi Text",
        Aliases:   []string{"genshitext"},
        Filenames: []string{},
        MimeTypes: []string{"application/x-genshi-text", "text/x-genshi"},
    },
    genshiTextRules,
))

Gherkin lexer.

var Gherkin = internal.Register(MustNewLazyLexer(
    &Config{
        Name:      "Gherkin",
        Aliases:   []string{"cucumber", "Cucumber", "gherkin", "Gherkin"},
        Filenames: []string{"*.feature", "*.FEATURE"},
        MimeTypes: []string{"text/x-gherkin"},
    },
    gherkinRules,
))

Gnuplot lexer.

var Gnuplot = internal.Register(MustNewLazyLexer(
    &Config{
        Name:      "Gnuplot",
        Aliases:   []string{"gnuplot"},
        Filenames: []string{"*.plot", "*.plt"},
        MimeTypes: []string{"text/x-gnuplot"},
    },
    gnuplotRules,
))

Go lexer.

var Go = internal.Register(MustNewLazyLexer(
    &Config{
        Name:      "Go",
        Aliases:   []string{"go", "golang"},
        Filenames: []string{"*.go"},
        MimeTypes: []string{"text/x-gosrc"},
        EnsureNL:  true,
    },
    goRules,
).SetAnalyser(func(text string) float32 {
    if strings.Contains(text, "fmt.") && strings.Contains(text, "package ") {
        return 0.5
    }
    if strings.Contains(text, "package ") {
        return 0.1
    }
    return 0.0
}))

var GoHTMLTemplate = internal.Register(DelegatingLexer(h.HTML, MustNewLazyLexer(
    &Config{
        Name:    "Go HTML Template",
        Aliases: []string{"go-html-template"},
    },
    goTemplateRules,
)))

var GoTextTemplate = internal.Register(MustNewLazyLexer(
    &Config{
        Name:    "Go Text Template",
        Aliases: []string{"go-text-template"},
    },
    goTemplateRules,
))

Go lexer.

var Graphql = internal.Register(MustNewLazyLexer(
    &Config{
        Name:      "GraphQL",
        Aliases:   []string{"graphql", "graphqls", "gql"},
        Filenames: []string{"*.graphql", "*.graphqls"},
    },
    graphqlRules,
))

Groff lexer.

var Groff = internal.Register(MustNewLazyLexer(
    &Config{
        Name:      "Groff",
        Aliases:   []string{"groff", "nroff", "man"},
        Filenames: []string{"*.[1-9]", "*.1p", "*.3pm", "*.man"},
        MimeTypes: []string{"application/x-troff", "text/troff"},
    },
    func() Rules {
        return Rules{
            "root": {
                {`(\.)(\w+)`, ByGroups(Text, Keyword), Push("request")},
                {`\.`, Punctuation, Push("request")},
                {`[^\\\n]+`, Text, Push("textline")},
                Default(Push("textline")),
            },
            "textline": {
                Include("escapes"),
                {`[^\\\n]+`, Text, nil},
                {`\n`, Text, Pop(1)},
            },
            "escapes": {
                {`\\"[^\n]*`, Comment, nil},
                {`\\[fn]\w`, LiteralStringEscape, nil},
                {`\\\(.{2}`, LiteralStringEscape, nil},
                {`\\.\[.*\]`, LiteralStringEscape, nil},
                {`\\.`, LiteralStringEscape, nil},
                {`\\\n`, Text, Push("request")},
            },
            "request": {
                {`\n`, Text, Pop(1)},
                Include("escapes"),
                {`"[^\n"]+"`, LiteralStringDouble, nil},
                {`\d+`, LiteralNumber, nil},
                {`\S+`, LiteralString, nil},
                {`\s+`, Text, nil},
            },
        }
    },
))

Groovy lexer.

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