c

package
Version: v0.10.0 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Jan 12, 2022 License: MIT Imports: 3 Imported by: 28

Documentation

Index

Constants

This section is empty.

Variables

View Source
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,
))

C lexer.

View Source
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,
))

CPP lexer.

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

CSS lexer.

View Source
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,
))

CSharp lexer.

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

Caddyfile lexer.

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

Caddyfile directive-only lexer.

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

Cap'N'Proto Proto lexer.

View Source
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,
))

CassandraCQL lexer.

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

Ceylon lexer.

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

Cfengine3 lexer.

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

Cfstatement lexer.

View Source
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,
))

Chaiscript lexer.

View Source
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,
))

Cheetah lexer.

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

Clojure lexer.

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

Cmake lexer.

View Source
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,
))

Cobol lexer.

View Source
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,
))

Coffeescript lexer.

View Source
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},
}))

Common Lisp lexer.

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

Coq lexer.

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

Crystal lexer.

View Source
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,
))

Cython lexer.

Functions

This section is empty.

Types

This section is empty.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL