The Command Line interface

ROOT commands are executable C++ statements with a few extensions.

Note that:

• Commands are case sensitive.
• The semi colon at the end of a command may be omitted. However, note that the semi colon is mandatory at the end of a statement in a macro.
• ROOT does not make any difference between an object and a pointer to an object. Object.Function and Object->Function are equivalent.

To execute a macro, use the .x command. For example:

Root >  .x  macro.C;

a ROOT macro is a real and valid C++ file enclosed in curly brackets {}. ROOT accepts the following extensions:

• A statement like TCanvas *c1 = new TCanvas(..) can be abbreviated to: c1 = new TCanvas(...).
• A function prototype is not required at the beginning of the macro.
• ROOT can automatically get in memory persistent objects from a file. For example, if we have an object called hpx in the current directory, one can type:

  Root >  hpx.Draw();
  

All commands must be preceded by a . (dot), except for the evaluation statement { } and the ?.

===========================================================================
Dump:        n [file]  : create new readline dumpfile and start dump
             y [file]  : append readline dump to [file]
             z         : stop readline dump
             < [file]  : execute readline dumpfile
             > [file]  : output redirect to [file]
             2> [file] : error redirect to [file]
Help:        ?         : help
             help      : help
             /[keyword]: help information for keyword
Completion:  [nam][Tab]: complete symbol name start with [nam]
             [nam][Tab][Tab]: list up all symbol name start with [nam]]
Shell:       ![shell]  : execute shell command
Source:      v <[line]>: view source code around line
             V [stack] : view source code in function call stack
             t         : show function call stack
             f [file]  : view source file [file]
             trace <classname> : turn on trace mode for class
             deltrace <classname> : turn off trace mode for class
             break [classname] : break at the memberfunc
             delbreak [classname] : turn off memberfunc break
Evaluation:  p [expr]  : evaluate expression (no declaration/loop/condition)
             {[statements]}: evaluate statement (any kind)
             x [file]  : load [file] and evaluate {statements} in the file
             X [file]  : load [file] and execute function [file](minus extension)
             E <[file]>: open editor and evaluate {statements} in the file
Load/Unload: L [file]  : load [file]
             U [file]  : unload [file]
             reset     : reset interpreter environment
Monitor:     g <[var]> : list global variable
             l <[var]> : list local variable
             class <[name]>: show class definition (one level)
             Class <[name]>: show class definition (all level)
             typedef <name>  : show typedefs
             function  : show interpreted functions
             macro     : show macro functions
             template  : show templates
             include   : show include paths
             file      : show loaded files
             garbage   : show garbage collection buffer
             Garbage   : Do garbage collection
             cover [file]: save trace coverage
             return [val]: return undefined symbol value
Run:         S         : step over function/loop
             s         : step into function/loop
             i         : ignore and step over
             c <[line]>: continue <to [line]>
             e         : step out from function
             b [line]  : set break point
             db [line] : delete break point
             a [assert]: break only if assertion is true
Quit:        q         : quit cint execution
             qqq       : quit anyway

If an object resides in the current directory, a reference to this object puts the object in memory.

Objects in the list of files, geometries, canvases may be accessed directly by name.