...

Package c

import "github.com/alecthomas/chroma/lexers/c"
Overview
Index

Overview ▾

Variables

C lexer.

var C = internal.Register(MustNewLazyLexer(
    &Config{
        Name:      "C",
        Aliases:   []string{"c"},
        Filenames: []string{"*.c", "*.h", "*.idc", "*.x[bp]m"},
        MimeTypes: []string{"text/x-chdr", "text/x-csrc", "image/x-xbitmap", "image/x-xpixmap"},
        EnsureNL:  true,
    },
    cRules,
))

CPP lexer.

var CPP = internal.Register(MustNewLazyLexer(
    &Config{
        Name:      "C++",
        Aliases:   []string{"cpp", "c++"},
        Filenames: []string{"*.cpp", "*.hpp", "*.c++", "*.h++", "*.cc", "*.hh", "*.cxx", "*.hxx", "*.C", "*.H", "*.cp", "*.CPP"},
        MimeTypes: []string{"text/x-c++hdr", "text/x-c++src"},
        EnsureNL:  true,
    },
    cppRules,
))

CSS lexer.

var CSS = internal.Register(MustNewLazyLexer(
    &Config{
        Name:      "CSS",
        Aliases:   []string{"css"},
        Filenames: []string{"*.css"},
        MimeTypes: []string{"text/css"},
    },
    cssRules,
))

CSharp lexer.

var CSharp = internal.Register(MustNewLazyLexer(
    &Config{
        Name:      "C#",
        Aliases:   []string{"csharp", "c#"},
        Filenames: []string{"*.cs"},
        MimeTypes: []string{"text/x-csharp"},
        DotAll:    true,
        EnsureNL:  true,
    },
    cSharpRules,
))

Caddyfile lexer.

var Caddyfile = internal.Register(MustNewLazyLexer(
    &Config{
        Name:      "Caddyfile",
        Aliases:   []string{"caddyfile", "caddy"},
        Filenames: []string{"Caddyfile*"},
        MimeTypes: []string{},
    },
    caddyfileRules,
))

Caddyfile directive-only lexer.

var CaddyfileDirectives = internal.Register(MustNewLazyLexer(
    &Config{
        Name:      "Caddyfile Directives",
        Aliases:   []string{"caddyfile-directives", "caddyfile-d", "caddy-d"},
        Filenames: []string{},
        MimeTypes: []string{},
    },
    caddyfileDirectivesRules,
))

Cap'N'Proto Proto lexer.

var CapNProto = internal.Register(MustNewLazyLexer(
    &Config{
        Name:      "Cap'n Proto",
        Aliases:   []string{"capnp"},
        Filenames: []string{"*.capnp"},
        MimeTypes: []string{},
    },
    capNProtoRules,
))

CassandraCQL lexer.

var CassandraCQL = internal.Register(MustNewLazyLexer(
    &Config{
        Name:            "Cassandra CQL",
        Aliases:         []string{"cassandra", "cql"},
        Filenames:       []string{"*.cql"},
        MimeTypes:       []string{"text/x-cql"},
        NotMultiline:    true,
        CaseInsensitive: true,
    },
    cassandraCQLRules,
))

Ceylon lexer.

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

Cfengine3 lexer.

var Cfengine3 = internal.Register(MustNewLazyLexer(
    &Config{
        Name:      "CFEngine3",
        Aliases:   []string{"cfengine3", "cf3"},
        Filenames: []string{"*.cf"},
        MimeTypes: []string{},
    },
    cfengine3Rules,
))

Cfstatement lexer.

var Cfstatement = internal.Register(MustNewLazyLexer(
    &Config{
        Name:            "cfstatement",
        Aliases:         []string{"cfs"},
        Filenames:       []string{},
        MimeTypes:       []string{},
        NotMultiline:    true,
        CaseInsensitive: true,
    },
    cfstatementRules,
))

Chaiscript lexer.

var Chaiscript = internal.Register(MustNewLazyLexer(
    &Config{
        Name:      "ChaiScript",
        Aliases:   []string{"chai", "chaiscript"},
        Filenames: []string{"*.chai"},
        MimeTypes: []string{"text/x-chaiscript", "application/x-chaiscript"},
        DotAll:    true,
    },
    chaiscriptRules,
))

Cheetah lexer.

var Cheetah = internal.Register(MustNewLazyLexer(
    &Config{
        Name:      "Cheetah",
        Aliases:   []string{"cheetah", "spitfire"},
        Filenames: []string{"*.tmpl", "*.spt"},
        MimeTypes: []string{"application/x-cheetah", "application/x-spitfire"},
    },
    cheetahRules,
))

Clojure lexer.

var Clojure = internal.Register(MustNewLazyLexer(
    &Config{
        Name:      "Clojure",
        Aliases:   []string{"clojure", "clj"},
        Filenames: []string{"*.clj"},
        MimeTypes: []string{"text/x-clojure", "application/x-clojure"},
    },
    clojureRules,
))

Cmake lexer.

var Cmake = internal.Register(MustNewLazyLexer(
    &Config{
        Name:      "CMake",
        Aliases:   []string{"cmake"},
        Filenames: []string{"*.cmake", "CMakeLists.txt"},
        MimeTypes: []string{"text/x-cmake"},
    },
    cmakeRules,
))

Cobol lexer.

var Cobol = internal.Register(MustNewLazyLexer(
    &Config{
        Name:            "COBOL",
        Aliases:         []string{"cobol"},
        Filenames:       []string{"*.cob", "*.COB", "*.cpy", "*.CPY"},
        MimeTypes:       []string{"text/x-cobol"},
        CaseInsensitive: true,
    },
    cobolRules,
))

Coffeescript lexer.

var Coffeescript = internal.Register(MustNewLazyLexer(
    &Config{
        Name:         "CoffeeScript",
        Aliases:      []string{"coffee-script", "coffeescript", "coffee"},
        Filenames:    []string{"*.coffee"},
        MimeTypes:    []string{"text/coffeescript"},
        NotMultiline: true,
        DotAll:       true,
    },
    coffeescriptRules,
))

Common Lisp lexer.

var CommonLisp = internal.Register(TypeRemappingLexer(MustNewLazyLexer(
    &Config{
        Name:            "Common Lisp",
        Aliases:         []string{"common-lisp", "cl", "lisp"},
        Filenames:       []string{"*.cl", "*.lisp"},
        MimeTypes:       []string{"text/x-common-lisp"},
        CaseInsensitive: true,
    },
    commonLispRules,
), TypeMapping{
    {NameVariable, NameFunction, clBuiltinFunctions},
    {NameVariable, Keyword, clSpecialForms},
    {NameVariable, NameBuiltin, clMacros},
    {NameVariable, Keyword, clLambdaListKeywords},
    {NameVariable, Keyword, clDeclarations},
    {NameVariable, KeywordType, clBuiltinTypes},
    {NameVariable, NameClass, clBuiltinClasses},
}))

Coq lexer.

var Coq = internal.Register(MustNewLazyLexer(
    &Config{
        Name:      "Coq",
        Aliases:   []string{"coq"},
        Filenames: []string{"*.v"},
        MimeTypes: []string{"text/x-coq"},
    },
    coqRules,
))

Crystal lexer.

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

Cython lexer.

var Cython = internal.Register(MustNewLazyLexer(
    &Config{
        Name:      "Cython",
        Aliases:   []string{"cython", "pyx", "pyrex"},
        Filenames: []string{"*.pyx", "*.pxd", "*.pxi"},
        MimeTypes: []string{"text/x-cython", "application/x-cython"},
    },
    cythonRules,
))