The Find and Replace... command in the Edit menu allows text, elements, and patterns to be found and replaced.
When you choose this command you will see a dialog box, like the one illustrated below, that allows you to enter various values and options.
The search and replace operations represented by the buttons at the bottom of the dialog box generally work the way they do in other word-processing applications. Note the following, however:
Choose Find Next to repeat a search using the most recent search text.
The Find text
entry box allows you to specify search text consisting of text characters, elements, or patterns. If the document contains a selection when you
choose
Find and Replace... the selected text will automatically become the search text. If the selected text is longer than 255 characters, it will be truncated. If the selection
contains an element it will be truncated at the last character before the start-tag icon.
The Replace text
entry box allows you to specify replace text consisting of text characters, elements, or patterns with which you want to replace the search text.
The Find In text
entry box allows you to restrict your search to a particular element.
The Find,
Replace, and
Find In text is described in more detail below.
There are five search options that you can set. You may want to search forward or backward through the file, match only whole words, match upper- and lower-case exactly, employ wrapping, or
perform pattern searching. These options can be used in combination. You can turn Backwards Search on or off by clicking in the check box in the
Find & Replace dialog box. The other options can be set by clicking on the [
Options...] button and then clicking in the appropriate check boxes in the dialog box that appears.
Whole Words means that the search will match a sequence of one or more
whole words only. For example, if you search for `red' with
Whole Words turned on, HoTMetaL PRO will not find it in `Fred'. Wrap is turned on, HoTMetaL PRO will wrap around the top or bottom of the file, depending on whether you are doing a forward or backward search. Find Patterns is turned off, any special search characters that you type in the search or replace text will be treated as ordinary
characters. See Using search patterns
for more information on patterns.The search and replace text can both consist of an element. An open angle bracket, `<', followed by a valid element name matches an element. The angle bracket must be the first thing on the line. If the search succeeds, the insertion point is positioned to the right of the start tag. The name in the search text can optionally be followed by a closing angle bracket (>).
For example,
<P
matches the element P. Element names are not case sensitive in HoTMetaL PRO, so `<p' and `<P' will match the same elements.
In a replacement, if the search text and the replace text are both elements, the element in the search text will be changed to the type specified in the replace text, if the HTML rules allow it. The contents of the element will be unchanged.
If the search text matches text (as opposed to an element) and the replace text is an element, the element will be inserted after the found text if the replacement operation is carried out.
The search text can contain both an element name and, following it, some text (or a pattern) that must be matched within the element. In this case the element name must end with a closing angle bracket. For example:
<P>the
would match the word `the' anywhere within the element
P. This is similar to the kind of restrictive searching that can be done using the Find In text but it can be used in conjunction with that feature to further
restrict the search. In the last example, if the Find In text is set to:
<OL
the word `the' would be matched if it appeared in a paragraph in an OL list but not if it appeared in a paragraph in another context.
An element name in the replace text cannot be followed by text: if it is, an error message will be displayed and the replace operation will not be performed.
You can restrict the search to an element with specific attribute values. This is done in the search text by following the element name with a space-separated list consisting of attribute names followed by an equal sign, `=', followed by a value contained in double quotes (" "). For example:
<a name="donkey"
will search only for those A elements whose NAME attribute has the value `donkey'.
You can specify replacement attribute values in the replace text. For example, you could use the following replace text in conjunction with the find text in the previous example:
<a name="burro"
Any attribute values that aren't specified in the replace text will remain unchanged.
Search patterns can be used to specify attribute values. You can specify as many attributes as you wish, and in any order.
One of HoTMetaL PRO's more powerful search features is its ability to restrict a search to the contents of a particular element type. For example, you could search for a word only when it appears in an EM element.
Use the Find In
text entry box
to specify the element that you want to restrict searching to. Specify the element in the same way you would in the search text, except that the element name can't be
followed by text. Attribute values may also be specified in the
Find In text-you can use
Find In text such as:
<a name="donkeys"
If you have badly-formed search or replace text, HoTMetaL PRO will display an error dialog box giving a description of the error. Errors that will be reported include: invalid attribute or element names; unmatched parentheses and brackets in search patterns; `?', `*', or `+' not preceded by any character; invalid character ranges.
For example, if you use the search pattern:
<QUAGMIRE
you will get the error message:
Find: Invalid element name
because the HTML rules do not allow an element called QUAGMIRE.
If the Find Patterns option is turned on
the characters you type in the Find text
entry box are interpreted as
patterns by
HoTMetaL PRO: that is, the search text can contain certain special search characters that allow the search text to match a class of text strings, or markup constructs. (If your search text does not
contain any special search characters, HoTMetaL PRO will search for exactly the text you have typed.) For example, the search character `.' (period) is used in the following pattern:
m...y
This matches a sequence of five characters beginning with `m' and ending with `y', e.g., the words `money', `marry', `murky', etc.
The following characters are special search characters in a search pattern:
. * ? + ^ $ [ ]
In addition, the character `<' (used to specify an element search) is special when it appears as the first character of the pattern.
To search for any special character as an ordinary character when Find Patterns is turned on, precede it with a backslash. For example:
\.
is used to match a period.
Search patterns may be enclosed within parentheses for grouping.
Any single character (other than a special character) matches itself in a search pattern. To match a single, arbitrary character, use a period or dot, `.'. This will also match a single blank space. Therefore:
fo.d
would match `food', `ford', `fond', `fold', etc. Similarly,
s.o.
matches `stop', `shot', `snow', etc.
A single character, or text enclosed in parentheses, followed by an asterisk, `*', matches zero or more occurrences of that character or text. For example:
l*ama
would match `ama', `lama', `llama', `lllama', etc.
b(an)*a
would match `ba', `bana', `banana', and so on.
You can combine the `*' with `.' to match arbitrary text. So:
s.*ch
matches `search', `such', `stretch', `stopwatch', as well as `sch' and `skip lunch'. This search pattern represents text that starts with `s' followed by zero or more occurrences of an arbitrary single character (it doesn't have to be the same character over and over) followed by the characters `ch'. Since the period can match a blank space, this pattern can match a multi-word piece of text.
A single character, or text enclosed in parentheses, followed by a plus sign, `+', matches one or more occurrences of that character or text. For example, the following expression matches `ben', `been', `beeen', and so forth, but not `bn'.
be+n
A single character, or text enclosed in parentheses, followed by a question mark, `?', matches zero or one occurrences of that character or text. For example, to search for instances of both `color' and `colour', you would use:
colou?r
If you want to search for either of two search patterns, separate them with a vertical bar, `|'. This will match any text that matches either of the patterns. For example, if you wanted to search for either `love' or `money', you would use the expression:
love|money
You can combine two search patterns:
s.*ch|fo.d
A caret, `^', at the very beginning of a search pattern means that text will match the pattern only if it immediately follows a start- or end-tag. Such text must not be separated from the tag by white space. Anywhere else, the caret is not treated as a special search character (except in character ranges, see below). For example, if you wanted to search for the word `Note' immediately following a tag, you would use:
^Note
A dollar sign, `$', at the very end of a search pattern means that text will match the pattern only if it is immediately followed by a tag. The text must not be separated from the tag by white space. Anywhere else, the dollar sign is not treated as a special search character. For example, if you wanted to search for the word `sub' immediately preceding a tag, you would use:
sub$
A pair of square brackets, `[' and `]', around any group of characters defines a range that matches any one of the characters between the brackets. The simplest case is of this type:
an[dy]
This matches `and' and `any'.
A range of characters of the form
[char1-char2]
matches any character beginning at char1 and ending at char2. For example:
[e-p]
matches any lowercase letter between `e' and `p', inclusive. The pattern:
[A-Za-z]
matches any upper or lower case letter.
[A-Za-z0-9]
matches any alphanumeric character.
A range of characters can be embedded in a longer range. For example, the pattern:
[ac-fh]
matches any of `a', `c' through `f', and `h'.
If searching is not in case-sensitive mode, no distinction between lower case and upper case letters is made in character ranges. In this situation, for example, the character range:
[a-z]
would match any upper- or lower-case letter.
You can reverse the meaning of a character range by preceding it with a caret, `^': this causes it to match any character not in the range. For example:
th[^ei]n
matches `than' but not `then' or `thin'. An expression of the form:
[^char1-char2]
matches any character not in the range of characters beginning at char1 and ending at char2.
If you surround a sub-expression in the search text by parentheses, `(' and `)', you can refer in the replace text to whatever this sub-expression matches. In general, an expression in the replace text of the form `\n', where n is a number from 1 to 9, means `replace this expression with whatever the nth expression in brackets in the search text has matched'. For example, if the search text is:
(.)read
and the replace text is:
\1ox
then if the search text matches `bread', the found text will be replaced by `box'. This is because the sub-expression `(.)' matched the letter `b'; the expression `\1' in the replace text means `replace this expression with whatever is matched by the first expression in parentheses in the search text'. Therefore `b' is substituted for `\1' and the replace text becomes `box'.
Here is a more complicated example: suppose the search text is:
(v.*e) (v.*a)
and the replace text is:
\2 \1
Now the search text may match the words `vice versa'. The first sub-expression, `(v.*e)', matches `vice' and the second sub-expression, `(v.*a)', matches `versa'. In the replace text, HoTMetaL PRO replaces `\2' by what the second sub-expression in the search text matched, and replaces `\1' by what the first sub-expression matched. Therefore the replace text becomes `versa vice'. The net effect of the operation is to replace an occurrence of `vice versa' with `versa vice'.
It is possible to nest sub-expressions. In this situation, the sub-expressions are numbered according to the order of occurrence of their left parentheses. For example, if the search text were:
(a(bc)d)
and the replace text:
\2 \1
the effect would be to find `abcd' and replace it by `bc abcd'.
The expression `\0' in the replace text refers to the entire text that was matched by the search text. For example, if the search text were:
fish
and the replace text were:
gone \0ing
then an occurrence of `fish' would be replaced by `gone fishing'.
You can use `\n' expressions in attribute replacement values: one application of this technique is changing the value of a group of URLs in some regular way. (The Publish... command lets you change the scheme for a set of URLs: the `\n' is actually a more general form of this kind of substitution). For example, if you want to change all of the filenames in your A elements to have the `.htm' file extension instead of `.html', you could use the following pattern for the find text:
<a href="(.*)html"
And the replace text:
<a href="\1htm"
The element is matched by `<a'; the attribute that contains the URL value is called HREF; the pattern `(.*)' matches everything in the URL up to the characters `html'; in the replacement, everything this pattern matched is substituted for `\1', and the characters `htm' are appended, thus creating the modified filename.
There's an even simpler way to do this, if you're sure that all the filenames end in `.html'. Use the following find text:
<a href="(.*)l"
And the replace text:
<a href="\1"
In this case, the replacement text will consist of everything the search text matched, except the final letter `l'.
The following list summarizes the search patterns and special characters available in HoTMetaL PRO's search facility.