3. Template File

The AutoGen template file defines the content of the output text. It is composed of two parts. The first part consists of a pseudo macro invocation and commentary. It is followed by the template proper.

This pseudo macro is special. It is used to identify the file as a AutoGen template file, fixing the starting and ending marks for the macro invocations in the rest of the file, specifying the list of suffixes to be generated by the template and, optionally, the shell to use for processing shell commands embedded in the template.

AutoGen-ing a file consists of copying text from the template to the output file until a start macro marker is found. The text from the start marker to the end marker constitutes the macro text. AutoGen macros may cause sections of the template to be skipped or processed several times. The process continues until the end of the template is reached. The process is repeated once for each suffix specified in the pseudo macro.

This chapter describes the format of the AutoGen template macros and the usage of the AutoGen native macros. Users may augment these by defining their own macros, See section DEFINE - Define a user AutoGen macro.

3.1 Format of the Pseudo Macro

The pseudo macro is used to tell AutoGen how to process a template. It tells autogen:

1. The start macro marker. It consists of punctuation characters used to demarcate the start of a macro. It may be up to seven characters long and must be the first non-whitespace characters in the file.

   It is generally a good idea to use some sort of opening bracket in the starting macro and closing bracket in the ending macro (e.g. {, (, [, or even < in the starting macro). It helps both visually and with editors capable of finding a balancing parenthesis.

2. That start marker must be immediately followed by the identifier strings "AutoGen5" and then "template", though capitalization is not important.

The next several components may be intermingled:

1. Zero, one or more suffix specifications tell AutoGen how many times to process the template file. No suffix specifications mean that it is to be processed once and that the generated text is to be written to ‘stdout’. The current suffix for each pass can be determined with the (suffix) scheme function (see section ‘suffix’ - get the current suffix).

   The suffix specification consists of a sequence of POSIX compliant file name characters and, optionally, an equal sign and a file name formatting specification. That specification may be either an ordinary sequence of file name characters with zero, one or two "%s" formatting sequences in it, or else it may be a Scheme expression that, when evaluated, produces such a string. The Scheme result may not be empty. The two string arguments allowed for that string are the base name of the definition file, and the current suffix (that being the text to the left of the equal sign). (Note: "POSIX compliant file name characters" consist of alphanumerics plus the period (.), hyphen (-) and underscore (_) characters.)

   If the suffix begins with one of these three latter characters and a formatting string is not specified, then that character is presumed to be the suffix separator. Otherwise, without a specified format string, a single period will separate the suffix from the base name in constructing the output file name.

2. Comments: blank lines, lines starting with a hash mark [#]), and edit mode comments (text between pairs of -*- strings).
3. Some scheme expressions may be inserted in order to make configuration changes before template processing begins. “before template processing begins” means that there is no current output file, no current suffix and, basically, none of the AutoGen specific functions (see section AutoGen Scheme Functions) may be invoked.

   It is used, for example, to allow the template writer to specify the shell program that must be used to interpret the shell commands in the template. It can have no effect on any shell commands in the definitions file, as that file will have been processed by the time the pseudo macro is interpreted.

   (setenv "SHELL" "/bin/sh")

   This is extremely useful to ensure that the shell used is the one the template was written to use. By default, AutoGen determines the shell to use by user preferences. Sometimes, that can be the "csh", though.

   The scheme expression can also be used to save a pre-existing output file for later text extraction (see section ‘extract’ - extract text from another file).

   (shellf "mv -f %1$s.c %1$s.sav" (base-name))

After these must come the end macro marker:

1. The punctuation characters used to demarcate the end of a macro. Like the start marker, it must consist of seven or fewer punctuation characters.

The ending macro marker has a few constraints on its content. Some of them are just advisory, though. There is no special check for advisory restrictions.

• It must not begin with a POSIX file name character (hyphen -, underscore _ or period .), the backslash (\) or open parenthesis ((). These are used to identify a suffix specification, indicate Scheme code and trim white space.
• If it begins with an equal sign, then it must be separated from any suffix specification by white space.
• The closing marker may not begin with an open parenthesis, as that is used to enclose a scheme expression.
• It cannot begin with a backslash, as that is used to indicate white space trimming after the end macro mark. If, in the body of the template, you put the backslash character (\) before the end macro mark, then any white space characters after the mark and through the newline character are trimmed.
• It is also helpful to avoid using the comment marker (#). It might be seen as a comment within the pseudo macro.
• You should avoid using any of the quote characters double, single or back-quote. It won't confuse AutoGen, but it might well confuse you and/or your editor.

As an example, assume we want to use [+ and +] as the start and end macro markers, and we wish to produce a ‘.c’ and a ‘.h’ file, then the pseudo macro might look something like this:

[+ AutoGen5 template -*- Mode: emacs-mode-of-choice -*-
h=chk-%s.h
c
# make sure we don't use csh:
(setenv "SHELL" "/bin/sh")  +]

The template proper starts after the pseudo-macro. The starting character is either the first non-whitespace character or the first character after the newline that follows the end macro marker.

3.2 Naming a value

When an AutoGen value is specified in a template, it is specified by name. The name may be a simple name, or a compound name of several components. Since each named value in AutoGen is implicitly an array of one or more values, each component may have an index associated with it.

It looks like this:

comp-name-1 . comp-name-2 [ 2 ]

Note that if there are multiple components to a name, each component name is separated by a dot (.). Indexes follow a component name, enclosed in square brackets ([ and ]). The index may be either an integer or an integer-valued define name. The first component of the name is searched for in the current definition level. If not found, higher levels will be searched until either a value is found, or there are no more definition levels. Subsequent components of the name must be found within the context of the newly-current definition level. Also, if the named value is prefixed by a dot (.), then the value search is started in the current context only. No higher levels are searched.

If someone rewrites this, I'll incorporate it. :-)

3.3 Macro Expression Syntax

AutoGen has two types of expressions: full expressions and basic ones. A full AutoGen expression can appear by itself, or as the argument to certain AutoGen built-in macros: CASE, IF, ELIF, INCLUDE, INVOKE (explicit invocation, see section INVOKE - Invoke a User Defined Macro), and WHILE. If it appears by itself, the result is inserted into the output. If it is an argument to one of these macros, the macro code will act on it sensibly.

You are constrained to basic expressions only when passing arguments to user defined macros, See section DEFINE - Define a user AutoGen macro.

The syntax of a full AutoGen expression is:

[[ <apply-code> ] <value-name> ] [ <basic-expr-1> [ <basic-expr-2> ]]

How the expression is evaluated depends upon the presence or absence of the apply code and value name. The "value name" is the name of an AutoGen defined value, or not. If it does not name such a value, the expression result is generally the empty string. All expressions must contain either a value-name or a basic-expr.

3.3.1 Apply Code

The "apply code" selected determines the method of evaluating the expression. There are five apply codes, including the non-use of an apply code.

‘no apply code’

This is the most common expression type. Expressions of this sort come in three flavors:

‘<value-name>’

The result is the value of value-name, if defined. Otherwise it is the empty string.

‘<basic-expr>’

The result of the basic expression is the result of the full expression, See section Basic Expression.

‘<value-name> <basic-expr>’

If there is a defined value for value-name, then the basic-expr is evaluated. Otherwise, the result is the empty string.

‘% <value-name> <basic-expr>’

If value-name is defined, use basic-expr as a format string for sprintf. Then, if the basic-expr is either a back-quoted string or a parenthesized expression, then hand the result to the appropriate interpreter for further evaluation. Otherwise, for single and double quote strings, the result is the result of the sprintf operation. Naturally, if value-name is not defined, the result is the empty string.

For example, assume that fumble had the string value, stumble:

[+ % fumble `printf '%%x\\n' $%s` +]

This would cause the shell to evaluate "printf '%x\n' $stumble". Assuming that the shell variable stumble had a numeric value, the expression result would be that number, in hex. Note the need for doubled percent characters and backslashes.

‘? <value-name> <basic-expr-1> <basic-expr-2>’

Two basic-expr-s are required. If the value-name is defined, then the first basic-expr-1 is evaluated, otherwise basic-expr-2 is.

‘- <value-name> <basic-expr>’

Evaluate basic-expr only if value-name is not defined.

‘?% <value-name> <basic-expr-1> <basic-expr-2>’

This combines the functions of ‘?’ and ‘%’. If value-name is defined, it behaves exactly like ‘%’, above, using basic-expr-1. If not defined, then basic-expr-2 is evaluated.

For example, assume again that fumble had the string value, stumble:

[+ ?% fumble `cat $%s` `pwd` +]

This would cause the shell to evaluate "cat $stumble". If fumble were not defined, then the result would be the name of our current directory.

3.3.2 Basic Expression

A basic expression can have one of the following forms:

‘'STRING'’

A single quoted string. Backslashes can be used to protect single quotes ('), hash characters (#), or backslashes (\) in the string. All other characters of STRING are output as-is when the single quoted string is evaluated. Backslashes are processed before the hash character for consistency with the definition syntax. It is needed there to avoid preprocessing conflicts.

‘"STRING"’

A double quoted string. This is a cooked text string as in C, except that they are not concatenated with adjacent strings. Evaluating "STRING" will output STRING with all backslash sequences interpreted.

‘`STRING`’

A back quoted string. When this expression is evaluated, STRING is first interpreted as a cooked string (as in `"STRING"') and evaluated as a shell expression by the AutoGen server shell. This expression is replaced by the ‘stdout’ output of the shell.

‘(STRING)’

A parenthesized expression. It will be passed to the Guile interpreter for evaluation and replaced by the resulting value. If there is a Scheme error in this expression, Guile 1.4 and Guile 1.6 will report the template line number where the error occurs. Guile 1.7 has lost this capability.

Additionally, other than in the % and ?% expressions, the Guile expressions may be introduced with the Guile comment character (;) and you may put a series of Guile expressions within a single macro. They will be implicitly evaluated as if they were arguments to the (begin ...) expression. The result will be the result of the last Guile expression evaluated.

3.4 AutoGen Scheme Functions

AutoGen uses Guile to interpret Scheme expressions within AutoGen macros. All of the normal Guile functions are available, plus several extensions (see section Common Scheme Functions) have been added to augment the repertoire of string manipulation functions and manage the state of AutoGen processing.

This section describes those functions that are specific to AutoGen. Please take note that these AutoGen specific functions are not loaded and thus not made available until after the command line options have been processed and the AutoGen definitions have been loaded. They may, of course, be used in Scheme functions that get defined at those times, but they cannot be invoked.

3.4.1 ‘ag-function?’ - test for function

Usage: (ag-function? ag-name)
return SCM_BOOL_T if a specified name is a user-defined AutoGen macro, otherwise return SCM_BOOL_F.

Arguments:
ag-name - name of AutoGen macro

3.4.2 ‘base-name’ - base output name

Usage: (base-name)
Returns a string containing the base name of the output file(s). Generally, this is also the base name of the definitions file.

This Scheme function takes no arguments.

3.4.3 ‘chdir’ - Change current directory

Usage: (chdir dir)
Sets the current directory for AutoGen. Shell commands will run from this directory as well. This is a wrapper around the Guile native function. It returns its directory name argument and fails the program on failure.

Arguments:
dir - new directory name

3.4.4 ‘count’ - definition count

Usage: (count ag-name)
Count the number of entries for a definition. The input argument must be a string containing the name of the AutoGen values to be counted. If there is no value associated with the name, the result is an SCM immediate integer value of zero.

Arguments:
ag-name - name of AutoGen value

3.4.5 ‘def-file’ - definitions file name

Usage: (def-file)
Get the name of the definitions file. Returns the name of the source file containing the AutoGen definitions.

This Scheme function takes no arguments.

3.4.6 ‘def-file-line’ - get a definition file+line number

Usage: (def-file-line ag-name [ msg-fmt ])
Returns the file and line number of a AutoGen defined value, using either the default format, "from %s line %d", or else the format you supply. For example, if you want to insert a "C" language file-line directive, you would supply the format "# %2$d \"%1$s\"", but that is also already supplied with the scheme variable See section format file info as, “#line nn "file"”. You may use it thus:

(def-file-line "ag-def-name" c-file-line-fmt)

It is also safe to use the formatting string, "%2$d". AutoGen uses an argument vector version of printf: See section Replacement for Stdio Formatting Library.

Arguments:
ag-name - name of AutoGen value
msg-fmt - Optional - formatting for line message

3.4.7 ‘dne’ - "Do Not Edit" warning

Usage: (dne prefix [ first_prefix ] [ optpfx ])
Generate a "DO NOT EDIT" or "EDIT WITH CARE" warning string. Which depends on whether or not the --writable command line option was set. The first argument is a per-line string prefix. The optional second argument is a prefix for the first-line and, in read-only mode, activates the editor hints.

-*- buffer-read-only: t -*- vi: set ro:

The warning string also includes information about the template used to construct the file and the definitions used in its instantiation.

The optional third argument is used when the first argument is actually an invocation option and the prefix arguments get shifted. The first argument must be, specifically, "-d". That is used to signify that the date stamp should not be inserted into the output.

Arguments:
prefix - string for starting each output line
first_prefix - Optional - for the first output line
optpfx - Optional - shifted prefix

3.4.8 ‘error’ - display message and exit

Usage: (error message)
The argument is a string that printed out as part of an error message. The message is formed from the formatting string:

DEFINITIONS ERROR in %s line %d for %s:  %s\n

The first three arguments to this format are provided by the routine and are: The name of the template file, the line within the template where the error was found, and the current output file name.

After displaying the message, the current output file is removed and autogen exits with the EXIT_FAILURE error code. IF, however, the argument begins with the number 0 (zero), or the string is the empty string, then processing continues with the next suffix.

Arguments:
message - message to display before exiting

3.4.9 ‘exist?’ - test for value name

Usage: (exist? ag-name)
return SCM_BOOL_T iff a specified name has an AutoGen value. The name may include indexes and/or member names. All but the last member name must be an aggregate definition. For example:

(exist? "foo[3].bar.baz")

will yield true if all of the following is true:
There is a member value of either group or string type named baz for some group value bar that is a member of the foo group with index 3. There may be multiple entries of bar within foo, only one needs to contain a value for baz.

Arguments:
ag-name - name of AutoGen value

3.4.10 ‘find-file’ - locate a file in the search path

Usage: (find-file file-name [ suffix ])
AutoGen has a search path that it uses to locate template and definition files. This function will search the same list for ‘file-name’, both with and without the ‘.suffix’, if provided.

Arguments:
file-name - name of file with text
suffix - Optional - file suffix to try, too

3.4.11 ‘first-for?’ - detect first iteration

Usage: (first-for? [ for_var ])
Returns SCM_BOOL_T if the named FOR loop (or, if not named, the current innermost loop) is on the first pass through the data. Outside of any FOR loop, it returns SCM_UNDEFINED. See section FOR - Emit a template block multiple times.

Arguments:
for_var - Optional - which for loop

3.4.12 ‘for-by’ - set iteration step

Usage: (for-by by)
This function records the "step by" information for an AutoGen FOR function. Outside of the FOR macro itself, this function will emit an error. See section FOR - Emit a template block multiple times.

Arguments:
by - the iteration increment for the AutoGen FOR macro

3.4.13 ‘for-from’ - set initial index

Usage: (for-from from)
This function records the initial index information for an AutoGen FOR function. Outside of the FOR macro itself, this function will emit an error. See section FOR - Emit a template block multiple times.

Arguments:
from - the initial index for the AutoGen FOR macro

3.4.14 ‘for-index’ - get current loop index

Usage: (for-index [ for_var ])
Returns the current index for the named FOR loop. If not named, then the index for the innermost loop. Outside of any FOR loop, it returns SCM_UNDEFINED. See section FOR - Emit a template block multiple times.

Arguments:
for_var - Optional - which for loop

3.4.15 ‘for-sep’ - set loop separation string

Usage: (for-sep separator)
This function records the separation string that is to be inserted between each iteration of an AutoGen FOR function. This is often nothing more than a comma. Outside of the FOR macro itself, this function will emit an error.

Arguments:
separator - the text to insert between the output of each FOR iteration

3.4.16 ‘for-to’ - set ending index

Usage: (for-to to)
This function records the terminating value information for an AutoGen FOR function. Outside of the FOR macro itself, this function will emit an error. See section FOR - Emit a template block multiple times.

Arguments:
to - the final index for the AutoGen FOR macro

3.4.17 ‘get’ - get named value

Usage: (get ag-name [ alt-val ])
Get the first string value associated with the name. It will either return the associated string value (if the name resolves), the alternate value (if one is provided), or else the empty string.

Arguments:
ag-name - name of AutoGen value
alt-val - Optional - value if not present

3.4.18 ‘get-c-name’ - get named value, mapped to C name syntax

Usage: (get-c-name ag-name)
Get the first string value associated with the name. It will either return the associated string value (if the name resolves), the alternate value (if one is provided), or else the empty string. The result is passed through "string->c-name!".

Arguments:
ag-name - name of AutoGen value

3.4.19 ‘get-down-name’ - get lower cased named value, mapped to C name syntax

Usage: (get-down-name ag-name)
Get the first string value associated with the name. It will either return the associated string value (if the name resolves), the alternate value (if one is provided), or else the empty string. The result is passed through "string->c-name!" and "string->down-case!".

Arguments:
ag-name - name of AutoGen value

3.4.20 ‘get-up-name’ - get upper cased named value, mapped to C name syntax

Usage: (get-up-name ag-name)
Get the first string value associated with the name. It will either return the associated string value (if the name resolves), the alternate value (if one is provided), or else the empty string. The result is passed through "string->c-name!" and "string->up-case!".

Arguments:
ag-name - name of AutoGen value

3.4.21 ‘high-lim’ - get highest value index

Usage: (high-lim ag-name)
Returns the highest index associated with an array of definitions. This is generally, but not necessarily, one less than the count value. (The indexes may be specified, rendering a non-zero based or sparse array of values.)

This is very useful for specifying the size of a zero-based array of values where not all values are present. For example:

tMyStruct myVals[ [+ (+ 1 (high-lim "my-val-list")) +] ];

Arguments:
ag-name - name of AutoGen value

3.4.22 ‘last-for?’ - detect last iteration

Usage: (last-for? [ for_var ])
Returns SCM_BOOL_T if the named FOR loop (or, if not named, the current innermost loop) is on the last pass through the data. Outside of any FOR loop, it returns SCM_UNDEFINED. See section FOR - Emit a template block multiple times.

Arguments:
for_var - Optional - which for loop

3.4.23 ‘len’ - get count of values

Usage: (len ag-name)
If the named object is a group definition, then "len" is the same as "count". Otherwise, if it is one or more text definitions, then it is the sum of their string lengths. If it is a single text definition, then it is equivalent to (string-length (get "ag-name")).

Arguments:
ag-name - name of AutoGen value

3.4.24 ‘low-lim’ - get lowest value index

Usage: (low-lim ag-name)
Returns the lowest index associated with an array of definitions.

Arguments:
ag-name - name of AutoGen value

3.4.25 ‘make-header-guard’ - make self-inclusion guard

Usage: (make-header-guard name)
This function will create a #ifndef/#define sequence for protecting a header from multiple evaluation. It will also set the Scheme variable header-file to the name of the file being protected and it will set header-guard to the name of the #define being used to protect it. It is expected that this will be used as follows:

[+ (make-header-guard "group_name") +]
...
#endif /* [+ (. header-guard) +] */

#include "[+ (. header-file)  +]"

The #define name is composed as follows:

1. The first element is the string argument and a separating underscore.
2. That is followed by the name of the header file with illegal characters mapped to underscores.
3. The end of the name is always, "_GUARD".
4. Finally, the entire string is mapped to upper case.

The final #define name is stored in an SCM symbol named header-guard. Consequently, the concluding #endif for the file should read something like:

#endif /* [+ (. header-guard) +] */

The name of the header file (the current output file) is also stored in an SCM symbol, header-file. Therefore, if you are also generating a C file that uses the previously generated header file, you can put this into that generated file:

#include "[+ (. header-file) +]"

Obviously, if you are going to produce more than one header file from a particular template, you will need to be careful how these SCM symbols get handled.

Arguments:
name - header group name

3.4.26 ‘match-value?’ - test for matching value

Usage: (match-value? op ag-name test-str)
This function answers the question, "Is there an AutoGen value named ag-name with a value that matches the pattern test-str using the match function op?" Return SCM_BOOL_T iff at least one occurrence of the specified name has such a value. The operator can be any function that takes two string arguments and yields a boolean. It is expected that you will use one of the string matching functions provided by AutoGen.
The value name must follow the same rules as the ag-name argument for exist? (see section ‘exist?’ - test for value name).

Arguments:
op - boolean result operator
ag-name - name of AutoGen value
test-str - string to test against

3.4.27 ‘out-delete’ - delete current output file

Usage: (out-delete)
Remove the current output file. Cease processing the template for the current suffix. It is an error if there are push-ed output files. Use the (error "0") scheme function instead. See section Redirecting Output.

This Scheme function takes no arguments.

3.4.28 ‘out-depth’ - output file stack depth

Usage: (out-depth)
Returns the depth of the output file stack. See section Redirecting Output.

This Scheme function takes no arguments.

3.4.29 ‘out-emit-suspended’ - emit the text of suspended output

Usage: (out-emit-suspended suspName)
This function is equivalent to (begin (out-resume <name>) (out-pop #t))

Arguments:
suspName - A name tag of suspended output

3.4.30 ‘out-line’ - output file line number

Usage: (out-line)
Returns the current line number of the output file. It rewinds and reads the file to count newlines.

This Scheme function takes no arguments.

3.4.31 ‘out-move’ - change name of output file

Usage: (out-move new-name)
Rename current output file. See section Redirecting Output. Please note: changing the name will not save a temporary file from being deleted. It may, however, be used on the root output file.

Arguments:
new-name - new name for the current output file

3.4.32 ‘out-name’ - current output file name

Usage: (out-name)
Returns the name of the current output file. If the current file is a temporary, unnamed file, then it will scan up the chain until a real output file name is found. See section Redirecting Output.

This Scheme function takes no arguments.

3.4.33 ‘out-pop’ - close current output file

Usage: (out-pop [ disp ])
If there has been a push on the output, then close that file and go back to the previously open file. It is an error if there has not been a push. See section Redirecting Output.

If there is no argument, no further action is taken. Otherwise, the argument should be #t and the contents of the file are returned by the function.

Arguments:
disp - Optional - return contents of the file

3.4.34 ‘out-push-add’ - append output to file

Usage: (out-push-add file-name)
Identical to push-new, except the contents are not purged, but appended to. See section Redirecting Output.

Arguments:
file-name - name of the file to append text to

3.4.35 ‘out-push-new’ - purge and create output file

Usage: (out-push-new [ file-name ])
Leave the current output file open, but purge and create a new file that will remain open until a pop delete or switch closes it. The file name is optional and, if omitted, the output will be sent to a temporary file that will be deleted when it is closed. See section Redirecting Output.

Arguments:
file-name - Optional - name of the file to create

3.4.36 ‘out-resume’ - resume suspended output file

Usage: (out-resume suspName)
If there has been a suspended output, then make that output descriptor current again. That output must have been suspended with the same tag name given to this routine as its argument.

Arguments:
suspName - A name tag for reactivating

3.4.37 ‘out-suspend’ - suspend current output file

Usage: (out-suspend suspName)
If there has been a push on the output, then set aside the output descriptor for later reactiviation with (out-resume "xxx"). The tag name need not reflect the name of the output file. In fact, the output file may be an anonymous temporary file. You may also change the tag every time you suspend output to a file, because the tag names are forgotten as soon as the file has been "resumed".

Arguments:
suspName - A name tag for reactivating

3.4.38 ‘out-switch’ - close and create new output

Usage: (out-switch file-name)
Switch output files - close current file and make the current file pointer refer to the new file. This is equivalent to out-pop followed by out-push-new, except that you may not pop the base level output file, but you may switch it. See section Redirecting Output.

Arguments:
file-name - name of the file to create

3.4.39 ‘set-option’ - Set a command line option

Usage: (set-option opt)
The text argument must be an option name followed by any needed option argument. Returns SCM_UNDEFINED.

Arguments:
opt - AutoGen option name + its argument

3.4.40 ‘set-writable’ - Make the output file be writable

Usage: (set-writable [ set? ])
This function will set the current output file to be writable (or not). This is only effective if neither the --writable nor --not-writable have been specified. This state is reset when the current suffix's output is complete.

Arguments:
set? - Optional - boolean arg, false to make output non-writable

3.4.41 ‘stack’ - make list of AutoGen values

Usage: (stack ag-name)
Create a scheme list of all the strings that are associated with a name. They must all be text values or we choke.

Arguments:
ag-name - AutoGen value name

3.4.42 ‘suffix’ - get the current suffix

Usage: (suffix)
Returns the current active suffix (see section Format of the Pseudo Macro).

This Scheme function takes no arguments.

3.4.43 ‘tpl-file’ - get the template file name

Usage: (tpl-file [ full_path ])
Returns the name of the current template file. If #t is passed in as an argument, then the template file is hunted for in the template search path. Otherwise, just the unadorned name.

Arguments:
full_path - Optional - include full path to file

3.4.44 ‘tpl-file-line’ - get the template file+line number

Usage: (tpl-file-line [ msg-fmt ])
Returns the file and line number of the current template macro using either the default format, "from %s line %d", or else the format you supply. For example, if you want to insert a "C" language file-line directive, you would supply the format "# %2$d \"%1$s\"", but that is also already supplied with the scheme variable See section format file info as, “#line nn "file"”. You may use it thus:

(tpl-file-line c-file-line-fmt)

It is also safe to use the formatting string, "%2$d". AutoGen uses an argument vector version of printf: See section Replacement for Stdio Formatting Library.

Arguments:
msg-fmt - Optional - formatting for line message

3.4.45 ‘autogen-version’ - autogen version number

This is a symbol defining the current AutoGen version number string. It was first defined in AutoGen-5.2.14. It is currently “5.9.5”.

3.4.46 format file info as, “#line nn "file"”

This is a symbol that can easily be used with the functions See section ‘tpl-file-line’ - get the template file+line number, and See section ‘def-file-line’ - get a definition file+line number. These will emit C program #line directives pointing to template and definitions text, respectively.

3.5 Common Scheme Functions

This section describes a number of general purpose functions that make the kind of string processing that AutoGen does a little easier. Unlike the AutoGen specific functions (see section AutoGen Scheme Functions), these functions are available for direct use during definition load time. The equality test (see section ‘string-eqv?’ - caseless string match) is “overloaded” to do string equivalence comparisons. If you are looking for inequality, the Scheme/Lisp way of spelling that is, “(not (= ...))”.