Modules

The fdoc program: documentation for modern Fortran, from FORD project files.

The style sheet and script of the site. Generated from assets/ by tools/gen_assets.py.

Building text piece by piece, without functions returning deferred-length strings, so that it can be used in parallel regions (see example/slen_race.f90).

The command line. Options are those of FORD, and override the project file.

Reading declarations and procedure headers from the text of a statement.

Rendering the documentation of every entity from Markdown to HTML.

A port to Fortran of the parts of Fypp, the preprocessor by Bálint Aradi, that the Fortran standard library needs, so that fdoc can read Fypp sources without running Python.

The overview of a generic interface: which ways there are to call it, and which types and ranks each one takes. Specific procedures with the same arguments make a call form, and each form gets a table with a row for each combination of types and a column for each rank. Types are compared as written, so two names of one kind count as different types. Pages are rendered in parallel, so nothing here calls a function returning a deferred-length string (see example/slen_race.f90).

Dependency graphs: which modules use which, what procedures call, how types extend each other and how files depend on each other. Graphs are laid out and drawn by fdot, in parallel, each by one thread.

Syntax highlighting of Fortran, from fformat's tokens. Classes: k keywords and intrinsics, c comments, d doc comments, s strings, n numbers, p preprocessor lines.

Finding, reading and preprocessing source files.

Names that are not procedures of the project: Fortran's keywords and intrinsic procedures, with common compiler extensions.

Connecting names to entities: bindings, interfaces, implementations and procedure calls.

Markdown to HTML, in the dialect of Python-Markdown with the extensions FORD uses: fenced code, tables, footnotes, definition lists, abbreviations, attribute lists, Markdown inside HTML, math, file inclusion, and FORD's links, aliases and admonitions.

The documented program: source files and the entities in them.

Writing the documentation.

Static pages: a tree of Markdown files under page_dir, each directory with an index.md.

Turning a source text into entities: fformat finds the statements and their structure, and this module reads the declarations and doc comments.

Progress in the terminal: a live bar for each stage of the run, leaving a line with its time, and warnings that do not get mixed up with the bar. When standard output is not a terminal there are no bars or colours, just a line for each stage.

The whole project: loads and parses the files, merges them into one list of entities, and connects the entities with each other.

Reading settings from a project file, fpm.toml or a TOML string.

The project settings: FORD's options, their defaults and their conversion from text.

What standard Fortran cannot do with the file system, through the shell of the platform: cmd.exe on Windows, and sh elsewhere. All commands that differ between them are here. The tests call these from several threads, so they do not return deferred-length strings (see example/slen_race.f90).

Writing the HTML site. Pages are rendered and written in parallel, so nothing that renders a page calls a function returning a deferred-length string (see example/slen_race.f90).

The size of source files: how many lines hold code, comments or nothing. This uses fformat's tokens, so that a ! in a string is not taken for a comment. It runs in parallel, so nothing here calls a function returning a deferred-length string (see example/slen_race.f90).

Where entities are documented, and what [[name]] links refer to.

String, date and path helpers shared by the rest of fdoc.