Procedures

True if c is of the category want of children_of.

Append text to b.

Add a block to node, with condition condition.

Add the reference ending at name j to e%more%calls, unless it is intrinsic or already there.

Add an edge to a description.

Set key in entries, replacing any entry it has.

Add modules documented elsewhere: extra_mods, and the modules.json of external projects.

Write value, not negative, which may be too large for int_text.

Add the modules that come with compilers and common libraries to extra_mods.

Append text for use in a JavaScript string in single quotes.

Add the links of entity id to node.

Add node id to a description.

Add the counts of item to total.

Add name for entity id to list, replacing any entity it has.

Add a value for key, whose position in meta%items is returned in current.

Write words as list items.

text without leading blanks.

An admonition: a line @note Type, then indented text.

Turn @note blocks into a line @note Type followed by indented lines, ending at @endnote, a blank line, another admonition, or the end of the text.

The admonition type that starts at line, or '', with where it is and what follows it.

Write the anchor of entity id.

Put node at the end of the block being read.

Apply command line options to the settings.

Apply statements such as public :: x to the entities they name.

Apply attribute value, from a statement in unit u, to entity e.

Apply the keys of TOML table as options.

Apply --config options: TOML with ; between lines.

Write the attributes of argument e.

The name of argument id.

Write a table of dummy arguments, or with components of other variables, such as the components of a type. Those have no intent, and may have a default value and a permission.

a + b, a - b or a * b.

The items of a TOML array as text. An array of tables is taken to be extra_filetypes.

The contents of assets/fdoc.css.

The contents of assets/fdoc.js.

Give each entity with a page of its own a page name that is unique in its directory, as FORD does: name, then name~2.

Set the variables targets to v, unpacking it if there are several.

True if the current token is word, as an operator or keyword.

Connect the dummy arguments and result of a procedure with their declarations.

Turn the contents of an attribute list, #id .class key=value, into HTML attributes.

Write text, an intent or attribute, as a badge. Its class comes from its first word, such as attr-pointer, which is what gives it its colour.

The bar for steps of size steps, width characters wide, with its filled and empty parts.

The Markdown options of a project.

Bind one name in a comprehension.

Bind the names of a loop to v in a comprehension.

Write a table of type-bound procedures.

The end of the [...] that opens at i, or 0.

Write what contains entity id, from its source file down, each with a link to its page.

Build the graphs of the project: those of s%graph, and of entities that ask for them.

Build the relations between entities.

C isatty.

A builtin function: defined, dict, len, list, range, reversed, str, zip.

#:call name(arguments) or #:block name(arguments).

Call macro which.

A method: of strings startswith, format, join, strip and split, and of dicts get.

Write how a call of a form looks. Square brackets mark what is optional.

Write what a procedure calls.

The last name of the component chain starting at token j, or 0.

The first token of the component chain ending at name j.

Validate the project file's settings and derive what depends on them, before the command line is applied.

The visible children of id that want accepts, sorted: 1 variables, 2 functions, 3 subroutines, 4 explicit and generic interfaces, 5 abstract interfaces, 6 types, 7 bindings, 8 final procedures, 9 namelists, 10 common blocks, 11 enumerations, 12 separate module procedures.

Leave a block, which must be of kind kind.

Finish an interface block. All but generic interfaces dissolve, leaving their bodies in the unit around them.

Close the current scope.

Finish entity id at its closing statement.

Find where emphasis of width marks c opened before start closes.

