# Not a comment anymore

(1,

(2,

(3,

(4,

(Unix)

(printf-like)

(see

, ...)

, Prev:

, Up:

, a definition for

, and

, opt

--define=

--enable-changeword

--prefix-builtins

--version

.  If

.  See

.  Thus

...)

...] [

199

<1>:

<NL>

=>    

=># Not a COMMENT anymore

=>/tmp/fooa07346

=>Diversion

=>Expansion one.

=>Expansion two.

=>GNUS NOT UNIX

=>Hello world.

=>Include file

=>Macro foo.

=>This is macro foo.

=>This text is diverted.

=>This text is not diverted.

=>arg1,arg2,arg3 ,arg4

=>expansion text

=>foo

=>true

About Makertf

About this help file

Also,

Arguments

Arguments to macros

Arithmetic

Bitwise

Bugs

Calculating length of strings

Changecom

Changequote

Changeword

Changing comment delimiters

Changing the comment delimiters

Changing the lexical structure of words

Changing the quote characters

Cleardiv

Comments

Comments in m4 input

Comparing strings

Compatibility

Compatibility with other versions of

Compatibility with other versions of m4

Concept index

Conditionals

Conditionals, loops and recursion

Control

Controlling debugging output

Debug Levels

Debug Output

Debugging

Decrement and increment operators

Defining a macro

Defining a new macro

Definitions

Defn

Deleting a macro

Deleting whitespace in input

Discarding diverted text

Displaying macro definitions

Diversion numbers

Diversion one: divnum

Diversion two: divnum

Diversions

Divert

Diverting and undiverting output

Diverting output

Divnum

Dnl

Dumpdef

Emacs.

Errprint

Esyscmd

Eval

Evaluating integer expressions

Executing simple commands

Exit codes

Exiting from

Exiting from m4

Expanding macros

Expecting

Extensions in GNU m4

Extracting substrings

Facilities in System V m4 not in GNU m4

Fast loading of frozen states

File Inclusion

First,

Format

Formatted output

Formatting strings (printf-like)

Frozen files

GNU

GNU extensions <

General

Hello world

Historical references

History

How to debug macros and input

How to define new macros

How to invoke macros

However,

If 

If-else construct, or multibranch

Ifdef

Ifelse

Include

Include file

Including named files

Inclusion

Incompat

Incompatibilities

Incr

Indir

Indirect call of builtins

Indirect call of macros

Inhibiting Invocation

Input Control

Intro

Introduction and preliminaries

Introduction to

Invocation

Invoking

Invoking m4

Later

Len

Levels

Lexical and syntactic conventions

Library

Loops and recursion

Loops and recursion in m4

M4PATH

M4exit

M4wrap

Macro Arguments

Macro expansion

Macro index

Macro invocation

Macro names

Macros

Macros for doing arithmetic

Macros for text handling

Makertf

Maketemp

Making names for temporary files

Miscellaneous

Miscellaneous builtin macros

Most

Next:

Node:

On Quoting Arguments to macros

Once

Other Incompat

Other incompatibilities

Other kinds of input tokens

Other tokens

Path

Patsubst

Please

Preliminaries

Prev:

Preventing macro invocation

Printing error messages

Prior to executing the command,

Problems and bugs

Pseudo Arguments

Pseudo arguments to macros

Pushdef

Quoted strings

Quoting

Quoting Arguments

Quoting input to m4

Quoting macro arguments

Reading the output of commands

Regexp

Renaming macros

Running UNIX commands

Saving debugging output

Saving input

Saving input until end of input

Search Path

Searching for include files

Searching for regular expressions

Searching for substrings

See

Source

Special arguments to macros

Substituting text by regular expression

Substr

Such

Syscmd

System

Sysval

TeX

Temporarily redefining macros

Testing if a macro is defined

Testing macro definitions

Text handling

The

The builtin

The builtin macro

The builtin macros

The expansion of

The macro

There

They

This enters

This text is diverted.

This text is not diverted.

Through

Thus

Thus,

Top

Trace

Tracing macro calls

Translating characters

Translit

UNIX

UNIX commands

Undefine

Undivert

Undiverting output

Unix',

Up:

Using this manual

Usually,

Vice

World.

You

\catcode`\

__file__

__line__

_forloop

`$2'

`$3',

`$@')

`(\&)')

`A-Z')

`A-Z')')dnl

`COMMENT')

`Hello

`This

`\w+',

``foo'

`a-z',

`di$1')

`expansion

`false')

`foo'.')

`macro

`translit(`$*',

`true')

`true',

ability

about

above

above.

accepts

access

actions.

active

actual

actually

after

all

all.

allows

also

alternative

always

amount

analysis

and

another

any

anymore

appear

append

appended.

application

applies

are

are recognized only when given arguments.

are the same as those of

arg2,

argument

argument,

argument.

arguments to macros:

arguments,

arguments.

arguments:

arithmetic,

arithmetic:

armadillos',

associated

assumed

attempt

automatic

available

avoided

back

bar

bar,

base

base.m4

base.m4f

based

because

been

before

beginning

being

being the text the entire regular expression matched.

between

between.

bigger

bitwise

brought

buffers.

builtin

builtins

builtins,

but

call

call,

call.

called

called.

calls

calls.

can

cannot

careful

case

case,

cases

causes

change

changecom(`/*', `*/')

changed

changing

chapter

character

character,

character.

characters

chars

cleanup

code

codes

collected

collected,

command

command line,

command,

commands

commands,

commands:

commas

commas,

comment

comment,

comments

comments.

common

compared

compiled

compiler

compiler.

completely

complex

conditions

configure

connection

consequently

construct,

contain

containing

contains

contents

controlled

controlling

conventions

converts

copied

copies

copy

could

counting:

course,

covered

created

current

debug

debug-level

debugfile

debugmode

decimal

decimal.

decr

decrement

default

define

define(`

define(`comment', `COMMENT')

define(`echo

define(`echo', `$@')

define(`exch', `$2, $1')

define(`foo', `Expansion one.')

define(`foo', `Hello world.')

define(`foo', `Macro `FOO'.')

define(`foo', `This is macro `foo'.')

define(`macro', `di$1')

defined

defined'

defined,

defines

defini

defining

definition

definition,

definition.

definitions,

definitions:

deleted

deletes

deleting

delimiter

delimiter.

delimiters

delimiters,

delimiters:

denoted

described

describes

details

details.

detect

difference,

differences

different

digit.

digits

digits,

direct

directive

directives

directly

directories

directory.

disables

discarded

discarded,

discarded.

discards

display

display.

displayed.

displaying

displays

distinguish

distribute

diversion

diversion.

divert(-1)

divert(0)undivert(1)dnl

divert(1)

divert(2)

diverted

diverted,

diverted.

diverting

documentation

documentation.

does

doing

done

e.g.,

each

echo(arg1,    arg2, arg3 , arg4)

effect

effectively

either

empty

end

ending

endless

enters

entire

equal

error

error,

error:

etc.

even

exactly

example

example,

example:

examples

except

excess

exclusive-or.

executes

executing

execution

existing

exit

expand

expanded

expanded,

expanded.

expanding

expands

expands into

expands to

expansion

expansion,

expansion.

expansion:

expansions

expected

experimental

exponentiation,

expressed

expression

expression:

expressions

expressions:

extensions

facilities

fairly

feature

few

file

file,

file.

file1.m4

file1.m4f

file2.m4

file2.m4f

file3.m4

file3.m4f

file4.m4

filename

filenames

files

files,

files.

files:

finished,

first

first.

fixed

flag is used, otherwise only the macros covered by calls of

flags

flags.

follow

followed

following

foo

foo,

foo.

for

for information on controlling the details of the display.

for more details.

for more information.

forloop

format

format:

found

four

fourth

from

frozen

function

functionnality

functions

further

generally

generated

generating

given

given.

giving

gnats,

granted

handling

has

have

hello

help

here

how

ifdef(`foo', ``foo' is defined', ``foo' is not defined')

ifelse(

ignored.

immediately

implementation

implemented

improve

incl.m4

included

including

inclusion, of files

increase

increment

incremented,

index

index.

indirect

indirect:

indirectly

information

information.

initializations.

input

input,

input-files

input.

input.m4

input:

inserted

inside

instead

instead of

instead,

integer

intended

internal

into

invocation,

invoke

is recognized only when given arguments.

is recognized only with parameters.

is void.

isolate

it.

iteration

its

itself.

jumped

just

languages.

larger

last

leading

left

length

length.

length1

length2

letter

letters

letters,

lexical

like

limit

limited

line

line,

line.

line:

linenum

lines

list

listed

little

loading

long

looked

loops

loops,

loops:

losing

lowercase

machine

macro

macro,

macro.

macro:

macros,

macros, arguments to

macros.

macros:

made

make

maketemp(`/tmp/fooXXXXXX')

making

manipulating

manual

manual.

many

match

match.

matched

matched.

matching

may

meaning

memory

memory,

message

messages

middle

might

missing

missing,

modeled

modified

more

mostly

much

multibranch

must

name

name,

name.

named

names

names,

names.

names:

necessarily

necessary

need

needed.

negation

nested,

nesting

never

new

newline

newline.

next

non-existent

normal

normally

not

not-equal

not.

notation

nothing

notice

number

number.

numbers

numbers:

numerical

occurs

of:

often

omitted,

one

one,

one.

one.')

one:

only

opening

operator:

operators

operators,

opt

option

option to

option will define the macro

option,

option.

options

options.

options:

or 

order

order.

other

otherwise

out,

output

output,

output.

output:

over

parameters.

parentheses

parentheses,

parenthesis

parenthesis.

parenthesized

part

passed

people

permission

place

point

popdef

popdef(`foo')

possible

precise

predefined

prefix

prefixed

present

present,

prevent

previous

printed

printf

printing

prior

problem

problem.

problems,

process

processed,

processor

processor.

produce

produced

program

programming

provided

pushdef(`foo', `Expansion two.')

quite

quote

quoted

quoted,

quoted.

quotes

quotes,

quotes.

radix

radix,

rather

read

reading

real

really

recognize

recognized

recover

recursion

recursion.

redefine

redefined

redefining

redefinition

references

regexp(

regular

regular expressions

relation

release

reload

remainder

remember

removed

removed,

removed.

rename

repeatedly

replaced

replacement

report

reporting

requires

reread

reread.

rescanning

respectively,

rest

result

resulting

results

return

reverse

running

safe

same

saved

saving

saving:

search

searches

second

seen,

send

sequence

several

shell

shell-command

shift

shift(

should

show

shown

shows

simple

simplest

simply

since

sinclude

single

slightly

some

something

special

specified

specified,

specifies

specify

squared

standard

start

starting

starts

state

states

still

stores

stream.

string

string,

string-1

string-2

string.

string1

string2

strings

strings,

strings.

strings:

structure

sub-expression

subject

substituted by the text matched by the

substitution

substring

substrings

supplied

supplied,

support

supported

supports

suppressed

symbol

sync

synchronisation

syntactic

syntax

table,

take

taken

template

temporarily

temporary

temporary:

test

text

text,

text.

th parenthesized sub-expression of

than

that

the

the:

them

then

therefore

these

things,

third

this

those

though

three

time

time,

time.

token

tokens

tokens:

topmost

traced

traceo

traceoff

traceon

tracing

traditional

trailing

translation

translations

triggered.

trying

two

two.

two.')

two:

unclear

undefine(`foo')

under

understand

undivert

undiverted

undiverted,

undiverting

unless

unquoted

unquoted,

until

unwanted

uppercase

usable

use

used

used,

useful

useful,

user

users

using

usually

value

value,

variable

various

varying

verbatim

version

version.

version:

versions

very

void,

void.

want

warning

warnings

was

way

were

what

whatever

when

whenever

where

whether

which

while

whitespace

width

width.

will

with

within

without

without reading any

word

words

work

working

world.'

world.')

would

write

writing

written

wrong

yet.

yield

you've

your

