Add code block languages readme.md

Author: mcbarton

README.md

@@ -75,34 +75,34 @@ Build instructions for CppInterOp and its dependencies are as follows. CppInterO
 
 First clone the CppInterOp repository, as this contains patches that need to be applied to the subsequently cloned llvm-project repo (these patches are only applied if building CppInterOp with Clang-REPL)
 
-```
+```bash
 git clone --depth=1 https://github.com/compiler-research/CppInterOp.git
 ```
 
 and clone cppyy-backend repository where we will be installing the CppInterOp library
 
-```
+```bash
 git clone --depth=1 https://github.com/compiler-research/cppyy-backend.git
 ```
 
 #### Setup Clang-REPL
 
 Clone the 19.x release of the LLVM project repository.
 
-```
+```bash
 git clone --depth=1 --branch release/19.x https://github.com/llvm/llvm-project.git
 cd llvm-project
 ```
 
 For Clang 16 & 17, the following patches required for development work. To apply these patches on Linux and MacOS execute the following command(substitute `{version}` with your clang version):
 
-```
+```bash
 git apply -v ../CppInterOp/patches/llvm/clang{version}-*.patch
 ```
 
 and
 
-```
+```powershell
 cp -r ..\CppInterOp\patches\llvm\clang17* .
 git apply -v clang{version}-*.patch
 ```
@@ -115,7 +115,7 @@ Clang-REPL is an interpreter that CppInterOp works alongside. Build Clang (and
 Clang-REPL along with it). On Linux and MacOS you do this by executing the following
 command
 
-```
+```bash
 mkdir build 
 cd build 
 cmake -DLLVM_ENABLE_PROJECTS="clang;lld"                  \
@@ -135,7 +135,7 @@ cmake --build . --target clang clang-repl lld --parallel $(nproc --all)
 
 On Windows you would do this by executing the following
 
-```
+```powershell
 $env:ncpus = $([Environment]::ProcessorCount)
 mkdir build 
 cd build 
@@ -153,15 +153,15 @@ cmake   -DLLVM_ENABLE_PROJECTS=clang                  `
 
 Note the 'llvm-project' directory location. On linux and MacOS you execute the following
 
-```
+```bash
 cd ../
 export LLVM_DIR=$PWD
 cd ../
 ```
 
 On Windows you execute the following
 
-```
+```powershell
 cd ..\
 $env:LLVM_DIR= $PWD.Path
 cd ..\
@@ -174,7 +174,7 @@ interpreter. Cling depends on its own customised version of `llvm-project`,
 hosted under the `root-project` (see the git path below).
 Use the following build instructions to build on Linux and MacOS
 
-```
+```bash
 git clone https://github.com/root-project/cling.git
 cd ./cling/
 git checkout tags/v1.0
@@ -204,7 +204,7 @@ cmake --build . --target gtest_main --parallel $(nproc --all)
 
 Use the following build instructions to build on Windows
 
-```
+```powershell
 git clone https://github.com/root-project/cling.git
 cd .\cling\
 git checkout tags/v1.0
@@ -233,15 +233,15 @@ cmake --build . --target gtest_main --parallel $env:ncpus
 
 Note the 'llvm-project' directory location. On linux and MacOS you execute the following
 
-```
+```bash
 cd ../
 export LLVM_DIR=$PWD
 cd ../
 ```
 
 On Windows you execute the following
 
-```
+```powershell
 cd ..\
 $env:LLVM_DIR= $PWD.Path
 cd ..\
@@ -251,21 +251,21 @@ cd ..\
 
 Regardless of whether you are building CppInterOP with Cling or Clang-REPL you will need to define the following environment variables (as they clear for a new session, it is recommended that you also add these to your .bashrc in linux, .bash_profile if on MacOS, or profile.ps1 on Windows). On Linux and MacOS you define as follows
 
-```
+```bash
 export CB_PYTHON_DIR="$PWD/cppyy-backend/python"
 export CPPINTEROP_DIR="$CB_PYTHON_DIR/cppyy_backend"
 export CPLUS_INCLUDE_PATH="${CPLUS_INCLUDE_PATH}:${LLVM_DIR}/llvm/include:${LLVM_DIR}/clang/include:${LLVM_DIR}/build/include:${LLVM_DIR}/build/tools/clang/include"
 ```
 
 If on MacOS you will also need the following environment variable defined
 
-```
+```bash
 export SDKROOT=`xcrun --show-sdk-path`
 ```
 
 On Windows you define as follows (assumes you have defined $env:PWD_DIR= $PWD.Path )
 
-```
+```powershell
 $env:CB_PYTHON_DIR="$env:PWD_DIR\cppyy-backend\python"
 $env:CPPINTEROP_DIR="$env:CB_PYTHON_DIR\cppyy_backend"
 $env:CPLUS_INCLUDE_PATH="$env:CPLUS_INCLUDE_PATH;$env:LLVM_DIR\llvm\include;$env:LLVM_DIR\clang\include;$env:LLVM_DIR\build\include;$env:LLVM_DIR\build\tools\clang\include"
@@ -275,69 +275,71 @@ $env:CPLUS_INCLUDE_PATH="$env:CPLUS_INCLUDE_PATH;$env:LLVM_DIR\llvm\include;$env
 
 Now CppInterOp can be installed. On Linux and MacOS execute
 
