Ex-Mode Addresses

A single address is often all you need with an ex-mode command. One address refers to just one line, which tells a command like delete or substitute to operate on that one line only. A command like insert or read, which puts something immediately before or after a particular line, has no use for more than one address.

A search pattern, as discussed in the first installment of this tutorial, is always an acceptable ex-mode address. You put the address at the start of the command line, before the command name (but after the initial colon if you are giving the command from normal mode), so:

will erase the last previous line that contains the string “the cat” or “the Cat”, while:

puts the contents of the file “gloss.book” right after the next line in the file you’re editing that contains only the word “GLOSSARY”.

There are two shorthand forms for reusing search patterns as addresses. Typing ?? or // tells the editor to use the last search pattern you used previously, and your choice of ?? or // will set the direction of the search, overriding the direction you chose the previous time you used that search pattern. That is, if you type:

the second command will search forward, to remove the last previous line containing the string “the cat”, even though your original use of that pattern was in a backward search. The third command will search backward to find the line to print, which (by coincidence) is the direction of the original search.

But the search pattern that those preceding abbreviations reuse may not be a pattern you used to search for a line. If you ran a substitute command after any pattern searches for lines, then the pattern you gave the substitute command to tell it what text to take out of the line is the pattern that will be reused. This is so even if your substitute command began with a search pattern to specify the line on which the substitution was to be performed — the search to find the pattern to be replaced within the line was run after the first search pattern had found the line to operate on, so the search within the line was the last pattern search run. So if you were to type:

the second command would, in this case, delete the last previous line containing “in the hat”. To be sure that the pattern that gets reused is the last one used to find a line, use the abbreviations \? and \/ to search backward and forward, respectively. In all other respects these work just as typing ?? and // do.

A line number is also a valid ex-mode address. The editor automatically numbers each line in the file consecutively, and this numbering is dynamic — that is, whenever you add or delete lines somewhere, the editor renumbers all the lines following the insertion or deletion point. So if you change some text on line 46 in your file, and then delete lines 11 and 12, the line with the text you changed is now line 44. And if you then add ten new lines after line 17, the line with your changed text on it now automatically becomes line 54.

There is never a gap or an overlap in the line number sequence, so the nth line in the file is always line number n ; that is, the 7th line is always line number 7, and so on. (There are several ways to display these line numbers, which I will expound in a later tutorial installment.) To delete the 153rd line in your file, just type:

You don’t use any delimiters around a line number, or around any other address except a search pattern.

There are two symbolic line numbers and one fictional one that can be used in ex-mode addresses. As long as there are any lines in the buffer (that is, you haven’t specified a not-yet-existent file to edit and failed to enter any text so far), the editor regards you as being ‘on’ one of them, usually the last line affected by your latest command. A period or dot (.) is the symbolic address for this line. The last line in the file also has a symbolic address: the dollar sign ($). So if you should type:

the first command would append a copy of just the line you are on now to a file named “goodlines”, while the second would delete the last line in the file you are editing.

A few commands put text immediately after the line address you give: the append command is one of them. In order to let them put their text at the very start of a file (if that is where you want it), these commands can take the fictitious line number zero (0) as their address. So, if you want to type some text that will appear ahead of anything already in the file, you can do it with either of these command lines:

Writing your own line addresses is possible, too. You can attach lower-case letters to lines as line addresses, and change the attachments whenever you like. You can even use a special address that is automatically attached to the last line you jumped off from.

There are ways to mark a particular line with a lower-case letter of the alphabet, and those ways differ between ex and normal modes. I’ll be explaining all these ways in later installments of this tutorial. But once a line is marked, the ex-mode address that refers to that line is just the single-quote character followed immediately by the lower-case letter with which the line was marked. So typing:

will display on the screen whatever line you have previously marked with the letter b, no matter where the line is in relation to where you are when you give the command. No need to tell the editor whether to search forward or backward; there can be only one line at a time marked with any one letter, and the editor will find that line regardless.

The editor does some line marking on its own, too. Whenever you move from one line to another by a non-relative address, the editor marks the line you just left. (A non-relative address is one that isn’t a known number of lines from where you were.) So:

are all non-relative addresses, and if you give any one of them, the editor will mark the line you are leaving for future reference. Then you can return to that line just by typing two successive single quotes:

