Vimorama 2000

[Dec. 20, 2000] Some VI-related stories from LinuxToday

GNULinux.com: A Quick & Dirty Vi Tutorial(Jul 15, 2000)
Linux.ie: VI Tutorial III(Jul 08, 2000)
dotcomma: vi For New Users(Jun 11, 2000)
RootPrompt.org: The VI Editor [Tutorial](Apr 05, 2000)
DevShed: Vi 101(Mar 28, 2000)
PSCU: Vi Strain(Nov 28, 1999)
linux.ie: vi tutorial, episode 2 - filters, word count and more(Oct 29, 1999)
Linux.ie: vi Tutorial(Sep 22, 1999)

[Aug 19, 2000] Introduction to Programming in C/C++ with Vim Written By: Kmj

... ... ...

Ctags is a program that comes with vim. Basically, it's purpose is to help a programmer get to various parts of his program with relative ease. The typical method of running ctags is by simply typing the following in your source directory:

[/home/someuser/src]$ ctags *

This will create a 'tags' file in you current directory with the following information for all C or C++ files in you directory. This file contains a listing of the following objects:
       macros defined by #define
       enumerated values
       function definitions, prototypes, and declarations
       class, enum, struct, and union names
       namespaces
       typedefs

        variables (definitions and 
    declarations)

           class, struct, and union members
Vim then uses this file to help you locate these tagged items. This can be done in a few ways. First, one can open vim to the location of a tagged object. To do this, run vim with the '-t' flag and the tag-name as an argument. For example:

[/home/someuser/src]$ vi -t foo_bar

would open to the file containing the definition of foo_bar at that line.

If you are already in vi, you can enter the command by the tag-name:

:ta foo_bar

This may take you out of the file you are currently in, unless the 'autowrite' option is enabled. (It is off by default.) For more information on autowrite, type ':h autowrite' from with vi command-mode.

The final way to jump to a tagged location is by typing 'Ctrl-]' in command mode while the cursor is on a specific word. For example, if you are looking at my program, and you come across a point where I call foo_bar(), you can type 'Ctrl-]', while the cursor is somewhere on that word, and it will jump to that definition. Note that 'Ctrl-]' is the escape character for telnet, so this may cause some issues if your editing files remotely. Type ':h^]' for more information.

Ctags can also be used with other languages (java, fortran, ...and more) and editors (emacs, NEdit, ...and more). When set up properly, this tool can make your job tremendously easier, especially when you have to jump into a large ongoing project head-first.

For more information: View the man page, man ctags, or view the vim help, :h ctags.

c-style indenting

Vi has various methods of implementing auto-indenting. The best for C and C++ programmers is, obviously, cindent mode. This is a very versatile tool which gives the programmer much control over the look and feel of his source code, without any effort (except the effort of initial setup, of course). To enable c-indenting, just type ':set cindent' from the command mode. The most important thing to note is that cindenting makes use of shiftwidth, not tabstops. The default shiftwidth is 8. In order to change this, enter ':set shiftwidth=x' where x is the desired number of spaces to shift.

The default cindent options tend to be nice, but if you find your program indenting in some way that is annoying, you can modify the behaviour. To set the cindent options, type ':set cino=<string>', where <string> is a list defining exactly how you want your cindent options to behave. There are quite a few different types of indenting which can be done, and vim's help does a good job explaining them, so I won't go over them here. To view the help for the possible values of cinoptions, type ':h cinoptions-values'. To view the current values, simply type ':set cino'. Most likely there will be none, since everything starts at a default value.

For more information, check out the following: ':h shiftwidth', ':h cindent', ':h cinoptions', ':h cinoptions-values', ':h cinkeys', and ':h cinwords'.

syntax highlighting

Programmers who are used to integrated development environments know the beauty of syntax highlighting. It doesn't just make your code more readable; it also helps prevent annoying commenting and string errors. Vim has syntax highlighting for a number of languages, including C and C++ of course. To enable it, type ':syntax on'. Using it is as simple as that if you're happy with the default values. Vim's syntax highlighting tools can be quite complex, with a number of different things to play around with. To view information on syntax hilighting, type ':h syntax', which will lead you to vim's extensive help system. Syntax hilighting with color terminals and with gvim is nice, but if you don't have color, vim uses underlining, boldface, etc. To me, this is pretty ugly.

