259 lines
		
	
	
		
			10 KiB
		
	
	
	
		
			Python
		
	
	
	
	
	
		
		
			
		
	
	
			259 lines
		
	
	
		
			10 KiB
		
	
	
	
		
			Python
		
	
	
	
	
	
| 
								 | 
							
								import re
							 | 
						||
| 
								 | 
							
								from collections.abc import Callable, Iterable, Mapping
							 | 
						||
| 
								 | 
							
								from typing import IO, Any, Concatenate, Final, Never, ParamSpec, TypeAlias, overload
							 | 
						||
| 
								 | 
							
								from typing import Literal as L
							 | 
						||
| 
								 | 
							
								
							 | 
						||
| 
								 | 
							
								from _typeshed import StrOrBytesPath, StrPath
							 | 
						||
| 
								 | 
							
								
							 | 
						||
| 
								 | 
							
								from .__version__ import version
							 | 
						||
| 
								 | 
							
								from .auxfuncs import isintent_dict as isintent_dict
							 | 
						||
| 
								 | 
							
								
							 | 
						||
| 
								 | 
							
								###
							 | 
						||
| 
								 | 
							
								
							 | 
						||
| 
								 | 
							
								_Tss = ParamSpec("_Tss")
							 | 
						||
| 
								 | 
							
								
							 | 
						||
| 
								 | 
							
								_VisitResult: TypeAlias = list[Any] | dict[str, Any] | None
							 | 
						||
| 
								 | 
							
								_VisitItem: TypeAlias = tuple[str | None, _VisitResult]
							 | 
						||
| 
								 | 
							
								_VisitFunc: TypeAlias = Callable[Concatenate[_VisitItem, list[_VisitItem], _VisitResult, _Tss], _VisitItem | None]
							 | 
						||
| 
								 | 
							
								
							 | 
						||
| 
								 | 
							
								###
							 | 
						||
| 
								 | 
							
								
							 | 
						||
| 
								 | 
							
								COMMON_FREE_EXTENSIONS: Final[list[str]] = ...
							 | 
						||
| 
								 | 
							
								COMMON_FIXED_EXTENSIONS: Final[list[str]] = ...
							 | 
						||
| 
								 | 
							
								
							 | 
						||
| 
								 | 
							
								f2py_version: Final = version
							 | 
						||
| 
								 | 
							
								tabchar: Final[str] = "    "
							 | 
						||
| 
								 | 
							
								
							 | 
						||
| 
								 | 
							
								f77modulename: str
							 | 
						||
| 
								 | 
							
								pyffilename: str
							 | 
						||
| 
								 | 
							
								sourcecodeform: L["fix", "gree"]
							 | 
						||
| 
								 | 
							
								strictf77: L[0, 1]
							 | 
						||
| 
								 | 
							
								quiet: L[0, 1]
							 | 
						||
| 
								 | 
							
								verbose: L[0, 1, 2]
							 | 
						||
| 
								 | 
							
								skipemptyends: L[0, 1]
							 | 
						||
| 
								 | 
							
								ignorecontains: L[1]
							 | 
						||
| 
								 | 
							
								dolowercase: L[1]
							 | 
						||
| 
								 | 
							
								
							 | 
						||
| 
								 | 
							
								beginpattern: str | re.Pattern[str]
							 | 
						||
| 
								 | 
							
								currentfilename: str
							 | 
						||
| 
								 | 
							
								filepositiontext: str
							 | 
						||
| 
								 | 
							
								expectbegin: L[0, 1]
							 | 
						||
| 
								 | 
							
								gotnextfile: L[0, 1]
							 | 
						||
| 
								 | 
							
								neededmodule: int
							 | 
						||
| 
								 | 
							
								skipblocksuntil: int
							 | 
						||
| 
								 | 
							
								groupcounter: int
							 | 
						||
| 
								 | 
							
								groupname: dict[int, str] | str
							 | 
						||
| 
								 | 
							
								groupcache: dict[int, dict[str, Any]] | None
							 | 
						||
| 
								 | 
							
								grouplist: dict[int, list[dict[str, Any]]] | None
							 | 
						||
| 
								 | 
							
								previous_context: tuple[str, str, int] | None
							 | 
						||
| 
								 | 
							
								
							 | 
						||