-```
+```bash
 mkdir CppInterOp/build/
 cd CppInterOp/build/
 ```
 
 On Windows execute
 
-```
+```powershell
 mkdir CppInterOp\build\
 cd CppInterOp\build\
 ```
 
 Now if you want to build CppInterOp with Clang-REPL then execute the following commands on Linux and MacOS
 
-```
+```bash
 cmake -DBUILD_SHARED_LIBS=ON -DUSE_CLING=Off -DUSE_REPL=ON -DLLVM_DIR=$LLVM_DIR/build/lib/cmake/llvm -DClang_DIR=$LLVM_DIR/build/lib/cmake/clang -DCMAKE_INSTALL_PREFIX=$CPPINTEROP_DIR ..
 cmake --build . --target install --parallel $(nproc --all)
 ```
 
 and
 
-```
+```powershell
 cmake -DUSE_CLING=Off -DUSE_REPL=ON -DLLVM_DIR=$env:LLVM_DIR\build\lib\cmake\llvm -DClang_DIR=$env:LLVM_DIR\build\lib\cmake\clang -DCMAKE_INSTALL_PREFIX=$env:CPPINTEROP_DIR ..
 cmake --build . --target install --parallel $env:ncpus
 ```
 
 on Windows. If alternatively you would like to install CppInterOp with Cling then execute the following commands on Linux and MacOS
 
-```
+```bash
 cmake -DBUILD_SHARED_LIBS=ON -DUSE_CLING=ON -DUSE_REPL=Off -DCling_DIR=$LLVM_DIR/build/tools/cling -DLLVM_DIR=$LLVM_DIR/build/lib/cmake/llvm -DClang_DIR=$LLVM_DIR/build/lib/cmake/clang -DCMAKE_INSTALL_PREFIX=$CPPINTEROP_DIR ..
 cmake --build . --target install --parallel $(nproc --all)
 ```
 
 and
 
-```
+```powershell
 cmake -DUSE_CLING=ON -DUSE_REPL=Off -DCling_DIR=$env:LLVM_DIR\build\tools\cling -DLLVM_DIR=$env:LLVM_DIR\build\lib\cmake\llvm -DClang_DIR=$env:LLVM_DIR\build\lib\cmake\clang -DCMAKE_INSTALL_PREFIX=$env:CPPINTEROP_DIR ..
 cmake --build . --target install --parallel $env:ncpus
 ```
 
+on Windows.
+
 #### Testing CppInterOp
 
 To test the built CppInterOp execute the following command in the CppInterOP build folder on Linux and MacOS
 
-```
+```bash
 cmake --build . --target check-cppinterop --parallel $(nproc --all)
 ```
 
 and
 
-```
+```powershell
 cmake --build . --target check-cppinterop --parallel $env:ncpus
 ```
 
 on Windows. Now go back to the top level directory in which your building CppInterOP. On Linux and MacOS you do this by executing
 
-```
+```bash
 cd ../..
 ```
 
 and
 
-```
+```powershell
 cd ..\..
 ```
 
@@ -347,7 +349,7 @@ on Windows. Now you are in a position to install cppyy following the instruction
 
 Cd into the cppyy-backend directory, build it and copy library files into `python/cppyy-backend` directory:
 
-```
+```bash
 cd cppyy-backend
 mkdir -p python/cppyy_backend/lib build 
 cd build
@@ -357,32 +359,32 @@ cmake --build .
 
 If on a linux system now execute the following command
 
-```
+```bash
 cp libcppyy-backend.so ../python/cppyy_backend/lib/
 ```
 
 and if on MacOS execute the following command
 
-```
+```bash
 cp libcppyy-backend.dylib ../python/cppyy_backend/lib/
 ```
 
 Note go back to the top level build directory
 
-```
+```bash
 cd ../..
 ```
 
 #### Install CPyCppyy
 
 Create virtual environment and activate it:
 
-```
+```bash
 python3 -m venv .venv
 source .venv/bin/activate
 ```
 
-```
+```bash
 git clone --depth=1 https://github.com/compiler-research/CPyCppyy.git
 mkdir CPyCppyy/build
 cd CPyCppyy/build
@@ -392,26 +394,26 @@ cmake --build .
 
 Note down the path to the `build` directory as `CPYCPPYY_DIR`:
 
-```
+```bash
 export CPYCPPYY_DIR=$PWD
 cd ../..
 ```
 
 Export the `libcppyy` path to python:
 
-```
+```bash
 export PYTHONPATH=$PYTHONPATH:$CPYCPPYY_DIR:$CB_PYTHON_DIR
 ```
 
 and on Windows:
 
-```
+```powershell
 $env:PYTHONPATH="$env:PYTHONPATH;$env:CPYCPPYY_DIR;$env:CB_PYTHON_DIR"
 ```
 
 #### Install cppyy
 
-```
+```bash
 git clone --depth=1 https://github.com/compiler-research/cppyy.git
 cd cppyy
 python -m pip install --upgrade . --no-deps --no-build-isolation
@@ -423,21 +425,21 @@ cd ..
 Each time you want to run cppyy you need to:
 Activate the virtual environment
 
-```
+```bash
 source .venv/bin/activate
 ```
 
 Now you can `import cppyy` in `python`
 
-```
+```bash
 python -c "import cppyy"
 ```
 
 #### Run cppyy tests
 
 **Follow the steps in Run cppyy.** Change to the test directory, make the library files and run pytest:
 
-```
+```bash
 cd cppyy/test
 make all
 python -m pip install pytest