For more information: ':h syntax', ':h syn-qstart', ':h syntax-printing'

edit-compile-edit, a.k.a. Quickfix

This is a really nifty feature. Basically, by typing one command, you can cause vim to attempt to make the program you're working on, then open to whatever file first compiler error is in at the line of that error. The command to execute is ':mak' (or ':make'). Vim will run whatever program is denoted by the value of 'makeprg'. The default value for 'makeprg' is 'make'. You can change this, if you wish, by typing ':set makprg=<string>', where <string> denotes the desired command. Vim uses the 'errorformat' value to figure out how to understand the output from the compiler. Since different compilers have different output format's, you'll probably have to enter the format string. The method used is rather similar to C-style formatting with scanf. The most important format specifiers are %f, meaning filename, %l, meaing line-number, and %m, meaning message.

GCC's format string: %f:%l:\%m

This can become quite complex with different compilers, but fortunately, vim has a world of information in their help at ':h errorformat'.

For more information, check out: ':h quickfix', ':h mak', ':h makeprg', ':h errorfile', ':h errorformat'.

useful keystrokes

There are certain command-mode keystrokes that are especially useful for programmers. Below is a small subset of these:

Moving around within functions:
    [ [   = Go to previous first-column '{';   equivalent to ?^{
    ] ]   = Go to next first-column '{';   equivalent to /^{
    [ ]   = Go to previous first-column '}';   equivalent to ?^}
    ] ]   = Go to next first-column '}';   equivalent to /^}

    {   = Go to previous blank line.
   }   = Go to next blank line.

    gd   = Go to definition of current local variable (current = cursor is on it)
    *   = Go to next instance of current word
    #   = Go to previous instance of current word
    ''   = Go to location where last search was started.

Parenthesis Matching:
%   Takes you to the matching parenthesis, curly brace, or bracket, depending on what you are on. This always comes in handy as a quick double-check.

Substution:
Vim has powerful substution capabilities, with a very simple interface. No annoying GUI to get in the way (though you may need to keep a cheat-sheet handy). To search for and replace text, use the following command:
: [address] s/<pattern>/<string>/[g|c|N] (where N is an integer value).

This finds one (or more) instance of the grep-style regular expression represented by <pattern>, and substitutes it with <string>. 'address', 'g', and 'N' are modifiers which determine which and how many occurrences of <pattern> are replaced.
g = Global:    Replace all occurrences of <pattern> on the line.
c = Cond.      Ask before making each replacement.
N = Nth    Replace only the Nth occurrence of <pattern> on the line.
(No modifier implies N=1, the first occurrence on that line)

[address values]    -May be one specifier or two separated by a comma. (below, x represents an integer).
. = The current line
$ = The last line in the file
% = Entire file
x = The xth line of the file
+x = x lines after the current line
-x = x lines before the current line

The comma may separate any of the above in order to specify a range. All lines within the given range will undergo the substitution. The best reference I have found for substituting can be found at the Vi Helpfile, linked below.

Miscellany

Vim has so many nifty little things, it would be impossible to list them all. Here are a few more things that are worth taking a look at.
Include File Searching-  ':h include-search'
    
Bookmarking-  'mx' to set,  ' 'x' 
    to return; (x can be any letter, must stay within file to remember)
    
"Clipboard" buffers-  ' "xY '  to cut or 
    copy to  buffer x (Y represents any normal deletion or yank command),  
    ' "xZ '  to paste contents of x (Z represents pasting... p 
    or P);  (x can be any letter, can switch to another file(:e 
    filename) and still maintain contents of buffers). 
Comment Specifiers-     ':h 
    comments' 
.vimrc-    Don't forget your .vimrc!!! (Located in 
    your home directory). You'll find it very handy to add many of the above 
    things to your .vimrc file, so that vim "remembers" everything you want it 
    to. (You may find that some of them are already there.) Remember that you 
    don't need to prepend a ':' to the command when adding them to the .vimrc.