| 
								 | 
							
								f90modulevars: dict[str, dict[str, Any]] = {}
							 | 
						||
| 
								 | 
							
								debug: list[Never] = []
							 | 
						||
| 
								 | 
							
								include_paths: list[str] = []
							 | 
						||
| 
								 | 
							
								onlyfuncs: list[str] = []
							 | 
						||
| 
								 | 
							
								skipfuncs: list[str] = []
							 | 
						||
| 
								 | 
							
								skipfunctions: Final[list[str]] = []
							 | 
						||
| 
								 | 
							
								usermodules: Final[list[dict[str, Any]]] = []
							 | 
						||
| 
								 | 
							
								
							 | 
						||
| 
								 | 
							
								defaultimplicitrules: Final[dict[str, dict[str, str]]] = {}
							 | 
						||
| 
								 | 
							
								badnames: Final[dict[str, str]] = {}
							 | 
						||
| 
								 | 
							
								invbadnames: Final[dict[str, str]] = {}
							 | 
						||
| 
								 | 
							
								
							 | 
						||
| 
								 | 
							
								beforethisafter: Final[str] = ...
							 | 
						||
| 
								 | 
							
								fortrantypes: Final[str] = ...
							 | 
						||
| 
								 | 
							
								groupbegins77: Final[str] = ...
							 | 
						||
| 
								 | 
							
								groupbegins90: Final[str] = ...
							 | 
						||
| 
								 | 
							
								groupends: Final[str] = ...
							 | 
						||
| 
								 | 
							
								endifs: Final[str] = ...
							 | 
						||
| 
								 | 
							
								moduleprocedures: Final[str] = ...
							 | 
						||
| 
								 | 
							
								
							 | 
						||
| 
								 | 
							
								beginpattern77: Final[tuple[re.Pattern[str], L["begin"]]] = ...
							 | 
						||
| 
								 | 
							
								beginpattern90: Final[tuple[re.Pattern[str], L["begin"]]] = ...
							 | 
						||
| 
								 | 
							
								callpattern: Final[tuple[re.Pattern[str], L["call"]]] = ...
							 | 
						||
| 
								 | 
							
								callfunpattern: Final[tuple[re.Pattern[str], L["callfun"]]] = ...
							 | 
						||
| 
								 | 
							
								commonpattern: Final[tuple[re.Pattern[str], L["common"]]] = ...
							 | 
						||
| 
								 | 
							
								containspattern: Final[tuple[re.Pattern[str], L["contains"]]] = ...
							 | 
						||
| 
								 | 
							
								datapattern: Final[tuple[re.Pattern[str], L["data"]]] = ...
							 | 
						||
| 
								 | 
							
								dimensionpattern: Final[tuple[re.Pattern[str], L["dimension"]]] = ...
							 | 
						||
| 
								 | 
							
								endifpattern: Final[tuple[re.Pattern[str], L["endif"]]] = ...
							 | 
						||
| 
								 | 
							
								endpattern: Final[tuple[re.Pattern[str], L["end"]]] = ...
							 | 
						||
| 
								 | 
							
								entrypattern: Final[tuple[re.Pattern[str], L["entry"]]] = ...
							 | 
						||
| 
								 | 
							
								externalpattern: Final[tuple[re.Pattern[str], L["external"]]] = ...
							 | 
						||
| 
								 | 
							
								f2pyenhancementspattern: Final[tuple[re.Pattern[str], L["f2pyenhancements"]]] = ...
							 | 
						||
| 
								 | 
							
								formatpattern: Final[tuple[re.Pattern[str], L["format"]]] = ...
							 | 
						||
| 
								 | 
							
								functionpattern: Final[tuple[re.Pattern[str], L["begin"]]] = ...
							 | 
						||
| 
								 | 
							
								implicitpattern: Final[tuple[re.Pattern[str], L["implicit"]]] = ...
							 | 
						||
| 
								 | 
							
								intentpattern: Final[tuple[re.Pattern[str], L["intent"]]] = ...
							 | 
						||
| 
								 | 
							
								intrinsicpattern: Final[tuple[re.Pattern[str], L["intrinsic"]]] = ...
							 | 
						||
