Package f

Variables

Factor lexer.

var Factor = internal.Register(MustNewLazyLexer(
    &Config{
        Name:      "Factor",
        Aliases:   []string{"factor"},
        Filenames: []string{"*.factor"},
        MimeTypes: []string{"text/x-factor"},
    },
    factorRules,
))

Fennel lexer.

var Fennel = internal.Register(MustNewLazyLexer(
    &Config{
        Name:      "Fennel",
        Aliases:   []string{"fennel", "fnl"},
        Filenames: []string{"*.fennel"},
        MimeTypes: []string{"text/x-fennel", "application/x-fennel"},
    },
    fennelRules,
))

Fish lexer.

var Fish = internal.Register(MustNewLazyLexer(
    &Config{
        Name:      "Fish",
        Aliases:   []string{"fish", "fishshell"},
        Filenames: []string{"*.fish", "*.load"},
        MimeTypes: []string{"application/x-fish"},
    },
    fishRules,
))

Forth lexer.

var Forth = internal.Register(MustNewLazyLexer(
    &Config{
        Name:            "Forth",
        Aliases:         []string{"forth"},
        Filenames:       []string{"*.frt", "*.fth", "*.fs"},
        MimeTypes:       []string{"application/x-forth"},
        CaseInsensitive: true,
    },
    forthRules,
))

Fortran lexer.

var Fortran = internal.Register(MustNewLazyLexer(
    &Config{
        Name:            "Fortran",
        Aliases:         []string{"fortran"},
        Filenames:       []string{"*.f03", "*.f90", "*.F03", "*.F90"},
        MimeTypes:       []string{"text/x-fortran"},
        CaseInsensitive: true,
    },
    fortranRules,
))

FortranFixed lexer.

var FortranFixed = internal.Register(MustNewLazyLexer(
    &Config{
        Name:            "FortranFixed",
        Aliases:         []string{"fortranfixed"},
        Filenames:       []string{"*.f", "*.F"},
        MimeTypes:       []string{"text/x-fortran"},
        NotMultiline:    true,
        CaseInsensitive: true,
    },
    func() Rules {
        return Rules{
            "root": {
                {`[C*].*\n`, Comment, nil},
                {`#.*\n`, CommentPreproc, nil},
                {`[\t ]*!.*\n`, Comment, nil},
                {`(.{5})`, NameLabel, Push("cont-char")},
                {`.*\n`, Using(Fortran), nil},
            },
            "cont-char": {
                {` `, Text, Push("code")},
                {`0`, Comment, Push("code")},
                {`.`, GenericStrong, Push("code")},
            },
            "code": {
                {`(.{66})(.*)(\n)`, ByGroups(Using(Fortran), Comment, Text), Push("root")},
                {`.*\n`, Using(Fortran), Push("root")},
                Default(Push("root")),
            },
        }
    },
))

Fsharp lexer.

var Fsharp = internal.Register(MustNewLazyLexer(
    &Config{
        Name:      "FSharp",
        Aliases:   []string{"fsharp"},
        Filenames: []string{"*.fs", "*.fsi"},
        MimeTypes: []string{"text/x-fsharp"},
    },
    fsharpRules,
))