[Apr. 5, 2000] Root Prompt Vi Tutotial -- nice VI tutorial
Indenting Your Code and Checking

The VI editor has features to help programmers format their code neatly. There is a variable that to set up the indentation for each level of nesting in code. In order to set it up, see the customization section of this tutorial. For example, the command to set the shift width to 4 characters is :set sw=4.

The following commands indent your lines or remove the indentation, and can be specified with count:
<<
```
Shifts the current line to the left by 
      one shift width. 
```
>>
```
Shifts the current line to the right by 
      one shift width.
```
The VI editor also has a helpful feature which checks your source code for any hanging parentheses or braces. The % command will look for the left parenthesis or brace corresponding to a particular right parenthesis or brace and vice versa. Place the cursor onto a parenthesis or brace and type % to move the cursor to the corresponding parenthesis or brace. This is useful to check for unclosed parentheses or braces. If a parenthesis or brace exists without a matching parenthesis or brace, VI will beep at you to indicate that no matching symbol was found.
(Apr 01, 2000) JustLinux.com: Introducing vi
(Mar 28, 2000) DevShed: Vi 101
(Feb 13, 2000)TheLinuxGurus.org: An Introduction to vi
(Nov 28, 1999) PSCU: Vi Strain
(Jan 16, 2000) Linux PR Vim (Vi IMproved) version 5.6
Vim Color Editor HOWTO (Vi Improved with syntax color highlighting) This document is a guide to very quickly setup Vim editor on Linux or Unix systems. Vim supports syntax color highlighting and bold fonts which improves the "readability" of program code. The information in this document applies to all operating systems where Vim works that is - Windows 95/NT and all flavors of Unix like Linux, Solaris, HPUX, AIX, SCO, Sinix, BSD, SCO, etc..
HTML Clean up Macro
OK, here's another fun little item that can save you HTML authors out there a bit of time. I've been doing a bit of writing over the past year and repeatedly come back to VIM as my hands-down favorite editor for simply getting things done. It's one of those editors which, if you keep you fingers on the keyboard and not have to peek all the time or feel compelled to push a mouse or other small rodent around to get work done, let's you get things done VERY quickly. Now, you can say the same thing about Emacs I suspect, but since I'm still using 'ol VI, you're stuck having to listen to me talk about this for the moment :-)

Anyway, one of the cool things about VI is the ":so" command which basically let's you create a series of command-mode commands which you save to a text file, and then you can simply have VI "source" this in order to run the commands.

Since there's nothing like a good example to clear things up, let's see how to use this with doing a bit of pre-formatting for HTML.

As you all know, there are several characters which are not "allowed" to be directly included in the text portion of an HTML document -- these are the "reserved" characters and they include:
- ```
the ampersand character: & 
```
- ```
the less-than character: < 
```
- ```
the greater-than character: > 
```
- ```
the double-quote character: "
```
When a browser parses the HTML document these characters are used to convey formatting or other information and so cannot be directly input.

The problem comes in when you want to include text in an HTML document. Specifically, I include a lot of email in the 'ol LG. Problem is, that much of it contains so-called "reserved characters" -- those characters enumerated above that should not be directly entered into the text. In the past I've manually searched through each letter trying to ferret these out but, as with most Linux things, there's a MUCH easier and more efficient way to do this.

As your Uncle Louigi says, "Use your head, not your back..."

So, the first thing to note is that the first step in the email->HTML conversion is converting these characters to either a "Character Reference" or an "Entity Reference" (you know -- you have to use " for the (") double-quote character). You can easily do this using something like:
```
	:%s/\&/\&amp;/g
```
This particular command does a global substitution for the current file by converting every instance of "&" to "&". Do this for the other three reserved characters and you'll be on your way to dropping your email (or any other text document for that matter) into your HTML docs.

Now, you could obviously just enter these commands in by hand each time you want to do this, but hey, this is Linux and being lazy is OK -- as long as you're smart about it :-)