| 
								 | 
							
								optionalpattern: Final[tuple[re.Pattern[str], L["optional"]]] = ...
							 | 
						||
| 
								 | 
							
								moduleprocedurepattern: Final[tuple[re.Pattern[str], L["moduleprocedure"]]] = ...
							 | 
						||
| 
								 | 
							
								multilinepattern: Final[tuple[re.Pattern[str], L["multiline"]]] = ...
							 | 
						||
| 
								 | 
							
								parameterpattern: Final[tuple[re.Pattern[str], L["parameter"]]] = ...
							 | 
						||
| 
								 | 
							
								privatepattern: Final[tuple[re.Pattern[str], L["private"]]] = ...
							 | 
						||
| 
								 | 
							
								publicpattern: Final[tuple[re.Pattern[str], L["public"]]] = ...
							 | 
						||
| 
								 | 
							
								requiredpattern: Final[tuple[re.Pattern[str], L["required"]]] = ...
							 | 
						||
| 
								 | 
							
								subroutinepattern: Final[tuple[re.Pattern[str], L["begin"]]] = ...
							 | 
						||
| 
								 | 
							
								typespattern: Final[tuple[re.Pattern[str], L["type"]]] = ...
							 | 
						||
| 
								 | 
							
								usepattern: Final[tuple[re.Pattern[str], L["use"]]] = ...
							 | 
						||
| 
								 | 
							
								
							 | 
						||
| 
								 | 
							
								analyzeargs_re_1: Final[re.Pattern[str]] = ...
							 | 
						||
| 
								 | 
							
								callnameargspattern: Final[re.Pattern[str]] = ...
							 | 
						||
| 
								 | 
							
								charselector: Final[re.Pattern[str]] = ...
							 | 
						||
| 
								 | 
							
								crackline_bind_1: Final[re.Pattern[str]] = ...
							 | 
						||
| 
								 | 
							
								crackline_bindlang: Final[re.Pattern[str]] = ...
							 | 
						||
| 
								 | 
							
								crackline_re_1: Final[re.Pattern[str]] = ...
							 | 
						||
| 
								 | 
							
								determineexprtype_re_1: Final[re.Pattern[str]] = ...
							 | 
						||
| 
								 | 
							
								determineexprtype_re_2: Final[re.Pattern[str]] = ...
							 | 
						||
| 
								 | 
							
								determineexprtype_re_3: Final[re.Pattern[str]] = ...
							 | 
						||
| 
								 | 
							
								determineexprtype_re_4: Final[re.Pattern[str]] = ...
							 | 
						||
| 
								 | 
							
								determineexprtype_re_5: Final[re.Pattern[str]] = ...
							 | 
						||
| 
								 | 
							
								getlincoef_re_1: Final[re.Pattern[str]] = ...
							 | 
						||
| 
								 | 
							
								kindselector: Final[re.Pattern[str]] = ...
							 | 
						||
| 
								 | 
							
								lenarraypattern: Final[re.Pattern[str]] = ...
							 | 
						||
| 
								 | 
							
								lenkindpattern: Final[re.Pattern[str]] = ...
							 | 
						||
| 
								 | 
							
								namepattern: Final[re.Pattern[str]] = ...
							 | 
						||
| 
								 | 
							
								nameargspattern: Final[re.Pattern[str]] = ...
							 | 
						||
| 
								 | 
							
								operatorpattern: Final[re.Pattern[str]] = ...
							 | 
						||
| 
								 | 
							
								real16pattern: Final[re.Pattern[str]] = ...
							 | 
						||
| 
								 | 
							
								real8pattern: Final[re.Pattern[str]] = ...
							 | 
						||
| 
								 | 
							
								selectpattern: Final[re.Pattern[str]] = ...
							 | 
						||
| 
								 | 
							
								typedefpattern: Final[re.Pattern[str]] = ...
							 | 
						||
| 
								 | 
							
								typespattern4implicit: Final[re.Pattern[str]] = ...
							 | 
						||
| 
								 | 
							
								word_pattern: Final[re.Pattern[str]] = ...
							 | 
						||
| 
								 | 
							
								
							 | 
						||
| 
								 | 
							
								post_processing_hooks: Final[list[_VisitFunc[...]]] = []
							 | 
						||
| 
								 | 
							
								
							 | 
						||
