SILENT BOB

Main ideas of SilentBob

Preprocessor, which is described above, is called "THE_TT" and placed in
appropriate file...
Actually it's quite simple: it removes all "extras" from C/C++ source. It
removes/minimizes all variants of C code notations, removes all extra space
symbols and comments, adds additional spaces where it's necessary (for
example, before brackets). THE_TT allows to take some part of code and
exactly (about 99%) tell you what is it, using minimum of checks.
All it works quite fast (for example, 1.6 GHz processor, 256 Mb of RAM - works
excellent), which allows to do some interesting things. As far as I know,
such kind of code usually is written only to compilers and isn't used for
other things, what, as for my view, isn't good enough.

Next SilentBob's level - "t_op", "what_is_this" and alike functions. First of
them simply allows to enumerate all "operators" of source code, second -
checks, what kind of operator do we met. Actually, "what_is_this" isn't
quite enough for all, so some additional functions exists... Now, THE_TT and
t_op are two separate parts of program. In future I plan to unite them...

It took from me for about one month to develop current version (1.0-rc1) and
two months for testing, finding out bugs, etc.

LYRICS
("life story", "blog" )

SilentBob was written one dark night, when one Siberian fellow tried to
understand how sys_poll system call works. After some time of digging the
sources and several tanks of drinked beer, this fellow understood, that
abilities of Gvim only isn't quite enough. Some tricks was made - they helped
a little, but this wasn't the solution.
Then, some other popular programs was used. After several tries fellow
understood, that he received the access to function he needs. But only one
function. If you take into account, that such calls, let's say, not only one
in program - you can imaging fellows indignation.


    Version 1.5
 - added -j N for --cgrep --grep --make-ctags --call-tags. Tags creation code (--make-ctags) is rewritten for new
engine (sblib/TT.cxx). gclib library was minimized to size needed only for SilentBob. Of course, you are able to 
download gclib2 separately.

    Version 1.4
 - Bug fixes. Bugs are caught, fryed and worn out
 - Removed support for ./tags file from exuberant-ctags. Now the project is autonomous and doesn't need it.
 - Added heapsort and [working] variant with paralleling.
 - All libs are in the one heap now



    HOW to USE:
Files for SilentBob are given as parameters or as file with filelist (every file is in the new line)
and option -L, i.e. -L <file with filelist>.

 -- Creating filelist:
$ bob --cfiles
or
$ bob -f

 -- Creating file ./tags
$ bob --make-ctags
or
$ bob -c
You may specify -j N --make-ctags, where N is the num of CPUs
*  templates are not indexed
** There is test option "--lang cpp" for C++. This option make Bob to use "C++" mode.
   In this mode global variables are not indexed. To search global vars in C++ code it's recommended
   to use --cgrep option.

If you have plugins installed (not from deb package), you may add for these options (--cfiles и --make-ctags) --perl or --python accordingly for Perl and Python, but this fitch is testing...
$ bob [--perl | --python] --files
$ bob [--perl | --python] --make-ctags
Created tag file is supported only by Vim, but you may use directly SilentBob to work with it.

 -- Creating ./call_tags file
$ bob <filelist> --call-tags
It creates tags file. But instead of start points of function it will be written where they are called.
You may rename it to ./tags, run Vi and go throw _functions_call_points with a plain usual command
	:tag

 -- Call-trees
./call_tags needed.

  -- Simple
$ bob <the name of function> [--depth N]
Where N is the maximum level (for huge projects).

  -- The reverse
$ bob -u <the name of function> [--depth N]
Сorrectness for C++ code functions is not guaranteed.
 
  -- Search in operators :
$ bob <filelist> --cgrep op1,op2...
Where op1 and op2 are required parts of _one operator_. I.e. to search the place of checking T variable
you may use, for example:
$ bob -L ./cfiles --cgrep if,T
Using -ts option (it may be used at once c>./tags) you may get tags-formatted output.

 -- Access to tags
$ bob --tags <function1> <function2> ... <functionN>
Where function1..functionN are needed symbol from ./tags file
The code if all listed functions will be reflected after this call

 -- Plugins
$ bob --plugins-info
(list of plugins with id)
$ bob --plugin <id>

And also there are many another tasty things, not listed here.

                Other information
We need responses about working with Bob on another platforms.
Any thoughts on:
    Oleg Puchinin <graycardinalster@gmail.com>

Thanks for your attention.
Oleg.

Translation to English: Evgeniy Ivanov <lolkaantimat Angry_DOG gmail BIGdot com>