Module numpy.distutils.from

process_file(filename)

takes templated file .xxx.src and produces .xxx file where .xxx is .pyf .f90 or .f using the following template rules:

'<..>' denotes a template.

All function and subroutine blocks in a source file with names that contain '<..>' will be replicated according to the rules in '<..>'.

The number of comma-separeted words in '<..>' will determine the number of replicates.

'<..>' may have two different forms, named and short. For example,

named:

<p=d,s,z,c> where anywhere inside a block '<p>' will be replaced with 'd', 's', 'z', and 'c' for each replicate of the block.

<_c> is already defined: <_c=s,d,c,z> <_t> is already defined: <_t=real,double precision,complex,double complex>

short:

<s,d,c,z>, a short form of the named, useful when no <p> appears inside a block.

In general, '<..>' contains a comma separated list of arbitrary expressions. If these expression must contain a comma|leftarrow|rightarrow, then prepend the comma|leftarrow|rightarrow with a backslash.

If an expression matches '<index>' then it will be replaced by <index>-th expression.

Note that all '<..>' forms in a block must have the same number of comma-separated entries.

Predefined named template rules:

<prefix=s,d,c,z> <ftype=real,double precision,complex,double complex> <ftypereal=real,double precision,0,1> <ctype=float,double,complex_float,complex_double> <ctypereal=float,double,0,1>

Variables

function_start_re

function_start_re = re.compile('\\n     (\\$|\\*)\\s*function\\b', re.I)

include_src_re

include_src_re = re.compile('(\\n|\\A)\\s*include\\s*[\'\\"](?P<name>[\\w\\d./\\\\]+[.]src)[\'\\"]', re.I)

item_re

item_re = re.compile('\\A\\\\(?P<index>\\d+)\\Z')

list_re

list_re = re.compile('<\\s*((.*?))\\s*>')

named_re

named_re = re.compile('<\\s*(\\w[\\w\\d]*)\\s*=\\s*(.*?)\\s*>')

routine_end_re

routine_end_re = re.compile('\\n\\s*end\\s*(subroutine|function)\\b.*(\\n|\\Z)', re.I)

routine_start_re

routine_start_re = re.compile('(\\n|\\A)((     (\\$|\\*))|)\\s*(subroutine|function)\\b', re.I)

template_name_re

template_name_re = re.compile('\\A\\s*(\\w[\\w\\d]*)\\s*\\Z')

template_re

template_re = re.compile('<\\s*(\\w[\\w\\d]*)\\s*>')

Functions

conv(astr)

expand_sub(substr, names)

find_repl_patterns(astr)

parse_structure(astr)

Return a list of tuples for each function or subroutine each tuple is the start and end of a subroutine or function to be expanded.

process_file(source)

process_str(allstr)

resolve_includes(source)

unique_key(adict)

Obtain a unique key given a dictionary.

Local name	Refers to
os	os
string	string
sys	sys

Local name

Refers to

string

sys

Module numpy.distutils.from_template

Variables

Function summary

Functions

Imported names