| 
								 | 
							
								#
							 | 
						||
| 
								 | 
							
								def outmess(line: str, flag: int = 1) -> None: ...
							 | 
						||
| 
								 | 
							
								def reset_global_f2py_vars() -> None: ...
							 | 
						||
| 
								 | 
							
								
							 | 
						||
| 
								 | 
							
								#
							 | 
						||
| 
								 | 
							
								def rmbadname1(name: str) -> str: ...
							 | 
						||
| 
								 | 
							
								def undo_rmbadname1(name: str) -> str: ...
							 | 
						||
| 
								 | 
							
								def rmbadname(names: Iterable[str]) -> list[str]: ...
							 | 
						||
| 
								 | 
							
								def undo_rmbadname(names: Iterable[str]) -> list[str]: ...
							 | 
						||
| 
								 | 
							
								
							 | 
						||
| 
								 | 
							
								#
							 | 
						||
| 
								 | 
							
								def openhook(filename: StrPath, mode: str) -> IO[Any]: ...
							 | 
						||
| 
								 | 
							
								def is_free_format(fname: StrPath) -> bool: ...
							 | 
						||
| 
								 | 
							
								def readfortrancode(
							 | 
						||
| 
								 | 
							
								    ffile: StrOrBytesPath | Iterable[StrOrBytesPath],
							 | 
						||
| 
								 | 
							
								    dowithline: Callable[[str, int], object] = ...,
							 | 
						||
| 
								 | 
							
								    istop: int = 1,
							 | 
						||
| 
								 | 
							
								) -> None: ...
							 | 
						||
| 
								 | 
							
								
							 | 
						||
| 
								 | 
							
								#
							 | 
						||
| 
								 | 
							
								def split_by_unquoted(line: str, characters: str) -> tuple[str, str]: ...
							 | 
						||
| 
								 | 
							
								
							 | 
						||
| 
								 | 
							
								#
							 | 
						||
| 
								 | 
							
								def crackline(line: str, reset: int = 0) -> None: ...
							 | 
						||
| 
								 | 
							
								def markouterparen(line: str) -> str: ...
							 | 
						||
| 
								 | 
							
								def markoutercomma(line: str, comma: str = ",") -> str: ...
							 | 
						||
| 
								 | 
							
								def unmarkouterparen(line: str) -> str: ...
							 | 
						||
| 
								 | 
							
								def appenddecl(decl: Mapping[str, object] | None, decl2: Mapping[str, object] | None, force: int = 1) -> dict[str, Any]: ...
							 | 
						||
| 
								 | 
							
								
							 | 
						||
| 
								 | 
							
								#
							 | 
						||
| 
								 | 
							
								def parse_name_for_bind(line: str) -> tuple[str, str | None]: ...
							 | 
						||
| 
								 | 
							
								def analyzeline(m: re.Match[str], case: str, line: str) -> None: ...
							 | 
						||
| 
								 | 
							
								def appendmultiline(group: dict[str, Any], context_name: str, ml: str) -> None: ...
							 | 
						||
| 
								 | 
							
								def cracktypespec0(typespec: str, ll: str | None) -> tuple[str, str | None, str | None, str | None]: ...
							 | 
						||
| 
								 | 
							
								
							 | 
						||
| 
								 | 
							
								#
							 | 
						||
| 
								 | 
							
								def removespaces(expr: str) -> str: ...
							 | 
						||
| 
								 | 
							
								def markinnerspaces(line: str) -> str: ...
							 | 
						||
| 
								 | 
							
								def updatevars(typespec: str, selector: str | None, attrspec: str, entitydecl: str) -> str: ...
							 | 
						||
| 
								 | 
							
								def cracktypespec(typespec: str, selector: str | None) -> tuple[dict[str, str] | None, dict[str, str] | None, str | None]: ...
							 | 
						||
| 
								 | 
							
								
							 | 
						||
| 
								 | 
							
								#
							 | 
						||
| 
								 | 
							
								def setattrspec(decl: dict[str, list[str]], attr: str | None, force: int = 0) -> dict[str, list[str]]: ...
							 | 
						||
| 
								 | 
							
								def setkindselector(decl: dict[str, dict[str, str]], sel: dict[str, str], force: int = 0) -> dict[str, dict[str, str]]: ...
							 | 
						||
