ToDo Cached Add-on for Visual C++

CodeGuru content and product recommendations are editorially independent. We may make money when you click on links to our partners. Learn More.

Add-on Screen shots:

Click here for larger image

Add-on find dialog:

Environment: Microsoft Visual C++ version 6.0

To-do cached add-on was designed to simplify developer’s tasks,
like debugging and code management. As a result of my work a Visual Studio
Add-on component was created. It makes some things easier.

Debugging Features

Main feature of Debugging is STL containers
expanding. This add-on supports debugging of such STL containers:

•      std::vector
•      std::list
•      std::map
•      std::multimap
•      std::set
•      std::multiset

Also special debugging
features were added they add support of very long strings to Visual C++
debugger. Add-on fixes Visual C++ Debugger limitation to string output.
(Visual C++ debugger can show only 242 symbols of the string). This Add-on
can expand very long strings (more than 65536 symbols):

•     
  CString (MFC Class)
•     
  std::string
•     
  BSTR and WCHAR*
•     
  bstr_t (COM support class)
•     
  char *
•     
  CComBSTR (ATL Class)

Add-on is also capable
of showing XML long strings with user friendly formatting/indenting. It
also supports quick find by simple string or RegExp (Regular Expressions).
In Find Dialog any part of the string can be copied to the system clipboard
for the future use of developer.

Code Management Features

Add-on
has special features which can be used to manage Visual C++ project source
code. In simple words it looks like:

Developer
adds a comment with special signature, like: //
TODO: after such keyword the task description could be written.
Add-on can support as many keywords as developer wants. The main advantage
of this Visual C++ add-on is that it parses comments. Add-on parses all
comments in source code, checks commented strings for needed keywords
and displays results. Add-on is capable of distinguishing comments of
two types // – single line and /*
– multi line comments. Each keyword used in Add-on must start from ‘//‘
or ‘/*‘ symbols – if you want to parse comments
only, and from any other symbol if you want to parse full source code.

All
Results of parsing are cached and updated when developer save changes
to file. That is why add-on have name To-Do Cached. Results of
its work are printed into Macro tab of output window. Find
needed string in output window and make a double click on it to proceed
to that string in your source code. Add-on also understands multi line
comments written as a list of single line comments, example:

// TODO: — start — write code which do something
special and with context and
// and continue work — end —

Add-on will interpret such comment as a long
one comment and will display it by one line. Results of work can be sorted
and filtered.

Toolbar look’s like:

 Show
Results
This is a first button in toolbar (direction from left to right). Press
this button to display results of keywords search in Macro tab
of output window. It’s a pity but I still don’t know how to
set active Macro tab on button press. That is why after press you
must change tab to Macro manually.

 Reparse
Workspace
 Press this button to free the cache of add-on. Needed only when
there are too much files in workspace. Don’t open Option dialog
after that– according to add-on logic, it will have to parse the
workspace again to display statistics.

 Options
Dialog

Some of the add-on’s features can be configured using Option Dialog.

 Tabify
all files

On press add-on will automatically open all files in active project and
change all spaces in files to tabs.

 Untabify
all files

Reverse process of Tabify action. Add-on will open all files of active
project and change all tabs to spaces.

 STL
Debug Dialog
Open STL Debug Dialog of add-on. On
button press add-on will try to locate variable in currently opened source
file by selection or by cursor position.

Example of application with all tested STL and C++ classes datatypes.

#pragma warning( disable : 4786 )

#include <string>

#include <vector>

#include <map>

#include <list>

#include <set>

#include <queue>

#include <deque>

#include <stack>
#include <comutil.h>

#include <atlbase.h>
typedef std::string string;
// map types

typedef std::map<long, string>    TLongStr;

typedef std::map<string, string > TStrStr;

typedef std::map<long, long>      TLongLong;
// multimap types

typedef std::multimap<long, string>   TMLongStr;

typedef std::multimap<long, long>     TMLongLong;

typedef std::multimap<string, string> TMStrStr;
// vector types

typedef std::vector<string> TVStr;

typedef std::vector<long>   TVLong;
// list types

typedef std::list<string> TLStr;

typedef std::list<long>   TLLong;
// set

typedef std::set<long>        TSLong;

typedef std::set<string>      TSStr;

typedef std::multiset<long>   TMsLong;

typedef std::multiset<string> TMsStr;
#define DEF_TEST_STRING “ABCDEFGHIJKLMNOPQRSTUVWXYZ\r\n\t\v\b”

#define STR_DEF_TEST  string( DEF_TEST_STRING )
int main( int argc, char* argv[] )

{

  char buffer[ 8192 ];
  // maps

  TLongLong   mapLL;  TLongStr    mapLS;  TStrStr     mapSS;

  TMLongLong  mmapLL; TMLongStr   mmapLS; TMStrStr    mmapSS;
  // list, vector

  TLLong      listL;  TLStr       listS;

  TVStr       vecS;   TVLong      vecL;
  // set, multiset

  TSLong      setL;   TSStr      setS;

  TMsLong     msetL;  TMsStr      msetS;
  string    strValue = DEF_TEST_STRING;
  for( int j=0; j<10; j++ )

    strValue += strValue;
  const char * czBuffTestLongVariableNamesWithSomething =

                             strValue.c_str( );

  CString   cstrClass = czBuffTestLongVariableNamesWithSomething;

  CComBSTR  combstr = cstrClass;

  BSTR      bstr = combstr;

  bstr_t    TBstr = bstr;
  for( long i = 0; i<4000; i++ )

  {

    sprintf( buffer, “%04d – ABCDEFGHIJKLMNOPQRSTUVWXYZ” , i );

    string temp = buffer;
    mapLL.insert( TLongLong::value_type( i, i+1 ) );

    mapLS.insert( TLongStr::value_type( i, temp ) );

    mapSS.insert( TStrStr::value_type( temp, temp ) );
    mmapLL.insert( TMLongLong::value_type( i, i+1 ) );

    mmapLL.insert( TMLongLong::value_type( i, i ) );

    mmapLS.insert( TMLongStr::value_type( i, temp ) );

    mmapLS.insert( TMLongStr::value_type( i, temp ) );

    mmapSS.insert( TMStrStr::value_type( temp, temp ) );

    mmapSS.insert( TMStrStr::value_type( temp, temp ) );
    listL.push_back( i );

    listS.push_back( temp );

    vecL.push_back( i );

    vecS.push_back( temp );
    setL.insert( i );

    setS.insert( temp );
    msetL.insert( i );

    msetL.insert( i );
    msetS.insert( temp );

    msetS.insert( temp );

  }
  return 0;

}

Downloads

Download demo project – 4 Kb

Add-on binary files – 514 Kb

Project is a comercial product that is why no source available.
Now add-on is in beta testing phase, but if you take action into bug
tracking process then you will be added to users database and have
add-on without any payment. Help author to make product more stable
and author will help you in your developers work by it’s add-on…

Release Candidate: download file – 565 Kb