Firebolt 3.0 is available. Firebolt is a free, open source,
development environment for Vi/Vim users and an emacs aware GUI debugger
for emacs users (fdb).

        Sirius 1.0 is available. Sirius is a free, open source, C++ Class
Browser/Code Navigator that acts as a sidekick for Vi,Vim, Emacs and Xemacs.

Screenshots : 
http://atwnt961.external.hp.com/dspp/tech/tech_TechDocumentDetailPage_IDX/1,1701,3352,00.html

Download page : 
http://atwnt961.external.hp.com/dspp/tech/tech_TechSoftwareDetailPage_IDX/1,1703,3325,00.html

        Please send questions, comments and defect reports to
firebolt@cup.hp.com

Thanks!
Srikanth.

Release Notes for Firebolt 3.0 and Sirius 1.0
---------------------------------------------

Apart from defect fixes and improvements, Firebolt 3.0 includes a new
tool called Sirius that could be used as a C++ class browser/code
navigator.

    o Sirius analyzes C++ programs and weaves a Code Wide Web that is navigable
      by clicking on hyperlinks.

    o Designed to look and feel like a world wide web browser to eliminate
      learning curve.

    o Excellent integration with Vi, Vim, Emacs, Xemacs. Sirius can "talk"
      to an existing session of [x]emacs or Vim to help you visit source
      code.

    o Internal source code browser is also available.

    o Fast source code analysis. (Sirius analyzes 500KLOC in less than 30
      seconds on an N class machine.)

    o Ability to browse source code that does not yet compile or link.

    o Automatic, incremental analysis and update of databases as the source
      files change.

    o Ability to generate the database against one view (or source tree) and
      use it to browse against another view (or source tree)

    o Multiuser support : Ability to share the database with other users.

    o Fast search engine to instantly lookup and visit definitions and 
      declarations of classes, members, methods, global variables, functions,
      typedefs, macros etc.

    o Browse classes and visits methods in Firebolt as you debug with
      Firebolt.

---------------------------------------------------------------------

Getting started with Firebolt:
-----------------------------

    (a) Download the binary distribution, gunzip, untar.
    (b) Invoke firebolt as 

        (i)  fb [a.c]  ==> start firebolt in editor mode [on a.c]
        (ii) fb a.out  ==> start firebolt in debug mode on a.out.

    (c) See Help menu + FAQ for help.
    
Getting started with fdb (Firebolt debugger for emacs users)
------------------------

    (a) Download the binary distribution, gunzip, untar.
    (b) Invoke firebolt as 

        (i) fdb  ==> start firebolt in debugger mode with emacs command
             line editing mode.
        (ii) fdb a.out ==> Do the same on a.out.

Getting started with Sirius
---------------------------

    (a) Download the binary distribution, gunzip, untar.
    (b) Create an empty directory and cd into it.
    (c) Run <FIREBOLT_LOCATION>/analyze <SOURCE-TREE-ROOT>

    (d) Run <FIREBOLT_LOCATION>/sirius
    (e) See Help menu + FAQ for help.

Known problems with Sirius
--------------------------
 There are several known limitations :

    o Sirius analyzes unpreprocessed C++ code. Such code should "look" like
      C++ code. We decide what looks like C++ code :-) More seriously, it is
      possible to concoct strange looking constructs using the preprocessor
      facility that look like perfect C++ once the file is preprocessed, but
      would otherwise stump even a champ.

    o Classes nested within another class are viewable only in the context
      of the enclosing class. 

    o Sirius is only partially namespace aware : It will digest all the 
      namespace constructs correctly, but will silently promote any classes
      encountered within namespaces to global namespace. If you have two 
      classes by the same name in different namespaces, we pick what you
      get to browse :-), well, it is actually worse,  the binary search
      algorithm decides what you get to browse. 

    o Prototypes and definitions must match in their use or nonuse of macros
      and typedefs for parameter types. 

    o Classes local to a function are not browsable. 

    o Sirius digests template specialization constructs correctly, but may
      not process them correctly.

    o Using directives are digested, but not processed.