| 
								 | 
							
								def setcharselector(decl: dict[str, dict[str, str]], sel: dict[str, str], force: int = 0) -> dict[str, dict[str, str]]: ...
							 | 
						||
| 
								 | 
							
								def getblockname(block: Mapping[str, object], unknown: str = "unknown") -> str: ...
							 | 
						||
| 
								 | 
							
								def setmesstext(block: Mapping[str, object]) -> None: ...
							 | 
						||
| 
								 | 
							
								def get_usedict(block: Mapping[str, object]) -> dict[str, str]: ...
							 | 
						||
| 
								 | 
							
								def get_useparameters(block: Mapping[str, object], param_map: Mapping[str, str] | None = None) -> dict[str, str]: ...
							 | 
						||
| 
								 | 
							
								
							 | 
						||
| 
								 | 
							
								#
							 | 
						||
| 
								 | 
							
								@overload
							 | 
						||
| 
								 | 
							
								def postcrack2(
							 | 
						||
| 
								 | 
							
								    block: dict[str, Any],
							 | 
						||
| 
								 | 
							
								    tab: str = "",
							 | 
						||
| 
								 | 
							
								    param_map: Mapping[str, str] | None = None,
							 | 
						||
| 
								 | 
							
								) -> dict[str, str | Any]: ...
							 | 
						||
| 
								 | 
							
								@overload
							 | 
						||
| 
								 | 
							
								def postcrack2(
							 | 
						||
| 
								 | 
							
								    block: list[dict[str, Any]],
							 | 
						||
| 
								 | 
							
								    tab: str = "",
							 | 
						||
| 
								 | 
							
								    param_map: Mapping[str, str] | None = None,
							 | 
						||
| 
								 | 
							
								) -> list[dict[str, str | Any]]: ...
							 | 
						||
| 
								 | 
							
								
							 | 
						||
| 
								 | 
							
								#
							 | 
						||
| 
								 | 
							
								@overload
							 | 
						||
| 
								 | 
							
								def postcrack(block: dict[str, Any], args: Mapping[str, str] | None = None, tab: str = "") -> dict[str, Any]: ...
							 | 
						||
| 
								 | 
							
								@overload
							 | 
						||
| 
								 | 
							
								def postcrack(block: list[dict[str, str]], args: Mapping[str, str] | None = None, tab: str = "") -> list[dict[str, Any]]: ...
							 | 
						||
| 
								 | 
							
								
							 | 
						||
| 
								 | 
							
								#
							 | 
						||
| 
								 | 
							
								def sortvarnames(vars: Mapping[str, object]) -> list[str]: ...
							 | 
						||
| 
								 | 
							
								def analyzecommon(block: Mapping[str, object]) -> dict[str, Any]: ...
							 | 
						||
| 
								 | 
							
								def analyzebody(block: Mapping[str, object], args: Mapping[str, str], tab: str = "") -> list[dict[str, Any]]: ...
							 | 
						||
| 
								 | 
							
								def buildimplicitrules(block: Mapping[str, object]) -> tuple[dict[str, dict[str, str]], dict[str, str]]: ...
							 | 
						||
| 
								 | 
							
								def myeval(e: str, g: object | None = None, l: object | None = None) -> float: ...
							 | 
						||
| 
								 | 
							
								
							 | 
						||
| 
								 | 
							
								#
							 | 
						||
| 
								 | 
							
								def getlincoef(e: str, xset: set[str]) -> tuple[float | None, float | None, str | None]: ...
							 | 
						||
| 
								 | 
							
								
							 | 
						||
| 
								 | 
							
								#
							 | 
						||
| 
								 | 
							
								def get_sorted_names(vars: Mapping[str, Mapping[str, str]]) -> list[str]: ...
							 | 
						||
| 
								 | 
							
								def get_parameters(vars: Mapping[str, Mapping[str, str]], global_params: dict[str, str] = {}) -> dict[str, str]: ...
							 | 
						||
| 
								 | 
							
								
							 | 
						||
| 
								 | 
							
								#
							 | 
						||
| 
								 | 
							
								def analyzevars(block: Mapping[str, Any]) -> dict[str, dict[str, str]]: ...
							 | 
						||
