VI Improved Tips :: vimrc dissected

[off-topic] Perl on Windows: handling files with Unicode characters

2012-01-29T14:34:00.000-08:00

Using Strawberry Perl.

The rename with the proper Win32 module initialization:


# init
use strict;
use warnings;
use utf8;
use Win32::OLE qw(in);
Win32::OLE->Option( CP => Win32::OLE::CP_UTF8 );

# the code
my $fso = Win32::OLE->new("Scripting.FileSystemObject");
$fso->MoveFile( ".\\".$old_name , ".\\".$new_name );

Recursively scan directory tree:


# the code
sub scan1
{
 my ($f, $l) = @_;
 my $obj = Win32::OLE->new('Scripting.FileSystemObject');

 my $folder = $obj->GetFolder( $f );
 die "ERROR: $f" unless $folder;
 foreach my $file (in $folder->Files) {
  print $file->{Name}, ", size ", $file->{Size}, "bytes\n";
 }

 my $collection = $folder->{SubFolders};
 foreach my $value (in $collection) {
  my $foldername = $value->{Name};
  scan1( "$f\\$foldername", $l );
 }
}
my @l;
scan1( 'c:\\Movies', \@l );

Scripting.FileSystemObject documentation.

A use case for \%#

2012-01-17T13:46:00.000-08:00

Some time ago, per chance, quite obscure feature of VIM's regular expressions: \%# - :h /\%# says "Matches with the cursor position."

At first I couldn't see any use for it.

But then, while editing per hand some XMLs, I stumbled upon a problem: how to insert a tag break (close and open), while adding the indentation? Normal VIM macrii(*) can insert - but one looses the cursor position as soon as movement commands are used. But to make a copy of the indentation, one needs to move the cursor to the beginning of the line.

Edit0. OK. It just dawned on me. One could first insert the XML tag break + new line. Then copy indentation. Uh. Need to sleep more and more often. But I already wrote the post so what the heck I'll just post it.

Then I recalled that the regular expressions could match current cursor position. And I had a hunch that the \%# could be used for the purpose. The Enlightenment come only few days later and took shape of that for the <p> tag:

:s!^$\s*$$.\{}$\s\+$\k*\%#\k*$!\1\2</p>\r\1<p>\3!

First () submatch are the spaces (= indentation) of the current line.

Second () submatch is everything up to the word under cursor (matched non-greedily as I had some fancy problems with greedy match here).

Third () submatch is the actual word under cursor, anchored by the \%# to the current cursor position. (The redundant spaces before the word are trimmed between the second and third submatches.)

That all is replaced by. Original line: \1\2 is the line up to the word under cursor, closing </p> tag and \r for new line. New line: \1 which is the wanted indentation, opening <p> tag and finally the word (obviously followed by the rest of the original line).

P.S. \S (anything but space) in place of \k works pretty well too.

P.P.S. VIM should support some sort of nesting of regular expressions. During editing lots of pieces could be reused - but only reuse regular expressions do support is the copy-paste. The Clue.

(*) Because for the particular task at hand, macros have infested irreversibly my vimrc. Just like virii. Any press of a wrong button, and only the undo can sort out what the hell has just happened.

[link] LOCALE settings and regexp classes

2012-01-08T07:43:00.000-08:00

Spent some time editing a German text (actually an FB2 book) in VIM. Hell of a job, because as it turned out, I wasn't blind: VIM really doesn't support locale in the regular expressions.

