fortls 包

子包

子模块

fortls.constants 模块

fortls.constants.FORTRAN_LITERAL = '0^=__LITERAL_INTERNAL_DUMMY_VAR_'

用于标记字面量（例如 10、3.14、“words” 等）的字符串。选择的描述名称是明确的，并且不能自然地出现在 Fortran（有/无 C 预处理）代码中。定义以数字开头的类型的语法无效，它也不能是需要 !、c、d 和 ^=（异或等）运算符的注释在 Fortran 中无效 C++ 预处理

class fortls.constants.Severity

基类：object

error = 1
info = 3
warn = 2

fortls.debug 模块

exception fortls.debug.DebugError

基类：Exception

调试 CLI 的基类。

exception fortls.debug.ParameterError

基类：DebugError

针对参数错误引发的异常。

fortls.debug.check_request_params(args, loc_needed=True)
fortls.debug.debug_actions(args, server)
fortls.debug.debug_completion(args, server)
fortls.debug.debug_definition(args, server)
fortls.debug.debug_diagnostics(args, server)
fortls.debug.debug_generic(args, test_label, lsp_request, format_results, loc_needed=True)
fortls.debug.debug_hover(args, server)
fortls.debug.debug_implementation(args, server)
fortls.debug.debug_lsp(args, settings)
fortls.debug.debug_parser(args)

调试语言服务器的解析器 由 –debug_parser 选项触发。

参数：

args (Namespace) – 从 ArgumentParser 解析的参数

fortls.debug.debug_preprocessor(args)

调试语言服务器的预处理器 由 –debug_preprocessor 选项触发。

参数：

args (Namespace) – 从 ArgumentParser 解析的参数

fortls.debug.debug_references(args, server)
fortls.debug.debug_rename(args, server)
fortls.debug.debug_rootpath(args, server)
fortls.debug.debug_signature(args, server)
fortls.debug.debug_symbols(args, server)
fortls.debug.debug_workspace_symbols(args, server)
fortls.debug.ensure_file_accessible(filepath)

确保文件存在且可访问，如果不存在则引发错误。

fortls.debug.is_debug_mode(args)
fortls.debug.locate_config(root, input_config)
返回类型:

str | None

fortls.debug.print_children(obj, indent='')
fortls.debug.print_results(results, format_results, args)

辅助函数，根据请求的详细级别打印结果。

fortls.debug.process_file_changes(file_path, changes, file_contents)
fortls.debug.read_config(root, input_config)
fortls.debug.separator()

fortls.ftypes 模块

class fortls.ftypes.ClassInfo(name, parent, keywords)

基类：object

保存关于 Fortran CLASS 的信息

keywords: list[str]

与类关联的关键字

name: str

类名

parent: str

类的父对象，例如 TYPE, EXTENDS(scaled_vector) :: a

class fortls.ftypes.FunSig(name, args, keywords=<factory>, mod_flag=False, result=<factory>)

基类: SubInfo

保存关于 Fortran FUNCTION 的信息

result: ResultSig

函数的结果，默认 result.name = name

class fortls.ftypes.GenProcDefInfo(bound_name, pro_links, vis_flag)

基类：object

保存关于 GENERIC PROCEDURE DEFINITION 的信息

bound_name: str

过程名称

过程链接

vis_flag: int

可见性标志，公共或私有

class fortls.ftypes.IncludeInfo(line_number, path, file, scope_objs)

基类：object

保存关于 Fortran INCLUDE 语句的信息

file: None
line_number: int

包含语句的行号

path: str

包含文件的路径

scope_objs: list[str]

可用作用域的列表

class fortls.ftypes.InterInfo(name, abstract)

基类：object

保存关于 Fortran INTERFACE 的信息

abstract: bool

接口是否为抽象接口

name: str

接口名称

class fortls.ftypes.Range(start, end)

基类: tuple

单个行范围元组

end: int

字段编号 1 的别名

start: int

字段编号 0 的别名

class fortls.ftypes.ResultSig(name=None, type=None, kind=None, keywords=<factory>)

基类：object

保存关于 Fortran FUNCTION 的 RESULT 部分的信息

keywords: list[str]

与结果变量关联的关键字，可以在不初始化的情况下追加

kind: str | None = None

结果变量的类型

name: str | None = None

结果变量的名称

type: str | None = None

结果变量的类型

class fortls.ftypes.SelectInfo(type, binding, desc)

基类：object

保存关于 SELECT 结构的信息

binding: str

正在进行选择操作的变量/对象

desc: str

select 的描述，例如“TYPE”，“CLASS”，“None”

type: int

SELECT 的类型，例如正常、选择类型、选择种类、选择等级

class fortls.ftypes.SmodInfo(name, parent)

基类：object

保存关于 Fortran 子模块的信息

name: str

子模块名称

parent: str

子模块，即模块，父模块

class fortls.ftypes.SubInfo(name, args, keywords=<factory>, mod_flag=False)

基类：object

保存关于 Fortran 子程序的信息

args: str

参数列表

keywords: list[str]

与过程关联的关键字

mod_flag: bool = False

这是否为MODULE PROCEDURE

name: str

过程名称

class fortls.ftypes.UseInfo(mod_name, only_list, rename_map)

基类：object

保存关于 Fortran USE 语句的信息

mod_name: str

模块名称

only_list: set[str]

通过 only 导入的过程、变量、接口等的列表

rename_map: dict[str, str]

一个字典，保存重命名操作后的新名称

class fortls.ftypes.VarInfo(var_type, keywords, var_names, var_kind=None)

基类：object

保存关于 Fortran 变量的信息

keywords: list[str]

