# 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.