How to run ROOT Macros in VS Code(31 March 2021)
Visual Studio Code offers some great functionalities when it comes to coding, such as IntelliSense, debugging, built-in Git, and many more through extensions. In this blog post I’m going to show how to configure VS Code in order to use all of these awesome features when creating and editing ROOT Macros!
A few weeks ago, I published a blog post about ROOT File Viewer, an extension to view ROOT Files directly in VS Code. On the discussion of said post the question of how to run ROOT Macros in VS Code arose, and I came up with an example repository to show how that can be accomplished. Let us now walk through this example repository and see how everything works.
Get it running
To get started, we will start cloning and opening the repository. This can be done from the command line with:
git clone https://github.com/AlbertoPdRF/root-on-vscode.git cd root-on-vscode code .
After this is done, we need to manually set the path to our local ROOT installation in two files. We can do that quickly with the editor’s convenient global search and replace functionality:
- Toggle the global
Ctrl + Shift + For clicking on the
Searchicon in the
- Search for
/home/apdrf/programs/root-6.22/install, two occurrences should show up
Toggle Replaceby clicking on the caret on the left of the
- Write the path to your local ROOT installation directory on the
- Replace the two occurrences with
Ctrl + Alt + Enteror clicking on
Replace Allon the right of the input box
We are almost ready to see everything in action, so let us open the workspace and get to it! There’s a few ways to do that, but probably the simplest one to do it is to:
- Open the file
root-on-vscode.code-workspace, which is located inside the
- Click on the blue button at the bottom right of the editor that reads
After we have opened the workspace, a toast notification will appear at the bottom right of the editor asking us if we want to install the recommended extensions for the repository. Clicking on the
Install button will install both the C/C++ and ROOT File Viewer extensions. Please note that the second one is not strictly required for everything to work, it is just listed as a recommendation for convenience.
And that is everything that is needed! Just press
F5 and see it for yourself: the example
hsimple.C ROOT Macro will run and the
hsimple.root file will be recreated.
With everything running, we can now take advantage of some of the awesome functionalities that we mentioned before to develop our ROOT Macros, for instance:
- Use IntelliSense’s smart completions to easily create and edit macros without fear of getting the syntax wrong
- Debug the macros right from the editor setting break points, seeing call stacks, and with an interactive console available
- Use the integrated
clang-formatto always get our code styled as we want it
- And there’s much more!
But I know this all feels like magic, so if you want to know how everything works, keep reading!
How it works
What we do in this example is to define a VS Code Workspace with the necessary configuration for everything to work, so let us first see what a workspace is and how it is configured.
A VS Code Workspace is simply a collection of (one or more) folders that are opened in a VS Code instance (a window). For this example, we have defined a
root-on-vscode workspace through the
root-on-vscode.code-workspace JSON file located on the
.vscode folder. Said file contains the following configuration:
folders: here we define the path to our workspace folder(s), relative to the location of this same file
settings: through this object we tell VS Code to treat files with the
.Cextension as C++ files and the path where it has to search for our header files, which in this case is ROOT’s
extensions: here is were we recommend for the
ROOT File Viewerextensions to be installed for this workspace
Apart from configuring the settings of the workspace, we have also defined a launch configuration, which is how we are going to be able to run ROOT Macros directly within VS Code. This is done in the
launch.json file, also located on the
.vscode folder. From this file I will just mention a few of its key points:
- We will use the
gdbdebugger under the hood
- The program that we will launch is the
- We will pass everything necessary to ROOT’s executable as arguments (which of course can be tweaked at will), as we would do on the command line:
-lto avoid showing ROOT’s banner
-qso the program quits after it finishes processing the macro
hsimple.C+gto tell the program which macro to run and to compile it with debugging symbols – this is what allows us to set break points through the macro
And this is basically it, the rest of the things that the repository includes are:
- A very basic
.gitignorefile to not commit compilation artifacts to the repository
hsimple.Cmacro from ROOT Tutorials
- The resulting
- And a
README.mdfile with some basic information
With this blog post I just wanted to quickly illustrate how we can configure VS Code to run ROOT Macros directly in it. Doing so allows us to take advantage of some great functionalities of the editor that will make our lives way easier, and this way we can focus on what truly matters!