as an ex-mode address. In theory, you can use this address with any ex-mode command. But it is so difficult to know for sure when you left a line via a non-relative address that this address form is best saved for going back to where you were when a mistake moves you far away, at least until you’re a wizard with this editor.

Modifying any of these addresses is possible, and there are two ways to do this. The simpler way is to offset the address a certain number of lines forward or backward with plus ( + ) or minus (-) signs. The rule is that each plus sign following an address tells the editor to go one line farther forward in the file than the basic address, while each minus sign means a line backward. So these three addresses all refer to the same line:

Not that you’re likely to want to modify line-number addresses with counts, unless you’re weak in arithmetic and want the editor to do the adding and subtracting for you. But the count offsets will work with any ex-mode addresses, and are most often used with search patterns. In any event, there is a shorthand for these counts, too. A plus or minus sign immediately followed by a number (single or multiple digits) is equivalent to a string of plus or minus signs equal to that number, so that these two addresses are the same:

The second style of address modifier is used where you want to do a search that’s complex. Let’s say you want to go forward in the file to delete a line that starts with “WARNING!”, but not the first such line the editor would encounter; you want the second instance. Either of these command lines will do it:

The consecutive search patterns tells the editor to find the location of the first pattern in the usual way, then start searching from that location for the second pattern. In this case, the first search pattern turned up the first instance of a line starting with “WARNING!”, and the second search pattern led the editor on to the second instance.

A very significant point here is that this combination of two search patterns, either of which could be a line address in itself, does not tell the editor to delete two lines. The sequence means that the first pattern is merely a way station, and that the single line found by the second search pattern is the only line to be deleted. In brief, what looks like addresses for two lines is actually only an address for one.

But that’s just the start of what you can do. You are not restricted to just two addresses. I’ve used up to ten of them to reach one specific line. As an example:

will bring me to the title line of Spinoza’s first work with “Monads” in the title, in the bibliography for Chapter 3.

Nor are you limited to search pattern addresses when putting together address string. If you want to reach the first line following line 462 that contains the word “union”, typing:

will bring you there. And any of the addresses can take numerical offsets, so:

is also a legitimate address string.

Even though an explicit +137 was used there to show that it will be added to 462, successive numeric addresses are additive in Vim. So this is the same as the last command:

Indeed, the awkward looking --- demonstrates this well. Each - is effectively -1 so --- is the same as -1 -1 -1 .

There is another way to chain several addresses together to identify a single line in Vim — by separating the addresses with a semicolon.

Using addr ; sets the cursor to the line where addr matches before considering the subsequent address. Using:

will find the next line forward containing "pat2" after the next line forward (from the cursor) containing "pat1", whereas:

will find the next line forward from line 7 containing "pat2", leaving the cursor in line 7.

Vim prefers the second address in a separated range addresses to be farther ahead in the file than the first address. Vim will ask for confirmation to swap both sides and continue if this is not the case. So, the range:

is just fine, while the similar-looking command:

will result in the request to swap the addresses. You can prevent Vim from asking and let it swap the addresses automatically by prepending silent to the start of the ex range, as in:

If the two addresses happen to evaluate to the same line, the command will silently operate on the one line you’ve specified.

Multiple space separated addresses can be chained together to achieve your desired range. For example, in:

the first command would write the latter part of the index to a new file, while the second could be used to remove a section of a book’s preface.

However, if you want the search after the comma to begin from the point the first search found, use a semicolon instead of a comma, as in:

I’ve already mentioned that most ex-mode commands that can take an address have a “default” address built in, which tells the editor where to run the command if you don’t give an address with it. Each command has its own default address, which may be the current line, the current line plus the one following, the last line of the file, or the entire file.

The range separators have default addresses of their own. They are the same regardless of what command is being used, and they override any command’s own default address. If you put a comma or semicolon before a command and don’t put an address before the it, by default the address there is the current line. In the same way, if you leave out the address after it, the default there is also the current line. You can even leave out the address in both places and use the current-line default in both: that means the implied address is “from the current line to the current line”, which makes the current line the only line the command will operate on. So every one of the following command lines:

will do exactly the same thing: append a copy of just the current line in the file you’re editing to another file named “goodlines”.

Finally, there is one special symbol that represents the 1,$ (comma or semicolon-separated) address combination — the percent sign (%). Both refer to the entire file.