| 
								 | 
							
								
							 | 
						||
| 
								 | 
							
								#
							 | 
						||
| 
								 | 
							
								def param_eval(v: str, g_params: dict[str, Any], params: Mapping[str, object], dimspec: str | None = None) -> dict[str, Any]: ...
							 | 
						||
| 
								 | 
							
								def param_parse(d: str, params: Mapping[str, str]) -> str: ...
							 | 
						||
| 
								 | 
							
								def expr2name(a: str, block: Mapping[str, object], args: list[str] = []) -> str: ...
							 | 
						||
| 
								 | 
							
								def analyzeargs(block: Mapping[str, object]) -> dict[str, Any]: ...
							 | 
						||
| 
								 | 
							
								
							 | 
						||
| 
								 | 
							
								#
							 | 
						||
| 
								 | 
							
								def determineexprtype(expr: str, vars: Mapping[str, object], rules: dict[str, Any] = {}) -> dict[str, Any]: ...
							 | 
						||
| 
								 | 
							
								def crack2fortrangen(block: Mapping[str, object], tab: str = "\n", as_interface: bool = False) -> str: ...
							 | 
						||
| 
								 | 
							
								def common2fortran(common: Mapping[str, object], tab: str = "") -> str: ...
							 | 
						||
| 
								 | 
							
								def use2fortran(use: Mapping[str, object], tab: str = "") -> str: ...
							 | 
						||
| 
								 | 
							
								def true_intent_list(var: dict[str, list[str]]) -> list[str]: ...
							 | 
						||
| 
								 | 
							
								def vars2fortran(
							 | 
						||
| 
								 | 
							
								    block: Mapping[str, Mapping[str, object]],
							 | 
						||
| 
								 | 
							
								    vars: Mapping[str, object],
							 | 
						||
| 
								 | 
							
								    args: Mapping[str, str],
							 | 
						||
| 
								 | 
							
								    tab: str = "",
							 | 
						||
| 
								 | 
							
								    as_interface: bool = False,
							 | 
						||
| 
								 | 
							
								) -> str: ...
							 | 
						||
| 
								 | 
							
								
							 | 
						||
| 
								 | 
							
								#
							 | 
						||
| 
								 | 
							
								def crackfortran(files: StrOrBytesPath | Iterable[StrOrBytesPath]) -> list[dict[str, Any]]: ...
							 | 
						||
| 
								 | 
							
								def crack2fortran(block: Mapping[str, Any]) -> str: ...
							 | 
						||
| 
								 | 
							
								
							 | 
						||
| 
								 | 
							
								#
							 | 
						||
| 
								 | 
							
								def traverse(
							 | 
						||
| 
								 | 
							
								    obj: tuple[str | None, _VisitResult],
							 | 
						||
| 
								 | 
							
								    visit: _VisitFunc[_Tss],
							 | 
						||
| 
								 | 
							
								    parents: list[tuple[str | None, _VisitResult]] = [],
							 | 
						||
| 
								 | 
							
								    result: list[Any] | dict[str, Any] | None = None,
							 | 
						||
| 
								 | 
							
								    *args: _Tss.args,
							 | 
						||
| 
								 | 
							
								    **kwargs: _Tss.kwargs,
							 | 
						||
| 
								 | 
							
								) -> _VisitItem | _VisitResult: ...
							 | 
						||
| 
								 | 
							
								
							 | 
						||
| 
								 | 
							
								#
							 | 
						||
| 
								 | 
							
								def character_backward_compatibility_hook(
							 | 
						||
| 
								 | 
							
								    item: _VisitItem,
							 | 
						||
| 
								 | 
							
								    parents: list[_VisitItem],
							 | 
						||
| 
								 | 
							
								    result: object,  # ignored
							 | 
						||
| 
								 | 
							
								    *args: object,  # ignored
							 | 
						||
| 
								 | 
							
								    **kwargs: object,  # ignored
							 | 
						||
| 
								 | 
							
								) -> _VisitItem | None: ...
							 | 
						||
| 
								 | 
							
								
							 | 
						||
| 
								 | 
							
								# namespace pollution
							 | 
						||
| 
								 | 
							
								c: str
							 | 
						||
| 
								 | 
							
								n: str
							 |