Position of the ) matching the ( at open in s, skipping strings, or 0.

The code block processor.

The HTML of a code block.

Make the abbreviations defined in any documentation apply everywhere, as they do in FORD.

Remove link references, footnotes and abbreviations from lines and keep them.

Find the documentation of each code statement.

The members of each list page, in the order of the sort setting.

Number of commas in text.

Write common blocks.

A chain of comparisons.

One comparison.

Compile expression text.

Add an edge, once. With label, the edge is dashed and labelled: components of a type have one.

The lines of low that could start or end a procedure or type.

True if s is in list.

The type whose members a reference through item reaches, or 0.

Act on control directive word.

Add to type id a copy of generic binding item, returning the copy.

Copy file from to to.

Copy from to the new array to.

Copy the files and directories that static pages list.

Copy file or directory from to to, with what a directory holds.

Copy a value, with what it holds.

Connect entities across files: the public names of each module, and what types inherit.

Number of blanks and tabs in s.

Number of line feeds in text.

Count the lines of text. A last line with no line ending counts as a line.

Day of the year of a date, from 1.

Remove the leading whitespace that all non-blank lines of lines share.

#:def name(arguments). Each argument's default is compiled to an entry of args, or 0 if none.

Set variable id in the current scope.

Define the macro of node id, evaluating its defaults now.

The definition list processor.

The text and rank of the type of variable id. Anything else, such as a dummy procedure, is procedure.

Put the graph of job in g. found is false if it would have only one node or no edges. Nodes go in as they are reached, and edges after them.

The value of text, without an internal read, as those take a lock.

Length of the result of display_name.

The base name of a file entity, or the name of another.

If line is a doxygen command, blank it and add it to moved as a metadata line.

Move doxygen @param name text lines from procedure id to the variables they describe.

Draw the bar of the current stage.

Lay out and draw one graph.

Lay out and draw jobs. A graph that turns out to have nothing to show gets no drawing.

The share of draw_graphs of one thread, with working space of its own.

How entities are connected, as JSON, for comparison with FORD.

The settings as a JSON object, for comparison with FORD's. Unset options are null.

The position of the end of the element starting at start, or 0.

Write text as numeric character references.

The position of the end of the line with position from: of its newline, or after the last line.

True if s finishes with suffix.

Write the anchor of an entity in a page.

The JSON form of entity id, for modules.json.

Render the page of entity id.

Write the title of an entity's page, with what is known about it.

The URL of an entity relative to the root of the site, or ''.

Write enumerations.

True if a equals b.

Evaluate expression id.

Evaluate the arguments of call id.

A call of a macro or a builtin function.

An f-string.

a[first:last].

Replace file include directives by the contents of the file.

Replace include lines in text by the files they name, found in directory or search.

path with $NAME and ${NAME} replaced by environment variables. Unset variables are left as written.

Go past token word, which must come next.

Write text as a badge, with an explanation for when the pointer is over it.

The extension of path, without the dot, or ''.

Record the first problem.

The language named after a code fence.

The length of the code fence that line starts with, or 0.

Write what is specific to a source file.

The entity named name at the top level of the project, or 0.

The child of parent named name, or 0.

Find a definition line in block.

Find the first # header line of block.

The position of name in symbols, or 0.

The position in p%modules of the module named name, or 0.

The number of name name, or 0.

Find the first line of block that quotes.

Find link reference id, returning its position or 0.

Find a line of block that is a horizontal rule.

Find the text of the construct keyword name in low, from its first line to its end line.

The source files of the project, sorted, without those excluded. Fixed-form files are left out with a warning, as they are not supported yet.

What name means in scope scope for category category (see in_category), or 0.

Make paths absolute and format dates, after all settings are applied.

The first line of text.

The first paragraph of html, or ''.

The part of text before its first blank.

The first blank-separated word of text, after any leading blanks.

Add the text between first and last as a text node.

Fold a line in Fypp's default way, at a blank near the end of the line if there is one.

Fold the long lines of text that hold results of evaluation. Others stay as they are.

Where to end the part of line after first, at most at last. Positions count from 0.

Fold each line of text.

#:for names in iterable.

Handle [[name(type):child(type)]], a link to an entity.

What specific procedure id has in common with those of its call form.

text.format(args), for fields {} and {n}.

Make sure that one more variable fits in frame.

The output of Fypp for file path. Each of defines is NAME or NAME=expression.

Replace text by the output of Fypp for path, or keep it if that fails.

Add the public bodies of the generic interfaces of module id.

True if path matches exclusion pattern, like Python's fnmatch: a * crosses /. A pattern that is not absolute may match the end of the path.

Write the graphs of entity id.

True if entity id is drawn with graphs.

Write value, not negative, with a comma between each group of three digits.

Make room for more edges.

Act on a directive of type kind, which is $, # or @.

True if path starts with a drive letter, as in C:.

True if comment c starts with ! and doc marker mark.

True if e has math in its documentation.

True if entity id has a page of its own.

True if path is absolute.

The # header processor.

Write code as highlighted HTML. With line_anchors, each line starts with an anchor ln-N.

Append text, escaped for HTML.

Write an icon linking to url, if it is set.

Add a variable for name, implicitly typed.

Add to module which what it makes public of what use with spec imports from module used.

True if entity e declares a name of category category: 1 procedures, 2 abstract interfaces, 3 types, 4 variables.

True if ch can be part of a name.

True if key is one of the blank-separated words of set, which starts and ends with a blank.

True if the innermost parser state is state.

#:include "file".

True if line is an include line, returning the file it names.

How deep block is in the lists of parent, and the node at that depth.

Index the entities that links can name from anywhere, for find_anywhere.

The value of name in table, or 0.

Render the front page.

Give name the value value in table.

Work out what type id inherits, after its parent type.

Copy the display settings that apply to id from its parent, and apply its own metadata.

The permission of what is declared now in id.

Write inline Markdown text as HTML.

Handle an abbreviation at i, if there is a whole word there.

Handle <: an automatic link or inline HTML.

Handle a backslash: math, or an escaped character.

Handle [: a FORD link, a footnote reference or a link.

Handle a code span.

Handle $: display math or an environment variable.

Handle * and _.

Handle &: an entity stays as it is, anything else is escaped.

Handle ![: an image.

Handle the punctuation that the smarty extension changes.

Replace the [TOC] marker by the table of contents.

k as text, in a fixed width. This is for parallel code, as an internal write takes a lock that threads end up spending most of their time on.

Write what is specific to a generic interface: the procedures in it.

The number of name name, added if it is new.

True if low starts with a word that gives attributes to names listed after it.

True if ch is a blank or a tab.

True if block starts with a bullet list item.

True if c is a digit.

True if procedure e is elemental.

True if statement v can have procedure references: not a declaration.

True if directory is an input of the project, so that it not being a page is expected.

True if name, in lowercase, is one of the names.

True if tag is ul or ol.

True if line is three of c, alone or followed by whitespace and anything else.

True if key is the name of an option.

True if block starts with an ordered list item.

True if text is one placeholder.

True if kind is a subroutine or function.

True if entities of kind are program units. The permission of a module is what its members get by default, so display says nothing about whether the module itself is shown.

True if line is a horizontal rule.

True if the second line of block underlines the first.

True if item and everything that holds it are shown.

True if a graph shows binding id as the procedure it binds: it binds one, which can be shown.

True if ch is white space.

True if block is a table: a header line with |, then a separator line.

True if low starts a type declaration rather than, for example, an assignment.

True on Windows, which sets the variable OS to this value.

The position where the item text of a list line starts, or 0 if it is not one.

The items of v, which is iterated over.

The strings of list with sep between them.

Length of the result of join.

The entity that label means in context, a scope or a type, or 0.

The text of each result.

The last child of node parent, or 0.

The position of the last separator in path, / or \, or 0.

Number of blanks at the start of line.

The first code tokens of v from token j, in lowercase and joined by blanks, up to about 80 characters.

The lowercase class for icon letter.

Remove empty, . and .. components from absolute path.

Write the name of license license, linked if it is a known one.

The position of keyword followed by name in line, or 0.

Write the anchor of line line.

Find what a type-bound procedure binds to and its interface.

Find what the calls of entity id refer to.

Find the procedure or interface named like type id.

Connect a separate module procedure with its interface, and copy what it does not repeat.

Find what a generic interface lists with module procedure.

Connect what the names in the project refer to.

Add submodule id to the descendants of its parent.

Read the (address "title") at open.

Write name, linked to entity id if it can be.

Find the modules that use statements and submodules refer to.

Find the type or interface that a variable declaration names.

Add an entity of kind kind inside parent, returning its index.

The list processors.

Write the columns of a list page between the name and the description.

The indented block processor: block continues a list.

The items of a list chunk.

The list page that entity id belongs on, or 0.

Render list page which.

Add the modules in the modules.json of an external project at url, a path or a web address.

Read the [extra.fdoc] or [extra.ford] table of fpm.toml file path, if there is one.

Read the pages of the project into pages, parents before children.

Read the settings and front page text of the project. Settings come from an [extra.fdoc] or [extra.ford] table in fpm.toml if there is one, and otherwise from the metadata of the project file. With no path the project file is ford.md, if it exists: [extra.fdoc] does not need one, as the text of the front page can be in its front_page, or the file named by front_page_file.

Find, load and parse the source files, and merge the results into p.

Read source file path, preprocessing it if its extension calls for that. Unless that runs an external command, this can be called from parallel code.

The path of include file name, or '' if it is not found.

Find the code of entities ids, all from one file. They are in source order, so each search starts where the last one found something. Only the lines that name a construct are searched, as a name that is not in the file, like those Fypp makes, would otherwise cost two readings of the file.

Find the code of each procedure and type in the text of its file. Files are handled in parallel.

The name in the site of the file of the logo setting: logo, with its extension, or '' if there is no such file.

Find the value of name id.

Remove level indents from each line of block that has them.

c in lowercase.

Make text lowercase, without a temporary, for text too long for the stack of a thread.

Make a bool value.

Create directory path with those above it, if it does not exist. It is not a failure if something else creates it first.

The end of every page.

Make an integer value.

range(...), as a list.

Make a string value.

zip(...), as a list of tuples.

The string entries of table in the form key<sep>value.

Mark the variables of unit id named in its common blocks.

Convert the Markdown texts in JSON array file path, and print the results as a JSON array.

Convert Markdown source to HTML.

True if line is key: value, indented by at most three blanks.

True if entity id is named name, in lowercase, and is of class entity.

Write math for MathJax.

Measure the source files of the list of files.

Move the entities of from to the end of p%list, adjusting their indices.

The position in p%modules of module entity id, or 0.

Move an expression, without copying what it holds.

Move a node, without copying what it holds.

Move a value, without copying what it holds.

Split name(entity).

The hash of name, FNV-1a, as a position in 1:size, where size is a power of 2.

The innermost entity on stack that can call procedures, or 0 if there is none or a declaration scope such as a type is inside it.

True if path goes through Fypp, which is Python, so that fdoc_fypp takes its place.

A new expression.

A new node.

Add a child with tag tag to node parent, returning it.

The defaults.

Go to the next token.

id in lowercase, with runs of whitespace as single blanks.

Expand tabs and blank lines of only spaces.

Write value as a cell of a table.

The word FORD uses for the kind of entity e.

True if entity e is of class entity, as written in a link. Any entity matches ''.

Enter block node.

Create the entity for a subroutine or function statement.

Open a scope that also sees frame up.

Create the entity for the statement opening construct construct, if it has one.

Set text to line(1:n) with the words of attribs removed, keeping the case of what is left.

True if type id declares a binding named name itself.

Create the directories of the static pages.

The HTML file for Markdown file name. As in FORD one other suffix goes too: CI.yml.md becomes CI.html.

Write the end of a page.

Write the start of a page.

Write the pages below page parent, or the top one if that is 0, as a tree of links.

name as used in file names and anchors.

Write the sections of a procedure page, for the sidebar.

The paragraph processor. In a tight list an item's text stays in the item.

Operands of and.

Read the command line.

The arguments of call id, up to closing.

Find the block processor for block and run it.

Read true or false, in any case.

Parse chunks into node parent.

Comparisons.

The for clauses after the item element.

Read one name of a declaration, such as x(3) = 1.

Read file path into the block being read.

Parse source text of file path into list, whose first entity is the file.

An f-string, whose quotes and escapes are already gone.

Read a decimal integer.

The items of a list or tuple, after the first, which is first.

An expression, or several separated by commas, which make a tuple.

Split project file text into metadata and body.

An operand of not.

Parse the single chunk chunk into node parent.

Operands of or.

A primary with what follows it: calls, subscripts and methods.

A primary: a literal, a name, or something in brackets.

Read a subroutine or function statement.

Factors multiplied.

Read a statement that opens nothing, if it declares anything.

A subscript of object, or a slice.

Terms added and subtracted.

An expression, which may be conditional.

Split text, the contents of file path, into text and directives.

Parse text that may hold several chunks into node parent.

Read the type at the start of line.

A factor, perhaps negated.

Length of the result of inherited_permission.

The order of the permission of e.

html as plain text of at most limit characters, with blanks collapsed.

Replace text by the output of the preprocessor for path, or keep it if that fails.

The preprocessor command for path. FORD's default of pcpp is Python, so it is replaced.

Write the attributes of procedure e that say how it behaves, as badges. Anything else is left out.

Write what is specific to a procedure.

Turn progress reports on.

Finish the stage, leaving its line.

Start stage name, of steps steps, or of unknown length if that is 0.

Report the end of the run.

Count a step, or steps of them. This can be called from any thread.

Hide what should not be displayed.

Compute the public names of module which, after those of the modules it uses.

The public entity of module which named name in category category, or 0.

The public names of module which in a category: 1 procedures, 2 abstract interfaces, 3 types, 4 variables.

Append s to list, allocating it if needed.

Put text back on the stack of chunks.

Append value to list.

Append value to list, allocating it if needed.

The name of entity id with those around it, up to its top-level unit.

The block quote processor.

text in quotes, as one argument of a command.

path in quotes, with the separator of the platform, as one argument of a command.

The text of type text with its rank. A rank in columns is left out, and a tied one is relative.

The rank given by dimension, such as (:,:): one more than the commas outside inner parentheses.

Add the names of an associate statement to associations.

Read a statement such as public :: x, keeping what it says until the unit is finished.

Read a type-bound procedure or generic statement.

Read a common statement, adding a common block entity for each block it names.

Read a variable declaration, adding a variable for each name.

Add the entity described by node of an external modules.json, with those inside it.

Read a final statement.

Read a line directive whose text starts at from, joining continuation lines.

Read a module procedure or procedure statement in an interface.

Read a name.

Read a namelist statement.

Read and render one page, adding it to pages.

Read source file path, warning if that fails.

Read a string in quotes, undoing its escapes.

Read a submodule statement.

Read the names separated by commas at the start of text.

Read the directory directory of pages, location below the top.

Read a type statement.

Read a use statement.

Read what follows the module name in a use statement.

Read all of file path. This can be called from parallel code, as all file I/O of threads has to take turns: libgfortran 16 can crash otherwise (see example/io_race.f90).

Record that the output from after first to last was evaluated.

s without blanks and tabs.

Remove id from the children of e.

Delete directory path with what it holds, if it exists.

Delete file path, if it can be. This can be called from parallel code.

Remove markdown="..." from an opening tag.

Render the nodes of body. With top, what is evaluated is recorded for line folding.

Render a call: the block is the last positional argument.

Write the children of node id.

The HTML of an indented code block, whose first line may name its language.

Render the documentation and summary of each entity.

Render the documentation and summary of entity id.

Write the footnotes that were referred to.

Write a heading or definition term. With the toc extension headings get ids.

Render a loop.

Render a node.

Write node id.

Write a table.

Render text, as if it belonged to entity context, for a page prefix away from the root.

attr with a blank after each comma.

Leave the innermost parser state.

Find what a [[name]] link means: see link_resolver in fdoc_markdown.

The absolute form of path relative to directory base, with variables expanded and . and .. removed, and with / as the separator on paths with a drive letter. Links are left as they are, and the path does not have to exist.

The cells of a table row, split at | outside code spans.

Run with command line args, returning the exit status.

Run clause k of comprehension id, collecting items.

Run command and wait for it. Without cmdstat, a program can stop with an error if the command is not found, which some shells report with status 127.

True if reading path runs an external preprocessor.

A string, integer or logical value of table as text.

The search index, as a script: browsers do not let a page opened from a file read JSON.

Render the search results page.

ticks of the clock as text.

An anchor for the section titled title.

The length of the kind selector at the start of text, which is (...), *n or *(...).

Give a procedure or interface named like type id, its constructor, the type's permission.

#:set names = expression.

Set the documentation and metadata of e from its doc lines.

Set a list option.

Set a logical option.

Set a map option from strings of the form key<sep>value. Empty strings are ignored.

Set option key, which must be one (see is_option), from its values as text.

Enter parser state state.

Set a text or path option.

Copy a parsed type to variable v.

The underlined header processor.

Write the summary of the procedures ids, if they all have the same one.

Replace item by what holds it, if it is inside something not shown, which has no page.

Write a sidebar group of links to the entities ids, on the same page if anchors.

Write the icon of entity e in a sidebar: a letter, with what it stands for as its tooltip.

The script holding the entries of the lists of the sidebar, for fdoc.js.

Write the declaration of a procedure.

Write the arguments of procedure e, each in the colour of its intent, as in the table of arguments.

Write the links to the list pages, for the sidebar. The list of the page is empty here, as it could be far too long to go in each page: fdoc.js fills it from sidebar.js. Pages outside the lists, which have no place in one, show the start of each list.

Write a size in bytes, with one decimal once it is in kilobytes or megabytes.

The first position from from that is not a blank.

Sort ids, keeping the source order of equal entries.

Put list in order.

Sort list by byte value, removing duplicates.

True if a sorts before b, for the sort setting.

Write the source of entity id, if source is set, from the text of its file.

Write a link to specific procedure id, further down the page.

Split what follows the type of a declaration into its attributes and the names declared.

Split text at blank lines, as text.split('\n\n') does.

The lines of text, ended by LF, CRLF or CR. As in Python's splitlines, a final line ending does not start another line.

The parts of text between the characters sep, including empty ones.

text.split(separator).

The blank-separated words of text.

True if ch can start a name.

True if s begins with prefix.

True if s starts with word word: followed by anything but a letter, digit or _.

Replace fenced code blocks by placeholders.

Keep html aside, returning the placeholder for it.

Replace block-level HTML by placeholders, rendering the contents of markdown="1" elements.

Add the procedures that a statement refers to to e%more%calls.

The code of statement item: its tokens as written, without comments and continuation marks. Continuation lines are joined as FORD joins them.

Render static page k.

Write stats as cells of a table. Each has the plain number, to sort by.

Write the row of totals of the list of files.

The length of the part of name that names its page.

The current local time in a strftime format.

s without leading and trailing whitespace.

s without trailing whitespace.

Length of s without leading and trailing whitespace.

Item index of a, counting from 0, and from the end if negative.

Replace |alias| by its value. |alias| gives the text without the backslash.

Write a short entry for entity id.

Write a section of short entries that link to the pages of ids.

Write a table row with exactly as many cells as align has.

The tag at position at of line, in lowercase, or ''.

Move the text of b to text.

The directory for temporary files.

Position of the first pattern in s outside brackets and strings, or 0.

True if a link to kind can name it from anywhere in the project.

The parts of s between the characters sep outside brackets and strings, each stripped.

The length of text without blanks at its end.

text without blanks at its end.

text without trailing line feeds.

The truth of v.

The binding named name of type id, including inherited ones, or 0.

Write what is specific to a derived type.

The length of the type keyword that low starts with, ignoring blanks in double precision, or 0. Its normal spelling is returned in word.

The component of kind kind named name of type id, including inherited ones, or 0.

An id for a heading with text html, not used before. Like Python-Markdown's slugify, this drops punctuation and turns each run of blanks and hyphens into one hyphen.

A number, as text, that another run at the same time is very unlikely to get, for temporary names.

Write what is specific to a module, submodule, program or block data unit.

Put stashed HTML back into html.

Percent-encode the characters of text that are not safe in a URL.

The help text.

True if the documentation shown on the page of id has math.

Write the use statements of a unit.

The derived type of variable id, or 0.

Add edges from from to what id calls. What cannot be shown is replaced by what it calls.

True if the source of entity id should be shown.

Write warning message to standard error, keeping the bar intact. This can be called from any thread.

Warn about settings that are read but have no effect.

Day of the week of a date: 0 for Sunday.

Turn the line ends of text into a line feed, as Python does when it reads text.

True if whole word word is at position at of s.

Length of the first blank-separated word of text.

Write the call forms of generic name, if it has more than one specific procedure. shown says whether anything was written.

Render the page of entity id and write it.

Render the pages of entities ids and write them, in parallel. A page is not kept once it is written, as together they can be larger than everything else in memory.

Write one call form, whose specific procedures are ids.

Write graph k.

Write a link.

Write modules.json, which other projects can use to link to this one.

Write the whole site.

Write text to standard output.

Write the type of variable e.

Write v as str() does, or as repr() does if quoted.

Replace the contents of file path. This can be called from parallel code.