Workaround is to use \k (also suggested \i doesn't match ß). But that's only half workaround, since \k is case insensitive and case is used in German (e.g. nouns are capitalized).

Another workaround is to use Perl or Python integration for regular expressions, since both provide locale support in the regular expressions. But I haven't gone that far yet.

P.S. Here are some of my FB2 editing helper functions.

" some Fiction Book functions

"
" merge adjacent paragraphs
"
function! ParaMany_ToSingle() range
        let lines = getline(a:firstline, a:lastline)
        call filter( lines, 'v:val !~ "^$"' )
        let xind = substitute( lines[0], '^$\s*$.*', '\1', '' )
        for i in range( 0, len(lines)-1 )
                if i != 0
                        let lines[i] = substitute( lines[i], '^\s*<p>[ \t]*', '', '' )
"                       echo i." < ".lines[i] | sleep 2
                endif
                if i != len(lines)-1
                        let lines[i] = substitute( lines[i], '[ \t]*</p>\s*$', '', '' )
"                       echo i." > ".lines[i] | sleep 2
                endif
        endfor
"       echo "xxx:".join( lines, " " ) | sleep 2
        if a:lastline > a:firstline
                exec ':'.(a:firstline+1).",".a:lastline."d"
        endif
        let text = join( lines, " " )
        let text = substitute( text, '[ \t]\{2,}', ' ', 'g' )
        let text = substitute( text, '^\s\+', '', '' )
        call setline( a:firstline, xind.text )
endfunction

" gvim helper keyboard shortcuts (c-up/-down do not work in terminal)
function! Keyboard_ParaCUpDown()
        map <C-Up> :-1,.call ParaMany_ToSingle()<CR>
        map <C-Down> :.,+1call ParaMany_ToSingle()<CR><Up>
endfunction

"
"  insert section break, using the line's text as the section title
"
function! Para_ToSectionBreak()
        let t = getline(".")

        " capture the line indentation
        let xind = substitute( t, '^$\s*$.*', '\1', '' )
        " etch a bit from section tag indentation
        let xindS = substitute( xind, '^$\s*$\s$', '\1', '' )

        " clean-up tags
        let t = substitute( t, '\v\</{0,1}[a-z]+[^>]*\>', '', 'g' )
        let t = substitute( t, '[ \t]\+$', '', '' )
        let t = substitute( t, '^[ \t]\+', '', '' )

        " generate id, ensure starts with letter or _
        let id = substitute( t, '[^a-zA-Z0-9_-]', '_', 'g' )
        let id = substitute( id, '^$[^a-zA-Z_]$', '_\1', 'g' )

        let l = [xindS.'</section>',
\               '',
\               xindS.'<section>',
\               xind.'<title>',
\               xind.'<p id="'.id.'">'.t.'</p>',
\               xind.'</title>' ]
        call setline( ".", l[0] )
        call  append( ".", l[1:] )

        call cursor( line(".")+len(l), 0 )
endfunction

"
"  convert line's text to subtitle
"
function! Para_ToSubtitle()
        let t = getline(".")
        let xi = substitute( t, '^$\s*$.*', '\1', '' )
        let t = substitute( t, '\v\</{0,1}[a-z]+[^>]*\>', '', 'g' )
        let t = substitute( t, '[ \t]\+$', '', '' )
        let t = substitute( t, '^[ \t]\+', '', '' )
        call setline( ".", xi.'<subtitle>'.t.'</subtitle>' )
endfunction

[link] More Fun with Vimscript

2011-11-25T03:22:00.001-08:00

More Fun with Vimscript by Juliet Kemp.

Mentions something totally new to me: ZOMG! VIM has a function debugger!!

:h debug-scripts.

Example :debug call CustomeFunc().

P.S. Wow, and profiler too! :h profiling

[link] Getting more out of Vim - some tips

2011-02-20T14:21:00.000-08:00

Some VIM tips from FSM (Free Software Magazine).

The neat trick to count words - :s/pattern//gn - somehow I have missed it before.

^O/^I (in normal mode, :h jump-motions) are cool too. Work like Back/Forward buttons on the web browsers.

modeline on steroids

2011-01-20T13:57:00.000-08:00

Modeline is a great tool. Yet, sometimes it is also quite limiting: it can change only limited number of options. My most often gripe - one can't change the 'makeprg' to add the target (for what in past I attempted to use the workaround).

Reading through the modeline documentation, I have found an idea how to improve the modeline to allow to execute random VIM commands, not just setting few options.

Here it goes.

function! CustomModeLine(cid)
        let i = &modelines
        let lln = line("$")
        if i > lln | let i = lln | endif
        while i>0
                let l = getline(lln-i+1)
                if l =~ a:cid
                        exec strpart(l, stridx(l, a:cid)+strlen(a:cid))
                endif
                let i = i-1
        endwhile
endfunction

au BufReadPost * :call CustomModeLine("VIM666:")

Now, after adding that to the .vimrc, one can put something like this in the last lines (among &modelines last of them) of the source file:

// VIM666:set makeprg=make\ aaaa
// VIM666:sy keyword cType block_id_t

When opening the file in VIM, the scriptlet would find the lines and :execute them. First would add to the makeprg a default target "aaaa", second would make symbol "block_id_t" to be highlighted as a C/C++ type (typedef from my pet not-really-a-project).

Why the VIM666:?

Well. VIM creator has allowed the modelines to change only limited set of options for the reason:

No other commands than "set" are supported, for security reasons (somebody
might create a Trojan horse text file with modelines). And not all options
can be set. For some options a flag is set, so that when it's used the
|sandbox| is effective.

Thus, randomizing the "VIM666" into something more random and unpredictable is strongly advised. Sadly, :sandbox isn't configurable and thus incapable of disallowing only certain actions - at the moment it is all-or-nothing type of command in VIM.

[DUMP] VIM custom folding for Rational Purify's plog files

2011-01-11T08:00:00.000-08:00

Dump.


"
" Fold (collapse) the Purify problem descriptions into single line
" As the comment to the fold, Purify message would appear with
" list of files/libraries in the call stack.
" "-CHAIN_LENGTH=32" parameter in PURIFYOPTIONS is highly recommended
"
" custom fold function for Purify's .plog files
function! PuriFold(lnum)
        let l = getline(a:lnum)
        " fold starts at 'XXX:' marker (though exclude File In Use)
        if l =~ '^[A-Z][A-Z][A-Z]:' && l !~ '^FIU:'
                return 1
        endif

        " store fold level of previous line
        let pfl = foldlevel(a:lnum-1) > 0

        " check whether it is a continuation of a fold
        if pfl && (l =~ '^\t' || l =~ '^  \*' || l =~ '^    ')
                return 1
        endif

        if pfl
                return '<1'     " close fold if open
        else
                return 0        " not a fold otherwise
        endif
endfunction

" custom fold text function to quickly see the approx location of the problem
function! Puri_GatherNames(fl, ll)
        let l:i = a:fl
        let l:x = ''
        let l:count = 0
        while l:i <= a:ll && l:count < 10
                let l:l = getline( i )
                if l:l =~ '\*unknown func\*'
                        let l:l = ''
                endif
                let l:tmp = matchstr( l:l, '\[[^\]]\+\]$' )
                if strlen(l:tmp) == 0
                        let l:i = l:i+1
                        continue
                endif
                if l:tmp =~ '^\[libclntsh\.so'
                        let l:tmp = '[*ORA*]'
                endif
                if l:tmp =~ '^\[libstlport\.so' ||
\                  l:tmp =~ '^\[_\(pair\|tree\|alloc\|map\|construct\)\.h:' ||
\                  l:tmp =~ '^\[_\(tree\)\.c:'
                        let l:tmp = '[*STL*]'
                endif
                if strlen(l:tmp)>0 && l:tmp!=strpart(l:x,strlen(l:x)-strlen(l:tmp))
                        if l:tmp == '[crt1.o]' || l:tmp == '[rtlib.o]' ||
\                          l:tmp == '[crti.o]' || l:tmp == '[libCrun.a]' ||
\                          l:tmp == '[libc.so.1]' || l:tmp == '[libnsl.so.1]' ||
\                          l:tmp == '[libsocket.so.1]'
                                " nothing, ignore system libraries
                        else
                                let l:x = l:x.' '.l:tmp
                                let l:count = l:count+1
                        endif
                endif
                "echo x
                let l:i = l:i+1
        endwhile
        return l:x
endfunction
function! Puri_FoldText()
        return foldtext().Puri_GatherNames(v:foldstart, v:foldend)
endfunction

" activate the folds when .plog file is opened
au BufReadPost *.plog set foldexpr=PuriFold(v:lnum)
au BufReadPost *.plog set foldmethod=expr
" use custom fold text function
au BufReadPost *.plog set foldtext=Puri_FoldText()

P.S. WT Rational Purify?

VIM inline calculator revisited, floating point numbers comapatible

2011-01-10T05:19:00.000-08:00

As it turned out, sometimes I really like to use the VIM as a calculator, with free editing, history and even access to env vars. (Unintentionally, calls to VIM functions also do work.)

Yesterday I needed to calculate few more things than usually and also using floating point numbers. I have recalled that VIM 7.2 added support for Float type and tried it out. After some tinkering, I managed to make my calculator even more useful to me than expected.

The previous version of calculator looked relatively innocent:

:map <silent> <F11> :exec "s!^\\([^=]\\{-}\\)\\( *=.*\\)\\=$!\\1 = ".eval(substitute(getline(".")," *=.*$","",""))."!"<CR>

The new version looks more serious and even less intimidating:


function! CalcGetValue(tag)
        let tag_marker = "#"
        let s = search( '^'.a:tag.tag_marker, "bn" )
        if s == 0 | throw "Calc error: tag ".tag." not found" | endif
        " avoid substitute() as we are called from inside substitute()
        let line = getline( s )
        let idx = strridx( line, "=" )
        if idx == -1 |  throw "Calc error: line with tag ".tag."doesn't contain the '='" | endif
        return strpart( line, idx+1 )
endfunction

function! CalcLine(ln)
        let tag_marker = "#"
        let s = getline(a:ln)

        " remove old result if any
        let x = substitute( s, '[[:space:]]*=.*', "", "" )
        " strip the tag, if any
        let x1 = substitute( x, '[a-zA-Z0-9]\+'.tag_marker.'[[:space:]]*', "", "" )
        " replace values by the tag
        let x1 = substitute( x1, tag_marker.'\([a-zA-Z0-9]\+\)', '\=CalcGetValue(submatch(1))', 'g' )
        " evaluate
        let v = 0
        try
                let v = "".eval(x1)
        catch /E806:/
                " VIM can't convert float to string automagically, apply printf("%g")
                let v = "".eval('printf( "%g", '.x1.')')
        endtry
        " finish the job
        call setline(a:ln, x.' = '.v)
endfunction

:map <silent> <F11> :call CalcLine(".")<CR>

The new version addresses two my problems (old) allow simple reuse of the previous calculations and (new) allow floating point numbers.

At the core, the usage of calculator remained pretty much the same as before. For example, typing 2*2 and pressing F11 would change the line into 2*2 = 4.

To allow reuse of previous calculation results, I have introduced the tags. A line with a calculation result can be prefixes with label# tag (e.g. label# 2*2 = 4). Results of the calculation can be accessed in another expression using #label, e.g. 33*#label. During evaluation, the scriptlet above would search the buffer for string starting with label# and put into the original expression whatever is found after the '=' on the matching line. (What has turned out to be a minor, nice-to-have feature: expression itself is optional; line label# = value works as a definition of constant).

Example: calculate area and volume given the radius. Type this:

radius# = 5
pi# = 3.1415
area# pow(#radius,2)*#pi
volume# pow(#radius,3)*#pi*4.0/3.0

First two lines work like constants denoting Pi and the radius. Press the F11 (or ^O + F11 if in insert mode) when cursor on 3rd and 4th lines to evaluate the expressions and see the results:

area# pow(#radius,2)*#pi = 78.5375
volume# pow(#radius,3)*#pi*4.0/3.0 = 523.583333

The new (to me) features that are used in the new calculator:

1. search() to find a line number of a string matching given pattern (used to search in the buffer for the line with a tag).

2. submatch(), when inside the substitution, to access a submatch (functional equivalent of \1, \2 and so on).

3. \= in s/// and substitute() to substitute with result of an expression instead of a constant.

4. E806 + :try. VIM can't convert float to string automatically. Error E806 is generated when that is attempted. Scriptlet catches the error and applies suggested by documentation conversion method - printf(). The construct with try/catch also ensures that integer calculation remains integer. Only if there are floating point numbers involved, exception would be thrown and the conversion would be performed (spares the redundant '.0' in the integer calculations).

Make (next) found match to appear in the screen's center

2010-12-16T09:13:00.000-08:00

Turned out to be easier than expected:

nnoremap n nzz
nnoremap N Nzz

Simply adds the zz (see :h z.) to n and N commands.

P.S. Original question and answer as SO.

Edit1 Problem with the solution is that the message search hit BOTTOM, continuing at TOP, due to the zz command, now doesn't appear on the screen anymore. Trying now to use the other tip: set scrolloff=5. Will see how that works.

Edit2 Yep, the set scrolloff=5 works for me much better than the nzz.

diff this!

2010-10-19T02:17:00.000-07:00

Found a cool VIM's command - :diffthis. Invoking it in two different buffers tells the editor to diff the buffers as if it was started as vimdiff. Best (most interesting to me) part is that one can diff two unsaved buffers. E.g.:

" split the screen vertically
:vnew
" paste first code fragment into the left buffer and
:diffthis
" press ^W^W to switch to the right buffer, paste the second code fragment and again call
:diffthis

To cancel the effect of :diffthis one uses the :diffoff command. The command is too buffer specific and has to be invoked in both buffers.

Another interesting related command is :diffpatch {diff-file} which again invokes vimdiff diffing the file currently in buffer against the file with the patch applied.

vim vs. grep : external quickfix/error file, cont'd

2010-09-07T07:43:00.000-07:00

As an enhancement to my old trick of using grep with the VIM, I have finally come up with a solution which doesn't use the temp file:

$ alias vq="vi -c ':cgetb' -c ':cfirst! ' -"
$ grep -nr whatever . | grep -v garbage | vq

The trick is to use the new VIM 7.x command :cgetb which retrieves the error list from the current buffer. So first suck in the output of the grep into the nameless buffer, tell VIM to use the buffer as a error list and then with :cfirst! to jump to first matching line (and discard the nameless buffer).

Note in alias the space after :cfirst!: it is a secret ingredient to avoid bash interpreting the ! as the history expansion mark.

Life goes on

2010-08-16T09:07:00.000-07:00

VIM 7.3 released.

[off-topic] Rakudo - Perl6 - wait is over!

2010-08-04T12:28:00.000-07:00

Just compiled the Rakudo and it seems the wait for a Perl6 implementation is finally over!

~/src/rakudo $ time ./perl6 -e 'print "hello\n"'
hello

real    0m3.052s
user    0m0.708s
sys     0m0.753s

I mean, ~3 [*CENSORED*] seconds to print a puny [*CENSORED*] string?

No folks, I'm not waiting for it anymore. I simply go on using the Perl5.

R.I.P. Perl6, we barely knew you.

P.S. I understand alpha/beta status and all. But I doubt that even release would be able to fix the 10-100x performance regression. And yes, I checked Parrot was all compiled with optimizations.

P.P.S. I tested inside of the VirtualBox. That might slow down an application. Yet the Perl5 performance in the very same conditions is totally OK:

~/src/rakudo $ time perl -e 'print "hello\n"'
hello

real    0m0.041s
user    0m0.002s
sys     0m0.013s
~/src/rakudo $

P.P.P.S. On my up-to-date Sidux, strace tells that "perl" needed only 101 syscall to print a string. Rakudo - 1146. Among them 527 brk()s. That's a very RAM conscious application we have here.

Getting the exit code from make in Vim

2010-06-19T17:48:00.001-07:00

Just answered the question on SO and I think the final trick is worth documenting here. The problem is how to get after :make exit code of the make itself. As it is wrapped by VIM, it gets lost in the pipe: :echo v:shell_error always shows 0 (:h v:shell_error).

The bash-specific trick is:

:set shellpipe=2>&1\ \|\ tee\ %s;exit\ \${PIPESTATUS[0]}

The magic is in the ;exit ${PIPESTATUS[0]}.

man bash (search for PIPESTATUS) and :h 'shellpipe' (check the %s) for more info.

[link] VIM + ctags

2010-06-07T08:17:00.000-07:00

Nothing new, yet useful to have for reference.

So StackOverflow.com can be useful at times.

VIM inline calculator

2010-05-07T06:13:00.000-07:00

Map the F11 key to VIM's eval() function (I hope the Blogger will not eat any characters):

:map <silent> <F11> :exec "s!^\\([^=]\\{-}\\)\\( *=.*\\)\\=$!\\1 = ".eval(substitute(getline(".")," *=.*$","",""))."!"<CR>

Came up during lengthy analysis of log files and source code. Some calculators allow expression. Some support history. But all that is quite limited and often is mouse driven. Check into the VIM's :help :let + digging around pointed in direction of the eval() and thus the monster macro was born.

2 statements are at the core:

1. eval(substitute(getline(".")," *=.*$","","")) strip "= whatever" from the end of the string and feed it to eval(). :h eval()

2. :exec "s!!!" where we take everything from the line, save in \1 string before "=", replace the line with "\1 = " plus result of eval(). Requires :set magic. Backslashes had to be doubled since :exec looks for them.

After adding that to vimrc or executing in place, open VIM, type on empty line "2*2", press Esc and F11. You should see "2*2 = 4".

Edit1 Apparently, the eval() function isn't available in VIM 6.x. Equivalent using :exec ":let":


function CalcX(line_num)
        let l = getline(a:line_num)
        let expr = substitute( l, " *=.*$","","" )
        exec ":let g:tmp_calcx = ".expr
        call setline(a:line_num, expr." = ".g:tmp_calcx)
endfunction
:map <silent> <F11> :call CalcX(".")<CR>

Edit2 VIM 7.2 supports floating point numbers. Would be interesting to experiment with it, but I haven't bothered to upgrade yet.

Another little thing. :echo too evaluates its parameters. Typing :echo 2*2[Enter] would display 4.

Disable syntax highlighting for a large file

2010-05-03T09:50:00.001-07:00

Got to edit today a 150MB XML file. That was painful. Tried to disable the syntax highlighting - improved the performance a lot. So I added the trick to my vimrc:

au BufReadPost * if getfsize(bufname("%")) > 512*1024 | 
\  set syntax= |
\  endif

That tells VIM to disable syntax (:set syntax=) for any file whose size (while opening, :h BufReadPost) is greater than a half meg (if getfsize(bufname("%")) > 512*1024).

Edit1 A more generic solution is to use the LargeFile script from vim.sf.net, as found out by reader David in the comments below. Starting from version 5 (at the moment of writing available only on author's, Charles Campbell, personal web page.), the script handles properly(*) the buffers with content populated using external commands. The script's main purpose in life is, when opening a large file, to set buffer options to make editing of large files more palatable experience: disable swap file, disable syntax highlighting, discard buffer with large file as soon as it is closed, disable folding, disable undo and so on.

(*) Event used is the BufReadPost, and the size of buffer is evaluated with line2byte(line("$")+1).

[link] Vim 7.2 Scripting

2010-05-03T09:00:00.000-07:00

Rundown on a number of simple things one encounters when starting scripting: version check, OS check, debugging.

vim vs. grep : external quickfix/error file

2010-04-29T07:17:00.000-07:00

My usual trick of using vim with grep works well when single grep invocation is sufficient.

Yet quite often I end up piping one grep's output to another grep to refine the results. And that doesn't work with my old trick of wrapping the grep MethodName *.cpp into vim -c ":grep MethodName *.cpp" as the vim's internal grep doesn't support pipes.

Digging through the documentation I found that it is possible to accomplish and it fits well to my workflow.

Start grepping(*):

$ grep MethodName *.cpp         # not fine enough...
$ grep MethodName *.cpp | grep -v rubbish   # much better
    # and save to a file
$ grep -n MethodName *.cpp | grep -v rubbish > tmp1.out

N.B. -n to the grep is required as VIM needs line numbers to jump to the locations.

And now tell VIM to use the produced tmp1.out error file:

$ vim -q tmp1.out

or

$ vim -c ":cf tmp1.out"

or from inside running VIM:

:cf tmp1.out

Check the :h :cf for the official documentation.

(*) Obviously in the case it doesn't have to be grep - anything what produces similar output would do. I used once a perl script to generate VIM-compatible error file from diff output to preview potential merge conflicts.

Capture output of a command

2010-04-16T04:52:00.000-07:00

I was playing around with ^K and wanted to see all possible combinations available. :help CTRL-K directed to the :digraphs command. The problem is that amount of output from :dig eclipses even that of the :set all.

So how one can somehow serialize the output into e.g. a VIM's buffer?

Search on the net unveiled the following tip:

:redir @a
:dig
:redir END

Or even cooler, putting the output into a variable:

:redir => varname
:dig
:redir END

followed by echo varname.

Final step is the dumping all that into a buffer/window: :put =varname.

P.S. The official Learn to use help article. Til now, I haven't knew that the :help could be abbreviated to the :h.

Save file owned by root

2010-04-12T02:42:00.000-07:00

Have just seen the nice trick on the Interwebs.

It happens often: one starts editing a file owned by root. One gets used rather quickly to the VIM's warnings about editing a file one does not have permissions to. Only much later realizing that you can't save it.

So you opened a VIM and edited a file, but can't save it. Instead of saving a temp one can use the trick:

:w !sudo tee %

P.S. ZOMG PONYZ!!1 For what I was always adding a custom shortcut :map <F6> :b#<CR> turned out to have an official shortcut: ^6 (:help CTRL-6). In VIM 7.1, this is sole shortcut of the form CTRL-<number>.

[link] Scripting the Vim editor, Part 3: Built-in lists

2010-02-04T05:26:00.001-08:00

Scripting the Vim editor, Part 3: Built-in lists, part of Scripting the vim editor series over at IBM's dW.

Insightful read. Though I hope I would never need to script the VIM to such extent.

[link] Vim 401: Extending Vim and More

2009-12-13T03:43:00.000-08:00

While I was procrastinating here, the Joe Brockmeier guy is already on fourth installment of his articles dedicated to learning Vim: Vim 401: Extending Vim and More.

Do not forget to check the links (provided in article) to the previous installments.

[link] Vim 101: A Beginner's Guide to Vim

2009-11-26T05:10:00.000-08:00

Vim 101: A Beginner's Guide to Vim by Joe Brockmeier.

Bit too vi-ish IMO, yet as beginner's guide quite complete.

[link] vi Introduction

2009-08-15T01:45:00.000-07:00

vi Introduction. Obviously by "vi" they mean "VIM".

[link] Vim Tutorial

2009-08-07T03:02:00.000-07:00

Vim Tutorial - with videos!

Bit too vi-compatible to my tastes. Otherwise most bases are covered.

[humor] Vim vs. Emacs

2009-07-30T13:41:00.000-07:00

Vim vs. Emacs

[link] Customizing vim and coloring the terminal in OpenSolaris 2009.06

2009-07-17T15:14:00.000-07:00

dd if=/dev/random of=/dev/blog » Customizing vim and coloring the terminal in OpenSolaris 2009.06.

Hehehe. Somebody tries to make some use of Solaris.... Good Luck. Piece of advice though: upgrade to Linux, it's faster that way. Do not get me wrong... ... BUT WHAT THE F***?! This is year 2009 and Solaris still can't take care of colors?

P.S. BTW, Good Luck trying to use "TERM=xterm-color" though. Last I time I tried it on Solaris only to find that it is lacking something like half keyboard.

Really. Get over it, swallow your childish pride and get the Linux. It works.

[link] Speed-Typing in Vim With Maps and Abbreviations - Better Than a Clipboard

2009-07-06T04:49:00.000-07:00

LinuxPlanet - Tips - Speed-Typing in Vim With Maps and Abbreviations - Better Than a Clipboard.

Some nice tips on how to use VIM's abbreviations to insert some dynamic (not static!) text like e.g. current date.

[link] LinuxPlanet - Tips - Turning on Unicode Support in Vim - Unicode in Vim

2009-06-27T07:02:00.000-07:00

LinuxPlanet - Tips - Turning on Unicode Support in Vim - Unicode in Vim.

Though article is more about how to input all those fancy characters.

C++ vs. tags

2009-06-05T04:10:00.000-07:00

One - at times very - annoying problem I had was that jumping to tag not very C++ friendly. Namely it doesn't consider ':' (colon) to be part of word under cursor. It finally bothered me to the point of reading documentation which promptly sent me to :help star where from I was sent to :help 'iskeyword'. In less than a minute I had a fix:

au BufReadPost *.cpp set isk+=:

'isk' is shorthand for 'iskeyword' and tells VIM what symbols should be considered to be part of (key)words. 'isk' is a list (as usually comma separated) of characters/character ranges and as with any other comma-separated lists, operators '+=' and '-=' do they job as they should.

That obviously has an impact on any VIM command which works with words - '*', '#', 'w', etc. Beware.

[link] Vim made easy: how to get your favorite IDE features in Vim

2009-05-19T07:27:00.000-07:00

Vim made easy: how to get your favorite IDE features in Vim by Ryan Paul on ArsTechnica.

Something about plug-ins and such. Lots of screenshots with Python source code, so I couldn't look deeper.

[link] my vi first steps

2009-04-26T05:54:00.000-07:00

Handle With Linux's my vi first steps.

I presume the guy means "vim" as he's working with Linux and Linux for past 10+ years has "vi" as a symlink to vim.

P.S. Nice trick to use :wn from a macro - to make macro to go to the next file. When macro invoked with repeat counter N, it would be applied to N first files open for editing.

vim + grep = visual grep

2009-04-25T07:57:00.000-07:00

Trick I'm using quite often and is worth mentioning:

vi -c ":grep -r something files_or_dirs"

That would start VIM and tell it to run grep right after that. Very convenient.

[link] vimdiff - Edit two or Three versions of a file with Vim and show differences

2009-04-09T03:24:00.000-07:00

vimdiff intro on www.debianadmin.com.

Fixing PageUp and PageDown

2009-02-11T14:57:00.001-08:00

For a long time it had annoyed me that pressing PageUp or PageDown would not only go to previous/next screen portion of file, but would also screw cursor position. Essentially, unlike good ol' DOS editors, in VIM pressing PageDown followed by PageUp (or vice versa) would send cursor to the start of first visible line - not back to the position where it was before. Especially as I now work more on my notebook's cramped keyboard (which btw has full sized keyboard, yet no keypad and no dedicated PageUp/PageDown keys) hitting by accident any of the keys requires some seconds to recover cursor position.

It annoyed me to the point of trying to make a VIM script to PageUp/PageDown properly.

But thankfully I have sobered up and my always questioning mind aksed: "Do you idiot think that you are the first annoyed by that? Don't you think VIM folks already have a feature for that??"

So finally I read as resourceful as ever :help - and my Eureka! awaited me right there, few lines above ":help <PageUp>". Now my ~/.vimrc has this:

map <PageUp> <C-U>
map <PageDown> <C-D>
imap <PageUp> <C-O><C-U>
imap <PageDown> <C-O><C-D>
set nostartofline

Essentially, PageUp and PageDown are now mapped to ^U and ^D respectively. The difference is that ^U/^D do preserve cursor's relative line number (relative to first visible line). ^U/^D work in normal mode, thus the ^O trick is needed to access it from insert mode.

The final nail - ":set nostartofline" - tells VIM during motion commands to try to preserve column where cursor is positioned.

You cannot possibly imagine how happy I am ;)

Update1. I felt something was wrong - but couldn't tell it immediately. Apparently, unlike PageUp/PageDown, ^U/^D move cursor only by half of screen. In other words, to emulate PageUp/PageDown, they have to be triggered twice:

map <PageUp> <C-U><C-U>
map <PageDown> <C-D><C-D>
imap <PageUp> <C-O><C-U><C-O><C-U>
imap <PageDown> <C-O><C-D><C-O><C-D>

Now that's much better.

Update2. Here goes improved version:

map <silent> <PageUp> 1000<C-U>
map <silent> <PageDown> 1000<C-D>
imap <silent> <PageUp> <C-O>1000<C-U>
imap <silent> <PageDown> <C-O>1000<C-D>

It turned out, ^U and ^D look at the counter for how many lines to scroll. Yet, they would scroll up to screen size. Thus specifying large value would make the shortcuts to scroll full screen at once. And you have to use counter all the time. Read more in :help CTRL-U and :help scroll. I'm not sure what led to the messy design (try :set scroll=NN) yet the mappings as above work fine.

With version from "Update1" especially on large files when triggering e.g. ^U^U it would be still visible that the scrolling happens in half screen steps. With the version that doesn't happen anymore as VIM now is properly told how many lines to scroll. As there is now counter involved, adding silent option is required.

VIM's keywordprg for Perl and ... VIM itself

2009-02-11T14:20:00.000-08:00

This is logical follow-up to my previous post about K shortcut.

The two (actually three lines) added to ~/.vimrc allow when editing Perl and VIM scripts to transparently call with K proper help system.

au BufReadPost *.pl   set keywordprg=perldoc\ -f
au BufReadPost *.vim  map K :exe ":help ".expand("<cword>")<CR>
au BufReadPost .vimrc map K :exe ":help ".expand("<cword>")<CR>

Perl one is obvious. VIM one actually required some trickery: we do not call external program, but call VIM's internal command instead.

P.S. BTW, :help :help is pretty useful reading. Due to my error, 'K' in VIM mode used to constantly show it, instead of expected 'expand("<cword>")'.

how to not loose vim stdin buffer after opening a file

2008-11-20T04:53:00.000-08:00

I often use VIM instead of "less" as pager. Usually in a way like "diff -u ... | vim -R -c 'set syntax=diff' -" (for what I actually have a shell alias).

The one thing was annoying me for quite some time: when vim reads input from stdin, it does create unnamed buffer where to the content is loaded. Unnamed means that as soon as I open in the same vim another file, the stdin input is lost and I do not know of a way to recover it: it doesn't show up in ":ls" anymore.

I have tried to do ":w" yet that created a new file - but the buffer with stdin still remained unnamed and was still replaced by first open file.

After some search I have found a nice command - ":sav" (:help :saveas).

Unlike originally intended for ranges ":w" command, the ":sav" operates on files and thus has enough authority to change buffer name, making stdin buffer persistent.

P.S. "vim -" is described under ":help read-stdin" and ":help --" (two minuses). Though the description is quite shallow.

getting colder?

2008-11-10T02:59:00.000-08:00

Another gem (from pov of those of us who grep a lot) found in VIM documentation:

:help :colder

At first I thought that is another wit command but then realized that the name fits to :cnext and :cprev commands.

Snip from VIM documentation:

So far has been assumed that there is only one list of errors. Actually the
ten last used lists are remembered. When starting a new list, the previous
ones are automatically kept.

And the two commands are :colder (to go to previous results) and :cnewer (to go back to newer results).

P.S. "List of errors" is used in VIM originally for :make. Results of :grep are also interpreted as list of errors, what promotes grep into rank of compiler (:

VIM tips exchange on Slashdot

2008-11-06T16:14:00.000-08:00

Link.

Flamewars Alert. This is Slashdot after all.

[link] vim scripts

2008-10-03T06:23:00.001-07:00

From Sander Marechal: My list of must-have vim scripts.

Defining a user command: easy make invocation

2008-09-14T10:10:00.000-07:00

This little thing:

command MM :exec ":make ".substitute( substitute(expand('%:p'), '\.[^\.]*$', '', ''), '^'.getcwd().'/', '', '')

defines a new VIM command ":MM" which does invoke ":make" with name of current file without extension. E.g. if you edit file "helloworld.c" and then type command ":MM" that would expand to command ":make helloworld"

Just in case I have also added stripping of $PWD (getcwd() in VIM universe) so that if you edit file from another directory, make would be called with relative path and Makefile from current directory would be used. That will not improve much make behavior, but if by chance you are using "cons", then that would work very well.

Edit1. Forgot to mention. VIM mandates that all user commands start with capital letter (all standard commands start with lower case letters). That's why I named the custom command "MM"

[link] 21 of the Best Free Linux Text Editors

2008-08-26T05:32:00.000-07:00

21 of the Best Free Linux Text Editors

Unfortunately, VI and Emacs clones are not presented. Emacs itself is too bloated to be used by people who like to remain in control of their text editor - but there are number of decent Emacs clones.

From Wikipedia: Emacs clones and VI clones. VIM is listed in VI clones.

P.S. Most important Emacs shortcuts: Ctrl-g - end minibuffer editing, if any; Ctrl-x Ctrl-c - exit Emacs. Ctrl-g you need because often, after entering shortcut from another text editor, you might end-up in Emacs minibuffer (internal command line). Ctrl-x Ctrl-c will not work in minibuffer - so you need to press Ctrl-g. After exiting Emacs, type in shell "vim" and press Enter to start real text editor ^_^

[link] 100 Vim commands

2008-08-25T08:46:00.000-07:00

100 Vim commands every programmer should know

Nice summary of vim commands.

P.S. Though apparently the people are messing up "vim" and "vi". As things stand right now, "vim" has absolutely nothing to do with "vi". Hey I worked in "vi" (on both Solaris 10 and HP-UX 11.x) - that was most frustrating 5 minutes in my life. The *NIX vendors do not even bother adding keyboard support. Solaris' "vi" proudly says that it wasn't updated since 1996.

little useful bit of info showcmd

2008-07-09T07:02:00.000-07:00

How to see how long selection (visual) is?

How to see whether you have accidentally entered any numbers which would act as repeat counter for the command?

The little thing I always forget about:

:set showcmd

In right bottom corner (before ruler) little useful bits about actual state of keyboard input in normal are displayed.

Most useful is of course to now how long visual selection is, which I use often to e.g. count number of characters.

P.S. Documentation says the showcmd setting will be changed if you changed compatible mode. Shouldn't be a problem since no sane person uses compatible mode anyway.

[off topic] Darn good quote

2008-05-29T23:43:00.000-07:00

It's so much easier to suggest solutions when you don't know too much about the problem.
-- Malcolm Forbes

[link] Sweeten your Vim with Cream

2008-05-29T14:07:00.000-07:00

Simple Vim intro by Linux Magazine.

My personal minimal .vimrc

2008-05-26T12:56:00.000-07:00

Another upgrade, another OS, another update... Well, new home directory - consequently new .vimrc.

Here is N hours into coding minimalistic usable .vimrc:


filetype plugin off
syntax on
imap <Insert> <Nop>
set bs=2 ruler title comments= nowrap
set cindent cinkeys-=: cinkeys-=0#
colo torte
let loaded_matchparen = 1
au BufReadPost * if line("'\"") > 0 &&
   \  line("'\"") <= line("$") | exe "normal g'\"" | endif

I hope this time, Blogger/BlogSpot hadn't eaten any characters.
The set comment= creeped in before I have realized that filetype plugin is still on.

Normal command from Insert mode

2008-05-24T15:00:00.000-07:00

Always forget the very useful shortcut which is apparently intended for "Vim Easy":

^O

When in insert mode (and, by definition, in easy vim you are always in the mode) to insert command from Normal mode, you press first ^O and then start typing the command.

e.g. to delete to the end of line press ^O followed by Shift-d. Pressing : you can also access all the ex commands too - but that will leave insert mode.

Inserting command output from a function

2008-03-30T04:40:00.000-07:00

How would I use a vim function to insert the output of these commands at the current cursor position?

Well, that would look like a crude hack, yet here it goes:


:function InsertCmd( cmd )
:       exe ':silent !'.a:cmd.' > /tmp/vim.insert.xxx 2>/dev/null'
:       let l = readfile( '/tmp/vim.insert.xxx', '', 1 )
:       exe "normal a".l[0]
:       redraw!
:endfunction

:imap <silent> <F5> <Esc>:call InsertCmd( 'hostname' )<CR><Insert>
:map <silent> <F5> :call InsertCmd( 'hostname' )<CR>

The function InsertCmd(cmd) runs in shell given command and redirects its stdout to a file. Then using readfile() function, first line of file is read into list l. Finally using :normal command and a (:help a) command we put the first line of output into buffer.

The two mappings for F5 key - for insert and for command mode show how to invoke the function to insert output of "hostname" into current cursor position. ":imap" probably needs extra <Right> on the end since due to switch between insert/normal modes cursor goes one position back.

Edit1. Better way to do it, from SO.

[off topic] Another monospace font: Droid Sans Mono

2007-11-16T12:43:00.001-08:00

Accidentally came across new (at least to me) monospace font called "Droid Sans Mono."

Since I'm droid coder already, there is no real danger of using the font - with such terribly sounding name.

Link

[link] A more informative status line for Vim

2007-11-04T12:12:00.000-08:00

A more informative status line for Vim by Linux.com.

[off topic] MSWindows - Minimize Window shortcut

2007-10-30T10:29:00.000-07:00

Lack of shortcut to minimize current window had bothered me for very very long time.

But finally I found a solution. There is a wonderful program for M$Windows called AutoHotkey. Main purpose of program is to allow you to override particular shortcuts to perform custom action. Program is pretty cryptic, but allow for some automation of Windows what is definitely progress. (For example I have bunch of shortcuts to retrieve information from Firefox in half-automatic fashion.)

Now the magic to put into AutoHotkey.ahk (default) configuration file:

#x::
WinMinimize, A
return

"#x" is "Win-X" shortcut (hold the (otherwise worthless) key with Windows flag on it and press X). "WinMinimize, A" command tells to minimize active ("A") window. "return" tells to stop further script processing.

Edit1.
Bit of additional magic to disable the single-Alt menu silliness and to emulate Mac OS X input of German umlaut characters:

Alt::
return

>!u::Send {ASC 0252}
>!o::Send {ASC 0246}
>!a::Send {ASC 0228}
+>!u::Send {ASC 0220}
+>!o::Send {ASC 0214}
+>!a::Send {ASC 0196}

[off topic] VIM Plug-in for Eclipse

2007-10-29T14:36:00.000-07:00

While wonders of KDE's VIM components are not new, that stroke me as ... funny.

Vimplugin and viPlugin allow one to use VIM editor as replacement of standard text editor of Eclipse SDK.

Funny.

P.S. Thanks God I'm safe from Java programming. For now.

VIM vs. broken OSs/terminals :: colors are forever!

2007-08-13T07:36:00.000-07:00

The tip was found in VIM's help under :help color-xterm and works for HP-UX and Solaris. I conditionally exclude Linux to be unaffected by workaround, since F/LOSS folks - compared to the Unix old farts - have managed somehow to ship decent terminfo/termcap boasting color support out of box.


if &t_Co > 0
       " Linux/etc has proper terminfo
else
       if &term =~ "xterm"
               if has("terminfo")
                       set t_Co=8
                       set t_Sf=^[[3%p1%dm
                       set t_Sb=^[[4%p1%dm
               else
                       set t_Co=8
                       set t_Sf=^[[3%dm
                       set t_Sb=^[[4%dm
               endif
       endif
endif

The thing needs to be put into ~/.vimrc. The '^[' needs to be replaced by real escape character - ^V<Esc>.

[off-topic] Hardcore vs. Casual gaming

2007-08-12T02:01:00.000-07:00

In reply to one comment on Joystiq while discussing hardware sales.

> I'd really like for somebody to define "hardcore game" for me.

My definition of "hardcore game" is game which requires involved playing.

I would consider you to be hardcore gamer in "Madden and NCAA football games". Because you have extensive experience in football games, you would demand more of it from newer games. That's what makes gaming "hardcore": entry level is very high.

Casual gaming is all about "Pick and Play" e.g. WiiSports' Tennis or Baseball. One doesn't need to spend hours getting into game - s/he can pick WaggleMote and start playing right away.

Also, feat of many console games I consider "hardcore" is boss fights and poor/non-existent saving system. "Pick and Play" should really be "Pick, Play and Put it back". And that's where most console games fail miserably: you can't stop playing moment you want to stop playing - but the moment game allows you to stop playing. E.g. Metroid and it stupid save rooms: you came into room and door was locked behind you - now you are expected to spend time looking for way out or fight boss. But you can NOT save game and start doing something else. No. Game doesn't allow that.

Hardcore gaming: gaming demanding higher degree of involvement. Whether by mean of poor save system or by lots of tricks you need to keep in your head to be able to play game (and you easily start forgetting them if you do not play many hours daily; lengthy key combos are good example of that).

Casual gaming: gaming by formula "Pick, Play and Move on." You can start any moment you want to play. You can play and enjoy game as long you want and have time. And last (but not least) you can stop playing (preserving your progress) any moment you like or have to (the "have to"s are what adult life is all about).

P.S. Many PC games are much better suited for casual gaming, since most of them have good save system (or what console folks call "instant save/load"). And somehow PC games also manage to avoid the silliness of boss fights, which can bar you from making any progress in game for long time.

VIM :: man pages invokation shortcut

2007-06-25T00:41:00.000-07:00

I have finally found it. The very important shortcut I was missing long time. I knew it was there - but never actually managed to dig it up.

K

That's simple. It replaces my now archaic ":!man ".expand("<cword>") - use word under cursor and invoke 'K'eyword program on it. Keyword program is normally man. Can be configured with option 'keywordprg' (:help 'keywordprg' for more info).

If keywordprg is man, then VIM provides another cool feature: repeat count when used with K now tells to go to particular man section. e.g. 3K would invoke "man 3" on current word. What is very very cool.

[off topic] Tribute to Your-Mom

2007-06-06T14:46:00.000-07:00

Domou arigatou gozaimashita!

Moving around in VIM : buggy terminal edition

2007-05-29T07:25:00.001-07:00

Buggy terminals are one of the most frustrating things one can encounter when trying to edit a file on remote site.

Big boys like Emacs are out of question immediately, since they depend on <Esc> sequences too much. And the sequences are what is used to represent functional, arrow and motion keys in Unix world. Often even Backspace and Delete fall victims of buggy terminals.

Though unpractical, it is often required to edit at least single file on remote site - to tell it proper terminal configuration - before anything else might be done.

VIM is for rescue. VIM (ans as its ancestor VI) were designed in times when there were no such keys available at all. It might be painful to work that way, yet quick edit is quite OK.

All the command are to be used in normal (non-insert) mode. Some of them as noted change vim's mode. To go back to normal mode, press Ctrl-[ or Esc.

u	Most important command here: undo.
/	Search forward - the most effective way to move around in vim.
?	Search backward.
:NNN<Enter>	Go to line number NNN.
x	Pressing 'x' would delete character under cursor. With repetition counter, can delete more than single character in a go: e.g. '20x' would delete 20 characters starting with current one (and analogous to pressing 'x' twenty times). Backspace key (delete backward) is 'hx'. Delete key (delete forward) is 'x'.
r<character>	Pressing 'r' would replace character under cursor with character pressed after 'r'. e.g., 'ra' would replace character under cursor with character 'a'.
f<character>	'f' stands for Find and moves cursor forward to next occurrence of given character. e.g., 'fa' would move cursor to next character 'a' in current line. Variation: 'F' (capital f) searches backwards.
$	Move cursor to the end of current line.
^	Move cursor to the beginning of current line.
h, j, k, l	Move cursor to left, down, up and right correspondently. Very useful with repetition counter: e.g. '10h' (typed 10 followed by 'h') would move cursor ten characters left.
w, e	Move cursor over words forward. 'w' stops at word beginnings. 'e' stops at word ends. 'W' and 'E' are the same, but they move backwards.
d	Most dangerous command here. Or rather 'd' isn't command, but a modifier. Pressing 'd' before any motion command would delete characters/lines traveled. e.g. 'df<Space>' would delete all characters from one under cursor till next Space (Space itself included). e.g. 'dl' would delete current character and one next to it. Analogous to 'xx' or '2x'. e.g. 'dj' would delete current line and one after it. Analogous to 'dddd' or '2dd'. e.g. 'd$' would delete characters starting from current one to the end of line. Analogous to 'D'. e.g. 'd/xxx' would delete characters starting with current one up to next entry of 'xxx' string in text (not including - search stops before - string itself).
dd	Delete current line.
c	Change operator. Analogous to 'd', it deletes according to given motion, but after deletion switches to insert mode.
cc	Clears current line and switches to insert mode.
C	Clears line starting from character under cursor and switches to insert mode.
i	Pressing 'i' would put vim into edit (insert) mode.
R	Pressing 'R' (Shift-r) would put vim into replace mode (or in PC editors called "overwrite" mode). Unlike insert mode, where typing inserts characters, in replace mode any typed character would replace character under cursor.
A	Pressing 'A' (Shift-a) in command mode would make vi to go into insert mode and move cursor to end of line after last symbol.

That's about it. Move around with searches ('/' and 'f'), delete with 'x' or 'd'. Insert mode - 'i'. Replace mode - 'R'. Ctrl-[ - to go back to normal mode. Something went wrong - undo with 'u'. And of course ':w' to write changes and ':q' to exit.

Edit1. He-he. As soon as I have written that I ended up working under the ever-sucking Solaris with its original vi whos author needs to be shot dead 666 times to get him out of genetic pool - to make sure that no such thing would ever appear.

Another important point. Adding something at the end of something. This is next to impossible in original vi. With little bit of tinkering I came to conclusion that only way to do that is through substitution.

Add at the end of the line with :s/$/ missing word./<Enter> (See also 'A')

Add new line with :s/$/<^V><^M>/<Enter> (<^V><^M> == Ctrl-V Ctrl-M == ^V says to terminal to insert next typed symbol (^M) verbatim. And ^M is "new line" symbol, which understood by vi as your intention to add a new line. (Enter under Unices is "carriage return")). Doing that on last line in file would add a new line after last.

Adding new line before first apparently can be done with :s/^/<^V><^M>/<Enter> which is analoguos to previous trick - but instead of '$' (end of line) we substitute '^' (beginning of line).

Last words: Solaris muzz-die. It looks to me like my beloved Belarus which is often called a "reservation of communism." Same way, Solaris can be called a "reservation of Unix" - of all those mistakes made 30 years ago, fixed everywhere else, with only Sun keeping them in place. For backward compatibility I gather.

Edit2. Added '^' - moving to beginning of line.

Edit3. Added 'A' - inserting text at end of line.

VIM Crash Course. Study #2.

2007-05-29T06:35:00.000-07:00

OK. Recently, we have replaced a word in file. Now let's replace particular line in file.

Example presumes you have open file you need to replace a line in.

Line number is known and is 1234. (Or you can use '/' search operator from previous post to find the line.)

1. :1234<Return>
2. C
3. <new text for given line>
4. <Esc>
5. :wq

Explanation.

1. Colon ':' allows us not only to input commands, but also to jump to particular line given by its number. Press colon, type line number and hit Enter. Cursor will be put on the first character in line number 1234. (Or last line, if number is too big.)

2. 'C' would 'C'lear (delete all characters) starting from current one and put vim into insert mode. If cursor stands on first character in line - as it should after step 1 - it would clear whole line.

3. Now type whatever you need to type in the line. After step 2 we are in insert mode - to insert text. Any text you would type would appear verbatim.

4. <Esc> will put vim back into normal mode.

5. ':wq' will write file and end editing session.

Done!

VIM Crash Course. Study #1.

2007-05-29T05:30:00.000-07:00

VIM (or equally VI) crash course #1: Correcting misspelled word AAA to BBB in a file "file-name".

Most frustrating part in starting with vim (or vi) is that one often is forced to work with vim while there is no other editor on the system. That happens alot when working on some embedded system or antique unique boxes, which do have slimest and featureless editor installed. E.g. busybox or original vi from Bill Joy. To be frank, I'm also frustrated with the both things. But still they are cheap and thus are widespread. Making some use of them is only natural.

Here we go.

Launching: vi file-name

Commands needs to be typed as they a written here (without line numbers of course).

1. /AAA<Return>

2. n

3. :s/AAA/BBB/<Return>

4. :wq<Return>

Explanation.

1. '/' is search operator. Whatever you would type after it is search string. Search string is terminated (and search started) by pressing Enter. That will move cursor to place of first match. Or complain that string isn't found.

2. Optional step, if found match isn't what you want to replace. 'n' repeats last search and moves cursor to next match in file. Press 'n' repeatedly, until you have found what you want to replace. With 'n' you can go over all matches in file and after hitting end of file, vim would restart search from the beginning of file.

3. ':' colon is start of many commands in vim. 's' is short for "substitute" command. Its syntax is simple. 's' is followed by '/'. After first slash goes string you want to be replaced (or substituted). It is terminated by second '/'. After second slash goes replacement string. It is also optionally terminated by '/'. Pressing Enter would execute the substitution operation on current line, replacing first entry of AAA with BBB.

4. ':wq' is vim's command to "write and quit". That would write modified file and leave vim.

Notice, that the editing was done without switching into vi's infamous insert mode. The example doesn't use any kind of complex keys and guaranteed to work on all terminals.

[link] Making Vim easy

2007-05-25T08:54:00.000-07:00

Tips: Making Vim easy by Joe 'Zonker' Brockmeier published on Linux.com

Though I can not recommend using VIM in 'easy' mode (:help easy). You would not learn VIM, nor would make it VIM really easier to you - most commands still require some level of knowledge of real vim modes.

P.S. Somehow, most important shortcut Ctrl-L was left out of this introduction. Pressing Ctrl-L allows you to input a normal or ex command to vim. I guess that idea of easy vim is to not bother user with the modes and commands. Yet main power of vim - and the whole point of using it - is in the commands. Without Ctrl-L, vim in easy mode is pretty lame imitation of M$Windows infamous Notepad.

[off topic] Using GNU GDB for assembler

2007-05-23T09:08:00.000-07:00

GNU GDB refuses to be good debugger for assembler. But still with some pain it is possible to get out of it something.

But generally, I would advise learning to debug your programs right in your brains while you typing them. Think that's too complicated? Then read on. By end of the post you might be not that sure about that.

0. Starting program. 'break *&_start' to set breakpoint at program entry point. 'run' as usual to actually load program.

1. 'list' - forget about it. It will never ever show assembler. 'set language asm'? - HA-HA!! Naively thought you can outsmart GDB?? How naive of you. 'list' will not work. Period.

2. But how to see the code then?? Answer: 'disass $pc $pc+36'. $pc is content of register 'pc', what under PowerPC is 'program counter' - pointer to next instruction. (Probably pc is portable, have no clue.) Second parameter - $pc+36 - tells to disassembler to stop at address +36 (thus disassembling next 8 instructions, stopping at 9th).

3. 'step' and 'next' will not work. I would have paid a premium to disable them altogether when I do use gdb for assembler, because they are screwing execution context in most unexpected way. You fingers slipped and typed 'n<Return>'? Restart everything again - that way it's faster.

4. 'stepi' and 'nexti' are used to walk instruction-wise.

5. Breakpoints: 'break *0xdeadbeef', where 0xXXXXXXXX is address where you want to set a break point.

Overall, you would hit snag at every corner. Yet, if you are courageous enough, my experience laid out here might serve as starting point.

P.S. Interesting article aboug GDB from IBM's developerWorks.

Hello World in VIM

2007-05-23T07:00:00.000-07:00

OK, I feel myself empowered enough to actually write a "Hello World!" in VIM.

function Hello(wrld)
        let hw = "Hello ".a:wrld."!"
        echo hw
endfunction

call Hello("World")

Save that to hw.vim and run this:

$ vim -u hw.vim -c ":q"

It should print "Hello World!" and wait for you to press Enter before quiting. (-u hw.vim tells vim to load hw.vim as substitute of ~/.vimrc and -c ":q" tells vim after loading ~/.vimrc (which is substituted with hw.vim) to execute ":q" to terminate.)

Dissection. :function & :endfunction are start and end of function definition. :let creates new variable hw which contains string "Hello " concatenated with a:wrld (function argument) and "!". (:help :let describes operator '.' which is string concatenation operator.) :echo is used to print the value contained in variable hw to screen. If we pass as parameter "World" to the function, hw would contain "Hello World!" string.

N.B. Colon ':' before command names, when is inside of script file - e.g. ~/.vimrc - is optional and used by me here merely to highlight that commands are all from normal mode. Also when you say to VIM :help :let, colon before let would tell vim that you are interested precisely in let command of normal mode - not something else. (Just like in :help 'ts', where single quotes tells vim to look for ts only amongst settable options.)

P.S. Adding that function to you ~/.vimrc with call Hello($LOGNAME) would greet you with silly "Hello <Your-Login-Name-Here>!" message every time you would launch vim.

Simple string function in VIM

2007-05-23T04:37:00.000-07:00

Recently I have posted a script for automatically picking up a ctags' tags file, if one found in obvious locations.

New thing for me in the script is definition and calling of a user function. User functions in VIM are documented under :help user-functions topic. (Standard functions are documented under :help functions. Pressing ^] on function name would bring you to detailed description of corresponding function.)

So, from POV of vimrc, function definition is simply set of commands, open with 'function Name([params])' line and closed with 'endfunction' line. Name must start with capital letter. Parameters are given as comma separated list - types are automagically deduced by VIM itself. Normally, most parameters would be strings and numbers - and VIM apparently can convert them silently one into another w/o bothering user about that (a-la Perl or JavaScript).

Inside of function one puts normal VIM commands (:help :normal). To access parameters, their names must be prefixed with 'a:' (:help internal-variables has nice list of all prefixes.)

To generate a value, function must use inside a return command (:help :return). Function will stop and callee would receive value given to return.

Function found in .vimrc become global and available everywhere. Additionally one can put function definitions in external file and then call :source to make them available (:help :source).

To call a function, one can use

:call command:

:call FindCtagsHere('/home/ifilipau/trunk/src/','/')


or simple :echo (which also prints function return value):

:echo FindCtagsHere('/home/ifilipau/trunk/src/','/')


or to save the value in variable one can use :let:

:let x=FindCtagsHere('/home/ifilipau/trunk/src/','/')


because (compared to simpler :set used for options, :let (used for generic variable manipulation) evaluates right side of assignment operator).



making vim and ctags real friends, rev2
2007-05-22T05:43:00.000-07:00
Time have to review my little script from awhile ago to automatically update &tags option with tag file if one is found in directory under current one.

What bothered me that if I was opening file by full path, 'tags' option wasn't updated - since vim would be launched in $HOME, instead of directory were file itself resided. Thus script was failing to do anything.

But today, I decided to waste whooooping 15 minutes to actually read VIM documentation and update my script. Now I use user functions to do the dirty job.

Here we go.

" 1
function FindCtagsHere(dir, dir_sep)
      let tag_dir = a:dir
      let sep = a:dir_sep
      while !filereadable(tag_dir.sep."tags") && tag_dir!=$HOME && stridx(tag_dir, sep)>=0
              let tag_dir = substitute(tag_dir, sep.'[^'.sep.']\+$', "", "")
      endwhile
      if filereadable(tag_dir.sep."tags")
              return tag_dir.sep."tags"
      else
              return ''
      endif
endfunction

" 2
au BufReadPost *.cpp    let b:current_file_tags=FindCtagsHere(expand('%:p:h'),'/')
au BufReadPost *.h      let b:current_file_tags=FindCtagsHere(expand('%:p:h'),'/')

" 3
au BufReadPost *        if exists("b:current_file_tags") &&
\       filereadable(b:current_file_tags) &&
\       stridx(&tags, b:current_file_tags)<0 | let &tags.=','.b:current_file_tags | endif

" 4
let x = FindCtagsHere(getcwd(), '/')
if filereadable(x)
       let &tags .= ','.x
endif


That's it. (Blogger of course tries to eat '<' & '&' - so watch for syntax errors.)

First I declare function. The function takes two parameters - directory to start search from and directory separator ('\\' for Windows (not tested!) and '/' for sane rest of the world). It returns string containing name of found tag file. Content was more or less copy-pasted from previous post.

Second with 'au BufReadPost *.cpp/*.h' I add triggers to search for tags upon file loading. The tag file name is stored in buffer local variable 'b:current_file_tags'.

Third with 'au BufReadPost *' I check to see if there was tag file found by earlier auto commands and if so I add the tag file into global option 'tags' (which is comma separated list of all tag files for VIM to check.)

Fourth, lastly, I do restore original functionality of the script: if editor was launched even without files open, we search for tags starting from current directory. If tags were found we add them to 'tags' option. As before, launching VIM w/o files would allow to use ':tag' to browse code.

Now we search for tags every time relevant file is open. This is added overhead, but I haven't noticed any visible slowdown from VIM. And my tags file is 300k lines & ~30MB big.


[off topic] Driving Principles of Programming: Ignorance
2007-05-22T01:47:00.000-07:00
Well, I have already talked a bit about laziness and egoism, but now time have come to mention - after all - the last (as I count them) third principle: ignorance.

I was pitched to write this after whole week of meetings with two engineers, whose many questions may be rephrased as "what if sky falls down?" After several days I was ready to scream "As heck I care!!!" (and this is really polite form of what I actually wanted to say.)

I have a function to do task A. WTF shall I care here about B, C and D??? Some people just do not get it.

IGNORANCE. The ignorance which is bliss. As programming concerned, ignorance allows programmer to concentrate on particular task, ignoring ever-changing environment his program is ought to work in. Otherwise, if one would try to track all new requirements and developments, his/her attention would be diverted from original task. End result? Task would be always in half finished state.

Egoism and ignorance are very similar. Egoism tells us to ignore other's opinion (a.k.a. critics). Ignorance tells us to ignore other's problems (a.k.a. new requirements).

Like with other two principles, all is good in moderation. Pushing any of the principles to the limit of course goes against the laziness principle. And being too lazy would mean that you are not egoistic. And being too egoistic would mean that you can't ignore yourself. You see now? That's vicious circle of software development. ;)

P.S. How to use ignorance in practice. Ignorance normally results in task-oriented applications. You do not try to do everything - since you ignore everything - but concentrate on precisely the task/job you want to accomplish. Often such applications might look as hairy agglutinations of functions - and they are really functional and do what you want from them. Though lazy guys like I am would find them short on ergonomics ^_^


[off topic] Perl v. Python: Python Sucks!
2007-05-20T06:35:00.000-07:00
Results of my non-scientific research: "Python sucks". Or rather Python performance does suck big time. Or rather lack of performance.

Simple test.
$ cat a.py
print "Hello world!"
$ time python a.py
Hello world!

real    0m0.039s
user    0m0.032s
sys     0m0.008s
$

Compare to this:
$ cat a.pl
print "Hello World!\n";
$ time perl a.pl
Hello World!

real    0m0.008s
user    0m0.004s
sys     0m0.004s
$

or this:
$ cat a.c
#include <stdio.h>
int main()
{
    printf("Hello World!\n");
    return 0;
}
$ make a && time ./a
gcc   a.c   -o a
Hello World!

real    0m0.003s
user    0m0.000s
sys     0m0.000s
$


I mean, what Python does those 40ms? Compared to Perl's 4ms? Or C's ZILCHms?

Absolute values seem to be small enough to be disregarded. But the same cliche can be seen in bigger applications.

For example Gentoo's tool chain - emerge - many Gentoo users are familiar with. Its DARN slow. Even compared to Debian system - apt-get - which does so much more and often labeled by jealous RedHat folks "amateurish" - works magnitudes faster (and even on junk hardware).

Or SCons. SCons take 1.5 seconds to just start up and print help message. It's Perl's sibling cons/pcons in the time manages to compile several sources.


[link] Vi Lovers Home Page
2007-05-16T13:59:00.000-07:00
Vi Lovers Home Page - terrific resource for everybody. Piles of links - tutorials and FAQs.

Must read.


[link] Gentoo's VI guide
2007-05-16T10:59:00.000-07:00
Learning vi

Pretty good for beginners - just like about any other document I have seen from Gentoo.


[off topic] Divide and Conquer (DaC) vs. Model-View-Controller (MVC)
2007-05-04T08:09:00.000-07:00
Thinking about team work organization, I was constantly humming "Divide and Conquer" (DaC) principle. That's pretty obvious since it is guiding principle how big teams are taking on large problems - by splitting them into many smaller ones. (Small enough for single person to solve.)
  Turning back to work, my eyes have met again with several of my constructs loosely based on MVC model.
  Sudden enlightenment: MVC is another application of more general DaC.
  How DaC works. A (simple) problem is split into three (primitive) problems:
 2 smaller problems of original  bigger problem and (one more piece everybody forgets about)
  
problem of integration the two  smaller solutions into solution for bigger problem.
 
  The third part - often forgotten line connecting two blocks - is very important and often play crucial development organization role. Recurrently applying DaC we can slice problems until they reach manageable size.
 How MVC works. A problem is split into three problems:  
 stateful part containing all  data/state (model),
  
stateless part containing all  utilities needed to work with model (view) and
  
controller part which best  exemplified by UI to manage the data of model using the utility of  view.
 
  MVC generally drawn as three blocks, with model being independent, view depending solely on model and controller depending on both model and view.
Similarities are obvious.
  On high level, MVC's controller is the interface connecting the two pieces of problem - model (state) and view (functions). (Bigger problem split into two smaller problems - model and view - with controller playing role of integration problem.)
 On lower level, MVC looks like DaC splitting original problem into three smaller problems and plus three more integration problems (view to model, controller to view and to model).



Clever tricks from VIM's Bram Moolenaar
2007-05-01T05:23:00.000-07:00
The page where I found tip for the annoying PuTTY problem, also had great tip:
:help usr_12.txt
There you will find clever tricks you can do with VIM to accomplish simple yet sometimes needed tasks. And overall page has lots of simple hints. Very good reading.


VIM vs. PuTTY keypad
2007-05-01T05:11:00.000-07:00
The problem was annoying me for very long time: under PuTTY, applications (e.g. less, vim) using tek window (alternative terminal screen) had totally screwed keypad. Solution was found here.
Apparently, PuTTY tries to do something smart. And fails.
Workaround:
Change function key/keypad mapping from standard "ESC[n~" to "Linux".
Disable application keypad mode
Apparently only second is required, but first is also recommended.
The options, as usual to all options of Windows applications, change their location in settings dialog periodically so I cannot give their precise locations. Go through PuTTY setting and you will find them.


[off topic] Driving Principles of Programming
2007-04-30T02:23:00.000-07:00
I often asked on how software development works. To most people unfamiliar with all stinky innards of development process, figuring out how to get anything out of developers is very very tricky. Sometimes people see logic behind what I do - but often they are lost when trying to deal with me.

So as an insight into developer's head I would explain shortly here two of my software development principles. "Shortly" and "two" - because I have managed to date to formulate only one (second) of them and first was well know before I was even born.

1. This is grand principle which regulates lion share of decisions made by software developer. LAZINESS. Some think of it as of bad habit, but in as old programmers' proverb goes to find simplest solution to a problem, assign the problem to laziest programmer you have. In development and programming, laziness is source of all simple decisions which are often by outsiders are seen as "original" or even "genius". To programmers - it's just N days of work saved.

1a. Corollary. In development team with no lazy people, one would hardly see any innovation - or properly working program. After all, non-lazy people can make even pigs flying.

2. It just dawned on me recently and I have managed to formulate my second most used programming principle. EGOISM. (I would claim nothing and rather expect that somebody already did research that before me.) The principle is very simple: make something what would be useful to you and most likely others would find it also useful. Check the Unix made of thousands of small and big utilities - most of the utilities were initially developed for particular purpose of its author himself. But later were also found by others to be useful. Well, Unix itself was made for very particular purpose - and none of its developers even thought that Unix would catch up. Yet it did. Why? Because first and foremost it was useful to its creators. They didn't cared much what others did with it - how egoistic of them!? ;)

2a. Corollary. Excessive non-egoistic programming results in piles of abstract interfaces made to abstract other interfaces which abstract other interfaces. They do not do anything in particular - they are written often because people are told to write something. It is hard to make something useful - if you are just a little gear which needs only to mesh with other such gears. And to mesh better  - we need more interfaces, abstraction layers and level of indirection. It also happens to be a generic sickness of many successful projects which in beginning "just work", but authors along the way get bored and start adding needless minor features (by request of vocal user minority) which in the end obstruct core functionality. Program was started as something working - thus became popular. Later on to satisfy needs of few others (here ended the egoism!) features added were not needed by authors themselves (nor (as usually!) were properly communicated by end users to developers) thus ended up being implemented poorly.

That's it for today.


[off topic] [rants] GNU Make - missing features
2007-04-09T04:48:00.000-07:00
For all "declaration" nature of make, it is still very very hard to build your own rule out of predefined ones found in make database. e.g. making a rule for new file extension to call existing rule for older file extension is only possible with dumb copy-and-pasting. Now imaging project with hundreds makefiles - all at different times doing such copy-and-pasting: one hell to do maintenance.
Arithmetics. I was really surprised to find that make doesn't have any internal facility for arithmetic expression calculation. Even more so I was surprised when I learned that GNU project doesn't even have such library. Best call - is to call external optional program 'dc' or hope that bash is installed and do arithmetics through it. That bars many accessibility features like progress counter for long build processes. Also obviously renders makefiles unportable.
Clean mechanism to overwrite rules. That's actually what makes proper dependency check implementation impossible. E.g. if you have dependency "a: b" and "a: c" that would really mean "a: b c" - and there is no way to cancel the "a: b" dependency.
List and string routines. Again, mere convenience, yet has performance impact. To put it simply: it is very stupid when to transform file name I have to call several external programs. String manipulation is needed for file name transformations. List routines are needed for proper management of list of targets scheduled to build.
Recursiveness. The dead horse was beaten many times before. Lack of proper recursiveness support bars use of make on very large projects. Or leads to arcane make files understood by few thus having very very low accessibility. One can't require everybody on project to be a make specialist.

Looking at all the rants, my mind instantly points out that the list is precisely difference between make and cons. Last update to cons - pcons - was in 2001 and (thanks to that fact that it was written in Perl) it still works perfectly in all situations I have been to.

I had very ridiculous accident: people using pcons were told to switch to make ("Of course there is no reasons to it - it is just our corporate policy"). Case looked bleak: dumbing down build system back to stone age of make wasn't problem - problem was the lost functionality (the list above). I have advised (and it actually worked) simple solution: put pcons right along with sources and create makefiles with all targets calling cons instead. Worked beautifully - thanks to slim nature of cons/pcons which is written in Perl and has little/no external dependencies.


[off topic] One-liner to make GNU Info usable
2007-04-09T04:10:00.000-07:00
Something like this should be shipped along with GNU Info documentation system - to make it any useful:

$ cat ~/usr/bin/iinfo
#!/bin/bash
info --subnodes --output=- "$@" 2>/dev/null | less
$
 


Option "--subnodes" tells info to dump everything it has - w/o frigging inhuman document structure. Option "--output=-" tells to dump that all on stdout. The bit "2>/dev/null" is to shut up the stupid useless stuff info spits on stderr. And '| less' bit tells it to behave like proper "man".

Rants. Ironically, even the one-liner cannot make GNU tools any better: they show their age, were not updates in years and do not support most modern things one expects. Searching internet generally brings more and better results than digging outdated GNU documentation. (N.B. GCC of all GNU tools is kind of exception.)



[off topic] message logging severities
2007-02-27T01:32:00.000-08:00
I can recall only five levels of severities:

MAJOR: Alarm. Critical unrecoverable error. Results in certain termination of application.
MINOR: Recoverable error. Application can go on, but something is fishy.
NOTICE: Not an error, but shouldn't have happened.
INFO: Run-time information statistics, "anomalies" a.k.a. unsolicited messages. Must produce passable amount of information since might be used for monitoring of real system.
TRACE: Used to trace what's happening in the system: functions called and their arguments. Produces insane amount of output.
DEBUG: Debugging info. Developer's corner.

Production systems run on MINOR level, so that all errors are displayed. MAJOR level normally has abort() built in so that OS would dump core of application for further investigations.

Systems in testing run with INFO level. Often the output is saved and required to match in repeated tests. E.g. if we have fed application with 1000 bytes of info, we would expect INFO message to reflect that 1000 bytes where handled. Not 999, not 1001, not 500 + 500.

Edit1: Added "TRACE" level.


Off-Topic :: Wait-Free/Lock-less synchronization crash course
2007-02-01T10:23:00.000-08:00
Well, results are not that good as I have hoped. (In depth info at Wikipedia. Read the first reference on the page written by Maurice Herlihy in 1993.)

Rule of thumb: lock-less can only be data structures which synchronize using single datum.
Compare-And-Swap( ptr, old, new ) can be used for implementation of atomic counters. The operation is supported by all high performance platforms (e.g. PowerPC & IA-32).
One cannot make lock-less FIFO for N:M (N readers/M writers) nor for 1:M (1 reader/M writers) configurations. Seems that 1:1 (1 read and 1 writer) only possible configuration and in fact it doesn't require any special support at CPU level. (Reference to rule of thumb: FIFO requires two data items for implementation - head/tail (or next/prev).)
Stack (LIFO) can be implemented wait-free/lock-less using Compare-And-Swap() op, since it needs only single pointer for implementation - head - pointing to first element to remove/last element inserted.
Conclusion:
Unixes were 100% right putting pipes at foundation of I/O: pipe can be implemented as couple of FIFOs and as long as pipe isn't shared between more than 2 applications, it can be completely lock free.
Stack (along with Compare-And-Swap op) allows to implement memory management (for static block size) very efficiently. (Edit1. In preemptive SMP OS, that might lead to situation when Compare-And-Swap would succeed despite fact that state of queue already changed. Proper implementation for multiple CPUs would use several (at minimum 2) stacks. Allocations are made from one stack, freeing is done on next stack. Allocation function rotates stacks when detects that current stack is empty. Allocation is failed when all stacks were queried at least once and all are empty. Alternatively, one can introduce additional counter: generation counter. That way Compare-And-Swap needs to be able to write double word. When element is allocated, generation counter is incremented. When element is freed, we put on stack pair - pointer and generation counter - which would be with high probability unique.)
Message passing systems suck big time because (i) 1:1 FIFOs are inapplicable and (ii) it is impossible to optimize memory allocation with lock-less stack since it is impossible to tell where the message would end up. (The later can only be implemented in worst case scenario of shared memory.)



vim 7.0 :: tabs / tabbed editing
2007-01-29T01:35:00.000-08:00
Not that I fun of all the GUI niceties, but some people cannot live without mouse and think :b#/:bn/:bp are bore. So vim7 has added a way for mouse fans (*) to work with multiple files.

For tab fans, Linux.com published intro into vim7' tabs: Vim tips: Using tabs.

(*) How people edit text files with mouse is beyond me. Do they use charmap or what? [/sarcasm]


Sample Ex/Vim Ranges
2006-11-20T09:10:00.000-08:00
Here we go.

:%s/[a-z]/\u&/g

Substitute in all lines (the range defined by '%') all lower case latin letters ('[a-z]') with upper case letters ('[A-Z]'). Substitute in all lines (the range defined by '%') every lower case latin letter ('[a-z]') with upper-case letter ('\u&', see for more info :h s/\u).

:<'>' w new_file_from_selection.txt

Write ('w') all selected lines ("<'>'") into new_file_from_selection.txt. (You do not need to type that "<'>'" thing. Select lines in visual mode (entered by Shift-V) and then press ':' - vim will put the <'>' in prompt line for you)

:5,+99 w new_file.txt

Write ('w') to the file "new_file.txt" lines: 5th and next 99 ones included, total of 100 lines. (Provided that the actual file has minimum 1054 lines).

:0,$ ! tac

Filter ('!') all lines ('%' is simple shortcut for '0,$') through the external application 'tac'. The filter command would then replace all affected lines with the output of the application - in that case the lines would reappear in inverse order, thanks to the 'tac' command. ('tac' is of course opposite of 'cat'. man tac.).

:<'>' ! wc -l

That would replace all selected (in visual mode) lines with the count of selected lines, as counted by 'wc -l'.

And to conclude, the most useless (unless you're vim scripting addict) range example:

:.=

Print current line (range '.') number (command '=').

Edit1 Fix the uppercase command, as per anon comment. It should have been some real weird booze I had that day. N.B. more optimal is of course this: :%s/.\+/\U&/.

ZQ



[Linux.com] Vim tips: Working with external commands
2006-10-25T13:31:00.000-07:00
Vim tips: Working with external commands


Off Topic :: GNU Arch (TLA) Commands Quick Reference
2006-10-20T06:37:00.000-07:00
User identification
$ tla my-id  "John Doe <user@aol.com>"
$ tla my-id                       # to print currently set id
Create Archive
$ mkdir  ~/{archives}
$ tla make-archive  user@aol.com--2006-quickref ~/{archives}/2006-quickref
Find Archives
$ tla archives                    # to print all available archives
$ tla whereis-archive user@aol.com--2006-quickref
Default Archive
$ tla  my-default-archive  user@aol.com--2006-quickref
$ tla  my-default-archive         # to print it
$ tla  my-default-archive -d      # to delete the preference
Provisioning Archive Space
$ tla archive-setup hello-world--mainline--1.0
$ tla categories                  # prints hello-world
$ tla branches hello-world        # prints hello-world--mainline
$ tla versions hello-world--mainline        # prints hello-world--mainline--1.0
Initializing before Import
$ cd ~/wd/hello-world
$ tla init-tree hello-world--mainline--1.0
$ tla tree-root                   # prints /home/jdoe/wd/hello-world
$ tla tree-version                # prints user@aol.com--2006-quickref/hello-world--mainline--1.0
$ tla log-versions                # prints user@aol.com--2006-quickref/hello-world--mainline--1.0
$ tla set-tree-version [new-version-name]
$ tla add-log-version [new-log-name]
$ tla remove-log-version [existing-log-name]
Checking Inventory
$ tla inventory --names --source  # to see what arch classifies as sources
$ tla inventory --source --ids    # to see ids given by arch to sources
$ tla inventory --names --backups # to see what arch classifies as backups
$ tla inventory --junk | xargs rm # remove all what arch think is junk
Adding/Removing Files
$ tla add hw.c main.c
$ tla delete hw.c
$ mv hw.c hello.c
$ tla move hw.c hello.c
$ tla tree-lint   # to see if all clean, tla won't import/ci from unclean directory
Import (Initial check in)
$ tla make-log                    # create log file and print its name
$ vim `tla make-log`              # edit log in vim
$ tla import                      # copy working copy into archive
$ tla revisions hello-world--mainline--1.0  # prints base-0
$ tla revisions --summary --creator --date hello-world--mainline--1.0
$ tla log-revisions
$ tla logs hello-world--mainline--0.1       # prints base-0
$ tla logs --summary --creator --date hello-world--mainline--1.0
$ tla cat-log hello-world--mainline--1.0--base-0
Committing Changes
$ tla changes --diffs             # or (in tla 1.3) just "tla diff"
$ tla make-log                    # create log, required
$ tla commit                      # do it, creates patch-1
$ tla commit -s "Summary" -L "Log Message"            # commit with log auto generated
$ tla revisions --summary hello-world--mainline--1.0  # last revision info
$ tla logs --summary hello-world--mainline--1.0       # last log entry info
Checking Out
$ tla my-default-archive          # check where is default archive is
$ tla whereis-archive user@aol.com--2006-example      # display local/net path
$ tla categories        # lists available project in default archive "hello-world"
$ tla branches hello-world        # lists available branches of the project "*--mainline"
$ tla versions hello-world--mainline        # lists available version of the branch "*--0.1"
$ tla revisions hello-world--mainline--0.1  # lists available revisions base-0 & patch-1
$ tla get hello-world--mainline--0.1 hello-world                # check out most recent revision of into "hello-world" directory, or
$ tla get hello-world--mainline--0.1--base-0 hello-world        # check out specific revision
$ ls                    # should list "hello-world"
Update (Replay)
$ tla undo              # back off local changes
$ tla replay            # get latest patches from repository
$ tla redo              # reapply local changes
$ tla update            # all of three steps above with one command.
Networked Archives
$ tla register-archive lord@emf.net--2003b          
   http://regexps.srparish.net/{archives}/lord@emf.net--2003b    # HTTP, R/O
$ tla register-archive lord@regexps.com--2002
   ftp://ftp.regexps.com/{archives}/lord@regexps.com--2002       # FTP, R/W
$ tla register-archive user@aol.com--2006
   sftp://random.homeunix.org/home/jdoe/{archives}/2006-quickref # SFTP, R/W
$ tla my-default-archive [archive-name]      # and the rest is just like described above
Mirroring (Locally) Network Archives
$ tla register-archive lord@emf.net--2003b-SOURCE $remote_location   # once
$ tla make-archive --mirror-from lord@emf.net--2003b-SOURCE $local_location # once
$ tla archive-mirror lord@emf.net--2003b    # repeat to pull latest changes
Mirroring (Remotely) Local Archives
$ tla make-archive --mirror mine@somewhere.com $remote_location      # once
$ tla archive-mirror mine@somewhere.com     # repeat to push latest changes

P.S. Made after this tutorial.


More from that Oualline person
2006-10-18T09:43:00.000-07:00
Top 10 things Vi user need to know about Vim.

Very short and clear.


Vim Cookbook by Steve Oualline
2006-10-12T11:57:00.000-07:00
Vim Cookbook by Steve Oualline. Interesting reading. Lots of little tips.

P.S. Delves a bit into ranges supported in ex commands. I still cannot get myself to write entry on vim ranges.


All about Linux: A visual walk through of a couple of the new features in Vim 7.0
2006-09-19T03:10:00.000-07:00
All about Linux: A visual walk through of a couple of the new features in Vim 7.0


VIM 7 :: RE: turn off paren/parenthesis/whatever highlighting
2006-09-15T08:21:00.000-07:00
 The fix submitted before isn't reliable. That piece of magic in .vimrc does the job:
 let loaded_matchparen = 1
 It tells some plug-in/script/whatever that it has already did the job. If you put that in .vimrc - it would think that way always and would not load anymore. Nice.
 P.S. The Tip was found here :help pi_paren.txt. It would be all really nice if computers had a special interface to read my mind - and tell me how the devels named particular feature. That way I will not need to waste weeks to find the corresponding help entry.



VIM7 :: file type detection
2006-09-13T02:59:00.000-07:00
 New in VIM7 is file type detection. To get info whether it is present/activated try that:
:filetype
and that to turn it off:
:filetype off
File types are made to allow bulk customization for particular file type. At moment it doesn't provide any advantages over plain :au - but probably more to come in future.
 P.S. :filetype off must be at top of .vimrc - it tries to manage everything so many options changed before would be reset.
 P.P.S. Relevant help pages/see also: :help filetype, :help 'filetype' and :help ftplugin.



VIM 7 :: turn off paren/parenthesis/whatever highlighting
2006-09-11T05:02:00.000-07:00
 Put that line into .gvimrc:
 NoMatchParen
 Seems like due to serious Q&A problem that shit creeped into release of VIM7.
 :help hl-MatchParen for more info on how to wear down your eye in under 5 minutes with minimum of options set. [sarcasm off]
 Edit1: seems like that feature is automatically enabled only for GUI vim, in other words NoMatchParen is accepted only in .gvimrc.
 Edit2: The solution is not reliable. Proper fix!



Dangers of Wikipedia
2006-08-31T06:15:00.000-07:00
That damm Wikipedia thing is addictive. It must be outlawed. Once you start reading it - page after page, link after link - you cannot stop.

Anyway. Pretty nice opinion from Tim O'Reilly about why he is vi guy.

Replace "emacs" with "random Wind0ze GUI IDE" - and what he said would be true to me too.

P.S. As for me, "Emacs vs. VI " holy war really comes down to "all-in-one v. modularized" debate. Or from another POV it can be seen as "shell vs. emacs lisp": to Emacs lisp is what shell to Unix. I like VIM since it works with shell directly - it does not have any layers distancing user from OS. I guess if one doesn't like shell but likes elisp instead - then Emacs may be the way to go.


Cult of vi
2006-08-31T06:08:00.000-07:00
Cult of vi has among other interesting references the chart of vi commands.

P.S. :g/^/m0/ and ZZ look like fun!


VIM @ Wikipedia
2006-08-31T05:56:00.000-07:00
VIM's Wikipedia Page


Off-Topic: dumping gcc/cpp predefined macros
2006-08-31T02:53:00.000-07:00
echo | gcc -dM -E -

-dM tells cpp to out #define for every variable it has.

-E tells gcc to run cpp only

P.S. I dead tired to dig documentation every time I need to find how platform is identified by GCC. So putting that stuff here in hope that it would be easier locatable.


vim :: repetition counter (and period command)
2006-08-14T04:42:00.000-07:00
One of the funniest (and obscure) VIM features is repetition counter. Most of the commands allow the counter. Consider example (that needs to be typed in in normal mode):
20l

The VIM's command 'l' is the command to move left (VIM supports motion keys as in old time games - 'h', 'j', 'k' and 'l' are correspondently left, down, up and right.) Prepended to it '20' is the repetition counter. If cursor was in position 1, after the command it would be in position 21 (or on end of line if it is shorter).

1000dd

Would delete 1000 lines starting from current.

3f<Space>

Would move cursor to third space in line, counting from current cursor position. (:help f for find motion command.)

It is very useful at times for example combined with command '.' which is used to repeat last command(s). Example how to make a nice C comment with 50 dashes.
<Insert>/*<Space><Space>*/
<Esc>lll
<Insert>-
<Esc>49.

I intentionally made typing of dash separate, thus it can be later repeated with '.' command. I yet to gain complete understanding on how '.' works precisely, but in most obvious cases it works as expected. :help . for more info. Experimentation plus 'u' undo command could help to get it right.

More info can be found in VIM under :help count & :help repeat.txt.


vertical selection from Nth to Mth character
2006-08-11T14:54:00.000-07:00
ZOMG! I got e-mail. That stuff apparently got indexed by Google. So. Here we go.

I do have a question for you, however.  When performing a vertical selection, is there any way to advance the screen other than the arrow keys? For instance, if a file were thousands of lines long, is there a way to quickly select characters 10 through 20 for the entire length?


All motion shortcuts must work as usual. (:help motion.txt) In other words. To select vertically across all lines in the file chars 10 to 20 you need something like that (those " are comments):


gg      " move to beginning of file, beginning of line
9l      " move to 10th symbol in line (l == move 1 char left, 
        "   9l == move 9 times chars left)
^V      " start vertical selection
G       " move to last line of file, beginning of line
19l     " move to 20th symbol in line.


now y/d/whatever to yank/delete/etc. IOW, no magic - standard shortcuts. I hope that answers your question.

Though there might be problem: if last line of file shorter than 20 characters, or if first line shorter than 10 characters, or tab character is sitting somewhere there - VIM wouldn't be able to do precisely what you want it to do. 

P.S. For later case shell comes in handy: man cut for -b & -c options. Using redirection and intermediate file you can get you part into separate file and then open it (along with original) in VIM - and use normal line blocks. With combination of head and tail (man head & man tail) you can get from file lines you need.


vim :: turn that 'showmatch' crap off
2006-08-10T06:17:00.000-07:00
I have just waisted hour to find that sucker:

set noshowmatch

SUSE (as well RedHat) have long tradition of shipping f*cked up configs for all major editors and terminal emulators. SUSE 10 (in addition to unusable xterm config and vim's "set backspace=0" (which renders backspace key in vim totally borken)) now started adding "set showmatch" to default exrc. As if anybody over there at SUSE/Novell actually used once xterm or vim. Why they keep crapping in the configs?? Are GNOME/KDE configs not enough for distros to shit into???

set showmatch, if you have just typed parens/bracket/comment opening/etc, makes cursor to jump shortly to its counterpart. That shit is creping off Wind0ze over-bloated unusable IDEs. It distracts your attention of what you were doing. It forces you to move your eye - as if you do not know your own source code - needlessly, wearing and tiring them down. Might it be OS vendors have a secret contract with ophthalmologists??? I have no other guess.

P.S. Linux Productivity Magazine, Volume 1 Issue 5, December 2002 "VI and Vim" - http://www.troubleshooters.com/lpm/200212/200212.htm - lots of vi/vim basics.

Edit1 Related: matching parens highlighting. Mistakenly attributed to VIM7, but also present in VIM6.

Edit2 Proper fix


vim :: tags keyboard shortcuts
2006-07-18T05:42:00.000-07:00
Keyboard shortcuts used to work with tags. There are really few of them. All of them work in control/normal mode.
:set tags? needless to remind that VIM must be told which tag files to use. It can be done automatically as for example shown here.
:tag word is main one. Opens file and goes to line with first tag entry matching word.
^] same as above, but uses word under cursor.
:tag /word is similar to :tag word. Opens file and goes to line with first tag entry matching regular expression in word.
:tselect word is what I use most often. The function - tag select - displays list of matching tags allowing you to select one to go to. Without word, it will display list of matching tags for word used last time.
g^] same as above, but uses word under cursor. Also, omits displaying list if only single match is found.
:tnext goes to next matching tag entry.
:tprev goes to previous matching tag entry.
:tlast goes to last matching tag entry.
:tfirst goes to first matching tag entry.
^T Every time you do :tag word, the word with current file position is put on stack and vim goes to new file/position as it is told by tag file. To restore the previous file position you use ^T. The shortcut removes tag stack top element and moves to the file position saved there. So if you wandered off far away with ^] - to return back where you started you need to press ^T until vim would complain that it is at bottom of tag stack.
That's about it. Both :tag word and :tselect word support wildcard key (Tab/^D) to show list of tags matching partially the word. That will work with regilar expressions too. But be warned that often tag files can host millions of entries: displaying list of thousands items can take some time. Use wildcard key carefully.


syntax highlight for non-standard file types
2006-07-14T23:40:00.000-07:00
Following line once put into vimrc will tell vim which syntax highlighting to use:

au BufReadPost SCons* set syntax=python
au BufReadPost Cons* set syntax=perl
au BufReadPost *.mke set syntax=make
au BufReadPost make*.inc set syntax=make
au BufReadPost *.fcc set syntax=cpp
au BufReadPost *.fhh set syntax=cpp

This is selfexplanatory. e.g. SCons files are in fact python scripts - so tell vim to use python syntax highlighting on everything what matches 'SCons*'. Same goes for Construct - but done in perl.

:au BufReadPost <mask> tells vim to execute something right after file read into buffer. In that particular case we use that to set buffer local variable 'syntax' to name of one of standard syntax highlightings (perl, make, cpp, etc). :help :au for more info.

P.S. One can check what syntax module vim has loaded by looking at 'syntax' variable value: do :set syntax? after opening file recognized by vim.

P.P.S. Of course, :syntax on has to be put somewhere in the vimrc for syntax highlighting to work automatically. VIM 6.x doesn't have problem of previous versions (I experienced that in VIM 5.x), where loading of syntax from vimrc was slowing launch time, even if file had no syntax highlighting assigned. Hm.. or probably my PC now fast enough for me not to notice that launch time. Who cares. It works.


highligting tabs and trailing spaces
2006-06-30T07:11:00.000-07:00
Add the following to .vimrc:

highlight SpecialKey ctermfg=DarkGray
set listchars=tab:»-,trail:~
set list

That makes something like that:
map <silent> <F7> :exec ":e ".(expand("%") =~ ".h$"
       \       ? glob(substitute(expand("%"), ".h$", ".cpp", ""))
       \       : substitute(expand("%"), "\\.cpp$", ".h", ""));<CR>

to be displayed that way:
map <silent> <F7> :exec ":e ".(expand("%") =~ ".h$"~
»-------\»------? glob(substitute(expand("%"), ".h$", ".cpp", ""))
»-------\»------: substitute(expand("%"), "\\.cpp$", ".h", ""))<CR>


Tabs are now plainly visible and also public enemy trailing space on first line became apparent.

P.S. Nice character '»' requires set encoding=utf-8. That looks great with "Andale Mono" and "Black Bold" color set in PuTTY to (39,39,39).

Edit1:

to



tabs!!!
2006-06-30T06:38:00.000-07:00
It's nice to know that there are reasonable people left. Read on.

http://derkarl.org/why_to_tabs.html 

Attack of clowns^Wclones^Wamateurs of WYSIWYG/WYSIAYG at times is plain depressing.


vim :: windows and buffers
2006-06-28T08:44:00.000-07:00
VIM can  open and edit simultaneously many files. For that VIM uses two elements:
Window - part of VIM's screen space. Screen of every VIM instance can be divided into several windows. When GUI available, one can of course launch several instances of VIM. But in terminal in common case user is limited to single 80x25. When you need to edit two files side by side - VIM windows come to help.
Buffer - place in VIM's memory. That's where file content resides while you are editing it. Buffers is what you see in output of ":ls" command. Every file you open automatically put into new buffer. Buffers are numbered starting from 1. Single buffer can be displayed in more than one window at the same time.
Consult ":help windows" (":help buffers") for indepth info on buffers and windows.