与变量关联的关键字

var_kind: str | None = None

变量的类型，例如INTEGER*4等。

var_names: list[str]

变量名称

var_type: str

变量类型，例如 INTEGER、REAL 等。

class fortls.ftypes.VisInfo(type, obj_names)

基类：object

保存有关模块内容可见性的信息

obj_names: list[str]

具有该可见性的模块变量、过程等。

type: int

PRIVATE 待办事项：转换为布尔值

类型：

可见性类型 0

类型：

PUBLIC 1

fortls.helper_functions 模块

fortls.helper_functions.detect_fixed_format(file_lines)

通过查看标签列和第 6 列之前的变量声明中的字符来检测定长/自由格式。将交集格式文件视为自由格式。

参数：

**file_lines** (list[str]) – 连续文件行的列表

返回值：

如果 file_lines 为 Fortran 定长格式，则返回 True

返回类型:

布尔值

示例

>>> detect_fixed_format([' free format'])
False

>>> detect_fixed_format([' INTEGER, PARAMETER :: N = 10'])
False

>>> detect_fixed_format(['C Fixed format'])
True

包含 & 符号的行不是定长格式 >>> detect_fixed_format([‘trailing line & ! comment’]) False

但是预处理器行将被忽略 >>> detect_fixed_format( … [‘#if defined(A) && !defined(B)’, ‘C Fixed format’, ‘#endif’]) True

>>> detect_fixed_format(
...     ['#if defined(A) && !defined(B)', ' free format', '#endif'])
False

并且预处理器行延续被考虑在内 >>> detect_fixed_format( … [‘#if defined(A) \ ‘, ‘ && !defined(B)’, ‘C Fixed format’, ‘#endif’]) True

>>> detect_fixed_format(
...     ['#if defined(A) \\', '&& \\', '!defined(B)', ' free format', '#endif'])
False
fortls.helper_functions.expand_name(line, char_pos)

获取包含给定光标位置的完整单词

参数：

  • **line** (str) – 文本行

  • **char_pos** (int) – 行中的列位置

返回值：

输入列的单词正则表达式匹配

返回类型:

字符串

fortls.helper_functions.find_paren_match(string)

通过对字符串的前向搜索从已打开的括号范围查找匹配的闭合括号，如果未找到匹配项则返回 -1

参数：

**string** (str) – 输入字符串

返回值：

字符串中匹配的 ) 字符的索引

返回类型:

整数

示例

>>> find_paren_match('a, b)')
4

多个已关闭的括号

>>> find_paren_match('a, (b, c), d)')
12

如果最外层的括号未关闭，则函数返回 -1

>>> find_paren_match('a, (b, (c, d)')
-1

>>> find_paren_match('nt(sin(0.5))+8+len("ab((c")-3) :: y')
29

>>> find_paren_match("nt(sin(0.5))+8+len('ab))c')-3) :: y")
29
fortls.helper_functions.find_word_in_line(line, word)

在行中查找 Fortran 单词

参数：

  • **line** (str) – 文本行

  • **word** (str) – 要在行中查找的单词

返回值：

如果未找到单词，则返回单词的起始和结束位置（索引），否则返回 -1、len(word) -1

返回类型:

范围

fortls.helper_functions.fortran_md(code, docs)

将 Fortran 代码转换为 Markdown

参数：

  • **code** (str) – Fortran 代码

  • **docs** (str | None) – 文档字符串

返回值：

Markdown 字符串

返回类型:

字符串

fortls.helper_functions.get_keywords(keywords, keyword_info=None)
fortls.helper_functions.get_line_prefix(pre_lines, curr_line, col, qs=True)

从当前行和前面的延续行获取代码行前缀

参数：

  • **pre_lines** (list) – 对于多行情况，获取所有先前的相关行

  • **curr_line** (str) – 当前行

  • **col** (int) – 当前行的列索引

  • **qs** (bool, optional) – 从 curr_line 和 pre_lines 中去除引号，即字符串文字。在将鼠标悬停在字符串文字上时需要禁用此功能，默认值为 True

返回值：

包括 col 之前任何相关行延续的行的一部分

返回类型:

字符串

示例

>>> get_line_prefix([''], '#pragma once', 0) is None
True
fortls.helper_functions.get_paren_level(line)

通过向后搜索整行获取对应于单个括号级别的子字符串。

参数：

**line** (str) – 文档行

返回值：

作为字符串和针对 line 的参数的 Range 列表的参数

返回类型:

tuple[str, list[Range]]

示例

>>> get_paren_level('CALL sub1(arg1,arg2')
('arg1,arg2', [Range(start=10, end=19)])

如果范围被括号打断，则使用另一个 Range 变量来标记参数的 start 和 end

>>> get_paren_level('CALL sub1(arg1(i),arg2')
('arg1,arg2', [Range(start=10, end=14), Range(start=17, end=22)])

>>> get_paren_level('')
('', [Range(start=0, end=0)])
fortls.helper_functions.get_paren_substring(string)

获取第一对括号括起来的內容

参数：

**string** (str) – 字符串

返回值：

括号中字符串的一部分，例如或 None

返回类型:

str | None

示例

>>> get_paren_substring('some line(a, b, (c, d))')
'a, b, (c, d)'

但是，如果该行包含不完整的括号，则返回 None >>> get_paren_substring(‘some line(a, b’) is None True

fortls.helper_functions.get_placeholders(arg_list)

用于为代码片段生成占位符的函数

参数：

**arg_list** (list[str]) – 方法参数列表

返回值：

参数作为字符串和代码片段字符串的元组

返回类型:

Tuple[str, str]

示例

>>> get_placeholders(['x', 'y'])
('(x, y)', '(${1:x}, ${2:y})')

>>> get_placeholders(['x=1', 'y=2'])
('(x=1, y=2)', '(x=${1:1}, y=${2:2})')

>>> get_placeholders(['x', 'y=2', 'z'])
('(x, y=2, z)', '(${1:x}, y=${2:2}, ${3:z})')
fortls.helper_functions.get_var_stack(line)

获取以给定行结尾的用户定义类型字段序列

参数：

**line** (str) – 文档行

返回值：

以 % 分隔的对象列表

返回类型:

list[str]

示例

>>> get_var_stack('myvar%foo%bar')
['myvar', 'foo', 'bar']

>>> get_var_stack('myarray(i)%foo%bar')
['myarray', 'foo', 'bar']

>>> get_var_stack('myarray( i ) % foo   % bar')
['myarray', 'foo', 'bar']

在这种情况下，它将在字符串末尾运行，即 'this%foo'

>>> get_var_stack('CALL self%method(this%foo')
['this', 'foo']

>>> get_var_stack('')
['']
fortls.helper_functions.map_keywords(keywords)
fortls.helper_functions.only_dirs(paths)

从字符串列表中返回仅为目录的路径

参数：

paths (list[str]) – 包含文件和目录的列表

返回值：

仅包含有效目录的列表

返回类型:

list[str]

引发:

FileNotFoundError – 包含所有不存在的目录的列表

示例

>>> only_dirs(['./test/', './test/test_source/', './test/test_source/test.f90'])
['./test/', './test/test_source/']

>>> only_dirs(['/fake/dir/a', '/fake/dir/b', '/fake/dir/c'])
Traceback (most recent call last):
FileNotFoundError: /fake/dir/a
/fake/dir/b
/fake/dir/c
fortls.helper_functions.parenthetic_contents(string)

生成字符串中带括号的内容作为 (内容，起始位置，级别) 对。

示例

>>> list(parenthetic_contents('character*(10*size(val(1), 2)) :: name'))
[('1', 22, 2), ('val(1), 2', 18, 1), ('10*size(val(1), 2)', 10, 0)]
fortls.helper_functions.resolve_globs(glob_path, root_path=None)

解析路径（绝对路径和相对路径）和 glob 模式，同时忽略不存在的路径

参数：
返回值：

使用绝对路径展开的 glob 模式。绝对路径用于解决任何潜在的歧义

返回类型:

list[str]

示例

相对于根路径 >>> import os, pathlib >>> resolve_globs(‘test’, os.getcwd()) == [str(pathlib.Path(os.getcwd()) / ‘test’)] True

绝对路径解析 >>> resolve_globs(‘test’) == [str(pathlib.Path(os.getcwd()) / ‘test’)] True

fortls.helper_functions.separate_def_list(test_str)

分隔定义列表，跳过括号和括号组。

参数：

test_str (str) – 文本字符串

返回值：

[描述]

返回类型:

list[str] | None

示例

>>> separate_def_list('var1, var2, var3')
['var1', 'var2', 'var3']

>>> separate_def_list('var, init_var(3) = [1,2,3], array(3,3)')
['var', 'init_var(3) = [1,2,3]', 'array(3,3)']
fortls.helper_functions.set_keyword_ordering(sorted)
fortls.helper_functions.strip_line_label(line)

去除开头的数字行标签

参数：

**line** (str) – 文本行

返回值：

输出字符串，如果不存在行标签，则行标签返回 None

返回类型:

tuple[str, str | None]

fortls.helper_functions.strip_strings(in_line, maintain_len=False)

从代码行中去除字符串字面量

参数：

  • in_line (str) – 文本字符串

  • maintain_len (bool, 可选) – 在输出字符串中保持 len(in_line)，默认为 False

返回值：

去除后的字符串

返回类型:

字符串

fortls.interface 模块

class fortls.interface.SetAction(option_strings, dest, nargs=None, const=None, default=None, type=None, choices=None, required=False, help=None, metavar=None)

基类：Action

fortls.interface.cli(name='fortls')

解析语言服务器的命令行参数

返回值：

命令行参数

返回类型:

argparse.ArgumentParser

fortls.json_templates 模块

fortls.json_templates.change_json(new_text, sln, sch, eln=None, ech=None)
fortls.json_templates.diagnostic_json(sln, sch, eln, ech, msg, sev)
fortls.json_templates.location_json(uri, sln, sch, eln=None, ech=None)
fortls.json_templates.range_json(sln, sch, eln=None, ech=None)
fortls.json_templates.symbol_json(name, kind, uri, sln, sch, eln=None, ech=None, container_name=None)
fortls.json_templates.uri_json(uri, sln, sch, eln=None, ech=None)

fortls.jsonrpc 模块

class fortls.jsonrpc.JSONRPC2Connection(conn=None)

基类：object

read_message(want=None)

读取通过当前连接发送的 JSON RPC 消息。如果 id 为 None，则返回下一个可用的消息。

send_notification(method, params)
send_request(method, params)
send_request_batch(requests)

流水线请求并返回响应。

响应是一个生成器，其中第 n 个响应对应于第 n 个请求。用户必须读取生成器直到结束，否则会泄漏线程。

write_error(rid, code, message, data=None)
write_response(rid, result)
exception fortls.jsonrpc.JSONRPC2ProtocolError

基类：Exception

class fortls.jsonrpc.ReadWriter(reader, writer)

基类：object

read(*args)
readline(*args)
write(out)
class fortls.jsonrpc.TCPReadWriter(reader, writer)

基类: ReadWriter

read(*args)
readline(*args)
write(out)
fortls.jsonrpc.deque_find_and_pop(d, f)
fortls.jsonrpc.path_from_uri(uri)
返回类型:

字符串

fortls.jsonrpc.path_to_uri(path)
返回类型:

字符串

fortls.jsonrpc.read_rpc_messages(content)
fortls.jsonrpc.write_rpc_notification(method, params)
fortls.jsonrpc.write_rpc_request(rid, method, params)

fortls.langserver 模块

exception fortls.langserver.JSONRPC2Error(code, message, data=None)

基类：Exception

class fortls.langserver.LangServer(conn, settings)

基类：object

static file_init(filepath, pp_defs, pp_suffixes, include_dirs, sort)

初始化一个 Fortran 文件

参数：

  • filepath (str) – 文件路径

  • pp_defs (dict) – 预处理器定义

  • pp_suffixes (list[str]) – 预处理器文件扩展名，除了默认值之外

  • include_dirs (set[str]) – 预处理器专用的包含目录，解析器不使用

  • sort (bool) – 是否应该对关键字进行排序

返回值：

一个 Fortran 文件对象或包含错误消息的字符串

返回类型:

fortran_file | str

get_all_references(def_obj, type_mem, file_obj=None)
get_definition(def_file, def_line, def_char, hover_req=False)

返回与 Fortran 文件、行号、列号匹配的定义的 Fortran 对象

参数：

  • def_file (fortran_file) – 要查询的文件

  • def_line (int) – 文件中的行位置

  • def_char (int) – 文件中的列位置

  • hover_req (bool, 可选) – 标志，用于启用是否从悬停请求调用，默认为 False

返回值：

Fortran 对象

返回类型:

fortran_var | fortran_include | None

get_diagnostics(uri)
handle(request)
post_message(msg, severity=1, exc_info=False)
run()
send_diagnostics(uri)
serve_autocomplete(request)
serve_codeActions(request)
serve_default(request)

在语言服务器中引发错误

参数：

request (dict) – 包含请求的客户端字典

引发:

JSONRPC2Error – 错误代码为 -32601

serve_definition(request)
serve_document_symbols(request)
serve_exit(request)
返回类型:

无

serve_hover(request)
serve_implementation(request)
serve_initialize(request)
serve_onChange(request)
serve_onClose(request)
serve_onOpen(request)
serve_onSave(request, did_open=False, did_close=False)
serve_references(request)
serve_rename(request)
serve_signature(request)
serve_workspace_symbol(request)
update_workspace_file(filepath, read_file=False, allow_empty=False, update_links=False)
workspace_init()

在多个线程之间初始化工作区根目录

fortls.langserver.update_recursion_limit(limit)

更新Python解释器的递归限制

参数：

limit (int) – 新的递归限制

返回类型:

无

示例

>>> update_recursion_limit(10000)

fortls.regex_patterns 模块

class fortls.regex_patterns.Fortran正则表达式(USE=re.compile('[ ]*USE([, ]+(?:INTRINSIC|NON_INTRINSIC))?[ :]+(\\\\w*)([, ]+ONLY[ :]+)?', re.IGNORECASE), IMPORT=re.compile('[ ]*IMPORT(?:[ ]*,[ ]*(?P<spec>ALL|NONE)|[ ]*,[ ]*(?P<only>ONLY)[ ]*:[ ]*(?P<start1>[\\\\w_])|[ ]+(?:::[ ]*)?(?P<start2>[\\\\w_]))?', re.IGNORECASE), INCLUDE=re.compile('[ ]*INCLUDE[ :]*[\\\\\\'\\\\"]([^\\\\\\'\\\\"]*)', re.IGNORECASE), CONTAINS=re.compile('[ ]*(CONTAINS)[ ]*$', re.IGNORECASE), IMPLICIT=re.compile('[ ]*IMPLICIT[ ]+([a-z]*)', re.IGNORECASE), SUB_MOD=re.compile('[ ]*(?!<[,\\\\()][ ]*)\\\\b(PURE|IMPURE|ELEMENTAL|RECURSIVE)\\\\b(?![,\\\\)][ ]*)', re.IGNORECASE), SUB=re.compile('[ ]*SUBROUTINE[ ]+(\\\\w+)', re.IGNORECASE), END_SUB=re.compile('SUBROUTINE', re.IGNORECASE), FUN=re.compile('[ ]*FUNCTION[ ]+(\\\\w+)', re.IGNORECASE), RESULT=re.compile('RESULT[ ]*\\\\((\\\\w*)\\\\)', re.IGNORECASE), END_FUN=re.compile('FUNCTION', re.IGNORECASE), MOD=re.compile('[ ]*MODULE[ ]+(\\\\w+)', re.IGNORECASE), END_MOD=re.compile('MODULE', re.IGNORECASE), SUBMOD=re.compile('[ ]*SUBMODULE[ ]*\\\\(', re.IGNORECASE), END_SMOD=re.compile('SUBMODULE', re.IGNORECASE), END_PRO=re.compile('(MODULE)?[ ]*PROCEDURE', re.IGNORECASE), BLOCK=re.compile('[ ]*([a-z_]\\\\w*[ ]*:[ ]*)?BLOCK|CRITICAL(?!\\\\w)', re.IGNORECASE), END_BLOCK=re.compile('BLOCK|CRITICAL', re.IGNORECASE), DO=re.compile('[ ]*(?:[a-z_]\\\\w*[ ]*:[ ]*)?DO([ ]+[0-9]*|$)', re.IGNORECASE), END_DO=re.compile('DO', re.IGNORECASE), WHERE=re.compile('[ ]*WHERE[ ]*\\\\(', re.IGNORECASE), END_WHERE=re.compile('WHERE', re.IGNORECASE), IF=re.compile('[ ]*(?:[a-z_]\\\\w*[ ]*:[ ]*)?IF[ ]*\\\\(', re.IGNORECASE), THEN=re.compile('\\\\)[ ]*THEN$', re.IGNORECASE), END_IF=re.compile('IF', re.IGNORECASE), ASSOCIATE=re.compile('[ ]*ASSOCIATE[ ]*\\\\(', re.IGNORECASE), END_ASSOCIATE=re.compile('ASSOCIATE', re.IGNORECASE), END_FIXED=re.compile('[ ]*([0-9]*)[ ]*CONTINUE', re.IGNORECASE), SELECT=re.compile('[ ]*(?:[a-z_]\\\\w*[ ]*:[ ]*)?SELECT[ ]*(CASE|TYPE)[ ]*\\\\(([\\\\w=> ]*)', re.IGNORECASE), SELECT_TYPE=re.compile('[ ]*(TYPE|CLASS)[ ]+IS[ ]*\\\\(([\\\\w ]*)', re.IGNORECASE), SELECT_DEFAULT=re.compile('[ ]*CLASS[ ]+DEFAULT', re.IGNORECASE), END_SELECT=re.compile('SELECT', re.IGNORECASE), PROG=re.compile('[ ]*PROGRAM[ ]+(\\\\w+)', re.IGNORECASE), END_PROG=re.compile('PROGRAM', re.IGNORECASE), INT=re.compile('[ ]*(ABSTRACT)?[ ]*INTERFACE[ ]*(\\\\w*)', re.IGNORECASE), END_INT=re.compile('INTERFACE', re.IGNORECASE), END_WORD=re.compile('[ ]*END[ ]*(DO|WHERE|IF|BLOCK|CRITICAL|ASSOCIATE|SELECT|TYPE|ENUM|MODULE|SUBMODULE|PROGRAM|INTERFACE|SUBROUTINE|FUNCTION|PROCEDURE)?([ ]+(?!\\\\W)|$)', re.IGNORECASE), TYPE_DEF=re.compile('[ ]*(TYPE)[, :]+', re.IGNORECASE), EXTENDS=re.compile('EXTENDS[ ]*\\\\((\\\\w*)\\\\)', re.IGNORECASE), GENERIC_PRO=re.compile('[ ]*(GENERIC)[, ]*(PRIVATE|PUBLIC)?[ ]*::[ ]*[a-z]', re.IGNORECASE), GEN_ASSIGN=re.compile('(ASSIGNMENT|OPERATOR)\\\\(', re.IGNORECASE), END_TYPED=re.compile('TYPE', re.IGNORECASE), ENUM_DEF=re.compile('[ ]*ENUM[, ]+', re.IGNORECASE), END_ENUMD=re.compile('ENUM', re.IGNORECASE), VAR=re.compile('[ ]*(INTEGER|REAL|DOUBLE[ ]*PRECISION|COMPLEX|DOUBLE[ ]*COMPLEX|CHARACTER|LOGICAL|PROCEDURE|EXTERNAL|CLASS|TYPE)', re.IGNORECASE), KIND_SPEC=re.compile('[ ]*([*]?\\\\([ ]*[\\\\w*:]|\\\\*[ ]*[0-9:]*)', re.IGNORECASE), KEYWORD_LIST=re.compile('[ ]*,[ ]*(PUBLIC|PRIVATE|ALLOCATABLE|POINTER|TARGET|DIMENSION[ ]*\\\\(|OPTIONAL|INTENT[ ]*\\\\([ ]*(?:IN|OUT|IN[ ]*OUT)[ ]*\\\\)|DEFERRED|NOPASS|PASS[ ]*\\\\(\\\\w*\\\\)|SAVE|PARAMETER|EXTERNAL|CONTIGUOUS)', re.IGNORECASE), PARAMETER_VAL=re.compile('\\\\w*[\\\\s\\\\&]*=(([\\\\s\\\\&]*[\\\\w\\\\.\\\\-\\\\+\\\\*\\\\/\\\\\\'\\\\"])*)', re.IGNORECASE), TATTR_LIST=re.compile('[ ]*,[ ]*(PUBLIC|PRIVATE|ABSTRACT|EXTENDS\\\\(\\\\w*\\\\))', re.IGNORECASE), VIS=re.compile('[ ]*\\\\b(PUBLIC|PRIVATE)\\\\b', re.IGNORECASE), WORD=re.compile('[a-z_][\\\\w\\\\$]*', re.IGNORECASE), NUMBER=re.compile('[\\\\+\\\\-]?(\\\\b\\\\d+\\\\.?\\\\d*|\\\\.\\\\d+)(_\\\\w+|d[\\\\+\\\\-]?\\\\d+|e[\\\\+\\\\-]?\\\\d+(_\\\\w+)?)?(?!\\\\w)', re.IGNORECASE), LOGICAL=re.compile('.true.|.false.', re.IGNORECASE), SUB_PAREN=re.compile('\\\\([\\\\w, ]*\\\\)', re.IGNORECASE), SQ_STRING=re.compile("\\\\'[^\\\\']*\\\\'", re.IGNORECASE), DQ_STRING=re.compile('\\\\"[^\\\\"]*\\\\"', re.IGNORECASE), LINE_LABEL=re.compile('[ ]*([0-9]+)[ ]+', re.IGNORECASE), NON_DEF=re.compile('[ ]*(CALL[ ]+[a-z_]|[a-z_][\\\\w%]*[ ]*=)', re.IGNORECASE), FIXED_COMMENT=re.compile('([!cd*])', re.IGNORECASE), FIXED_CONT=re.compile('( {5}[\\\\S])'), FIXED_DOC=re.compile('(?:[!cd\\\\*])([<>!])', re.IGNORECASE), FIXED_OPENMP=re.compile('[!c\\\\*]\\\\$OMP', re.IGNORECASE), FREE_COMMENT=re.compile('([ ]*!)'), FREE_CONT=re.compile('([ ]*&)'), FREE_DOC=re.compile('[ ]*!([<>!])'), FREE_OPENMP=re.compile('[ ]*!\\\\$OMP', re.IGNORECASE), FREE_FORMAT_TEST=re.compile('[ ]{1,4}[a-z]', re.IGNORECASE), DEFINED=re.compile('defined[ ]*\\\\(?[ ]*([a-z_]\\\\w*)[ ]*\\\\)?', re.IGNORECASE), PP_REGEX=re.compile('[ ]*#[ ]*(if |ifdef|ifndef|else|elif|endif)', re.IGNORECASE), PP_DEF=re.compile('[ ]*#[ ]*(define|undef|undefined)[ ]*(\\\\w+)(\\\\([ ]*([ \\\\w,]*?)[ ]*\\\\))?', re.IGNORECASE), PP_DEF_TEST=re.compile('(![ ]*)?defined[ ]*\\\\([ ]*(\\\\w*)[ ]*\\\\)$', re.IGNORECASE), PP_INCLUDE=re.compile('[ ]*#[ ]*include[ ]*([\\\\"\\\\w\\\\.]*)', re.IGNORECASE), PP_ANY=re.compile('^[ ]*#:?[ ]*(\\\\w+)'), CALL=re.compile('[ ]*CALL[ ]+[\\\\w%]*$', re.IGNORECASE), INT_STMNT=re.compile('^[ ]*[a-z]*$', re.IGNORECASE), TYPE_STMNT=re.compile('[ ]*(TYPE|CLASS)[ ]*(IS)?[ ]*$', re.IGNORECASE), PROCEDURE_STMNT=re.compile('[ ]*(PROCEDURE)[ ]*$', re.IGNORECASE), PRO_LINK=re.compile('[ ]*(MODULE[ ]*PROCEDURE )', re.IGNORECASE), SCOPE_DEF=re.compile('[ ]*(MODULE|PROGRAM|SUBROUTINE|FUNCTION|INTERFACE)[ ]+', re.IGNORECASE), END=re.compile('[ ]*(END)( |MODULE|PROGRAM|SUBROUTINE|FUNCTION|PROCEDURE|TYPE|DO|IF|SELECT)?', re.IGNORECASE), CLASS_VAR=re.compile('(TYPE|CLASS)[ ]*\\\\(', re.IGNORECASE), DEF_KIND=re.compile('(\\\\w*)[ ]*\\\\((?:KIND|LEN)?[ =]*(\\\\w*)', re.IGNORECASE), OBJBREAK=re.compile('[\\\\/\\\\-(.,+*<>=: ]', re.IGNORECASE))

基类：object

ASSOCIATE: Pattern = re.compile('[ ]*ASSOCIATE[ ]*\\(', re.IGNORECASE)
BLOCK: Pattern = re.compile('[ ]*([a-z_]\\w*[ ]*:[ ]*)?BLOCK|CRITICAL(?!\\w)', re.IGNORECASE)
CALL: Pattern = re.compile('[ ]*CALL[ ]+[\\w%]*$', re.IGNORECASE)
CLASS_VAR: Pattern = re.compile('(TYPE|CLASS)[ ]*\\(', re.IGNORECASE)
CONTAINS: Pattern = re.compile('[ ]*(CONTAINS)[ ]*$', re.IGNORECASE)
DEFINED: Pattern = re.compile('defined[ ]*\\(?[ ]*([a-z_]\\w*)[ ]*\\)?', re.IGNORECASE)
DEF_KIND: Pattern = re.compile('(\\w*)[ ]*\\((?:KIND|LEN)?[ =]*(\\w*)', re.IGNORECASE)
DO: Pattern = re.compile('[ ]*(?:[a-z_]\\w*[ ]*:[ ]*)?DO([ ]+[0-9]*|$)', re.IGNORECASE)
DQ_STRING: Pattern = re.compile('\\"[^\\"]*\\"', re.IGNORECASE)
END: Pattern = re.compile('[ ]*(END)( |MODULE|PROGRAM|SUBROUTINE|FUNCTION|PROCEDURE|TYPE|DO|IF|SELECT)?', re.IGNORECASE)
END_ASSOCIATE: Pattern = re.compile('ASSOCIATE', re.IGNORECASE)
END_BLOCK: Pattern = re.compile('BLOCK|CRITICAL', re.IGNORECASE)
END_DO: Pattern = re.compile('DO', re.IGNORECASE)
END_ENUMD: Pattern = re.compile('ENUM', re.IGNORECASE)
END_FIXED: Pattern = re.compile('[ ]*([0-9]*)[ ]*CONTINUE', re.IGNORECASE)
END_FUN: Pattern = re.compile('FUNCTION', re.IGNORECASE)
END_IF: Pattern = re.compile('IF', re.IGNORECASE)
END_INT: Pattern = re.compile('INTERFACE', re.IGNORECASE)
END_MOD: Pattern = re.compile('MODULE', re.IGNORECASE)
END_PRO: Pattern = re.compile('(MODULE)?[ ]*PROCEDURE', re.IGNORECASE)
END_PROG: Pattern = re.compile('PROGRAM', re.IGNORECASE)
END_SELECT: Pattern = re.compile('SELECT', re.IGNORECASE)
END_SMOD: Pattern = re.compile('SUBMODULE', re.IGNORECASE)
END_SUB: Pattern = re.compile('SUBROUTINE', re.IGNORECASE)
END_TYPED: Pattern = re.compile('TYPE', re.IGNORECASE)
END_WHERE: Pattern = re.compile('WHERE', re.IGNORECASE)
END_WORD: Pattern = re.compile('[ ]*END[ ]*(DO|WHERE|IF|BLOCK|CRITICAL|ASSOCIATE|SELECT|TYPE|ENUM|MODULE|SUBMODULE|PROGRAM|INTERFACE|SUBROUTINE|FUNCTION|PROCEDURE|FORALL)?([ ]+(?!\\W)|$)', re.IGNORECASE)
ENUM_DEF: Pattern = re.compile('[ ]*ENUM[, ]+', re.IGNORECASE)

EXTENDS: Pattern = re.compile('EXTENDS[ ]*\\((\\w*)\\)', re.IGNORECASE)
FIXED_COMMENT: Pattern = re.compile('([!cd*])', re.IGNORECASE)
FIXED_CONT: Pattern = re.compile('( {5}[\\S])')
FIXED_DOC: Pattern = re.compile('(?:[!cd\\*])([<>!])', re.IGNORECASE)
FIXED_OPENMP: Pattern = re.compile('[!c\\*]\\$OMP', re.IGNORECASE)
FREE_COMMENT: Pattern = re.compile('([ ]*!)')
FREE_CONT: Pattern = re.compile('([ ]*&)')
FREE_DOC: Pattern = re.compile('[ ]*!([<>!])')
FREE_FORMAT_TEST: Pattern = re.compile('[ ]{1,4}[a-z]', re.IGNORECASE)
FREE_OPENMP: Pattern = re.compile('[ ]*!\\$OMP', re.IGNORECASE)
FUN: Pattern = re.compile('[ ]*FUNCTION[ ]+(\\w+)', re.IGNORECASE)
GENERIC_PRO: Pattern = re.compile('[ ]*(GENERIC)[, ]*(PRIVATE|PUBLIC)?[ ]*::[ ]*[a-z]', re.IGNORECASE)
GEN_ASSIGN: Pattern = re.compile('(ASSIGNMENT|OPERATOR)\\(', re.IGNORECASE)
IF: Pattern = re.compile('[ ]*(?:[a-z_]\\w*[ ]*:[ ]*)?IF[ ]*\\(', re.IGNORECASE)
IMPLICIT: Pattern = re.compile('[ ]*IMPLICIT[ ]+([a-z]*)', re.IGNORECASE)
IMPORT: Pattern = re.compile('[ ]*IMPORT(?:[ ]*,[ ]*(?P<spec>ALL|NONE)|[ ]*,[ ]*(?P<only>ONLY)[ ]*:[ ]*(?P<start1>[\\w_])|[ ]+(?:::[ ]*)?(?P<start2>[\\w_]))?', re.IGNORECASE)
INCLUDE: Pattern = re.compile('[ ]*INCLUDE[ :]*[\\\'\\"]([^\\\'\\"]*)', re.IGNORECASE)
INT: Pattern = re.compile('[ ]*(ABSTRACT)?[ ]*INTERFACE[ ]*(\\w*)', re.IGNORECASE)
INT_STMNT: Pattern = re.compile('^[ ]*[a-z]*$', re.IGNORECASE)
KEYWORD_LIST: Pattern = re.compile('[ ]*,[ ]*(PUBLIC|PRIVATE|ALLOCATABLE|POINTER|TARGET|DIMENSION[ ]*\\(|OPTIONAL|INTENT[ ]*\\([ ]*(?:IN|OUT|IN[ ]*OUT)[ ]*\\)|DEFERRED|NOPASS|PASS[ ]*\\(\\w*\\)|SAVE|PARAMETER|EXTERNAL|CONTIGUOUS)', re.IGNORECASE)
KIND_SPEC: Pattern = re.compile('[ ]*([*]?\\([ ]*[\\w*:]|\\*[ ]*[0-9:]*)', re.IGNORECASE)
LINE_LABEL: Pattern = re.compile('[ ]*([0-9]+)[ ]+', re.IGNORECASE)
LOGICAL: Pattern = re.compile('.true.|.false.', re.IGNORECASE)
MOD: Pattern = re.compile('[ ]*MODULE[ ]+(\\w+)', re.IGNORECASE)
NON_DEF: Pattern = re.compile('[ ]*(CALL[ ]+[a-z_]|[a-z_][\\w%]*[ ]*=)', re.IGNORECASE)
NUMBER: Pattern = re.compile('[\\+\\-]?(\\b\\d+\\.?\\d*|\\.\\d+)(_\\w+|d[\\+\\-]?\\d+|e[\\+\\-]?\\d+(_\\w+)?)?(?!\\w)', re.IGNORECASE)
OBJBREAK: Pattern = re.compile('[\\/\\-(.,+*<>=: ]', re.IGNORECASE)
PARAMETER_VAL: Pattern = re.compile('\\w*[\\s\\&]*=(([\\s\\&]*[\\w\\.\\-\\+\\*\\/\\\'\\"])*)', re.IGNORECASE)
PP_ANY: Pattern = re.compile('^[ ]*#:?[ ]*(\\w+)')
PP_DEF: Pattern = re.compile('[ ]*#[ ]*(define|undef|undefined)[ ]*(\\w+)(\\([ ]*([ \\w,]*?)[ ]*\\))?', re.IGNORECASE)
PP_DEF_TEST: Pattern = re.compile('(![ ]*)?defined[ ]*\\([ ]*(\\w*)[ ]*\\)$', re.IGNORECASE)
PP_INCLUDE: Pattern = re.compile('[ ]*#[ ]*include[ ]*([\\"\\w\\.]*)', re.IGNORECASE)
PP_REGEX: Pattern = re.compile('[ ]*#[ ]*(if |ifdef|ifndef|else|elif|endif)', re.IGNORECASE)
PROCEDURE_STMNT: Pattern = re.compile('[ ]*(PROCEDURE)[ ]*$', re.IGNORECASE)
PROG: Pattern = re.compile('[ ]*PROGRAM[ ]+(\\w+)', re.IGNORECASE)
RESULT: Pattern = re.compile('RESULT[ ]*\\((\\w*)\\)', re.IGNORECASE)
SCOPE_DEF: Pattern = re.compile('[ ]*(MODULE|PROGRAM|SUBROUTINE|FUNCTION|INTERFACE)[ ]+', re.IGNORECASE)
SELECT: Pattern = re.compile('[ ]*(?:[a-z_]\\w*[ ]*:[ ]*)?SELECT[ ]*(CASE|TYPE)[ ]*\\(([\\w=> ]*)', re.IGNORECASE)
SELECT_DEFAULT: Pattern = re.compile('[ ]*CLASS[ ]+DEFAULT', re.IGNORECASE)
SELECT_TYPE: Pattern = re.compile('[ ]*(TYPE|CLASS)[ ]+IS[ ]*\\(([\\w ]*)', re.IGNORECASE)
SQ_STRING: Pattern = re.compile("\\'[^\\']*\\'", re.IGNORECASE)
SUB: Pattern = re.compile('[ ]*SUBROUTINE[ ]+(\\w+)', re.IGNORECASE)

SUBMOD: Pattern = re.compile('[ ]*SUBMODULE[ ]*\\(', re.IGNORECASE)
SUB_MOD: Pattern = re.compile('[ ]*(?!<[,\\()][ ]*)\\b(PURE|IMPURE|ELEMENTAL|RECURSIVE)\\b(?![,\\)][ ]*)', re.IGNORECASE)

解析过程关键字，但如果它们以逗号或左括号开头或以逗号或右括号结尾则不解析。 这是为了避免将名为 pure、impure 等的变量解析为关键字。

SUB_PAREN: Pattern = re.compile('\\([\\w, ]*\\)', re.IGNORECASE)
TATTR_LIST: Pattern = re.compile('[ ]*,[ ]*(PUBLIC|PRIVATE|ABSTRACT|EXTENDS\\(\\w*\\))', re.IGNORECASE)
THEN: Pattern = re.compile('\\)[ ]*THEN$', re.IGNORECASE)
TYPE_DEF: Pattern = re.compile('[ ]*(TYPE)[, :]+', re.IGNORECASE)
TYPE_STMNT: Pattern = re.compile('[ ]*(TYPE|CLASS)[ ]*(IS)?[ ]*$', re.IGNORECASE)
USE: Pattern = re.compile('[ ]*USE([, ]+(?:INTRINSIC|NON_INTRINSIC))?[ :]+(\\w*)([, ]+ONLY[ :]+)?', re.IGNORECASE)
VAR: Pattern = re.compile('[ ]*(INTEGER|REAL|DOUBLE[ ]*PRECISION|COMPLEX|DOUBLE[ ]*COMPLEX|CHARACTER|LOGICAL|PROCEDURE|EXTERNAL|CLASS|TYPE)', re.IGNORECASE)
VIS: Pattern = re.compile('[ ]*\\b(PUBLIC|PRIVATE)\\b', re.IGNORECASE)
WHERE: Pattern = re.compile('[ ]*WHERE[ ]*\\(', re.IGNORECASE)
WORD: Pattern = re.compile('[a-z_][\\w\\$]*', re.IGNORECASE)
fortls.regex_patterns.create_src_file_exts_regex(input_exts=[])

创建语言服务器应解析的源代码文件的正则表达式。

默认扩展名（不区分大小写）：F F03 F05 F08 F18 F77 F90 F95 FOR FPP

参数：

input_exts (列表[字符串], 可选) – 要解析的文件扩展名的附加列表，以 Python 正则表达式格式表示，这意味着特殊字符必须转义，默认为 []

示例

>>> regex = create_src_file_exts_regex([r"\.fypp", r"\.inc"])
>>> regex.search("test.fypp")
<re.Match object; span=(4, 9), match='.fypp'>
>>> regex.search("test.inc")
<re.Match object; span=(4, 8), match='.inc'>

>>> regex = create_src_file_exts_regex([r"\.inc.*"])
>>> regex.search("test.inc.1")
<re.Match object; span=(4, 10), match='.inc.1'>

无效的正则表达式将导致函数恢复为默认扩展名。

>>> regex = create_src_file_exts_regex(["*.inc"])
>>> regex.search("test.inc") is None
True
返回值：

用于匹配文件扩展名的已编译正则表达式。

返回类型:

Pattern[字符串]

fortls.regex_patterns.create_src_file_exts_str(input_exts=[])

这是 create_src_file_exts_regex 的一个版本，它接受一个列表，在编译正则表达式之前对 input_exts 列表进行清理。 有关更多信息，请参阅 create_src_file_exts_regex。

返回类型:

Pattern[str]

fortls.schema 模块

fortls.schema.create_schema(root=None)

fortls.version 模块

模块内容