So, instead of typing in a set of commands to convert these characters to their Entity Reference format, we'll just set up a macro file which can be sourced for any text file. Using something like:
```
%s/\&/\&amp;/g
%s/</\&lt;/g
%s/>/\&gt;/g
%s/\"/\&quot;/g
```
will let you convert these automatically. So, how do you do this? Easy:
1. Create a plain text file and copy the above lines to it
2. Save the file with some catchy little title such as "htmlconv"
3. Load up some test document that you want to experiment on
4. Now, just issue the command ";so /path/to/file/htmlconv"
and Presto!! VI will grind away for a moment and all of the changes will be made for you.

Sourcing a macro file is one way to improve the speed and efficiency of doing things under VI(M) -- especially if you find yourself doing tasks that required frequent repetition. One small suggestion is to put these macros in their own directory off your HOME directory so that they are easily accessible from anywhere in the directory tree. To specify such a macro you could enter:
```
	:so ~/macros/htmlconv
```
and the tilde (~) would be automagically expanded out to point to your home directory.

Anyway, this is one of those "tip of the iceburg" types of things because there is a HUGE amount of mischief you can get into using macros :-)

Have fun!

John
[July 18, 1999] VI paragraph formatting!

Date: Wed, 17 Apr 1996 15:22:58 CDT
From: Pat Traynor <pat@ssih.com>
To: fiskjm@ctrvax.Vanderbilt.Edu
Subject: vi justification

Here's a modification on a vi tip that was offered a few issues ago.

In my .exrc file, I have the following entry:
```
	map ^P {!}fmt^M
```
(The "^P" and "^M" are actual control characters that I had to escape with a <ctl>-V.)

When the cursor is anywhere within a paragraph and I hit a <ctl>-P, it re-aligns all of the text. It's just the thing for those occasions when you've typed in a long paragraph and then decide to delete or add several words near the top.

I won't go into the explanation of what everything does, since that has already been done. But rather than typing
```
	:10,50! fmt
```
which requires that you know what the first and last lines of the paragraph are, the '{' moves you to the top of the paragraph, and the trailing '}' means to do this function up to the end of this paragraph.

--pat--
--
Pat Traynor
pat@ssih.com
[July 14, 1999] EXT2 February 99 Issue -- interview with Bram Moolenaar creator of vim. Although it's hard to teach old dog now tricks vim 6.0 will support folding :-)

[May 20, 1999] vile-perl-api -- Vile-Perl interface reference

Macro (Map) Recording

Vi users who write "mappings" to abbreviate a series of commands know 
    how tedious it can be to remember the keystrokes for this. Vim makes it easy 
    with "macro recording": The letter 'q' (which is unused in Vi, btw) is used 
    to start the recording; the next letter is the name of a register which is 
    to store the keystrokes. Whatever you type after that is stored within the 
    register until you type another 'q'. That's it. You can then play back this 
    sequence with the command '@' followed by the register letter/name.

Example:
     Start recording into register 'a' G jump to last line of current 
    buffer ?^-- $^M search backward for a line with sigdashes d/^$^M delete unto 
    next empty line q end recording 
    This simply deletes the signature from the current file. You can now edit 
    another file with a signature and have it removed by simply replaying the 
    macro with "@a".

Copyright © 1996-2009 by Dr. Nikolai Bezroukov. www.softpanorama.org was created as a service to the UN Sustainable Development Networking Programme (SDNP) in the author free time. Submit comments This document is an industrial compilation designed and created exclusively for educational use and is placed under the copyright of the Open Content License(OPL). Site uses AdSense so you need to be aware of Google privacy policy. Original materials copyright belong to respective owners. Quotes are made for educational purposes only in compliance with the fair use doctrine.

Disclaimer:

The statements, views and opinions presented on this web page are those of the author and are not endorsed by, nor do they necessarily reflect, the opinions of the author present and former employers, SDNP or any other organization the author may be associated with.
We do not warrant the correctness of the information provided or its fitness for any purpose
In no way this site is associated with or endorse cybersquatters using the term "softpanorama" with other main or country domains (e.g. softpanorama.com) with bad faith intent to profit from the goodwill belonging to someone else.

Last modified: February 28, 2008

Vimorama 2000

... ... ...

c-style indenting

syntax highlighting

edit-compile-edit, a.k.a. Quickfix

useful keystrokes

Miscellany

Indenting Your Code and Checking